大数据学习13_MapReduce计数器&排序和序列化

MapReduce 中的计数器

计数器介绍

计数器是收集作业统计信息的有效手段之一，用于质量控制或应用级统计。计数器还可辅助 诊断系统故障。如果需要将日志信息传输到 map 或 reduce 任务， 更好的方法通常是看能否 用一个计数器值来记录某一特定事件的发生。对于大型分布式作业而言，使用计数器更为方 便。除了因为获取计数器值比输出日志更方便，还有根据计数器值统计特定事件的发生次数 要比分析一堆日志文件容易得多。

hadoop内置计数器列表

1. MapReduce任务计 数器 org.apache.hadoop.mapreduce.TaskCounter
2. 文件系统计数器 org.apache.hadoop.mapreduce.FileSystemCounter
3. FileInputFormat计数 器 org.apache.hadoop.mapreduce.lib.input.FileInputFormatCounter
4. FileOutputFormat计 数器 org.apache.hadoop.mapreduce.lib.output.FileOutputFormatCounter
5. 作业计数器 org.apache.hadoop.mapreduce.JobCounter

实现自己的计数器

//方式1：定义计数器
        Counter counter = context.getCounter("MR_COUNTER", "partition_counter");
        //每次执行该方法，则计数器变量的值加1
        counter.increment(1L);

　　

 public static enum  Counter{
        MY_INPUT_RECOREDS,MY_INPUT_BYTES
    }
//方式2：使用枚枚举来定义计数器
        context.getCounter(Counter.MY_INPUT_RECOREDS).increment(1L);

MapReduce 排序和序列化

介绍

• 序列化 (Serialization) 是指把结构化对象转化为字节流
• 反序列化 (Deserialization) 是序列化的逆过程. 把字节流转为结构化对象. 当要在进程间传 递对象或持久化对象的时候, 就需要序列化对象成字节流, 反之当要将接收到或从磁盘读取 的字节流转换为对象, 就要进行反序列化
• Java 的序列化 (Serializable) 是一个重量级序列化框架, 一个对象被序列化后, 会附带很多额 外的信息 (各种校验信息, header, 继承体系等）, 不便于在网络中高效传输. 所以, Hadoop 自己开发了一套序列化机制(Writable), 精简高效. 不用像 Java 对象类一样传输多层的父子 关系, 需要哪个属性就传输哪个属性值, 大大的减少网络传输的开销
• Writable 是 Hadoop 的序列化格式, Hadoop 定义了这样一个 Writable 接口. 一个类要支持可 序列化只需实现这个接口即可
• 另外 Writable 有一个子接口是 WritableComparable, WritableComparable 是既可实现序列 化, 也可以对key进行比较, 我们这里可以通过自定义 Key 实现 WritableComparable 来实现 我们的排序功能

实战

要求:

第一列按照字典顺序进行排列

第一列相同的时候, 第二列按照升序进行排列

SortBean

public class SortBean implements WritableComparable<SortBean> {
    private String word;
    private int  num;
    public String getWord() {
        return word;
    }

    public void setWord(String word) {
        this.word = word;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return   word + "\t"+ num ;
    }

    //实现比较器，指定排序的规则
    /*
      规则:  快速排序  归并排序
        第一列(word)按照字典顺序进行排列    //  aac   aad
        第一列相同的时候, 第二列(num)按照升序进行排列
     */


    @Override
    public void write(DataOutput out) throws IOException {

        out.writeUTF(word);
        out.writeInt(num);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.word = in.readUTF();
        this.num = in.readInt();

    }


    @Override
    public int compareTo(SortBean sortBean) {
        //先对第一列排序: Word排序
        int result = this.word.compareTo(sortBean.word);
        //如果第一列相同，则按照第二列进行排序
        if(result == 0){
            return  this.num - sortBean.num;
        }
        return result;
    }
}

SortMapper

public class SortMapper extends Mapper<LongWritable, Text,SortBean, NullWritable> {
    /*
     map方法将K1和V1转为K2和V2:

     K1            V1
     0            a  3
     5            b  7
     ----------------------
     K2                         V2
     SortBean(a  3)         NullWritable
     SortBean(b  7)         NullWritable
    */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //1:将行文本数据(V1)拆分，并将数据封装到SortBean对象,就可以得到K2
        String[] split = value.toString().split("\t");

        SortBean sortBean = new SortBean();
        sortBean.setWord(split[0]);
        sortBean.setNum(Integer.parseInt(split[1]));

        //2:将K2和V2写入上下文中
        context.write(sortBean, NullWritable.get());
    }
}

SortReducer

public class SortReducer extends Reducer<SortBean, NullWritable,SortBean,NullWritable> {
    //reduce方法将新的K2和V2转为K3和V3
    @Override
    protected void reduce(SortBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        context.write(key, NullWritable.get());
    }
}

JobMain

public class JobMain extends Configured implements Tool {
    @Override
    public int run(String[] strings) throws Exception {
        //1:创建job对象
        Job job = Job.getInstance(super.getConf(), "mapreduce_sort");

        //2:配置job任务(八个步骤)
        //第一步:设置输入类和输入的路径
        job.setInputFormatClass(TextInputFormat.class);
       
        TextInputFormat.addInputPath(job, new Path("file:///F:\\input\\sort_input"));

        //第二步: 设置Mapper类和数据类型
        job.setMapperClass(SortMapper.class);
        job.setMapOutputKeyClass(SortBean.class);
        job.setMapOutputValueClass(NullWritable.class);

        //第三，四，五，六

        //第七步：设置Reducer类和类型
        job.setReducerClass(SortReducer.class);
        job.setOutputKeyClass(SortBean.class);
        job.setOutputValueClass(NullWritable.class);


        //第八步: 设置输出类和输出的路径
        job.setOutputFormatClass(TextOutputFormat.class);
        
        TextOutputFormat.setOutputPath(job, new Path("file:///F:\\out\\sort_out"));


        //3:等待任务结束
        boolean bl = job.waitForCompletion(true);

        return bl?0:1;
    }
    public static void main(String[] args) throws Exception {
        Configuration configuration = new Configuration();
        //启动job任务
        int run = ToolRunner.run(configuration, new JobMain(), args);

        System.exit(run);
    }
}

　查看运行结果

原文件：

 

排序后的文件：