java 序列化

java序列化简单来讲就是将java对象转换为二进制文件的过程；反序列化的过程就是从二进制文件中生成原java对象拷贝的过程。代码实现的基本过程为，通过ObjectOutputStream调用writeObject方法将类的对象序列化为二进制文件；反序列化就是从二进制文件通过ObjectInputStream调用readObject方法生成一个新的对象的过程。
上面简单的描述了java序列化和反序列化的基本过程，接下来看看java序列化有哪些需要注意的地方：
1）java类必须实现serializable接口才能进行序列化，否则抛出如下异常。

Exception in thread "main" java.io.NotSerializableException: com.basic.object.TestObject
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1180)
    at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:346)
    at com.basic.object.TestSerialize.main(TestSerialize.java:16)

2）java类有引用类型的变量，那这个变量的类也必须实现serializable接口，否则序列化时也会抛出NotSerializableException异常，还有一种变通的方式就是跳过该字段的序列化，见第三点。
3）transient修饰的变量不会被序列化。
4）父类没有实现serializable接口时，子类序列化时，从父类继承的属性不会被序列化。
5）java类中的静态变量不会被序列化，这个实际上比较好理解，序列化是针对对象实例的，静态变量是类相关的，所有对象共享的，所以在序列化的过程中不会被序列化。
6）反序列化是需要验证serializableId，当发现两者不一致时无法正确的序列化，建议针对需要序列化的类都生成默认的Id。
7）同一个类的不同对象序列化到同一个文件中，保存的时候只会保存第一个序列化的对象，其他的对象序列化时jvm只保存了第一个对象的引用地址。
8）序列化类中定义readObject，writeObject方法自定义序列化的过程，当类中有这个两个方法的定义，则在序列化和反序列化过程中会被调用。

public class TestSerialize {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("e:\\result.obj"));
        TestObject testObj1 = new TestObject(new Small(2), "test1");
        out.writeObject(testObj1);
        out.close();

        ObjectInputStream in = new ObjectInputStream(new FileInputStream("e:\\result.obj"));
        TestObject obj1 = (TestObject)in.readObject();
        in.close();
        System.out.println(obj1.getName());
        System.out.println(obj1.attr1 + " " + obj1.attr2);
        System.out.println(obj1.s.age);
    }
}

class SuperObject {
    protected String attr1;
    protected String attr2;

    public SuperObject() {

    }

    public SuperObject(String a, String b) {
        this.attr1 = a;
        this.attr2 = b;
    }
}

class TestObject extends SuperObject implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private String name;

    public static String call = "call";

    Small s;

    public TestObject(Small s, String name) {
        super(name+"1", name+"2");
        this.s = s;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    private void readObject(ObjectInputStream in) throws ClassNotFoundException, IOException {
        in.defaultReadObject();
        name = (String)in.readObject();
        if (name.equals("lpntest")) {
            name = "test111";
        }
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        name = "lpntest";
        out.writeObject(name);
    }
}

class Small implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    int age = 0;

    public Small(int a) {
        this.age = a;
    }
}

输出结果如下：
test111
null null
2
从上面的代码，我们演示了利用readObject和writeObject自定义了序列化的形式。