Hadoop中的二次排序实现，自定义分区，以及自定义分组

最新推荐文章于 2022-06-01 15:44:08 发布

weixin_39953756

最新推荐文章于 2022-06-01 15:44:08 发布

阅读量306

点赞数

理论部分摘自博客园，感谢博主的总结！
https://www.cnblogs.com/codeOfLife/p/5568786.html

默认情况下，Map输出的结果会对Key进行默认的排序，但是有时候需要对Key排序的同时还需要对Value进行排序，这时候就要用到二次排序了。下面我们来说说二次排序

1、二次排序原理

我们把二次排序分为以下几个阶段

Map起始阶段

在Map阶段，使用job.setInputFormatClass()定义的InputFormat，将输入的数据集分割成小数据块split，同时InputFormat提供一个RecordReader的实现。在这里我们使用的是TextInputFormat，它提供的RecordReader会将文本的行号作为Key，这一行的文本作为Value。这就是自定 Mapper的输入是<LongWritable,Text> 的原因。然后调用自定义Mapper的map方法，将一个个<LongWritable,Text>键值对输入给Mapper的map方法

Map最后阶段

在Map阶段的最后，会先调用job.setPartitionerClass()对这个Mapper的输出结果进行分区，每个分区映射到一个Reducer。每个分区内又调用job.setSortComparatorClass()设置的Key比较函数类排序。可以看到，这本身就是一个二次排序。如果没有通过job.setSortComparatorClass()设置 Key比较函数类，则使用Key实现的compareTo()方法

Reduce阶段

在Reduce阶段，reduce()方法接受所有映射到这个Reduce的map输出后，也会调用job.setSortComparatorClass()方法设置的Key比较函数类，对所有数据进行排序。然后开始构造一个Key对应的Value迭代器。这时就要用到分组，使用 job.setGroupingComparatorClass()方法设置分组函数类。只要这个比较器比较的两个Key相同，它们就属于同一组，它们的 Value放在一个Value迭代器，而这个迭代器的Key使用属于同一个组的所有Key的第一个Key。最后就是进入Reducer的 reduce()方法，reduce()方法的输入是所有的Key和它的Value迭代器，同样注意输入与输出的类型必须与自定义的Reducer中声明的一致

接下来我们通过示例，可以很直观的了解二次排序的原理

输入文件 sort.txt 内容为

40 20

40 10

40 30

40 5

30 30

30 20

30 10

30 40

50 20

50 50

50 10

50 60

输出文件的内容（从小到大排序）如下

30 10

30 20

30 30

30 40

--------

40 5

40 10

40 20

40 30

--------

50 10

50 20

50 50

50 60

从输出的结果可以看出Key实现了从小到大的排序，同时相同Key的Value也实现了从小到大的排序，这就是二次排序的结果

2、二次排序的具体流程

在本例中要比较两次。先按照第一字段排序，然后再对第一字段相同的按照第二字段排序。根据这一点，我们可以构造一个复合类IntPair ，它有两个字段，先利用分区对第一字段排序，再利用分区内的比较对第二字段排序。二次排序的流程分为以下几步。

1、自定义 key

所有自定义的key应该实现接口WritableComparable，因为它是可序列化的并且可比较的。WritableComparable 的内部方法如下所示

// 反序列化，从流中的二进制转换成IntPair
public void readFields(DataInput in) throws IOException

// 序列化，将IntPair转化成使用流传送的二进制
public void write(DataOutput out)

//  key的比较
public int compareTo(IntPair o)

//  默认的分区类 HashPartitioner，使用此方法
public int hashCode()

//  默认实现
public boolean equals(Object right)

2、自定义分区

自定义分区函数类FirstPartitioner，是key的第一次比较，完成对所有key的排序。

public static class FirstPartitioner extends Partitioner< IntPair,IntWritable>

在job中使用setPartitionerClasss()方法设置Partitioner

job.setPartitionerClasss(FirstPartitioner.Class);

3、Key的比较类

这是Key的第二次比较，对所有的Key进行排序，即同时完成IntPair中的first和second排序。该类是一个比较器，可以通过两种方式实现。

1) 继承WritableComparator。

public static class KeyComparator extends WritableComparator

必须有一个构造函数，并且重载以下方法。

public int compare(WritableComparable w1, WritableComparable w2)

2) 实现接口 RawComparator。

上面两种实现方式，在Job中，可以通过setSortComparatorClass()方法来设置Key的比较类。

job.setSortComparatorClass(KeyComparator.Class);

注意：如果没有使用自定义的SortComparator类，则默认使用Key中compareTo()方法对Key排序。

4、定义分组类函数

在Reduce阶段，构造一个与 Key 相对应的 Value 迭代器的时候，只要first相同就属于同一个组，放在一个Value迭代器。定义这个比较器，可以有两种方式。

1) 继承 WritableComparator。

public static class GroupingComparator extends WritableComparator

必须有一个构造函数，并且重载以下方法。

public int compare(WritableComparable w1, WritableComparable w2)

2) 实现接口 RawComparator。

上面两种实现方式，在 Job 中，可以通过 setGroupingComparatorClass()方法来设置分组类。

job.setGroupingComparatorClass(GroupingComparator.Class);

另外注意的是，如果reduce的输入与输出不是同一种类型，则 Combiner和Reducer 不能共用 Reducer 类，因为 Combiner 的输出是 reduce 的输入。除非重新定义一个Combiner。

代码如下：

package com.ibeifeng.hadoop19_copy;

import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Mapper.Context;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class SecondSort {
//每行数据有两个Int型数字，我们需要先对第一个数进行排序，然后再对第二个数进行排序，默认map的输出会对key进行排序，所以我们将第一个数字与第二个数字放到一起，组成新的key，这样就第一第二个字排序。
public static class Map extends Mapper<LongWritable,Text,IntPairs,IntWritable>{
  private final IntPairs mapoutkey = new IntPairs();
  private final IntWritable mapoutvalue = new IntWritable();
  @Override
  protected void map(LongWritable key, Text value, Context context)
    throws IOException, InterruptedException {
   int left = 0;
   int right = 0;
   String line = value.toString();
  // System.out.println(line);
   StringTokenizer tokenizer = new StringTokenizer(line);
   if(tokenizer.hasMoreTokens()){
    left = Integer.parseInt(tokenizer.nextToken());
   }
   if(tokenizer.hasMoreTokens()){
    right = Integer.parseInt(tokenizer.nextToken());
   }
   mapoutkey.set(left, right);
   System.out.println(mapoutkey);
   mapoutvalue.set(right);
   context.write(mapoutkey, mapoutvalue);
  }

}

public static class Reduce extends Reducer<IntPairs,IntWritable,Text,IntWritable>{
  private final Text reduceoutkey = new Text();
  @Override
  protected void reduce(IntPairs key, Iterable<IntWritable> value,
    Context context)
    throws IOException, InterruptedException {
   //System.out.println(key);
   //定义分割线，这样可以将不同的分组情况隔离开来，同一分组的数据会被reduce同一批处理
   Text symbol = new Text("-------------------------------------------");
   context.write(symbol, null);
   reduceoutkey.set(Integer.toString(key.getFirst()));
   for(IntWritable word : value){
    context.write(reduceoutkey, word);
   }
  }
}

public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException{
  //获取Hadoop的配置信息
  Configuration conf = new Configuration();

  //创建job
  Job job = Job.getInstance(conf, "Liuxe");

  //设置成打jar包提交
  job.setJarByClass(SecondSort.class);

  //设置输如路径
  Path inpath = new Path("hdfs://node-1:8020/testDate.txt");
  FileInputFormat.setInputPaths(job, inpath);

  //设置Map
  job.setMapperClass(Map.class);
  job.setMapOutputKeyClass(IntPairs.class);
  job.setMapOutputValueClass(IntWritable.class);

  //shuffle阶段，可以自定义分区！自定义分组！设置reduce数量，设置
  job.setNumReduceTasks(3);
  job.setPartitionerClass(NewPartitioner.class);
  job.setGroupingComparatorClass(GroupComparator.class);

  //设置Reduce
  job.setReducerClass(Reduce.class);
  job.setOutputKeyClass(IntWritable.class);
  job.setOutputValueClass(IntWritable.class);

  //设置输出路径
  Path outpath = new Path("hdfs://node-1:8020/jinhao");
  //检测路径是否存在，存在则删除
  FileSystem fs = outpath.getFileSystem(conf);
  if(fs.exists(outpath)){
   fs.delete(outpath, true);
  }

  FileOutputFormat.setOutputPath(job, outpath);

  System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}

自定义的IntPairs数据类型

package com.ibeifeng.hadoop19_copy;

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

import org.apache.hadoop.io.WritableComparable;
//因为key是可序列化并且可以比较的，所以要实现WritableComparable的接口
public class IntPairs implements WritableComparable<IntPairs>{
private int first;
private int 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;
}

public void set(int left, int right){
  this.first = left;
  this.second = right;
}

@Override
public int hashCode() {
  final int prime = 31;
  int result = 1;
  result = prime * result + first;
  result = prime * result + second;
  return result;
}

@Override
public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  IntPairs other = (IntPairs) obj;
  if (first != other.first)
   return false;
  if (second != other.second)
   return false;
  return true;
}

@Override
public String toString() {
return "IntPairs [first=" + first + ", second=" + second + "]";
}

//序列化，将IntPair转化为使用流传送的二进制
public void write(DataOutput out) throws IOException {
  out.writeInt(first);
  out.writeInt(second);
}

//反序列化，从流中的二进制转化为IntPair
public void readFields(DataInput in) throws IOException {
this.first = in.readInt();
this.second = in.readInt();
}

@Override
public int compareTo(IntPairs o) {
  if(this.first != o.first){
   return this.first < o.first ? -1:1;
  }else if(this.second != o.second){
   return this.second < o.second ? -1:1;
  }else{
   return 0;
  }
}

}

自定义的分区类：

package com.ibeifeng.hadoop19_copy;

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

public class NewPartitioner extends Partitioner<IntPairs,IntWritable>{

@Override
public int getPartition(IntPairs key, IntWritable value, int numPartitions) {
int left = key.getFirst();
return left % numPartitions;
}

}

自定义的分组类

package com.ibeifeng.hadoop19_copy;

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

public class NewPartitioner extends Partitioner<IntPairs,IntWritable>{

@Override
public int getPartition(IntPairs key, IntWritable value, int numPartitions) {
int left = key.getFirst();
return left % numPartitions;
}

}

本篇理论内容摘抄自博客园，

https://www.cnblogs.com/codeOfLife/p/5568786.html

weixin_39953756

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hadoop中的二次排序实现，自定义分区，以及自定义分组

理论部分摘自博客园，感谢博主的总结！https://www.cnblogs.com/codeOfLife/p/5568786.html默认情况下，Map输出的结果会对Key进行默认的排序，但是有时候需要对Key排序的同时还需要对Value进行排序，这时候就要用到二次排序了。下面我们来说说二次排序1、二次排序原理我们把二次排序分为以下几个阶段 Map起始阶段在Map阶段，使用job.s...
复制链接

扫一扫