java 序列化内容分析

网络通信，数据持久化的时候经常会涉及到对象序列化问题，如果对序列化的内容大小或者序列化的效率比较敏感，可以选择protobuf，hession等，如果不是特别在意这块，选择java默认的实现就可以了。java中通过调用ObjectOutputStream对象的writeObject()方法实现对象的序列化。来看段源码:

            // remaining cases
            if (obj instanceof String) {
                writeString((String) obj, unshared);
            } else if (cl.isArray()) {
                writeArray(obj, desc, unshared);
            } else if (obj instanceof Enum) {
                writeEnum((Enum) obj, desc, unshared);
            } else if (obj instanceof Serializable) {
                writeOrdinaryObject(obj, desc, unshared);
            } else {
                if (extendedDebugInfo) {
                    throw new NotSerializableException(
                        cl.getName() + "\n" + debugInfoStack.toString());
                } else {
                    throw new NotSerializableException(cl.getName());
                }
            }

ObjectOutputStream在写入对象的时候对四种不同的类型做了不同的处理，除了字符串，数组类型，枚举类型之外，其他的对象想要序列化必须实现Serializable这个标识接口。看到这里感觉好像基本数据类型(int,long之类)就不能写入，其实不是的。ObjectOutputStream在写入基本数据类型的时候会把它们转化成对象类写入，int的对象类就是Integer，而

Integer类的父类Number就是实现Serializable这个接口的。

经常看到网上说java中实现一个对象的序列化可以实现Serializable接口或者Externalizable接口，本质上Externalizable就是Serializable接口的一个子接口，但是实现Externalizable接口的类可以自定义写入需要通信或者持久化的字段信息。来看个例子:

public class ObjectTest {

	public static void main(String[] args) throws Exception {
		new ObjectTest().serialization();
	}
	
	public void serialization() throws Exception{
		URL url=ObjectTest.class.getResource("/config.properties");
		OutputStream output=new FileOutputStream(new File(url.getPath()));
		ObjectOutput objectOut=new ObjectOutputStream(output);
		objectOut.writeObject(new Object1());
		objectOut.close();
		output.close();
		
		URL url2=ObjectTest.class.getResource("/config2.properties");
		OutputStream output2=new FileOutputStream(new File(url2.getPath()));
		ObjectOutput objectOut2=new ObjectOutputStream(output2);
		objectOut2.writeObject(new Object2());
		objectOut2.close();
		objectOut2.close();
	}
}

package net.flyingfat.serialization;

import java.io.Serializable;

public class Object1 implements Serializable {
	private static final long serialVersionUID = 1L;
	private String bac="abc";
	private int a=123;
	
	public String getBac() {
		return bac;
	}

	public void setBac(String bac) {
		this.bac = bac;
	}

	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}
	
}

package net.flyingfat.serialization;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Object2  implements Externalizable {
	private static final long serialVersionUID = 1L;
	private String bac="123";
	private int a;

	public String getBac() {
		return bac;
	}

	public void setBac(String bac) {
		this.bac = bac;
	}

	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		out.write(bac.getBytes("utf-8"));
	}

	@Override
	public void readExternal(ObjectInput in) throws IOException,
			ClassNotFoundException {
		in.readObject();
	}

	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}
	
}

通过UE打开两个文件进行对比:

config.properties内容如下:

config2.properties内容如下:

2

截图内容太密，没法仔细标出每个字节是干嘛的，有兴趣的直接看源码吧，简单说明下:

1.两者开头都一样，写入类的定义(net.flyingfat.serialization.Object1/Object2)，紧接着的8个字节就是 serialVersionUID(序列化id，它的作用应该都清楚)

2.后面具体对象的信息就一样了，实现Serializable接口的对象写入的是每个字段的类型，名字，和值，而实现Externalizable接口的对象写入的就是我们自定义的内容。

在来看另一个现象

public class Object1 extends Super  {
	private static final long serialVersionUID = 1L;
	private String bac="abc";
	private int a=123;
	
	public String getBac() {
		return bac;
	}

	public void setBac(String bac) {
		this.bac = bac;
	}

	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}
	
}

class Super implements Serializable  {
	
	private String s;
	
	public Super(String s) {
		super();
		this.s = s;
	}
	public Super() {}

	public String getS() {
		return s;
	}

	public void setS(String s) {
		this.s = s;
	}
	
}

public class Object2 extends Super implements Serializable {
	private static final long serialVersionUID = 1L;
	private String bac="abc";
	private int a=123;
	
	public String getBac() {
		return bac;
	}

	public void setBac(String bac) {
		this.bac = bac;
	}

	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}
	
}

class Super  {
	
	private String s;
	
	public Super(String s) {
		super();
		this.s = s;
	}
	public Super() {}

	public String getS() {
		return s;
	}

	public void setS(String s) {
		this.s = s;
	}
	
}

同时序列化这两个对象，可以看到内容不一样。

结论就是: 对象在序列化的时候，看该对象是直接还是间接实现Serializable接口，直接实现就只序列化当前对象本身的字段信息，如果是间接就会挨个往上找到父类，一并把父类的字段信息也序列化了。