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~

此文章仅表明本身（本菜鸟）学习积累记录，或者学习笔记，若有侵权，请联系做者删除。人无完人，文章也同样，文笔稚嫩，在下不才，勿喷，若是有错误之处，还望指出，感激涕零~

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

公众号：秦怀杂货店