Hadoop学习之路（十三）MapReduce的初识

 1 /**
 2  * Licensed to the Apache Software Foundation (ASF) under one
 3  * or more contributor license agreements.  See the NOTICE file
 4  * distributed with this work for additional information
 5  * regarding copyright ownership.  The ASF licenses this file
 6  * to you under the Apache License, Version 2.0 (the
 7  * "License"); you may not use this file except in compliance
 8  * with the License.  You may obtain a copy of the License at
 9  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 package org.apache.hadoop.examples;
19 
20 import java.io.IOException;
21 import java.util.StringTokenizer;
22 
23 import org.apache.hadoop.conf.Configuration;
24 import org.apache.hadoop.fs.Path;
25 import org.apache.hadoop.io.IntWritable;
26 import org.apache.hadoop.io.Text;
27 import org.apache.hadoop.mapreduce.Job;
28 import org.apache.hadoop.mapreduce.Mapper;
29 import org.apache.hadoop.mapreduce.Reducer;
30 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
31 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
32 import org.apache.hadoop.util.GenericOptionsParser;
33 
34 public class WordCount {
35 
36   public static class TokenizerMapper 
37        extends Mapper<Object, Text, Text, IntWritable>{
38     
39     private final static IntWritable one = new IntWritable(1);
40     private Text word = new Text();
41       
42     public void map(Object key, Text value, Context context
43                     ) throws IOException, InterruptedException {
44       StringTokenizer itr = new StringTokenizer(value.toString());
45       while (itr.hasMoreTokens()) {
46         word.set(itr.nextToken());
47         context.write(word, one);
48       }
49     }
50   }
51   
52   public static class IntSumReducer 
53        extends Reducer<Text,IntWritable,Text,IntWritable> {
54     private IntWritable result = new IntWritable();
55 
56     public void reduce(Text key, Iterable<IntWritable> values, 
57                        Context context
58                        ) throws IOException, InterruptedException {
59       int sum = 0;
60       for (IntWritable val : values) {
61         sum += val.get();
62       }
63       result.set(sum);
64       context.write(key, result);
65     }
66   }
67 
68   public static void main(String[] args) throws Exception {
69     Configuration conf = new Configuration();
70     String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
71     if (otherArgs.length < 2) {
72       System.err.println("Usage: wordcount <in> [<in>...] <out>");
73       System.exit(2);
74     }
75     Job job = Job.getInstance(conf, "word count");
76     job.setJarByClass(WordCount.class);
77     job.setMapperClass(TokenizerMapper.class);
78     job.setCombinerClass(IntSumReducer.class);
79     job.setReducerClass(IntSumReducer.class);
80     job.setOutputKeyClass(Text.class);
81     job.setOutputValueClass(IntWritable.class);
82     for (int i = 0; i < otherArgs.length - 1; ++i) {
83       FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
84     }
85     FileOutputFormat.setOutputPath(job,
86       new Path(otherArgs[otherArgs.length - 1]));
87     System.exit(job.waitForCompletion(true) ? 0 : 1);
88   }
89 }

  1 package com.ghgj.mapreduce.wc.demo;
  2 
  3 import java.io.IOException;
  4 
  5 import org.apache.hadoop.conf.Configuration;
  6 import org.apache.hadoop.fs.FileSystem;
  7 import org.apache.hadoop.fs.Path;
  8 import org.apache.hadoop.io.IntWritable;
  9 import org.apache.hadoop.io.LongWritable;
 10 import org.apache.hadoop.io.Text;
 11 import org.apache.hadoop.mapreduce.Job;
 12 import org.apache.hadoop.mapreduce.Mapper;
 13 import org.apache.hadoop.mapreduce.Reducer;
 14 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
 15 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 16 
 17 /**
 18  * 
 19  * 描述: MapReduce出入门：WordCount例子程序 
 20  */
 21 public class WordCountMR {
 22 
 23     /**
 24      * 该main方法是该mapreduce程序运行的入口，其中用一个Job类对象来管理程序运行时所需要的很多参数：
 25      * 比如，指定用哪个组件作为数据读取器、数据结果输出器 指定用哪个类作为map阶段的业务逻辑类，哪个类作为reduce阶段的业务逻辑类
 26      * 指定wordcount job程序的jar包所在路径 .... 以及其他各种需要的参数
 27      */
 28     public static void main(String[] args) throws Exception {
 29         // 指定hdfs相关的参数
 30         Configuration conf = new Configuration();
 31 //         conf.set("fs.defaultFS", "hdfs://hadoop02:9000");
 32         System.setProperty("HADOOP_USER_NAME", "hadoop");
 33 
 34         // 这是高可用的集群的配置文件。如果不是高可用集群，请自行替换配置文件
 35 //        conf.addResource("hdfs_config/core-site.xml");
 36 //        conf.addResource("hdfs_config/hdfs-site.xml");
 37 
 38         // conf.set("mapreduce.framework.name", "yarn");
 39         // conf.set("yarn.resourcemanager.hostname", "hadoop04");
 40 
 41         // 通过Configuration对象获取Job对象，该job对象会组织所有的该MapReduce程序所有的各种组件
 42         Job job = Job.getInstance(conf);
 43 
 44         // 设置jar包所在路径
 45         job.setJarByClass(WordCountMR.class);
 46 
 47         // 指定mapper类和reducer类
 48         job.setMapperClass(WordCountMapper.class);
 49         job.setReducerClass(WordCountReducer.class);
 50 
 51         // Mapper的输入key-value类型，由MapReduce框架决定
 52         // 指定maptask的输出类型
 53         job.setMapOutputKeyClass(Text.class);
 54         job.setMapOutputValueClass(IntWritable.class);
 55         // 假如 mapTask的输出key-value类型，跟reduceTask的输出key-value类型一致，那么，以上两句代码可以不用设置
 56 
 57         // reduceTask的输入key-value类型 就是 mapTask的输出key-value类型。所以不需要指定
 58         // 指定reducetask的输出类型
 59         job.setOutputKeyClass(Text.class);
 60         job.setOutputValueClass(IntWritable.class);
 61 
 62         // 为job指定输入数据的组件和输出数据的组件，以下两个参数是默认的，所以不指定也是OK的
 63         // job.setInputFormatClass(TextInputFormat.class);
 64         // job.setOutputFormatClass(TextOutputFormat.class);
 65 
 66         // 为该mapreduce程序制定默认的数据分区组件。默认是 HashPartitioner.class
 67         // job.setPartitionerClass(HashPartitioner.class);
 68 
 69         // 如果MapReduce程序在Eclipse中，运行，也可以读取Windows系统本地的文件系统中的数据
 70          Path inputPath = new Path("D:\\bigdata\\wordcount\\input");
 71          Path outputPath = new Path("D:\\bigdata\\wordcount\\output33");
 72 
 73         // 设置该MapReduce程序的ReduceTask的个数
 74         // job.setNumReduceTasks(3);
 75 
 76         // 指定该mapreduce程序数据的输入和输出路径
 77 //        Path inputPath = new Path("/wordcount/input");
 78 //        Path outputPath = new Path("/wordcount/output");
 79         // 该段代码是用来判断输出路径存在不存在，存在就删除，虽然方便操作，但请谨慎
 80         FileSystem fs = FileSystem.get(conf);
 81         if (fs.exists(outputPath)) {
 82             fs.delete(outputPath, true);
 83         }
 84 
 85         // 设置wordcount程序的输入路径
 86         FileInputFormat.setInputPaths(job, inputPath);
 87         // 设置wordcount程序的输出路径
 88         FileOutputFormat.setOutputPath(job, outputPath);
 89 
 90         // job.submit();
 91         // 最后提交任务(verbose布尔值 决定要不要将运行进度信息输出给用户)
 92         boolean waitForCompletion = job.waitForCompletion(true);
 93         System.exit(waitForCompletion ? 0 : 1);
 94     }
 95 
 96     /**
 97      * Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT>
 98      * 
 99      * KEYIN 是指框架读取到的数据的key的类型，在默认的InputFormat下，读到的key是一行文本的起始偏移量，所以key的类型是Long
100      * VALUEIN 是指框架读取到的数据的value的类型,在默认的InputFormat下，读到的value是一行文本的内容，所以value的类型是String
101      * KEYOUT 是指用户自定义逻辑方法返回的数据中key的类型，由用户业务逻辑决定，在此wordcount程序中，我们输出的key是单词，所以是String
102      * VALUEOUT 是指用户自定义逻辑方法返回的数据中value的类型，由用户业务逻辑决定,在此wordcount程序中，我们输出的value是单词的数量，所以是Integer
103      * 
104      * 但是，String ，Long等jdk中自带的数据类型，在序列化时，效率比较低，hadoop为了提高序列化效率，自定义了一套序列化框架
105      * 所以，在hadoop的程序中，如果该数据需要进行序列化（写磁盘，或者网络传输），就一定要用实现了hadoop序列化框架的数据类型
106      * 
107      * Long ----> LongWritable 
108      * String ----> Text 
109      * Integer ----> IntWritable 
110      * Null ----> NullWritable
111      */
112     static class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
113 
114         /**
115          * LongWritable key : 该key就是value该行文本的在文件当中的起始偏移量
116          * Text value ： 就是MapReduce框架默认的数据读取组件TextInputFormat读取文件当中的一行文本
117          */
118         @Override
119         protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
120 
121             // 切分单词
122             String[] words = value.toString().split(" ");
123             for (String word : words) {
124                 // 每个单词计数一次，也就是把单词组织成<hello,1>这样的key-value对往外写出
125                 context.write(new Text(word), new IntWritable(1));
126             }
127         }
128     }
129 
130     /**
131      * 首先，和前面一样，Reducer类也有输入和输出，输入就是Map阶段的处理结果，输出就是Reduce最后的输出
132      * reducetask在调我们写的reduce方法,reducetask应该收到了前一阶段（map阶段）中所有maptask输出的数据中的一部分
133      * （数据的key.hashcode%reducetask数==本reductask号），所以reducetaks的输入类型必须和maptask的输出类型一样
134      * 
135      * reducetask将这些收到kv数据拿来处理时，是这样调用我们的reduce方法的： 先将自己收到的所有的kv对按照k分组（根据k是否相同）
136      * 将某一组kv中的第一个kv中的k传给reduce方法的key变量，把这一组kv中所有的v用一个迭代器传给reduce方法的变量values
137      */
138     static class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
139 
140         /**
141          * Text key : mapTask输出的key值
142          * Iterable<IntWritable> values ： key对应的value的集合（该key只是相同的一个key）
143          * 
144          * reduce方法接收key值相同的一组key-value进行汇总计算
145          */
146         @Override
147         protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
148 
149             // 结果汇总
150             int sum = 0;
151             for (IntWritable v : values) {
152                 sum += v.get();
153             }
154             // 汇总的结果往外输出
155             context.write(key, new IntWritable(sum));
156         }
157     }
158 }