hadoop之二次排序

mr自帶的例子中的源碼SecondarySort，我重新寫了一下，基本沒變。

這個例子中定義的map和reduce如下，關鍵是它對輸入輸出類型的定義：（java泛型編程）

public static class Map extends Mapper<LongWritable, Text, IntPair, IntWritable>
public static class Reduce extends Reducer<IntPair, NullWritable, IntWritable, IntWritable>

1 首先說一下工作原理：

在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方法，而在下一個例子中，專門定義了key比較函數類。
在reduce階段，reducer接收到所有映射到這個reducer的map輸出後，也是會調用job.setSortComparatorClass設置的key比較函數類對所有數據對排序。然後開始構造一個key對應的value迭代器。這時就要用到分組，使用jobjob.setGroupingComparatorClass設置的分組函數類。只要這個比較器比較的兩個key相同，他們就屬於同一個組，它們的value放在一個value迭代器，而這個迭代器的key使用屬於同一個組的所有key的第一個key。最後就是進入Reducer的reduce方法，reduce方法的輸入是所有的（key和它的value迭代器）。同樣注意輸入與輸出的類型必須與自定義的Reducer中聲明的一致。

2  二次排序就是首先按照第一字段排序，然後再對第一字段相同的行按照第二字段排序，注意不能破壞第一次排序的結果 。例如

輸入文件
20 21
50 51
50 52
50 53
50 54
60 51
60 53
60 52
60 56
60 57
70 58
60 61
70 54
70 55
70 56
70 57
70 58
1 2
3 4
5 6
7 82
203 21
50 512
50 522
50 53
530 54
40 511
20 53
20 522
60 56
60 57
740 58
63 61
730 54
71 55
71 56
73 57
74 58
12 211
31 42
50 62
7 8
輸出：（注意需要分割線）
------------------------------------------------
1       2
------------------------------------------------
3       4
------------------------------------------------
5       6
------------------------------------------------
7       8
7       82
------------------------------------------------
12      211
------------------------------------------------
20      21
20      53
20      522
------------------------------------------------
31      42
------------------------------------------------
40      511
------------------------------------------------
50      51
50      52
50      53
50      53
50      54
50      62
50      512
50      522
------------------------------------------------
60      51
60      52
60      53
60      56
60      56
60      57
60      57
60      61
------------------------------------------------
63      61
------------------------------------------------
70      54
70      55
70      56
70      57
70      58
70      58
------------------------------------------------
71      55
71      56
------------------------------------------------
73      57
------------------------------------------------
74      58
------------------------------------------------
203     21
------------------------------------------------
530     54
------------------------------------------------
730     54
------------------------------------------------
740     58

3  具體步驟：
（1）自定義key

在mr中，所有的key是需要被比較和排序的，並且是二次，先根據partitione，再根據大小。而本例中也是要比較兩次。先按照第一字段排序，然後再對第一字段相同的按照第二字段排序。根據這一點，我們可以構造一個複合類IntPair，他有兩個字段，先利用分區對第一字段排序，再利用分區內的比較對第二字段排序。
所有自定義的key應該實現接口WritableComparable，因爲是可序列的並且可比較的。並重載方法：

//反序列化，從流中的二進制轉換成IntPair
public void readFields(DataInput in) throws IOException
//序列化，將IntPair轉化成使用流傳送的二進制
public void write(DataOutput out)
//key的比較
public int compareTo(IntPair o)
//另外新定義的類應該重寫的兩個方法
//The hashCode() method is used by the HashPartitioner (the default partitioner in MapReduce)
public int hashCode()
public boolean equals(Object right)

//反序列化，從流中的二進制轉換成IntPair
public void readFields(DataInput in) throws IOException        
//序列化，將IntPair轉化成使用流傳送的二進制
public void write(DataOutput out)
//key的比較
public int compareTo(IntPair o)        
//另外新定義的類應該重寫的兩個方法
//The hashCode() method is used by the HashPartitioner (the default partitioner in MapReduce)
public int hashCode() 
public boolean equals(Object right)

（2）由於key是自定義的，所以還需要自定義一下類：
（2.1）分區函數類。這是key的第一次比較。

public static
class FirstPartitioner extends Partitioner<IntPair,IntWritable>

 public static class FirstPartitioner extends Partitioner<IntPair,IntWritable>

在job中使用setPartitionerClasss設置Partitioner。
（2.2）key比較函數類。這是key的第二次比較。這是一個比較器，需要繼承WritableComparator。

public static
class KeyComparator extends WritableComparator

public static class KeyComparator extends WritableComparator

必須有一個構造函數，並且重載 public int compare(WritableComparable w1, WritableComparable w2)

另一種方法是 實現接口RawComparator。
在job中使用setSortComparatorClass設置key比較函數類。
（2.3）分組函數類。在reduce階段，構造一個key對應的value迭代器的時候，只要first相同就屬於同一個組，放在一個value迭代器。這是一個比較器，需要繼承WritableComparator。

public static
class GroupingComparator extends WritableComparator

public static class GroupingComparator extends WritableComparator

分組函數類也必須有一個構造函數，並且重載 public int compare(WritableComparable w1, WritableComparable w2)
分組函數類的另一種方法是實現接口RawComparator。
在job中使用setGroupingComparatorClass設置分組函數類。

另外注意的是，如果reduce的輸入與輸出不是同一種類型，則不要定義Combiner也使用reduce，因爲Combiner的輸出是reduce的輸入。除非重新定義一個Combiner。

3 代碼。

這個例子中沒有使用key比較函數類，而是使用key的實現的compareTo方法。

package secondarySort;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

public class SecondarySort {
    //自己定義的key類應該實現WritableComparable接口
    public static
class IntPair implements WritableComparable<IntPair> {
        int first;
        int second;
        /**
         * Set the left and right values.
         */
        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
        //The hashCode() method is used by the HashPartitioner (the default partitioner in MapReduce)
        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;
            }
        }
    }
     /**
       * 分區函數類。根據first確定Partition。
       */
      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;
        }
      }

      /**
       * 分組函數類。只要first相同就屬於同一個組。
       */
    /*//第一種方法，實現接口RawComparator
    public static class GroupingComparator implements RawComparator<IntPair> {
        @Override
        public int compare(IntPair o1, IntPair o2) {
            int l = o1.getFirst();
            int r = o2.getFirst();
            return l == r ? 0 : (l < r ? -1 : 1);
        }
        @Override
        //一個字節一個字節的比，直到找到一個不相同的字節，然後比這個字節的大小作爲兩個字節流的大小比較結果。
        public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2){
            // TODO Auto-generated method stub
             return WritableComparator.compareBytes(b1, s1, Integer.SIZE/8,
                     b2, s2, Integer.SIZE/8);
        }
    }*/
    //第二種方法，繼承WritableComparator
    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);
          }
        }


    // 自定義map
    public static
class Map extends
            Mapper<LongWritable, Text, IntPair, IntWritable> {
        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(left, right);
                intvalue.set(right);
                context.write(intkey, intvalue);
            }
        }
    }
    // 自定義reduce
    //
    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()));
            for (IntWritable val : values) {
                context.write(left, val);
            }
        }
    }
    /**
     * @param args
     */
    public static
void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        // TODO Auto-generated method stub
        // 讀取hadoop配置
        Configuration conf = new Configuration();
        // 實例化一道作業
        Job job = new Job(conf,
"secondarysort");
        job.setJarByClass(SecondarySort.class);
        // Mapper類型
        job.setMapperClass(Map.class);
        // 不再需要Combiner類型，因爲Combiner的輸出類型<Text, IntWritable>對Reduce的輸入類型<IntPair, IntWritable>不適用
        //job.setCombinerClass(Reduce.class);
        // Reducer類型
        job.setReducerClass(Reduce.class);
        // 分區函數
        job.setPartitionerClass(FirstPartitioner.class);
        // 分組函數
        job.setGroupingComparatorClass(GroupingComparator.class);

        // map 輸出Key的類型
        job.setMapOutputKeyClass(IntPair.class);
        // map輸出Value的類型
        job.setMapOutputValueClass(IntWritable.class);
        // rduce輸出Key的類型，是Text，因爲使用的OutputFormatClass是TextOutputFormat
        job.setOutputKeyClass(Text.class);
        // rduce輸出Value的類型
        job.setOutputValueClass(IntWritable.class);

        // 將輸入的數據集分割成小數據塊splites，同時提供一個RecordReder的實現。
        job.setInputFormatClass(TextInputFormat.class);
        // 提供一個RecordWriter的實現，負責數據輸出。
        job.setOutputFormatClass(TextOutputFormat.class);

        // 輸入hdfs路徑
        FileInputFormat.setInputPaths(job, 
new Path(args[0]));
        // 輸出hdfs路徑
        FileOutputFormat.setOutputPath(job, 
new Path(args[1]));
        // 提交job
        System.exit(job.waitForCompletion(true) ?
0 : 1);
    }
}