大数据技术之Hadoop（MapReduce&Yarn）V3.0 阿善重要

第1章 MapReduce概述1.1 MapReduce定义MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。1.2 MapReduce优缺点1.2.1 优点1)MapReduce 易于编程它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一样的。就是因为这个特点使得MapReduce编程变得非常流行。2)良好的扩展性当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。3)高容错性MapReduce设计的初衷就是使程序能够部署在廉价的PC机器上，这就要求它具有很高的容错性。比如其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上运行，不至于这个任务运行失败，而且这个过程不需要人工参与，而完全是由Hadoop内部完成的。4)适合PB级以上海量数据的离线处理可以实现上千台服务器集群并发工作，提供数据处理能力。1.2.2 缺点1)不擅长实时计算MapReduce无法像MySQL一样，在毫秒或者秒级内返回结果。2)不擅长流式计算流式计算的输入数据是动态的，而MapReduce的输入数据集是静态的，不能动态变化。这是因为MapReduce自身的设计特点决定了数据源必须是静态的。3)不擅长DAG(有向图)计算多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce并不是不能做，而是使用后，每个MapReduce作业的输出结果都会写入到磁盘，会造成大量的磁盘IO，导致性能非常的低下。1.3 MapReduce核心思想

1) MapReduce运其程序一投需要分成2个阶段:Map阶段和Reduce阶段2) Map阶段的并发MapTask，完全并行运行，互不相干3 Reduce阶段的并发ReduceTask，完全互不相干，但是他门的数据依赖于上一个阶段的所有MapTask并发实例的输出MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻担非常良杂，那就只能多个MapR educe程序，串行运行

(1)分布式的运算程序往往需要分成至少2个阶段。(2)第一个阶段的MapTask并发实例，完全并行运行，互不相干。(3)第二个阶段的ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。(4)MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个MapReduce程序，串行运行。总结：分析WordCount数据流走向深入理解MapReduce核心思想。1.4 MapReduce进程一个完整的MapReduce程序在分布式运行时有三类实例进程：(1)MrAppMaster：负责整个程序的过程调度及状态协调。(2)MapTask：负责Map阶段的整个数据处理流程。(3)ReduceTask：负责Reduce阶段的整个数据处理流程。1.5 官方WordCount源码采用反编译工具反编译源码，发现WordCount案例有Map类、Reduce类和驱动类。且数据的类型是Hadoop自身封装的序列化类型。1.6 常用数据序列化类型Java类型 Hadoop Writable类型Boolean BooleanWritableByte ByteWritableInt IntWritableFloat FloatWritableLong LongWritableDouble DoubleWritableString TextMap MapWritableArray ArrayWritable1.8 WordCount案例实操1)需求在给定的文本文件中统计输出每一个单词出现的总次数(1)输入数据

(2)期望输出数据atguigu 2banzhang 1cls 2hadoop 1jiao 1ss 2xue 12)需求分析按照MapReduce编程规范，分别编写Mapper，Reducer，Driver。

 

3)环境准备(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>(2)在项目的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>4)编写程序(1)编写Mapper类package com.atguigu.mapreduce;import java.io.IOException;import org.apache.hadoop.io.IntWritable;import org.apache.hadoop.io.LongWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Mapper;

public class WordcountMapper extends Mapper<LongWritable, Text, Text, IntWritable>{ Text k = new Text(); IntWritable v = 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) { k.set(word); context.write(k, v); } }}(2)编写Reducer类package com.atguigu.mapreduce.wordcount;import java.io.IOException;import org.apache.hadoop.io.IntWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Reducer;

public class WordcountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{

int sum;IntWritable v = new IntWritable();

@Override protected void reduce(Text key, Iterable<IntWritable> values,Context context) throws IOException, InterruptedException { // 1 累加求和 sum = 0; for (IntWritable count : values) { sum += count.get(); } // 2 输出 v.set(sum); context.write(key,v); }}(3)编写Driver驱动类package com.atguigu.mapreduce.wordcount;import java.io.IOException;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;

public class WordcountDriver {

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

// 1 获取配置信息以及封装任务 Configuration configuration = new Configuration(); 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); }}5)本地测试(1)需要首先配置好HadoopHome变量以及Windows运行依赖(2)在Eclipse/Idea上运行程序6)集群上测试(0)用maven打jar包，需要添加的打包插件依赖注意：标记红颜色的部分需要替换为自己工程主类<build> <plugins> <plugin> <artifactId>maven-compiler-plugin</artifactId> <version>2.3.2</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> <archive> <manifest> <mainClass>com.atguigu.mr.WordcountDriver</mainClass> </manifest> </archive> </configuration> <executions> <execution> <id>make-assembly</id> <phase>package</phase> <goals> <goal>single</goal> </goals> </execution> </executions> </plugin> </plugins></build>注意：如果工程上显示红叉。在项目上右键->maven->update project即可。(1)将程序打成jar包，然后拷贝到Hadoop集群中步骤详情：右键->Run as->maven install。等待编译完成就会在项目的target文件夹中生成jar包。如果看不到。在项目上右键-》Refresh，即可看到。修改不带依赖的jar包名称为wc.jar，并拷贝该jar包到Hadoop集群。(2)启动Hadoop集群(3)执行WordCount程序[atguigu@hadoop102 software]$ hadoop jar wc.jar com.atguigu.wordcount.WordcountDriver /user/atguigu/input /user/atguigu/output7)在Windows上向集群提交任务 (1)添加必要配置信息public class WordcountDriver {

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

// 1 获取配置信息以及封装任务 Configuration configuration = new Configuration();

configuration.set("fs.defaultFS", "hdfs://hadoop102:8020"); configuration.set("mapreduce.framework.name","yarn"); configuration.set("mapreduce.app-submission.cross-platform","true"); configuration.set("yarn.resourcemanager.hostname","hadoop103");

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); }}(2)编辑任务配置

(3)打包，并将Jar包设置到Driver中public class WordcountDriver {

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

// 1 获取配置信息以及封装任务 Configuration configuration = new Configuration();

configuration.set("fs.defaultFS", "hdfs://hadoop102:8020"); configuration.set("mapreduce.framework.name","yarn"); configuration.set("mapreduce.app-submission.cross-platform","true"); configuration.set("yarn.resourcemanager.hostname","hadoop103");

Job job = Job.getInstance(configuration);

// 2 设置jar加载路径 job.setJar("C:\\Users\\skiin\\IdeaProjects\\mapreduce1021\\target\\mapreduce1021-1.0-SNAPSHOT.jar");

// 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); }}(4)提交并查看结果第2章 Hadoop序列化2.1 序列化概述

 

 序列化概述

2.1.3为什么不用Java的序列化

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

Hadoop序列化特点:

(1)紧凑:高效使用存储空间。

(2)快速:读写数据的额外开销小。

3)可扩展:随着通信协议的升级而可升级

4)互操作:支持多语言的交互

2.2 自定义bean对象实现序列化接口(Writable)

在企业开发中往往常用的基本序列化类型不能满足所有需求，比如在Hadoop框架内部传递一个bean对象，那么该对象就需要实现序列化接口。具体实现bean对象序列化步骤如下7步。(1)必须实现Writable接口(2)反序列化时，需要反射调用空参构造函数，所以必须有空参构造public FlowBean() { super();}(3)重写序列化方法@Overridepublic void write(DataOutput out) throws IOException { out.writeLong(upFlow); out.writeLong(downFlow); out.writeLong(sumFlow);}(4)重写反序列化方法@Overridepublic 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必须能排序。详见后面排序案例。@Overridepublic int compareTo(FlowBean o) { // 倒序排列，从大到小 return this.sumFlow > o.getSumFlow() ? -1 : 1;}2.3 序列化案例实操 1)需求统计每一个手机号耗费的总上行流量、下行流量、总流量(1)输入数据

(2)输入数据格式：7 13560436666 120.196.100.99 1116 954 200id 手机号码 网络ip 上行流量 下行流量 网络状态码(3)期望输出数据格式13560436666 1116 954 2070手机号码 上行流量 下行流量 总流量2)需求分析

3)编写MapReduce程序(1)编写流量统计的Bean对象package com.atguigu.mapreduce.flowsum;import java.io.DataInput;import java.io.DataOutput;import java.io.IOException;import org.apache.hadoop.io.Writable;

// 1 实现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) { super(); this.upFlow = upFlow; this.downFlow = downFlow; this.sumFlow = upFlow + downFlow; } //3 写序列化方法 @Override public void write(DataOutput out) throws IOException { out.writeLong(upFlow); out.writeLong(downFlow); out.writeLong(sumFlow); } //4 反序列化方法 //5 反序列化方法读顺序必须和写序列化方法的写顺序必须一致 @Override public void readFields(DataInput in) throws IOException { this.upFlow = in.readLong(); this.downFlow = in.readLong(); this.sumFlow = in.readLong(); }

// 6 编写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类package com.atguigu.mapreduce.flowsum;import java.io.IOException;import org.apache.hadoop.io.LongWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Mapper;

public class FlowCountMapper extends Mapper<LongWritable, Text, Text, FlowBean>{ FlowBean v = new FlowBean(); Text k = new Text(); @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]);

k.set(phoneNum); v.set(downFlow, upFlow); // 4 写出 context.write(k, v); }}(3)编写Reducer类package com.atguigu.mapreduce.flowsum;import java.io.IOException;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Reducer;

public class FlowCountReducer extends Reducer<Text, FlowBean, Text, FlowBean> {

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

long sum_upFlow = 0; long sum_downFlow = 0;

// 1 遍历所用bean，将其中的上行流量，下行流量分别累加 for (FlowBean flowBean : values) { sum_upFlow += flowBean.getUpFlow(); sum_downFlow += flowBean.getDownFlow(); }

// 2 封装对象 FlowBean resultBean = new FlowBean(sum_upFlow, sum_downFlow); // 3 写出 context.write(key, resultBean); }}(4)编写Driver驱动类package com.atguigu.mapreduce.flowsum;import java.io.IOException;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;

public class FlowsumDriver {

public static void main(String[] args) throws IllegalArgumentException, IOException, ClassNotFoundException, InterruptedException {// 输入输出路径需要根据自己电脑上实际的输入输出路径设置args = new String[] { "e:/input/inputflow", "e:/output1" };

// 1 获取配置信息，或者job对象实例 Configuration configuration = new Configuration(); Job job = Job.getInstance(configuration);

// 6 指定本程序的jar包所在的本地路径 job.setJarByClass(FlowsumDriver.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); }}第3章 MapReduce框架原理3.1 InputFormat数据输入

 

3.1.1 切片与MapTask并行度决定机制1)问题引出MapTask的并行度决定Map阶段的任务处理并发度，进而影响到整个Job的处理速度。思考：1G的数据，启动8个MapTask，可以提高集群的并发处理能力。那么1K的数据，也启动8个MapTask，会提高集群性能吗？MapTask并行任务是否越多越好呢？哪些因素影响了MapTask并行度？2)MapTask并行度决定机制数据块：Block是HDFS物理上把数据分成一块一块。数据切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。

 一个切片分配一个maptask执行

3.1.2 Job提交流程源码和切片源码详解1)Job提交流程源码详解waitForCompletion()

submit();

// 1建立连接 connect(); // 1)创建提交Job的代理 new Cluster(getConfiguration()); // (1)判断是本地yarn还是远程 initialize(jobTrackAddr, conf);

// 2 提交jobsubmitter.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());

2)FileInputFormat切片源码解析(input.getSplits(job))

 FilelnputFormat切片源码解析

尚硅谷

(1)程序先找到你数据存储的目录。

(2)开始遍历处理(规划切片)目录下的每一个文件(3)遍万第一个文件ss .tct

a)获取文件大小f.sizeOfss .tct)b)计算切片大小

conputeSplitS jze(Matlmax(irS iza,Math.mir(maxS iza,blocksiza1)=b locksize= 128M

c)默认情况下,切片大小=blocks ize

d)开始切。形成第1个切片:ss .bt—O:12M第2个切片ss .t—128:256M 第3个切片ss.trt—256M:30OM(每次切片时,都要判断切完剩下的部分是否大于块的1.l倍，不大于1.1倍就划分一块切片)

e)将切片信息写到一个切片规划文件中

f整个切片的核心过程在getsplit()方法中完成

g)InpuntSp只记录了切片的元数据信息，比如起始位置、长度以及所在的节点列表等。

(4)提交切片规划文件到YARN上，YARN上的MrAppMlaster就可以根据切片规划文件计算开启MapTask个数。

3.1.3 FileInputFormat切片机制

 

3.1.4 CombineTextInputFormat切片机制框架默认的TextInputFormat切片机制是对任务按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个MapTask，这样如果有大量小文件，就会产生大量的MapTask，处理效率极其低下。1)应用场景：CombineTextInputFormat用于小文件过多的场景，它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个MapTask处理。2)虚拟存储切片最大值设置CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);// 4m注意：虚拟存储切片最大值设置最好根据实际的小文件大小情况来设置具体的值。3)切片机制生成切片过程包括：虚拟存储过程和切片过程二部分。

 小于4M分成一块,  大于4M平分成两块

(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)M3.1.5 CombineTextInputFormat案例实操1)需求将输入的大量小文件合并成一个切片统一处理。(1)输入数据准备4个小文件(2)期望期望一个切片处理4个文件2)实现过程(1)不做任何处理，运行1.6节的WordCount案例程序，观察切片个数为4。

(2)在WordcountDriver中增加如下代码，运行程序，并观察运行的切片个数为3。(a)驱动类中添加代码如下：// 如果不设置InputFormat，它默认用的是TextInputFormat.classjob.setInputFormatClass(CombineTextInputFormat.class);

//虚拟存储切片最大值设置4mCombineTextInputFormat.setMaxInputSplitSize(job, 4194304); (b)运行如果为3个切片。

(3)在WordcountDriver中增加如下代码，运行程序，并观察运行的切片个数为1。 (a)驱动中添加代码如下：// 如果不设置InputFormat，它默认用的是TextInputFormat.classjob.setInputFormatClass(CombineTextInputFormat.class);

//虚拟存储切片最大值设置20mCombineTextInputFormat.setMaxInputSplitSize(job, 20971520);(b)运行如果为1个切片。

3.1.6 TextInputFormat的KV

3.2 MapReduce工作流程

 

具体Shuffle过程详解上面的流程是整个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)缓冲区的大小可以通过参数调整，参数：io.sort.mb默认100M。(3)源码解析流程context.write(k, NullWritable.get());output.write(key, value);collector.collect(key, value,partitioner.getPartition(key, value, partitions)); HashPartitioner();collect() close() collect.flush()sortAndSpill() sort() QuickSortmergeParts();collector.close();3.3 Shuffle机制3.3.1 Shuffle机制Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle。

3.3.2 Partition分区

 

 Partition分区

1、问题引出

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

2、默认Partitioner分区

public class HashPartitioner<, V> extends Partitioner<R,V>{

public int getPartition( key, v value, int nuReduceTasks){

return (key.hashCode () s Integer.NAX_VALUE) % numReduceTasks;

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

 

 Partition分区

4、分区总结   

(1)如果Rece Task的漱量>getParttion的结果数,则会多产生几个空的输出文件part-r-0O0kxz;

(2)如果1<ReduceTask的擞量<getPartition的结果数,则有一部分分区数据无处安放，会Exception;

(3)如果Reduce Task的数量=1，则不管Map Task端输出多少个分区文件，最终结果都交给这一个RecceTask,最终也就只会产生—个结果文件part-r-00000;

(4)分区号必须从零开始,逐—累加。

5、案例分析

伪收:假设自定义分区数为5，则

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

(2) job.setNumRedceTasks2);会报错

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

3.3.3 Partition分区案例实操1)需求将统计结果按照手机归属地不同省份输出到不同文件中(分区)(1)输入数据(2)期望输出数据 手机号136、137、138、139开头都分别放到一个独立的4个文件中，其他开头的放到一个文件中。2)需求分析

3)在案例2.4的基础上，增加一个分区类package com.atguigu.mapreduce.flowsum;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Partitioner;

public class ProvincePartitioner extends Partitioner<Text, FlowBean> {

@Override public int getPartition(Text key, FlowBean value, int numPartitions) {

// 1 获取电话号码的前三位 String preNum = key.toString().substring(0, 3); int partition = 4; // 2 判断是哪个省 if ("136".equals(preNum)) { partition = 0; }else if ("137".equals(preNum)) { partition = 1; }else if ("138".equals(preNum)) { partition = 2; }else if ("139".equals(preNum)) { partition = 3; }

return partition; }}4)在驱动函数中增加自定义数据分区设置和ReduceTask设置package com.atguigu.mapreduce.flowsum;import java.io.IOException;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;

public class FlowsumDriver {

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

// 输入输出路径需要根据自己电脑上实际的输入输出路径设置 args = new String[]{"e:/output1","e:/output2"};

// 1 获取配置信息，或者job对象实例 Configuration configuration = new Configuration(); Job job = Job.getInstance(configuration);

// 2 指定本程序的jar包所在的本地路径 job.setJarByClass(FlowsumDriver.class);

// 3 指定本业务job要使用的mapper/Reducer业务类 job.setMapperClass(FlowCountMapper.class); job.setReducerClass(FlowCountReducer.class);

// 4 指定mapper输出数据的kv类型 job.setMapOutputKeyClass(Text.class); job.setMapOutputValueClass(FlowBean.class);

// 5 指定最终输出的数据的kv类型 job.setOutputKeyClass(Text.class); job.setOutputValueClass(FlowBean.class);

// 8 指定自定义数据分区 job.setPartitionerClass(ProvincePartitioner.class);

// 9 同时指定相应数量的reduce task job.setNumReduceTasks(5); // 6 指定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); }}

3.3.4 WritableComparable排序

 

 排序概述

对于MapTask，它会将处理的结果暂时放到环形缓冲区中,当环形缓冲区使用率达到一定阈值后,再对缓冲区中的数据进行一次快速排序,并将这些有序数据溢写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。

对于ReduceTask,它从每个MapTask上远程拷贝相应的数据文件,如果文件大小超过一定阈值，则溢写磁盘上，否则存储在内存中。如果磁盘上文件数目达到一定阈值,则进行一次归并排序以生成一个更大文件;如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据溢写到磁盘上。当所有数据拷贝完毕后,ReduceTask统一对内存和磁盘上的所有数据进行一次归并排序。

 

自定义排序WritableComparable原理分析bean对象做为key传输，需要实现WritableComparable接口重写compareTo方法，就可以实现排序。@Overridepublic int compareTo(FlowBean o) {

int result; // 按照总流量大小，倒序排列 if (sumFlow > bean.getSumFlow()) { result = -1; }else if (sumFlow < bean.getSumFlow()) { result = 1; }else { result = 0; }

return result;}3.3.5 WritableComparable排序案例实操(全排序)1)需求根据案例2.3产生的结果再次对总流量进行排序。(1)输入数据原始数据 第一次处理后的数据(2)期望输出数据13509468723 7335 110349 11768413736230513 2481 24681 2716213956435636 132 1512 164413846544121 264 0 264。。。 。。。2)需求分析   

3)代码实现(1)FlowBean对象在在需求1基础上增加了比较功能package com.atguigu.mapreduce.sort;import java.io.DataInput;import java.io.DataOutput;import java.io.IOException;import org.apache.hadoop.io.WritableComparable;

public class FlowBean implements WritableComparable<FlowBean> {

private long upFlow; private long downFlow; private long sumFlow;

// 反序列化时，需要反射调用空参构造函数，所以必须有 public FlowBean() { super(); }

public FlowBean(long upFlow, long downFlow) { super(); this.upFlow = upFlow; this.downFlow = downFlow; this.sumFlow = upFlow + downFlow; }

public void set(long upFlow, long downFlow) { this.upFlow = upFlow; this.downFlow = downFlow; this.sumFlow = upFlow + downFlow; }

public long getSumFlow() { return sumFlow; }

public void setSumFlow(long sumFlow) { this.sumFlow = 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; }

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

/** * 反序列化方法 注意反序列化的顺序和序列化的顺序完全一致 * @param in * @throws IOException */ @Override public void readFields(DataInput in) throws IOException { upFlow = in.readLong(); downFlow = in.readLong(); sumFlow = in.readLong(); }

@Override public String toString() { return upFlow + "\t" + downFlow + "\t" + sumFlow; }

@Override public int compareTo(FlowBean bean) { int result; // 按照总流量大小，倒序排列 if (sumFlow > bean.getSumFlow()) { result = -1; }else if (sumFlow < bean.getSumFlow()) { result = 1; }else { result = 0; }

return result; }}(2)编写Mapper类package com.atguigu.mapreduce.sort;import java.io.IOException;import org.apache.hadoop.io.LongWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Mapper;

public class FlowCountSortMapper extends Mapper<LongWritable, Text, FlowBean, Text>{

FlowBean bean = new FlowBean(); Text v = new Text();

@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 phoneNbr = fields[0]; long upFlow = Long.parseLong(fields[1]); long downFlow = Long.parseLong(fields[2]); bean.set(upFlow, downFlow); v.set(phoneNbr); // 4 输出 context.write(bean, v); }}(3)编写Reducer类package com.atguigu.mapreduce.sort;import java.io.IOException;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Reducer;

public class FlowCountSortReducer extends Reducer<FlowBean, Text, Text, FlowBean>{

@Override protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException { // 循环输出，避免总流量相同情况 for (Text text : values) { context.write(text, key); } }}(4)编写Driver类package com.atguigu.mapreduce.sort;import java.io.IOException;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;

public class FlowCountSortDriver {

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

// 输入输出路径需要根据自己电脑上实际的输入输出路径设置 args = new String[]{"e:/output1","e:/output2"};

// 1 获取配置信息，或者job对象实例 Configuration configuration = new Configuration(); Job job = Job.getInstance(configuration);

// 2 指定本程序的jar包所在的本地路径 job.setJarByClass(FlowCountSortDriver.class);

// 3 指定本业务job要使用的mapper/Reducer业务类 job.setMapperClass(FlowCountSortMapper.class); job.setReducerClass(FlowCountSortReducer.class);

// 4 指定mapper输出数据的kv类型 job.setMapOutputKeyClass(FlowBean.class); job.setMapOutputValueClass(Text.class);

// 5 指定最终输出的数据的kv类型 job.setOutputKeyClass(Text.class); job.setOutputValueClass(FlowBean.class);

// 6 指定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); }}3.3.6 WritableComparable排序案例实操(区内排序)1)需求要求每个省份手机号输出的文件中按照总流量内部排序。2)需求分析 基于前一个需求，增加自定义分区类，分区按照省份手机号设置。

3)案例实操(1)增加自定义分区类package com.atguigu.mapreduce.sort;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Partitioner;

public class ProvincePartitioner extends Partitioner<FlowBean, Text> {

@Override public int getPartition(FlowBean key, Text value, int numPartitions) { // 1 获取手机号码前三位 String preNum = value.toString().substring(0, 3); int partition = 4; // 2 根据手机号归属地设置分区 if ("136".equals(preNum)) { partition = 0; }else if ("137".equals(preNum)) { partition = 1; }else if ("138".equals(preNum)) { partition = 2; }else if ("139".equals(preNum)) { partition = 3; }

return partition; }}(2)在驱动类中添加分区类// 加载自定义分区类job.setPartitionerClass(ProvincePartitioner.class);

// 设置Reducetask个数job.setNumReduceTasks(5);3.3.7 Combiner合并

 

(1 ) Combiner是MR程序中Mapper和Reducer之外的一种组件。

(2) Combiner组件的父类就是Reducer。(3) Combiner和Reducer的区别在于运行的位置Combiner是在每一个MapTask所在的节点运行;Reducer是接收全局所有Mapper的输出结果;(4 ) Cormbiner的意义就是对每一个MapTask的输出进行局部汇总，以减小网络传输量。

(5)Combiner能够应用的前提是不能影响最终的业务逻辑，而且，Combiner的输出kv应该跟Reducer的输入kv类型要对应起来。Mapp erReducer357->(3+5+7)/3=5(3+5+7+2+6)/5=23f5不等于(5+4)/2=9/226->(2+6)/2=4

(6)自定义Combiner实现步骤(a)自定义一个Combiner继承Reducer，重写Reduce方法public class WordcountCombiner extends Reducer<Text, IntWritable, Text,IntWritable>{

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

// 1 汇总操作 int count = 0; for(IntWritable v :values){ count += v.get(); }

// 2 写出 context.write(key, new IntWritable(count)); }}(b)在Job驱动类中设置： job.setCombinerClass(WordcountCombiner.class);3.3.8 Combiner合并案例实操1)需求统计过程中对每一个MapTask的输出进行局部汇总，以减小网络传输量即采用Combiner功能。(1)数据输入

(2)期望输出数据期望：Combine输入数据多，输出时经过合并，输出数据降低。2)需求分析

3)案例实操-方案一(1)增加一个WordcountCombiner类继承Reducerpackage com.atguigu.mr.combiner;import java.io.IOException;import org.apache.hadoop.io.IntWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Reducer;

public class WordcountCombiner extends Reducer<Text, IntWritable, Text, IntWritable>{

IntWritable v = new IntWritable();

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

// 1 汇总 int sum = 0;

for(IntWritable value :values){ sum += value.get(); }

v.set(sum);

// 2 写出 context.write(key, v); }}(2)在WordcountDriver驱动类中指定Combiner// 指定需要使用combiner，以及用哪个类作为combiner的逻辑job.setCombinerClass(WordcountCombiner.class);4)案例实操-方案二(1)将WordcountReducer作为Combiner在WordcountDriver驱动类中指定// 指定需要使用Combiner，以及用哪个类作为Combiner的逻辑job.setCombinerClass(WordcountReducer.class);运行程序，如下图所示

 

3.4 MapTask工作机制

(1)Read阶段：MapTask通过用户编写的RecordReader，从输入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)Combine阶段：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。 当所有数据处理完后，MapTask会将所有临时文件合并成一个大文件，并保存到文件output/file.out中，同时生成相应的索引文件output/file.out.index。 在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并io.sort.factor(默认10)个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。 让每个MapTask最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。3.5 ReduceTask工作机制

(1)Copy阶段：ReduceTask从各个MapTask上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。 (2)Merge阶段：在远程拷贝数据的同时，ReduceTask启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。 (3)Sort阶段：按照MapReduce语义，用户编写reduce()函数输入数据是按key进行聚集的一组数据。为了将key相同的数据聚在一起，Hadoop采用了基于排序的策略。由于各个MapTask已经实现对自己的处理结果进行了局部排序，因此，ReduceTask只需对所有数据进行一次归并排序即可。 (4)Reduce阶段：reduce()函数将计算结果写到HDFS上。1)设置ReduceTask并行度(个数)ReduceTask的并行度同样影响整个Job的执行并发度和执行效率，但与MapTask的并发数由切片数决定不同，ReduceTask数量的决定是可以直接手动设置：// 默认值是1，手动设置为4job.setNumReduceTasks(4);2)实验：测试ReduceTask多少合适(1)实验环境：1个Master节点，16个Slave节点：CPU:8GHZ，内存: 2G(2)实验结论：表 改变ReduceTask (数据量为1GB)MapTask =16ReduceTask 1 5 10 15 16 20 25 30 45 60总时间 892 146 110 92 88 100 128 101 145 1043)注意事项

(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 OutputFormat数据输出3.6.1 OutputFormat接口实现类

3.6.2 自定义OutputFormat

 

3.6.3 自定义OutputFormat案例实操1)需求 过滤输入的log日志，包含atguigu的网站输出到e:/atguigu.log，不包含atguigu的网站输出到e:/other.log。(1)输入数据

(2)期望输出数据

 

2)需求分析

 

3)案例实操(1)编写FilterMapper类package com.atguigu.mapreduce.outputformat;import java.io.IOException;import org.apache.hadoop.io.LongWritable;import org.apache.hadoop.io.NullWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Mapper;

public class FilterMapper extends Mapper<LongWritable, Text, Text, NullWritable>{ @Override protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

// 写出 context.write(value, NullWritable.get()); }}(2)编写FilterReducer类package com.atguigu.mapreduce.outputformat;import java.io.IOException;import org.apache.hadoop.io.NullWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Reducer;

public class FilterReducer extends Reducer<Text, NullWritable, Text, NullWritable> {

Text k = new Text();

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

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

// 2 拼接 line = line + "\r\n";

// 3 设置key k.set(line);

// 4 输出 context.write(k, NullWritable.get()); }}(3)自定义一个OutputFormat类package com.atguigu.mapreduce.outputformat;import java.io.IOException;import org.apache.hadoop.io.NullWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.RecordWriter;import org.apache.hadoop.mapreduce.TaskAttemptContext;import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class FilterOutputFormat extends FileOutputFormat<Text, NullWritable>{

@Override public RecordWriter<Text, NullWritable> getRecordWriter(TaskAttemptContext job) throws IOException, InterruptedException {

// 创建一个RecordWriter return new FilterRecordWriter(job); }}(4)编写RecordWriter类package com.atguigu.mapreduce.outputformat;import java.io.IOException;import org.apache.hadoop.fs.FSDataOutputStream;import org.apache.hadoop.fs.FileSystem;import org.apache.hadoop.fs.Path;import org.apache.hadoop.io.NullWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.RecordWriter;import org.apache.hadoop.mapreduce.TaskAttemptContext;

public class FilterRecordWriter extends RecordWriter<Text, NullWritable> {

FSDataOutputStream atguiguOut = null; FSDataOutputStream otherOut = null;

public FilterRecordWriter(TaskAttemptContext job) {

// 1 获取文件系统 FileSystem fs;

try { fs = FileSystem.get(job.getConfiguration());

// 2 创建输出文件路径 Path atguiguPath = new Path("e:/atguigu.log"); Path otherPath = new Path("e:/other.log");

// 3 创建输出流 atguiguOut = fs.create(atguiguPath); otherOut = fs.create(otherPath); } catch (IOException e) { e.printStackTrace(); } }

@Override public void write(Text key, NullWritable value) throws IOException, InterruptedException {

// 判断是否包含“atguigu”输出到不同文件 if (key.toString().contains("atguigu")) { atguiguOut.write(key.toString().getBytes()); } else { otherOut.write(key.toString().getBytes()); } }

@Override public void close(TaskAttemptContext context) throws IOException, InterruptedException {

// 关闭资源IOUtils.closeStream(atguiguOut); IOUtils.closeStream(otherOut); }}(5)编写FilterDriver类package com.atguigu.mapreduce.outputformat;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.Path;import org.apache.hadoop.io.NullWritable;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;

public class FilterDriver {

public static void main(String[] args) throws Exception {

// 输入输出路径需要根据自己电脑上实际的输入输出路径设置args = new String[] { "e:/input/inputoutputformat", "e:/output2" };

Configuration conf = new Configuration(); Job job = Job.getInstance(conf);

job.setJarByClass(FilterDriver.class); job.setMapperClass(FilterMapper.class); job.setReducerClass(FilterReducer.class);

job.setMapOutputKeyClass(Text.class); job.setMapOutputValueClass(NullWritable.class); job.setOutputKeyClass(Text.class); job.setOutputValueClass(NullWritable.class);

// 要将自定义的输出格式组件设置到job中 job.setOutputFormatClass(FilterOutputFormat.class);

FileInputFormat.setInputPaths(job, new Path(args[0]));

// 虽然我们自定义了outputformat，但是因为我们的outputformat继承自fileoutputformat // 而fileoutputformat要输出一个_SUCCESS文件，所以，在这还得指定一个输出目录 FileOutputFormat.setOutputPath(job, new Path(args[1]));

boolean result = job.waitForCompletion(true); System.exit(result ? 0 : 1); }}3.7 Join多种应用3.7.1 Reduce Join

3.7.2 Reduce Join案例实操1)需求表4-4 订单数据表t_orderid pid amount1001 01 11002 02 21003 03 31004 01 41005 02 51006 03 6表4-5 商品信息表t_productpid pname01 小米02 华为03 格力 将商品信息表中数据根据商品pid合并到订单数据表中。表4-6 最终数据形式id pname amount1001 小米 11004 小米 41002 华为 21005 华为 51003 格力 31006 格力 62)需求分析通过将关联条件作为Map输出的key，将两表满足Join条件的数据并携带数据所来源的文件信息，发往同一个ReduceTask，在Reduce中进行数据的串联。

3)代码实现(1)创建商品和订合并后的Bean类package com.atguigu.reducejoin;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;import java.io.DataOutput;import java.io.IOException;

public class OrderBean implements WritableComparable<OrderBean> { private String id; private String pid; private int amount; private String pname;

@Override public String toString() { return id + "\t" + pname + "\t" + amount; }

public String getId() { return id; }

public void setId(String id) { this.id = id; }

public String getPid() { return pid; }

public void setPid(String pid) { this.pid = pid; }

public int getAmount() { return amount; }

public void setAmount(int amount) { this.amount = amount; }

public String getPname() { return pname; }

public void setPname(String pname) { this.pname = pname; }

//按照Pid分组，组内按照pname排序，有pname的在前 @Override public int compareTo(OrderBean o) { int compare = this.pid.compareTo(o.pid); if (compare == 0) { return o.getPname().compareTo(this.getPname()); } else { return compare; } }

@Override public void write(DataOutput out) throws IOException { out.writeUTF(id); out.writeUTF(pid); out.writeInt(amount); out.writeUTF(pname); }

@Override public void readFields(DataInput in) throws IOException { id = in.readUTF(); pid = in.readUTF(); amount = in.readInt(); pname = in.readUTF(); }}(2)编写TableMapper类package com.atguigu.reducejoin;

import org.apache.hadoop.io.LongWritable;import org.apache.hadoop.io.NullWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Mapper;import org.apache.hadoop.mapreduce.lib.input.FileSplit;

import java.io.IOException;

public class OrderMapper extends Mapper<LongWritable, Text, OrderBean, NullWritable> {

private String filename;

private OrderBean order = new OrderBean();

@Override protected void setup(Context context) throws IOException, InterruptedException { //获取切片文件名 FileSplit fs = (FileSplit) context.getInputSplit(); filename = fs.getPath().getName(); }

@Override protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException { String[] fields = value.toString().split("\t"); //对不同数据来源分开处理 if ("order.txt".equals(filename)) { order.setId(fields[0]); order.setPid(fields[1]); order.setAmount(Integer.parseInt(fields[2])); order.setPname(""); } else { order.setPid(fields[0]); order.setPname(fields[1]); order.setAmount(0); order.setId(""); }

context.write(order, NullWritable.get()); }}(3)编写TableReducer类package com.atguigu.reducejoin;

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

import java.io.IOException;import java.util.Iterator;

public class OrderReducer extends Reducer<OrderBean, NullWritable, OrderBean, NullWritable> {

@Override protected void reduce(OrderBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException { //第一条数据来自pd，之后全部来自order Iterator<NullWritable> iterator = values.iterator(); //通过第一条数据获取pname iterator.next(); String pname = key.getPname(); //遍历剩下的数据，替换并写出 while (iterator.hasNext()) { iterator.next(); key.setPname(pname); context.write(key,NullWritable.get()); } }}(4)编写TableDriver类package com.atguigu.reducejoin;

import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.Path;import org.apache.hadoop.io.NullWritable;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 OrderDriver { public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException { Job job = Job.getInstance(new Configuration()); job.setJarByClass(OrderDriver.class);

job.setMapperClass(OrderMapper.class); job.setReducerClass(OrderReducer.class); job.setGroupingComparatorClass(OrderComparator.class);

job.setMapOutputKeyClass(OrderBean.class); job.setMapOutputValueClass(NullWritable.class);

job.setOutputKeyClass(OrderBean.class); job.setOutputValueClass(NullWritable.class);

FileInputFormat.setInputPaths(job, new Path("d:\\input")); FileOutputFormat.setOutputPath(job, new Path("d:\\output"));

boolean b = job.waitForCompletion(true);

System.exit(b ? 0 : 1);

}}4)测试运行程序查看结果1001 小米 1 1001 小米 1 1002 华为 2 1002 华为 2 1003 格力 3 1003 格力 3 5)总结

3.7.3 Map Join1)使用场景Map Join适用于一张表十分小、一张表很大的场景。2)优点思考：在Reduce端处理过多的表，非常容易产生数据倾斜。怎么办？在Map端缓存多张表，提前处理业务逻辑，这样增加Map端业务，减少Reduce端数据的压力，尽可能的减少数据倾斜。3)具体办法：采用DistributedCache (1)在Mapper的setup阶段，将文件读取到缓存集合中。 (2)在驱动函数中加载缓存。// 缓存普通文件到Task运行节点。job.addCacheFile(new URI("file://e:/cache/pd.txt"));3.7.4 Map Join案例实操1)需求表 订单数据表t_orderid pid amount1001 01 11002 02 21003 03 31004 01 41005 02 51006 03 6表 商品信息表t_productpid pname01 小米02 华为03 格力 将商品信息表中数据根据商品pid合并到订单数据表中。表 最终数据形式id pname amount1001 小米 11004 小米 41002 华为 21005 华为 51003 格力 31006 格力 62)需求分析MapJoin适用于关联表中有小表的情形。  

3)实现代码(1)先在驱动模块中添加缓存文件package test;import java.net.URI;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.Path;import org.apache.hadoop.io.NullWritable;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;

public class DistributedCacheDriver {

public static void main(String[] args) throws Exception {// 0 根据自己电脑路径重新配置args = new String[]{"e:/input/inputtable2", "e:/output1"};

// 1 获取job信息 Configuration configuration = new Configuration(); Job job = Job.getInstance(configuration);

// 2 设置加载jar包路径 job.setJarByClass(DistributedCacheDriver.class);

// 3 关联map job.setMapperClass(DistributedCacheMapper.class);// 4 设置最终输出数据类型 job.setOutputKeyClass(Text.class); job.setOutputValueClass(NullWritable.class);

// 5 设置输入输出路径 FileInputFormat.setInputPaths(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1]));

// 6 加载缓存数据 job.addCacheFile(new URI("file:///e:/input/inputcache/pd.txt")); // 7 Map端Join的逻辑不需要Reduce阶段，设置reduceTask数量为0 job.setNumReduceTasks(0);

// 8 提交 boolean result = job.waitForCompletion(true); System.exit(result ? 0 : 1); }}(2)读取缓存的文件数据package com.atguigu.mapjoin;

import org.apache.commons.lang.StringUtils;import org.apache.hadoop.fs.FSDataInputStream;import org.apache.hadoop.fs.FileSystem;import org.apache.hadoop.fs.Path;import org.apache.hadoop.io.IOUtils;import org.apache.hadoop.io.LongWritable;import org.apache.hadoop.io.NullWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Mapper;

import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.net.URI;import java.util.HashMap;import java.util.Map;

public class MjMapper extends Mapper<LongWritable, Text, Text, NullWritable> {

//pd表在内存中的缓存 private Map<String, String> pMap = new HashMap<>();

private Text line = new Text();

//任务开始前将pd数据缓存进PMap @Override protected void setup(Context context) throws IOException, InterruptedException { //从缓存文件中找到pd.txt URI[] cacheFiles = context.getCacheFiles(); Path path = new Path(cacheFiles[0]);

//获取文件系统并开流 FileSystem fileSystem = FileSystem.get(context.getConfiguration()); FSDataInputStream fsDataInputStream = fileSystem.open(path);

//通过包装流转换为reader BufferedReader bufferedReader = new BufferedReader( new InputStreamReader(fsDataInputStream, "utf-8"));

//逐行读取，按行处理 String line; while (StringUtils.isNotEmpty(line = bufferedReader.readLine())) { String[] fields = line.split("\t"); pMap.put(fields[0], fields[1]); }

//关流 IOUtils.closeStream(bufferedReader);

}

@Override protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException { String[] fields = value.toString().split("\t");

String pname = pMap.get(fields[1]);

line.set(fields[0] + "\t" + pname + "\t" + fields[2]);

context.write(line, NullWritable.get()); }}3.8 计数器应用

Hadoop为每个作业维护若干内置计数器，以描术多项指标。例如，某些计数器记录已处理的字节数和记录数，使用户可监控已处理的输入数据量和已产生的输出数据量。1．计数器API(1)采用枚举的方式统计计数enurnMyCounter{MALFORORMEDNORMAL)!/对枚举定义的自定义计数器加1context.getCounter(MyCounter.MALFORORMED).increrment(1 ),(2)采用计数器组、计数器名称的方式统计cortext.getCounter(" counterGroup" , " counter" ).increnent(1);组名和l数器名称随便起，但最好有意义。(3)计数结果在程序运行后的控制台上查看。2.计数器案例实操详见数据清洗案例。

3.9 数据清洗(ETL)在运行核心业务MapReduce程序之前，往往要先对数据进行清洗，清理掉不符合用户要求的数据。清理的过程往往只需要运行Mapper程序，不需要运行Reduce程序。1)需求去除日志中字段个数小于等于11的日志。(1)输入数据

(2)期望输出数据每行字段长度都大于11。2)需求分析需要在Map阶段对输入的数据根据规则进行过滤清洗。3)实现代码(1)编写LogMapper类package com.atguigu.mapreduce.weblog;import java.io.IOException;import org.apache.hadoop.io.LongWritable;import org.apache.hadoop.io.NullWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Mapper;

public class LogMapper extends Mapper<LongWritable, Text, Text, NullWritable>{ Text k = new Text(); @Override protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException { // 1 获取1行数据 String line = value.toString(); // 2 解析日志 boolean result = parseLog(line,context); // 3 日志不合法退出 if (!result) { return; } // 4 设置key k.set(line); // 5 写出数据 context.write(k, NullWritable.get()); }

// 2 解析日志 private boolean parseLog(String line, Context context) {

// 1 截取 String[] fields = line.split(" "); // 2 日志长度大于11的为合法 if (fields.length > 11) {

// 系统计数器 context.getCounter("map", "true").increment(1); return true; }else { context.getCounter("map", "false").increment(1); return false; } }}(2)编写LogDriver类package com.atguigu.mapreduce.weblog;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.Path;import org.apache.hadoop.io.NullWritable;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;

public class LogDriver {

public static void main(String[] args) throws Exception {

// 输入输出路径需要根据自己电脑上实际的输入输出路径设置 args = new String[] { "e:/input/inputlog", "e:/output1" };

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

// 2 加载jar包 job.setJarByClass(LogDriver.class);

// 3 关联map job.setMapperClass(LogMapper.class);

// 4 设置最终输出类型 job.setOutputKeyClass(Text.class); job.setOutputValueClass(NullWritable.class);

// 设置reducetask个数为0 job.setNumReduceTasks(0);

// 5 设置输入和输出路径 FileInputFormat.setInputPaths(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1]));

// 6 提交 job.waitForCompletion(true); }}3.10 MapReduce开发总结

第4章 Yarn资源调度器Yarn是一个资源调度平台，负责为运算程序提供服务器运算资源，相当于一个分布式的操作系统平台，而MapReduce等运算程序则相当于运行于操作系统之上的应用程序。4.1 Yarn基本架构

  YARN主要由ResourceManager、NodeManager、ApplicationMaster和Container等组件构成。

4.2 Yarn工作机制

(1)MR程序提交到客户端所在的节点。  阿善背诵 (2)YarnRunner向ResourceManager申请一个Application。 (3)RM将该应用程序的资源路径返回给YarnRunner。 (4)该程序将运行所需资源提交到HDFS上。 (5)程序资源提交完毕后，申请运行mrAppMaster。 (6)RM将用户的请求初始化成一个Task。 (7)其中一个NodeManager领取到Task任务。 (8)该NodeManager创建容器Container，并产生MRAppmaster。 (9)Container从HDFS上拷贝资源到本地。 (10)MRAppmaster向RM 申请运行MapTask资源。 (11)RM将运行MapTask任务分配给另外两个NodeManager，另两个NodeManager分别领取任务并创建容器。 (12)MR向两个接收到任务的NodeManager发送程序启动脚本，这两个NodeManager分别启动MapTask，MapTask对数据分区排序。(13)MrAppMaster等待所有MapTask运行完毕后，向RM申请容器，运行ReduceTask。 (14)ReduceTask向MapTask获取相应分区的数据。 (15)程序运行完毕后，MR会向RM申请注销自己。4.3 作业提交全过程

 作业提交全过程详解
(1)作业提交
第1步：Client调用job.waitForCompletion方法，向整个集群提交MapReduce作业。
第2步：Client向RM申请一个作业id。
第3步：RM给Client返回该job资源的提交路径和作业id。
第4步：Client提交jar包、切片信息和配置文件到指定的资源提交路径。
第5步：Client提交完资源后，向RM申请运行MrAppMaster。
(2)作业初始化
第6步：当RM收到Client的请求后，将该job添加到容量调度器中。
第7步：某一个空闲的NM领取到该Job。
第8步：该NM创建Container，并产生MRAppmaster。
第9步：下载Client提交的资源到本地。
(3)任务分配
第10步：MrAppMaster向RM申请运行多个MapTask任务资源。
第11步：RM将运行MapTask任务分配给另外两个NodeManager，另两个NodeManager分别领取任务并创建容器。
(4)任务运行
第12步：MR向两个接收到任务的NodeManager发送程序启动脚本，这两个NodeManager分别启动MapTask，MapTask对数据分区排序。
第13步：MrAppMaster等待所有MapTask运行完毕后，向RM申请容器，运行ReduceTask。
第14步：ReduceTask向MapTask获取相应分区的数据。
第15步：程序运行完毕后，MR会向RM申请注销自己。
(5)进度和状态更新
YARN中的任务将其进度和状态(包括counter)返回给应用管理器, 客户端每秒(通过mapreduce.client.progressmonitor.pollinterval设置)向应用管理器请求进度更新, 展示给用户。
(6)作业完成
除了向应用管理器请求作业进度外, 客户端每5秒都会通过调用waitForCompletion()来检查作业是否完成。时间间隔可以通过mapreduce.client.completion.pollinterval来设置。作业完成之后, 应用管理器和Container会清理工作状态。作业的信息会被作业历史服务器存储以备之后用户核查。

4.4 资源调度器目前，Hadoop作业调度器主要有三种：FIFO、Capacity Scheduler和Fair Scheduler。Hadoop3.1.3默认的资源调度器是Capacity Scheduler。具体设置详见：yarn-default.xml文件<property> <description>The class to use as the resource scheduler.</description> <name>yarn.resourcemanager.scheduler.class</name><value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value></property>1)先进先出调度器(FIFO)

2)容量调度器(Capacity Scheduler)

3)公平调度器(Fair Schedule

 

4.5 容量调度器多队列提交案例4.5.1 需求 Yarn默认的容量调度器是一条单队列的调度器，在实际使用中会出现单个任务阻塞整个队列的情况。同时，随着业务的增长，公司需要分业务限制集群使用率。这就需要我们按照业务种类配置多条任务队列。4.5.2 配置多队列的容量调度器默认Yarn的配置下，容量调度器只有一条Default队列。在capacity-scheduler.xml中可以配置多条队列，并降低default队列资源占比：<property> <name>yarn.scheduler.capacity.root.queues</name> <value>default,hive</value> <description> The queues at the this level (root is the root queue). </description></property><property> <name>yarn.scheduler.capacity.root.default.capacity</name> <value>40</value></property>同时为新加队列添加必要属性：<property> <name>yarn.scheduler.capacity.root.hive.capacity</name> <value>60</value></property>

<property> <name>yarn.scheduler.capacity.root.hive.user-limit-factor</name> <value>1</value></property>

<property> <name>yarn.scheduler.capacity.root.hive.maximum-capacity</name> <value>80</value></property>

<property> <name>yarn.scheduler.capacity.root.hive.state</name> <value>RUNNING</value></property>

<property> <name>yarn.scheduler.capacity.root.hive.acl_submit_applications</name> <value>*</value></property>

<property> <name>yarn.scheduler.capacity.root.hive.acl_administer_queue</name> <value>*</value></property>

<property> <name>yarn.scheduler.capacity.root.hive.acl_application_max_priority</name> <value>*</value></property>

<property> <name>yarn.scheduler.capacity.root.hive.maximum-application-lifetime</name> <value>-1</value></property>

<property> <name>yarn.scheduler.capacity.root.hive.default-application-lifetime</name> <value>-1</value></property>在配置完成后，重启Yarn，就可以看到两条队列：

4.5.3 向Hive队列提交任务 默认的任务提交都是提交到default队列的。如果希望向其他队列提交任务，需要在Driver中声明：public class WcDrvier { public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException { Configuration configuration = new Configuration();

configuration.set("mapred.job.queue.name", "hive");

//1. 获取一个Job实例 Job job = Job.getInstance(configuration);

//2. 设置类路径 job.setJarByClass(WcDrvier.class);

//3. 设置Mapper和Reducer job.setMapperClass(WcMapper.class); job.setReducerClass(WcReducer.class);

//4. 设置Mapper和Reducer的输出类型 job.setMapOutputKeyClass(Text.class); job.setMapOutputValueClass(IntWritable.class);

job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class);

job.setCombinerClass(WcReducer.class);

//5. 设置输入输出文件 FileInputFormat.setInputPaths(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1]));

//6. 提交Job boolean b = job.waitForCompletion(true); System.exit(b ? 0 : 1); }}这样，这个任务在集群提交时，就会提交到hive队列：

第5章 常见错误及解决方案1)导包容易出错。尤其Text和CombineTextInputFormat。2)Mapper中第一个输入的参数必须是LongWritable或者NullWritable，不可以是IntWritable. 报的错误是类型转换异常。3)java.lang.Exception: java.io.IOException: Illegal partition for 13926435656 (4)，说明Partition和ReduceTask个数没对上，调整ReduceTask个数。4)如果分区数不是1，但是reducetask为1，是否执行分区过程。答案是：不执行分区过程。因为在MapTask的源码中，执行分区的前提是先判断ReduceNum个数是否大于1。不大于1肯定不执行。5)在Windows环境编译的jar包导入到Linux环境中运行，hadoop jar wc.jar com.atguigu.mapreduce.wordcount.WordCountDriver /user/atguigu/ /user/atguigu/output报如下错误：Exception in thread "main" java.lang.UnsupportedClassVersionError: com/atguigu/mapreduce/wordcount/WordCountDriver : Unsupported major.minor version 52.0原因是Windows环境用的jdk1.7，Linux环境用的jdk1.8。解决方案：统一jdk版本。6)缓存pd.txt小文件案例中，报找不到pd.txt文件原因：大部分为路径书写错误。还有就是要检查pd.txt.txt的问题。还有个别电脑写相对路径找不到pd.txt，可以修改为绝对路径。7)报类型转换异常。通常都是在驱动函数中设置Map输出和最终输出时编写错误。Map输出的key如果没有排序，也会报类型转换异常。8)集群中运行wc.jar时出现了无法获得输入文件。原因：WordCount案例的输入文件不能放用HDFS集群的根目录。9)出现了如下相关异常Exception in thread "main" java.lang.UnsatisfiedLinkError: org.apache.hadoop.io.nativeio.NativeIO$Windows.access0(Ljava/lang/String;I)Z at org.apache.hadoop.io.nativeio.NativeIO$Windows.access0(Native Method) at org.apache.hadoop.io.nativeio.NativeIO$Windows.access(NativeIO.java:609) at org.apache.hadoop.fs.FileUtil.canRead(FileUtil.java:977)java.io.IOException: Could not locate executable null\bin\winutils.exe in the Hadoop binaries. at org.apache.hadoop.util.Shell.getQualifiedBinPath(Shell.java:356) at org.apache.hadoop.util.Shell.getWinUtilsPath(Shell.java:371) at org.apache.hadoop.util.Shell.<clinit>(Shell.java:364)解决方案：拷贝hadoop.dll文件到Windows目录C:\Windows\System32。个别同学电脑还需要修改Hadoop源码。方案二：创建如下包名，并将NativeIO.java拷贝到该包名下

10)自定义Outputformat时，注意在RecordWirter中的close方法必须关闭流资源。否则输出的文件内容中数据为空。@Overridepublic void close(TaskAttemptContext context) throws IOException, InterruptedException { if (atguigufos != null) { atguigufos.close(); } if (otherfos != null) { otherfos.close(); }}

需求:统计一堆文件中单词出现的个数( WordCount案例)U尚硅谷1、输入数据2、输出数据atgigu atguiguatguigu 2ss ssbanzhang1cls c1scls 2jiaohadoop 1bannzhangjiao 1xuess 2hadoopxue13、Mapper4、 Reducer5、Driver[13.1 格MlapTask传给我们的文本4.1汇总各个key的个数内容先转换成Sting15.1获取配置信息,获取j站对象实例atguigu atguiguatguigu, 15.2指定本程序的j ar包,所在的本地路径atguigu, 115.3关联MappersReducer业务类13.2根据空格将这—行切分成单词atguigu4.2输出该kex的总次数15.4指定Mapper输出数据的kv类型atguiguatguigu. 215.5指定最终输出的数据的kv类型 3.3将单词输出为<单词，1>15.6指定job的输入原始文件所在目录atguigu, 115.7指定job的输出结果所在目录atguigu,1{5.8提交作业子涅方省学的技人