Hadoop-Mapreduce

Hadoop-Mapreduce

1. MapReduce 介绍

MapReduce思想在生活中处处可见。或多或少都曾接触过这种思想。MapReduce的思想核心是“分而治之”，适用于大量复杂的任务处理场景（大规模数据处理场景）。

• Map负责“分”，即把复杂的任务分解为若干个“简单的任务”来并行处理。可以进行拆分的前提是这些小任务可以并行计算，彼此间几乎没有依赖关系。
• Reduce负责“合”，即对map阶段的结果进行全局汇总。
• MapReduce运行在yarn集群
  1. ResourceManager
  2. NodeManager

这两个阶段合起来正是MapReduce思想的体现。

还有一个比较形象的语言解释MapReduce:

我们要数图书馆中的所有书。你数1号书架，我数2号书架。这就是“Map”。我们人越多，数书就更快。

现在我们到一起，把所有人的统计数加在一起。这就是“Reduce”。

1.1. MapReduce 设计构思

MapReduce是一个分布式运算程序的编程框架，核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在Hadoop集群上。

MapReduce设计并提供了统一的计算框架，为程序员隐藏了绝大多数系统层面的处理细节。为程序员提供一个抽象和高层的编程接口和框架。程序员仅需要关心其应用层的具体计算问题，仅需编写少量的处理应用本身计算问题的程序代码。如何具体完成这个并行计算任务所相关的诸多系统层细节被隐藏起来,交给计算框架去处理：

Map和Reduce为程序员提供了一个清晰的操作接口抽象描述。MapReduce中定义了如下的Map和Reduce两个抽象的编程接口，由用户去编程实现.Map和Reduce,MapReduce处理的数据类型是<key,value>键值对。

• Map: (k1; v1) → [(k2; v2)]

• Reduce: (k2; [v2]) → [(k3; v3)]

一个完整的mapreduce程序在分布式运行时有三类实例进程：

1. MRAppMaster 负责整个程序的过程调度及状态协调
2. MapTask 负责map阶段的整个数据处理流程
3. ReduceTask 负责reduce阶段的整个数据处理流程

2. MapReduce 编程规范

MapReduce 的开发一共有八个步骤, 其中 Map 阶段分为 2 个步骤，Shuffle 阶段 4 个步骤，Reduce 阶段分为 2 个步骤

Map 阶段 2 个步骤

1. 设置 InputFormat 类, 将数据切分为 Key-Value(K1和V1) 对, 输入到第二步
2. 自定义 Map 逻辑, 将第一步的结果转换成另外的 Key-Value（K2和V2） 对, 输出结果

Shuffle 阶段 4 个步骤

3. 对输出的 Key-Value 对进行分区
4. 对不同分区的数据按照相同的 Key 排序
5. (可选) 对分组过的数据初步规约, 降低数据的网络拷贝
6. 对数据进行分组, 相同 Key 的 Value 放入一个集合中

Reduce 阶段 2 个步骤

7. 对多个 Map 任务的结果进行排序以及合并, 编写 Reduce 函数实现自己的逻辑, 对输入的 Key-Value 进行处理, 转为新的 Key-Value（K3和V3）输出
8. 设置 OutputFormat 处理并保存 Reduce 输出的 Key-Value 数据

3. WordCount

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

流程图分析

Step 1. 数据格式准备

1. 创建一个新的文件

cd /export/servers
vim wordcount.txt

2. 向其中放入以下内容并保存

hello,world,hadoop
hive,sqoop,flume,hello
kitty,tom,jerry,world
hadoop

3. 上传到 HDFS

hdfs dfs -mkdir /wordcount/
hdfs dfs -put wordcount.txt /wordcount/

Step 2. Mapper

public class WordCountMapper extends Mapper<LongWritable, Text, Text, LongWritable> {
    /**
     * 将k1 v1 转为 k2 v2
     * key :K1  行偏移量
     * value:V1  每一行的文本数据
     * context:表示上下文对象
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        Text text = new Text();
        LongWritable longWritable = new LongWritable(1);
        //拆分一行文本数据
        String[] split = value.toString().split(",");
        //遍历数据 组装k2 v2
        for (String s : split) {
            text.set(s);
            //将k2 v2 写入Context中
            context.write(text, longWritable);
        }

    }
}

Step 3. Reducer

public class WordCountReducer extends Reducer<Text,LongWritable,Text,LongWritable> {
    /**
     * 自定义我们的reduce逻辑
     * 所有的key都是我们的单词，所有的values都是我们单词出现的次数
     * @param key		新key2
     * @param values	新values2
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
        long count = 0;
        for (LongWritable value : values) {
            count += value.get();
        }
        context.write(key,new LongWritable(count));
    }
}

public class JobMain extends Configured implements Tool {

    public static void main(String[] args) throws Exception {

        Configuration cof = new Configuration();
        //1.运行run方法时,实际上运行的是下面中的run(String[] strings)方法.

        //3.返回值如果是0,说明运行成功.
        int run = ToolRunner.run(cof, new JobMain(), args);

        System.exit(run);
    }

    @Override
    public int run(String[] strings) throws Exception {
        /*
            job的实例化第一参数需要的是一个configuration,对于同一个任务,Configuration必须是同一个.所以不能直接new.
            那么如果获取同一个呢?
            run(cof, new JobMain(), args)方法会将之前new出来的cof对象保存到JobMain的父类Configured中,
            我们可以进入到Configured类中看到,此类有一个成员变量:private Configuration conf;
            所以我们通过super.getConf()就可以获取到同一个任务的Configuration
        */
        //1.创建一个job任务
        Job job = Job.getInstance(super.getConf(), "worldcount");
        //如果打成jar后运行不了,添加此代码
        job.setJarByClass(JobMain.class);

        //2.配置job任务,共八个步骤

        //第一步:指定输入类型,读取文件的源文件的路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path("hdfs://node01:8020/wordcount_input"));
        //TextInputFormat.addInputPath(job, new Path("file:///d:/new"));


        //第二步:指定map阶端的处理方式和数据类型

        //设置map阶端自定义的逻辑类
        job.setMapperClass(WordCountMapper.class);

        //设置Map k2的类型
        job.setMapOutputKeyClass(Text.class);
        //设置Map v2的类型
        job.setMapOutputValueClass(LongWritable.class);

        //第三,四,五,六 采用默认方式,暂不做shuffle的自定义处理

        //第七:指定reducer处理方式和数据类型
        job.setReducerClass(WordCountRuducer.class);
        //设置reducer的k3类型
        job.setOutputKeyClass(Text.class);
        //设置reducer的v3类型
        job.setOutputValueClass(LongWritable.class);

        //第八步:设置输出类型和输出路径(目标文件夹不能已经存在,否则会报错)
        job.setOutputFormatClass(TextOutputFormat.class);
        //TextOutputFormat.setOutputPath(job, new Path("file:///d:/new/out"));
        Path path = new Path("hdfs://node01:8020/wordcount_out");
        TextOutputFormat.setOutputPath(job, path);

        //判断目录是否存在
        FileSystem fileSystem = FileSystem.get(new URI("hdfs://node01:8020"), new Configuration());
        boolean exists = fileSystem.exists(path);
        if (exists) {
            //如果存在则删除
            fileSystem.delete(path, true);
        }
        ///等待任务结束
        boolean b = job.waitForCompletion(true);

        return b ? 0 : 1;
    }
}

4. MapReduce 运行模式

集群运行模式

1. 将 MapReduce 程序提交给 Yarn 集群, 分发到很多的节点上并发执行
2. 处理的数据和输出结果应该位于 HDFS 文件系统
3. 提交集群的实现步骤: 将程序打成JAR包，然后在集群的任意一个节点上用hadoop命令启动

hadoop jar hadoop_hdfs_operate-1.0-SNAPSHOT.jar cn.itcast.hdfs.demo1.JobMain

实际工作当中，都是将代码打成jar包，开发main方法作为程序的入口，然后放到集群上面去运行

本地运行模式

1. MapReduce 程序是被提交给 LocalJobRunner 在本地以单进程的形式运行
2. 处理的数据及输出结果可以在本地文件系统, 也可以在hdfs上

TextInputFormat.addInputPath(job, new Path("file:///d:/new"));
TextOutputFormat.setOutputPath(job, new Path("file:///d:/new/out"));

5. MapReduce 分区

在 MapReduce 中, 通过我们指定分区, 会将同一个分区的数据发送到同一个 Reduce 当中进行处理

例如: 为了数据的统计, 可以把一批类似的数据发送到同一个 Reduce 当中, 在同一个 Reduce 当中统计相同类型的数据, 就可以实现类似的数据分区和统计等

其实就是相同类型的数据, 有共性的数据, 送到一起去处理

Reduce 当中默认的分区只有一个

Step 1. 定义 Mapper

这个 Mapper 程序不做任何逻辑, 也不对 Key-Value 做任何改变, 只是接收数据, 然后往下发送.
未完待遇…