Java IO——对象的序列化与反序列化

本篇章简单讲述对象序列化的概念和实现，下一篇章讲解与序列化相关的关键字transient，transient关键字可以使被修饰的属性，将不会被Java默认的方式序列化，如果要对transient关键字修饰的属性进行序列化和反序列化，需要在类中实现writeObject方法和readObject方法。

一、对象的序列化概念与作用

     - 把对象转换为字节序列的过程称为对象的序列化。
     - 把字节序列恢复为对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：
　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
　　2） 在网络上传送对象的字节序列。

二、对象序列化的实现

1、要序列化的类必须实现 Serializable 接口。

实现 Serializable 接口后，如果用户没有自己声明一个serialVersionUID,接口会默认生成一个serialVersionUID，但是强烈建议用户自定义一个serialVersionUID，因为默认的serialVersinUID对于class的细节非常敏感，反序列化时可能会导致InvalidClassException这个异常。

我们先建一个实体类Person 实现Serializable接口

public class Person implements Serializable {
    

    private int age;
    private String name;
    private String sex;
  

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

然后去序列化和反序列化它

public class TestPersonSerialize {

    public static void main(String[] args) throws Exception {
        serializePerson();
        Person p = deserializePerson();
        System.out.println(p.getName()+";"+p.getAge());
        
        
    }
    
    private static void serializePerson() throws FileNotFoundException,IOException {
        Person person = new Person();
        person.setName("测试实例");
        person.setAge(25);
        person.setSex("male");

        ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
                new File("E:/person.txt")));
        oo.writeObject(person);
        System.out.println("序列化成功");
        oo.close();
    }
    
    private static Person deserializePerson() throws IOException, Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("E:/person.txt")));
        Person person = (Person) ois.readObject();
        System.out.println("反序列化成功");
        return person;
    }
}

结果如图

如果我们先尽心序列化，然后在反序列化之前修改了Person类会怎样呢

public class Person implements Serializable {
    
    private int age;
    private String name;
    private String sex;
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

运行结果

可以看到，当我们修改Person类的时候，Person类对应的SerialversionUID也变化了，而序列化和反序列化就是通过对比其SerialversionUID来进行的，一旦SerialversionUID不匹配，反序列化就无法成功。在实际的生产环境中，我们可能会建一系列的中间Object来反序列化我们的pojo，为了解决这个问题，我们就需要在实体类中自定义SerialversionUID。

e.g:3 在Person类中加入自定义SerialversionUID

public class Person implements Serializable {
    
   private static final long serialVersionUID = -5809782578272943999L;
    private int age;
    private String name;
    private String sex;
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

不管我们序列化之后如何更改我们的Person（不删除原有字段），最终都可以反序列化成功。

 

总结：

1、对象的类名、属性都会被序列化；而方法、static属性（静态属性）、transient属性（默认不会序列化，可以自定义）都不会被序列化

2、当通过文件、网络来读取序列化后的对象时，必须按实际的写入顺序读取。

3、要序列化的对象的引用属性也必须是可序列化的，否则该对象不可序列化，除非以transient关键字修饰该属性使其不用序列化。

【属性加密】通常，对象中的所有属性都会被序列化，但是对于一些比较敏感的信息，如用户的密码，一旦序列化后，人们可以通过读取文件或拦截网络传输数据的方式，获得这些信息。因此，出于安全考虑，某些属性应该限制被序列化。解决的办法是使用transient关键字为其加密，如transient private String password.
【序列化的深度】如果要序列化某个特定的对象，那么它的各个成员对象必须也是可序列化的。所有保存到磁盘中的对象都有一个序列号。
【序列化写入多个对象】如果使用序列化机制向文件中写入多个对象，那么反序列化恢复对象时，必须按照写入的顺序读取
【序列化类的父类】如果一个类可序列化，那么其父类要么是可序列化的，要么有无参构造，否则会抛出异常