hadoop MapReduce辅助排序解析
1、数据样本，w1.csv到w5.csv，每个文件数据样本2000条，第一列是年份从1990到2000随机，第二列数据从1-100随机，本例辅助排序目标是找出每年最大值，实际上结果每年最大就是100，但是这里通过mapreduce辅助排序方式来找。
1999,71 1994,57 1995,33 1993,44 1994,99 1994,83 1995,59 ... ...
2、核心概念：
1）分区，假设有海量的数据，为了增加并行度，按照hash算法将所有数据分区后，确保同一年的数据进入到同一个分区，也就是同一个reduce里。
2）键比较器，将数据拆分后，年份和数据同时组成一个组合键（本质就是一个对象），因为采用组合键的key，需要一个键排序比较器来对key排序，通过年份升序，数据降序的算法编写核心比较方法。
那么mapper就会安装key比较器将自己所负责的所有数据排序。
3）分组比较器，在reducer阶段，需求实际上只求最大值，那么实际上就是排序后的第一条，如果reducer阶段不做什么变化，那么数据将会安装年份升序和数据降序输出所有数据（重复的已经被reduce过滤）。
为了只得到一条最大的数据，可以采用设置分组器的方式实现。同一年份，我们只需要一条数据，那么分组比较器就可以只按照年份分组，分组后，reducer最终归并数据后，只会得到排第一的那条最大数据。
这种取最大值得方式，实际上是取巧，是依赖mapper和reducer的排序特性而来。
3、IntPair，本例把整行数据解析后，年份和数据都放入key，需要自定义一个IntPair对象，实际生产环境中可根据需求自定义各种类.
public class IntPair implements WritableComparable<IntPair> { private int first; private int second; public IntPair() { } public IntPair(int first, int second) { this.first = first; this.second = second; } public int getFirst() { return first; } public void setFirst(int first) { this.first = first; } public int getSecond() { return second; } public void setSecond(int second) { this.second = second; } @Override public int compareTo(IntPair o) { int result = Integer.valueOf(first).compareTo(o.getFirst()); if(result==0){ result = Integer.valueOf(second).compareTo(o.getSecond()); } return result; } public static int compare(int first1,int first2){ return Integer.valueOf(first1).compareTo(Integer.valueOf(first2)); } @Override public void write(DataOutput out) throws IOException { out.writeInt(first); out.writeInt(second); } @Override public void readFields(DataInput in) throws IOException { first = in.readInt(); second = in.readInt(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; IntPair intPair = (IntPair) o; if (first != intPair.first) return false; return second == intPair.second; } @Override public int hashCode() { int result = first; result = 31 * result + second; return result; } @Override public String toString() { return first+"\t"+second; } }
4、RecordParser，记录解析器，用于解析数据，规避错误数据
public class RecordParser { private int year; private int data; private boolean valid; public int getYear() { return year; } public int getData() { return data; } public boolean isValid() { return valid; } public void parse(String value){ String[] sValue = value.split(","); try { year = Integer.parseInt(sValue[0]); data = Integer.parseInt(sValue[1]); valid = true; }catch (Exception e){ valid = false; } } }
5、分区器
/** * @Author: xu.dm * @Date: 2019/2/21 11:56 * @Description:根据key进行分区，确保同一个key.first进入相同的分区，泛型类型和mapper输出一致 */ public class FirstPartitioner extends Partitioner<IntPair,IntWritable> { /** * Get the partition number for a given key (hence record) given the total * number of partitions i.e. number of reduce-tasks for the job. * <p> * <p>Typically a hash function on a all or a subset of the key.</p> * * @param key the key to be partioned. * @param value the entry value. * @param numPartitions the total number of partitions. * @return the partition number for the <code>key</code>. */ @Override public int getPartition(IntPair key, IntWritable value, int numPartitions) { return Math.abs(key.getFirst() * 127) % numPartitions; } }
6、key比较器，map阶段的key排序使用，如果没有分组比较器，则key比较器也会应用在混洗和reduce阶段。
/** * @Author: xu.dm * @Date: 2019/2/21 11:59 * @Description: key比较器 * 对IntPair的first升序，second降序，在mapper排序的时候被应用 * 最终同样年份的数据第一条是最大的。 */ public class KeyComparator extends WritableComparator { protected KeyComparator() { super(IntPair.class,true);//需要实例化 } @Override public int compare(WritableComparable a, WritableComparable b) { IntPair p1=(IntPair)a; IntPair p2=(IntPair)b; int result = IntPair.compare(p1.getFirst(),p2.getFirst()); if(result==0){ result = -IntPair.compare(p1.getSecond(),p2.getSecond()); //前面加一个减号求反 } return result; } }
7、分组比较器，这里最关键，看注释。
/** * @Author: xu.dm * @Date: 2019/2/21 12:16 * @Description: 分组比较器，应用在reduce阶段，数据进reduce后，归并之前。
* 本例目标是：确保同一个年份的数据在同一个组里 * 之前key比较器使得key值中的年份升序，数据降序排列。 * 那么这个分组比较器只按年进行比较，意味着，[1990,100]和[1990,00]会被认为是相同的分组， * 而，reduce阶段，相同的KEY只取第一个，哦也，这个时候，reduce阶段后，年份中最大的数据就被保存下来，其他数据都被kickout * 所以，用这种方式变相的达到取最大值得效果。 */ public class GroupComparator extends WritableComparator { public GroupComparator() { super(IntPair.class,true); } @Override public int compare(WritableComparable a, WritableComparable b) { IntPair p1=(IntPair)a; IntPair p2=(IntPair)b; return IntPair.compare(p1.getFirst(),p2.getFirst()); } }
8、mapper，如果只取年份里的最大数据，Mapper<LongWritable,Text,IntPair,IntWritable> 的IntWritable可以用NullWritable，这里保留IntWritable是因为，程序稍加改动就可以输出所有年份数据的计数
public class DataMapper extends Mapper<LongWritable,Text,IntPair,IntWritable> { private RecordParser parser = new RecordParser(); @Override protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException { parser.parse(value.toString()); if(parser.isValid()){ context.write(new IntPair(parser.getYear(),parser.getData()),new IntWritable(1)); context.getCounter("MapValidData","dataCounter").increment(1); //做一个计数，总的数据应该是10000条。 } } }
9、reducer
public class DataReducer extends Reducer<IntPair,IntWritable,IntPair,IntWritable> { @Override protected void reduce(IntPair key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; //因为分组器，[1990,100]和[1990,00]会被认为是相同的分组 //这里的计数就会混淆。如果需要年份下各数据的正确的计数结果，则需要注销分组器 // for(IntWritable val:values){ // sum+=val.get(); // } context.write(key,new IntWritable(sum)); } }
10、job
public class DataSecondarySort extends Configured implements Tool { /** * Execute the command with the given arguments. * * @param args command specific arguments. * @return exit code. * @throws Exception */ @Override public int run(String[] args) throws Exception { Configuration conf = getConf(); Job job = Job.getInstance(conf,"Secondary Sort"); // conf.set("mapreduce.job.ubertask.enable","true"); if(conf==null){ return -1; } job.setJarByClass(DataSecondarySort.class); job.setMapperClass(DataMapper.class); job.setPartitionerClass(FirstPartitioner.class); job.setSortComparatorClass(KeyComparator.class);
// 决定如何分组 job.setGroupingComparatorClass(GroupComparator.class); job.setReducerClass(DataReducer.class); // job.setNumReduceTasks(2);//如果数据海量，则可以根据情况设置reduce的数目，也是分区的数量，通过Tool类，也可以在命令行进行设置 job.setOutputKeyClass(IntPair.class); //如果只求最大数，前面的mapper，reducer和这里的输出都可以设置成NullWritable job.setOutputValueClass(IntWritable.class); FileInputFormat.addInputPath(job,new Path(args[0])); FileOutputFormat.setOutputPath(job,new Path(args[1])); Path outPath = new Path(args[1]); FileSystem fileSystem = outPath.getFileSystem(conf); //删除输出路径 if(fileSystem.exists(outPath)) { fileSystem.delete(outPath,true); } return job.waitForCompletion(true) ? 0:1; } public static void main(String[] args) throws Exception{ int exitCode = ToolRunner.run(new DataSecondarySort(),args); System.exit(exitCode); } }
11、如果求最大值，结果会是这样：
[hadoop@bigdata-senior01 ~]$ hadoop fs -cat /output3/part-r-00000 | more
1990 100 0
1991 100 0
1992 100 0
1993 100 0
1994 100 0
1995 100 0
1996 100 0
1997 100 0
1998 100 0
1999 100 0
2000 100 0
如果求最大值和计数则会列出所有数据，当然需要注销分组器的set代码，并打开reducer的sum
[hadoop@bigdata-senior01 ~]$ hadoop fs -cat /output/part-r-00000 | more 1990 100 10 1990 99 15 1990 98 10 1990 97 9 1990 96 6 1990 95 4 1990 94 12 1990 93 9 1990 92 12 1990 91 13 1990 90 8 1990 89 9 ... ...
多个分区可以使用job.setNumReduceTasks(n)，或者在命令行上指定
[hadoop@bigdata-senior01 ~]$ hadoop jar DataSecondarySort.jar -D mapreduce.job.reduces=3 /sampler /output3
[hadoop@bigdata-senior01 ~]$ hadoop fs -ls /output3
Found 4 items
-rw-r--r-- 1 hadoop supergroup 0 2019-02-21 15:29 /output3/_SUCCESS
-rw-r--r-- 1 hadoop supergroup 2868 2019-02-21 15:29 /output3/part-r-00000
-rw-r--r-- 1 hadoop supergroup 3860 2019-02-21 15:29 /output3/part-r-00001
-rw-r--r-- 1 hadoop supergroup 3850 2019-02-21 15:29 /output3/part-r-00002
总结一下：最容易混淆的概念就是分组，而排序和分组实际上就是MapReduce最核心的地方。
总结步骤： 1、视数据量大小决定是否分区，分几个区输出数据，可以在作业中设置，也可以在命令行中指定 2、规划数据结构，抽象为对象，自定义对象排序规则，实现排序接口，明确key排序比较器 3、自定义分组规则，视情况进行分组归纳，实现分组排序接口 4、作业配置中配置分区类、排序类、分组类以及输出类。
