[大数据]Hadoop(3)MapReduce(3)

3.2 Shuffle机制

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

3.2.1 Shuffle机制：

shuffle过程：
（1）MapTask收集我们的map()方法输出的kv对，放到内存缓冲区中。
（2）从内存缓冲区不断溢出本地磁盘文件，可能会溢出多个文件。
（3）多个溢出文件会被合并成大的溢出文件。
（4）在溢出过程及合并的过程中，都要调用Partitioner进行分区和针对key进行排序。
（5）ReduceTask根据自己的分区号，去各个MapTask机器上取相应的结果分区数据。
（6）ReduceTask会取到同一个分区的来自不同MapTask的结果文件，ReduceTask会将这些文件再进行合并（归并排序）。
（7）合并成大文件后，Shuffle的过程也就结束了，后面进入ReduceTask的逻辑运算过程（从文件中取出一个一个的键值对Group，调用用户自定义的reduce()方法）。

3.2.2 Partition分区

Partition是用来指定map输出的key交给哪个reducer处理，默认通过对map输出的key去hashcode对指定的reduce个数取余。partition决定reduce数，业务又决定reduce数。

默认情况下，作业的ReduceNum=1，每一个Reduce对应生成一个结果文件。如果ReduceNum=0，则没有reduce阶段。

partition分区机制：
默认情况下，分区采用org.apache.hadoop.mapreduce.Partitioner抽象类说明，分类器按照key进行分区，提供getPartition()方法用于获取当前key对应的分区号。通常情况下，采用hash分区，分区总数与reducer数量相同。
源码：

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

  /** Use {@link Object#hashCode()} to partition. */
  public int getPartition(K key, V value,int numReduceTasks) {
    	return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
  }	
}
//这里的与Integer.MAX_VALUE做与运算代表处理负数，及与全1的数与，去掉负号

自定义partition：

eg：同序列化案例2.3中的文件phone_data.txt,期望将手机号136、137、138、139开头都分别放到一个独立的4个文件中，其他开头的放到一个文件中。
自定义分区类MyPartitioner.java，继承Partitioner类，输入泛型为map输出的kv对。

import com.atguigu.mr.flow.FlowBean;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

public class MyPartitioner extends Partitioner<Text, FlowBean> {
    /**
     * 对每一条KV对返回它们对应的分区号
     *
     * @param text 手机号
     * @param flowBean 流量
     * @param i
     * @return
     */
    @Override
    public int getPartition(Text text, FlowBean flowBean, int i) {
        String phone_head = text.toString().substring(0, 3);
        switch (phone_head) {
            case "136":
                return 0;
            case "137":
                return 1;
            case "138":
                return 2;
            case "139":
                return 3;
            default:
                return 4;
        }
    }
}

在驱动类中定义Reduce的个数为5，并设置分区类

job.setNumReduceTasks(5);
job.setPartitionerClass(ProvincePartitioner.class);

提交到hadoop服务器验证：


分区成功。

3.2.3 WritableComparable比较器

WritableComparable是mapreduce的默认比较器，会调用compareTo方法。

MapTask和ReduceTask均会对数据按照key进行排序。该操作属于Hadoop的默认行为。任何应用程序的数据均会被排序，而不管逻辑上是否需要。默认排序是按照字典序排序，且实现排序的方法是快速排序。

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

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

（1）部分排序：MapReduce根据输入记录的键对数据集进行排序，保证输出的每个文件内部有序。
（2）全排序：最终的输出结果只有一个文件，且文件内部有序。实现方式是实现一个ReduceTask。但该方法在处理大型文件时效率极低，因为一台机器处理所有文件，完全丧失了MapReduce所提供的并行架构。
（3）辅助排序：在Reduce端对key进行分组，应用于：在接受的key为bean对象时，想让一个或几个字段相同（全部字段相同的不比较）的key进入到同一个reduce方法时，可以才作用分组排序。
（4）二次排序：在自定义排序过程中，如果compareTo中的判断条件为两个则为二次排序。

自定义实现WritableComparable

对案例2.3的结果再次按照总流量的大小进行排序。

方法1：使用默认Comparator，调用compareTo方法

实现WritableCompare接口，重写compareTo方法。

在原FlowBean类中修改为：

import org.apache.hadoop.io.WritableComparable;

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

/**
 * 实现WritableCompareable接口
 */
public class FlowBean implements WritableComparable<FlowBean> {
	//...原FlowBean方法
    /**
     * 排序方法，按照总流量的降序进行排序
     *
     * @param o
     * @return
     */
    @Override
    public int compareTo(FlowBean o) {
        if (this.sumFlow < o.sumFlow) return 1;
        else if (this.sumFlow == o.sumFlow) return 0;
        else return -1;
    }
}

CompareMapper.java

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

import java.io.IOException;
//注意传入的泛型顺序，Mapper会默认以key的位置进行排序，所以FlowBean在前
public class CompareMapper extends Mapper<LongWritable, Text, FlowBean, Text> {
    private Text phone = new Text();
    private FlowBean flow = new FlowBean();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String line = value.toString();
        String[] fields = line.split("\t");
        phone.set(fields[0]);
        flow.setUpFlow(Long.parseLong(fields[1]));
        flow.setDownFlow(Long.parseLong(fields[2]));
        flow.setSumFlow(Long.parseLong(fields[3]));
        context.write(flow, phone);
    }
}

CompareReducer.java

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

import java.io.IOException;

//收到的数据时手机号在后，流量在前，输出的时候手机号在前。
public class CompareReducer extends Reducer<FlowBean, Text, Text, FlowBean> {
    /**
     * reduce收到的数据已经排完序了，直接输出
     *
     * @param key
     * @param values
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        for (Text value : values) {
            context.write(value, key);
        }
    }
}

CompareDriver.java

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class CompareDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Job job = Job.getInstance(new Configuration());
        job.setJarByClass(CompareDriver.class);

        job.setMapperClass(CompareMapper.class);
        job.setReducerClass(CompareReducer.class);

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

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

        boolean b = job.waitForCompletion(true);
        System.exit(b ? 0 : 1);
    }
}

输出结果：按照总流量降序进行输出

方法2：自己实现Comparator

FlowComparator.java

import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

public class FlowComparator extends WritableComparator {
    protected FlowComparator() {
        super(FlowBean.class, true);
    }

    @Override
    public int compare(WritableComparable a, WritableComparable b) {
        FlowBean fa = (FlowBean) a;
        FlowBean fb = (FlowBean) b;
        return Long.compare(fb.getSumFlow(), fa.getSumFlow());
    }
}

在Driver中添加

job.setSortComparatorClass(FlowComparator.class);

调用自己实现的Comparator类。

3.2.4 Combiner

（1）Combiner时MR程序中Mapper和Reducer之外的一种组件。
（2）Combiner组件的父类就是Reducer。
（3）Combiner和Reducer的区别在于运行的位置。Combiner在每一个MapTask节点运行，Reducer是接受全局所有的Mapper输出结果。
（4）Combiner的意义就是对每一个MapTask的输出进行局部汇总，以减少网络传输量（IO）。
（5）Combiner能够应用的前提是不能影响最终的业务逻辑，而且Combiner的输出kv应该与Reducer的输入kv类型对应起来。

自定义实现Combiner方法：

需求：统计过程中对每一个MapTask的输出进行局部汇总，以减小网络传输量即采用Combiner功能。

方法一：
1）增加一个WordcountCombiner类继承Reducer。
2）在WordcountCombiner中汇总单词，将结果输出。

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

// 指定需要使用combiner，以及用哪个类作为combiner的逻辑
job.setCombinerClass(WordcountCombiner.class);

方法二：
将WordcountReducer作为Combiner在WordcountDriver驱动类中指定。

// 指定需要使用Combiner，以及用哪个类作为Combiner的逻辑
job.setCombinerClass(WordcountReducer.class);

运行结果：

使用前：

使用后：

3.2.5 GroupingComparator（辅助排序）

对Reduce阶段的数据根据某一个或几个字段进行分组。由于reduce阶段，如果key相同的一组，只取第一个key作为key，迭代所有的values。如果reduce的key是bean，我们只需要bean里面的某个属性相同就认为这样的key是相同的，这样就需要定义GroupComparator来辅助排序了。

自定义GroupingComparator分组：
需求:
由如下订单数据

现在需要求出每一个订单中最贵的商品。

1）输入数据

0000001 Pdt_01 222.8
0000002 Pdt_05 722.4
0000001 Pdt_02 33.8
0000003 Pdt_06 232.8
0000003 Pdt_02 33.8
0000002 Pdt_03 522.8
0000002 Pdt_04 122.4

2）期望输出

1 222.8
2 722.4
3 232.8

3）需求分析
（1）利用“订单id和成交金额”作为key，可以将Map阶段读取到的所有订单数据按照id升序排序，如果id相同再按照金额降序排序，发送到Reduce。

（2）在Reduce端利用groupingComparator将订单id相同的kv聚合成组，然后取第一个即是该订单中最贵商品，如图所示。

4）实现

1.定义JavaBean来存储订单信息

OrderBean.java

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 orderId;
    private String productId;
    private double price;

    @Override
    public String toString() {
        return orderId + "\t" + productId + "\t" + price;
    }

    /**
     * 排序逻辑：先按照订单排序，订单相同按照价格降序排列
     *
     * @param o
     * @return
     */
    @Override
    public int compareTo(OrderBean o) {
        int compare = this.orderId.compareTo(o.orderId);
        if (compare != 0) {
            return compare;
        } else {
            return Double.compare(o.price, this.price);
        }
    }

    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(orderId);
        dataOutput.writeUTF(productId);
        dataOutput.writeDouble(price);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.orderId = dataInput.readUTF();
        this.productId = dataInput.readUTF();
        this.price = dataInput.readDouble();
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

2.实现分组比较器，只使用bean中的订单编号作为分组依据

OrderComparator.java

import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

/**
 * 按照订单编号对数据进行分组
 */
public class OrderComparator extends WritableComparator {
    protected OrderComparator() {
        super(OrderBean.class, true);
    }

    /**
     * 分组比较器，按照相同订单进入一组进行比较
     * @param a
     * @param b
     * @return
     */
    @Override
    public int compare(WritableComparable a, WritableComparable b) {
        OrderBean oa = (OrderBean) a;
        OrderBean ob = (OrderBean) b;
        return oa.getOrderId().compareTo(ob.getOrderId());//在分组的时候只看订单是否一样
    }
}

3.OrderMapper.java:

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.IOException;


public class OrderMapper extends Mapper<LongWritable, Text, OrderBean, NullWritable> {
    //输入全部封装到key中，value中没有数据，为NULLWritable
    private OrderBean order = new OrderBean();

    /**
     * 封装OrderBean
     *
     * @param key
     * @param value
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //拆分
        String[] fields = value.toString().split("\t");
        //封装
        order.setOrderId(fields[0]);
        order.setProductId(fields[1]);
        order.setPrice(Double.parseDouble(fields[2]));
        //写出
        context.write(order, NullWritable.get());
    }
}

4.OrderReducer.java

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

import java.io.IOException;

public class OrderReducer extends Reducer<OrderBean, NullWritable, OrderBean, NullWritable> {
    /**
     * 取每个订单的最高价格
     *
     * @param key
     * @param values
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(OrderBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        context.write(key, NullWritable.get());
    }
}

5.OrderDriver.java

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.setMapOutputKeyClass(OrderBean.class);
        job.setMapOutputValueClass(NullWritable.class);
        job.setOutputKeyClass(OrderBean.class);
        job.setOutputValueClass(NullWritable.class);

        job.setGroupingComparatorClass(OrderComparator.class);//设置分组比较器

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

        boolean b = job.waitForCompletion(true);
        System.exit(b ? 0 : 1);
    }
}

5）输出结果

ps：修改reduce方法定义输出为排序之后的前几个订单。

protected void reduce(OrderBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        Iterator<NullWritable> iterator = values.iterator();
        for (int i = 0; i < 2; i++) {
            if (iterator.hasNext()) {
                context.write(key, iterator.next());
            }
        }
    }