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

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

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

公众号：秦怀杂货店