MapReduce（二）

一：序列化概述

什么是序列化？

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

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

为什么要序列化

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

为什么不用Java的序列化

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

Hadoop自己开发了一套序列化机制（Writable）。

Hadoop序列化特点：  

（1）紧凑 ：高效使用存储空间。

（2）快速：读写数据的额外开销小。

（3）互操作：支持多语言的交互。

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

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

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

（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）注意反序列化的顺序和序列化的顺序完全一致

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

（7）如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为

MapReduce框中的Shuffle过程要求对key必须能排序。

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

三：序列化案例实操

需求：

案例分析：

 代码实现：

（1）编写流量统计的Bean对象

package com.atguigu.mapreduce.combineTextinputformat;

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, InterruptedException, ClassNotFoundException {
        //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(WordCountReduce.class);

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

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

        //如果不设置InputFormat，它默认使用的是TextInputFormat.class
     //   job.setInputFormatClass(CombineTextInputFormat.class);

        //虚拟存储切片最大值设置4m
      //  CombineTextInputFormat.setMaxInputSplitSize(job,4194304);

        //6.设置输出路径和输出路径
        FileInputFormat.setInputPaths(job,new Path("D:\\inputinputformat"));
        FileOutputFormat.setOutputPath(job,new Path("D:\\outputcompare"));

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

（2）编写Mapper类

package com.atguigu.mapreduce.writable;

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

import java.io.IOException;

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 {
        //1.读一行
        //1	13736230513	192.196.100.1	www.atguigu.com	2481	24681	200
       String line = value.toString();

        //2.切割
        //1,13736230513,192.196.100.1,www.atguigu.com,2481,24681,200
        String[] split=line.split("\t");

        //3.抓取想要的数据
        //电话号码：13736230513
        //上行流量：2481
        //下行流量：24681
        String phone=split[1];
        String up=split[split.length-3];
        String down=split[split.length-2];

        //4.封装
        outK.set(phone);
        outV.setUpFlow(Long.getLong(up));
        outV.setDownFlow(Long.getLong(down));
        outV.setSumFlow();

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

（3）编写Reducer类

package com.atguigu.mapreduce.writable;

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

import java.io.IOException;

public class FlowReduce extends Reducer<Text,FlowBean,Text,FlowBean> {
    private FlowBean outV=new FlowBean();
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Reducer<Text, FlowBean, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        //1.遍历集合累加值
        long totalUp=0;
        long totalDown=0;
        for(FlowBean value:values){
            totalUp+=value.getUpFlow();
            totalDown+=value.getDownFlow();
        }
        //2.outV
        outV.setSumFlow(totalUp);
        outV.setDownFlow(totalDown);
        outV.setSumFlow();

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

（4）编写Driver驱动类

package com.atguigu.mapreduce.writable;

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

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

        //2.设置jar包
        job.setJarByClass(FlowDriver.class);

        //3.关联mapper和Reducer
        job.setMapperClass(FlowMapper.class);
        job.setReducerClass(FlowReduce.class);

        //4.设置mapper 输出的key和value类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);

        //5.设置最终数据输出的key和value类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);
        //6.设置数据的输入路径和输出路径
        FileInputFormat.setInputPaths(job,new Path("D:\\In\\phone_data.txt"));
        FileOutputFormat.setOutputPath(job,new Path("D:\\Out"));

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

    }
}

 四：MapReduce框架原理

 4.1 InputFormat数据输入

4.1.1 切片与MapTask并行度决定机制

1）问题引出

MapTask的并行度决定Map阶段的任务处理并发度，进而影响到整个Job的处理速度。

思考：1G的数据，启动8个MapTask，可以提高集群的并发处理能力。那么1K的数据，也启动8个MapTask，会提高集群性能吗？MapTask并行任务是否越多越好呢？哪些因素影响了MapTask并行度？

2）MapTask并行度决定机制

数据块：Block是HDFS物理上把数据分成一块一块。数据块是HDFS存储数据单位。

数据切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。数据切片是MapReduce程序计算输入数据的单位，一个切片会对应启动一个MapTask。

五：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());

六： FileInputFormat切片源码解析（input.getSplits(job)）

 切片机制：

1、切片机制

（1）简单地按照文件的内容长度进行切片

（2）切片大小，默认等于Block大小

（3）切片时不考虑数据集整体，而是逐个针对每一个文件单独切片

2、案例分析

（1）输入数据有两个文件：

file1.txt320M

file2.txt10M

（2）经过FileInputFormat的切片机制

运算后，形成的切片信息如下：

file1.txt.split1--0~128

file1.txt.split2--128~256

file1.txt.split3--256~320

file2.txt.split1--0~10M

（1）源码中计算切片大小的公式

Math.max(minSize,Math.min(maxSize,blockSize));

mapreduce.input.fileinputformat.split.minsize=1默认值为1

mapreduce.input.fileinputformat.split.maxsize=Long.MAXValue默认值Long.MAXValue

因此，默认情况下，切片大小=blocksize。

（2）切片大小设置

maxsize（切片最大值）：参数如果调得比blockSize小，则会让切片变小，而且就等于配置的这个参数的值。

minsize（切片最小值）：参数调的比blockSize大，则可以让切片变得比blockSize还大。

（3）获取切片信息API

//获取切片的文件名称

Stringname=inputSplit.getPath().getName();//根据文件类型获取切片信息

FileSplitinputSplit=(FileSplit)context.getInputSplit();

 七：TextInputFormat

1）FileInputFormat实现类

思考：在运行MapReduce程序时，输入的文件格式包括：基于行的日志文件、二进制格式文件、数据库表等。那么，针对不同的数据类型，MapReduce是如何读取这些数据的呢？ FileInputFormat常见的接口实现类包括：TextInputFormat、KeyValueTextInputFormat、

NLineInputFormat、CombineTextInputFormat和自定义InputFormat等。

2）TextInputFormat

TextInputFormat是默认的FileInputFormat实现类。按行读取每条记录。键是存储该行在整个文件中的起始字节偏移量， LongWritable类型。值是这行的内容，不包括任何行终止符（换行符和回车符），Text类型。

八： CombineTextInputFormat切片机制

框架默认的TextInputFormat切片机制是对任务按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个MapTask，这样如果有大量小文件，就会产生大量的

MapTask，处理效率极其低下。

1）应用场景：

CombineTextInputFormat用于小文件过多的场景，它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个MapTask处理。

2）虚拟存储切片最大值设置

CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);// 4m

注意：虚拟存储切片最大值设置最好根据实际的小文件大小情况来设置具体的值。

3）切片机制

生成切片过程包括：虚拟存储过程和切片过程二部分。

 

（1）虚拟存储过程：

将输入目录下所有文件大小，依次和设置的setMaxInputSplitSize值比较，如果不大于设置的最大值，逻辑上划分一个块。如果输入文件大于设置的最大值且大于两倍，那么以最大值切割一块；当剩余数据大小超过设置的最大值且不大于最大值2倍，此时将文件均分成2个虚拟存储块（防止出现太小切片）。

例如setMaxInputSplitSize值为4M，输入文件大小为8.02M，则先逻辑上分成一个

4M。剩余的大小为4.02M，如果按照4M逻辑划分，就会出现0.02M的小的虚拟存储文件，所以将剩余的4.02M文件切分成（2.01M和2.01M）两个文件。

（2）切片过程：

（a）判断虚拟存储的文件大小是否大于setMaxInputSplitSize值，大于等于则单独形成一个切片。

（b）如果不大于则跟下一个虚拟存储文件进行合并，共同形成一个切片。

（c）测试举例：有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

实操案例：

代码实现过程：

（1）不做任何处理，运行WordCount案例程序，观察切片个数为4。 

number of splits:4 

（2）在WordcountDriver中增加如下代码，运行程序，并观察运行的切片个数为3。

（a）驱动类中添加代码如下： 
// 如果不设置InputFormat，它默认用的是TextInputFormat.class 
job.setInputFormatClass(CombineTextInputFormat.class);  
//虚拟存储切片最大值设置4m 
CombineTextInputFormat.setMaxInputSplitSize(job, 4194304); 
 （b）运行如果为3个切片。 
number of splits:3 

（3）在WordcountDriver中增加如下代码，运行程序，并观察运行的切片个数为1。

（a）驱动中添加代码如下： 
// 如果不设置InputFormat，它默认用的是TextInputFormat.class 
job.setInputFormatClass(CombineTextInputFormat.class);  
//虚拟存储切片最大值设置20m 
CombineTextInputFormat.setMaxInputSplitSize(job, 20971520); 
（b）运行如果为1个切片 
number of splits:1 

九：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。 

十：Shuffle机制  

Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle。

 

十一：Partition分区  

1、问题引出

要求将统计结果按照条件输出到不同文件中（分区）。比如：将统计结果按照手机归属地不同省份输出到不同文件中（分区）

2、默认Partitioner分区 

publicclassHashPartitioner<K,V>extendsPartitioner<K,V>{
publicintgetPartition(Kkey,Vvalue,intnumReduceTasks)
{
return(key.hashCode()&Integer.MAX_VALUE)%numReduceTasks;

}

}

默认分区是根据key的hashCode对ReduceTasks个数取模得到的。用户没法控制哪个

key存储到哪个分区。

 3、自定义Partitioner步骤

（1）自定义类继承Partitioner，重写getPartition()方法

publicclassCustomPartitionerextendsPartitioner<Text,FlowBean>{
@Override
publicintgetPartition(Textkey,FlowBeanvalue,intnumPartitions){
//控制分区代码逻辑
……returnpartition;
}
}

（2）在Job驱动中，设置自定义Partitioner

job.setPartitionerClass(CustomPartitioner.class);

（3）自定义Partition后，要根据自定义Partitioner的逻辑设置相应数量的ReduceTask

job.setNumReduceTasks(5);

4、分区总结

（1）如果ReduceTask的数量>getPartition的结果数，则会多产生几个空的输出文件part-r-000xx；

（2）如果1的数量的结果数，则有一部分分区数据无处安放，会Exception；

（3）如果ReduceTask的数量=1，则不管MapTask端输出多少个分区文件，最终结果都交给这一个ReduceTask，最终也就只会产生一个结果文件part-r-00000；

（4）分区号必须从零开始，逐一累加。

5、案例分析

例如：假设自定义分区数为5，则

（1）job.setNumReduceTasks(1);会正常运行，只不过会产生一个输出文件

（2）job.setNumReduceTasks(2);会报错

（3）job.setNumReduceTasks(6);大于5，程序会正常运行，会产生空文件