Hadoop 3.x|第九天|序列化及案例代码编写

Hadoop序列化

定义

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

为什么需要序列化

因为内存不能直接传递对象，所以hadoop采用序列化的方式传递。

为什么不用Java的序列化

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

源码

序列化案例实操-流量统计

需求

统计每一个手机号耗费的总上行流量，总下行流量，总流量

输入数据

1 13736230513 192.196.100.1 www.atguigu.com 2481 24681 200
2 13846544121 192.196.100.2 264 0 200
3 13956435636 192.196.100.3 132 1512 200
4 13966251146 192.168.100.1 240 0 404
5 18271575951 192.168.100.2 www.atguigu.com 1527 2106 200
6 84188413 192.168.100.3 www.atguigu.com 4116 1432 200
7 13590439668 192.168.100.4 1116 954 200
8 15910133277 192.168.100.5 www.hao123.com 3156 2936 200
9 13729199489 192.168.100.6 240 0 200
10 13630577991 192.168.100.7 www.shouhu.com 6960 690 200
11 15043685818 192.168.100.8 www.baidu.com 3659 3538 200
12 15959002129 192.168.100.9 www.atguigu.com 1938 180 500
13 13560439638 192.168.100.10 918 4938 200
14 13470253144 192.168.100.11 180 180 200
15 13682846555 192.168.100.12 www.qq.com 1938 2910 200
16 13992314666 192.168.100.13 www.gaga.com 3008 3720 200
17 13509468723 192.168.100.14 www.qinghua.com 7335 110349 404
18 18390173782 192.168.100.15 www.sogou.com 9531 2412 200
19 13975057813 192.168.100.16 www.baidu.com 11058 48243 200
20 13768778790 192.168.100.17 120 120 200
21 13568436656 192.168.100.18 www.alibaba.com 2481 24681 200
22 13568436656 192.168.100.19 1116 954 200

输出数据

期望输出的是：以手机号码为key，它的上行流量和下行流量，以及总流量

分析各个阶段的KV

map阶段输入的key：必定是偏移量
map阶段输入的value：必定为一行数据，如

1 13736230513 192.196.100.1 www.atguigu.com 2481 24681 200

map阶段输出的key：相同的手机号
map阶段输出的value：因为不能够包揽所有不同标准的，于是把它们封装成一个bean对象，作为一个整体进行传输
reduce阶段输入的key和value就是map里输出的key和value
reduce阶段输出的key：手机号
reduce阶段输出的value：bean对象
bean对象要能够进行传输，必须实现序列化接口

自定义对象实现序列化接口的步骤

1. 实现 Writable 接口
2. 反序列化时，需要反射调用空参构造函数，所以必须有空参构造
3. 重写序列化方法
4. 重写反序列化方法
5. 注意反序列化的顺序和序列化的顺序完全一致
6. 要想把结果显示在文件中，需要重写 toString()
7. 如果需要将自定义的 bean 放在 key 中传输，则还需要实现 Comparable 接口，因为MapReduce 框中的 Shuffle 过程要求key必须能排序。

创建FlowBean对象

用来储存三类流量

继承接口

package com.mapreduce.writable;
import org.apache.hadoop.io.Writable;

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

public class FlowBean implements Writable {

    @Override
    public void write(DataOutput dataOutput) throws IOException {
        
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {

    }
}

具体代码

package com.mapreduce.writable;

import org.apache.hadoop.io.Writable;

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

public class FlowBean implements Writable {
    //三种流量构成属性
    private long upFlow;
    private long downFlow;
    private long sumFlow;
    //空参构造
    public FlowBean(){

    }
    //三个属性的get和set方法
    public long getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(long upFlow) {
        this.upFlow = upFlow;
    }

    public long getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(long downFlow) {
        this.downFlow = downFlow;
    }

    public long getSumFlow() {
        return sumFlow;
    }

    public void setSumFlow(long sumFlow) {
        this.sumFlow = sumFlow;
    }
    //因为sum为up+down 所以要重新写一个方法
    public void setSumFlow(){
        this.sumFlow = this.upFlow+this.downFlow;
    }

    //开始重写序列化方法
    @Override
    public void write(DataOutput dataOutput) throws IOException {
        //把输入进来的DataOutput对流量进行写操作
        dataOutput.writeLong(this.upFlow);
        dataOutput.writeLong(this.downFlow);
        dataOutput.writeLong(this.sumFlow);

    }
    //开始重写反序列化方法
    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.upFlow = dataInput.readLong();
        this.downFlow = dataInput.readLong();
        this.sumFlow = dataInput.readLong();
    }
    //重写toString() 方法

    @Override
    public String toString() {
        return upFlow +"\t" + downFlow +"\t"+ sumFlow;
    }
}

编写Mapper部分

继承Mapper

public class FLowMapper extends Mapper<LongWritable, Text,Text,FlowBean> {
}

`

## 具体代码

```java
package com.mapreduce.writable;

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 outK = new Text();
    private  FlowBean outV = new FlowBean();

    //重写map方法
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //获取一行
        String line = value.toString();
        //切割
        String[] split = line.split("\t");
        //抓取自己想要的数据 手机号 上行流量 下行流量
        String phone = split[1];
        //因为有列可能出现空值 所以从后开始取
        String up  = split[split.length-3];
        String down = split[split.length-2];
        //封装
        outK.set(phone);
        outV.setDownFlow(Long.parseLong(down));
        outV.setUpFlow(Long.parseLong(up));
        outV.setSumFlow();
        //写出
        context.write(outK,outV);
    }
}

``

编写Reducer部分

package com.mapreduce.writable;

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 outV = new FlowBean();
    //重写reduce
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {
        //遍历
        long totalup=0;
        long totaldown=0;
        for(FlowBean bean:values){
            totalup+=bean.getUpFlow();
            totaldown+=bean.getDownFlow();
        }
        //封装outK outV
        outV.setUpFlow(totalup);
        outV.setDownFlow(totaldown);
        outV.setSumFlow();
        //封装
        context.write(key,outV);
    }
}

运行结果