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