MapReduce WritableComparable 排序

MapReduce WritableComparable 排序

排序是MapReduce框架中最重要的操作之一。

MapTask和ReduceTask均会对数据按 照key进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是
否需要。

默认排序是按照字典顺序排序，且实现该排序的方法是快速排序。

对于MapTask，它会将处理的结果暂时放到环形缓冲区中，当环形缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一次快速排序，并将这些有序数据溢写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。

对于ReduceTask，它从每个MapTask上远程拷贝相应的数据文件，如果文件大小超过一定阈值，则溢写磁盘上，否则存储在内存中。如果磁盘上文件数目达到一定阈值，则进行一次归并排序以生成一个更大文件；如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据溢写到磁盘上。当所有数据拷贝完毕后，ReduceTask统一对内存和磁盘上的所有数据进行一次归并排序。

排序分类

（1）部分排序
MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部有序。
（2）全排序
最终输出结果只有一个文件，且文件内部有序。实现方式是只设置一个ReduceTask。但该方法在处理大型文件时效率极低，因为一台机器处理所有文件，完全丧失了MapReduce所提供的并行架构。
（3）辅助排序：（GroupingComparator分组）
在Reduce端对key进行分组。应用于：在接收的key为bean对象时，想让一个或几个字段相同（全部字段比较不相同）的key进入到同一个reduce方法时，可以采用分组排序。
（4）二次排序
在自定义排序过程中，如果compareTo中的判断条件为两个即为二次排序。

自定义排序 WritableComparable 原理分析

bean 对象做为 key 传输，需要实现 WritableComparable 接口重写 compareTo 方法，就可以实现排序。

WritableComparable全排序案例

根据序列化案例产生的结果再次对总流量进行倒序排序。

FlowBean 对象增加了比较功能

@Override
public int compareTo(FlowBean flowBean) {
    if (this.sumFlow > flowBean.sumFlow) {
        return -1;
    } else if (this.sumFlow < flowBean.sumFlow) {
        return 1;
    } else {
        if (this.upFlow>flowBean.upFlow){
            return 1;
        }else if (this.upFlow<flowBean.upFlow){
            return -1;
        }else {
            return 0;
        }
    }
}

WritableComparableMapper

package com.xiaoqiu.mapreduce.WritableComparable;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * @author 小邱
 * @version 0.0.1
 * @description WritableComparableMapper
 * @since 2021/12/2 18:25
 */
public class WritableComparableMapper extends Mapper<LongWritable, Text, FlowBean, Text> {
    private FlowBean outK = new FlowBean();
    private Text outV = new Text();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //1 获取一行数据
        String line = value.toString();
        //2 按照"\t",切割数据
        String[] split = line.split("\t");
        //3 封装 outK outV
        outK.setUpFlow(Long.parseLong(split[1]));
        outK.setDownFlow(Long.parseLong(split[2]));
        outK.setSumFlow();
        outV.set(split[0]);
        //4 写出 outK outV
        context.write(outK,outV);

    }
}

WritableComparableReducer

package com.xiaoqiu.mapreduce.WritableComparable;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * @author 小邱
 * @version 0.0.1
 * @description WritableComparableReducer
 * @since 2021/12/2 18:33
 */
public class WritableComparableReducer extends Reducer<FlowBean, Text, Text, FlowBean> {
    private FlowBean outV = new FlowBean();
    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        //遍历 values 集合,循环写出,避免总流量相同的情况
        for (Text value : values) {
            //调换 KV 位置,反向写出
            context.write(value,key);
        }
    }
}

WritableComparableDriver

package com.xiaoqiu.mapreduce.WritableComparable;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

/**
 * @author 小邱
 * @version 0.0.1
 * @description WritableComparableDriver
 * @since 2021/12/2 18:36
 */
public class WritableComparableDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        // 1 创建配置类，获取job
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);
        // 2 设置jar包路径
        job.setJarByClass(WritableComparableDriver.class);
        // 3 关联mapper和reducer
        job.setMapperClass(WritableComparableMapper.class);
        job.setReducerClass(WritableComparableReducer.class);
        // 4 设置map输出的kv类型
        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);
        // 5 设置reduce输出的kV类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);
        // 6 设置输入路径和输出路径
        FileInputFormat.setInputPaths(job,new Path("F:\\share\\output\\part-r-00000"));
        FileOutputFormat.setOutputPath(job,new Path("F:\\share\\output1"));
        // 7 提交job
        boolean b = job.waitForCompletion(true);
        System.exit(b ? 0:1);
    }
}

WritableComparable 区内排序案例

增加自定义分区类
ProvincePartitioner

package com.xiaoqiu.mapreduce.WritableComparable;

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

/**
 * @author 小邱
 * @version 0.0.1
 * @description ProvincePartitioner
 * @since 2021/12/4 11:46
 */
public class ProvincePartitioner extends Partitioner<FlowBean,Text > {
    @Override
    public int getPartition(FlowBean flowBean, Text text, int partition) {
        String s = text.toString();
        String phone = s.substring(0, 3);
        if ("136".equals(phone)){
            partition=0;
        }else if("137".equals(phone)){
            partition=1;
        }else if("138".equals(phone)){
            partition=2;
        }
        else if("139".equals(phone)){
            partition=3;
        }else {
            partition=4;
        }
        return partition;
    }
}

在驱动类中添加分区类

job.setPartitionerClass(ProvincePartitioner.class);
job.setNumReduceTasks(5);