Hadoop 序列化操作

1、序列化概述

1.1 什么是序列化

  序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。
  反序列化就是将收到字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。

1.2 为什么要序列化

  一般来说，“活的”对象只生存在内存里，关机断电就没有了。而且“活的”对象只能由本地的进程使用，不能被发送到网络上的另外一台计算机。然而序列化可以存储“活的”对象，可以将“活的”对象发送到远程计算机。

1.3 为什么不用Java 的序列化

  Java 的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，Header，继承体系等），不便于在网络中高效传输。所以，Hadoop 自己开发了一套序列化机制（Writable）。

1.4 Hadoop 序列化特点

• 紧凑 ：高效使用存储空间。
• 快速：读写数据的额外开销小。
• 互操作：支持多语言的交互。如可以使用其它语言进行反序列化操作。

2、实现自定义序列化接口（Writable）

2.1 自定义序列化基本步骤

  在企业开发中往往常用的基本序列化类型不能满足所有需求，比如在Hadoop 框架内部传递一个bean 对象，那么该对象就需要实现序列化接口。 具体实现bean 对象序列化步骤如下7 步。
（1）必须实现Writable 接口
（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造

public FlowBean() { 
 super(); 

}
（3）重写序列化方法

@Override 
public void write(DataOutput out) throws IOException { 
 out.writeLong(upFlow); 
 out.writeLong(downFlow); 
 out.writeLong(sumFlow);
}

（4）重写反序列化方法

@Override
public void readFields(DataInput in) throws IOException { 
 upFlow = in.readLong();
 downFlow = in.readLong();
 sumFlow = in.readLong();
}

（5）注意反序列化的顺序和序列化的顺序完全一致
（6）要想把结果显示在文件中，需要重写toString()，可用"\t"分开，方便后续调用。
（7）如果需要将自定义的bean 放在key 中传输，则还需要实现Comparable 接口，因为MapReduce 框架中的Shuffle 过程默认要求对key 必须能排序

@Override
public int compareTo(FlowBean o) {
 // 倒序排列，从大到小
 return this.sumFlow > o.getSumFlow() ? -1 : 1; 
}

2.2 自定义序列化案例

1. 分析需求及实现逻辑

  统计每一个手机号耗费的总上行流量、总下行流量、总流量。输入数据格式：

id	手机号码	网络ip	上行流量	下行流量	网络状态码
1	13560436666	120.196.100.99	1116	954	200
…	…	…	…	…	…

期望输出数据格式：

手机号码	上行流量	下行流量	总流量
13560436666	1116	954	2070
…	…	…	…

1、Map阶段
（1）读取一行数据，切分字段
（2）抽取手机号、上行流量、下行流量
（3）以手机号为key，bean对象为value输出，因为value不能同时输出三个值，只能将这三个值封装成bean对象，即context.write(手机号,bean);
（4）bean对象要想能够传输，必须实现hadoop的序列化接口

2、Reduce阶段
（1）累加上行流量和下行流量得到总流量。

2. 编写MapReduce 程序

  由于期望传输的数据的value有多个，我们需要定义一个自定义的封装类。
1、FlowBean.java

package cn.jiangyun.mapreduce.serializable;

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
 * 定义一个bean对象类并实现Writable接口
 * 1、重写空参构造
 * 2、重写序列化方法和反序列化方法
 * 4、重写toString方法
 */
public class FlowBean implements Writable{
    //bean对象包含的属性
    private long upFlow;
    private long downFlow;
    private long sumFlow;

    //1、重写空参构造,快捷键alt+insert
    public FlowBean() {
    }

    //2、重写序列化方法和反序列化方法
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.upFlow = in.readLong();
        this.downFlow = in.readLong();
        this.sumFlow = in.readLong();
    }

	//3、重写toString,输出为我们想要的格式快捷键alt+insert
    @Override
    public String toString() {
        return upFlow +
                "\t" + downFlow +
                "\t" + sumFlow;
    }

	//alt+insert得到各属性get、set方法，此处省略

    //后面对sumFlow求和
    public void setSumFlow() {
        this.sumFlow = this.upFlow+this.downFlow;
    }

}

2、FlowMapper.java

package cn.jiangyun.mapreduce.serializable;

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

import java.io.IOException;

public class FlowMapper extends Mapper<LongWritable, Text,Text,FlowBean> {
    private Text outKey = new Text();
    private FlowBean outValue = new FlowBean();
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        //1.获取一行
        String line = value.toString();
        //2.分割
        String[] split = line.split("\t");
        //3.只要手机号、上行流量、下行流量
        String phone = split[1];
        String up = split[split.length-3];//倒数第三个为上行流量
        String down = split[split.length-2];//倒数第二个为下行流量
        //4.封装k,v
        outKey.set(phone);//不要使用key，会冲突导致参数类型错误,使用我们自己定义的outKey
        outValue.setUpFlow(Long.parseLong(up));
        outValue.setDownFlow(Long.parseLong(down));
        outValue.setSumFlow();//必须先完成up和down的赋值才能进行这一步，否则结果不正确
        //5.写出
        context.write(outKey,outValue);
    }
}

3、FlowReducer.java

package cn.jiangyun.mapreduce.serializable;

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

import java.io.IOException;

public class FlowReducer extends Reducer<Text,FlowBean,Text,FlowBean> {
    private FlowBean outValue = new FlowBean();
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Reducer<Text, FlowBean, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        //1.遍历集合取值
        long totalUp = 0,totalDown = 0;
        for (FlowBean value : values) {
            totalUp += value.getUpFlow();
            totalDown += value.getDownFlow();
        }
        //2.封装outKey不变，outValue加上sumFlow
        outValue.setUpFlow(totalUp);
        outValue.setDownFlow(totalDown);
        outValue.setSumFlow();//这个操作在FlowBean类里定义了设置累加方法
        //3.写出
        context.write(key,outValue);
    }
}

4、FlowDriver.java

package cn.jiangyun.mapreduce.serializable;

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;

public class FlowDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        //1.获取job
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        //2.设置jar路径
        job.setJarByClass(FlowDriver.class);

        //3.关联Mapper和Reducer
        job.setMapperClass(FlowMapper.class);
        job.setReducerClass(FlowReducer.class);

        //4.设置map阶段输出类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);

        //5.设置最终输出类型
        job.setOutputValueClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        //6.设置输入输出路径
        FileInputFormat.setInputPaths(job,new Path("src/main/java/cn/jiangyun/mapreduce/serializable/phone_data.txt"));
        FileOutputFormat.setOutputPath(job,new Path("src/main/java/cn/jiangyun/mapreduce/serializable/output"));

        //7.提交job
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);
    }
}