transient关键字作用是什么

transient关键字作用是什么

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

执行结果如下,可以看到School字段反序列化出来,其实是null,这也是transient起作用了。
但是注意,transient只能修饰变量,但是不能修饰类和方法,

Teacher{age=9,school=null}

4.ArrayList里面的elementData都被transient 关键字修饰了,为什么ArrayList还可以序列化呢?

这里提一下,既然transient修饰了ArrayList的数据节点,那么为什么序列化的时候我们还是可以看到ArrayList的数据节点呢?
这是因为序列化的时候:

如果仅仅实现了Serializable接口,那么序列化的时候,肯定是调用java.io.ObjectOutputStream.defaultWriteObject()方法,将对象序列化。然后如果是transient修饰了该属性,肯定该属性就不能序列化。
但是,如果我们虽然实现了Serializable接口,也transient修饰了该属性,该属性确实不会在默认的java.io.ObjectOutputStream.defaultWriteObject()方法里面被序列化了,但是ArrayList重写一个writeObject()方法,这样一来,序列化的时候调用的就是ArrayList重写的writeObject()方法,而不是java.io.ObjectOutputStream.defaultWriteObject()的方法了。

下面的源码是ObjectOutputStream.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);

        // 此时elementData在默认序列化方法中没有被序列化,单独对elementData中的元素进行writeObject操作
        for (int i=0; i<size; i++) {
            // 序列化对象的值
            s.writeObject(elementData[i]);
        }

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

我们可以看到,writeOject()里面其实在里面调用了默认的方法defaultWriteObject()defaultWriteObject()底层其实是调用改了writeObject0()方法。ArrayList重写的writeOject()的思路主要是先序列化默认的,然后序列化数组大小,再序列化数组elementData里面真实的元素。这就达到了序列化元素真实内容的目的。

/**
     * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
     * deserialize it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            int capacity = calculateCapacity(elementData, size);
            SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

ArrayList的反序列化操作入上面代码所示。先调用defaultReadObject()进行默认的反序列化操作,对于之前writeOject()写入的elementData中的真实元素,在for循环中挨个读取出来,实现了elementData的反序列化,因此elementData虽然使用了transient关键字修饰,但是因为重写了writeOject()和readObject()方法,所以最终还是实现了elementData属性的序列化和反序列化。

同理,借用ArrayList的实现逻辑,可以实现带有transient关键字的属性的序列化和反序列化,下面构造一个简单的实体类

class TransientTest implements Serializable {
    private static final long serialVersionUID = 233858934995755239L;
    private String name1;
    private transient String name2;

    public TransientTest(String name1, String name2) {
        this.name1 = name1;
        this.name2 = name2;
    }

    public String toString() {
        return String.format("TransientTest.toString(): name1=%s,name2=%s", name1, name2);
    }

    private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
        s.defaultWriteObject();
        s.writeObject(name2);
    }

    private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        name2 = String.valueOf(s.readObject());
    }

    private static void serial() {
        try {
            TransientTest teacher = new TransientTest("常规属性", "transient修饰的属性");
            System.out.println("序列化前:" + teacher.toString());
            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);
            TransientTest teacher = (TransientTest) ois.readObject();
            ois.close();
            System.out.println("反序列化:" + teacher.toString());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

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

结果如下:

序列化前:TransientTest.toString(): name1=常规属性,name2=transient修饰的属性
反序列化:TransientTest.toString(): name1=常规属性,name2=transient修饰的属性

5.除了transient,有没有其他的方式,可以屏蔽属性的反序列化?

且慢,问出这个问题,答案肯定是有的!!!那就是Externalizable接口。

具体情况:Externalizable意思就是,类里面有很多很多属性,但是我只想要一部分,要屏蔽大部分,那么我不想在大部分的属性前面加关键字transient,我只想标识一下自己序列化的字段,这个时候就需要使用Externalizable接口。

首先定义一个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是无效的…

站在巨人肩膀上摘苹果

https://www.jianshu.com/p/31c77d833a8e

https://blog.csdn.net/u010188178/article/details/83581506

hmoban主题是根据ripro二开的主题,极致后台体验,无插件,集成会员系统
自学咖网 » transient关键字作用是什么