Hadoop的序列化类型介绍

1、Hadoop序列化的简介？

       序列化就是把内存中的对象的状态信息转换成字节序列，以便于存储（持久化）和网络传输；反序列化就是就将收到的字节序列或者是硬盘的持久化数据，转换成内存中的对象。

JDK的序列化只要实现了serializable接口就能实现序列化与反序列化。

• 优点：实现简便，对于循环引用和重复引用的情况也能处理，允许一定程度上的类成员改变。支持加密，验证。
• 缺点：序列化后的对象占用空间过大，数据膨胀。反序列会不断创建新的对象。同一个类的对象的序列化结果只输出一份元数据（描述类关系），导致了文件不能分割。

        

Hadoop的序列化相对于JDK比较简洁，在集群信息的传递主要就是靠这些序列化的字节来传递的，所以更快速度，容量更小。

• 紧凑：由于带宽是集群中信息传递的最宝贵的资源所以我们必须想法设法缩小传递信息的大小，hadoop的序列化就为了更好地坐到这一点而设计的。
• 对象可重用：JDK的反序列化会不断地创建对象，这肯定会造成一定的系统开销，但是在hadoop的反序列化中，能重复的利用一个对象的readField方法来重新产生不同的对象。
• 可扩展性：当前hadoop的序列化有多中选择。可以利用实现hadoop的Writable接口；也使用开源的序列化框架protocol Buffers，Avro等框架。

2、Hadoop中的常用数据类型：

       JAVA中的常用数据类型，在Hadoop中都有一个对应的数据类型，我们在编写MapReduce程序时，需使用Hadoop对应的数据类型。一般直接用构造方法或者使用set方法，使用方式如下：

        Text text = new Text("this is a example");
        text.set("test");
        
        IntWritable i = new IntWritable(11);
        i.set(22);

JAVA中的类型	Hadoop中对应的类型
boolean	BooleanWritable
byte	ByteWritable
short	ShortWritable
int	IntWritable
long	LongWritable
float	FloatWritable
double	DoubleWritable
null	NullWritable
String	Text

3、Hadoop的自定义数据类型

       如果是作为Key，那么其数据类型必须实现WritableComparable接口；如果只是作为Value，那么其数据类型只需要实现Writable接口即可。

作为Value实现Writable接口的代码示例如下：

import org.apache.hadoop.io.Writable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

// 流量统计的实体类，代表着某一用户在某一时段内所有的流量使用情况
public class FlowCount implements Writable {

    private long upFlow;   // 上行流量
    private long downFlow; // 下行流量
    private long sumFlow;  // 总流量

    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 upFlow + downFlow;
    }

    /**
     * Writable接口中的write方法，把数据一个一个写出去即可
     * @param out
     * @throws IOException
     */
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    /**
     * Writable接口中的read方法，把数据一个一个按照上面写出的顺序读出来即可
     * @param in
     * @throws IOException
     */
    @Override
    public void readFields(DataInput in) throws IOException {
        this.upFlow = in.readLong();
        this.downFlow = in.readLong();
        this.sumFlow = in.readLong();
    }
}

       WritableComparable接口继承了Writable接口和Comparable接口，其中Writable实现了序列化功能，Comparable实现了比较功能。

作为Key实现WritableComparable接口的代码示例如下：

import org.apache.hadoop.io.WritableComparable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/*
    流量统计的实体类，代表着某一用户在某一时段内所有的流量使用情况，
    将该作为Key，然后可以根据总流量对手机用户进行排序
  */
public class FlowCount implements WritableComparable<FlowCount> {

    private long phoneNum; // 用户手机号

    private long upFlow;   // 上行流量
    private long downFlow; // 下行流量
    private long sumFlow;  // 总流量

    public long getPhoneNum() {
        return phoneNum;
    }

    public void setPhoneNum(long phoneNum) {
        this.phoneNum = phoneNum;
    }

    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;
    }

    /**
     * Writable接口中的write方法，把数据一个一个写出去即可
     * @param out
     * @throws IOException
     */
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeLong(phoneNum);
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    /**
     * Writable接口中的read方法，把数据一个一个按照上面写出的顺序读出来即可
     * @param in
     * @throws IOException
     */
    @Override
    public void readFields(DataInput in) throws IOException {
        this.phoneNum = in.readLong();
        this.upFlow = in.readLong();
        this.downFlow = in.readLong();
        this.sumFlow = in.readLong();
    }

    /**
     * Comparable接口中的compareTo方法，按照总流量比较，可以进行排序
     * @param flowCount
     * @return
     */
    @Override
    public int compareTo(FlowCount flowCount) {
        if(this.getSumFlow() == flowCount.getSumFlow())
            return 0;
        return this.getSumFlow() > flowCount.getSumFlow() ? 1 : -1;
    }
}