MapReduce 排序三种实现方式

MapReduce 排序两种实现方式

MapReduce 排序两种实现方式 都是借助重写 compareTo 方法 实现
方式一：借助 MapReduce 按照 Key 排序特性，在WritableComparable实现类中 重写 compareTo 方法
方式二：在 Reduce 阶段 cleanUp方法中将最终结果封装到实现JavaBean对象使用集合的排序方法
方式三：在 Reduce 阶段 cleanUp方法中将最终结果封装到实现Comparable的实现类使用集合的排序方法

方式一

该方式需要两次 MapReduce
第一次 MapReduce 做分类统计
第二次 MapReduce 实现排序

第一次 MapReduce 做分类统计

1. 第一次 MapReduce 做分类统计 Mapper 类

   package cn.lhz.hadoop.mapreduce.wordcount03;
   
   import org.apache.hadoop.io.IntWritable;
   import org.apache.hadoop.io.LongWritable;
   import org.apache.hadoop.io.Text;
   import org.apache.hadoop.mapreduce.Mapper;
   
   import java.io.IOException;
   import java.util.StringTokenizer;
   
   /**
    * map 阶段
    * Mapper<LongWritable, Text, Text, IntWritable>
    * 前两个 LongWritable,Text 为 map 输入数据的类型，LongWritable 文本文件偏移量，Text 是读取一行的内容
    * 后两个 Text,IntWritable 为 map 输出数据的类型 ，map输出 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
    *
    * @author 李昊哲
    * @version 1.0.0
    */
   public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
        
        
     // 定义map输出的value
     private final static IntWritable one = new IntWritable(1);
   
     // 定义map输出的key
     private final Text word = new Text();
   
     /**
      * @param key     map输入偏移量
      * @param value   map输入的内容
      * @param context Mapper.Context 可以利用该对象做 map 的输出操作
      * @throws IOException          IOException
      * @throws InterruptedException InterruptedException
      */
     @Override
     protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
        
        
       // 将输入的内容转为 java 字符串
       String line = value.toString();
       // 默认分隔为 空格 \t \n \r 可以利用构造方法传入自定义分隔符
       StringTokenizer itr = new StringTokenizer(line);
       while (itr.hasMoreTokens()) {
        
        
         // 获取每一行中的每一个单词
         String string = itr.nextToken();
         // 封装 map 阶段输出 key
         word.set(string);
         // 将读取内容安需求输（map阶段输出）
         context.write(word, one);
       }
     }
   }
   
   

2. 第一次 MapReduce 做分类统计 Reducer 类

   package cn.lhz.hadoop.mapreduce.wordcount03;
   
   import org.apache.hadoop.io.IntWritable;
   import org.apache.hadoop.io.Text;
   import org.apache.hadoop.mapreduce.Reducer;
   
   import java.io.IOException;
   
   /**
    * reduce 阶段
    * Reduce<Text, IntWritable,Text,IntWritable> 中四个泛型 两个为一组
    * 前两个 LongWritable,Text 为 map 输出 reduce 输入 数据的类型，map 输出 reduce 输入 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
    * 后两个 Text,IntWritable 为 reduce 输出数据的类型 ，reduce 输出 是一个 key value 数据结构， Text 是 key 的数据类型，IntWritable 是 value 的数据类型
    *
    * @author 李昊哲
    * @version 1.0.0
    */
   public class WordCountReduce extends Reducer<Text, IntWritable, Text, IntWritable> {
        
        
     // 定义 reduce 输出 value
     private IntWritable result = new IntWritable();
   
     @Override
     protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
        
        
       // 单词数量累加的和
       int sum = 0;
       // 遍历迭代器
       for (IntWritable value : values) {
        
        
         // 单词标记累加得到单词数量
         sum += value.get();
       }
       // 封装 reduce 输出 value
       result.set(sum);
       // reduce 输出
       context.write(key, result);
     }
   }
   
   

   3. 第一次 MapReduce 做分类统计 Job 类

   package cn.lhz.hadoop.mapreduce.wordcount03;
   
   import org.apache.hadoop.conf.Configuration;
   import org.apache.hadoop.fs.FileSystem;
   import org.apache.hadoop.fs.Path;
   import org.apache.hadoop.hdfs.DistributedFileSystem;
   import org.apache.hadoop.io.IntWritable;
   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.net.URI;
   
   
   /**
    * 本地提交 mapreduce 任务到 集群
    * 1、打包项目
    * 2、重新编写代码 添加 本地 jar 文件路径 job.setJar(本地jar文件路径)
    * 3、本地提交
    * 服务器提交 mapreduce 任务到 集群
    * 1、打包项目 注意：代码中不允许出现 job.setJar(本地jar文件路径)
    * 2、上传 jar文件到集群
    * 3、提交 hadoop jar hadoop.jar cn.lhz.hadoop.mapreduce.wordcount03.WordCount
    *
    * @author 李昊哲
    * @version 1.0.0
    */
   public class WordCount {
        
        
   
     public static void main(String[] args) throws Exception {
        
        
       // 设置环境变量 hadoop 用户名 为 root
       System.setProperty("HADOOP_USER_NAME", "root");
   
       // 参数配置对象
       Configuration conf = new Configuration();
   
       // 跨平台提交
       conf.set("mapreduce.app-submission.cross-platform", "true");
   
       // 本地运行
       // conf.set("mapreduce.framework.name", "local");
   
       // 设置默认文件系统为 本地文件系统
       // conf.set("fs.defaultFS", "file:///");
   
       // 声明Job对象 就是一个应用
       Job job = Job.getInstance(conf, "word count");
   
       // 本地提交启用该行
       // job.setJar("F:\\code\\bigdata2024\\bigdata\\hadoop\\target\\hadoop.jar");
   
       // 指定当前Job的驱动类
       job.setJarByClass(WordCount.class);
   
       // 指定当前Job的 Mapper
       job.setMapperClass(WordCountMapper.class);
       // 指定当前Job的 Combiner 注意：一定不能影响最终计算结果 否则 不使用
       job.setCombinerClass(WordCountReduce.class);
       // 指定当前Job的 Reducer
       job.setReducerClass(WordCountReduce.class);
   
       // 设置 map 输出 key 的数据类型
       job.setMapOutputValueClass(Text.class);
       // 设置 map 输出 value 的数据类型
       job.setMapOutputValueClass(IntWritable.class);
       // 设置 reduce 输出 key 的数据类型
       job.setOutputKeyClass(Text.class);
       // 设置 reduce 输出 value 的数据类型
       job.setOutputValueClass(IntWritable.class);
       // 定义 map 输入的路径 注意：该路径默认为hdfs路径
       FileInputFormat.addInputPath