Hadoop序列化

1. 简介

简单来说，序列化就是将对象（实例）转换为字节流（字节数组）的过程，转换后的字节流可用于网络传输或写入磁盘。对应的，反序列化就是将字节流转换成对象的过程。Hadoop有自己的序列化实现，并已提取为Avro子项目。序列化要求具有字节流紧凑、处理快速、可扩展、多语言支持等特性。

2. 基本知识

Hadoop中定义了两个序列化相关的接口：Writable接口和Comparable接口，这两个接口可以合成一个接口WritableComparable。

Writable接口

所有实现了Writable接口的类都可以被序列化和反序列化。该接口定义：

package org.apache.hadoop.io;

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

public interface Writable {
  /**
  * 将对象转换为字节流并写入到输出流out中
  */
  void write(DataOutput out) throws IOException;

  /**
  * 从输入流in中读取字节流并反序列化为对象
  */
  void readFields(DataInput in) throws IOException;
}

Comparable接口

所有实现了Comparable的对象都可以和自身相同类型的对象比较大小。该接口定义：

package java.lang;
import java.util.*;

public interface Comparable<T> {
  /**
  * 将this对象和对象o比较，约定：返回<0为小于，==0为等于，>0为大于
  */
  public int compareTo(T o);
}

Hadoop自带的序列化类

实现了WritableComparable接口的类：

• 基础：BooleanWritable | ByteWritable
• 数字：IntWritable | VIntWritable | FloatWritable | LongWritable | VLongWritable | DoubleWritable
• 高级：NullWritable | Text | BytesWritable | MDSHash | ObjectWritable | GenericWritable

仅实现了Writable接口的类：

• 数组：ArrayWritable | TwoDArrayWritable
• 映射：AbstractMapWritable | MapWritable | SortedMapWritable

3. 实践

首先写3个实用的静态方法，serialize方法将Writable对象转换成字节流，deserialize方法将字节流转换成对象，printBytesHex方法打印byte[]数组对象。并通过最简单的IntWritable类，将int变量序列化，再反序列化。Serialize.java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.util.StringUtils;

public class Serialize {

    /**
     * 将Writable对象转换成字节流
     */
    public static byte[] serialize(Writable writable) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        writable.write(dataOut);
        dataOut.close();
        return out.toByteArray();
    }

    /**
     * 将字节流转换成Writable对象
     */
    public static void deserialize(Writable writable, byte[] bytes)
            throws IOException {
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        DataInputStream dataIn = new DataInputStream(in);
        writable.readFields(dataIn);
        dataIn.close();
    }

    /**
     * 打印字节流
     */
    public static void printBytesHex(byte[] bytes) {
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(StringUtils.byteToHexString(bytes, i, i + 1)
                    .toUpperCase());
            if (i % 16 == 15)
                System.out.print('\n');
            else if (i % 1 == 0)
                System.out.print(' ');
        }
    }

    public static void main(String[] args) throws IOException {
        IntWritable intWritable = new IntWritable(99999);
        // 序列化
        byte[] bytes = serialize(intWritable);
        printBytesHex(bytes);

        IntWritable intWritable2 = new IntWritable();
        // 反序列化
        deserialize(intWritable2, bytes);
        System.out.println(intWritable2);
    }
}

运行该程序可以得到：数字9999序列化字节流之后为：00 01 86 9F

VIntWritable和VLongWritable 这两个是同一个实现，将数字转化成变长的字节流，数字越小，字节流越短。

Text 经常使用，序列化为字节流长度 + String的UTF8编码，最大2G。

4. 优化

序列化和反序列化将消耗一定的资源，Hadoop中实现了直接比较字节流以确定两个Writable对象的大小，不需要进行序列化和反序列化。

以IntWritable对象的源码片段为例：

  /** A Comparator optimized for IntWritable. */ 
  public static class Comparator extends WritableComparator {
    public Comparator() {
      super(IntWritable.class);
    }

    /**
    * 通过实现compare方法进行两个字节流大小的比较
    * 其中s1和s2表示各自字节数组的起始位置，l1和l2表示各自字节数组在起始位置后的长度
    */
    public int compare(byte[] b1, int s1, int l1,
                       byte[] b2, int s2, int l2) {
      int thisValue = readInt(b1, s1);
      int thatValue = readInt(b2, s2);
      return (thisValue<thatValue ? -1 : (thisValue==thatValue ? 0 : 1));
    }
  }

  static {    // 注册comparator，可以理解为WritableComparator为管理者
    WritableComparator.define(IntWritable.class, new Comparator());
  }