第1章MapReduce概述
1.1 MapReduce定义
MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。
MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。
1.2 MapReduce优缺点
1.2.1 优点
MapReduce易于编程
它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。
良好的扩展性
当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。
高容错性
MapReduce设计的初衷就是使程序能够部署在廉价的PC机器上，这就要求它具有很高的容错性。比如其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上运行，不至于这个任务运行失败，而且这个过程不需要人工参与，而完全是由Hadoop内部完成的。
适合PB级以上海量数据的离线处理
可以实现上千台服务器集群并发工作，提供数据处理能力。
1.2.2 缺点
不擅长实时计算
MapReduce无法像MySQL一样，在毫秒或者秒级内返回结果。
不擅长流式计算
流式计算的输入数据是动态的，而MapReduce的输入数据集是静态的，不能动态变化。这是因为MapReduce自身的设计特点决定了数据源必须是静态的。
不擅长DAG（有向无环图）计算
多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce并不是不能做，而是使用后，每个MapReduce作业的输出结果都会写入到磁盘，会造成大量的磁盘IO，导致性能非常的低下。
1.3 MapReduce进程
一个完整的MapReduce程序在分布式运行时有三类实例进程：
（1）MrAppMaster：负责整个程序的过程调度及状态协调。
（2）MapTask：负责Map阶段的整个数据处理流程。
（3）ReduceTask：负责Reduce阶段的整个数据处理流程。
1.4 常用数据序列化类型
Java类型 |
Hadoop Writable类型 |
Boolean |
BooleanWritable |
Byte |
ByteWritable |
Int |
IntWritable |
Float |
FloatWritable |
Long |
LongWritable |
Double |
DoubleWritable |
String |
Text |
Map |
MapWritable |
Array |
ArrayWritable |
Null |
NullWritable |
1.5 MapReduce编程规范
用户编写的程序分成三个部分：Mapper、Reducer和Driver。
Mapper阶段
（1） 用户自定义的Mapper要继承自己的父类
（2） Mapper的输入数据是KV对的形式 (KV的类型可自定义)
（3） Mapper中的业务逻辑写在map()方法中
（4） Mapper的输出数据是KV对的形式(KV的类型可自定义）
（5） map()方法(MapTask进程) 对每一个<KV>调用一次
Reducer阶段
（1） 用户自定义的Reducer要继承自己的父类
（2） Reducer的输入数据类型对应Mapper的输出数据类型，也是KV
（3） Reducer的业务逻辑写在reduce0方法中
（4） ReduceTask进程对每一组相同k的<k,v>组调用一次reduce()方法
Driver阶段
相当于YARN集群的客户端，用于提交我们整个程序到YARN集群，提交的是封装了MapReduce程序相关运行参数的iob对象
1.6 WordCount案例实操
1.6.1 本地测试
环境准备
（1）创建maven工程，MapReduceDemo
（2）在pom.xml文件中添加如下依赖
<dependencies>
<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>
</dependencies>（3）在项目的src/main/resources目录下，新建一个文件，命名为“log4j.properties”，在文件中填入。
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（4）创建包名：com.atguigu.mapreduce.wordcount
编写程序
（1）编写Mapper类
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/**
* Mapper阶段会运行 MapTask. MapTask 会调用 Mapper 类
* 作用：
* 在该类中实现需要在 MapTask 中实现的业务逻辑代码
*
* public class Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> :
* 第一组泛型:
* KEYIN : 读取数据时的偏移量的类型
* VALUEIN : 读取的一行一行的数据类型
* 第二组泛型:
* KEYOUT : 写出的key 的类型（在这里是单词的类型）
* VALUEOUT : 写出的 value 的类型 （单词的个数）
*
*/
public class WCMapper extends Mapper<LongWritable, Text, Text, LongWritable> {
// 3.1 创建key 的对象
private Text outKey = new Text();
// 3.2 创建 value 的对象
private LongWritable outValue = new LongWritable();
/**
* 1. 在 map 方法中实现需要在MapTask中实现的业务逻辑代码
* 2. 该方法在被循环调用，每调用一次传入一行数据
* @param key 读取数据时的偏移量
* @param value 读取的数据 （一行一行的数据）
* @param context 上下文（在这用来将key, value 写出去）
* @throws IOException
* @throws InterruptedException
*/
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, LongWritable>.Context context) throws IOException, InterruptedException {
// super.map(key, value, context);
// 1. 将数据 进行切割
// 1.1 将Text 转成 String ---- 为了使用String API进行处理
String line = value.toString();
// 1.2 切割数据
String[] words = line.split(" ");
// 2. 遍历数据
for (String word : words) {
// 3. 封装 key, value
// 3.3 赋值
outKey.set(word);
outValue.set(1);
// 4. 将key, value 写出去
context.write(outKey, outValue);
}
}
}（2）编写Reducer类
import java.io.IOException;
/**
* Reduce阶段会运行 ReduceTask. ReduceTask 会调用 Reducer 类
* 作用：
* 在该类中实现需要在 ReduceTask 中实现的业务逻辑代码
*
* public class Reducer<KEYIN, VALUEIN, KEYOUT, VALUEOUT> :
* 第一组泛型:
* KEYIN : 读取的key的类型 (Mapper 写出的 key 类型)
* VALUEIN : 读取的 value 的类型 (Mapper 写出的 value 类型)
* 第二组泛型:
* KEYOUT : 写出的 key 的类型（在这里是单词的类型）
* VALUEOUT : 写出的 value 的类型 （单词的个数）
*/
public class WCReducer extends Reducer<Text, LongWritable, Text, LongWritable> {
private LongWritable outValue = new LongWritable();
/**
* 1. 在 reduce 方法中实现需要在ReduceTask中实现的业务逻辑代码
* 2. 该方法在被循环调用，每调用一次传入一行数据 (key 值相同为一组)
* @param key 读取的key
* @param values 读取的所有的 value
* @param context 上下文（在这用来将 key, value 写出去）
* @throws IOException
* @throws InterruptedException
*/
@Override
protected void reduce(Text key, Iterable<LongWritable> values, Reducer<Text, LongWritable, Text, LongWritable>.Context context) throws IOException, InterruptedException {
// super.reduce(key, values, context);
long sum = 0;
// 1. 遍历所有的value
// Iterator<LongWritable> iterator = values.iterator(); // 通过 iterator 进行遍历
for (LongWritable value : values) {
// 将 LongWritable 转成 long
long v = value.get();
// 2. 对 value 进行累加
sum += v;
}
// 3. 封装 key, value
// 给value 赋值
outValue.set(sum);
// 4. 将 key, value 写出去
context.write(key, outValue);
}
}（3）编写Driver驱动类
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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;
/**
* 程序的入口
* 1. 创建 Job 实例并运行
*/
public class WCDriver {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
// 1. 创建 Job 实例
//public static Job getInstance(Configuration conf)
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
// 2. 给 Job 赋值
// 2.1 关联本程序的 Jar —— 如果是本地可以不写； 如果在集群上运行，必须写
job.setJarByClass(WCDriver.class);
// 2.2 设置Mapper 和Reducer 类
job.setMapperClass(WCMapper.class);
job.setReducerClass(WCReducer.class);
// 2.3 设置 Mapper 输出的 key, value 的类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
// 2.4 设置最终输出的 key., value的类型（在这里是reducer 输出的 key, value 的类型）
job.setOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
// 2.5 设置输入和输出路径
FileInputFormat.setInputPaths(job, new Path("E:\\io\\input\\hello.txt"));
// 输出路径一定不能存在 否则报错
FileOutputFormat.setOutputPath(job, new Path("E:\\io\\output2"));
// 3. 运行 Job
/*
@param verbose print the progress to the user
@return true if the job succeeded
*/
boolean b = job.waitForCompletion(true);
System.out.println("b====" + b);
}
}3）本地测试
（1）需要首先配置好HADOOP_HOME变量以及Windows运行依赖
（2）在IDEA/Eclipse上运行程序
1.6.2 提交到集群测试
1）集群上测试
（1）用maven打jar包，需要添加的打包插件依赖
<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>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
注意：如果工程上显示红叉。在项目上右键->maven->Reimport刷新即可。
（2）将程序打成jar包
/**
* 程序的入口
* Job 在集群上运行
* 1、将输入和输出路径通过 main 方法传参的方式传入
* 2、打包
* 3、将 jar包上传到集群上
* 4。 执行命令：
* hadoop jar xxx.jar 全类名 输入路径 输出路径
* 案例 hadoop jar MRDemo-1.0-SNAPSHOT.jar com.atguigu.mr.wordcount.WCDriver2 /input/hello.txt /output
*/
public class WCDriver2 {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
//public static Job getInstance(Configuration conf)
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
job.setJarByClass(WCDriver2.class);
job.setMapperClass(WCMapper.class);
job.setReducerClass(WCReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
job.setOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
//将输入和输出路径通过 main 方法传参的方式传入
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
boolean b = job.waitForCompletion(true);
System.out.println("b====" + b);
}
}（3）修改不带依赖的jar包名称为wc.jar，并拷贝该jar包到Hadoop集群的/opt/module/hadoop-3.1.3路径。
（4）启动Hadoop集群
[atguigu@hadoop102 hadoop-3.1.3]$ hadoop jar wc.jar com.atguigu.mapreduce.wordcount.WordCountDriver /user/atguigu/input /user/atguigu/output 1.6.3 在Windows上向集群提交任务
（1）添加必要配置信息
/**
* 从本地像集群提交 Job
* 1. 配置参数
* //设置在集群运行的相关参数-设置HDFS,NAMENODE的地址
* conf.set("fs.defaultFS", "hdfs://hadoop102:8020");
* //指定MR运行在Yarn上
* conf.set("mapreduce.framework.name","yarn");
* //指定MR可以在远程集群运行
* conf.set("mapreduce.app-submission.cross-platform", "true");
* //指定yarn resourcemanager的位置
* conf.set("yarn.resourcemanager.hostname", "hadoop103");
* 2、 打包
* 3、 将下面的代码注释掉
* // job.setJarByClass(WCDriver3.class);
* 添加如下代码
* job.setJar("jar包路径");
* 4.
* VM Options ： -DHADOOP_USER_NAME=atguigu
* program Argumnets : hdfs://hadoop102:8020/input hdfs://hadoop102:8020/output6
*/
public class WCDriver3 {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
//public static Job getInstance(Configuration conf)
Configuration conf = new Configuration();
//设置在集群运行的相关参数-设置HDFS,NAMENODE的地址
conf.set("fs.defaultFS", "hdfs://hadoop102:8020");
//指定MR运行在Yarn上
conf.set("mapreduce.framework.name","yarn");
//指定MR可以在远程集群运行
conf.set("mapreduce.app-submission.cross-platform", "true");
//指定yarn resourcemanager的位置
conf.set("yarn.resourcemanager.hostname", "hadoop103");
Job job = Job.getInstance(conf);
// 打完包再注释
// job.setJarByClass(WCDriver3.class);
job.setJar("E:\\DK\\Codes\\IdeaProject\\MRDemo\\target\\MRDemo-1.0-SNAPSHOT.jar");
job.setMapperClass(WCMapper.class);
job.setReducerClass(WCReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
job.setOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
boolean b = job.waitForCompletion(true);
System.out.println("b====" + b);
}
}第2章Hadoop序列化
2.1 序列化概述
1）什么是序列化
序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。
反序列化就是将收到字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。
2）为什么要序列化
一般来说，“活的”对象只生存在内存里，关机断电就没有了。而且“活的”对象只能由本地的进程使用，不能被发送到网络上的另外一台计算机。然而序列化可以存储“活的”对象，可以将“活的”对象发送到远程计算机。
3）为什么不用Java的序列化
Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，Header，继承体系等），不便于在网络中高效传输。所以，Hadoop自己开发了一套序列化机制（Writable）。
4）Hadoop序列化特点
紧凑：高效使用存储空间。
快速：读写数据的额外开销小。
互操作：支持多语言的交互
2.2 自定义bean对象实现序列化接口（Writable）
在企业开发中往往常用的基本序列化类型不能满足所有需求，比如在Hadoop框架内部传递一个bean对象，那么该对象就需要实现序列化接口。
具体实现bean对象序列化步骤如下7步:
必须实现Writable接口
反序列化时，需要反射调用空参构造函数，所以必须有空参构造
重写序列化方法
重写反序列化方法
注意反序列化的顺序和序列化的顺序完全一致。
要想把结果显示在文件中，需要重写toString()，可用"\t"分开，方便后续用。
如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为MapReduce框中的Shuffle过程要求对key必须能排序。
/*
JavaBean :
1. 自定义类并实现 Writable接口
2. 重写 write 和 readFields方法
*/
public class FlowBean implements Writable {
private long upFlow;
private long downFlow;
private long sumFlow;
public FlowBean() {
}
/*
序列化时调用该方法
*/
@Override
public void write(DataOutput dataOutput) throws IOException {
dataOutput.writeLong(upFlow);
dataOutput.writeLong(downFlow);
dataOutput.writeLong(sumFlow);
}
@Override
public String toString() {
return upFlow + " " + downFlow + " " + sumFlow;
}
/*
反序列化时调用该方法
注意： 反序列化时的顺序和序列化的顺序要保持一致
*/
@Override
public void readFields(DataInput dataInput) throws IOException {
upFlow = dataInput.readLong();
downFlow = dataInput.readLong();
sumFlow = dataInput.readLong();
}
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;
}
}其他类不用修改，只需修改输入输出的类型。
第3章MapReduce框架原理
3.1 InputFormat数据输入
3.1.1 切片与MapTask并行度决定机制
1）MapTask并行度决定机制
数据块：Block是HDFS物理上把数据分成一块一块。数据块是HDFS存储数据单位。
数据切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。数据切片是MapReduce程序计算输入数据的单位，一个切片会对应启动一个MapTask。
3.1.2 Job提交流程源码详解
Job提交流程源码详解
waitForCompletion()
submit();
// 1建立连接
connect();
// 1）创建提交Job的代理
new Cluster(getConfiguration());
// （1）判断是本地运行环境还是yarn集群运行环境
initialize(jobTrackAddr, conf);
// 2 提交job
submitter.submitJobInternal(Job.this, cluster)
// 1）创建给集群提交数据的Stag路径
Path jobStagingArea = JobSubmissionFiles.getStagingDir(cluster, conf);
// 2）获取jobid ，并创建Job路径
JobID jobId = submitClient.getNewJobID();
// 3）拷贝jar包到集群
copyAndConfigureFiles(job, submitJobDir);
rUploader.uploadFiles(job, jobSubmitDir);
// 4）计算切片，生成切片规划文件
writeSplits(job, submitJobDir);
maps = writeNewSplits(job, jobSubmitDir);
input.getSplits(job);
// 5）向Stag路径写XML配置文件
writeConf(conf, submitJobFile);
conf.writeXml(out);
// 6）提交Job,返回提交状态
status = submitClient.submitJob(jobId, submitJobDir.toString(), job.getCredentials());3.1.3 FileInputFormat切片机制以及源码解析（input.getSplits(job)）
FileInputFormat切片机制的源码解析
一 InputFromat的继承树
|----InputFormat
|------FileInputFormat
|------TextInputFormat
二 InputFormat（抽象类）
/*
用来生成切片信息
*/
public abstract
List<InputSplit> getSplits(JobContext context
) throws IOException, InterruptedException;
/*
用来创建RecordReader对象。RecordReader是用来读取数据的。
*/
public abstract
RecordReader<K,V> createRecordReader(InputSplit split,
TaskAttemptContext context
) throws IOException,
InterruptedException;
三 FileInputFormat（抽象类）
重写了getSplits方法。
四 TextInputFormat（默认使用的InputFormat）
/*
1.重写了createRecordReader方法
2.在createRecordReader方法中返回了LineRecordReader。LineRecordReader真正用来读取数据的类
3.RecordReader是一个抽象类。LineRecordReader是RecordReader的子类
*/
@Override
public RecordReader<LongWritable, Text>
createRecordReader(InputSplit split,
TaskAttemptContext context) {
return new LineRecordReader(recordDelimiterBytes);
} （1） 程序先找到你数据存储的目录。
（2） 开始遍历处理 (规划切片) 目录下的每一个文件。
（3） 遍历第一个文件ss.txt
获取文件大小fs.sizeOf(ss.txt)
计算切片大
computeSplitSize(Math.max(minSize,Math.min(maxSize,blocksize)))=blocksize=128M
默认情况下，切片大小=blocksize
开始切，形成第1个切片: ss.txt-0:128M;第2个切片ss.txt-128:256M; 第3个切片ss.txt-256M:300M。
(每次切片时，都要判断切完剩下的部分是否大于块的1.1倍，不大于1.1倍就划分一块切片)
将切片信息写到一个切片规划文件中。
整个切片的核心过程在getSplit()方法中完成。
InputSplit只记录了切片的元数据信息，比如起始位置、长度以及所在的节点列表等。
（3） 提交切片规划文件到YARN上，YARN上的MrAppMaster就可以根据切片规划文件计算开启MapTask个数。
FileInputFormat切片大小的参数配置
（1） 源码中计算切片大小的公式
Math.max(minSize, Math.min(maxSize, blockSize));
mapreduce.input.fileinputformat.split.minsize=1 默认值为1
mapreduce.input.fileinputformat.split.maxsize= Long.MAXValue 默认值LongMAXValue
因此，默认情况下，切片大小=blocksize。
（2） 切片大小设置
maxsize (切片最大值) : 参数如果调得比blockSize小，则会让切片变小，而且就等于配置的这个参数的值。
minsize (切片最小值) : 参数调的比blockSize大，则可以让切片变得比blockSize还大。
（3）获取切片信息API
//根据文件类型获取切片信息
FileSplit inputSplit= (FileSplit) context.getInputSplit();
//获取切片的文件名称
String name = inputSplit.getPath().getName();3.1.4 TextInputFormat
TextInputFormat
TextInputFormat是默认的FileInputFormat实现类。按行读取每条记录。
key是存储该行在整个文件中的起始字节偏移量， LongWritable类型。
value是这行的内容，不包括任何行终止符（换行符和回车符），Text类型。
示例：
一个分片包含了如下4条文本记录：
Rich learning form
Intelligent learning engine
Learning more convenient
From the real demand for more close to the enterprise每条记录表示为以下键/值对：
(0,Rich learning form)
(20,Intelligent learning engine)
(49,Learning more convenient)
(74,From the real demand for more close to the enterprise)3.1.5 CombineTextInputFormat切片机制
框架默认的TextInputFormat切片机制是对任务按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个MapTask，这样如果有大量小文件，就会产生大量的MapTask，处理效率极其低下。
1）应用场景
CombineTextInputFormat用于小文件过多的场景，它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个MapTask处理。
2）虚拟存储切片最大值设置
CombineTextInputFormat.setMaxInputSplitSize(job,4194304);// 4m
注意：虚拟存储切片最大值设置最好根据实际的小文件大小情况来设置具体的值。
3）切片机制
生成切片过程包括：虚拟存储过程和切片过程二部分。
虚拟存储过程：
将输入目录下所有文件大小，依次和设置的setMaxInputSplitSize值比较，如果不大于设置的最大值，逻辑上划分一个块。如果输入文件大于设置的最大值且大于两倍，那么以最大值切割一块；当剩余数据大小超过设置的最大值且不大于最大值2倍，此时将文件均分成2个虚拟存储块（防止出现太小切片）。
切片过程:
①判断虚拟存储的文件大小是否大于setMaxInputSplitSize值，大于等于则单独形成一个切片。
②如果不大于则跟下一个虚拟存储文件进行合并，共同形成一个切片。
③测试举例：有4个小文件大小分别为1.7M、5.1M、3.4M以及6.8M这四个小文件，则虚拟存储之后形成6个文件块，大小分别为：
1.7M，（2.55M、2.55M），3.4M以及（3.4M、3.4M）
最终会形成3个切片，大小分别为：
（1.7+2.55）M，（2.55+3.4）M，（3.4+3.4）M
3) 实现方法
①驱动类中添加代码如下：
// 设置虚拟存储切片的最大值：4194304
CombineFileInputFormat.setMaxInputSplitSize(job, 4194304);
// 设置使用 CombineTextInputFormat ： 如果不设置 默认使用的是 TextInputFormat
job.setInputFormatClass(CombineTextInputFormat.class);3.2 MapReduce工作流程
上面的流程是整个MapReduce最全工作流程，但是Shuffle过程只是从第7步开始到第16步结束，具体Shuffle过程详解，如下：
（1）MapTask收集我们的map()方法输出的kv对，放到内存缓冲区中
（2）从内存缓冲区不断溢出本地磁盘文件，可能会溢出多个文件
（3）多个溢出文件会被合并成大的溢出文件
（4）在溢出过程及合并的过程中，都要调用Partitioner进行分区和针对key进行排序
（5）ReduceTask根据自己的分区号，去各个MapTask机器上取相应的结果分区数据
（6）ReduceTask会抓取到同一个分区的来自不同MapTask的结果文件，ReduceTask会将这些文件再进行合并（归并排序）
（7）合并成大文件后，Shuffle的过程也就结束了，后面进入ReduceTask的逻辑运算过程（从文件中取出一个一个的键值对Group，调用用户自定义的reduce()方法）
注意：
（1）Shuffle中的缓冲区大小会影响到MapReduce程序的执行效率，原则上说，缓冲区越大，磁盘io的次数越少，执行速度就越快。
（2）缓冲区的大小可以通过参数调整，参数：mapreduce.task.io.sort.mb默认100M。
3.3 Shuffle机制
3.3.1 Shuffle机制
Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle。
3.3.2 Partition分区
问题引出
要求将统计结果按照条件输出到不同文件中 (分区)。比如: 将统计结果按照手机归属地不同省份输出到不同文件中 (分区)
默认Partitioner分区
默认分区是根据key的hashCode对ReduceTasks个数取模得到的。用户没法控制哪个key存储到哪个分区。
public class HashPartitioner<K, V> extends Partitioner<K, V> {
public int getPartition(K key, V value, int numReduceTasks) {
return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
}
}自定义 Partitioner 步骤
（1）自定义类继承Partitioner，重写getPartition()方法
public class my_partitioner extends Partitioner<Text, LongWritable> {
@Override
public int getPartition(Text text, LongWritable longWritable, int numPartitions) {
// 控制分区的逻辑代码
return partition;
}
}（2）在驱动类中，设置自定义Partitioner 并且 根据自定义Partitioner的逻辑设置相应数量的ReduceTask。
// 设置自定义Partitioner
job.setPartitionerClass(my_partitioner.class);
// 根据自定义Partitioner的逻辑设置相应数量的ReduceTask
job.setNumReduceTasks(2);Partitioner 分区的总结
（1）如果ReduceTask的数量> getPartition的结果数，则会多产生几个空的输出文件part-r-000xx；
（2）如果1<ReduceTask的数量< getPartition的结果数，则有一部分分区数据无处安放，会Exception;
（3）如果ReduceTask的数量-1，则不管MapTask端输出多少个分区文件，最终结果都交给这一个最终ReduceTask，也就只会产生一个结果文件 part-r-00000;
（4）分区号必须从零开始，逐一累加。
3.3.3 WritableComparable排序
排序是MapReduce框架中最重要的操作之一。
MapTask和ReduceTask均会对数据按照key进行排序。该操作属于Hadoop的默认行为，任何应用程序中的数据均会被排序，而不管逻辑上是否需要。
默认排序是按照字典顺序排序，且实现该排序的方法是快速排序。
对于MapTask，它会将处理的结果暂时放到环形缓冲区中，当环形缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一次快速排序，并将这些有序数据溢写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。
对于ReduceTask，它从每个MapTask上远程拷贝相应的数据文件，如果文件大小超过一定阈值，则溢写磁盘上，否则存储在内存中。如果磁盘上文件数目达到一定阈值，则进行一次归并排序以生成一个更大文件，如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据溢写到磁盘上。当所有数据拷贝完毕后，ReduceTask统一对内存和磁盘上的所有数据进行一次归并排序。
排序分类
（1）部分排序
MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部有序。
（2）全排序
最终输出结果只有一个文件，且文件内部有序。实现方式是只设置一个ReduceTask。但该方法在处理大型文件时效率极低，因为一台机器处理所有文件，完全丧失了MapReduce所提供的并行架构。
（3）二次排序
在自定义排序过程中，如果compareTo中的判断条件为两个即为二次排序。
自定义排序WritableComparable原理分析
bean对象做为key传输，需要实现WritableComparable接口重写compareTo方法，就可以实现排序。
3.3.4 Combiner合并
Combiner是MR程序中Mapper和Reducer之外的一种组件。
Combiner组件的父类就是Reducer。
Combiner和Reducer的区别在于运行的位置：
Combiner是在每一个MapTask所在的节点运行；
Reducer是接收全局所有Mapper的输出结果；
Combiner的意义就是对每一个MapTask的输出进行局部汇总，以减小网络传输量。
Combiner能够应用的前提是不能影响最终的业务逻辑，而且，Combiner的输出kv应该跟Reducer的输入kv类型要对应起来。
例如：
不能应用Combiner。
自定义Combiner实现步骤
①自定义一个Combiner继承Reducer，重写Reduce方法
public class WCCombiner extends Reducer<Text, LongWritable, Text, LongWritable> {
private LongWritable outValue = new LongWritable();
@Override
protected void reduce(Text key, Iterable<LongWritable> values, Reducer<Text, LongWritable, Text, LongWritable>.Context context) throws IOException, InterruptedException {
// super.reduce(key, values, context);
long sum = 0;
// 1. 遍历所有的value
// Iterator<LongWritable> iterator = values.iterator(); // 通过 iterator 进行遍历
for (LongWritable value : values) {
// 将 LongWritable 转成 long
long v = value.get();
// 2. 对 value 进行累加
sum += v;
}
// 3. 封装 key, value
// 给value 赋值
outValue.set(sum);
// 4. 将 key, value 写出去
context.write(key, outValue);
}
}②在Job驱动类中设置：
job.setCombinerClass(WCCombiner.class);3.4 OutputFormat数据输出
3.4.1 OutputFormat接口实现类
源码分析：
一 OutputFormat的继承树
|-----OutputFormat
|-----FileOutputFormat
|-------TextOutputFormat
二 OutputFormat（抽象类）
/*
在该方法中做一些输出的检查（①输出的路径是否设置 ②输出的路径是否存在 等......）
*/
public abstract void checkOutputSpecs(JobContext context
) throws IOException,
InterruptedException;
/*
通过该方法返回RecordWriter的对象。RecordWriter是用来写数据的。
*/
public abstract RecordWriter<K, V>
getRecordWriter(TaskAttemptContext context
) throws IOException, InterruptedException;
三 FileOutputFormat（抽象类）
重写了checkOutputSpecs方法。在该方法中判断了①输出的路径是否设置 ②输出的路径是否存在
四 TextOutputFormat（默认使用的OutputFormat）
/*
1.重写了getRecordWriter方法
2.在该方法中返回了LineRecordWriter类的对象。LineRecordWriter是真正用来写数据的那个类。
3.RecordWriter是抽象类。LineRecordWriter是RecordWriter的子类
*/
public RecordWriter<K, V>
getRecordWriter(TaskAttemptContext job
) throws IOException, InterruptedException {
return new LineRecordWriter<>(fileOut, keyValueSeparator);
}
步骤：
编写AddressMapper类
编写AddressReducer类
自定义一个MyOutputFormat类，继承FileOutputFormat类
/*
自定义 MyOutputFormat类：
1.自定义一个类并继承 FileOutputFormat: 因为继承该类只需要重写 getRecordWriter方法:
而getRecordWriter用来获取 RecordWriter对象：
RecordWriter对象 是用来真正写数据的。
FileOutputFormat<K, V>
K : Reducer 写出的 key 类型
V : Reducer 写出的 value 类型
*/
public class MyOutputFormat extends FileOutputFormat<Text, NullWritable>{
/*
在方法中 创建 RecordWriter对象并返回
*/
@Override
public RecordWriter<Text, NullWritable> getRecordWriter(TaskAttemptContext job) throws IOException, InterruptedException {
return new MyRecordWriter(job);
}
}自定义MyRecordWriter类继承RecordWriter类：
public class MyRecordWriter extends RecordWriter<Text, NullWritable> {
private FSDataOutputStream atguigu;
private FSDataOutputStream other;
/*
创建流
*/
public MyRecordWriter(TaskAttemptContext job) throws IOException {
try {
// 1. 创建客户端对象(文件系统对象————操作 HDFS)
FileSystem fileSystem = FileSystem.get(job.getConfiguration());
// 2. 创建流
// 2.1 获取输出路径
Path outputPath = FileOutputFormat.getOutputPath(job);
// 2.2
atguigu = fileSystem.create(new Path(outputPath, "atguigu.txt"));
other = fileSystem.create(new Path(outputPath, "other.txt"));
} catch (Exception e) {
// 打印异常信息
e.printStackTrace();
// 将编译时异常转为运行时异常
throw new RuntimeException(e.getMessage());
}
}
/**
* 用来写数据: 该方法在被循环调用, 每调用一次传入一个键值对
*
* @param key Reducer 写出的 key
* @param value Reducer 写出的 value
* @throws IOException
* @throws InterruptedException
*/
@Override
public void write(Text key, NullWritable value) throws IOException, InterruptedException {
// 判断
String address = key.toString() + "\n";
if (address.contains("atguigu")) {
// 写到atguigu.txt
atguigu.write(address.getBytes());
} else {
// 写到other.txt
other.write(address.getBytes());
}
}
/**
* 关闭资源 : 该方法会在写数据的操作结束后被调用
*
* @param context
* @throws IOException
* @throws InterruptedException
*/
@Override
public void close(TaskAttemptContext context) throws IOException, InterruptedException {
if (atguigu != null) {
atguigu.close();
}
if (other != null) {
other.close();
}
}
}编写AddressDriver类，添加设置：
// 设置使用 自定义的 OutputFormat类, 如果不设置使用的是 TextOutputFormat 类
job.setOutputFormatClass(MyOutputFormat.class);
//虽然我们自定义了outputformat，但是因为我们的outputformat继承自fileoutputformat
//而fileoutputformat要输出一个_SUCCESS文件，所以在这还得指定一个输出目录
FileOutputFormat.setOutputPath(job, new Path("D:\\logoutput"));3.5 MapReduce工作机制
3.5.1 MapTask工作机制
（1）Read阶段：MapTask通过InputFormat获得的RecordReader（底层是lineRecordReader），从输入InputSplit中解析出一个个key/value。
（2）Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。
（3）Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitioner），并写入一个环形内存缓冲区中。
（4）Spill阶段：即“溢写”，当环形缓冲区满后，MapReduce会将数据写到本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地排序，并在必要时对数据进行合并、压缩等操作。
溢写阶段详情：
步骤1：利用快速排序算法对缓存区内的数据进行排序，排序方式是，先按照分区编号Partition进行排序，然后按照key进行排序。这样，经过排序后，数据以分区为单位聚集在一起，且同一分区内所有数据按照key有序。
步骤2：按照分区编号由小到大依次将每个分区中的数据写入任务工作目录下的临时文件output/spillN.out（N表示当前溢写次数）中。如果用户设置了Combiner，则写入文件之前，对每个分区中的数据进行一次聚集操作。
步骤3：将分区数据的元信息写到内存索引数据结构SpillRecord中，其中每个分区的元信息包括在临时文件中的偏移量、压缩前数据大小和压缩后数据大小。如果当前内存索引大小超过1MB，则将内存索引写到文件output/spillN.out.index中。
（5）Merge阶段：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。
当所有数据处理完后，MapTask会将所有临时文件合并成一个大文件，并保存到文件output/file.out中，同时生成相应的索引文件output/file.out.index。
在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并mapreduce.task.io.sort.factor（默认10）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。
让每个MapTask最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。
3.5.2 ReduceTask工作机制
（1）Copy阶段：ReduceTask从各个MapTask上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。
（2）Sort阶段：在远程拷贝数据的同时，ReduceTask启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。按照MapReduce语义，用户编写reduce()函数输入数据是按key进行聚集的一组数据。为了将key相同的数据聚在一起，Hadoop采用了基于排序的策略。由于各个MapTask已经实现对自己的处理结果进行了局部排序，因此，ReduceTask只需对所有数据进行一次归并排序即可。
（3）Reduce阶段：reduce()函数将计算结果写到HDFS上。
3.5.3 ReduceTask并行度决定机制
ReduceTask的并行度同样影响整个Job的执行并发度和执行效率，但与MapTask的并发数由切片数决定不同，ReduceTask数量的决定是可以直接手动设置：
// 默认值是1，手动设置为4
job.setNumReduceTasks(4);注意：
（1）ReduceTask=0，表示没有Reduce阶段，输出文件个数和Map个数一致。
（2）ReduceTask默认值就是1，所以输出文件个数为一个。
（3）如果数据分布不均匀，就有可能在Reduce阶段产生数据倾斜。
（4）ReduceTask数量并不是任意设置，还要考虑业务逻辑需求，有些情况下需要计算全局汇总结果，就只能有1个ReduceTask。
（5）具体多少个ReduceTask，需要根据集群性能而定。
（6）如果分区数不是1，但是ReduceTask为1，是否执行分区过程。
答案是: 不执行分区过程。因为在MapTask的源码中，执行分区的前提是先判断ReduceNum个数是否大于1。不大于1肯定不执行。
3.6 Join应用
3.6.1 Reduce Join
Map端的主要工作：为来自不同表或文件的key/value对，打标签以区别不同来源的记录。然后用连接字段作为key，其余部分和新加的标志作为value，最后进行输出。
Reduce端的主要工作：在Reduce端以连接字段作为key的分组已经完成，我们只需要在每一个分组当中将那些来源于不同文件的记录（在Map阶段已经打标志）分开，最后进行合并就ok了。
3.6.2 Map Join
1）使用场景
Map Join适用于一张表十分小、一张表很大的场景。
2）优点
思考：在Reduce端处理过多的表，非常容易产生数据倾斜。怎么办？
在Map端缓存多张表，提前处理业务逻辑，这样增加Map端业务，减少Reduce端数据的压力，尽可能的减少数据倾斜。
3）具体办法：采用DistributedCache
（1）在Mapper的setup阶段，将文件读取到缓存集合中。
（2）在Driver驱动类中加载缓存。
//缓存普通文件到Task运行节点。
job.addCacheFile(new URI("file:///e:/cache/pd.txt"));
//如果是集群运行,需要设置HDFS路径
job.addCacheFile(new URI("hdfs://hadoop102:8020/cache/pd.txt"));3.7 MapReduce开发总结
输入数据接口：InputFormat
（1）默认使用的实现类是：TextInputFormat
（2）TextInputFormat的功能逻辑是：一次读一行文本，然后将该行的起始偏移量作为key，行内容作为value返回。
（3）CombineTextInputFormat可以把多个小文件合并成一个切片处理，提高处理效率。
逻辑处理接口：Mapper
用户根据业务需求实现其中三个方法：map() setup() cleanup ()
Partitioner分区
（1）有默认实现 HashPartitioner，逻辑是根据key的哈希值和numReduces来返回一个分区号；key.hashCode()&Integer.MAXVALUE % numReduces
（2）如果业务上有特别的需求，可以自定义分区。
Comparable排序
（1）当我们用自定义的对象作为key来输出时，就必须要实现WritableComparable接口，重写其中的compareTo()方法。
（2）部分排序：对最终输出的每一个文件进行内部排序。
（3）全排序：对所有数据进行排序，通常只有一个Reduce。
（4）二次排序：排序的条件有两个。
Combiner合并
Combiner合并可以提高程序执行效率，减少IO传输。但是使用时必须不能影响原有的业务处理结果。
逻辑处理接口：Reducer
用户根据业务需求实现其中三个方法：reduce() setup() cleanup ()
7.输出数据接口：OutputFormat
（1）默认实现类是TextOutputFormat，功能逻辑是：将每一个KV对，向目标文本文件输出一行。
（2）用户还可以自定义OutputFormat。
第4章 Hadoop数据压缩
4.1 概述
压缩的好处和坏处
压缩的优点：以减少磁盘IO、减少磁盘存储空间。
压缩的缺点：增加CPU开销。
压缩原则
（1）运算密集型的Job，少用压缩。
（2）IO密集型的Job，多用压缩。
4.2 MR支持的压缩编码
压缩算法对比介绍
压缩格式 |
Hadoop自带？ |
算法 |
文件扩展名 |
是否可切片 |
换成压缩格式后，原来的程序是否需要修改 |
DEFLATE |
是，直接使用 |
DEFLATE |
.deflate |
否 |
和文本处理一样，不需要修改 |
Gzip |
是，直接使用 |
DEFLATE |
.gz |
否 |
和文本处理一样，不需要修改 |
bzip2 |
是，直接使用 |
bzip2 |
.bz2 |
是 |
和文本处理一样，不需要修改 |
LZO |
否，需要安装 |
LZO |
.lzo |
是 |
需要建索引，还需要指定输入格式 |
Snappy |
是，直接使用 |
Snappy |
.snappy |
否 |
和文本处理一样，不需要修改 |
压缩性能的比较
压缩算法 |
原始文件大小 |
压缩文件大小 |
压缩速度 |
解压速度 |
gzip |
8.3GB |
1.8GB |
17.5MB/s |
58MB/s |
bzip2 |
8.3GB |
1.1GB |
2.4MB/s |
9.5MB/s |
LZO |
8.3GB |
2.9GB |
49.3MB/s |
74.6MB/s |
4.3 压缩方式选择
压缩方式选择时重点考虑：压缩/解压缩速度、压缩率（压缩后存储大小）、压缩后是否可以支持切片。
4.3.1 Gzip压缩
优点：压缩率比较高。
缺点：不支持Split；压缩/解压速度一般。
4.3.2 Bzip2压缩
优点：压缩率高；支持Split。
缺点：压缩/解压速度慢。
4.3.3 Lzo压缩
优点：压缩/解压速度比较快；支持Split。
缺点：压缩率一般；想支持切片需要额外创建索引。
4.3.4 Snappy压缩
优点：压缩和解压缩速度快。
缺点：不支持Split；压缩率一般。
4.3.5 压缩位置选择
压缩可以在MapReduce作用的任意阶段启用。
4.4 压缩参数配置
为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器
压缩格式 |
对应的编码/解码器 |
DEFLATE |
org.apache.hadoop.io.compress.DefaultCodec |
gzip |
org.apache.hadoop.io.compress.GzipCodec |
bzip2 |
org.apache.hadoop.io.compress.BZip2Codec |
LZO |
com.hadoop.compression.lzo.LzopCodec |
Snappy |
org.apache.hadoop.io.compress.SnappyCodec |
要在Hadoop中启用压缩，可以配置如下参数
参数 |
默认值 |
阶段 |
建议 |
io.compression.codecs （在core-site.xml中配置） |
无，这个需要在命令行输入hadoop checknative查看 |
输入压缩 |
Hadoop使用文件扩展名判断是否支持某种编解码器 |
mapreduce.map.output.compress （在mapred-site.xml中配置） |
false |
mapper输出 |
这个参数设为true启用压缩 |
mapreduce.map.output.compress.code （在mapred-site.xml中配置） |
org.apache.hadoop.io.compress.DefaultCodec |
mapper输出 |
企业多使用LZO或Snappy编解码器在此阶段压缩数据 |
mapreduce.output.fileoutputformat.compress （在mapred-site.xml中配置） |
false |
reducer输出 |
这个参数设为true启用压缩 |
mapreduce.output.fileoutputformat.compress.codec （在mapred-site.xml中配置） |
org.apache.hadoop.io.compress.DefaultCodec |
reducer输出 |
使用标准工具或者编解码器，如gzip和bzip2 |
4.5 压缩实操案例
4.5.1 Map输出端采用压缩
给大家提供的Hadoop源码支持的压缩格式有：BZip2Codec、DefaultCodec
驱动类中添加如下设置:
// 开启map端输出压缩
conf.setBoolean("mapreduce.map.output.compress", true);
// 设置map端输出压缩方式
conf.setClass("mapreduce.map.output.compress.codec", BZip2Codec.class,CompressionCodec.class);4.5.2 Reduce输出端采用压缩
修改驱动
// 设置reduce端输出压缩开启
FileOutputFormat.setCompressOutput(job, true);
// 设置压缩的方式
FileOutputFormat.setOutputCompressorClass(job, BZip2Codec.class);