WordCount 代码实现【java】

1、Map 类编写

Mapper：是 MapReduce 计算框架中 Map 过程的封装
Text：Hadoop 对 Java String 类的封装，适用于 Hadoop 对文本字符串的处理
IntWritable：Hadoop 对 Java Integer 类的封装，适用于 Hadoop 整型的处理
Context：Hadoop 环境基于上下文的操作对象，如 Map 中 key/value 的输出、分布式缓存数据、分布式参数传递等
StringTokenizer：对 String 对象字符串的操作类，做基于空白字符的切分操作工具类
源码编写实现：

package com.mapper; 
import  java.io.IOException; import java.util.StringTokenizer; 
import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; 
import org.apache.hadoop.mapreduce.Mapper; public class MyTokenizerMapper extends 
        Mapper<Object, Text, Text, IntWritable> { 
    // 暂存每个传过来的词频计数，均为 1,省掉重复申请空间 
    private final static IntWritable one = new IntWritable(1); 
    // 暂存每个传过来的词的值，省掉重复申请空间 
    private Text word = new Text(); 
    // 核心 map 方法的具体实现,逐个<key,value>对去处理 
    public void map(Object key, Text value, Context context) 
            throws IOException, InterruptedException { 
        // 用每行的字符串值初始化 StringTokenizer 
        StringTokenizer itr = new StringTokenizer(value.toString()); 
        // 循环取得每个空白符分隔出来的每个元素 
        while (itr.hasMoreTokens()) { 
            // 将取得出的每个元素放到 word Text 对象中 
            word.set(itr.nextToken()); 
            // 通过 context 对象，将 map 的输出逐个输出 
            context.write(word, one); 
        } 
    } 
} 

2、Reduce 类编写

Reducer：是 MapReduce 计算框架中 Reduce 过程的封装
源码编写实现：

package com.reducer; 
import java.io.IOException; 
import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; 
import org.apache.hadoop.mapreduce.Reducer; 
//reduce 类，实现 reduce 函数public class IntSumReducer extends 
                Reducer<Text, IntWritable, Text, IntWritable> { 
         private IntWritable result = new IntWritable(); 
         //核心 reduce 方法的具体实现,逐个<key,List(v1,v2)>去处理 
         public void reduce(Text key, Iterable<IntWritable> values, 
                      Context context) throws IOException, InterruptedException { 
                //暂存每个 key 组中计算总和 
                int sum = 0; 
                //加强型 for,依次获取迭代器中的每个元素值,即为一个一个的词频数值 
                for (IntWritable val : values) { 
                      //将 key 组中的每个词频数值 sum 到一起 
                      sum += val.get(); 
                } 
                //将该 key 组 sum 完成的值放到 result IntWritable 中，使可以序列化输出 
                result.set(sum); 
                //将计算结果逐条输出 
                context.write(key, result); 
         } 
   } 

3、Driver 类编写

Configuration：与 HDFS 中的 Configuration 一致，负责参数的加载和传递
Job：作业，是对一轮 MapReduce 任务的抽象，即一个 MapReduce 的执行全过程的管理类
FileInputFormat：指定输入数据的工具类，用于指定任务的输入数据路径
FileOutputFormat：指定输出数据的工具类，用于指定任务的输出数据路径
源码编写实现：

package com.driver;
import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; 
import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; 
import org.apache.hadoop.mapreduce.Job; 
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat
import com.mapper.MyTokenizerMapper;
import com.reducer.IntSumReducer; 
public class WordCount { 
   // 启动 mr 的 driver 方法 
   public static void main(String[] args) throws Exception { 
       // 得到集群配置参数 
       Configuration conf = new Configuration(); 
       // 设置到本次的 job 实例中 
       Job job = Job.getInstance(conf, "天亮 WordCount"); 
       // 指定本次执行的主类是 WordCount 
      job.setJarByClass(WordCount.class); 
       // 指定 map 类 
      job.setMapperClass(MyTokenizerMapper.class); 
       // 指定 combiner 类，要么不指定，如果指定，一般与 reducer 类相同 
      job.setCombinerClass(IntSumReducer.class); 
       // 指定 reducer 类 
      job.setReducerClass(IntSumReducer.class); 
       // 指定 job 输出的 key 和 value 的类型,如果 map 和 reduce 输出类型不完全相同，需要重新设置 map 的 output 的 key 和 value 的 class 类型 
      job.setOutputKeyClass(Text.class); 
      job.setOutputValueClass(IntWritable.class); 
       // 指定输入数据的路径 
      FileInputFormat.addInputPath(job, new Path(args[0])); 
       // 指定输出路径,并要求该输出路径一定是不存在的 
      FileOutputFormat.setOutputPath(job, new Path(args[1])); 
       // 指定 job 执行模式，等待任务执行完成后，提交任务的客户端才会退出! 
      System.exit(job.waitForCompletion(true) ? 0 : 1); 
   } 
} 

4、Maven 打包

使用 Maven 命令，基于配置的 Maven 插件实现代码打包。

5、上传到运行环境

使用 rz 命令将打好的运行包上传到集群环境中。

6、运行 WordCount 程序具体提交命令为：

yarn jar testhdfs-jar-with-dependencies.jar com.driver.WordCount
/tmp/input /tmp/output3

7、查看执行过程

8、标砖代码实现

将之前的三个类，合并成一个类来处理

import java.io.IOException; 
import java.util.StringTokenizer; 
import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; 
import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; 
import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.mapreduce.Mapper; import org.apache.hadoop.mapreduce.Reducer; 
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; 
 
//启动 mr 的 driver 类
public class WordCount { 
       //map 类，实现 map 函数 
        public static class MyTokenizerMapper extends 
                    Mapper<Object, Text, Text, IntWritable> { 
             //暂存每个传过来的词频计数，均为 1,省掉重复申请空间 
             private final static IntWritable one = new IntWritable(1); 
             //暂存每个传过来的词的值，省掉重复申请空间 
             private Text word = new Text(); 
 
             //核心 map 方法的具体实现,逐个<key,value>对去处理 
             public void map(Object key, Text value, Context context) 
                          throws IOException, InterruptedException { 
                    //用每行的字符串值初始化 StringTokenizer 
                    StringTokenizer itr = new StringTokenizer(value.toString()); 
                    //循环取得每个空白符分隔出来的每个元素 
                    while (itr.hasMoreTokens()) { 
                          //将取得出的每个元素放到 word Text 对象中 
                          word.set(itr.nextToken()); 
                          //通过 context 对象，将 map 的输出逐个输出 
                          context.write(word, one); 
                    } 
             } 
       } 
 
       //reduce 类，实现 reduce 函数 
       public static class IntSumReducer extends 
                    Reducer<Text, IntWritable, Text, IntWritable> { 
             private IntWritable result = new IntWritable(); 
 
             //核心 reduce 方法的具体实现,逐个<key,List(v1,v2)>去处理 
             public void reduce(Text key, Iterable<IntWritable> values, 
                          Context context) throws IOException, InterruptedException { 
                    //暂存每个 key 组中计算总和 
                    int sum = 0; 
                    //加强型 for,依次获取迭代器中的每个元素值,即为一个一个的词频数值 
                    for (IntWritable val : values) { 
                          //将 key 组中的每个词频数值 sum 到一起 
                          sum += val.get(); 
                    } 
                    //将该 key 组 sum 完成的值放到 result IntWritable 中，使可以序列化输出 
                    result.set(sum); 
                    //将计算结果逐条输出 
                    context.write(key, result); 
             } 
       } 
 
       //启动 mr 的 driver 方法 
       public static void main(String[] args) throws Exception { 
             //得到集群配置参数 
             Configuration conf = new Configuration(); 
             //设置到本次的 job 实例中 
             Job job = Job.getInstance(conf, "天亮 WordCount"); 
             //指定本次执行的主类是 WordCount 
             job.setJarByClass(WordCount.class); 
             //指定 map 类 
             job.setMapperClass(MyTokenizerMapper.class); 
             //指定 combiner 类，要么不指定，如果指定，一般与 reducer 类相同 
             job.setCombinerClass(IntSumReducer.class); 
             //指定 reducer 类 
             job.setReducerClass(IntSumReducer.class); 
             //指定 job 输出的 key 和 value 的类型,如果 map 和 reduce 输出类型不完全相同，需要重新设置 map 的 output 的 key 和 value 的 class 类型 
             job.setOutputKeyClass(Text.class); 
             job.setOutputValueClass(IntWritable.class); 
             //指定输入数据的路径 
             FileInputFormat.addInputPath(job, new Path(args[0])); 
             //指定输出路径,并要求该输出路径一定是不存在的 
             FileOutputFormat.setOutputPath(job, new Path(args[1])); 
             //指定 job 执行模式，等待任务执行完成后，提交任务的客户端才会退出! 
             System.exit(job.waitForCompletion(true) ? 0 : 1); 
       } 
}