hadoop学习笔记(1) 序列化

简介

序列化和反序列化就是结构化对象和字节流之间的转换，主要用在内部进程的通讯和持久化存储方面。 hadoop中定义了两个序列化相关的接口：Writable和Comparable，以下分别介绍：

通讯格式需求

hadoop在节点间的内部通讯使用的是RPC，RPC协议把消息翻译成二进制字节流发送到远程节点，远程节点再通过反序列化把二进制流转成原始的信息。RPC的序列化需要实现以下几点：

1.压缩，可以起到压缩的效果，占用的宽带资源要小。

2.快速，内部进程为分布式系统构建了高速链路，因此在序列化和反序列化间必须是快速的，不能让传输速度成为瓶颈。

3.可扩展的，新的服务端为新的客户端增加了一个参数，老客户端照样可以使用。

4.兼容性好，可以支持多个语言的客户端

存储格式需求

表面上看来序列化框架在持久化存储方面可能需要其他的一些特性，但事实上依然是那四点：

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

2.快速，可以快速读写

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

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

hadoop的序列化格式

hadoop自身的序列化存储格式就是实现了Writable接口的类,他只实现了前面两点，压缩和快速。但是不容易扩展，也不跨语言。

我们先来看下Writable接口，Writable接口定义了两个方法：

1.将数据写入到二进制流中

2.从二进制数据流中读取数据

[java]  view plain  copy

1. package org.apache.hadoop.io;  
2.   
3. public interface Writable {  
4.     void write(java.io.DataOutput p1) throws java.io.IOException;  
5.   
6.     void readFields(java.io.DataInput p1) throws java.io.IOException;  
7. }  

我们再来看下Writable接口与序列化和反序列化是如何关联的：

package hadoop.test;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.util.StringUtils;
import org.junit.Before;
import org.junit.Test;

import java.io.*;

import static org.junit.Assert.assertEquals;



/**
 * Created by WinLee on 2017/4/12.
 */
public class TestWritable {
    byte[] bytes = null;

    /**
     * 初始化一个IntWritable实例，并且调用序列化方法
     * @throws Exception
     */

    @Before
    public void init() throws Exception {
        IntWritable writable = new IntWritable(163);
        bytes =serialize(writable);
    }

    /**
     *一个IntWritable序列号后的四个字节的字节流
     * @throws Exception
     */

    public void testSerialize() {
        assertEquals(bytes.length,4);
        assertEquals(StringUtils.byteToHexString(bytes),"000000a3");
    }

    /**
     *创建一个没有值的IntWritable对象,并且通过调用反序列化方法将bytes的数据读入到它
     * 里面,通过调用它的get方法,获得原始值163
     */
    @Test
    public void testDeserialize() throws IOException {
        IntWritable newWritable = new IntWritable();
        deserialize(newWritable,bytes);
        System.out.println("success");
        assertEquals(newWritable.get(),163);
    }

    /**
     * 将一个实现了Writable接口的对象序列化成字节流
     * @param writable
     * @return
     * @throws IOException
     */
    public static byte[] serialize(Writable writable) throws Exception{
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        writable.write(dataOut);
        dataOut.close();
        return out.toByteArray();
    }

    /**
     * 将字节流转化为实现Writable接口的对象
     * @param writable
     * @param bytes
     *
     */

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