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("	");
            // 遍历数组，输出<单词，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使用的原则是：有或没有都不能影响业务逻辑