概述
MapReduce是一个分布式运算程序的编程框架, 是用户开发 “基于Hadoop的数据分析应用” 的核心框架。其核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序, 并发运行在一个Hadoop集群上。
优点
易于编程
良好的扩展性
高容错性
适合PB级以上海量数据的离线处理
缺点
不擅长实时计算
不擅长流式计算
不擅长DAG (有向图) 计算
MapReduce核心思想
需求：统计其中每一个单词出现的总次数 (查询结果：a-p一个文件，q-z一个文件)
1）分布式的运算程序往往需要分成至少2个阶段。
2）第一个阶段的MapTask并发实例，完全并行运行，互不相干。
3）第二个阶段的ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。
4）MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个MapReduce程序，串行运行。
MapReduce进程
一个完整的MapReduce程序在分布式运行时有三类实例进程
- MapReduceApplicationMaster : 负责整个程序的过程调度及状态协调
- MapTask : 负责Map阶段的整个数据处理流程
- ReduceTask : 负责Reduce阶段的整个数据处理流程
常用数据序列化类型
| Java类型 | Hadoop Writable类型 |
|---|---|
| Boolean | BooleanWritable |
| Byte | ByteWritable |
| Int | IntWritable |
| Float | FloatWritable |
| Long | LongWritable |
| Double | DoubleWritable |
| String | Text |
| Map | MapWritable |
| Array | ArrayWritable |
MapReduce编程规范
1．Mapper阶段
（1）用户自定义的Mapper要继承自己的父类
（2）Mapper的输入数据是KV对的形式（KV的类型可自定义）
（3）Mapper中的业务逻辑写在map()方法中
（4）Mapper的输出数据是KV对的形式（KV的类型可自定义）
（5）map()方法（MapTask进程）对每一个<K,V>调用一次
2．Reducer阶段
（1）用户自定义的Reducer要继承自己的父类
（2）Reducer的输入数据类型对应Mapper的输出数据类型，也是KV
（3）Reducer的业务逻辑写在reduce()方法中
（4）ReduceTask进程对每一组相同k的<k,v>组调用一次reduce()方法
3．Driver阶段
相当于YARN集群的客户端，用于提交我们整个程序到YARN集群，提交的是封装了MapReduce程序相关运行参数的job对象
WordCount案例
需求 : 在给定的文本文件中统计输出每一个单词出现的总次数
| 输入数据 | 期望输出数据 |
|---|---|
| java java abc abc hello hadoop hello mr java test | abc 2 hadoop 1 hello 2 java 3 mr 1 test 1 |
- 环境准备
(1) 创建Maven工程
(2) 添加依赖
junit
junit
4.12
org.apache.logging.log4j
log4j-slf4j-impl
2.12.0
org.apache.hadoop
hadoop-client
3.1.3
（2）在项目的src/main/resources目录下，新建一个文件，命名为“log4j2.xml”，在文件中填入。
<Loggers>
<!-- 可加性为false -->
<Logger name="test" level="info" additivity="false">
<AppenderRef ref="STDOUT" />
</Logger>
<!-- root loggerConfig设置 -->
<Root level="info">
<AppenderRef ref="STDOUT" />
</Root>
</Loggers>
import java.io.IOException;
// 1. 自定义类继承Mapper类
// 2. 定义输入/输出K-V泛型
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
// 输出的K
Text outK = new Text();
// 输出的V
IntWritable outV = new IntWritable();
// 2. 重写map()方法
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
// 获取一行数据
String line = value.toString();
// 切割
String[] words = line.split(" ");
// 封装K-V 并输出
for (String word : words) {
outK.set(word);
outV.set(1);
context.write(outK, outV);
}
}
}
(2) 编写Reducer类
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
// 1. 自定义类继承Reducer
// 2. 定义输入/输出K-V泛型
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
int sum ;
// 输出的V
IntWritable outV = new IntWritable();
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
// 累加求和
sum = 0;
for (IntWritable value : values) {
sum += value.get();
}
// 封装K-V 并输出
outV.set(sum);
context.write(key, outV);
}
}
(3) 编写Driver类
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. 获取配置信息及封装任务
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. 设置Mapper输出类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
// 5. 设置最终输出类型
job.setOutputKeyClass(Text.class);
// 6. 设置输入/输出路径
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
// 7. 提交
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
(4) 本地测试
需要首先配置好HadoopHome变量以及Windows运行依赖。
在Idea上配置好args参数, 运行程序。
(5) 集群上测试
用Maven打jar包, 如果有需要一并打进去的依赖, 需要添加打包插件
maven-compiler-plugin
2.3.2
1.8
1.8
maven-assembly-plugin
jar-with-dependencies
工程自定义Driver类的全类名
make-assembly
package
single
将程序打成jar包, 拷贝到Hadoop集群中。
启动Hadoop集群。
执行自定义的WordCount程序
(6) 在Windows上向集群提交任务
需在Driver类中添加必要的配置信息
public class WordcountDriver {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
// 1 获取配置信息以及封装任务
Configuration configuration = new Configuration();
//设置HDFS NameNode的地址
configuration.set("fs.defaultFS", "hdfs://node01:8020");
// 指定MapReduce运行在Yarn上
configuration.set("mapreduce.framework.name","yarn");
// 指定mapreduce可以在远程集群运行
configuration.set("mapreduce.app-submission.cross-platform","true");
//指定Yarn resourcemanager的位置
configuration.set("yarn.resourcemanager.hostname","node02");
Job job = Job.getInstance(configuration);
// 2 设置jar加载路径
job.setJarByClass(WordcountDriver.class);
// 3 设置map和reduce类
job.setMapperClass(WordcountMapper.class);
job.setReducerClass(WordcountReducer.class);
// 4 设置map输出
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
// 5 设置最终输出kv类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
// 6 设置输入和输出路径
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
// 7 提交
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
先进行打包, 并将打好的jar包设置到Driver中, 集群中运行需要制定jar包。
// 2 设置jar加载路径
job.setJarByClass(“D:\input\MapReduce-1.0-SNAPSHOT.jar”);
编辑任务配置
VM options : 指定操作集群的用户为user01
_DHADOOP_USER_NAME=user01
Program arguments : 指定输入/输出路径
hdfs://node01:9820/README.txt hdfs://node01:9820/output
提交并在集群查看结果
Hadoop序列化
序列化概述
序列化就是把内存中的对象, 转换成字节序列 (或其他数据传输协议) 以便于存储到磁盘 (持久化) 和网络传输。
反序列化就是将受到字节序列 (或其他数据传输协议) 或者是磁盘的持久化数据, 转换成内存中的对象。
Hadoop开发了自己的一套轻量级的序列化机制 (Writable), 以便于在网络中高效传输。
特点 : 紧凑 : 高效实用存储空间。
快速 : 读写数据的额外开销小。
可扩展性 : 随着通信协议的升级而升级。
互操作 : 支持多语言的交互。
自定义bean对象实现序列化接口
步骤
1. 自定义Bean类实现Writable接口。
2. 反序列化时，需要反射调用空参构造函数，所以必须有空参构造器。
3. 重写序列化方法。
4. 重写反序列化方法。
5. 注意反序列化的顺序和序列化的顺序完全一致
6. 要想把结果显示在文件中，需要重写toString()。
7. 如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为MapReduce框中的Shuffle过程要求对key必须能排序。
案例
需求 : 统计每一个手机号耗费的总上行流量、下行流量、总流量。
输入数据
1 13736230513 192.196.100.1 www.atguigu.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.atguigu.com 1527 2106 200
6 84188413 192.168.100.3 www.atguigu.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.atguigu.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
手机号码 上行流量 下行流量 总流量
(1) 编写流量统计的Bean对象
import org.apache.hadoop.io.Writable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
// 1. 自定义Bean实现Writable接口
public class FlowBean implements Writable {
private long upFlow; // 上行流量
private long downFlow; // 下行流量
private long sumFlow; // 总流量
// 2. 空参构造器
public FlowBean() {
super();
}
public FlowBean(long upFlow, long downFlow) {
this.upFlow = upFlow;
this.downFlow = downFlow;
}
// 3. 重写序列化方法
public void write(DataOutput out) throws IOException {
out.writeLong(upFlow);
out.writeLong(downFlow);
out.writeLong(sumFlow);
}
// 4. 重写反序列化方法
public void readFields(DataInput in) throws IOException {
this.upFlow = in.readLong();
this.downFlow = in.readLong();
this.sumFlow = in.readLong();
}
// 5. 重写toString()方法
@Override
public String toString() {
return upFlow + "\t" + downFlow + "\t" + sumFlow;
}
public long getUpFlow() {
return upFlow;
}
public void setUpFlow(long upFlow) {
this.upFlow = upFlow;
}
public long getDownFlow() {
return downFlow;
}
public void setDownFlow(long downFlow) {
this.downFlow = downFlow;
}
public long getSumFlow() {
return sumFlow;
}
public void setSumFlow(long sumFlow) {
this.sumFlow = sumFlow;
}
}
(2) 编写Mapper类
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/**
-
@author lofe
-
@create 2020-05-17 16:36
*/
public class FlowCountMapper extends Mapper<LongWritable, Text, Text, FlowBean> {
Text outK = new Text(); // 输出K
FlowBean outV = new FlowBean(); // 输出的V@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
// 1. 获取一行数据
String line = value.toString();
// 2. 切割字段
String[] fields = line.split("\t");
// 3. 封装对象
// 取出手机号
String phoneNum = fields[1];
// 取出上行流量
long upFlow = Long.parseLong(fields[fields.length-3]);
// 取出下行流量
long downFlow = Long.parseLong(fields[fields.length-2]);
// 封装
outK.set(phoneNum);
outV.setDownFlow(downFlow);
outV.setUpFlow(upFlow);
// 4. 写出
context.write(outK, outV);}
}
(3) 编写Reducer类
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/**
- @author lofe
- @create 2020-05-17 16:37
*/
public class FlowCountReducer extends Reducer<Text, FlowBean, Text, FlowBean> {
@Override
protected void reduce(Text key, Iterable values, Context context) throws IOException, InterruptedException {
long sum_upFlow = 0;
long sum_downFlow = 0;
// 1. 遍历所有bean, 将其中的上行流量, 下行流量分别累加汇总
for (FlowBean value : values) {
sum_upFlow += value.getUpFlow();
sum_downFlow += value.getDownFlow();
}
// 2. 封装对象
FlowBean resultBean = new FlowBean(sum_upFlow, sum_downFlow);
// 3. 写出
context.write(key, resultBean);
}
}
(4) 编写Driver类
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
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 FlowCountDriver {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
// 1 获取配置信息，或者job对象实例
Configuration configuration = new Configuration();
Job job = Job.getInstance(configuration);
// 6 指定本程序的jar包所在的本地路径
job.setJarByClass(FlowCountDriver.class);
// 2 指定本业务job要使用的mapper/Reducer业务类
job.setMapperClass(FlowCountMapper.class);
job.setReducerClass(FlowCountReducer.class);
// 3 指定mapper输出数据的kv类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(FlowBean.class);
// 4 指定最终输出的数据的kv类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(FlowBean.class);
// 5 指定job的输入原始文件所在目录
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
// 7 将job中配置的相关参数，以及job所用的java类所在的jar包， 提交给yarn去运行
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
MapReduce框架原理
InputFormat数据输入
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
