Hadoop 学习研究: 序列化与Writable

本文所有分析都基于Hadoop 2.6.5

序列化和反序列化就是结构化对象和字节流之间的转换，主要用在内部进程的通讯和持久化存储方面。

 

序列化存储格式要求：

 

1.压缩，占用的空间更小

2.快速，可以快速读写

3.可扩展，可以以老格式读取老数据

4.兼容性好，可以支持多种语言的读写

 

在Hadoop中实现了自己的序列化存储格式的接口：Writable接口

public interface Writable {
  void write(DataOutput out) throws IOException; //将数据写到二进制流中
  void readFields(DataInput in) throws IOException; //从二进制流中读取数据
}

 

在实现用作自定义key值的类的时候，需要实现WritableComparable接口，在序列化的同时，多实现一个对象的比较compareto函数，用于Key值的排序，所以Writable接口的实现参照WritableComparable接口就行啦。

 

 

给出一个小例子吧：

class key_own implements WritableComparable{
	String date1;    //date1 + date2 用来排序   04/Jan/2012:03  :   27:01
	String date2;
	
	public key_own(){}
	public key_own(String date1, String date2){
		this.date1 = date1;   this.date2 = date2;
	}

	@Override
	public void write(DataOutput out) throws IOException {
		// TODO Auto-generated method stub
		out.writeUTF(date1);
		out.writeUTF(date2);
	}

	@Override
	public void readFields(DataInput in) throws IOException {
		// TODO Auto-generated method stub
		date1 = in.readUTF();
		date2 = in.readUTF();
	}

	@Override
	public int compareTo(Object o) {
		key_own o2 = (key_own) o;
		if(this.date1.compareTo(o2.date1)<0){
			return -1;
		}else{
			return 1;
		}
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return date1 + "   " + date2;
	}

//此处是用来验证序列化流的 	
	public byte[] serialize(Writable w)throws IOException{     //序列化
	    ByteArrayOutputStream out = new ByteArrayOutputStream();
	    DataOutputStream dataout = new DataOutputStream(out);
	    w.write(dataout);
	    dataout.close();
	    return out.toByteArray();
	}
	
    public byte[] deserialize(Writable w, byte[] bytes) throws IOException{  //反序列化<-
	    ByteArrayInputStream in = new ByteArrayInputStream(bytes);
	    DataInputStream datain = new DataInputStream(in);
	    w.readFields(datain);
	    datain.close();
	    return bytes;
	} 
}

 

 

这里实现了一个用于key值的序列化类，我们注意到：

序列化和反序列化对于这个类中的数据的顺序是必须要一致的，先序列化 date1,date2  反序列化也需要是date1,date2。

在实现key值的类中，注意到有一个Compareto方法，这个方法用于key值的排序，后面再进行介绍。

 

我们可以看一下一个输出实例： 实例化上诉类，使用serialize()   输入的

date1  = 04/Jan/2012  date2 = 00:17:04       可以看到一个序列化对应的实例， 前两个字节分别对应 符号位 和 字符串的长度

          0   4   /    j    a   n    /    2    0  1   2                0   0  :    1   7   :    0   4 

 0 11 48 52 47 74 97 110 47 50 48 49 50      0 8 48 48 58 49 55 58 48 52 

 

在Hadoop中，有以下几种Writable类型，以及它们所占用的字节数。各种数据的传输格式在后面的字节流比较中非常有用。

 

在Hadoop中提供了一个优化的RawComparator接口：

        public interface RawComparator<T> extends Comparator<T> {
                 public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2);

        }

基于字节流的比较方法用于排序阶段。在实现比较的时候需要注意字节流的起始位置(s1,s2)和长度(l1,l2)。

例如上诉实例：我们采用date1进行排序阶段，则可以如下写入：

 

date1  = 04/Jan/2012  date2 = 00:17:04       

          0   4   /    j    a   n    /    2    0  1   2                0   0  :    1   7   :    0   4 

 0 11 48 52 47 74 97 110 47 50 48 49 50      0 8 48 48 58 49 55 58 48 52

 

class key_sort implements RawComparator<......>{
........................................
@Override
public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) { 

return WritableComparator.compareBytes(b1, s1,13, b2, s2, 13);
//如果想用date2进行排序 则可以如下写入：
//return WritableComparator.compareBytes(b1, 13, 10, b2, 13, 10);
}