hadoop序列化与Writable接口

简介

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

通讯格式需求

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

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

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

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

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

存储格式需求

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

1.压缩：占用空间小。

2.快速：可以快速读写。

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

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

Hadoop的序列化格式

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

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

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

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

package org.apache.hadoop.io;

public interface Writable {
    void write(java.io.DataOutput p1) throws java.io.IOException;

    void readFields(java.io.DataInput p1) throws java.io.IOException;
}

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

package com.sweetop.styhadoop;

import junit.framework.Assert;
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.*;

/**
 * Created with IntelliJ IDEA.
 * User: lastsweetop
 * Date: 13-7-4
 * Time: 下午10:25
 * To change this template use File | Settings | File Templates.
 */
public class TestWritable {
    byte[] bytes=null;

    /**
     * 初始化一个IntWritable实例，并且调用系列化方法
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        IntWritable writable = new IntWritable(163);
        bytes = serialize(writable);
    }

    /**
     * 一个IntWritable序列化后的四个字节的字节流
     * 并且使用big-endian的队列排列
     * @throws IOException
     */
    @Test
    public void testSerialize() throws IOException {
        Assert.assertEquals(bytes.length,4);
        Assert.assertEquals(StringUtils.byteToHexString(bytes),"000000a3");
    }

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

    /**
     * 将一个实现了Writable接口的对象序列化成字节流
     * @param writable
     * @return
     * @throws IOException
     */
    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接口的对象
     * @param writable
     * @param bytes
     * @return
     * @throws IOException
     */
    public static byte[] deserialize(Writable writable,byte[] bytes) throws IOException {
        ByteArrayInputStream in=new ByteArrayInputStream(bytes);
        DataInputStream dataIn = new DataInputStream(in);
        writable.readFields(dataIn);
        dataIn.close();
        return bytes;
    }
}

WritableComparable和Comparators

IntWritable实现了WritableComparable接口，WritableComparable接口又实现了Writable和Comparable接口

package org.apache.hadoop.io;

public interface WritableComparable <T>  extends org.apache.hadoop.io.Writable, java.lang.Comparable<T> {
}

MapReduce在排序部分要根据key值的大小进行排序，因此类型的比较相当重要，RawComparator是Comparator的增强版

package org.apache.hadoop.io;

public interface RawComparator <T>  extends java.util.Comparator<T> {
    int compare(byte[] bytes, int i, int i1, byte[] bytes1, int i2, int i3);
}

RawComparator可以做到，不先反序列化就可以直接比较二进制字节流的大小

package com.sweetop.styhadoop;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.RawComparator;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.io.WritableComparator;
import org.eclipse.jdt.internal.core.Assert;
import org.junit.Before;
import org.junit.Test;

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

/**
 * Created with IntelliJ IDEA.
 * User: lastsweetop
 * Date: 13-7-5
 * Time: 上午1:26
 * To change this template use File | Settings | File Templates.
 */
public class TestComparator {
    RawComparator<IntWritable> comparator;
    IntWritable w1;
    IntWritable w2;

    /**
     * 获得IntWritable的comparator,并初始化两个IntWritable
     */
    @Before
    public void init() {
        comparator = WritableComparator.get(IntWritable.class);
        w1 = new IntWritable(163);
        w2 = new IntWritable(76);
    }

    /**
     * 比较两个对象大小
     */
    @Test
    public void testComparator() {
        Assert.isTrue(comparator.compare(w1, w2) > 0);
    }

    /**
     * 序列化后进行直接比较二进制字节流的大小
     * @throws IOException
     */
    @Test
    public void testcompare() throws IOException {
        byte[] b1 = serialize(w1);
        byte[] b2 = serialize(w2);
        Assert.isTrue(comparator.compare(b1, 0, b1.length, b2, 0, b2.length) > 0);
    }

    /**
     * 将一个实现了Writable接口的对象序列化成字节流
     *
     * @param writable
     * @return
     * @throws java.io.IOException
     */
    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();
    }
}

为什么不适用java序列化

1.java序列化不够灵活，为了更好的控制序列化的整个流程所以使用Writable。

2.java序列化不符合序列化的标准，没有做一定的压缩，java序列化首先写类名，然后再是整个类的数据，而且成员对象在序列化中只存引用，成员对象的出现位置很随机，既可以在序列化对象前面，也可以在其后面，这样就对随机访问造成影响，一旦出错，整个后面的序列化就会全部出错，但是Writable完美的弥补了这一点，因为Writable中的每一条记录间是相互独立的。

3.java序列化每次序列化都要重新创建对象，内存消耗大，而Writable是可以重用的。

文章来自： http://blog.csdn.net/lastsweetop/article/details/9193907

源码来自：https://github.com/lastsweetop/styhadoop