序列化

一、序列化的用途

序列化的主要用途有两个，一个是对象持久化，另一个是跨网络的数据交换、远程过程调用。

二、各种序列化机制比较

（跨语言、序列化大小、性能）
1、(000)Java标准的序列化机制有很多优点，使用简单，可自动处理对象引用和循环引用，也可以方便的进行定制，处理版本问题等，但它也有一些重要的局限性：
　　Java序列化格式是一种私有格式，是一种Java语言特有的技术，不能被其他语言识别，不能实现跨语言的数据交换。
　　Java在序列化字节中保存了很多描述信息，使得序列化格式比较大。
　　Java的默认序列化使用反射分析遍历对象结构，性能比较低。
　　Java的序列化格式是二进制的，不方便查看和修改。
2、(100)由于这些局限性，实践中往往会使用一些替代方案。在跨语言的数据交换格式中，XML/JSON是被广泛采用的文本格式，各种语言都有对它们的支持，文件格式清晰易读，有很多查看和编辑工具，它们的不足之处是性能和序列化大小。
3、(111)在性能和大小敏感的领域，往往会采用更为精简高效的二进制方式如ProtoBuf, Thrift, MessagePack等

三、Java序列化

Java中有两个接口用于序列化：java.io.Serializable（默认序列化）、java.io.Externalizable（自定义序列化）

（一）默认序列化

1、实现java.io.Serializable即可被序列化，Serializable没有定义任何方法，只是一个标记接口。
默认序列化能hold住多个对象引用同一对象、对象间循环引用等情况，重复序列化同一个对象时只在第一次把对象转换成字节序列，以后只输出前面的序列化编号
静态属性不会被序列化，因为本身就在类中；方法也不会被序列化

2、默认的序列化机制已经很强大了，它可以自动将对象中的所有字段自动保存和恢复，但这种默认行为有时候不是我们想要的。
对于有些字段，它的值可能与内存位置有关，比如默认的hashCode()方法的返回值，当恢复对象后，内存位置肯定变了，基于原内存位置的值也就没有了意义。还有一些字段，可能与当前时间有关，比如表示对象创建时的时间，保存和恢复这个字段就是不正确的。

如果类中的字段表示的是类的实现细节，而非逻辑信息，那默认序列化也是不适合的。因为序列化格式表示一种契约，应该描述类的逻辑结构，而非与实现细节相绑定，绑定实现细节将使得难以修改，破坏封装。如LinkedList，它的默认序列化就是不适合的，因为LinkedList表示一个List，它的逻辑信息是列表的长度，以及列表中的每个对象，但LinkedList类中的字段表示的是链表的实现细节， 如头尾节点指针，对每个节点，还有前驱和后继节点指针等。

（二）定制序列化

1、对于java.io.Serializable，可以通过transient、writeObject/writeObject、readResolve/writeReplace实现定制序列化

1. 可以用 transient 修饰不想被Java自动序列化的属性，再用Java默认的序列化。（transient可且只可用于修饰不想被Java自动序列化的属性）
2. 或者通过实现方法 void writeObject(java.io.ObjectOutputStream out)、void readObject(java.io.ObjectInputStream in) 来实现自定义的序列化逻辑
3.  实现 Object writeReplace() 替换。如果定义了该方法，在序列化时，会先调用该方法，该方法的返回值才会被当做真正的对象进行序列化；实现 Object readResolve() 还原（自实现的枚举类、 单例中）。如果定义了该方法，在反序列化之后，会额外调用该方法，该方法的返回值才会被当做真正的反序列化的结果。这个方法通常用于反序列化单例对象的场景。（即序列化时的执行顺序是: writeReplace、writeObject、readObject、readResolve)

2、实现java.io.Externalizable接口，并实现两个方法:  void readExternal(ObjectInput in)、void writeExternal(ObjectOutput out) 。

• Externalizable继承于Serializable，当使用该接口时，之前基于Serializable接口的序列化机制就将失效，序列化的细节需要由程序员去完成。基于此，可以减少序列化后文件的大小。
• 实现Externalizable接口的类必须要提供一个无参的构造器，且它的访问权限为public。因为使用Externalizable进行序列化，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。
• 默认的序列化机制由于需要分析对象结构，往往比较慢，通过实现Externalizable接口，可以提高性能。

示例：如下代码中，实现Serializable比实现Externalizable时的序列化文件大，且前者中有out.defaultWriteObject();/in.defaultReadObject();比没有时序列化后文件大。但它们功能都一样。

//public class Fuck implements Serializable {
public class Fuck implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = -3466537175580251255L;
    public byte age;
    public String name;

    public Fuck() {

    }

    public Fuck(byte age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "[" + age + "," + name + "]";
    }

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        String fileName = "tmp0.out";
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(fileName));
        objectOutputStream.writeObject(new Fuck((byte) 1, "小华"));
        objectOutputStream.flush();
        objectOutputStream.close();

        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(fileName));
        Fuck fuck = (Fuck) objectInputStream.readObject();
        System.out.println(fuck);
        objectInputStream.close();
    }

    private void writeObject(java.io.ObjectOutputStream out) {
        try {
            // out.defaultWriteObject();
            out.writeByte(age);
            out.writeObject(name);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void readObject(java.io.ObjectInputStream in) {
        try {
            // in.defaultReadObject();
            this.age = in.readByte();
            this.name = (String) in.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeByte(age);
        out.writeObject(name);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.age = in.readByte();
        this.name = (String) in.readObject();
    }
}

（三）示例

public class _10_IO_SerialTest {

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        // TODO Auto-generated method stub
        // BasicTest
        // BasicTest();

        // customSerialTest
        // customSerialTestOne();
        // customSerialTestTwo();
        // customSerialTestThree();
        customSerialTestFour();
    }

    // 基本测试
    private static void BasicTest() throws FileNotFoundException, IOException, ClassNotFoundException {
        // 系统默认序列化,默认writeObject、readObject
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        ArrayList<Person> lst = new ArrayList<Person>();
        {
            lst.add(new Person("小张", 22));
            lst.add(new Person("小李", 23));
            // 以下两次输出同一个对象lst
            oos.writeObject(lst);
            lst.get(0).setAge(11);
            lst.remove(1);
            oos.writeObject(lst);

            oos.writeObject(new Person("小王", 24));
        }

        // 反序列化
        {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
            lst = (ArrayList<Person>) ois.readObject();
            System.out.println(lst.size());// 2
            lst = (ArrayList<Person>) ois.readObject();
            System.out.println(lst.size());// 2
            System.out.println(lst.get(0).getAge());// 22
            // 从上面两次输出反应的都是lst改变前的状态，说明重复序列化同一个对象时只在第一次把对象转换成字节序列。

            Person p = (Person) ois.readObject();
            System.out.printf("%s %s %s %s\n", p.getAge(), p.getName(), p.getHome(), p.getNumber());// transient修饰的home字段为null说明没有被序列化
        }
    }

    // 自定义序列化测试1
    private static void customSerialTestOne() throws FileNotFoundException, IOException, ClassNotFoundException {
        // -----自定义序列化：写入、读出
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        // 写
        PersonTypeOne ptt = new PersonTypeOne("小虎", 11);
        oos.writeObject(ptt);
        // 读
        ptt = (PersonTypeOne) ois.readObject();
        System.out.println(ptt.getAge() + " " + ptt.getName());
    }

    // 自定义序列化测试2
    private static void customSerialTestTwo() throws FileNotFoundException, IOException, ClassNotFoundException {
        // -----自定义序列化：对象替换writeReplace
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));

        // 写，调用PersonTypeTwo的writeReplace方法，对象替换为String
        PersonTypeTwo ptt = new PersonTypeTwo("小虎", 11);
        oos.writeObject(ptt);

        // 读，已是ArrayList类型
        ArrayList<Object> pttList = (ArrayList<Object>) ois.readObject();
        System.out.println(pttList.get(0) + " " + pttList.get(1));
    }

    // 自定义序列化测试3
    @SuppressWarnings("unused")
    private static void customSerialTestThree() throws FileNotFoundException, IOException, ClassNotFoundException {
        // -----自定义序列化：自定义enum的问题的解决readResolve
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));

        // 没有readResolve
        oos.writeObject(Season_0.SPRING);
        System.out.println(((Season_0) ois.readObject()) == Season_0.SPRING);// false，可见反序列化后得到的并不是我们希望的枚举常量SPRING
        // 有readResolve
        oos.writeObject(Season_1.SPRING);
        System.out.println(((Season_1) ois.readObject()) == Season_1.SPRING);// true，通过readResolve解决上述问题
    }

    // 自定义序列化测试4
    private static void customSerialTestFour() throws FileNotFoundException, IOException, ClassNotFoundException {
        // 通过实现Externalizable接口实现的序列化，必须实现两个抽象方法，其他的用法与Serializable一样。
        // 使用很少，一般通过实现Serializable接口实现序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        // 写
        PersonTypeThree ptt = new PersonTypeThree("xiaozhou", 30);
        oos.writeObject(ptt);

        // 读
        ptt = (PersonTypeThree) ois.readObject();
        System.out.println(ptt.getAge() + " " + ptt.getName());
    }
}

class Person implements java.io.Serializable {

    /**
     * 默认序列化，一个个字段输出，读入时再按同样顺序一个个读入
     */
    private static final long serialVersionUID = -2032185216332524429L;
    private String name;
    private int age;
    transient private String home = "北京";
    private static int number = 3;// 静态属性不会被序列化，因为本身就在类中

    public Person(String name, int age) {
        this.age = age;
        this.name = name;
    }

    public String getHome() {
        return home;
    }

    public void setHome(String home) {
        this.home = home;
    }

    public String toString() {
        return name + " " + age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static int getNumber() {
        return number;
    }

    public static void setNumber(int number) {
        Person.number = number;
    }
}

class PersonTypeOne implements java.io.Serializable {
    /**
     * 自定义序列化，可以自己确定什么顺序输出哪些东西，反序列化时再同序读入，否则出错<br/>
     * private void writeObject(java.io.ObjectOutputStream out)<br>
     * private void readObject(java.io.ObjectInputStream in)<br>
     * private void readObjectNoData()<br>
     */
    private static final long serialVersionUID = 5990380364728171582L;
    private String name;
    private int age;

    private void writeObject(java.io.ObjectOutputStream out) throws IOException {
        out.writeInt(age);
        out.writeObject(new StringBuffer(name).reverse());// 反转name
    }

    private void readObject(java.io.ObjectInputStream in) throws ClassNotFoundException, IOException {
        // 所读取的内容的顺序须与写的一样，否则出错
        this.age = in.readInt();
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
    }

    public PersonTypeOne(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

class PersonTypeTwo implements java.io.Serializable {
    /**
     * 自定义序列化，写入时对象替换。系统在序列化某个对象前会自动先后调用writeReplace、writeObject方法<br>
     * ANY-ACCESS-MODIFIER Object writeReplace()
     */
    private static final long serialVersionUID = -7958822199382954305L;
    private String name;
    private int age;

    // private void writeReplace() {
    // // java序列化机制在序列化对象前总先调用该对象的writeReplace方法，若方法返回另一java对象则转为序列化该对象否则序列化原对象
    // }

    private Object writeReplace() {
        // java序列化机制在序列化对象前总先调用该对象的writeReplace方法，若方法返回另一java对象则转为序列化该对象否则序列化原对象
        ArrayList<Object> al = new ArrayList<Object>();
        al.add(age);
        al.add(name);
        return al;
    }

    public PersonTypeTwo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class Season_0 implements java.io.Serializable {
    // readResolve() test
    private int id;

    private Season_0(int id) {
        this.id = id;
    }

    public static final Season_0 SPRING = new Season_0(1);
    public static final Season_0 SUMMER = new Season_0(2);
    public static final Season_0 FALL = new Season_0(3);
    public static final Season_0 WINTER = new Season_0(4);
}

class Season_1 implements java.io.Serializable {
    // readResolve() test
    /**
     * 与上面的Season_0相比，多了readResolve方法。<br>
     * 反序列化机制会在调用readObject后调用readResolve方法， 与writeReplace相对应<br>
     * ANY-ACCESS-MODIFIER Object readResolve()
     */
    private int id;

    private Season_1(int id) {
        this.id = id;
    }

    public static final Season_1 SPRING = new Season_1(1);
    public static final Season_1 SUMMER = new Season_1(2);
    public static final Season_1 FALL = new Season_1(3);
    public static final Season_1 WINTER = new Season_1(4);

    private Object readResolve() {
        // 系统会在调用readObject后调用此方法
        switch (id) {
        case 1:
            return SPRING;
        case 2:
            return SUMMER;
        case 3:
            return FALL;
        case 4:
            return WINTER;
        default:
            return null;
        }
    }
}

class PersonTypeThree implements java.io.Externalizable {
    private String name;
    private int age;

    public PersonTypeThree() {
        // 继承Externalizable实现的序列化必须要有此构造方法
    }

    public PersonTypeThree(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 通过实现Externalizable接口实现的序列化必须实现如下两个方法，其他的用法与Serializable一样。
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // TODO Auto-generated method stub
        out.writeObject(new StringBuffer(name).reverse());
        out.writeInt(age);
        System.out.println("writeExternal run");
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // TODO Auto-generated method stub
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        this.age = in.readInt();
        System.out.println("readExternal run");
    };

其他：

子类序列化时：

如果父类实现了Serializable接口，则父类和子类都可以序列化。

如果父类没有实现Serializable接口：若也没有提供默认构造函数，那么子类的序列化会出错；若提供了默认的构造函数，那么子类可以序列化，父类的成员变量不会被序列化。

    

 四、参考资料

1、http://mp.weixin.qq.com/s/y3b3prB54Mj1JN2CEURyrg-码农翻身

2、《疯狂Java讲义》