Hadoop二次排序

二次排序

前言
Hadoop的map和reduce阶段默认用Key值作为记录排序的依据，如果想按照Value值或其他自定义的方式进行排序，就需要使用Hadoop提供的机制来实现所谓的”二次排序”。

这篇文章涉及到的概念有：

• 自定义Key
• 自定义分区规则
• 自定义排序规则
• 自定义分组规则

实验环境
操作系统：Ubuntu 16.04 LTS
Hadoop版本：Apache Hadoop2.6.5
JDK：JDK1.7

---

问题描述：

有如下的数据，要求：
同龄的数据分为一组，组内按身高升序排列。

注：左列为“年龄”，右列为“身高”。这里忽略数据合理性。

---

问题分析

map()输出中，以“年龄”作为Key，“身高”作为value输出。
四种年龄值：12,13,14,15，直接设置reducer个数为4。
不同年龄的数据送至不同的Reducer。

自定义的排序类，实现自定义排序逻辑，这里按“身高”进行升序排列。

在下面的解决方法中，使用自定义的Key类KeyPair.java，将“年龄 身高”组合为一个新的对象，这是为了体现自定义Key的机制，与本问题无关。

---

编码

项目结构：

---

KeyPair.java
自定义Key类，实现WritableComparable接口,作为被比较的对象。

package mr;

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

import org.apache.hadoop.io.WritableComparable;

public class KeyPair implements WritableComparable<KeyPair> {

    private int age;
    private int height;

    public KeyPair(int age, int height) {
        super();
        this.age = age;
        this.height = height;
    }

    public KeyPair() {
        super();
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    //反序列化
    @Override
    public void readFields(DataInput in) throws IOException {

        this.age = in.readInt();
        this.height = in.readInt();
    }
    //序列化
    @Override
    public void write(DataOutput out) throws IOException {

        out.writeInt(age);
        out.writeInt(height);
    }

    //进行排序时的依据,如果没有通过
    //job.setSortComparatorClass(XXX.class)设置比较类,则默认用compareTo作为比较大小
    @Override
    public int compareTo(KeyPair o) {
        return Integer.compare(age, o.getAge());
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return age+" "+height;
    }
}

---

MyPartition .java
自定义分区规则

package demo;

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

import mr.KeyPair;

public class MyPartition extends Partitioner<KeyPair, Text>{

    //白话：指定map_task产生的输出分别到哪个reduce_task中去
    //num即为reduce个数，这里输出分段刚好被分配到num个reduce_task中
    @Override
    public int getPartition(KeyPair key, Text value, int num) {
        return (key.getAge() % num);
    }
}

---

SortAge.java
自定义排序规则

package demo;

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

import mr.KeyPair;

public class SortAge extends WritableComparator {

    public SortAge() {
        super(KeyPair.class,true);
    }

    //自定义排序规则
    //这里的规则为：按年龄升序排列，同龄时按身高升序排列
    public int compare(WritableComparable a, WritableComparable b) {

        KeyPair first=(KeyPair)a;
        KeyPair second=(KeyPair)b;
        int res= Integer.compare(first.getAge(), second.getAge());

        if(0==res){
            return Integer.compare(first.getHeight(), second.getHeight());
        }
        return res;
    }
}

---

MyGroup.java
自定义Reducer端的分组规则

package demo;

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

import mr.KeyPair;

public class MyGroup extends WritableComparator {



    public MyGroup() {
        super(KeyPair.class,true);
    }

    //指定分组规则,reduce端执行,根据map-reduce语义,reduce端先将key相同的记录group,
    // 生成<key,interable<>>迭代形式,传递给reduce函数

    //这里按照年龄进行分组，只要keyPair对象中的age一致，就认为是一个组
    //WritableCimparable即为自定义的KeyPair
    public int compare(WritableComparable a, WritableComparable b) {
        KeyPair first=(KeyPair)a;
        KeyPair second=(KeyPair)b;

        return Integer.compare(first.getAge(), second.getAge()); 
    }
}

关于分组的一些疑惑：

这里以age作为分组依据，age相同的记录作为同一个分组，难道<10:112 “MAP”>和<10:58 “MAP”>能作为一个分组进行“合并”吗？ “合并”后的形式是什么样的？

【问题概括】

1. 如果是<10 “MAP”>与<10 “DOW”>这两个记录
   Key值都为10，value值不相同，合并为<10,<”MAP”,”DOW”>>这样的形式。

2. 如果是<10 “MAP”>与<11 “DOW”>这两个记录，业务逻辑上要求分为一组，能合并吗？Key值不同怎么合并成<Key key, Iterable<Text> value>的形式？

关于Reduce端分组的问题，网上很多资料语焉不详，或以讹传讹。
这篇博文解答了我的疑惑,大家感兴趣可以阅读
hadoop的mapreduce编程模型中GroupingComparator的使用 - 黎杰的博客 - CSDN博客

---

MyMapper
map()函数，读入每行记录，按空白划分记录，生成KeyPair对象，作为map输出的Key。

package mr;

import java.io.IOException;

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

import mr.KeyPair;
public class MyMapper extends Mapper<LongWritable, Text, KeyPair, Text> {

    public void map(LongWritable ikey, Text ivalue, Context context) throws IOException, InterruptedException {

        String[] line = ivalue.toString().split("\\s+");
        if (line.length == 2) {
            int age = Integer.parseInt(line[0]);
            int height = Integer.parseInt(line[1]);
            //这里的new Text("MAP")仅仅是测试，填补一个Text
            context.write(new KeyPair(age, height), new Text("MAP"));
        }
    }
}

---

MyReducer.java
reduce()函数，这里输入为<KeyPair key, Iterable<Text> value>

package mr;

import java.io.IOException;

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

public class MyReducer extends Reducer<KeyPair, Text, KeyPair, Text> {
    @Override
    protected void reduce(KeyPair key, Iterable<Text> value, Context context) throws IOException, InterruptedException {

        for (Text v : value) {
            context.write(key, v);
        }
    }
}

---

Driver .java
驱动类，配置job，提交作业

package mr;

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 demo.MyGroup;
import demo.MyPartition;
import demo.SortAge;

public class Driver {

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "AGE");

        job.setJarByClass(mr.Driver.class);

        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);


        //测试集中年龄种类数为4，将每个年龄的数据划分给一个reduce_task处理
        job.setNumReduceTasks(4);

        //指定排序类,在map_task和rudece_task端都会执行
        job.setSortComparatorClass(SortAge.class);

        //指定分组类,reduce_task执行
        job.setGroupingComparatorClass(MyGroup.class);

        //指定分区类：数据被发送到哪个recude_task进行处理,map_task端执行
        job.setPartitionerClass(MyPartition.class);

        //设定reduce输出Key，Value的格式，这里KeyPair为自定义的Key
        job.setOutputKeyClass(KeyPair.class);
        job.setOutputValueClass(Text.class);

        FileInputFormat.setInputPaths(job, new Path("/user/root/input/test.txt"));
        FileOutputFormat.setOutputPath(job, new Path("/user/root/output_test"));

        if (!job.waitForCompletion(true))
            return;
    }
}

---

结果

如图，四组年龄共输出四份文件，每份年龄相同，按身高升序排列(“MAP”为测试用的Text，无意义)

---

反思

这个例子虽然简单，但囊括了map-reduce计算模型中几个非常重要的组成部分:如自定义Key，自定义分区规则，自定义排序规则，自定义分组规则等。

这里值得反思的是，对于上面的每个自定义的类，要能说明白：

• 为什么要定义这个类？
• 怎么做的？
• 在哪个节点做的？
• 在什么时候做的？

其实这些都是Map-Reduce计算模型中非常基本的内容，但自己往往犯了迷糊。

下一篇打算总结下Shuffle各个阶段的运行原理，加深自己的认识，把基础搞扎实。

---

参考资料

彻底理解MapReduce shuffle过程原理 - ArmandXu的专栏 - CSDN博客

Hadoop学习笔记—11.MapReduce中的排序和分组 - Edison Chou - 博客园
Hadoop学习笔记—10.Shuffle过程那点事儿 - Edison Chou - 博客园

刘超：MapReduce二次排序

hadoop的mapreduce编程模型中GroupingComparator的使用 - 黎杰的博客 - CSDN博客