IO流之对象序列化（Serializable接口和Externalizable接口）

Java对象序列化

所有分布式应用常常需要跨平台，跨网络，因此要求所有传的签署，返回值都必须实现序列化。

定义：对象的序列化是指将一个Java对象写入IO流中，反序列化是指从IO流中恢复改Java对象。

实现：
实现如下两个接口之一的类才能被序列化：
（1）Serializable
（2）Externalizable
—序列化：ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写道一个目标输出流中。
—反序列化：ObjectInputStream代表对象输入流，它的readObject()方法从一个源输出流中读取字节序列，再把他们反序列化为一个对象，并将其返回。

使用writeObject()和readObject()方法的对象必须已经被序列化。

---

一般序列化

示例：
要被序列化的对象：

public class Person implements Serializable {  

    private String name = null;  

    private Integer age = null;   

    public Person(){
        System.out.println("无参构造");
    }
    public Person(String name, Integer age) {  
        this.name = name;  
        this.age = age;  
    }  
    //getter setter方法省略...
    @Override 
    public String toString() {  
        return "[" + name + ", " + age+"]";  
    }  
} 

如果有另一个类持有一个Person类的引用，只有Person类是可序列化的，这个类才是可序列化的

MySerilizable 是一个简单的序列化程序，它先将一个Person对象保存到文件person.txt中，然后再从该文件中读出被存储的Person对象，并打印该对象。

ublic class MySerilizable {

    public static void main(String[] args) throws Exception {  
        File file = new File("person.txt");  

        //序列化持久化对象
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));  
        Person person = new Person("Peter", 27);  
        out.writeObject(person);  
        out.close();  

        //反序列化，并得到对象
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));  
        Object newPerson = in.readObject(); // 没有强制转换到Person类型，也可以强制转换到Person,这里主要是因为Person类里改写了toString方法才没有强制转换类型  
        in.close();  
        System.out.println(newPerson);  
    }  
}

---

选择序列化

transient

当某个对象进行序列化时，系统会自动把该对象的所有实例变量依次进行序列化，如果某个实例变量引用到另一个对象，则被引用的对象也会被序列化；如果被引用的对象的实例变量也引用了其他对象，则被引用的对象也会被序列化，这种情况被称为递归序列化。

为了避免这些情况，特别是某些实例变量是敏感信息时，例如银行账户信息等。这时不希望系统将该实例变量进行序列化，该怎么办呢？
通过在实例变量面前使用transient关键字修饰，就可以指定Java序列化时无需理会该实例变量。

public class Person
    implements java.io.Serializable
{
    private String name;
    private transient int age;
    // 注意此处没有提供无参数的构造器!
    public Person(String name , int age)
    {
        System.out.println("有参数的构造器");
        this.name = name;
        this.age = age;
    }
    // 省略name与age的setter和getter方法

    // name的setter和getter方法
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return this.name;
    }

    // age的setter和getter方法
    public void setAge(int age)
    {
        this.age = age;
    }
    public int getAge()
    {
        return this.age;
    }
}

对Person的age变量加了transient修饰符，便不会被序列化，因此下面程序中输出值为0

public class TransientTest
{
    public static void main(String[] args)
    {
        try(
            // 创建一个ObjectOutputStream输出流
            ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("transient.txt"));
            // 创建一个ObjectInputStream输入流
            ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("transient.txt")))
        {
            Person per = new Person("孙悟空", 500);
            // 系统会per对象转换字节序列并输出
            oos.writeObject(per);
            Person p = (Person)ois.readObject();
            System.out.println(p.getAge());
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

writeObject()与readObject()方法

使用transient组织序列化虽然简单，但被她修饰的属性被完全隔离在序列化机制之外，导致了在反序列化时无法获得该属性的值，而通过在需要的序列化对象的Java类加入writeObject()与readObject()的方法可以控制如何序列化各属性，甚至不完全序列化某些属性。

例如：如果我们想要上面的Person类里的name属性在序列化后存在文件里不让别人知道具体是什么（加密），我们就可在Person类里加如下代码：

public class Person
    implements java.io.Serializable
{
    private String name;
    private int age;
    // 注意此处没有提供无参数的构造器!
    public Person(String name , int age)
    {
        System.out.println("有参数的构造器");
        this.name = name;
        this.age = age;
    }
    // 省略name与age的setter和getter方法

    // name的setter和getter方法
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return this.name;
    }

    // age的setter和getter方法
    public void setAge(int age)
    {
        this.age = age;
    }
    public int getAge()
    {
        return this.age;
    }

    private void writeObject(java.io.ObjectOutputStream out)
        throws IOException
    {
        // 将name实例变量的值反转后写入二进制流
        out.writeObject(new StringBuffer(name).reverse());
        out.writeInt(age);
    }
    private void readObject(java.io.ObjectInputStream in)
        throws IOException, ClassNotFoundException
    {
        // 将读取的字符串反转后赋给name实例变量
        this.name = ((StringBuffer)in.readObject()).reverse()
            .toString();
        this.age = in.readInt();
    }
}

---

Externalizable接口

Java还提供了另一种序列化机制，这种序列化方式完全由程序员决定存储和恢复对象的数据。要实现改目标，Java类必须实现Externalizable接口，该接口里定义了如下两个方法。

void readExternal(ObjectInput in):需要序列化的类实现readExternal()方法来实现反序列化。
void writeExternal(ObjectOutput out):需要序列化的类实现writeExternal()方法来保存对象的状态值。

下面程序中的Person实现了java.io.Externalizable接口，该Person类还实现了readExternal(),writeExternal()两个方法，这两个方法除了方法签名和readObject(),writeObject()两个方法的方法签名有所不同之外，其方法体完全一样。

需要注意的是实现Externalizable接口的类必须实现无参构造方法，否则反序列化会失败。

public class Teacher implements Externalizable{

    private String name;
    private Integer age;

    public Teacher(){
        System.out.println("无参构造");
    }

    public Teacher(String name,Integer age){
        System.out.println("有参构造");
        this.name = name;
        this.age = age;
    }

    //setter、getter方法省略

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(new StringBuffer(name).reverse()); //将name简单加密
        //out.writeInt(age);  //注掉这句后，age属性将不能被序化
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        name = ((StringBuffer) in.readObject()).reverse().toString();
        //age = in.readInt();  
    }

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

}

public class MySerilizable {

    public static void main(String[] args) throws Exception {  
        File file = new File("person.txt");  

        //序列化持久化对象
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));  
        Teacher person = new Teacher("Peter", 27);  
        out.writeObject(person);  
        out.close();  

        //反序列化，并得到对象
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));  
        Object newPerson = in.readObject(); // 没有强制转换到Person类型  
        in.close();  
        System.out.println(newPerson);  

    }  
}

---

Serializable和Externalizable 的比较

— 实现Serializable接口的需要序列化的类可以没有无参构造器，但实现Externalizable接口的需要序列化的类必须有无参构造器，否在在反序列化时会失败。
—实现Serializable接口的类自动存储必要信息，而实现Externalizable接口的类由程序员决定存储哪些信息。
—实现Serializable接口的类易于实现，只需实现该接口即可，无需任何代码支持。而实现Externalizable接口的类必须为writeExternal(),readExternal()方法提供实现
— 实现Serializable接口的类性能略差，实现Externalizable的类性能略好。