MapReduce实战1

MapReduce编程规范：

（1）用户编写的程序分成三个部分：Mapper，Reducer，Driver(提交运行mr程序的客户端)

（2）Mapper的输入数据是KV对的形式（KV的类型可自定义）

（3）Mapper的输出数据是KV对的形式（KV的类型可自定义）

（4）Mapper中的业务逻辑写在map()方法中

（5）map()方法（maptask进程）对每一个<K,V>调用一次

（6）Reducer的输入数据类型对应Mapper的输出数据类型，也是KV

（7）Reducer的业务逻辑写在reduce()方法中

（8）Reducetask进程对每一组相同k的<k,v>组调用一次reduce()方法

（9）用户自定义的Mapper和Reducer都要继承各自的父类

（10）整个程序需要一个Drvier来进行提交，提交的是一个描述了各种必要信息的job对象

WordCount:在给定的文本文件中统计输出每一个单词出现的总次数

 package com.ahu.bigdata.mr;

 import java.io.IOException;

 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.io.IntWritable;
 import org.apache.hadoop.io.LongWritable;
 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;

 /**
  * 在给定的文本文件中统计出每一个单词出现的总次数
  *
  * @author ahu_lichang
  *
  */
 public class WordCountDriver {
     /**
      * 自定义mapper类
      *
      * @author ahu_lichang
      *
      */
     static class WordCountMapper extends
             Mapper<LongWritable, Text, Text, IntWritable> {
         // map方法的生命周期：框架每传一行数据就被调用一次
         // key:这一行的起始点在文件中的偏移量
         // value:这一行的内容
         @Override
         protected void map(LongWritable key, Text value, Context context)
                 throws IOException, InterruptedException {
             // 拿到一行数据转换为String
             String line = value.toString();
             // 将这一行切分出各个单词
             String[] words = line.split("\t");
             // 遍历数组，输出<单词，1>
             for (String word : words) {
                 context.write(new Text(word), new IntWritable(1));
             }
         }
     }

     /**
      * 自定义一个reducer类
      *
      * @author ahu_lichang
      *
      */
     static class WordCountReducer extends
             Reducer<Text, IntWritable, Text, IntWritable> {
         // reduce生命周期：框架每传递进来一个KV组，reduce方法就被调用一次
         @Override
         protected void reduce(Text key, Iterable<IntWritable> values,
                 Context context) throws IOException, InterruptedException {
             // 定义一个计数器
             int count = 0;
             // 遍历这一组KV的所有V,累加到count中
             for (IntWritable value : values) {
                 count += value.get();
             }
             context.write(key, new IntWritable(count));
         }
     }

     private static final String INPUT_PATH = "hdfs://hadoop1:9000/data.txt";
     private static final String OUT_PATH = "hdfs://hadoop1:9000/wcoutput";

     // WordCountDriver是一个主类，用来描述job并提交job
     // 相当于一个yarn集群的客户端
     // 需要在此封装我们的mr程序的相关运行参数，指定jar包
     // 最后提交给yarn
     public static void main(String[] args) throws Exception {
         if (args == null || args.length == 0) {
             args = new String[2];
             args[0] = INPUT_PATH;
             args[1] = OUT_PATH;
         }
         // 把业务逻辑相关的信息（哪个是mapper,哪个是reducer，要处理的数据在哪里，输出的结果放在哪里...）描述成一个job对象
         // 把这个描述好的job提交给集群去运行
         Configuration conf = new Configuration();
         Job job = Job.getInstance(conf);

         // 指定这个job所在的jar包
         // job.setJar("/usr/local/wordcount.jar");
         job.setJarByClass(WordCountDriver.class);

         job.setMapperClass(WordCountMapper.class);
         job.setReducerClass(WordCountReducer.class);

         // 设置业务逻辑Mapper类的输出key和value的数据类型
         job.setMapOutputKeyClass(Text.class);
         job.setMapOutputValueClass(IntWritable.class);

         // 设置业务逻辑Reducer类的输出key和value的数据类型
         job.setOutputKeyClass(Text.class);
         job.setOutputValueClass(IntWritable.class);

         // 指定job的输入原始文件所在目录
         //FileInputFormat.setInputPaths(job, new Path(INPUT_PATH));
         FileInputFormat.setInputPaths(job, new Path(args[0]));
         // 指定job的输出结果所在目录
         //FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
         FileOutputFormat.setOutputPath(job, new Path(args[1]));

         // 将job中配置的相关参数，以及job所用的java类所在的jar包，提交给yarn集群去运行
         /* job.submit(); */
         boolean res = job.waitForCompletion(true);
         System.exit(res ? 0 : 1);

     }

 }

1、先在eclipse工程中创建一个用户类库hadoop264jar，将hadoop安装目录中的share文件夹中的common、hdfs、MapReduce、yarn中的jar包全部添加进去。

2、书写代码：创建一个mapper自定义类，在创建一个reducer自定义类，最后创建一个描述job并提交job的主类。

3、运行方式有两种：

　　　　　　（1）直接在eclipse中运行。但是会出现个权限拒绝错误，那是因为没有身份标识造成的。这里再介绍第二种身份标识方式：（第一种身份标识方式，见《HDFS详解》）

　　　　　　　　

　　　　　　（2）在集群上打包运行。先将书写好的代码打成jar包，然后将wordcount.jar复制到Linux的/usr/local/目录下，然后就可以在命令行中运行了。

　　　　　　　　hadoop jar /usr/local/wordcount.jar /data.txt /wcout

　　　　　　　 

MapReduce程序运行模式：

1、本地运行模式

2、集群运行模式

MapReduce中的Combiner（归约）《Combiner》里面有代码示例

（1）combiner是MR程序中Mapper和Reducer之外的一种组件

（2）combiner组件的父类就是Reducer

（3）combiner和reducer的区别在于运行的位置：

　　　　Combiner是在每一个maptask所在的节点运行

　　　　Reducer是接收全局所有Mapper的输出结果；

(4) combiner的意义就是对每一个maptask的输出进行局部汇总，以减小网络传输量

具体实现步骤：

　　1、 自定义一个combiner继承Reducer，重写reduce方法

　　2、 在job中设置：  job.setCombinerClass(CustomCombiner.class)

(5) combiner能够应用的前提是不能影响最终的业务逻辑。而且，combiner的输出kv应该跟reducer的输入kv类型要对应起来

注意：

Combiner的使用要非常谨慎

因为combiner在mapreduce过程中可能调用也可能不调用，可能调一次也可能调多次

所以：combiner使用的原则是：有或没有都不能影响业务逻辑