《Effective Java》学习笔记 —— 序列化

　　Java的序列化API提供了一个框架，用来将对象编码成一个字节流（序列化，serializing），并从字节流中重新创建对象（反序列化， deserializing）。

第74条 谨慎地实现Serializable接口

　　* 实现Serializable接口最大的代价是，一旦一个类被发布，就大大降低了“改变这个类的实现”的灵活性。

　　* 实现Serializable接口的第二个代价是，它增加了出现Bug和安全漏洞的可能性。

　　* 实现Serializable接口的第三个代价是，随着新版本的发布，相关的测试负担也增加了。

　　* 内部类（inner class）不应该实现Serializable接口，内部类的默认序列化形式是定义不清楚的。而静态成员类（static member class）可以实现。

第75条 考虑使用自定义的序列化形式

　　* 如果所有的实例域都是瞬时的（transient），从技术角度而言，不调用 defaultWriteObject 和 defaultReadObject 也是允许的，但不推荐这么做。

　　* 被标记为transient的域，如果是对象引用域，则被初始化为null；如果是数值基本域，则为0；如果是boolean域，则为false。如果这些初始值不能被任何transient域接受，则需要提供一个readObject方法，先调用defaultReadObject，然后再将其恢复为可接受的值。

　　* 声明一个显式的序列化版本id。

第76条 保护性的编写 readObject 方法

　　* readObject方法实际上如同一个公有的构造器，如同其他构造器一样，也要注意同样的所有注意事项。

　　* 编写健壮的readO方法：

　　　　-- 对于对象引用域必须保持为私有的类，要保护性的拷贝这些域中的每一个对象。

　　　　-- 对于任何约束条件，如果检查失败，则抛出一个InvalidObjectException异常。这些检查动作应该在跟在保护性拷贝之后。

　　　　-- 如果整个对象图在被反序列化之后必须进行验证，就应该使用ObjectInputValidation接口。

　　　　-- 无论是直接方式还是间接方式，都不要调用类中任何可被覆盖的方法。

第78条 对于实例控制，枚举类型优先于readResolve

　　* 如果以下类实现Serializable 接口，那它将不再是单例：

 public class Singleon {
     private static final Singleon INSTANCE = new Singleon();
 
     private Singleon() { }
 
     // other codes
 }

// 实现序列化接口后将不再是一个单例
public class Singleon implements Serializable {
    private static final Singleon INSTANCE = new Singleon();
 
    private Singleon() { }
 
    // other codes
}

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

　　如果上述的Singleon类实现了下面的方法，就足以保证它的单例属性：

     private Object readResolve() {
         return INSTANCE;
     }

　　事实上，如果依赖readResolve进行实例控制，带有对象引用类型的所有实例域都必须声明为transient。否则，攻击者就有可能在readResolve方法被运行之前，保护指向反序列化的对象的引用。

　　* 将一个可序列化的实例受控的类编写成枚举，则可以绝对保证除了声明的常量之外，不会有别的实例。

第78条 考虑使用序列化代理代替序列化实例

　　* 序列化代理模式：

　　　　（1）首先，增加一个静态内部类，其成员参数与需要序列化的外部类一致。

　　　　（2）然后，在外部类中添加writeReplace方法。修改序列化时写入的内容，写入代理类的内容，而不是外部类的。

　　　　（3）再在外部类添加readObject方法，让其抛出异常（由于写入的时候不是外部类的，那读的时候肯定也不是外部类的，如果是，则一定是伪造的）。

　　　　（4）最后，在内部类中增加一个readResolve 方法，返回一个外部类实例。

　　从整体上看，序列化代理模式就是增加一层转换。写入时先转换为代理类再写入，读出时再将其转换为被代理的类。

　　完整代码如下：

 import java.io.InvalidObjectException;
 import java.io.ObjectInputStream;
 import java.io.Serializable;
 import java.util.Date;
 
 /**
  * @author Haoye
  * @brief
  * @detail
  * @date 2018/10/6
  * @see
  */
 public class Period implements Serializable {
     private static final long serialVersionUID = 1;
     private final Date start;
     private final Date end;
 
     public Period(Date start, Date end) {
         this.start = start;
         this.end = end;
     }
 
     public Date getStart() {
         return start;
     }
 
     public Date getEnd() {
         return end;
     }
 
     /**
      * writeReplace for the serialization proxy pattern
      * @return instance of SerializationProxy
      */
     private Object writeReplace() {
         return new SerializationProxy(this);
     }
 
     private void readObject(ObjectInputStream inputStream) throws InvalidObjectException {
         throw new InvalidObjectException("Proxy required");
     }
 
     /**
      * proxy class
      */
     private static class SerializationProxy implements Serializable{
         private static final long serialVersionUID = 1;
         private final Date start;
         private final Date end;
 
         SerializationProxy(Period period) {
             this.start = period.start;
             this.end = period.end;
         }
 
         private Object readResolve() {
             return new Period(start, end);
         }
     }
 
 }

　　

　　* 序列化代理模式的好处：　　

　　　　（1）可以阻止伪字节流的攻击。

　　　　（2）也可以阻止内部域的盗用攻击。

　　　　（3）并且允许实际需要序列化的类的域声明为final。

　　　　（4）序列化代理模式允许反序列化实例与原始序列化实例有着不同的类（如EnumSet的序列化代理）。

　　EnumSet序列化代理类代码：

    /**
      * This class is used to serialize all EnumSet instances, regardless of
      * implementation type.  It captures their "logical contents" and they
      * are reconstructed using public static factories.  This is necessary
      * to ensure that the existence of a particular implementation type is
      * an implementation detail.
      *
      * @serial include
      */
     private static class SerializationProxy <E extends Enum<E>>
         implements java.io.Serializable
     {
         /**
          * The element type of this enum set.
          *
          * @serial
          */
         private final Class<E> elementType;
 
         /**
          * The elements contained in this enum set.
          *
          * @serial
          */
         private final Enum<?>[] elements;
 
         SerializationProxy(EnumSet<E> set) {
             elementType = set.elementType;
             elements = set.toArray(ZERO_LENGTH_ENUM_ARRAY);
         }
 
         // instead of cast to E, we should perhaps use elementType.cast()
         // to avoid injection of forged stream, but it will slow the implementation
         @SuppressWarnings("unchecked")
         private Object readResolve() {
             EnumSet<E> result = EnumSet.noneOf(elementType);
             for (Enum<?> e : elements)
                 result.add((E)e);
             return result;
         }
 
         private static final long serialVersionUID = 362491234563181265L;
     }

本文地址：https://www.cnblogs.com/laishenghao/p/effective_java_note_serialization.html