乐趣区

关于java:transient关键字的作用以及几个疑问的解决

jiezi

[TOC]

1. 从 Serilizable 说到 transient

咱们晓得，如果一个对象须要序列化，那么须要实现 Serilizable 接口，那么这个类的所有非动态属性，都会被序列化。

留神：下面说的是 非动态属性 ，因为动态属性是属于类的，而不是属于类对象的，而序列化是针对类对象的操作，所以这个基本不会序列化。上面咱们能够试验一下：
实体类Teacher.class:

import java.io.Serializable;

class Teacher implements Serializable {
    public int age;
    public static String SchoolName;

    public Teacher(int age) {this.age = age;}

    @Override
    public String toString() {
        return "Teacher{" +
                "age=" + age +
                '}';
    }
}

测试代码 SerialTest.java, 基本思路就是初始化的时候，动态属性SchoolName 为 ” 西方小学 ”, 序列化对象之后，将动态属性批改，而后，反序列化，发现其实动态变量还是批改之后的，阐明动态变量并没有被序列化。

import java.io.*;

public class SerialTest {public static void main(String[] args) {
        Teacher.SchoolName = "西方小学";
        serial();
        Teacher.SchoolName = "东方小学";
        deserial();
        System.out.println(Teacher.SchoolName);
    }
    // 序列化
    private static void serial(){
        try {Teacher teacher = new Teacher(9);
            FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(teacher);
            objectOutputStream.flush();} catch (Exception exception) {exception.printStackTrace();
        }
    }
    // 反序列化
    private static void deserial() {
        try {FileInputStream fis = new FileInputStream("Teacher.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Teacher teacher = (Teacher) ois.readObject();
            ois.close();
            System.out.println(teacher.toString());
        } catch (IOException | ClassNotFoundException e) {e.printStackTrace();
        }
    }
}

输入的后果，证实 动态变量没有被序列化！！！

Teacher{age=9}
东方小学

2. 序列化属性对象的类须要实现 Serilizable 接口？

忽然想到一个问题，如果有些属性是对象，而不是根本类型，需不需要改属性的类型也实现 Serilizable 呢？

问题的答案是：须要！！！

上面是试验过程：

首先，有一个 Teacher.java, 实现了Serializable, 外面有一个属性是School 类型：

import java.io.Serializable;

class Teacher implements Serializable {
    public int age;

    public School school;
    public Teacher(int age) {this.age = age;}

    @Override
    public String toString() {
        return "Teacher{" +
                "age=" + age +
                '}';
    }
}

School类型, 不实现Serializable:


public class School {
    public String name;

    public School(String name) {this.name = name;}

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试代码，咱们只测试序列化：

import java.io.*;

public class SerialTest {public static void main(String[] args) {serial();
    }

    private static void serial(){
        try {Teacher teacher = new Teacher(9);
            teacher.school = new School("西方小学");
            FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(teacher);
            objectOutputStream.flush();} catch (Exception exception) {exception.printStackTrace();
        }
    }

}

会发现报错了，报错的起因是：School 不能被序列化，也就是没有实现序列化接口 ，所以如果咱们想序列化一个对象，那么这个对象的属性也必须是可序列化的，或者 它是 transient 润饰的。

java.io.NotSerializableException: com.aphysia.transienttest.School
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
    at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
    at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
    at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
    at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
    at com.aphysia.transienttest.SerialTest.serial(SerialTest.java:18)
    at com.aphysia.transienttest.SerialTest.main(SerialTest.java:9)

当咱们将 School 实现序列化接口的时候，发现所有就失常了 … 问题完满解决

3. 不想被序列化的字段怎么办？

然而如果有一个变量不是动态变量，然而咱们也不想序列化它，因为它可能是一些明码等敏感的字段，或者它是不那么重要的字段，咱们不心愿减少报文大小，所以想在序列化报文中排除该字段。或者改字段存的是援用地址，不是真正重要的数据，比方 ArrayList 外面的elementData。

这个时候就须要应用transient 关键字，将改字段屏蔽。

当咱们用 transient 润饰 School 的时候：

import java.io.Serializable;

class Teacher implements Serializable {
    public int age;

    public transient School school;
    public Teacher(int age) {this.age = age;}

    @Override
    public String toString() {
        return "Teacher{" +
                "age=" + age +
                ", school=" + school +
                '}';
    }
}
import java.io.Serializable;

public class School implements Serializable {
    public String name;

    public School(String name) {this.name = name;}

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                '}';
    }
}

执行上面序列化和反序列化的代码：

import java.io.*;

public class SerialTest {public static void main(String[] args) {serial();
        deserial();}

    private static void serial(){
        try {Teacher teacher = new Teacher(9);
            teacher.school = new School("西方小学");
            FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(teacher);
            objectOutputStream.flush();} catch (Exception exception) {exception.printStackTrace();
        }
    }

    private static void deserial() {
        try {FileInputStream fis = new FileInputStream("Teacher.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Teacher teacher = (Teacher) ois.readObject();
            ois.close();
            System.out.println(teacher.toString());
        } catch (IOException | ClassNotFoundException e) {e.printStackTrace();
        }
    }
}

执行后果如下，能够看到 teacher 字段反序列化进去，其实是 null，这也是 transient 起作用了。
然而留神，transient只能润饰变量，然而不能润饰类和办法，

4.ArrayList外面的 elementData 都被 transient 关键字润饰了，为什么ArrayList 还能够序列化呢？

这里提一下，既然 transient 润饰了 ArrayList 的数据节点，那么为什么序列化的时候咱们还是能够看到 ArrayList 的数据节点呢？
这是因为序列化的时候：

如果仅仅实现了 Serializable 接口，那么序列化的时候，必定是调用 java.io.ObjectOutputStream.defaultWriteObject() 办法，将对象序列化。而后如果是 transient 润饰了该属性，必定该属性就不能序列化。
然而，如果咱们尽管实现了 Serializable 接口, 也 transient 润饰了该属性, 该属性的确不会在默认的 java.io.ObjectOutputStream.defaultWriteObject() 办法外面被序列化了，然而咱们能够重写一个 writeObject() 办法，这样一来，序列化的时候调用的就是writeObject()，而不是java.io.ObjectOutputStream.defaultWriteObject()。

上面的源码是 ObjectInputStream.writeObject(Object obj), 外面底层其实会有反射的形式调用到重写的对象的writeObject() 办法，这里不做开展。

    public final void writeObject(Object obj) throws IOException {
        // 如果能够被重写，那么就会调用重写的办法
        if (enableOverride) {writeObjectOverride(obj);
            return;
        }
        try {writeObject0(obj, false);
        } catch (IOException ex) {if (depth == 0) {writeFatalException(ex);
            }
            throw ex;
        }
    }

ArrayList重写的 writeOject() 办法如下：

    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();
        }
    }

咱们能够看到，writeOject()外面其实在外面调用了默认的办法 defaultWriteObject()，defaultWriteObject() 底层其实是调用改了 writeObject0()。ArrayList 重写的 writeOject() 的思路次要是先序列化默认的，而后序列化数组大小，再序列化数组 elementData 外面实在的元素。这就达到了序列化元素实在内容的目标。

5. 除了 transient，有没有其余的形式，能够屏蔽反序列化？

且慢，问出这个问题，答案必定是有的！！！那就是 Externalizable 接口。

具体情况：Externalizable意思就是，类外面有很多很多属性，然而我只想要一部分，要屏蔽大部分，那么我不想在大部分的属性后面加关键字 transient，我只想标识一下本人序列化的字段，这个时候就须要应用Externalizable 接口。

show me the code!

首先定义一个Person.java, 外面有三个属性

  • age: 年龄
  • name：名字（被 transient 润饰）
  • score：分数

实现了 Externalizable 接口，就必须实现 writeExternal() 和readExternal()办法。

  • writeExternal：将须要序列化的属性进行自定义序列化
  • readExternal：将须要反序列化的属性进行自定义反序列化
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Person implements Externalizable {
    public int age;
    public transient String name;
    public int score;

    // 必须实现无参结构器
    public Person() {}

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

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        /*
         * 指定序列化时候写入的属性。这里不写入 score
         */
        out.writeObject(age);
        out.writeObject(name);
        out.writeObject(score);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        /*
         * 指定序列化时候写入的属性。这里依然不写入年龄
         */
        this.age = (int)in.readObject();
        this.name = (String)in.readObject();}

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

下面的代码，咱们能够看出，序列化的时候，将三个属性都写进去了，然而反序列化的时候，咱们仅仅还原了两个，那么咱们来看看测试的代码：

import java.io.*;

public class ExternalizableTest {public static void main(String[] args) {serial();
        deserial();}

    private static void serial(){
        try {Person person = new Person(9,"Sam",98);
            FileOutputStream fileOutputStream = new FileOutputStream("person.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(person);
            objectOutputStream.flush();} catch (Exception exception) {exception.printStackTrace();
        }
    }

    private static void deserial() {
        try {FileInputStream fis = new FileInputStream("person.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person person = (Person) ois.readObject();
            ois.close();
            System.out.println(person);
        } catch (IOException | ClassNotFoundException e) {e.printStackTrace();
        }
    }
}

测试后果如下, 就能够发现其实后面两个都反序列化胜利了，前面那个是因为咱们重写的时候，没有自定义该属性的反序列化，所以没有是失常的啦 …

Person{age=9, name='Sam', score='0'}

如果仔细点，能够发现，有一个字段是 transient 润饰的，不是说润饰了，就不会被序列化么，怎么序列化进去了。

没错，只有实现了 Externalizable 接口，其实就不会被 transient 左右了，只会依照咱们自定义的字段进行序列化和反序列化，这里的 transient 是有效的 …

对于序列化的 transient 临时到这，keep going~

此文章仅代表本人（本菜鸟）学习积攒记录，或者学习笔记，如有侵权，请分割作者删除。人无完人，文章也一样，文笔稚嫩，在下不才，勿喷，如果有谬误之处，还望指出，感激不尽~

技术之路不在一时，山高水长，纵使迟缓，驰而不息。

公众号：秦怀杂货店

退出移动版