手写WordCount程序

Mapper类

Mapper的输入指的就是mapreduce框架读取文件的内容  这里的输入相当于流读取完成的文件内容，然后封装成键值对

四个范型：
输入：固定
    KEYIN：输入的键的类型 标识读取行数,代表的是每一行的偏移量，按照字节标识下标，因为数据量比较大，用Long类型
    VALUEIN：输入的值的类型  这里指的就是一行一行的内容   String
输出：根据业务决定
    KEYOUT：输出的键的类型  表示要传递给reduce的键的类型，输出的键决定了reduce的分组依据
    VALUEOUT：输出的值的类型  表示要传递给reduce的值的类型

这里泛型用Hadoop的序列化对象作为泛型，因为java泛型过重，需要把整个类进行序列化。
用序列化的类型是因为这是分布式计算，需要多台服务器共同协作，序列化的类型才能进行网络传输。
hadoop中实现了一个轻量级序列化,反序列化的Writable接口 
* int----intwritable
* long----longwritable
* double-----doublewritable
* float-----floatwritable
* null-----NullWritable   可以在map输出不需要value时使用
* String-----Text

public class WordCountMapper extends Mapper<LongWritable,  Text, Text, IntWritable>{
     /*
      * 参数概念：
      *   LongWritable key, 指的是每一行的偏移量
      *   Text value, 指的是每一行读取的内容
      *   Context context   上下文对象    承上启下  向上承接框架  向下面向reducer
      */
     MapReduce框架每读到一行数据，就会调用一次这个map方法。
     @Override
     protected void map(LongWritable key, Text value, Context context)
              throws IOException, InterruptedException {
          //1.拿到每一行的内容  Text--String    toString
          String line=value.toString();
          //2.拆分每一个单词
          String[] words = line.split("\t");
          //3.不进行计算  将所有计算 放在reduce中
          //直接将数据发送到reduce中    以k-v形式   k---单词   v---1
          for(String w : words){
              Text mk=new Text(w);
              IntWritable mv=new IntWritable(1);
              context.write(mk,mv);
          }
     }
}

Reduce类

四个范型：
输入：Mapper的输出类型
    KEYIN：Mapper的输出的键的类型
    VALUEIN：Mapper的输出的值的类型
输出：根据业务决定
    KEYOUT：输出的键的类型  
    VALUEOUT：输出的值的类型  

public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
     /*
      *  Text key, 一组中的一个key
      *  Iterable<IntWritable> values,  迭代器,封装的是该key对应的一组values
      *  map到reduce的过程中默认按照map输出的key进行分组
      *  Context context：上下文对象   对上承接map,对下写出数据
      */
     reduce方法调用的频率：一组调用一次     不是一个reducetask调用一次   
     @Override
     protected void reduce(Text key,  Iterable<IntWritable> values,Context context)
                     throws IOException,  InterruptedException {
          //相同的单词全部过来了
          //统计迭代器中的值的和
          int sum=0;
          for(IntWritable v:values){
              //hadoop中的数值类型（int double...）---java数值   get()
              sum+=v.get();
          }
          context.write(key, new IntWritable(sum));
     }
}

主函数：整合Mapper和对应的Reduce到一个job

/*
 * 提交运行代码的时候  客户端传入的参数   通过args接受的
 * 第一个参数   放在数组第一个元素的  下标0
 * 第二个参数   下标1
 * ...
 */
public static void main(String[] args) throws  IOException, ClassNotFoundException, InterruptedException  {
          //加载配置文件
          Configuration conf=new Configuration();
          
          //启动一个job作业
          Job job=Job.getInstance(conf);
          
          //对job进行封装
          //指定主类入口  
          job.setJarByClass(Driver.class);
          //指定map对应的类
          job.setMapperClass(WordCountMapper.class);
          //指定reduce的类
          job.setReducerClass(WordCountReducer.class);
          
          //指定map输出的k   v类型
          /*
           * 泛型只在编译期生效  运行期自动擦除，所以这里需要指明Mapper和Reduce的泛型类型
           */
          job.setMapOutputKeyClass(Text.class);
          job.setMapOutputValueClass(IntWritable.class);
          
          //指定reduce输出的k v类型   设定的最终的结果输出
          job.setOutputKeyClass(Text.class);
          job.setOutputValueClass(IntWritable.class);
          
          //指定输入路径
          FileInputFormat.addInputPath(job, new  Path(args[0]));
          
          //指定输出路径
          FileOutputFormat.setOutputPath(job, new  Path(args[1]));
          
          //提交运行job  当这句代码提交时，就开始运行
          job.waitForCompletion(true);
     }
}