ReduceTask的shuffle流程(包括分组比较器，数据清洗，计数器等)

ReduceTask总流程说明

（1）Copy阶段：ReduceTask从各个MapTask上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。
（2）Merge阶段：在远程拷贝数据的同时，ReduceTask启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。
（3）Sort阶段：按照MapReduce语义，用户编写reduce()函数输入数据是按key进行聚集的一组数据。为了将key相同的数据聚在一起，Hadoop采用了基于排序的策略。由于各个MapTask已经实现对自己的处理结果进行了局部排序，因此，ReduceTask只需对所有数据进行一次归并排序即可。
（4）Reduce阶段：reduce()函数将计算结果写到HDFS上。

[注]shuffle线程拷贝多个MapTask同一分区的数据，拷贝后执行merge和sort,如果数据量过大，需要将部分数据先合并排序后，溢写到磁盘！如果设置了Combiner，Combiner会再次运行！

ReduceTask的shuffle细节

获取分组比较器

key相同的分为一组。

public RawComparator getOutputValueGroupingComparator() {
// 从配置中读取mapreduce.job.output.group.comparator.class， 
    Class<? extends RawComparator> theClass = getClass(
      JobContext.GROUP_COMPARATOR_CLASS, null, RawComparator.class);
//如果没有设置，默认使用MapTask对key排序时，key的比较器
    if (theClass == null) {
      return getOutputKeyComparator();
    }
    // 否则用户设置了，就使用用户自定义的比较器
    return ReflectionUtils.newInstance(theClass, this);
  }

排序分类

分组案例

具体需求

需求：统计同一笔订单中，金额最大的商品记录输出
分析得出： 在同一笔订单中，对每条记录的金额进行降序排序，最大的排前边，初始数据如下，orderid是订单号，pid是商品号，account是金额。

orderid		  pid		acount
10000001	Pdt_01	    222.8
10000002	Pdt_06	    722.4
10000001	Pdt_02	    222.8
10000001	Pdt_05	    25.8
10000003	Pdt_01	    232.8
10000003	Pdt_01	    33.8
10000002	Pdt_04	    122.4
10000002	Pdt_03	    522.8

①orderid和acount属性都必须作为key
②针对key，提供compareTo()，先按照orderid排序(升降序都可以)，再按照acount(降序)排序

那么经过Mapper时：

keyin-valuein
map()
keyout-valueout

然后经过shuffle后的数据为：

10000001	Pdt_02	222.8
10000001	Pdt_01	222.8
10000001	Pdt_05	25.8
10000002	Pdt_06	722.4
10000002	Pdt_03	522.8
10000002	Pdt_04	122.4
10000003	Pdt_01	232.8
10000003	Pdt_01	33.8

然后进入Reduce
获取分组比较器，如果没设置默认使用MapTask排序时key的比较器！
默认的比较器比较策略不符合要求，它会将orderId一样且acount一样的记录才认为是一组的！

自定义分组比较器，只按照orderId进行对比，只要OrderId一样，认为key相等，这样可以将orderId相同的分到一个组！
分组后如下：

10000001	Pdt_02	222.8
10000001	Pdt_01	222.8
10000001	Pdt_05	25.8

10000002	Pdt_06	722.4
10000002	Pdt_03	522.8
10000002	Pdt_04	122.4

10000003	Pdt_01	232.8
10000003	Pdt_01	33.8

在组内去第一个最大的即可！

Reducer
keyin-valuein
reduce()
keyout-valueout

编写代码

自定义orderbean:

public class OrderBean implements WritableComparable<OrderBean>{
	
	private String orderId;
	private String pId;
	private Double acount;
	public String getOrderId() {
		return orderId;
	}
	public void setOrderId(String orderId) {
		this.orderId = orderId;
	}
	public String getpId() {
		return pId;
	}
	public void setpId(String pId) {
		this.pId = pId;
	}
	public Double getAcount() {
		return acount;
	}
	public void setAcount(Double acount) {
		this.acount = acount;
	}
	public OrderBean() {
		
	}
	@Override
	public String toString() {
		return orderId + "\t" + pId + "\t" + acount ;
	}
	@Override
	public void write(DataOutput out) throws IOException {
		out.writeUTF(orderId);
		out.writeUTF(pId);
		out.writeDouble(acount);
		
	}
	@Override
	public void readFields(DataInput in) throws IOException {
		orderId=in.readUTF();
		pId=in.readUTF();
		acount=in.readDouble();
	}
	
	// 二次排序，先按照orderid排序(升降序都可以)，再按照acount(降序)排序
	@Override
	public int compareTo(OrderBean o) {
		
		//先按照orderid排序升序排序
		int result=this.orderId.compareTo(o.getOrderId());
		
		if (result==0) {
			//再按照acount(降序)排序
			result=-this.acount.compareTo(o.getAcount());
			
		}
		
		return result;
	}
}

Mapper

public class OrderMapper extends Mapper<LongWritable, Text, OrderBean, NullWritable>{
	
	private OrderBean out_key=new OrderBean();
	private NullWritable out_value=NullWritable.get();
	
	@Override
	protected void map(LongWritable key, Text value,
			Mapper<LongWritable, Text, OrderBean, NullWritable>.Context context)
			throws IOException, InterruptedException {
		
		String[] words = value.toString().split("\t");
		
		out_key.setOrderId(words[0]);
		out_key.setpId(words[1]);
		out_key.setAcount(Double.parseDouble(words[2]));
		
		context.write(out_key, out_value);
		
	}

}

Reducer

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

	/*
	 * OrderBean key-NullWritable nullWritable在reducer工作期间，
	 * 	只会实例化一个key-value的对象！
	 * 		每次调用迭代器迭代下个记录时，使用反序列化器从文件中或内存中读取下一个key-value数据的值，
	 * 		封装到之前OrderBean key-NullWritable nullWritable在reducer的属性中
	 */
	@Override
	protected void reduce(OrderBean key, Iterable<NullWritable> values,
			Reducer<OrderBean, NullWritable, OrderBean, NullWritable>.Context context)
			throws IOException, InterruptedException {
		
		Double maxAcount = key.getAcount();
		
		for (NullWritable nullWritable : values) {
			
			if (!key.getAcount().equals(maxAcount)) {
				break;
			}
			//复合条件的记录
			context.write(key, nullWritable);
			
		}
		
	}
	
}

自定义分组比较器

public class MyGroupingComparator implements RawComparator<OrderBean>{
	
	private OrderBean key1=new OrderBean();
	private OrderBean key2=new OrderBean();
	private  DataInputBuffer buffer=new DataInputBuffer();

	@Override
	public int compare(OrderBean o1, OrderBean o2) {
		return o1.getOrderId().compareTo(o2.getOrderId());
	}

	@Override
	public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
		
		try {
		      buffer.reset(b1, s1, l1);                   // parse key1
		      key1.readFields(buffer);
		      
		      buffer.reset(b2, s2, l2);                   // parse key2
		      key2.readFields(buffer);
		      
		      buffer.reset(null, 0, 0);                   // clean up reference
		    } catch (IOException e) {
		      throw new RuntimeException(e);
		    }
		
		return compare(key1, key2);
	}

}

driver

public class OrderBeanDriver {
	
	public static void main(String[] args) throws Exception {
		
		Path inputPath=new Path("E:\\mrinput\\groupcomparator");
		Path outputPath=new Path("e:/mroutput/groupcomparator");
		
		//作为整个Job的配置
		Configuration conf = new Configuration();
		
		//保证输出目录不存在
		FileSystem fs=FileSystem.get(conf);
		
		if (fs.exists(outputPath)) {
			
			fs.delete(outputPath, true);
			
		}
		
		// ①创建Job
		Job job = Job.getInstance(conf);
		
		// ②设置Job
		// 设置Job运行的Mapper，Reducer类型，Mapper,Reducer输出的key-value类型
		job.setMapperClass(OrderMapper.class);
		job.setReducerClass(OrderReducer.class);
		
		// Job需要根据Mapper和Reducer输出的Key-value类型准备序列化器，通过序列化器对输出的key-value进行序列化和反序列化
		// 如果Mapper和Reducer输出的Key-value类型一致，直接设置Job最终的输出类型

		job.setOutputKeyClass(OrderBean.class);
		job.setOutputValueClass(NullWritable.class);
		
		// 设置输入目录和输出目录
		FileInputFormat.setInputPaths(job, inputPath);
		FileOutputFormat.setOutputPath(job, outputPath);
		
		// 设置自定义的分组比较器
		job.setGroupingComparatorClass(MyGroupingComparator2.class);
		
		// ③运行Job
		job.waitForCompletion(true);
		
		
	}

}

计数器

ETL数据清洗

在运行核心业务MapReduce程序之前，往往要先对数据进行清洗，清理掉不符合用户要求的数据。清理的过程往往只需要运行Mapper程序，不需要运行Reduce程序。

需求

1．需求
去除日志中字段长度小于等于11的日志。
期望输出数据
每行字段长度都大于11。

2.需求分析
需要在Map阶段对输入的数据根据规则进行过滤清洗。

实现代码

LogMapper

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;
		}
	}
}

LogDriver

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);
	}
}