如何在Java中序列化/反序列化引用？

Question

I would like to have serializable reference, which works within single machine only.

Such sort of object, being set to reference and serialized, and then deserialized, should reference exactly the same object as it was before serialization.

Obvious solution I made:

public class ReferenceSerializable<T> implements Serializable {

   public static final DataFormat REFERENCE = new DataFormat("application/prs.reference");

   private static Int2ObjectOpenHashMap<WeakReference<Object>> map = new Int2ObjectOpenHashMap<>();

   private T referent;
   private int identity;

   public ReferenceSerializable(T referent) {
      this.referent = referent;
      identity = System.identityHashCode(referent);
      if( !map.containsKey(identity) ) {
         map.put(identity, new WeakReference<Object>(referent));
      }

   }

   private void writeObject(java.io.ObjectOutputStream out) throws IOException {
      out.writeInt(identity);
   }

   private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
      identity = in.readInt();
      referent = (T) map.get(identity).get();
      if( referent == null ) {
         throw new IllegalStateException("Object does not exist anymore, reference is obsolete");
      }
   }

}

Is it possible to implement other way?

Answer 1

I got the point and I think you cannot do it in Java. Even if you make up a different solution (other than the one you offered) you will anyway end up with a variation of "Dictionary" solution. So, you will need to store your artificial keys (and objects in some storage) anyway, since in Java, after deserialization, the object is completely detached, if you know what I mean.