MapReduce的二次排序

附录之前总结的一个例子：

http://www.cnblogs.com/DreamDrive/p/7398455.html

另外两个有价值的博文：

http://www.cnblogs.com/xuxm2007/archive/2011/09/03/2165805.html

http://blog.csdn.net/heyutao007/article/details/5890103

一.MR的二次排序的需求说明

在mapreduce操作时，shuffle阶段会多次根据key值排序。但是在shuffle分组后，相同key值的values序列的顺序是不确定的(如下图)。如果想要此时value值也是排序好的，这种需求就是二次排序。

二.测试的文件数据

a 1
a 5
a 7
a 9
b 3
b 8
b 10

三.未经过二次排序的输出结果

四.第一种实现思路

直接在reduce端对分组后的values进行排序。

reduce关键代码

 @Override

      public void reduce(Text key, Iterable<IntWritable> values, Context context)

              throws IOException, InterruptedException {

           List<Integer> valuesList = new ArrayList<Integer>();

           // 取出value

           for(IntWritable value : values) {

               valuesList.add(value.get());

           }

           // 进行排序

           Collections.sort(valuesList);

           for(Integer value : valuesList) {

              context.write(key, new IntWritable(value));

           }

      }

输出结果：

很容易发现，这样把排序工作都放到reduce端完成，当values序列长度非常大的时候，会对CPU和内存造成极大的负载。

注意的地方（容易被“坑”）

在reduce端对values进行迭代的时候，不要直接存储value值或者key值，因为reduce方法会反复执行多次，但key和value相关的对象只有两个，reduce会反复重用这两个对象。需要用相应的数据类型.get()取出后再存储。

五.第二种实现思路

将map端输出的<key,value>中的key和value组合成一个新的key（称为newKey），value值不变。这里就变成<(key,value),value>，在针对newKey排序的时候，如果key相同，就再对value进行排序。

需要自定义的地方
　　1.自定义数据类型实现组合key
　　　　实现方式：继承WritableComparable
　　2.自定义partioner，形成newKey后保持分区规则任然按照key进行。保证不打乱原来的分区。
　　　　实现方式：继承partitioner
　　3.自定义分组，保持分组规则任然按照key进行。不打乱原来的分组
　　　　实现方式：继承RawComparator
自定义数据类型关键代码

 import java.io.DataInput;

 import java.io.DataOutput;

 import java.io.IOException;

 import org.apache.hadoop.io.WritableComparable;

 public class PairWritable implements WritableComparable<PairWritable> {

  // 组合key

    private String first;

    private int second;

  public PairWritable() {

  }

  public PairWritable(String first, int second) {

      this.set(first, second);

  }

  /**

   * 方便设置字段

   */

  public void set(String first, int second) {

      this.first = first;

      this.second = second;

  }

  /**

   * 反序列化

   */

  @Override

  public void readFields(DataInput arg0) throws IOException {

      this.first = arg0.readUTF();

      this.second = arg0.readInt();

  }

  /**

   * 序列化

   */

  @Override

  public void write(DataOutput arg0) throws IOException {

      arg0.writeUTF(first);

      arg0.writeInt(second);

  }

  /*

   * 重写比较器

   */

  public int compareTo(PairWritable o) {

      int comp = this.first.compareTo(o.first);

      if(comp != 0) {

          return comp;

      } else { // 若第一个字段相等，则比较第二个字段

          return Integer.valueOf(this.second).compareTo(

                  Integer.valueOf(o.getSecond()));

      }

  }

  public int getSecond() {

      return second;

  }

  public void setSecond(int second) {

      this.second = second;

  }

  public String getFirst() {

      return first;

  }

  public void setFirst(String first) {

      this.first = first;

  }

自定义分区规则

 import org.apache.hadoop.io.IntWritable;

 import org.apache.hadoop.mapreduce.Partitioner;

 public class SecondPartitioner extends Partitioner<PairWritable, IntWritable> {

     @Override

     public int getPartition(PairWritable key, IntWritable value, int numPartitions) {

         /*

          * 默认的实现 (key.hashCode() & Integer.MAX_VALUE) % numPartitions

          * 让key中first字段作为分区依据

          */

         return (key.getFirst().hashCode() & Integer.MAX_VALUE) % numPartitions;

     }

 }

自定义分组比较器

 import org.apache.hadoop.io.RawComparator;

 import org.apache.hadoop.io.WritableComparator;

 public class SecondGroupComparator implements RawComparator<PairWritable> {

     /*

      * 对象比较

      */

     public int compare(PairWritable o1, PairWritable o2) {

         return o1.getFirst().compareTo(o2.getFirst());

     }

     /*

      * 字节比较

      * arg0,arg3为要比较的两个字节数组

      * arg1,arg2表示第一个字节数组要进行比较的收尾位置，arg4,arg5表示第二个

      * 从第一个字节比到组合key中second的前一个字节，因为second为int型，所以长度为4

      */

     public int compare(byte[] arg0, int arg1, int arg2, byte[] arg3, int arg4, int arg5) {

         return WritableComparator.compareBytes(arg0, 0, arg2-4, arg3, 0, arg5-4);

     }

 }

map关键代码

 private PairWritable mapOutKey = new PairWritable();

       private IntWritable mapOutValue = new IntWritable();

       public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

           String lineValue = value.toString();

           String[] strs = lineValue.split("\t");

           //设置组合key和value ==> <(key,value),value>

           mapOutKey.set(strs[0], Integer.valueOf(strs[1]));

           mapOutValue.set(Integer.valueOf(strs[1]));

           context.write(mapOutKey, mapOutValue);

       }

reduce关键代码

 private Text outPutKey = new Text();

       public void reduce(PairWritable key, Iterable<IntWritable> values, Context context)

               throws IOException, InterruptedException {

           //迭代输出

           for(IntWritable value : values) {

               outPutKey.set(key.getFirst());

               context.write(outPutKey, value);

           }

       }

输出结果：

原理：

在map阶段：

使用job.setInputFormatClass定义的InputFormat将输入的数据集分割成小数据块splites，同时InputFormat提供一个RecordReder的实现。

本例子中使用的是TextInputFormat，他提供的RecordReder会将文本的一行的行号作为key，这一行的文本作为value。这就是自定义Map的输入是<LongWritable, Text>的原因。

然后调用自定义Map的map方法，将一个个<LongWritable, Text>对输入给Map的map方法。注意输出应该符合自定义Map中定义的输出<IntPair, IntWritable>。最终是生成一个List<IntPair, IntWritable>。

在map阶段的最后，会先调用job.setPartitionerClass对这个List进行分区，每个分区映射到一个reducer。每个分区内又调用job.setSortComparatorClass设置的key比较函数类排序。

可以看到，这本身就是一个二次排序。如果没有通过job.setSortComparatorClass设置key比较函数类，则使用key的实现的compareTo方法。

在reduce阶段：

reducer接收到所有映射到这个reducer的map输出后，也是会调用job.setSortComparatorClass设置的key比较函数类对所有数据对排序。

然后开始构造一个key对应的value迭代器。这时就要用到分组，使用jobjob.setGroupingComparatorClass设置的分组函数类。

只要这个比较器比较的两个key相同，他们就属于同一个组，它们的value放在一个value迭代器，而这个迭代器的key使用属于同一个组的所有key的第一个key。

最后就是进入Reducer的reduce方法，reduce方法的输入是所有的（key和它的value迭代器）。同样注意输入与输出的类型必须与自定义的Reducer中声明的一致。