13mapreduce——排序

作用

类似于sql语句中的order by功能
默认情况下，mapreduce中，会默认对Mapper输出的key来进行自然排序,所以如果说希望对结构中的某个字段进行排序的话，就把这个字段放到map输出的key里面去。【排序是为了合并，为了reduce的计算分组】

概述

1、在MapReduce中，会默认对Mapper输出的键来进行自然排序；，所以也要求Mapper输出的键对应的类型必须实现Comparable，考虑到这个类型的对象还要被序列化，所以还需要实现Writable接口 - WritableComparable。比如Text类型也是继承了这个接口。
2、如果针对多字段进行排序，称之为二次排序 （也就是不止一个排序字段）
3、注意事项，在排序的时候，如果两个键compareTo的结果都为0，那么在MapReduce中，会认为这两个键实际上是同一个键，然后在Reduce阶段将这两个键对应的值放到一组去 ；其实不止是排序两个键，无论排序多少个键，只要比较下来都相等都是0的话，那么在reduce阶段都会将其分到同一组去。【例如下面的案例，当存在两个同分用户时，就会出现问题】,为了避免分到同一组 ，所以比较的字段可以唯一标识一行才可以。
4、将需要进行排序的内容进行封装，实现WritableComparable接口，重写其中的方法，注意比较为0的情况。

测试案例

对之前统计的学生的总成绩进行排序，按照成绩进行排序
先对每个学生的成绩进行求和，然后在根据成绩进行排序
如果想把自定义的类型输出在文本文件中的话，需要重写toString()方法，要不然最后写到结果文件中的就是一个内存地址了

package sortScore;

import org.apache.hadoop.io.WritableComparable;

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

//map输出的key类型
public class SumScore implements WritableComparable<SumScore> {
    //1 tom 888
    private int month;
    private String name = "";
    private int score;

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public int compareTo(SumScore o) {
        return this.score-o.getScore();
    }

    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeInt(this.month);
        dataOutput.writeUTF(this.name);
        dataOutput.writeInt(this.score);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.month = dataInput.readInt();
        this.name = dataInput.readUTF();
        this.score = dataInput.readInt();
    }

    @Override
    public String toString() {
        return "SumScore{" +
                "month=" + month +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

package sortScore;

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

import java.io.IOException;

/**
 * 希望对每个学生的总成绩进行排序，所以将学生的成绩作为输出key值
 */
public class sortMapper extends Mapper<LongWritable, Text,SumScore, NullWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] s = value.toString().split(" ");
        SumScore sumScore = new SumScore();
        sumScore.setMonth(Integer.parseInt(s[0]));
        sumScore.setName(s[1]);
        sumScore.setScore(Integer.parseInt(s[2]));
        context.write(sumScore,NullWritable.get());
    }
}

package sortScore;

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

import java.io.IOException;

public class sortReducer extends Reducer<SumScore, NullWritable,SumScore,NullWritable> {
    @Override
    protected void reduce(SumScore key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        context.write(key,NullWritable.get());
    }
}

package sortScore;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
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;

public class Driver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Job instance = Job.getInstance(new Configuration());
        instance.setJarByClass(Driver.class);
        instance.setMapperClass(sortMapper.class);
        instance.setReducerClass(sortReducer.class);
        instance.setOutputKeyClass(SumScore.class);
        instance.setOutputValueClass(NullWritable.class);
        FileInputFormat.addInputPath(instance,new Path("hdfs://hadoop01:9000/txt/totolscore.txt"));
        FileOutputFormat.setOutputPath(instance,new Path("hdfs://hadoop01:9000/result/ooo2"));
        instance.waitForCompletion(true);
    }
}

测试案例修改——存在同分学生时

2 tom 345
1 rose 235
1 tom 235
2 jim 572
3 rose 123
1 jim 321
2 tom 573
3 jim 876
3 tom 648

输出结果：
没有同分时：

有同分时：

输出结果少了一行 ： 1 rose 235
这是由于读取到的两行 1 rose 235 和 1 tom 235，比较时只比较了分数，认为这两行应该是属于同一个组，同一个key值，所以在reduce阶段，会把两行当做一行来进行处理，最后的结果也只有一行了【key:1 tom 235 value：null null】

解决办法：
只有增加一个比较条件，就是两个学生同分时，比较名称，让reduce不在判断这两行记录是同一行记录。

    @Override
    public int compareTo(SumScore o) {
        int res = this.score-o.getScore();
        if(res == 0){
            return this.getName().compareTo(o.getName());
        }
        return res;
    }

【如果使用SQL进行统计，也需要order by score,name】