In uno dei miei post precedenti relativi a “Implementazione dell’interfaccia serializzabile in java”, Mr. Bitoo ha fatto una buona domanda “al momento della deserializzazione, come la JVM crea l’oggetto senza chiamare il costruttore??”. Ho pensato di rispondergli nello stesso post in un commento, ma in un altro momento ho pensato a questo argomento molto interessante che richiede un articolo dettagliato separato, così come la discussione con voi gente., Quindi, qui sto iniziando la discussione con la mia conoscenza limitata in questo argomento e vi incoraggerò tutti a mettere i vostri pensieri/domande in modo da rendere questo argomento chiaro per tutti noi. Qui comincio.
Abbiamo già trattato molte cose relative alla serializzazione in java e alcune cose relative alla deserializzazione in java. Non ripeterò di nuovo la stessa cosa e verrò direttamente all’argomento di discussione principale, ad esempio come funziona la deserializzazione in Java?
La deserializzazione è il processo mediante il quale l’oggetto precedentemente serializzato viene ricostruito nella sua forma originale, ovvero, istanza oggetto. L’input al processo di deserializzazione è il flusso di byte che otteniamo dall’altra estremità della rete O semplicemente lo leggiamo dal file system/database. Una domanda sorge immediatamente, cosa è scritto all’interno di questo flusso di byte?
Leggi di più: Mini guida per implementare l’interfaccia serializzabile
Per essere molto precisi, questo flusso di byte (o dire dati serializzati) ha tutte le informazioni sull’istanza che è stata serializzata dal processo di serializzazione., Queste informazioni includono i metadati della classe, le informazioni sul tipo dei campi di istanza e i valori dei campi di istanza. Queste stesse informazioni sono necessarie quando l’oggetto viene ricostruito in una nuova istanza dell’oggetto. Durante la deserializzazione di un oggetto, la JVM legge i metadati della classe dal flusso di byte che specifica se la classe di un oggetto implementa l’interfaccia “Serializzabile” o “Esternalizzabile”.,
Se instance implementa l’interfaccia serializzabile, viene creata un’istanza della classe senza richiamare alcun costruttore. Veramente? quindi come viene creato l’oggetto se non viene chiamato il costruttore?
Diamo un’occhiata al bytecode di un semplice eprogramma:
Sopra il bytecode sembra roba reale, non è vero?, Nella nostra prima riga, stiamo andando a spingere un valore dalla “tabella variabile locale” sullo stack. In questo caso, stiamo solo spingendo il riferimento implicito a” questo”, quindi non è l’istruzione più eccitante. La seconda istruzione è la cosa principale. In realtà invoca il costruttore di super most class e nel caso precedente è Object.Java. E una volta che il costruttore di super most class (cioè Object in questo caso) è stato chiamato, il resto del codice fa istruzioni specifiche scritte in codice.
Corrispondenza al concetto precedente, cioè, costruttore di super più classe, abbiamo un concetto simile nella deserializzazione. Nel processo di deserializzazione, è necessario che tutte le classi padre dell’istanza siano serializzabili; e se una super classe in hirarchy non è serializzabile, deve avere un costruttore predefinito. Ora ha senso. Quindi, mentre la deserializzazione della classe super most viene cercata per prima fino a quando non viene trovata una classe non serializzabile. Se tutte le super classi sono serializzabili, JVM finisce per raggiungere la classe Oggetto stessa e creare prima un’istanza della classe Oggetto., Se tra la ricerca delle super classi, qualsiasi classe viene trovata non serializzabile, il costruttore predefinito verrà utilizzato per allocare un’istanza in memoria.
Inoltre, prima di continuare con la ricostruzione dell’oggetto, la JVM controlla se il serialVersionUID menzionato nel flusso di byte corrisponde al serialVersionUID della classe di quell’oggetto. Se non corrisponde, viene generata‘ InvalidClassException’.,
Per saperne di più: SerialVersionUID in java e relativi fatti veloci
Così fino ad ora abbiamo ottenuto l’istanza si trova in memoria utilizzando uno dei costruttore predefinito di superclasse. Si noti che dopo questo nessun costruttore verrà chiamato per qualsiasi classe. Dopo aver eseguito super class constructor, JVM legge il flusso di byte e usa i metadati dell’istanza per impostare le informazioni sul tipo e altre meta informazioni dell’istanza.,
Dopo aver creato l’istanza vuota, JVM prima imposta i suoi campi statici e quindi richiama internamente il metodo readObject() predefinito che è responsabile dell’impostazione dei valori dal flusso di byte all’istanza vuota.
Per saperne di più: Codice di esempio per readObject() e writeObject ()
Dopo il metodo readObject() è completato, il processo di deserializzazione è fatto e si è pronti a lavorare con nuova istanza deserializzata.