hadoop源码研读之路（三）----序列化_hadoop#++#byte b = bytes[i++];-优快云博客

本文介绍了Hadoop中的序列化机制，包括Writable接口的使用方法、序列化和反序列化的实现过程，以及如何通过比较字节流来判断对象大小。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

简单来说，序列化就是将对象（实例）转换为字符流（字符数组）的过程，转换后的字符流可用于网络传输或写入磁盘；相对的，反序列化就是将字符流转换成对象的过程。Hadoop有自己的序列化实现，并已提取为Avro子项目。序列化要求具有字符流紧凑，处理快速，可扩展，多语言支持特性。

Hadoop并没有采用Java的序列化，而是引入了它自己的系统。

Hadoop中定义了两个序列化相关的接口：Writable接口和Comparable接口，这两个接口可以合成一个接口WritableComparable.

Writable接口，所有实现了Writable接口的类都可以被序列化和反序列化

[java]view plaincopy 
   
 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的对象都可以和自身相同类型的对象比较大小。该接口定义为：

[java]view plaincopy 
   
 package java.lang;  
 import java.util.*;  
    
 public interface Comparable<T> {  
   /** 
   * 将this对象和对象o进行比较，约定：返回负数为小于，零为大于，整数为大于 
   */  
   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个实用的静态方法，serialize方法將Writable对象转换成字节流，deserialize方法将字节流转换为对象，printBytesHex方法打印byte[]数组对象。并通过最简单的IntWritable类，将int变量序列化，再反序列化。

[java]view plaincopy 
    
 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。

序列化和反序列化将消耗一定的资源，Hadoop中实现了直接比较字符流以确定两个Writable对象的大小，不需要进行序列化和反序列化。

以IntWritable对象的源码片段为例：

[java]view plaincopy 
    
 /** 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());  
 }  

ObjectWritable相对于其他对象，它有不同的地位。当我们讨论Hadoop的RPC时，我们会提到RPC上交换的信息，必须是Java的基本类型，String和Writable接口的实现类，以及元素为以上类型的数组。ObjectWritable对象保存了一个可以在RPC上传输的对象和对象的类型信息。这样，我们就有了一个万能的，可以用于客户端/服务器间传输的Writable对象。例如，我们要把上面例子中的对象作为RPC请求，需要根据MyWritable创建一个ObjectWritable，ObjectWritable往流里会写如下信息

（对象类名长度，对象类名，对象自己的串行化结果）

这样，到了对端，ObjectWritable可以根据对象类名创建对应的对象，并解串行。应该注意到，ObjectWritable依赖于WritableFactories，那存储了Writable子类对应的工厂。我们需要把MyWritable的工厂，保存在WritableFactories中（通过WritableFactories.setFactory）