序列化&反序列化

序列化：即将对象转换为字节序列的过程；Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

反序列化：即将字节序列转换回对象的过程。转换后的对象包含了转换前的对象的状态。

如何实现对象序列化

我们知道，在java中要实现一个对象的序列化，只需要实现Serializable接口即可。一般还有一个IDE自动生成的serialVersionUID字段。

serialVersionUID

这个字段实际上也是很重要的，如果去掉，在序列化或反序列化的过程中会根据一系列很复杂的算法生成，导致速度变慢。

transient

对于我们不想序列化的字段，可以使用transient修饰它。比如：private transient Date start;则说明start字段不参与序列化。

静态字段

静态字段也不会参与序列化。

实现序列化

通常将对象通过ObjectOutputStream写入一个文件或者在网络上传输后进行反序列化：

Period period = new Period(new Date(),new Date());
System.out.println("before serilization: " + period);
try(ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("d:/Period.b"))) {
    out.writeObject(period);
}

实现反序列化

通过ObjectInputStream从文件读取：

try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("d:/Period.b"))) {
    period = (Period) in.readObject();
    System.out.println("after deseriliaztion: " + period);
}

自定义序列化-readObject-writeObject

readObject和writeObject用于自定义序列化。比如对静态字段进行序列化就需要编写readObject和writeObject来实现序列化与反序列化。

示例：

public class Foo extends AbstractFoo implements Serializable {
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();

        // 手动反序列化并实例化父类的state
        int x = in.readInt();
        int y = in.readInt();
        initialize(x,y);
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();

        // 手动序列化父类的state
        out.writeInt(getX());
        out.writeInt(getY());
    }

    private static final long serialVersionUID = -3881436735239828405L;
}

如果一个对象的物理表示法等同于它的逻辑内容，可能就适合使用默认的序列化形式。

比如下面的类：

public class Name implements Serializable {

    private static final long serialVersionUID = 7188905641007443816L;

    private String lastName;
    private String firstName;
    private String middleName;

    public Name(String lastName, String firstName, String middleName) {
        this.lastName = lastName;
        this.firstName = firstName;
        this.middleName = middleName;
    }
}

从逻辑的角度而言，一个名字包含姓、名和中间名。Name中的实例域精确的反应了它的逻辑内容。

即使你确定了使用默认的序列化形式是合适的，通常还必须提供一个readObject方法以保证约束关系和安全性。对于Name这个类而言，readObject方法必须确保firstName和lastName是非null的。

修正的版本：

public class Name implements Serializable {

    private static final long serialVersionUID = 7188905641007443816L;

    private String lastName;
    private String firstName;
    private String middleName;

    public Name(String lastName, String firstName, String middleName) {
        this.lastName = lastName;
        this.firstName = firstName;
        this.middleName = middleName;
    }

    private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
        s.defaultReadObject();// 从该流中读取当前类的非静态和非瞬态字段。

        String lastNameTemp = s.readObject().toString();
        String firstNameTemp = s.readObject().toString();
        String middleNameTemp = s.readObject().toString();

        if (lastNameTemp == null || firstNameTemp == null) {
            throw new IllegalArgumentException("firstName or lastName can't be null!");
        }

        this.lastName = lastNameTemp;
        this.middleName = middleNameTemp;
        this.firstName = firstNameTemp;
    }
}

ps:readObject是ObjectInputStream在反序列化的时候通过反射调用的。

保护性的编写readObject方法

readObject实际上相当于另一个公有的构造器，如同其他构造器一样，也必须注意同样的所有注意事项。构造器必须检查其参数的有效性，并且在必要的时候对参数进行有效性拷贝 。

同样的，readObject也应该这么做。

不严格的说，readObject是一个“用字节流来作为唯一参数“的构造器。

所以，我们需要编写readObject方法，并对从流读取的对象的域进行合法性校验。

public class Period implements Serializable {
    private static final long serialVersionUID = -5896804371611599645L;
    private Date start;
    private Date end;

    public Period(Date start, Date end) {
        Date s = new Date(start.getTime());
        Date e = new Date(end.getTime());

        if (s.before(e)) {
            throw new IllegalArgumentException("start can't after end.");
        }

        this.start = s;
        this.end = e;
    }

    public Date getStart() {
        return new Date(start.getTime());
    }

    public Date getEnd() {
        return new Date(end.getTime());
    }

    private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
        s.defaultReadObject();

        // 保护性拷贝易变的组件，否则攻击者可能通过篡改序列化后的字节流，拿到Period的2个Date域的引用，从而进行修改，最终改变Period。
        start = new Date(start.getTime());
        end = new Date(end.getTime());

        if (start.after(end)) {
            throw new InvalidObjectException(start + " after " + end);
        }
    }

    @Override
    public String toString() {
        return start + " - " + end;
    }
}

上述代码，如果不对start和end进行保护性拷贝，实际上是有可能篡改Period对象的。

篡改方式：

通过伪造字节流，创建可变的Period仍是可能的，做法是：字节流以一个有效的Period开头，然后附加2个额外的引用，指向Period实例域的2个私有的Date域。

攻击者从ObjectInputStream读取Period实例，然后读取附加在其后面的“恶意编制的对象引用”。这些对象引用使得攻击者能够访问到Period对象内部的私有的Date域所引用的对象。

通过改变这些Date实例，可以改变Period实例。

篡改实例：

/**
 * @author Donny
 * @createTime 2020-05-06 16:48
 * @description 可变的Period
 */
public class MutablePeriod {
    private final Period period;
    private final Date start;
    private final Date end;

    public MutablePeriod() {
        /**
         * 如果不对Period的readObject做保护性拷贝
         * 通过伪造字节流，创建可变的Period仍是可能的，做法是：字节流以一个有效的Period开头，然后附加2个额外的引用，指向Period实例域的2个私有的Date域。
         * 攻击者从ObjectInputStream读取Period实例，然后读取附加在其后面的“恶意编制的对象引用”。这些对象引用使得攻击者能够访问到Period对象内部的私有的Date域所引用的对象。
         * 通过改变这些Date实例，可以改变Period实例。
         */
        try {
            // 序列化
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(baos);
            // 序列化一个有效的Period对象
            out.writeObject(new Period(new Date(),new Date()));
            /**
             * Append rogue "previous object refs" for internal Date fields in Period.
             * For details,see "Java Object Serialization Specification",Section 6.4.
             */
            byte[] ref = {0x71,0,0x7e,0,5}; // Ref #5
            baos.write(ref);// start field
            ref[4] = 4; // Ref #4
            baos.write(ref); // end field

            // 反序列化
            ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
            period = (Period) in.readObject();
            start = (Date) in.readObject();
            end = (Date) in.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new AssertionError(e);
        }

    }

    public static void main(String[] args) {
        MutablePeriod mp = new MutablePeriod();
        Period p = mp.period;
        Date pEnd = mp.end;

        pEnd.setYear(78);
        System.out.println(p);

        pEnd.setYear(69);
        System.out.println(p);
    }
}

让序列化的对象和反序列化后的对象为同一对象

如果使用枚举实现的单例模式，可以防止利用反射强行构建单例对象，而且可以在枚举类对象被反序列化的时候，保证反序列的返回结果是同一对象（JVM对此提供保障）。

对于其他方式实现的单例模式，如果既想要做到可序列化，又想要反序列化为同一对象，则必须实现readResolve方法。

readResolve特性允许你用readObject创建的实例代替另一个实例（反序列化的）。对于一个正在被反序列化的对象，如果它的类定义了一个readResolve方法啊，并且具备正确的声明，那么在反序列化之后，新建对象上的readResolve方法就会被调用。然后，该方法返回的对象引用将会被返回，取代新建的对象。

public class Elvis3 implements Serializable {
    private static final Elvis3 INSTANCE = new Elvis3();
    public static Elvis3 getInstance() {
        return INSTANCE;
    }
    // readResolve method to preserve singleton property
    private Object readResolve() {
        // return the one true Elvis and let the garbage collector take care of the Elvis impersonator.
        return INSTANCE;
    }
}

上面的readResolve忽略了被反序列化的对象，只返回该内初始化时创建的那个特殊的INSTANCE实例 。

如果依赖readResolve对实例进行控制，则带有对象引用类型的所有的域都应该声明为transient。

如果必须编写可序列化的实例受控的类，它的实例在编译时还不知道，那么就不能通过枚举的方式来实现，只能通过通过readResolve来保证。

考虑使用序列化代理序列化实例

当你发现自己必须在一个不能被客户端扩展的类上编写readObject或writeObject方法时，就应该考虑使用序列化代理模式。要想稳健的将带有重要约束条件的对象序列化时，这种模式可能是最容易的方法。

实现方式（本例中Period为待序列化的类，SerializationProxy是序列化代理类）：

1.序列化代理类与要序列化的类都实现Serializable接口；

2.序列化代理带有一个接收一个待序列化的类参数的构造器；

3.待序列化类编写writeReplace方法，并返回序列化代理对象；

4.在序列化代理类中编写readResolve方法，返回待序列化实例。

实现过程：

1.序列化

在我们序列化Period时，序列化系统发现Period中定义了writeReplace，转而使用writeReplace返回对象的序列化方式；

Period.writeReplace() ==> SerializationProxy.writeObject().也就是说序列化后存储的实际是序列化代理对象（SerializationProxy）。

2.反序列化

SerializationProxy.readObject() ==> SerializationProxy.readResolve().

反序列化的时候因为已经知道是SerializationProxy，所以直接使用它的反序列化方式。

要序列化的类：

public class Period implements Serializable {
    private final Date start;
    private final Date end;

    public Period(Date start, Date end) {
        Date s = new Date(start.getTime());
        Date e = new Date(end.getTime());

        if (s.after(e)) {
            throw new IllegalArgumentException(start + " after " + e);
        }

        this.start = s;
        this.end = e;
    }

    public Date getStart() {
        return new Date(start.getTime());
    }

    public Date getEnd() {
        return new Date(end.getTime());
    }

    @Override
    public String toString() {
        return start + " - " + end;
    }

    private Object writeReplace() {
        System.out.println("call Period.writeReplace().");
        return new SerializationProxy(this);
    }

    private void readObject(ObjectInputStream in) throws InvalidObjectException {
        System.out.println("call Period.readObject().");
        throw new InvalidObjectException("proxy required.");
    }

    private void writeObject(ObjectOutputStream out) throws InvalidObjectException {
        System.out.println("call Period.writeObject().");
        throw new InvalidObjectException("proxy required.");
    }
}

序列化代理类：

public class SerializationProxy implements Serializable {
    private static final long serialVersionUID = -2475499946017458008L;
    private final Date start;
    private final Date end;

    public SerializationProxy(Period period) {
        this.start = period.getStart();
        this.end = period.getEnd();
    }

    private Object readResolve() {
        System.out.println("call SerializationProxy.readResolve().");
        return new Period(start,end);
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        System.out.println("call SerializationProxy.readObject().");
        in.defaultReadObject();
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        System.out.println("call SerializationProxy.writeObject().");
        out.defaultWriteObject();
    }
}

测试代码：

public class Test {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 对Period进行序列化和反序列化
        String name = "d:/Period.d";
        Period period = new Period(new Date(),new Date());
        try(ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(name))) {
            out.writeObject(period);
        }

        System.out.println("start to deserilize.");
        try(ObjectInputStream in = new ObjectInputStream(new FileInputStream(name))) {
            period = (Period) in.readObject();
            System.out.println(period.toString());
        }
    }
}

测试结果：

call Period.writeReplace().

call SerializationProxy.writeObject().

start to deserilize.

call SerializationProxy.readObject().

call SerializationProxy.readResolve().

Thu May 07 11:00:32 CST 2020 - Thu May 07 11:00:32 CST 2020

总结

通过本文的内容，你会发现实现序列化从来都表示实现Serializable接口就完事了，要考虑的事情有很多。如何编写合适的序列化代码是一个值得考虑的问题。