乐趣区

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

[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~

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

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

公众号:秦怀杂货店

退出移动版