Hadoop ObjectWritable类的实现浅析

针对Java基本类型、字符串、枚举、Writable、空值、Writable的其他子类，ObjectWritable提供了一个封装，适用于字段需要使用多种类型。ObjectWritable可应用于Hadoop远程过程调用（将在第4章介绍）中参数的序列化和反序列化；ObjectWritable的另一个典型应用是在需要序列化不同类型的对象到某一个字段，如在一个SequenceFile的值中保存不同类型的对象（如LongWritable值或Text值）时，可以将该值声明为ObjectWritable。

ObjectWritable的实现比较冗长，需要根据可能被封装在ObjectWritable中的各种对象进行不同的处理。ObjectWritable有三个成员变量，包括被封装的对象实例instance、该对象运行时类的Class对象和Configuration对象。

ObjectWritable的write方法调用的是静态方法ObjectWritable.writeObject()，该方法可以往DataOutput接口中写入各种Java对象。

writeObject()方法先输出对象的类名（通过对象对应的Class 对象的getName()方法获得），然后根据传入对象的类型，分情况系列化对象到输出流中，也就是说，对象通过该方法输出对象的类名，对象序列化结果对到输出流中。在ObjectWritable.writeObject()的逻辑中，需要分别处理null、Java数组、字符串String、Java基本类型、枚举和Writable的子类6种情况，由于类的继承，处理Writable时，序列化的结果包含对象类名，对象实际类名和对象序列化结果三部分。

为什么需要对象实际类名呢？根据Java的单根继承规则，ObjectWritable中传入的declaredClass，可以是传入instance对象对应的类的类对象，也可以是instance对象的父类的类对象。但是，在序列化和反序列化的时候，往往不能使用父类的序列化方法（如write方法）来序列化子类对象，所以，在序列化结果中必须记住对象实际类名。相关代码如下：
public class ObjectWritable implements Writable, Configurable {
   private Class declaredClass;//保存于ObjectWritable的对象对应的类对象
   private Object instance;//被保留的对象
   private Configuration conf;

   public ObjectWritable() {}

   public ObjectWritable(Object instance) {
      set(instance);
   }

   public ObjectWritable(Class declaredClass, Object instance) {
      this.declaredClass = declaredClass;
      this.instance = instance;
   }          
   ……
   public void readFields(DataInput in) throws IOException {
      readObject(in, this, this.conf);
   }

   public void write(DataOutput out) throws IOException {
      writeObject(out, instance, declaredClass, conf);
   }
   ……
   public static void writeObject(DataOutput out, Object instance,
         Class declaredClass,Configuration conf) throws……{

      if (instance == null) {//空
         instance = new NullInstance(declaredClass, conf);
         declaredClass = Writable.class;
      }

      // 写出declaredClass的规范名
      UTF8.writeString(out, declaredClass.getName());

      if (declaredClass.isArray()) {//数组
         ……
      } else if (declaredClass == String.class) {//字符串
         ……
      } else if (declaredClass.isPrimitive()) {//基本类型
         if (declaredClass == Boolean.TYPE) {        //boolean
            out.writeBoolean(((Boolean)instance).booleanValue());
         } else if (declaredClass == Character.TYPE) { //char
            ……
         }
      } else if (declaredClass.isEnum()) {//枚举类型
         ……
      } else if (Writable.class.isAssignableFrom(declaredClass)) {
         //Writable的子类
         UTF8.writeString(out, instance.getClass().getName());
         ((Writable)instance).write(out);
      } else {
         ……
   }

   public static Object readObject(DataInput in,
                  ObjectWritable objectWritable, Configuration conf){
      ……
      Class instanceClass = null;
      ……
      Writable writable = WritableFactories.newInstance(instanceClass,
            conf);
      writable.readFields(in);
      instance = writable;
      ……
   }
}

和输出对应，ObjectWritable的readFields()方法调用的是静态方法ObjectWritable.readObject ()，该方法的实现和writeObject()类似，唯一值得研究的是Writable对象处理部分，readObject ()方法依赖于WritableFactories类。WritableFactories类允许非公有的Writable子类定义一个对象工厂，由该工厂创建Writable对象，如在上面的readObject ()代码中，通过WritableFactories的静态方法newInstance()，可以创建类型为instanceClass的Writable子对象。相关代码如下：
public class WritableFactories {
   //保存了类型和WritableFactory工厂的对应关系
   private static final HashMap<Class, WritableFactory>CLASS_TO_FACTORY
      = new HashMap<Class, WritableFactory>();
   ……
   public static Writable newInstance(Class<? extends Writable> c,
                                      Configuration conf) {
      WritableFactory factory = WritableFactories.getFactory(c);
      if (factory != null) {
         Writable result = factory.newInstance();
         if (result instanceof Configurable) {
            ((Configurable) result).setConf(conf);
         }
         return result;
      } else {
         //采用传统的反射工具ReflectionUtils，创建对象
         return ReflectionUtils.newInstance(c, conf);
      }
   }
}

WritableFactories.newInstance()方法根据输入的类型查找对应的WritableFactory工厂对象，然后调用该对象的newInstance()创建对象，如果该对象是可配置的，newInstance()还会通过对象的setConf()方法配置对象。

WritableFactories提供注册机制，使得这些Writable子类可以将该工厂登记到WritableFactories的静态成员变量CLASS_TO_FACTORY中。下面是一个典型的WritableFactory工厂实现，来自于HDFS的数据块Block。其中，WritableFactories.setFactory()需要两个参数，分别是注册类对应的类对象和能够构造注册类的WritableFactory接口的实现，在下面的代码里，WritableFactory的实现是一个匿名类，其newInstance()方法会创建一个新的Block对象。
public class Block implements Writable, Comparable<Block> {
   static {
      WritableFactories.setFactory
         (Block.class,//类对象
         new WritableFactory() {//对应类的WritableFactory实现
            public Writable newInstance() { return new Block(); }
         });
   }          
   ……
}

ObjectWritable作为一种通用机制，相当浪费资源，它需要为每一个输出写入封装类型的名字。如果类型的数量不是很多，而且可以事先知道，则可以使用一个静态类型数组来提高效率，并使用数组索引作为类型的序列化引用。GenericWritable就是因为这个目的被引入org.apache.hadoop.io包中，由于篇幅关系，不再详细介绍，有兴趣的读者可以继续分析GenericWritable的源代码。