Java IO —— 对象序列化之transient 关键字

上一篇中我们讲述了对象的序列化与对象的输入输出流，这一篇章我们讲述 对象序列化的transient 关键字。

一、transient关键字

transient关键字可以使被修饰的属性，将不会被Java默认的方式序列化和反序列化，如果要对transient关键字修饰的属性进行序列化和反序列化，需要在类中实现writeObject方法和readObject方法。

package com.bxp.serializer;

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = -1242608031152179018L;
    private String name;
    private transient String id;
    private Integer age;

    public Student() {
    }

    public Student(String name, String id, Integer age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                ", age=" + age +
                '}';
    }
}

对象输出和输入方法：

   public static void outputObject() throws IOException {
        Student student = new Student("bxp", "12306", 25);

        FileOutputStream fop = new FileOutputStream("student.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fop);

        oos.writeObject(student);

        oos.flush();
        oos.close();
    }

    public static void inputObject() throws IOException, ClassNotFoundException {
        FileInputStream fis = new FileInputStream("student.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);

        Student stu = (Student)ois.readObject();

        System.out.println(stu);

        fis.close();
    }

我们执行outputObject()，然后再执行inputObject()方法，会输出如下内容：

Student{name='bxp', id='null', age=25}

 这里就可以看出，id属性没有参与序列化和反序列化。

二、自定义序列化过程

transient关键字可以使被修饰的属性，将不会被Java默认的方式序列化和反序列化。但是

Java并不强求用户非要使用默认的序列化方式，用户也可以按照自己的喜好自己指定自己想要的序列化方式----只要你自己能保证序列化前后能得到想要的数据就好了。手动指定序列化方式的规则是：

进 行序列化、反序列化时，虚拟机会首先试图调用对象里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化。如果没有这 样的方法，那么默认调用的是ObjectOutputStream的defaultWriteObject以及ObjectInputStream的 defaultReadObject方法。换言之，利用自定义的writeObject方法和readObject方法，用户可以自己控制序列化和反序列 化的过程。

这是非常有用的。比如：

（1）、有些 场景下，某些字段我们并不想要使用Java提供给我们的序列化方式，而是想要以自定义的方式去序列化它，比如ArrayList的 elementData，elementData是一个数组，假如数组的大小是20，但是真正的有效值是2个，其余都是null，如果使用默认的序列化，数组的20个元素都会被序列化，这就浪费了时间和存储资源，所以对其使用自定义的序列化，只序列化那两个有效值，ArrayList的序列化方法如下：

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

 

（2）、因为 序列化并不安全，因此有些场景下我们需要对一些敏感字段进行加密再序列化，然后再反序列化的时候按照同样的方式进行解密，就在一定程度上保证了安全性了。 要这么做，就必须自己写writeObject和readObject，writeObject方法在序列化前对字段加密，readObject方法在序 列化之后对字段解密

writeObject和readObject的通常用法：

三、自定义序列化实现

writeObject和readObject的实现很简单，实现模板如下：

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // 先调用默认的序列化方式，将没有被transient修饰的属性进行序列化
        s.defaultWriteObject();

        // 自定义序列化，其实就是调用 输出流对象 s 将被transient修饰的属性输出
        ……
    }

    
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // 先调用默认的反序列化方式，将没有被transient修饰的属性进行反序列化
        s.defaultReadObject();
        // 自定义反序列化，其实就是调用 输入流对象 s 将被transient修饰的属性读取进来
        ……
        
    }

writeObject和readObject的实现顺序要相互对应，比如，第一步都是默认的方法，第二步都处理name字段，第三部都处理age字段等。

示例：

在上面代码的基础上，在Student类中添加如下方法：

    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{
        // 先调用默认的序列化方式，将没有被transient修饰的属性进行序列化
        s.defaultWriteObject();

        // 自定义序列化，其实就是调用 输出流对象 s 将被transient修饰的属性输出
        s.writeUTF(id);
    }


    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        // 先调用默认的反序列化方式，将没有被transient修饰的属性进行反序列化
        s.defaultReadObject();
        // 自定义反序列化，其实就是调用 输入流对象 s 将被transient修饰的属性读取进来\
        id = s.readUTF();
    }

运行之后，会发现“id”字段可以序列化。