MapReduce 经典案例手机流量排序的分析

在进行流量排序之前,先要明白排序是发生在map阶段,排序之后(排序结束后map阶段才会显示100%完成)才会到reduce阶段(事实上reduce也会排序),.此外排序之前要已经完成了手机流量的统计工作,即把第一次mr的结果作为本次排序的输入.也就是说读取的数据格式为     手机号 上行流量 下行流量 总流量

1,map阶段,读取并封装流量信息,不同的是context.write()时key必须是封装的实体类,而不再是手机号

 /**
  * 输入key 行号
  * 输入value 流量信息
  * 输出key 封装了流量信息的FlowBean
  * 输出value 手机号
  * @author tele
  *
  */
 public class FlowSortMapper extends Mapper<LongWritable,Text,FlowBean,Text>{
     FlowBean flow  = new FlowBean();
     Text v = new Text();
     //读取的内容格式 手机号 上行流量 下行流量 总流量
     @Override
     protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, FlowBean, Text>.Context context)
             throws IOException, InterruptedException {

         //1.读取
         String line = value.toString();

         //2.切割
         String[] split = line.split("\t");
         String upFlow = split[1];
         String downFlow = split[2];
         String phoneNum = split[0];

         //3.封装流量信息
         flow.set(Long.parseLong(upFlow),Long.parseLong(downFlow));

         v.set(phoneNum);

         //4.写出
         context.write(flow,v);

     }
 }

2.map之后会根据key进行排序,因此如果要实现自定义排序,必须让定义的bean实现WritableComparable接口,并重写其中的compare方法,我们只需要告诉MapReduce根据什么排序,升序还是降序就可以了

具体的排序过程由MapReduce完成

 public class FlowBean implements WritableComparable<FlowBean>{
     private long upFlow;
     public long getUpFlow() {
         return upFlow;
     }
     public void setUpFlow(long upFlow) {
         this.upFlow = upFlow;
     }
     public long getDownFlow() {
         return downFlow;
     }
     public void setDownFlow(long downFlow) {
         this.downFlow = downFlow;
     }
     public long getSumFlow() {
         return sumFlow;
     }
     public void setSumFlow(long sumFlow) {
         this.sumFlow = sumFlow;
     }
     private long downFlow;
     private long sumFlow;

     /**
      * 反序列化时需要通过反射调用空参构造方法.必须有空参构造
      */
     public FlowBean() {
         super();
     }

     public FlowBean(long upFlow, long downFlow) {
         super();
         this.upFlow = upFlow;
         this.downFlow = downFlow;
         this.sumFlow = upFlow + downFlow;
     }

     public void set(long upFlow, long downFlow) {
         this.upFlow = upFlow;
         this.downFlow = downFlow;
         this.sumFlow = upFlow + downFlow;
     }

     /**
      * 序列化与反序列化顺序必须一致
      */

     //序列化
     @Override
     public void write(DataOutput output) throws IOException {
         output.writeLong(upFlow);
         output.writeLong(downFlow);
         output.writeLong(sumFlow);

     }

     //反序列化
     @Override
     public void readFields(DataInput input) throws IOException {
         upFlow = input.readLong();
         downFlow = input.readLong();
         sumFlow = input.readLong();
     }

     /**
      * reduce context.write()会调用此方法
      */
     @Override
     public String toString() {
         return upFlow + "\t" + downFlow + "\t" + sumFlow;
     }

     @Override
     public int compareTo(FlowBean o) {
         // -1表示不交换位置,即降序,1表示交换位置,升序
         return this.sumFlow > o.getSumFlow() ? -1:1;
     }

 }

3.reduce阶段,map阶段会对输出的value根据key进行分组,具有相同key的value会被划分到一组,这样reduce阶段执行一次reduce()读取一组,由于map阶段输出的key是定义的FlowBean,因此key是唯一的,从而

每组只有一个值,即Iterable<Text> value中只有一个值,也就是只有一个手机号

 /**
  * 输出的格式仍然为 手机号 上行流量 下行流量 总流量
  * @author tele
  *
  */
 public class FlowSortReducer extends Reducer<FlowBean,Text,Text,FlowBean>{
     /**
      * reduce阶段读入的仍然是一组排好序的数据
      * 前面map阶段输出的结果已根据key(FlowBean)进行分组,但由于此处key的唯一
      * 所以一组只有一个数据,即 Iterable<Text> value 中只有一个值
      */
     @Override
     protected void reduce(FlowBean key, Iterable<Text> value, Reducer<FlowBean, Text, Text, FlowBean>.Context context)
             throws IOException, InterruptedException {

         //输出
         Text phone = value.iterator().next();
         context.write(phone,key);

     }
 }

下面进行debug,在map(),reduce()方法的开始与结束均打上断点,在FlowBean的compareTo()中也打上断点

map读取的内容

写出,注意key是FlowBean对象

接下来是排序,可以看到排序时map仍然不是100%,也就是说map阶段进行了排序(reduce阶段也会进行排序)

排序之后进入reduce阶段,reduce时write会调用FlowBean的toString()把结果输出到磁盘上

reduce除了归并排序之外,在执行write时同样会进行一次排序,执行第一组的write,(会调用FlowBean的toString()).但接下来还会去执行compareTo方法,此时在磁盘上生成的是临时目录,并且生成的part000文件是0KB,在执行完第二组的write之后才会真正把第一组数据写出到磁盘上

part000此时有了数据

这样看来我们重写的compareTo方法无论在map阶段还是reduce阶段都被调用了