Hadoop 之 MapReduce 概述 11

MapReduce 定义

        MapReduce 是一个分布式运算程序的编程框架，是用户开发 “基于 Hadoop 的数据分析应用”的核心框架。

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

MapReduce 优缺点

• 优点

        1、易于编程。用户只关心业务逻辑，实现框架的接口。

        2、良好的扩展性。可以动态的增加服务器，解决计算资源不够的问题。

        3、高容错性。任何一台机器挂掉，可以将任务转移到其他节点。

        4、适合海量数据计算（TB/PB）几千台服务器共同计算。

• 缺点

        1、不擅长实时计算。（MySQL 实时计算）

        2、不擅长流式计算。（Sparkstreaming、flink 流式计算）

        3、不擅长 DAG 有向无环图计算。（spark 擅长）

MapReduce 核心思想

MapReduce 进程

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

        1、MrAppMaster：负责整个程序的过程调度及状态协调。

        （任务、job、mr都是一个意思，都是一个应用程序）

        2、MapTask：负责 Map 阶段的整个数据处理流程。

        3、ReduceTask：负责 Reduce 阶段的整个数据处理流程。

官方 WordCount 源码

        采取反编译工具反编译源码，发现 WordCount 案例有 Map 类、Reduce 类和驱动类。且数据的类型时 Hadoop 自身封装的序列化类型。

# 下载到本地
[kane@hadoop102 mapreduce]$ sz hadoop-mapreduce-examples-3.1.3.jar 

常用数据序列化类型

Java类型	Hadoop Writable 类型
Boolean	BooleanWritable
Byte	ByteWritable
Int	IntWritable
Float	FloatWritable
Long	LongWritable
Double	DoubleWritable
String	Text
Map	MapWritable
Array	ArrayWritable
Null	NullWritable

MapReduce 编程规范

用户编写的程序分成三个部分：Mapper、Reducer、Driver。

• Mapper 阶段

        1.用户自定义的 Mapper 要继承自己的父类；

        2.Mapper 的输入数据时 k v 对的形式（k v 的类型可自定义）；

        3.Mapper 中的业务逻辑写在 map() 方法中；

        4.Mapper 的输出数据是 k v 对的形式（k v 的类型可自定义）；

        5.map() 方法（MapTask 进程）对每一个<k,v>调用一次

• Reducer 阶段

        1.用户自定义的 Reducer 要继承自己的父类；

        2.Reducer 的输入数据类型对应 Mapper 的输出数据类型，也是 k v； 

        3.Reducer 的业务逻辑写在 reduce() 方法中；

        4.ReducerTask 进程对每一组相同 k 的<k,v>组调用一次 reduce()方法。

• Driver 阶段

        相当于 YARN 集群的客户端，用于提交我们整个程序到 YARN 集群，提交的是封装了 MapReduce 程序相关运行参数的 job 对象。

 WordCount 案例实操

• 本地提交

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

        2、需求分析：按照 MapReduce 编程规范，分别编写 Mapper、Reducer、Driver。

        3、环境准备

                a.创建 maven 工程， MapReduceDemo

                b.在 pom.xml 文件添加如下依赖

                c.在 src/main/resources 目录下创建 log4j.properties

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.1.3</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.30</version>
        </dependency>

log4j.rootLogger=INFO, stdout  
log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n  
log4j.appender.logfile=org.apache.log4j.FileAppender  
log4j.appender.logfile.File=target/spring.log  
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout  
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

package com.kane.mapreduce.wordcount;

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 java.io.IOException;

public class WordCountDriver {

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

        // 1.获取 job
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        // 2.设置 jar 包路径
        job.setJarByClass(WordCountDriver.class);

        // 3.关联 mapper 和 reducer
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);

        // 4.设置 map 输出的 kv 类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);

        // 5.设置最终输出的 kv 类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        // 6.设置输入路径和输出路径
        FileInputFormat.setInputPaths(job, new Path("E:\\input\\wordCount.txt"));
        FileOutputFormat.setOutputPath(job, new Path("E:\\output"));

        // 7.提交 job
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);
    }
}

package com.kane.mapreduce.wordcount;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * KEYIN，map 阶段输入 key 的类型： LongWritable
 * VALUEIN，map 阶段输入 value 的类型： Text
 * KEYOUT，map 阶段输出 key 的类型： Text
 * VALUEOUT，map 阶段输出 value 的类型： IntWritable
 */
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    private Text outK = new Text();
    private IntWritable outV = new IntWritable(1);

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

        // 1.获取一行
        String line = value.toString();

        // 2.切割数据
        String[] words = line.split(" ");

        // 3.循环写出
        for (String word : words) {

            // 封装
            outK.set(word);
            // 写出
            context.write(outK, outV);
        }
    }
}

package com.kane.mapreduce.wordcount;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * KEYIN，reduce 阶段输入 key 的类型： Text
 * VALUEIN，reduce 阶段输入 value 的类型： IntWritable
 * KEYOUT，reduce 阶段输出 key 的类型： Text
 * VALUEOUT，reduce 阶段输出 value 的类型： IntWritable
 */
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {

    private IntWritable outV = new IntWritable();

    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {

        int sum = 0;
        // 累加
        for (IntWritable value : values) {
            sum += value.get();
        }
        outV.set(sum);

        // 写出
        context.write(key, outV);
    }
}

• 提交到集群测试

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRefs>jar-with-dependencies</descriptorRefs>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

# 执行任务
[kane@hadoop102 hadoop-3.1.3]$ hadoop jar wc.jar com.kane.mapreduce.wordcount.WordCountDriver /input /output