Mes deux cents de mon propre blog:
Voici une explication détaillée de la sérialisation : (mon propre blog)
Sérialisation:
La sérialisation est le processus de persistance de l'état d'un objet. Il est représenté et stocké sous la forme d'une séquence d'octets. Cela peut être stocké dans un fichier. Le processus pour lire l'état de l'objet à partir du fichier et le restaurer est appelé désérialisation.
Quel est le besoin de sérialisation?
Dans l'architecture moderne, il est toujours nécessaire de stocker l'état de l'objet, puis de le récupérer. Par exemple, dans Hibernate, pour stocker un objet, nous devons rendre la classe Serializable. Ce qu'il fait, c'est qu'une fois que l'état de l'objet est enregistré sous forme d'octets, il peut être transféré vers un autre système qui peut alors lire l'état et récupérer la classe. L'état de l'objet peut provenir d'une base de données ou d'un jvm différent ou d'un composant distinct. Avec l'aide de la sérialisation, nous pouvons récupérer l'état de l'objet.
Exemple de code et explication:
Voyons d'abord la classe d'objets:
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;
}
}
Dans le code ci-dessus, on peut voir que la classe Item implémente Serializable .
Il s'agit de l'interface qui permet à une classe d'être sérialisable.
Maintenant, nous pouvons voir qu'une variable appelée serialVersionUID est initialisée en variable Long. Ce nombre est calculé par le compilateur en fonction de l'état de la classe et des attributs de classe. C'est le nombre qui aidera le jvm à identifier l'état d'un objet lorsqu'il lit l'état de l'objet à partir d'un fichier.
Pour cela, nous pouvons consulter la documentation Oracle officielle:
Le runtime de sérialisation associe à chaque classe sérialisable un numéro de version, appelé serialVersionUID, qui est utilisé lors de la désérialisation pour vérifier que l'expéditeur et le récepteur d'un objet sérialisé ont chargé des classes pour cet objet qui sont compatibles par rapport à la sérialisation. Si le récepteur a chargé une classe pour l'objet qui a un serialVersionUID différent de celui de la classe de l'expéditeur correspondant, la désérialisation entraînera une InvalidClassException. Une classe sérialisable peut déclarer son propre serialVersionUID explicitement en déclarant un champ nommé "serialVersionUID" qui doit être statique, final et de type long: ANY-ACCESS-MODIFIER statique final long serialVersionUID = 42L; Si une classe sérialisable ne déclare pas explicitement un serialVersionUID, le runtime de sérialisation calcule alors une valeur serialVersionUID par défaut pour cette classe en fonction de divers aspects de la classe, comme décrit dans la spécification de sérialisation d'objet Java (TM). Cependant, il est fortement recommandé que toutes les classes sérialisables déclarent explicitement les valeurs serialVersionUID, car le calcul serialVersionUID par défaut est très sensible aux détails de classe qui peuvent varier en fonction des implémentations du compilateur et peuvent ainsi entraîner des InvalidClassExceptions inattendues lors de la désérialisation. Par conséquent, pour garantir une valeur serialVersionUID cohérente sur différentes implémentations du compilateur java, une classe sérialisable doit déclarer une valeur serialVersionUID explicite. Il est également fortement conseillé que les déclarations explicites serialVersionUID utilisent le modificateur privé dans la mesure du possible,
Si vous avez remarqué qu'il existe un autre mot-clé que nous avons utilisé, qui est transitoire .
Si un champ n'est pas sérialisable, il doit être marqué comme transitoire. Ici, nous avons marqué le itemCostPrice comme transitoire et ne voulons pas qu'il soit écrit dans un fichier
Voyons maintenant comment écrire l'état d'un objet dans le fichier, puis le lire à partir de 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();
}
}
}
Dans ce qui précède, nous pouvons voir un exemple de sérialisation et de désérialisation d'un objet.
Pour cela, nous avons utilisé deux classes. Pour sérialiser l'objet, nous avons utilisé ObjectOutputStream. Nous avons utilisé la méthode writeObject pour écrire l'objet dans le fichier.
Pour la désérialisation, nous avons utilisé ObjectInputStream qui lit à partir de l'objet à partir du fichier. Il utilise readObject pour lire les données d'objet du fichier.
La sortie du code ci-dessus serait comme:
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]
Notez que itemCostPrice de l'objet désérialisé est nul car il n'a pas été écrit.
Nous avons déjà discuté des bases de la sérialisation Java dans la partie I de cet article.
Maintenant, discutons-en profondément et comment cela fonctionne.
Commençons d'abord par le serialversionuid.
Le serialVersionUID est utilisé comme contrôle de version dans une classe Serializable.
Si vous ne déclarez pas explicitement un serialVersionUID, JVM le fera automatiquement pour vous, en fonction des différentes propriétés de la classe Serializable.
Algorithme de Java de calcul de serialversionuid (Lire plus de détails ici)
- Le nom de la classe.
- Les modificateurs de classe écrits sous la forme d'un entier 32 bits.
- Le nom de chaque interface trié par nom.
- Pour chaque champ de la classe trié par nom de champ (à l'exception des champs privés statiques et transitoires privés: le nom du champ. Les modificateurs du champ écrits sous la forme d'un entier 32 bits. Le descripteur du champ.
- S'il existe un initialiseur de classe, écrivez ce qui suit: Le nom de la méthode,.
- Le modificateur de la méthode, java.lang.reflect.Modifier.STATIC, écrit sous la forme d'un entier 32 bits.
- Le descripteur de la méthode, () V.
- Pour chaque constructeur non privé trié par nom et signature de méthode: Le nom de la méthode,. Les modificateurs de la méthode écrits sous la forme d'un entier 32 bits. Le descripteur de la méthode.
- Pour chaque méthode non privée triée par nom et signature de méthode: Le nom de la méthode. Les modificateurs de la méthode écrits sous la forme d'un entier 32 bits. Le descripteur de la méthode.
- L'algorithme SHA-1 est exécuté sur le flux d'octets produit par DataOutputStream et produit cinq valeurs de 32 bits sha [0..4]. La valeur de hachage est assemblée à partir des première et seconde valeurs 32 bits du condensé de message SHA-1. Si le résultat du résumé du message, les cinq mots de 32 bits H0 H1 H2 H3 H4, se trouve dans un tableau de cinq valeurs int nommées sha, la valeur de hachage serait calculée comme suit:
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;
Algorithme de sérialisation Java
L'algorithme de sérialisation d'un objet est décrit ci-dessous:
1. Il écrit les métadonnées de la classe associée à une instance.
2. Il écrit récursivement la description de la superclasse jusqu'à ce qu'il trouve java.lang.object .
3. Une fois qu'il a fini d'écrire les informations de métadonnées, il commence alors par les données réelles associées à l'instance. Mais cette fois, cela part de la superclasse la plus haute.
4. Il écrit récursivement les données associées à l'instance, en commençant par la classe la moins superflue jusqu'à la classe la plus dérivée.
Choses à garder à l'esprit:
Les champs statiques d'une classe ne peuvent pas être sérialisés.
public class A implements Serializable{
String s;
static String staticString = "I won't be serializable";
}
Si le serialversionuid est différent dans la classe read, il lèvera une InvalidClassExceptionexception.
Si une classe implémente sérialisable, toutes ses sous-classes seront également sérialisables.
public class A implements Serializable {....};
public class B extends A{...} //also Serializable
Si une classe a une référence d'une autre classe, toutes les références doivent être sérialisables sinon le processus de sérialisation ne sera pas effectué. Dans ce cas, NotSerializableException est levée lors de l'exécution.
Par exemple:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
