Java 序列化和反序列化

1.Java序列化与反序列化
a.序列化是指把对象转换为字节序列的过程
b.反序列化是指把字节序列恢复为对象的过程
c.如果一个对象被序列化,那么引用这个对象的其他对象也将被序列化
d.如果一个对象被反序列化,那么引用这个对象的其他对象也将被恢复
e.如果一个类可以被序列化,那么所有子类也可以被序列化
f.一个对象不能序列化将抛出NotSerializableException
g.static修饰变量不能被序列化，因为静态变量不属于对象是属于类本身
h.transient修饰的变量不能被序列化。这样的话，我们需要某个变量不被序列化，可以采用这个方式（并非绝对，后面有说明）
2.序列化的应用场景
a.把内存中的对象保存到磁盘的文件中，实现数据的持久化
用户的Session对象保存到服务器的磁盘中，而不保存到服务器的内存中，等用的时候才加载到内存中，这样就减少了服务器内存的压力。
b.在网络上传输对象的字节序列，实现远程通信
网路传输数据不管是何种类型，最终都是以二进制序列的形式传输的。那么我们就可以借助序列化，把Java对象序列化为字节序列传送给接收方，接收方再把字节序列恢复成Java对象
3.Java如何实现序列化和反序列化
a.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
b.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
c.只有实现Serializable或者Externalizable接口的类，它的对象才能被序列化。
Externalizable接口继承自Serializable接口，实现Externalizable接口的类完全由程序员来控制序列化，而仅实现Serializable接口的类可以采用默认的序列化方式
4.仅实现接口Serializable完成序列化

//实现接口Serializable
class Person implements Serializable {
    private static final long serialVersionUID = -5681071930954108556L;
    // 静态的变量不能序列化
    static int number = 1000;
    String name;
    int age;
    // 瞬息的变量不能序列化
    transient String password;

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

public class SerializableTest {
    public static void main(String[] args) throws Exception {
        // 创建一个人对象
        Person person1 = new Person("李文超", 18, "123456");
        // 序列化
        FileOutputStream fos = new FileOutputStream("Person.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(person1);
        // 反序列化
        FileInputStream fis = new FileInputStream("Person.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Person person2 = (Person) ois.readObject();
        // 检查反序列化的数据
        System.out.println("名称：" + person2.name);
        System.out.println("年龄：" + person2.age);
        System.out.println("密码：" + person2.password);
        oos.close();
        ois.close();
    }
}

打印结果为：
名称：李文超
年龄：18
密码：null
说明：被transient修饰的变量不能被序列化。那么如果有一些敏感信息，为了安全起见，不希望被序列化，这些信息对应的变量就可以加上transient关键字。
5.自定义序列化有两种方式
a.实现接口Serializable，并且在需要序列化的类中增加如下两个方法
private void writeObject(ObjectOutputStream out) throws Exception {}
private void readObject(ObjectInputStream in) throws Exception {}

class Person implements Serializable {
    private static final long serialVersionUID = -5681071930954108556L;
    String name;
    int age;
    transient String password;

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

    // 自定义序列化方法，没有指定序列化age
    private void writeObject(ObjectOutputStream out) throws Exception {
        out.writeUTF(name);
        out.writeUTF(password);
    }

    // 自定义反序列化方法，没有指定反序列化age
    private void readObject(ObjectInputStream in) throws Exception {
        name = in.readUTF();
        password = in.readUTF();
    }
}

public class SerializableTest {
    public static void main(String[] args) throws Exception {
        // 创建一个人对象
        Person person1 = new Person("李文超", 18, "123456");
        // 序列化
        FileOutputStream fos = new FileOutputStream("Person.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(person1);
        // 反序列化
        FileInputStream fis = new FileInputStream("Person.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Person person2 = (Person) ois.readObject();
        // 检查反序列化的数据
        System.out.println("名称：" + person2.name);
        System.out.println("年龄：" + person2.age);
        System.out.println("密码：" + person2.password);
        oos.close();
        ois.close();
    }
}

打印结果为：
名称：李文超
年龄：0
密码：123456
b.实现接口Externalizable，并且重写writeExternal和readExternal两个方法

class Person implements Externalizable {
    private static final long serialVersionUID = -5681071930954108556L;
    String name;
    int age;
    transient String password;
    //空构造器是必须的，否则会抛异常：no valid constructor
    public Person() {
        super();
    }

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

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // 手动指定序列化，没有指定序列化age
        out.writeObject(name);
        out.writeObject(password);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // 手动指定序列化，没有指定反序列化age
        name = (String) in.readObject();
        password = (String) in.readObject();
    }
}

public class ExternalizableTest {
    public static void main(String[] args) throws Exception {
        // 创建一个人对象
        Person person1 = new Person("李文超", 18, "123456");
        // 序列化
        FileOutputStream fos = new FileOutputStream("Person.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(person1);
        // 反序列化
        FileInputStream fis = new FileInputStream("Person.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Person person2 = (Person) ois.readObject();
        // 检查反序列化的数据
        System.out.println("名称：" + person2.name);
        System.out.println("年龄：" + person2.age);
        System.out.println("密码：" + person2.password);
        oos.close();
        ois.close();
    }
}

打印结果：
名称：李文超
年龄：0
密码：123456
c.总结
实现接口Serializable并且编写了writeObject和readObject两个方法或者实现接口Externalizable的类，是由程序员指定序列化那个，因为这两个例子都没有指定序列化age，所以取值为默认值0。
还有一点很重要，被transient修饰的变量也被序列化了。
6.serialVersionUID的作用
字​面​意​思​上​是​序​列​化​的​版​本​号​，凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量

serialVersionUID适用于Java的序列化机制。简单来说，Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException。

serialVersionUID有两种显示的生成方式：
一是默认的1L，比如：private static final long serialVersionUID = 1L;
二是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，
比如：private static final long serialVersionUID = xxxxL;

当实现java.io.Serializable接口的类没有显式地定义一个serialVersionUID变量时候，Java序列化机制会根据编译的Class自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果Class文件(类名，方法名等)没有发生变化(增加空格，换行，增加注释等等)，就算再编译多次，serialVersionUID也不会变化的。

如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。

为了提高serialVersionUID的独立性和确定性，强烈建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。