使用复合键值对二次排序

一般来说，利用复合键值对使用MR对键值对进行二次排序(MR默认只是对key排序，自定义的方式还对value排序就称为二次排序)，需要做四件事：

定制复合键值对类型
定制分区类(对应job的setPartitionerClass方法)
定制排序比较器类(对应job的setSortComparatorClass方法)
定制分组比较类（对应job的setGroupingComparatorClass方法）

1）以下代码只是实现了第一点和第二点，也可以实现二次排序。

A.主类：keySort

package keySort;
import java.io.IOException;
import java.io.File;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Partitioner;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.fs.Path;
public class keySort {
    public static class MyMapper extends Mapper<Text, Text, compositeKey, Text> {
        private compositeKey comKey=new compositeKey();        
        public void map(Text key,Text value,Context context) throws IOException, InterruptedException{
            //System.out.println("key:"+key+"value:"+value);
            //compositeKey.set(key.toString()+"	"+value.toString());
            //System.out.println("compositekey:"+compositeKey+"value:"+value);
            comKey.set(key, value);
            context.write(comKey,value);
        }
    }
    public static class MyPartitioner extends Partitioner<compositeKey, Text>{
        //public Text realKey=new Text();
        @Override
        public int getPartition(compositeKey key, Text value, int numredtasks) {
            // TODO 自动生成的方法存根
            //String[] kk=key.toString().split("	");
            //realKey.set(kk[0]);
            //System.out.println("partition key is:"+realKey.toString());
            return ((key.getNaturalKey()&Integer.MAX_VALUE)%numredtasks);
        }
        
    }
    public static class MyReducer extends Reducer<compositeKey, Text,
    Integer, Text>{
        @Override
        public void reduce(compositeKey key,Iterable<Text> values,Context context) throws IOException, InterruptedException{
            for (Text value : values) {
                context.write(key.getNaturalKey(), value);
            }
        }
    }
    public static void main(String[] args) throws Exception
    {
        if(args.length!=2){
            System.err.println("Usage: MatrixMultiply <inputPathM> <inputPathN> <outputPath>");
             System.exit(2);
                   }
        File outfile=new File(args[1]);
        if(outfile.isDirectory()&&outfile.exists()){
            System.out.println("out exist?"+outfile.exists());
            File[] files=outfile.listFiles();
            for (File file : files) {
                file.delete();
            }
            outfile.delete();
            System.out.println("out exit?"+outfile.exists());
        }
        else {
            System.out.println("out do not exit");
        }
        Configuration conf=new Configuration();
        Job job=new Job(conf,"SeconderySort");
        job.setNumReduceTasks(1);//设置为0的话，并不会执行分区过程，也就不能利用符合
        job.setJarByClass(keySort.class);
        job.setInputFormatClass(KeyValueTextInputFormat.class);        
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(compositeKey.class);
        job.setMapOutputValueClass(Text.class);
        job.setPartitionerClass(MyPartitioner.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        System.exit(job.waitForCompletion(true)?0:1);
    }
    }

B.自定义复合键值对类----compositeKey

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

import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
import org.aspectj.weaver.patterns.ArgsAnnotationPointcut;
//接口Writable并没有使用泛型，但是接口Comparable<T>是泛型，其唯一的方法为：
//int compareTo(T o);所以compositeKey实现接口的时候使用了<compositeKey>
public class compositeKey implements WritableComparable<compositeKey>{
    private int naturalKey;
    private int secondKey;
    public void set(Text naturalkey,Text secondkey ) {
        // TODO 自动生成的构造函数存根
        this.naturalKey=Integer.parseInt(naturalkey.toString());
        this.secondKey=Integer.parseInt(secondkey.toString());        
    }
    public int getNaturalKey() {
        return naturalKey;
    }
    @Override
    //反序列化
    public void readFields(DataInput arg0) throws IOException {
        // TODO 自动生成的方法存根
        this.naturalKey=arg0.readInt();
        this.secondKey=arg0.readInt();
        
    }
    @Override
    //序列化
    public void write(DataOutput arg0) throws IOException {
        // TODO 自动生成的方法存根
        arg0.writeInt(naturalKey);
        arg0.writeInt(secondKey);
    }
    @Override
    public int compareTo(compositeKey o) {
        // TODO 自动生成的方法存根
        int flag=this.naturalKey>o.naturalKey?1:(this.naturalKey==o.naturalKey?0:-1);
        if(flag!=0)
            return flag;
        return this.secondKey>o.secondKey?1:(this.secondKey==o.secondKey?0:-1);
    }
}

@Override就是覆盖的意思，表示在子类中重写父类中定义的方法，加上这个标示符可以使编译器在编译的时候帮我们检查是否与父类中的函数签名一致（函数名，参数个数，参数类型均相同）。

第11行可知，实现使用了泛型的接口的类，需要指定数据类型，并且在类中要实现接口中定义的所有方法(接口中的方法都是未实现的抽象方法)，WritableComparable接口的定义如下：

public interface WritableComparable<T> extends Writable, Comparable<T> {
}

所以，compositeKey实现此接口的时候形式如下，就是将T换为compositeKey：

 public class compositeKey implements WritableComparable<compositeKey>{

C.所以，接口WritableComparable接口就只是继承了Writable接口和Comparable接口而已。

Writable用于对象的序列化和反序列化，所有需要序列化的类都需要继承这个接口，定义如下：

public interface Writable {
  /** 
   * Serialize the fields of this object to <code>out</code>.
   * 
   * @param out <code>DataOuput</code> to serialize this object into.
   * @throws IOException
   */
  void write(DataOutput out) throws IOException;

  /** 
   * Deserialize the fields of this object from <code>in</code>.  
   * 
   * <p>For efficiency, implementations should attempt to re-use storage in the 
   * existing object where possible.</p>
   * 
   * @param in <code>DataInput</code> to deseriablize this object from.
   * @throws IOException
   */
  void readFields(DataInput in) throws IOException;
}

可见compositeKey需要实现write方法（序列化）和readFields（反序列化）方法，其具体实现是：

@Override
    //反序列化
    public void readFields(DataInput arg0) throws IOException {
        // TODO 自动生成的方法存根
        this.naturalKey=arg0.readInt();
        this.secondKey=arg0.readInt();
        
    }
    @Override
    //序列化
    public void write(DataOutput arg0) throws IOException {
        // TODO 自动生成的方法存根
        arg0.writeInt(naturalKey);
        arg0.writeInt(secondKey);

argo.readInt()表示序列化的是int型变量，字符串变量是.readUTF()。

而Comparable接口中只有一个方法：

int compareTo(T o);

所以，compositeKey还需要实现一个方法，就是compareTo方法：

@Override
    public int compareTo(compositeKey o) {
        // TODO 自动生成的方法存根
        int flag=this.naturalKey>o.naturalKey?1:(this.naturalKey==o.naturalKey?0:-1);
        if(flag!=0)
            return flag;
        return this.secondKey>o.secondKey?1:(this.secondKey==o.secondKey?0:-1);
    }

public class compositeKey implements WritableComparable<compositeKey>{

compositeKey实现接口的时候，使用的泛型就是对应着这里的compareTo方法。关于这个方法的返回值：首先调用形式是a.compareTo(o)

1，表示a大于o

0，表示两者相等

-1，表示a小于o

E:到这里，程序就可以顺利完成二次排序了，在map端排序的时候，会自动调用复合键值对定义的这个compareTo方法对复合键(compositeKey)排序。

结果如下：

排序前：

排序后：

2）以上是单机版，稍加修改为集群上跑得程序，并自动删除已存在的output目录：

keySort：

package keySort;
import java.io.IOException;
//import java.io.File;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Partitioner;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputFormat;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
public class keySort {
    public static class MyMapper extends Mapper<Text, Text, compositeKey, Text> {
        private compositeKey comKey=new compositeKey();        
        public void map(Text key,Text value,Context context) throws IOException, InterruptedException{
            //System.out.println("key:"+key+"value:"+value);
            //compositeKey.set(key.toString()+"	"+value.toString());
            //System.out.println("compositekey:"+compositeKey+"value:"+value);
            comKey.set(key, value);
            context.write(comKey,value);
        }
    }
    public static class MyPartitioner extends Partitioner<compositeKey, Text>{
        //public Text realKey=new Text();
        @Override
        public int getPartition(compositeKey key, Text value, int numredtasks) {
            // TODO 自动生成的方法存根
            //String[] kk=key.toString().split("	");
            //realKey.set(kk[0]);
            //System.out.println("partition key is:"+realKey.toString());
            return ((key.getNaturalKey()&Integer.MAX_VALUE)%numredtasks);
        }
        
    }
    public static class MyReducer extends Reducer<compositeKey, Text,
    Integer, Text>{
        private Text separator=new Text();
        @Override
        protected void setup(Context context) throws IOException ,InterruptedException {
            separator.set("-------------------------");
            context.write(null,separator);
            
        };
        
        @Override
        public void reduce(compositeKey key,Iterable<Text> values,Context context) throws IOException, InterruptedException{
            for (Text value : values) {
                context.write(key.getNaturalKey(), value);
            }
        }
    }
    public static void main(String[] args) throws Exception
    {
        if(args.length!=2){
            System.err.println("Usage: MatrixMultiply <inputPathM> <inputPathN> <outputPath>");
             System.exit(2);
                   }
        /*本地运行时检测并删除输出文件夹
        File outfile=new File(args[1]);
        if(outfile.isDirectory()&&outfile.exists()){
            System.out.println("out exist?"+outfile.exists());
            File[] files=outfile.listFiles();
            for (File file : files) {
                file.delete();
            }
            outfile.delete();
            System.out.println("out exit?"+outfile.exists());
        }
        else {
            System.out.println("out do not exit");
        }
        */
        Configuration conf=new Configuration();
        FileSystem hdfs=FileSystem.get(conf);
        Path path=new Path(args[1]);
        if(hdfs.exists(path)){
            hdfs.delete(path, true);//如果path是一个目录的话，true表示递归删除这个目录，如果path是文件的话，true
            //或者false无所谓。另外FileSystem.delete（path）方法已废除。        
            System.out.println("output deleted!");
        }
        else {
            System.out.println("no output");
        }
        Job job=new Job(conf,"SeconderySort");
        //job.setNumReduceTasks(1);//设置为0的话，并不会执行分区过程，也就不能利用符合
        job.setJarByClass(keySort.class);
        job.setInputFormatClass(KeyValueTextInputFormat.class);        
        job.setMapperClass(MyMapper.class);
        job.setMapOutputKeyClass(compositeKey.class);
        job.setMapOutputValueClass(Text.class);
        job.setPartitionerClass(MyPartitioner.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        System.exit(job.waitForCompletion(true)?0:1);
    }
    }

compositeKey：

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

import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
//接口Writable并没有使用泛型，但是接口Comparable<T>是泛型，其唯一的方法为：
//int compareTo(T o);所以compositeKey实现接口的时候使用了<compositeKey>
public class compositeKey implements WritableComparable<compositeKey>{
    private int naturalKey;
    private int secondKey;
    public void set(Text naturalkey,Text secondkey ) {
        // TODO 自动生成的构造函数存根
        this.naturalKey=Integer.parseInt(naturalkey.toString());
        this.secondKey=Integer.parseInt(secondkey.toString());        
    }
    public int getNaturalKey() {
        return naturalKey;
    }
    @Override
    //反序列化
    public void readFields(DataInput arg0) throws IOException {
        // TODO 自动生成的方法存根
        this.naturalKey=arg0.readInt();
        this.secondKey=arg0.readInt();
        
    }
    @Override
    //序列化
    public void write(DataOutput arg0) throws IOException {
        // TODO 自动生成的方法存根
        arg0.writeInt(naturalKey);
        arg0.writeInt(secondKey);
    }
    @Override
    public int compareTo(compositeKey o) {
        // TODO 自动生成的方法存根
        int flag=this.naturalKey>o.naturalKey?1:(this.naturalKey==o.naturalKey?0:-1);
        if(flag!=0)
            return flag;
        return this.secondKey>o.secondKey?1:(this.secondKey==o.secondKey?0:-1);
    }
}

原以为放在集群上跑，会造成每个reduce中顺序混乱，因为并没有定义分组比较类(setGroupingComparatorClass),目前认为没必要定义这个类，示例代码分析：

public class PersonNameComparator extends WritableComparator {

    protected PersonNameComparator() {
        super(Person.class, true);
    }
    
    @Override
    public int compare(WritableComparable o1, WritableComparable o2) {
        Person p1 = (Person) o1;
        Person p2 = (Person) o2;
        return p1.getLastName().compareTo(p2.getLastName());
    }
}

虽然是定义了分组排序的类，但是在排序函数compare内部还是调用了自定义的复合键类的方法compareTo方法。这个操作是在reduce端完成的。如下所述：

当reduce阶段将在本地磁盘上的map输出的记录进行流化处理（streaming）的时候，需要要进行分组。在分组中，记录将被按一定方式排成一个有逻辑顺序的流，并被传输给reduce。在分组阶段，所有的记录已经经过了次排序。

结果如下所示：

-------------------

-------------------------------------------------

-------------------------------------

-

---------------------------------------------------

谢谢：

http://www.cnblogs.com/datacloud/p/3584640.html

http://my.oschina.net/leejun2005/blog/132785

http://padma0.tumblr.com/post/59931427752/mapreduce%E7%9A%84%E4%BA%8C%E6%AC%A1%E6%8E%92%E5%BA%8F%E5%8E%9F%E7%90%86