zoukankan      html  css  js  c++  java
  • Effective Java 78 Consider serialization proxies instead of serialized instances

    Serialization proxy pattern

    1. private static nested class (has a single constructor whose parameter type is the enclosing class, the constructor just copies all the data of its argument) of the serializable class that concisely represents the logical state of an instance of the enclosing class.  

      // Serialization proxy for Period class

      private static class SerializationProxy implements Serializable {

      private final Date start;

      private final Date end;

      SerializationProxy(Period p) {

      this.start = p.start;

      this.end = p.end;

      }

      private static final long serialVersionUID = 234098243823485285L; // Any number will do (Item 75)

      }

         

    2. Both the enclosing class and its serialization proxy class must be declared to implement serializable.
    3. Add writeRepalce method in the enclosing class.

      // writeReplace method for the serialization proxy pattern

      private Object writeReplace() {

      return new SerializationProxy(this);

      }

    4. To guarantee no generation of a serialized instance of the enclosing class fabrication readObject method should be added.

       

    // readObject method for the serialization proxy pattern

    private void readObject(ObjectInputStream stream)

    throws InvalidObjectException {

    throw new InvalidObjectException("Proxy required");

    }

       

    1. Finally, provide a readResolve method on the SerializationProxy class that returns a logically equivalent instance of the enclosing class.

      // readResolve method for Period.SerializationProxy

      private Object readResolve() {

      return new Period(start, end); // Uses public constructor

      }

    Advantage of serialization proxy

    The serialization proxy pattern allows the deserialized instance to have a different class from the originally serialized instance.

       

    // EnumSet's serialization proxy

    private static class SerializationProxy <E extends Enum<E>>

    implements Serializable {

    // The element type of this enum set.

    private final Class<E> elementType;

    // The elements contained in this enum set.

    private final Enum[] elements;

    SerializationProxy(EnumSet<E> set) {

    elementType = set.elementType;

    elements = set.toArray(EMPTY_ENUM_ARRAY); // (Item 43)

    }

    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;

    }  

    Limitations of serialization proxy

    1. It is not compatible with classes that are extendable by their clients (Item 17).
    2. It is not compatible with some classes whose object graphs contain circularities.
    3. Performance of it is worse than defensive copying.  

    Summary

    Consider the serialization proxy pattern whenever you find yourself having to write a readObject or writeObject method on a class that is not extendable by its clients. This pattern is perhaps the easiest way to robustly serialize objects with nontrivial invariants.

  • 相关阅读:
    JavaWeb-对象增强的方式
    JavaWeb-dbcp连接池
    eclipse发送音频等大数据包到数据库的异常解决方案
    JDBC-prepareStatement预编译
    JDBC原理
    JDBC入门
    当我们说前端,我们在说什么?
    markdown上下左右,跳至行尾行首,重设快捷键
    web API简介(四):客户端储存之IndexedDB API
    过年搭出租车攻略
  • 原文地址:https://www.cnblogs.com/haokaibo/p/consider-serialization-proxies-instead-of-serialized-instances.html
Copyright © 2011-2022 走看看