Hadoop 之 Sort 排序 （星星笔记）

自从学习了hadoop之后，现在想想还没有怎么整理过自己写过的代码和读过的代码，今天就做一个整理吧，纪念一下。

Sort （排序）程序 。

1.问题描述

输入文件 

file1.txt:

2
32
654
32
15
756
65223

file2.txt:

5956
22
650
92

file3.txt:

26
54
6

样列输出：

1    2
2    6
3    15
4    22
5    26
6    32
7    32
8    54
9    92
10  650
11  654
12  756
13  5956
14  65223

2.设计思路

        从这个实例可知，仅仅是要求对输入的数据排序，我们都知道MapReduce过程有默认的排序过程，但是在默认的情况下这并不能满足数据全局有序。这是因为在排序前还有一个partition的过程，默认无法保证分割后的各个Reduce上的数据整体是有序的，而Reduce自动排序的数据仅仅是发送到自己所在节点的数据，因此使用默认的排序并不能保证全局有序。所以要想使用默认的排序过程，还必须定义自己的Partition类，保证执行Partition过程之后所有Reduce上的数据在整体上是有序的，然后在对局部Reduce上的数据进行默认排序，这样才能保证所有数据有序。

        首先应该使用封装int的 IntWritable型数据结构，也就是将读入的数据在Map中转化成 IntWritable 型，然后作为key 值输出（value任意）;其次需要重写partition类，保证全局有序，具体做法是用输入数据的最大值除以系统partition数量的商作为分割数据的边界增量，也就是说分割数据的边界为此商的 1 倍，2倍至numPartition-1 倍，这样就能保证执行partition后的数据整体是有序的；然后Reduce获得之后，根据value-list中元素的个数将输入的key作为value的输出次数，输出的key是一个全局变量，用于统计当前key的位次。值得一提是，这个过程中没有配置Combiner，也就是说MapReduce过程中不使用Combiner。这个主要是因为使用Map 和 Reduce 就已经能够完成任务了。

       具体程序如下：

package com.galaxy.star;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.util.GenericOptionsParser;
/**
 * 
 * @author LiuYinxing
 *
 */
public class Sort {
	public static class Map extends Mapper{
		private static IntWritable data = new IntWritable();
		public void map (Object key, Text value, Context context  )  throws IOException,InterruptedException{
			String line = value.toString();
			data.set(Integer.parseInt(line));
			
//			System.out.println("map过程:"+data);
			
			context.write(data, new IntWritable(1));
		}
	}
   public static class Reduce extends Reducer{
	   private static IntWritable linenum = new IntWritable(1);
	   
	   public void reduce(IntWritable key, Iterable values, Context context) throws IOException,InterruptedException{
		   for (IntWritable val : values) {
			   
//			   System.out.println("reduce过程："+ key);
			   context.write(linenum , key);
			   linenum = new IntWritable(linenum.get() + 1);
		}
	   } 
   }
   public static class Partition extends Partitioner{

	@Override
	public int getPartition(IntWritable key , IntWritable value , int numPartitions) 
	{
		// TODO Auto-generated method stub
		int Maxnumber = 65223 ;
		int bound = Maxnumber / numPartitions + 1;
		int keynumber = key.get();
		
//		System.out.println("text -----------text");
		
		for (int i = 0; i < numPartitions; i++)
        {
			if (keynumber < bound * i  &&  keynumber >= bound * ( i -1 )) 
				return i - 1;
		}
		return 0;          //partition是从0开始的，默认的返回应该给个0，return了-1确实不合适.
	}   
   }
	public static void main(String[] args) throws Exception
	{
		// TODO Auto-generated method stub
	       Configuration conf = new Configuration();
	       String[ ] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
	       if (otherArgs.length != 2) {
			System.err.println("参数不对  
");
			System.exit(2);
		}
	       Job job = new Job(conf, "排序例子");
	       job.setJarByClass(Sort.class);
	       job.setMapperClass(Map.class);
	       job.setReducerClass(Reduce.class);
	       job.setPartitionerClass(Partition.class);
	       job.setOutputKeyClass(IntWritable.class);
	       job.setOutputValueClass(IntWritable.class);
	       FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
	       FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
	       System.exit(job.waitForCompletion(true) ?  0 : 1 );
		}
}