对象的序列化和反序列化

对象序列化：
目标：将对象保存到磁盘中，或允许在网络中直接传输对象。
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，通过网络将这种二进制流传输到另一个网络节点。其他程序一旦获得了这种二进制流，都可以将这种二进制流恢复成原来的java对象。
含义：序列化机制将实现序列化的Java对象转换成字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以备以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。
（1）对象的序列化（Serialiaze)：将一个Java对象写入IO流中。
（2）对象的反序列化（Deserialize）：从IO流中恢复该Java对象。

如果需要让某个对象支持序列化机制，则必须让它的类是可序列化的。则该类必须实现如下两个接口之一：
（1）Serializable
（2）Externalizable
实现Serializable接口无须实现任何方法，它只是表明该类的实例是可序列化的。
所有可能在网络上传输的对象的类都应该是可序列化的，否则程序会出现异常。
因为序列化是远程方法调用（RMI（Remote Method Invoke））过程的参数和返回值都必须实现的机制，而RMI又是Java EE技术的基础，所有的分布式应用常常需要跨平台、跨网络，所以要求所有传递的参数、返回值必须实现序列化。

序列化过程：
一旦某个类实现了Serializable接口，该类的对象就是可序列化的，程序可通过两个步骤来序列化该对象：
（1）创建一个ObjectOutputStream,这个输出流是一个处理流，所以必须建立在其他节点流的基础之上。
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(“object.txt”));
（2）调用ObjectOutputStream对象的writeObject（）方法输出可序列化对象
Out.writeObject(person);//将一个Person对象输出到输出流中

反序列化过程：
将一个文件输入流包装成ObjectInputStream输入流
ObjectInputStream in=new ObjectInputStream(new FileInputStream(file))
使用readObject()读取文件中的Java对象
Object object = in.readObject();
反序列化读取的仅仅是Java对象的数据，而不是Java类，因此采用反序列化恢复Java对象时，必须提供Java对象所属类的class文件，否则将会发生ClassNotFoundException异常。
定义一个Person类，该类实现了Serializable接口，表明该类的对象是可序列化的

import java.io.Serializable;
import java.util.Arrays;
import java.util.Date;

public class Person implements Serializable {
    private String name;
    private transient Integer age;  //transient表明age未被序列化
    private String[] skills;
    private Date birthday;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String[] getSkills() {
        return skills;
    }

    public void setSkills(String[] skills) {
        this.skills = skills;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "IO.Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", skills=" + Arrays.toString(skills) +
                ", birthday=" + birthday +
                '}';
    }
}

序列化实现：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;

public class TestSerializable {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(18);
        person.setBirthday(new Date());
        person.setName("zhanghao");
        person.setSkills(new String[]{"python", "Java", "C"});

        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:" + File.separator + "test5.25" + File.separator + "Person.data"))) {
         //将person对象写入输出流
           out.writeObject(person);
    }catch (IOException e) {
            e.printStackTrace();
        }

        }
    }

反序列化实现：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class TestDeserializable {
    //反序列化
    public static void main(String[] args) {
        File file=new File("D:" + File.separator + "test5.25" + File.separator + "Person.data");
        try(ObjectInputStream in=new ObjectInputStream(new FileInputStream(file))){

            Object object = in.readObject();    //读取文件中的Java对象
            Person person = (Person)object; //会发生CCE异常
            System.out.println(person);

        }catch (IOException e){

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

当一个可序列化类有多个父类时（直接父类和间接父类），这些父类要么有无参数的构造器，要么也是可序列化的。如果父类是不可序列化的，只是带有无参数的构造器，则该父类中定义的成员变量不会序列化到二进制流中。

由于Serializable默认会将对象中所有属性进⾏序列化保存，如果现在某些属性不希望被保存了，那么就可以使⽤transient关键字。用transient修饰的属性表示未被序列化。

对象引用的序列化：
若某个类的成员变量的类型不是基本类型或String类型，而是另一个引用类型，则这个引用类型必须是可序列化的
Java序列化机制采用了一种特殊的序列化算法：
（1）所有保存到磁盘中的对象都有一个序列化编号
（2）当程序试图序列化一个对象时，程序将先检查该对象是否已经被序列化过，只有该对象未被序列化过，系统才会将该对象转换成字节序列并输出
（3）如果某个对象已经序列化过，程序将只是直接输出一个序列化编号，而不是再次重新序列化该对象

Java序列化的底层机制：当多次调用writeObject()方法输出同一个对象时，只有第一次调用writeObject()方法时才会将该对象转换成字节序列并输出。其他的仅仅是输出一个序列化编号。
注：当使用Java序列化机制序列化可变对象时：只有第一次调用writeObject()方法来输出对象时才会将对象转换成字节序列，并写入到ObjectOutputStream,在后面程序中即使该对象的实例变量发生了改变，再次调用writeObject()方法输出该对象时，改变后的实例变量也不会被输出。