Hadoop序列化【源码】

//原始compare()是将要比较的二进制流，先反序列化为对象，再调用对象的比较方法进行比较。
  public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
    try {
 //利用Buffer为桥接中介，把字节数组存储为buffer后
      buffer.reset(b1, s1, l1);
                   
 //调用key1（WritableComparable类型）的反序列化方法
      key1.readFields(buffer);
      
      buffer.reset(b2, s2, l2);                   
      key2.readFields(buffer);      
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
//调用Writable对象的compare()比较方法进行比较   
    return compare(key1, key2);              
  }

public static void define(Class c, WritableComparator comparator) {
    comparators.put(c, comparator);
   }

package cn.itcast.hadoop.mr;

import java.io.*;
import org.apache.hadoop.io.*;
import org.apache.hadoop.util.StringUtils;

//测试十进制序列化成不同Writable类型所占用的字节数组长度
public class WritableBytesLengthDemo {

    public static void main(String[] args) throws IOException {

        //将十亿用不同Writable类型表示出来
        IntWritable int_b = new IntWritable(1000000000);
        LongWritable long_b = new LongWritable(1000000000);
        VIntWritable vint_b = new VIntWritable(1000000000);
        VLongWritable vlong_b = new VLongWritable(1000000000);

        //将不同的Writable类型序列化成字节数组
        byte[] bs_int_b = serialize(int_b);
        byte[] bs_long_b = serialize(long_b);
        byte[] bs_vint_b = serialize(vint_b);
        byte[] bs_vlong_b = serialize(vlong_b);

        //以十六进制形式打印字节数组，并打印出数组的长度
        String hex = StringUtils.byteToHexString(bs_int_b);
        formatPrint("IntWritable", "1,000,000,000",hex, bs_int_b.length);

        hex = StringUtils.byteToHexString(bs_long_b);
        formatPrint("LongWritable", "1,000,000,000",hex, bs_long_b.length);

        hex = StringUtils.byteToHexString(bs_vint_b);
        formatPrint("VIntWritable", "1,000,000,000",hex, bs_vint_b.length);

        hex = StringUtils.byteToHexString(bs_vlong_b);
        formatPrint("VLongWritable", "1,000,000,000", hex, bs_vlong_b.length);        
    }
    //定义输出格式
    private static void formatPrint(String type, String param, String hex, int length) {

        String format = "%1$-50s %2$-16s with length: %3$2d%n";
        System.out.format(format, "Byte array per " + type
                + "("+ param +") is:", hex, length);
    }
    //将一个实现了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();
    }
    //反序列化
    public static Writable deserialize(Writable writable, byte[] bytes)    throws IOException {
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        DataInputStream dataIn = new DataInputStream(in);
        writable.readFields(dataIn);
        dataIn.close();

        return writable;
    }
}

/** A WritableComparator optimized for Text keys. */
  public static class Comparator extends WritableComparator {
    public Comparator() {
      super(Text.class);
    }
    @Override
    //b1代表字节数组；s1代表一个text类型的起始字节；l1代表一个text类型的字节长度
    public int compare(byte[] b1, int s1, int l1,
                       byte[] b2, int s2, int l2) {
 //返回Text的字符长度
      int n1 = WritableUtils.decodeVIntSize(b1[s1]);
      int n2 = WritableUtils.decodeVIntSize(b2[s2]);

 //比较器跳过 代表Text字符长度 的字节，直接比对UTF编码的真正的字符串部分的字节
 //compareBytes()方法是对字节进行逐个比较。一旦找到一个不同的，然后就返回结果，后面的不管
      return compareBytes(b1, s1+n1, l1-n1, b2, s2+n2, l2-n2);
    }
  }