Cosa succede durante la serializzazione in java, se due rifrazioni di oggetti puntano allo stesso oggetto serializzabile?

Question

Cosa succede durante la serializzazione in java, se due rifrazioni di oggetti puntano allo stesso oggetto serializzabile? Gli oggetti serializzabili vengono salvati due volte?
ad esempio:

class King implements java.io.Serializable { 
     private String name="Akbar"; 
    } 

    class Kingdom implements java.io.Serializable { 
     King goodKing=new King(); 
     King badKing=goodKing; 
    } 

    public class TestSerialization { 
     public static void serializeObject(String outputFileName, 
              Object serializableObject) throws IOException { 
      FileOutputStream fileStream=new FileOutputStream(outputFileName); 
      ObjectOutputStream outStream=new ObjectOutputStream(fileStream); 
      outStream.writeObject(serializableObject); 
      outStream.close(); 
     } 

     public static void main(String[] args) { 
      Kingdom kingdom=new Kingdom(); 
      try { 
       TestSerialization.serializeObject("Kingdom1.out", kingdom); 
      }catch(IOException ex) { 
       ex.getMessage(); 
      } 
     } 
    } 

Ora, se lo stato solo un oggetto viene salvato sia per goodKing e badKing refrences o l'oggetto re vengono salvati due volte?

Answer 1

La documentazione per ObjectOutputStream dice cosa succede:

Il meccanismo di serializzazione di default per un oggetto scrive la classe dell'oggetto, la firma di classe, ed i valori di tutti i campi non transienti e non statici. I riferimenti ad altri oggetti (ad eccezione dei campi transitori o statici) fanno sì che anche questi oggetti vengano scritti. Più riferimenti a un singolo oggetto vengono codificati utilizzando un meccanismo di condivisione di riferimento in modo che i grafici degli oggetti possano essere ripristinati nella stessa forma di quando è stato scritto l'originale.

(corsivo mio)

Ad esempio, se si dispone di più riferimenti a un singolo oggetto, quando il grafico è ricostituita, si finisce con più riferimenti a una sola versione ricostituito di tale oggetto, non riferimenti a più istanze equivalenti di esso.

Ovviamente, se il contenitore che viene serializzato implementa un meccanismo diverso, il comportamento è dettato da quel meccanismo, non da quello predefinito.

Così, per esempio, se abbiamo Thing e Test:

Thing.java:

import java.io.*; 
import java.util.*; 

public class Thing implements Serializable { 
    private Map<String,String> map1; 
    private Map<String,String> map2; 

    public Thing() { 
     this.map1 = new HashMap(); 
     this.map2 = this.map1; // Referring to same object 
    } 

    public void put(String key, String value) { 
     this.map1.put(key, value); 
    } 

    public boolean mapsAreSameObject() { 
     return this.map1 == this.map2; 
    } 
} 

Test.java:

import java.io.*; 

public class Test implements Serializable { 

    public static final void main(String[] args) { 
     try 
     { 
      // Create a Thing 
      Thing t = new Thing(); 
      t.put("foo", "bar"); 

      // Write it out 
      ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("foo")); 
      os.writeObject(t); 
      os.close(); 
      os = null; 

      // Read it in 
      Thing t2; 
      ObjectInputStream is = new ObjectInputStream(new FileInputStream("foo")); 
      t2 = (Thing)is.readObject(); 
      is.close(); 
      is = null; 

      // Same underlying map for both properties? 
      System.out.println("t2.mapsAreSameObject? " + t2.mapsAreSameObject()); 
     } 
     catch (Exception e) 
     { 
      System.out.println("Exception: " + e.getMessage()); 
     } 
    } 
} 

e correre java Test, otteniamo:

t2.mapsAreSameObject? true

... perché entrambi i membri di Thing, map1 e map2 finiscono per puntare a una singola istanza HashMap.