I miei due centesimi dal mio blog:
Ecco una spiegazione dettagliata della serializzazione : (il mio blog)
serializzazione:
La serializzazione è il processo di persistenza dello stato di un oggetto. È rappresentato e memorizzato sotto forma di una sequenza di byte. Questo può essere memorizzato in un file. Il processo per leggere lo stato dell'oggetto dal file e ripristinarlo si chiama deserializzazione.
Qual è la necessità della serializzazione?
Nell'architettura moderna, è sempre necessario memorizzare lo stato dell'oggetto e quindi recuperarlo. Ad esempio in Hibernate, per memorizzare un oggetto dovremmo rendere la classe serializzabile. Ciò che fa è che una volta salvato lo stato dell'oggetto sotto forma di byte, può essere trasferito su un altro sistema che può quindi leggere dallo stato e recuperare la classe. Lo stato dell'oggetto può provenire da un database o da un jvm diverso o da un componente separato. Con l'aiuto della serializzazione possiamo recuperare lo stato dell'Oggetto.
Esempio di codice e spiegazione:
Per prima cosa diamo un'occhiata alla classe di oggetti:
public class Item implements Serializable{
/**
* This is the Serializable class
*/
private static final long serialVersionUID = 475918891428093041L;
private Long itemId;
private String itemName;
private transient Double itemCostPrice;
public Item(Long itemId, String itemName, Double itemCostPrice) {
super();
this.itemId = itemId;
this.itemName = itemName;
this.itemCostPrice = itemCostPrice;
}
public Long getItemId() {
return itemId;
}
@Override
public String toString() {
return "Item [itemId=" + itemId + ", itemName=" + itemName + ", itemCostPrice=" + itemCostPrice + "]";
}
public void setItemId(Long itemId) {
this.itemId = itemId;
}
public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}
public Double getItemCostPrice() {
return itemCostPrice;
}
public void setItemCostPrice(Double itemCostPrice) {
this.itemCostPrice = itemCostPrice;
}
}
Nel codice sopra si può vedere che la classe Item implementa Serializable .
Questa è l'interfaccia che consente a una classe di essere serializzabile.
Ora possiamo vedere una variabile chiamata serialVersionUID inizializzata su Variabile lunga. Questo numero viene calcolato dal compilatore in base allo stato della classe e agli attributi della classe. Questo è il numero che aiuterà jvm a identificare lo stato di un oggetto quando legge lo stato dell'oggetto dal file.
Per questo possiamo dare un'occhiata alla documentazione Oracle ufficiale:
Il runtime di serializzazione associa a ciascuna classe serializzabile un numero di versione, chiamato serialVersionUID, che viene utilizzato durante la deserializzazione per verificare che il mittente e il destinatario di un oggetto serializzato abbiano caricato classi per quell'oggetto compatibili rispetto alla serializzazione. Se il destinatario ha caricato una classe per l'oggetto che ha un serialVersionUID diverso da quello della classe del mittente corrispondente, la deserializzazione si tradurrà in InvalidClassException. Una classe serializzabile può dichiarare esplicitamente la propria serialVersionUID dichiarando esplicitamente un campo denominato "serialVersionUID" che deve essere statico, finale e di tipo lungo: ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L; Se una classe serializzabile non dichiara esplicitamente un serialVersionUID, quindi il runtime di serializzazione calcolerà un valore serialVersionUID predefinito per quella classe in base a vari aspetti della classe, come descritto nelle Specifiche di serializzazione degli oggetti Java (TM). Tuttavia, si raccomanda vivamente che tutte le classi serializzabili dichiarino esplicitamente i valori serialVersionUID, poiché il calcolo serialVersionUID predefinito è altamente sensibile ai dettagli della classe che possono variare a seconda delle implementazioni del compilatore e può quindi provocare eccezioni InvalidClassException impreviste durante la deserializzazione. Pertanto, per garantire un valore serialVersionUID coerente tra le diverse implementazioni del compilatore java, una classe serializzabile deve dichiarare un valore serialVersionUID esplicito. Si consiglia inoltre vivamente che dichiarazioni esplicite serialVersionUID utilizzino il modificatore privato ove possibile,
Se hai notato che abbiamo usato un'altra parola chiave che è temporanea .
Se un campo non è serializzabile, deve essere contrassegnato come transitorio. Qui abbiamo contrassegnato l' articoloCostPrice come transitorio e non vogliamo che sia scritto in un file
Ora diamo un'occhiata a come scrivere lo stato di un oggetto nel file e quindi leggerlo da lì.
public class SerializationExample {
public static void main(String[] args){
serialize();
deserialize();
}
public static void serialize(){
Item item = new Item(1L,"Pen", 12.55);
System.out.println("Before Serialization" + item);
FileOutputStream fileOut;
try {
fileOut = new FileOutputStream("/tmp/item.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(item);
out.close();
fileOut.close();
System.out.println("Serialized data is saved in /tmp/item.ser");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void deserialize(){
Item item;
try {
FileInputStream fileIn = new FileInputStream("/tmp/item.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
item = (Item) in.readObject();
System.out.println("Serialized data is read from /tmp/item.ser");
System.out.println("After Deserialization" + item);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
In quanto sopra possiamo vedere un esempio di serializzazione e deserializzazione di un oggetto.
Per questo abbiamo usato due classi. Per serializzare l'oggetto abbiamo usato ObjectOutputStream. Abbiamo usato il metodo writeObject per scrivere l'oggetto nel file.
Per la deserializzazione abbiamo usato ObjectInputStream che legge dall'oggetto dal file. Utilizza readObject per leggere i dati dell'oggetto dal file.
L'output del codice sopra sarebbe simile a:
Before SerializationItem [itemId=1, itemName=Pen, itemCostPrice=12.55]
Serialized data is saved in /tmp/item.ser
After DeserializationItem [itemId=1, itemName=Pen, itemCostPrice=null]
Si noti che itemCostPrice dall'oggetto deserializzato è null quanto non è stato scritto.
Abbiamo già discusso le basi della serializzazione Java nella parte I di questo articolo.
Ora discutiamolo a fondo e come funziona.
Per prima cosa iniziamo con il serialversionuid.
il serialVersionUID viene utilizzato come controllo di versione in una classe Serializable.
Se non dichiari esplicitamente un serialVersionUID, JVM lo farà automaticamente per te, in base a varie proprietà della classe Serializable.
Algorithm of Calculating serialversionuid di Java (Leggi maggiori dettagli qui)
- Il nome della classe
- I modificatori di classe scritti come un intero a 32 bit.
- Il nome di ciascuna interfaccia ordinata per nome.
- Per ogni campo della classe ordinato per nome campo (eccetto i campi transitori privati statici e privati: il nome del campo. I modificatori del campo scritti come un numero intero a 32 bit. Il descrittore del campo.
- Se esiste un inizializzatore di classe, scrivere quanto segue: Il nome del metodo,.
- Il modificatore del metodo, java.lang.reflect.Modifier.STATIC, scritto come un numero intero a 32 bit.
- Il descrittore del metodo, () V.
- Per ogni costruttore non privato ordinato per nome e firma del metodo: Il nome del metodo,. I modificatori del metodo scritti come un numero intero a 32 bit. Il descrittore del metodo.
- Per ogni metodo non privato ordinato per nome e firma del metodo: il nome del metodo. I modificatori del metodo scritti come un numero intero a 32 bit. Il descrittore del metodo.
- L'algoritmo SHA-1 viene eseguito sul flusso di byte prodotto da DataOutputStream e produce cinque valori a 32 bit sha [0..4]. Il valore hash viene assemblato dal primo e dal secondo valore a 32 bit del digest del messaggio SHA-1. Se il risultato del digest del messaggio, le cinque parole a 32 bit H0 H1 H2 H3 H4, si trova in una matrice di cinque valori int chiamati sha, il valore di hash verrebbe calcolato come segue:
long hash = ((sha[0] >>> 24) & 0xFF) |
> ((sha[0] >>> 16) & 0xFF) << 8 |
> ((sha[0] >>> 8) & 0xFF) << 16 |
> ((sha[0] >>> 0) & 0xFF) << 24 |
> ((sha[1] >>> 24) & 0xFF) << 32 |
> ((sha[1] >>> 16) & 0xFF) << 40 |
> ((sha[1] >>> 8) & 0xFF) << 48 |
> ((sha[1] >>> 0) & 0xFF) << 56;
Algoritmo di serializzazione di Java
L'algoritmo per serializzare un oggetto è descritto di seguito:
1. Scrive i metadati della classe associata a un'istanza.
2. Scrive ricorsivamente la descrizione della superclasse fino a quando non trova java.lang.object .
3. Una volta terminata la scrittura delle informazioni sui metadati, inizia con i dati effettivi associati all'istanza. Ma questa volta, inizia dalla superclasse più in alto.
4. Scrive in modo ricorsivo i dati associati all'istanza, a partire dalla superclasse minima alla classe più derivata.
Cose da tenere a mente:
I campi statici in una classe non possono essere serializzati.
public class A implements Serializable{
String s;
static String staticString = "I won't be serializable";
}
Se il serialversionuid è diverso nella classe read genererà InvalidClassExceptionun'eccezione.
Se una classe implementa serializzabile, anche tutte le sue sottoclassi saranno serializzabili.
public class A implements Serializable {....};
public class B extends A{...} //also Serializable
Se una classe ha un riferimento di un'altra classe, tutti i riferimenti devono essere serializzabili altrimenti il processo di serializzazione non verrà eseguito. In tal caso, NotSerializableException viene generato in fase di esecuzione.
Per esempio:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
