1. 为什么要序列化

java序列化的目的就是把一个对象转换成流，并通过网络发送，或将其存入文件或者数据库以便未来使用。反序列则是把流转化成实际程序中使用的java。

Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte，这样日后要用这个对象时候，你就能把这些byte数据恢复出来，并据此重新构建那个对象了。这一点甚至在跨网络的环境下也是如此，这就意味着序列化机制能自动补偿操作系统方面的差异。也就是说，你可以在Windows机器上创键一个对象，序列化之后，再通过网络传到Unix机器上，然后在那里进行重建。你不用担心在不同的平台上数据是怎样表示的，byte顺序怎样，或者别的什么细节。之所以需要对象序列化，是因为有时候对象需要在网络上传输，传输的时候需要这种序列化处理，从服务器硬盘上把序列化的对象取出，然后通过网络传到客户端，再由客户端把序列化的对象读入内存，执行相应的处理。

2. 序列化实现及原理

在java jdk1.1中就引入了序列化api。如果你希望一个类对象是可序列化的，你所要做的是实现java.io.Serializable接口。序列化一种标记接口，不需要实现任何字段和方法，这就像是一种选择性加入的处理，通过它可以使类对象成为可序列化的对象。

序列化处理是通过ObjectInputStream和ObjectOutputStream实现的，因此我们所要做的是基于它们进行一层封装，要么将其保存为文件，要么将其通过网络发送

public class Foo implements Serializable{
    public static int w = 1;
    public static transient int x = 2;
    public int y = 3;
    public transient int z = 4;
}

package com.fun.lang;

import java.io.*;

/**
 * Created by fun on 2017/2/13.
 */
public class TransDemo {

    public static void main(String[] args) {
        Foo foo = new Foo();
        System.out.printf("w: %d%n", Foo.w);
        System.out.printf("x: %d%n", Foo.x);
        System.out.printf("y: %d%n", foo.y);
        System.out.printf("z: %d%n", foo.z);
        FileOutputStream fos = null;

        try {

            fos = new FileOutputStream("x.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(foo);

        } catch (Exception e) {
            e.printStackTrace();
        }

        Foo fooNew = null;
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("x.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            System.out.println();
            fooNew = (Foo) ois.readObject();
            // 上面代码执行完后，可以看到fooNew的属性中只有y=3,z=0 ,页验证了static 和 transient 不被序列化。
            // 查看源码writeObject上面的注释也写明了
            System.out.printf("w: %d%n", fooNew.w);
            System.out.printf("x: %d%n", fooNew.x);
            System.out.printf("y: %d%n", fooNew.y);
            System.out.printf("z: %d%n", fooNew.z);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

上面的示例是一个使用序列化的例子。从上面的例子可以看出:

如果想避免属性被序列化的话，将属性申明为static 或 transient就可以了。

为什么呢？查看源码ObjectOutputStream和ObjectInputStream就会发现，序列化实现就是依靠这两个类来做的。

查看ObjectOutputStream的 writeObject 方法，上面明显的注释说明，一个类的non-static属性和non-transient属性会被序列化。

序列化的过程 ObjectOutputStream.writeObject-->writeObject0-->writeOrdinaryObject-->writeSerialData-->defaultWriteFields-->writeObject0

可以看出，是一个递归的调用，也就是说被序列化的对象如果有嵌套的实现了序列化接口的用户对象，他也会被序列化。

3. 序列化版本uid

private static final long serialVersionUID = -1L;

serialVersionUID这个在实现序列化的类里面很常见，这个实际上就是一个数据版本号，已经序列化的数据在反序列化的时候，如果对象的版本已经修改了，反序列化就会出现错误。其实就是数据独享版本的控制，相同版本的才能正常反序列化。

把上的示例完善点：

public class Foo implements Serializable{

    private static final long serialVersionUID = -1L;// 注释①

    public static int w = 1;
    public static transient int x = 2;
    public int y = 3;
    public transient int z = 4;


}


package com.fun.lang;

import java.io.*;

/**
 * Created by fun on 2017/2/13.
 */
public class TransDemo {

    public static void main(String[] args) {
        TransDemo test = new TransDemo();
        Foo foo = new Foo();
        System.out.println("-----before serialize:");
        test.printObject(foo);

        test.putSerializedObject(foo); // 注释②
        System.out.println("-----after serialize:");
        test.printObject(test.getSerializedObject());
    }

    public void putSerializedObject(Foo foo) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("x.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(foo);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Foo getSerializedObject() {
        Foo fooNew = null;
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("x.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            System.out.println();
            fooNew = (Foo) ois.readObject();
            return fooNew;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public void printObject(Foo foo) {
        System.out.printf("w: %d%n", foo.w);
        System.out.printf("x: %d%n", foo.x);
        System.out.printf("y: %d%n", foo.y);
        System.out.printf("z: %d%n", foo.z);
    }

}

上面的示例，第一次直接执行，第二字只做反序列化，并且修改了序列化对象的版本号，即操作注释①的uid=-2L ,注释掉 注释②出的代码。只反序列化。这个时候就提提示异常了：

java.io.InvalidClassException: com.fun.lang.Foo; local class incompatible: stream classdesc serialVersionUID = -1, local class serialVersionUID = -2