hadoop io ObjectWritable and SerializableWritable

class SerializableWritable[T <: Writable](@transient var t: T) extends Serializable {

  def value: T = t

  override def toString: String = t.toString

  private def writeObject(out: ObjectOutputStream): Unit = Utils.tryOrIOException {
    out.defaultWriteObject()
    new ObjectWritable(t).write(out)
  }

  private def readObject(in: ObjectInputStream): Unit = Utils.tryOrIOException {
    in.defaultReadObject()
    val ow = new ObjectWritable()
    ow.setConf(new Configuration(false))
    ow.readFields(in)
    t = ow.get().asInstanceOf[T]
  }
}

The usage of ObjectWritable:

 val ow = new ObjectWritable()
    ow.setConf(new Configuration(false))
    ow.readFields(in)

ObjectWritable class defination:

public class ObjectWritable implements Writable, Configurable {
    private Class declaredClass;
    private Object instance;
    private Configuration conf;
    private static final Map<String, Class<?>> PRIMITIVE_NAMES = new HashMap();

constructors

public ObjectWritable() {
    }

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

    public ObjectWritable(Class declaredClass, Object instance) {
        this.declaredClass = declaredClass;
        this.instance = instance;
    }

conf operation

 public void setConf(Configuration conf) {
        this.conf = conf;
    }

    public Configuration getConf() {
        return this.conf;
    }

primitive

static {
        PRIMITIVE_NAMES.put("boolean", Boolean.TYPE);
        PRIMITIVE_NAMES.put("byte", Byte.TYPE);
        PRIMITIVE_NAMES.put("char", Character.TYPE);
        PRIMITIVE_NAMES.put("short", Short.TYPE);
        PRIMITIVE_NAMES.put("int", Integer.TYPE);
        PRIMITIVE_NAMES.put("long", Long.TYPE);
        PRIMITIVE_NAMES.put("float", Float.TYPE);
        PRIMITIVE_NAMES.put("double", Double.TYPE);
        PRIMITIVE_NAMES.put("void", Void.TYPE);
    }

write

public void write(DataOutput out) throws IOException {
        writeObject(out, this.instance, this.declaredClass, this.conf);
    }
    public static void writeObject(DataOutput out, Object instance, Class declaredClass, Configuration conf) throws IOException {
        writeObject(out, instance, declaredClass, conf, false);
    }
    public static void writeObject(DataOutput out, Object instance, Class declaredClass, Configuration conf, boolean allowCompactArrays) throws IOException {
        if(instance == null) {
            instance = new ObjectWritable.NullInstance(declaredClass, conf);
            declaredClass = Writable.class;
        }

        if(allowCompactArrays && declaredClass.isArray() && instance.getClass().getName().equals(declaredClass.getName()) && instance.getClass().getComponentType().isPrimitive()) {
            instance = new Internal(instance);
            declaredClass = Internal.class;
        }

        UTF8.writeString(out, declaredClass.getName());
        if(declaredClass.isArray()) {
            int length = Array.getLength(instance);
            out.writeInt(length);

            for(int i = 0; i < length; ++i) {
                writeObject(out, Array.get(instance, i), declaredClass.getComponentType(), conf, allowCompactArrays);
            }
        } else if(declaredClass == Internal.class) {
            ((Internal)instance).write(out);
        } else if(declaredClass == String.class) {
            UTF8.writeString(out, (String)instance);
        } else if(declaredClass.isPrimitive()) {
            if(declaredClass == Boolean.TYPE) {
                out.writeBoolean(((Boolean)instance).booleanValue());
            } else if(declaredClass == Character.TYPE) {
                out.writeChar(((Character)instance).charValue());
            } else if(declaredClass == Byte.TYPE) {
                out.writeByte(((Byte)instance).byteValue());
            } else if(declaredClass == Short.TYPE) {
                out.writeShort(((Short)instance).shortValue());
            } else if(declaredClass == Integer.TYPE) {
                out.writeInt(((Integer)instance).intValue());
            } else if(declaredClass == Long.TYPE) {
                out.writeLong(((Long)instance).longValue());
            } else if(declaredClass == Float.TYPE) {
                out.writeFloat(((Float)instance).floatValue());
            } else if(declaredClass == Double.TYPE) {
                out.writeDouble(((Double)instance).doubleValue());
            } else if(declaredClass != Void.TYPE) {
                throw new IllegalArgumentException("Not a primitive: " + declaredClass);
            }
        } else if(declaredClass.isEnum()) {
            UTF8.writeString(out, ((Enum)instance).name());
        } else if(Writable.class.isAssignableFrom(declaredClass)) {
            UTF8.writeString(out, instance.getClass().getName());
            ((Writable)instance).write(out);
        } else {
            if(!Message.class.isAssignableFrom(declaredClass)) {
                throw new IOException("Can\'t write: " + instance + " as " + declaredClass);
            }

            ((Message)instance).writeDelimitedTo(DataOutputOutputStream.constructOutputStream(out));
        }

    }

read

public static Object readObject(DataInput in, Configuration conf) throws IOException {
        return readObject(in, (ObjectWritable)null, conf);
    }

    public static Object readObject(DataInput in, ObjectWritable objectWritable, Configuration conf) throws IOException {
        String className = UTF8.readString(in);
        Class declaredClass = (Class)PRIMITIVE_NAMES.get(className);
        if(declaredClass == null) {
            declaredClass = loadClass(conf, className);
        }

        Object instance;
        if(declaredClass.isPrimitive()) {
            if(declaredClass == Boolean.TYPE) {
                instance = Boolean.valueOf(in.readBoolean());
            } else if(declaredClass == Character.TYPE) {
                instance = Character.valueOf(in.readChar());
            } else if(declaredClass == Byte.TYPE) {
                instance = Byte.valueOf(in.readByte());
            } else if(declaredClass == Short.TYPE) {
                instance = Short.valueOf(in.readShort());
            } else if(declaredClass == Integer.TYPE) {
                instance = Integer.valueOf(in.readInt());
            } else if(declaredClass == Long.TYPE) {
                instance = Long.valueOf(in.readLong());
            } else if(declaredClass == Float.TYPE) {
                instance = Float.valueOf(in.readFloat());
            } else if(declaredClass == Double.TYPE) {
                instance = Double.valueOf(in.readDouble());
            } else {
                if(declaredClass != Void.TYPE) {
                    throw new IllegalArgumentException("Not a primitive: " + declaredClass);
                }

                instance = null;
            }
        } else if(declaredClass.isArray()) {
            int instanceClass = in.readInt();
            instance = Array.newInstance(declaredClass.getComponentType(), instanceClass);

            for(int str = 0; str < instanceClass; ++str) {
                Array.set(instance, str, readObject(in, conf));
            }
        } else {
            Internal var9;
            if(declaredClass == Internal.class) {
                var9 = new Internal();
                var9.readFields(in);
                instance = var9.get();
                declaredClass = instance.getClass();
            } else if(declaredClass == String.class) {
                instance = UTF8.readString(in);
            } else if(declaredClass.isEnum()) {
                instance = Enum.valueOf(declaredClass, UTF8.readString(in));
            } else if(Message.class.isAssignableFrom(declaredClass)) {
                instance = tryInstantiateProtobuf(declaredClass, in);
            } else {
                var9 = null;
                String var11 = UTF8.readString(in);
                Class var10 = loadClass(conf, var11);
                Writable writable = WritableFactories.newInstance(var10, conf);
                writable.readFields(in);
                instance = writable;
                if(var10 == ObjectWritable.NullInstance.class) {
                    declaredClass = ((ObjectWritable.NullInstance)writable).declaredClass;
                    instance = null;
                }
            }
        }

        if(objectWritable != null) {
            objectWritable.declaredClass = declaredClass;
            objectWritable.instance = instance;
        }

        return instance;
    }

read from or write to protobuf

private static Message tryInstantiateProtobuf(Class<?> protoClass, DataInput dataIn) throws IOException {
        try {
            if(dataIn instanceof InputStream) {
                Method iae1 = getStaticProtobufMethod(protoClass, "parseDelimitedFrom", new Class[]{InputStream.class});
                return (Message)iae1.invoke((Object)null, new Object[]{(InputStream)dataIn});
            } else {
                int iae = ProtoUtil.readRawVarint32(dataIn);
                if(iae < 0) {
                    throw new IOException("Invalid size: " + iae);
                } else {
                    byte[] data = new byte[iae];
                    dataIn.readFully(data);
                    Method parseMethod = getStaticProtobufMethod(protoClass, "parseFrom", new Class[]{byte[].class});
                    return (Message)parseMethod.invoke((Object)null, new Object[]{data});
                }
            }
        } catch (InvocationTargetException var5) {
            if(var5.getCause() instanceof IOException) {
                throw (IOException)var5.getCause();
            } else {
                throw new IOException(var5.getCause());
            }
        } catch (IllegalAccessException var6) {
            throw new AssertionError("Could not access parse method in " + protoClass);
        }
    }

    static Method getStaticProtobufMethod(Class<?> declaredClass, String method, Class... args) {
        try {
            return declaredClass.getMethod(method, args);
        } catch (Exception var4) {
            throw new AssertionError("Protocol buffer class " + declaredClass + " does not have an accessible parseFrom(InputStream) method!");
        }
    }

NullInstance

private static class NullInstance extends Configured implements Writable {
        private Class<?> declaredClass;

        public NullInstance() {
            super((Configuration)null);
        }

        public NullInstance(Class declaredClass, Configuration conf) {
            super(conf);
            this.declaredClass = declaredClass;
        }

        public void readFields(DataInput in) throws IOException {
            String className = UTF8.readString(in);
            this.declaredClass = (Class)ObjectWritable.PRIMITIVE_NAMES.get(className);
            if(this.declaredClass == null) {
                try {
                    this.declaredClass = this.getConf().getClassByName(className);
                } catch (ClassNotFoundException var4) {
                    throw new RuntimeException(var4.toString());
                }
            }

        }

        public void write(DataOutput out) throws IOException {
            UTF8.writeString(out, this.declaredClass.getName());
        }
    }