大数据技术学习笔记（五）—— MapReduce（1）

最新推荐文章于 2024-07-23 17:34:00 发布

夏木夕

最新推荐文章于 2024-07-23 17:34:00 发布

阅读量989

点赞数 24

分类专栏：大数据学习笔记文章标签：大数据学习笔记

本文链接：https://blog.csdn.net/hu_wei123/article/details/133975399

版权

大数据学习笔记专栏收录该内容

29 篇文章 10 订阅

订阅专栏

1 MapReduce 概述

1.1 MapReduce 定义

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

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

1.2 MapReduce 优缺点

（1）优点

MapReduce 易于编程
- 它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一样的。就是因为这个特点使得 MapReduce 编程变得非常流行。
良好的扩展性
- 当你的计算资源不能得到满足的时候，你可以通过 简单的增加机器 来扩展它的计算能力。
高容错性
- MapReduce设计的初衷就是使程序能够部署在廉价的PC机器上，这就要求它具有很高的容错性。比如 其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上运行，不至于这个任务运行失败，而且这个过程不需要人工参与，而完全是由Hadoop内部完成的。
适合 PB 级以上海量数据的离线处理
- 可以实现上千台服务器集群并发工作，提供数据处理能力。

（2）缺点

不擅长 实时计算
- MapReduce 无法像 MySQL一样，在毫秒或者秒级内返回结果。
不擅长 流式计算
- 流式计算的输入数据是动态的，而MapReduce的输入数据集是静态的，不能动态变化。这是因为MapReduce自身的设计特点决定了数据源必须是静态的。
不擅长 DAG（有向无环图）计算
- 多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce并不是不能做，而是使用后，每个MapReduce作业的输出结果都会写入到磁盘，会造成大量的磁盘IO，导致性能非常的低下。

1.3 MapReduce 核心思想

在这里插入图片描述

（1）分布式的运算程序往往需要分成至少2个阶段。

（2）第一个阶段的MapTask并发实例，完全并行运行，互不相干。

（3）第二个阶段的ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。

（4）MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个MapReduce程序，串行运行。

总结：分析WordCount数据流走向深入理解MapReduce核心思想。

注意：

Map阶段对数据进行切片（针对单个文件），每片128M，一个片就代表一个MapTask
ReduceTask 的数量取决于有多少个分区
切片和分区的源码要掌握

1.4 MapReduce 进程

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

MrAppMaster：负责整个程序的过程调度及状态协调。
MapTask：负责Map阶段的整个数据处理流程。
ReduceTask：负责Reduce阶段的整个数据处理流程。

1.5 Hadoop 序列化类型

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

常用的序列化类型：

在这里插入图片描述

1.6 MapReduce 编程规范

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

（1） Mapper阶段

用户自定义的 Mapper 要继承自己的父类
Mapper的输入数据是KV对的形式（KV类型可自定义）
Mapper中的业务逻辑写在 map 方法中
Mapper的输出数据是KV对的形式（KV类型可自定义）
map方法（MapTask进程）对每一个<K,V>调用一次

（2）Reducer阶段

用户自定义的 Reducer 要继承自己的父类
Reducer的输入数据类型对应Mapper的输出类型，也是KV
Reducer中的业务逻辑写在 reduce 方法中
reduce方法（ReduceTask进程）对每一组相同的 K 的 <K,V> 组调用一次

（3）Driver 阶段

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

1.7 WordCount 案例实操

1.7.1 案例需求

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

hello.txt 文本内容

hu hu hu
ss ss
cls cls
jiao
banzhang
xue
hadoop

期望输出数据

hu	3
banzhang	1
cls	2
hadoop	1
jiao	1
ss	2
xue	1

1.7.2 环境准备

（1）创建 maven 工程
（2）在 pom.xml 文件中添加如下依赖

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-slf4j-impl</artifactId>
        <version>2.12.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-client</artifactId>
        <version>3.1.3</version>
    </dependency>
</dependencies>

（3）在项目的 src/main/resources目录下，新建一个文件，命名为log4j2.xml，在文件中填入

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error" strict="true" name="XMLConfig">
    <Appenders>
        <!-- 类型名为Console，名称为必须属性 -->
        <Appender type="Console" name="STDOUT">
            <!-- 布局为PatternLayout的方式，
            输出样式为[INFO] [2018-01-22 17:34:01][org.test.Console]I'm here -->
            <Layout type="PatternLayout"
                    pattern="[%p] [%d{yyyy-MM-dd HH:mm:ss}][%c{10}]%m%n" />
        </Appender>

    </Appenders>

    <Loggers>
        <!-- 可加性为false -->
        <Logger name="test" level="info" additivity="false">
            <AppenderRef ref="STDOUT" />
        </Logger>

        <!-- root loggerConfig设置 -->
        <Root level="info">
            <AppenderRef ref="STDOUT" />
        </Root>
    </Loggers>
</Configuration>

1.7.3 编写程序

WordCountMapper.java

/**
 * 自定义的Mapper类需要继承Hadoop提供的Mapper，并且根据具体的业务指定输入数据和输出数据的数据类型
 * 输入数据的类型
 * KEYIN, 读取文件的偏移量 数字（LongWritable）
 * VALUEIN, 读取文件的一行数据 文本（Text）
 * 输出数据的类型
 * KEYOUT, 输出数据 key 的形式 一个单词（Text）
 * VALUEOUT, 输出数据 value 的形式 给单词标记数字1（IntWritable）
 */

public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
    private Text outk = new Text();
    private IntWritable outv = new IntWritable(1);

    /**
     * Map阶段的核心业务处理方法，每输入一行数据就会调用一次 map 方法
     * @param context 上下文对象
     */
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
        // 获取输入的当前行数据
        String line = value.toString();
        // 切割数据
        String[] datas = line.split(" ");
        for (String data : datas) {
//            context.write(new Text(data),new IntWritable(1));
            outk.set(data);
            context.write(outk, outv);
        }
    }
}

WordCountReducer.java

/**
 * 自定义的Reducer类需要继承Hadoop提供的Reducer，并且根据具体的业务指定输入数据和输出数据的数据类型
 * 输入数据的类型
 * KEYIN, Map端输出的key的数据类型（Text）
 * VALUEIN, Map端输出的value的数据类型（IntWritable）
 * 输出数据的类型
 * KEYOUT, 输出数据 key 的形式 一个单词（Text）
 * VALUEOUT, 输出数据 value 的形式 单词出现的总次数（IntWritable）
 */
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
    private Text outk = new Text();
    private IntWritable outv = new IntWritable();

    /**
     * Reduce阶段的核心业务处理方法，一组相同key的values会调用一次reduce方法
     */
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
        int total = 0;
        // 遍历values
        for (IntWritable value : values) {
            // 对value累加，输出结果
            total += value.get();
        }
        // 封装key和value
        outk.set(key);
        outv.set(total);
        context.write(outk, outv);
    }
}

WordCountDriver.java

/**
 * MR的驱动类，主要用于提交MR任务
 */
public class WordCountDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        // 声明配置对象
        Configuration conf = new Configuration();
        // 声明Job对象
        Job job = Job.getInstance(conf);

        // 指定当前Job的驱动类
        job.setJarByClass(WordCountDriver.class);
        // 指定当前Job的Mapper
        job.setMapperClass(WordCountMapper.class);
        // 指定当前Job的Reducer
        job.setReducerClass(WordCountReducer.class);

        // 指定Map端输出数据的key的类型和输出数据value的类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        // 指定最终（Reduce端）输出数据的key的类型和输出数据value的类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        // 指定输入数据的路径和输出数据的路径
        FileInputFormat.setInputPaths(job,new Path("E:\\wcinput"));
        FileOutputFormat.setOutputPath(job,new Path("E:\\wcoutput"));
        // 输出文件夹会自己创建，不要自己提前创建，否则会报错

        // 提交Job
        // 参数代表是否监控提交过程
        job.waitForCompletion(true);
    }
}

注意：驱动类中这里选择的是第一个！！！

在这里插入图片描述

1.7.4 测试

本地测试的话，运行 WordCountDriver.java 即可。主要来讲讲在 Hadoop集群测试

（1）修改 WordCountDriver.java 代码

在这里插入图片描述

（2）将该 maven 模块打成 jar 包

在这里插入图片描述

不懂 Maven 的可以参考 Java Web 学习笔记（三） —— Maven 基础

（3）将打好的 jar 包上传到 /opt/module/hadoop-3.1.3/下
（4）开启 hadoop 集群，并将 wcinput/hello.txt上传到 HDFS
（5）执行程序

[huwei@hadoop101 hadoop-3.1.3]$ hadoop jar mapreduce-1.0-SNAPSHOT.jar com.huwei.mr.WordCountDriver /wcinput /wcoutput

com.huwei.mr.WordCountDriver 驱动类的全限类名，快速复制的方法如下

在这里插入图片描述
（6）查看结果

Web端查看YARN ：http://hadoop102:8088

在这里插入图片描述

Web端查看 HDFS：http://hadoop101:9870

在这里插入图片描述

2 MapReduce 序列化

2.1 序列化概述

序列化 就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。

反序列化 就是将收到的字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。

为什么要序列化呢？

一般来说，“活”的对象只生存在内存里，关机断电就没有了，而且“活”的对象只能由本地的进程使用，不能被发送到网络上的另一台计算机，然而序列化可以存储“活”的对象，可以将“活”的对象发送到远程计算机。

为什么不用Java的序列化呢？

Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息、Header，继承体系等），不便于在网络中高效的传输。所以，Hadoop自己开发了一套序列化机制（Writable）。

Hadoop序列化的特点：

紧凑：高效使用存储空间
快速：读写数据的额外开销小
可扩展：随着通信协议的升级而可以升级
互操作：支持多语言的交互

2.2 自定义bean对象实现序列化接口（Writable）

在企业开发中往往常用的基本序列化类型不能满足所有需求，比如在Hadoop框架内部传递一个bean对象，那么该对象就需要实现序列化接口。

具体实现bean对象序列化步骤如下：

（1）必须实现 Writable 接口

（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造

public FlowBean() {
	super();
}

（3）重写序列化方法

@Override
public void write(DataOutput out) throws IOException {
	out.writeLong(upFlow);
	out.writeLong(downFlow);
	out.writeLong(sumFlow);
}

（4）重写反序列化方法

@Override
public void readFields(DataInput in) throws IOException {
	upFlow = in.readLong();
	downFlow = in.readLong();
	sumFlow = in.readLong();
}

注意反序列化的顺序和序列化的顺序完全一致

（5）要想把结果显示在文件中，需要重写 toString()，可用\t分开，方便后续用。

（6）如果需要将自定义的 bean 放在 key 中传输，则还需要实现 Comparable 接口，因为 MapReduce 框架中的 Shuffle 过程要求对 key 必须能排序。

@Override
public int compareTo(FlowBean o) {
	// 倒序排列，从大到小
	return this.sumFlow > o.getSumFlow() ? -1 : 1;
}

2.3 序列化案例实操

2.3.1 案例需求

统计 phone_data.txt 中每一个手机号耗费的总上行流量、总下行流量、总流量。

phone_data.txt

1	13736230513	192.196.100.1	www.bala.com	2481	24681	200
2	13846544121	192.196.100.2			264	0	200
3 	13956435636	192.196.100.3			132	1512	200
4 	13966251146	192.168.100.1			240	0	404
5 	18271575951	192.168.100.2	www.bala.com	1527	2106	200
6 	84188413	192.168.100.3	www.bala.com	4116	1432	200
7 	13590439668	192.168.100.4			1116	954	200
8 	15910133277	192.168.100.5	www.hao123.com	3156	2936	200
9 	13729199489	192.168.100.6			240	0	200
10 	13630577991	192.168.100.7	www.shouhu.com	6960	690	200
11 	15043685818	192.168.100.8	www.baidu.com	3659	3538	200
12 	15959002129	192.168.100.9	www.bala.com	1938	180	500
13 	13560439638	192.168.100.10			918	4938	200
14 	13470253144	192.168.100.11			180	180	200
15 	13682846555	192.168.100.12	www.qq.com	1938	2910	200
16 	13992314666	192.168.100.13	www.gaga.com	3008	3720	200
17 	13509468723	192.168.100.14	www.qinghua.com	7335	110349	404
18 	18390173782	192.168.100.15	www.sogou.com	9531	2412	200
19 	13975057813	192.168.100.16	www.baidu.com	11058	48243	200
20 	13768778790	192.168.100.17			120	120	200
21 	13568436656	192.168.100.18	www.alibaba.com	2481	24681	200
22 	13568436656	192.168.100.19			1116	954	200

输入数据格式：

7 	 13560436666	  120.196.100.99		1116		 954			200
id	 手机号码		  网络ip			    上行流量      下行流量        网络状态码

期望输出数据格式：

13560436666 	1116		   954 			 2070
手机号码		    上行流量        下行流量		 总流量

2.3.2 编写程序

自定义 bean 对象 FlowBean.java

public class FlowBean implements Writable {

    private Integer upFlow;
    private Integer downFlow;
    private Integer sumFlow;

    // 默认有无参构造方法

    public Integer getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(Integer upFlow) {
        this.upFlow = upFlow;
    }

    public Integer getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(Integer downFlow) {
        this.downFlow = downFlow;
    }

    public Integer getSumFlow() {
        return sumFlow;
    }

    public void setSumFlow(Integer sumFlow) {
        this.sumFlow = sumFlow;
    }

    @Override
    public String toString() {
        return "FlowBean{" +
                "upFlow=" + upFlow +
                ", downFlow=" + downFlow +
                ", sumFlow=" + sumFlow +
                '}';
    }

    /**
     * 序列化方法
     */
    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeInt(upFlow);
        dataOutput.writeInt(downFlow);
        dataOutput.writeInt(sumFlow);
    }

    /**
     * 反序列化方法
     * （顺序要和序列化方法一致）
     */
    @Override
    public void readFields(DataInput dataInput) throws IOException {
        upFlow = dataInput.readInt();
        downFlow = dataInput.readInt();
        sumFlow = dataInput.readInt();
    }

    // 计算上下行流量之和
    public void setSumFlow() {
        this.sumFlow = this.upFlow + this.downFlow;
    }
}

FlowMapper.java

/**
 * 输入数据的类型
 * KEYIN, 读取文件的偏移量 数字（LongWritable）
 * VALUEIN, 读取文件的一行数据 文本（Text）
 * 输出数据的类型
 * KEYOUT, 输出数据 key 的形式 手机号码（Text）
 * VALUEOUT, 输出数据 value 的形式 FlowBean对象
 */
public class FlowMapper extends Mapper<LongWritable, Text, Text, FlowBean> {
    private Text outk = new Text();
    private FlowBean outv = new FlowBean();

    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        // 获取输入的当前行数据
        String line = value.toString();
        // 切割数据
        String[] datas = line.split("\t");
        // 获取输出数据的key（手机号）
        outk.set(datas[1]);
        // 获取输出数据的value（FlowBean对象）
        outv.setUpFlow(Integer.parseInt(datas[datas.length-3]));
        outv.setDownFlow(Integer.parseInt(datas[datas.length-2]));
        outv.setSumFlow();
        // 将数据输出
        context.write(outk,outv);

    }
}

FlowReducer.java

public class FlowReducer extends Reducer<Text, FlowBean, Text, FlowBean> {
    private Text outk = new Text();
    private FlowBean outv = new FlowBean();

    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Reducer<Text, FlowBean, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        // 遍历当前一组相同的key的values
        int totalUpFlow = 0;
        int totalDownFlow = 0;
        // int totalSumFlow = 0;
        for (FlowBean value : values) {
            totalUpFlow += value.getUpFlow();
            totalDownFlow += value.getDownFlow();
            //totalSumFlow += value.getSumFlow();
        }
        // 封装key和value
        outk.set(key);
        outv.setUpFlow(totalUpFlow);
        outv.setDownFlow(totalDownFlow);
        //outv.setSumFlow(totalSumFlow);
        outv.setSumFlow();
        context.write(outk, outv);


    }
}

FlowDriver.java

public class FlowDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        // 声明配置对象
        Configuration conf = new Configuration();
        // 声明Job对象
        Job job = Job.getInstance(conf);

        // 指定当前Job的驱动类
        job.setJarByClass(FlowDriver.class);
        // 指定当前Job的Mapper
        job.setMapperClass(FlowMapper.class);
        // 指定当前Job的Reducer
        job.setReducerClass(FlowReducer.class);

        // 指定Map端输出数据的key的类型和输出数据value的类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);
        // 指定最终（Reduce端）输出数据的key的类型和输出数据value的类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        FileInputFormat.setInputPaths(job, new Path("E:\\hadoop\\in\\phone_data.txt"));
        FileOutputFormat.setOutputPath(job, new Path("E:\\hadoop\\out\\phone_data_out"));

        // 提交Job
        job.waitForCompletion(true);
    }
}

夏木夕

关注

24
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
大数据技术学习笔记（五）—— MapReduce（1）

MapReduce 是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。MapReduce 核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并行运行在一个Hadoop集群上。序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。反序列化就是将收到的字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。为什么要序列化呢？
复制链接

扫一扫

专栏目录