MapReduce实现二次排序

本文参考章鱼大数据  https://www.ipieuvre.com/e/54/311/9533

问题：

在电商网站中，用户进入页面浏览商品时会产生访问日志，记录用户对商品的访问情况，现有goods_visit2表，包含（goods_id,click_num）两个字段，编写MapReduce代码，功能为根据商品的点击次数(click_num)进行降序排序，再根据goods_id升序排序，并输出所有商品。

思路：

在mapreduce中，所有的key是需要被比较和排序的，并且是二次，先根据partitioner，再根据大小。而本例中也是要比较两次。先按照第一字段排序，然后在第一字段相同时按照第二字段排序。根据这一点，我们可以构造一个复合类IntPair，他有两个字段，先利用分区对第一字段排序，再利用分区内的比较对第二字段排序。Java代码主要分为四部分：自定义key，自定义分区函数类，map部分，reduce部分。

public static class IntPair implements WritableComparable<IntPair>  
    {  
    int first;  //第一个成员变量  
    int second;  //第二个成员变量  
  
    public void set(int left, int right)  
    {  
    first = left;  
    second = right;  
    }  
    public int getFirst()  
    {  
    return first;  
    }  
    public int getSecond()  
    {  
    return second;  
    }  
    @Override  
    //反序列化，从流中的二进制转换成IntPair  
    public void readFields(DataInput in) throws IOException  
    {  
    // TODO Auto-generated method stub  
    first = in.readInt();  
    second = in.readInt();  
    }  
    @Override  
    //序列化，将IntPair转化成使用流传送的二进制  
    public void write(DataOutput out) throws IOException  
    {  
    // TODO Auto-generated method stub  
    out.writeInt(first);  
    out.writeInt(second);  
    }  
    @Override  
    //key的比较  
    public int compareTo(IntPair o)  
    {  
    // TODO Auto-generated method stub  
    if (first != o.first)  
    {  
    return first < o.first ? 1 : -1;  
    }  
    else if (second != o.second)  
    {  
    return second < o.second ? -1 : 1;  
    }  
    else  
    {  
    return 0;  
    }  
    }  
    @Override  
    public int hashCode()  
    {  
    return first * 157 + second;  
    }  
    @Override  
    public boolean equals(Object right)  
    {  
    if (right == null)  
    return false;  
    if (this == right)  
    return true;  
    if (right instanceof IntPair)  
    {  
    IntPair r = (IntPair) right;  
    return r.first == first && r.second == second;  
    }  
    else  
    {  
    return false;  
    }  
    }  
    }  

所有自定义的key应该实现接口WritableComparable，因为是可序列的并且可比较的，并重载方法。该类中包含以下几种方法：1.反序列化，从流中的二进制转换成IntPair 方法为public void readFields(DataInput in) throws IOException 2.序列化，将IntPair转化成使用流传送的二进制 方法为public void write(DataOutput out)3. key的比较 public int compareTo(IntPair o) 另外新定义的类应该重写的两个方法 public int hashCode() 和public boolean equals(Object right) 。

public static class FirstPartitioner extends Partitioner<IntPair, IntWritable>  
   {  
       @Override  
       public int getPartition(IntPair key, IntWritable value,int numPartitions)  
       {  
           return Math.abs(key.getFirst() * 127) % numPartitions;  
       }  
   }  

对key进行分区，根据自定义key中first乘以127取绝对值在对numPartions取余来进行分区。这主要是为实现第一次排序。

public static class GroupingComparator extends WritableComparator  
   {  
       protected GroupingComparator()  
       {  
           super(IntPair.class, true);  
       }  
       @Override  
       //Compare two WritableComparables.  
       public int compare(WritableComparable w1, WritableComparable w2)  
       {  
           IntPair ip1 = (IntPair) w1;  
           IntPair ip2 = (IntPair) w2;  
           int l = ip1.getFirst();  
           int r = ip2.getFirst();  
           return l == r ? 0 : (l < r ? -1 : 1);  
       }  
   }  

分组函数类。在reduce阶段，构造一个key对应的value迭代器的时候，只要first相同就属于同一个组，放在一个value迭代器。这是一个比较器，需要继承WritableComparator。

public static class Map extends Mapper<LongWritable, Text, IntPair, IntWritable>  
   {  
      //自定义map  
       private final IntPair intkey = new IntPair();  
       private final IntWritable intvalue = new IntWritable();  
       public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException  
       {  
           String line = value.toString();  
           StringTokenizer tokenizer = new StringTokenizer(line);  
           int left = 0;  
           int right = 0;  
           if (tokenizer.hasMoreTokens())  
           {  
               left = Integer.parseInt(tokenizer.nextToken());  
               if (tokenizer.hasMoreTokens())  
                   right = Integer.parseInt(tokenizer.nextToken());  
               intkey.set(right, left);  
               intvalue.set(left);  
               context.write(intkey, intvalue);  
           }  
       }  
   }  

在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方法。在本例子中，使用了IntPair实现compareTo方法。

public static class Reduce extends Reducer<IntPair, IntWritable, Text, IntWritable>  
    {  
        private final Text left = new Text();  
        private static final Text SEPARATOR = new Text("------------------------------------------------");  
  
        public void reduce(IntPair key, Iterable<IntWritable> values,Context context) throws IOException, InterruptedException  
    {  
    context.write(SEPARATOR, null);  
    left.set(Integer.toString(key.getFirst()));  
    System.out.println(left);  
    for (IntWritable val : values)  
    {  
    context.write(left, val);  
    //System.out.println(val);  
    }  
    }  
    }  

在reduce阶段，reducer接收到所有映射到这个reducer的map输出后，也是会调用job.setSortComparatorClass设置的key比较函数类对所有数据对排序。然后开始构造一个key对应的value迭代器。这时就要用到分组，使用job.setGroupingComparatorClass设置的分组函数类。只要这个比较器比较的两个key相同，他们就属于同一个组，它们的value放在一个value迭代器，而这个迭代器的key使用属于同一个组的所有key的第一个key。最后就是进入Reducer的reduce方法，reduce方法的输入是所有的key和它的value迭代器。同样注意输入与输出的类型必须与自定义的Reducer中声明的一致。