Qu'est-ce que la sérialisation d'objet?
https://stackoverflow.com/questions/447898
-
19-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Qu'entend-on par " sérialisation d'objet " Pouvez-vous s'il vous plaît expliquer avec quelques exemples?
La solution
La sérialisation est la conversion d'un objet en une série d'octets, de manière à ce que l'objet puisse être facilement sauvegardé dans un stockage persistant ou transmis en streaming sur un lien de communication. Le flux d'octets peut ensuite être désérialisé - converti en une réplique de l'objet d'origine.
Autres conseils
Vous pouvez considérer la sérialisation comme le processus de conversion d'une instance d'objet en une suite d'octets (binaire ou non, selon l'implémentation).
Cela est très utile lorsque vous souhaitez transmettre des données d'un objet sur le réseau, par exemple d'une machine virtuelle à une autre.
En Java, le mécanisme de sérialisation est intégré à la plate-forme, mais vous devez implémenter l'interface Serializable pour rendre un objet sérialisable.
Vous pouvez également empêcher la sérialisation de certaines données de votre objet en marquant l'attribut comme transitoire .
Enfin, vous pouvez remplacer le mécanisme par défaut et fournir le vôtre; cela peut convenir dans certains cas particuliers. Pour ce faire, vous utilisez l’une des fonctionnalités masquées de java .
Il est important de noter que ce qui devient sérialisé est la " valeur " de l'objet, ou le contenu, et non la définition de la classe. Ainsi, les méthodes ne sont pas sérialisées.
Voici un exemple très basique avec des commentaires pour en faciliter la lecture:
import java.io.*;
import java.util.*;
// This class implements "Serializable" to let the system know
// it's ok to do it. You as programmer are aware of that.
public class SerializationSample implements Serializable {
// These attributes conform the "value" of the object.
// These two will be serialized;
private String aString = "The value of that string";
private int someInteger = 0;
// But this won't since it is marked as transient.
private transient List<File> unInterestingLongLongList;
// Main method to test.
public static void main( String [] args ) throws IOException {
// Create a sample object, that contains the default values.
SerializationSample instance = new SerializationSample();
// The "ObjectOutputStream" class has the default
// definition to serialize an object.
ObjectOutputStream oos = new ObjectOutputStream(
// By using "FileOutputStream" we will
// Write it to a File in the file system
// It could have been a Socket to another
// machine, a database, an in memory array, etc.
new FileOutputStream(new File("o.ser")));
// do the magic
oos.writeObject( instance );
// close the writing.
oos.close();
}
}
Lorsque nous exécutons ce programme, le fichier & "; o.ser &"; est créé et nous pouvons voir ce qui est arrivé derrière.
Si nous modifions la valeur de: someInteger en Integer.MAX_VALUE , par exemple, nous pouvons comparer le résultat pour voir quelle est la différence.
Voici une capture d'écran montrant précisément cette différence:
Pouvez-vous repérer les différences? ;)
Il existe un champ supplémentaire pertinent dans la sérialisation Java: serialversionUID , mais je suppose que cela est déjà trop long pour le couvrir.
Oser répondre à une question de 6 ans en ajoutant simplement une compréhension de très haut niveau pour les débutants en Java
Qu'est-ce que la sérialisation?
Conversion d'un objet en octets et octet en objet (désérialisation).
quand utilise-t-on la sérialisation?
Quand nous voulons persister l’objet. Lorsque nous voulons que l’objet existe au-delà de la durée de vie de la machine virtuelle Java.
Exemple concret:
ATM: lorsque le titulaire du compte tente de retirer de l'argent du serveur via un guichet automatique, ses informations, telles que les détails du retrait, sont sérialisées et envoyées au serveur où les détails sont désérialisés et utilisés pour effectuer des opérations.
Comment la sérialisation est-elle effectuée en Java?
-
Implémenter
java.io.Serializablel'interface (interface de marqueur, donc aucune méthode à implémenter). -
Persistez l'objet: Utilisez
java.io.ObjectOutputStreamla classe, un flux de filtrage enveloppant un flux d'octets de niveau inférieur (pour écrire un objet dans un système de fichiers ou transférer un objet aplati via un fil réseau, puis reconstruit l’autre côté).-
writeObject(<<instance>>)- pour écrire un objet -
readObject()- pour lire un objet sérialisé
-
N'oubliez pas:
Lorsque vous sérialisez un objet, seul son état est enregistré, pas le fichier de classe ni les méthodes de l'objet.
Lorsque vous avez sérialisé un objet de 2 octets, vous voyez un fichier sérialisé de 51 octets.
Indique comment l'objet est sérialisé et désérialisé.
Réponse pour: Comment s'est-il converti en fichier de 51 octets?
- écrit d'abord les données magiques du flux de sérialisation (STREAM_MAGIC = " AC ED " et STREAM_VERSION = version de la machine virtuelle Java).
- Ensuite, il écrit les métadonnées de la classe associées à une instance (longueur de la classe, nom de la classe, serialVersionUID).
- Ensuite, il écrit récursivement les métadonnées de la super-classe jusqu'à ce qu'il trouve
java.lang.Object. - Commence ensuite avec les données réelles associées à l'instance.
- Enfin, écrit les données des objets associés à l’instance, depuis les métadonnées jusqu’au contenu réel.
Si vous souhaitez en savoir plus sur la sérialisation Java, consultez ce lien. .
Modifier : encore un bon link à lire.
Ceci répondra à quelques questions fréquentes:
-
Comment ne pas sérialiser un champ dans la classe.
Ans: utilisez le mot clé transitoire -
Lorsque la classe enfant est sérialisée, la classe parent est-elle sérialisée?
Réponse: Non, si le parent n'est pas étendu, le champ parents de l'interface sérialisable n'est pas sérialisé. -
Lorsque le parent est sérialisé, la classe enfant est-elle sérialisée?
Réponse: Oui, par défaut, les classes enfant sont également sérialisées. -
Comment éviter que la classe enfant ne soit sérialisée?
Ans: a. Redéfinissez les méthodes writeObject et readObject et lancezNotSerializableException.
b. vous pouvez également marquer tous les champs transitoires dans la classe enfant.
- Certaines classes de niveau système telles que Thread, OutputStream et ses sous-classes et Socket ne sont pas sérialisables.
La sérialisation prend un " live " objet en mémoire et le convertir dans un format pouvant être stocké quelque part (par exemple, en mémoire, sur disque) et plus tard & "; désérialisé &"; retour dans un objet en direct.
J'ai aimé la façon dont @OscarRyz présente. Bien que je reste ici, je poursuis la récit de la sérialisation , écrit à l'origine par @amitgupta.
Même si connaître la structure des classes de robots et disposer de données sérialisées, les scientifiques de Earth n'ont pas été en mesure de désérialiser les données, ce qui peut faire fonctionner les robots.
Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:
Les scientifiques de Mars attendaient le paiement complet. Une fois le paiement effectué, les scientifiques de Mars ont communiqué la serialversionUID aux scientifiques de la Terre. Le scientifique de la Terre l'a mis en classe de robot et tout est devenu bien.
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 permettant de lire l'état de l'objet à partir du fichier et de le restaurer s'appelle la désérialisation.
Quel est le besoin de sérialisation?
Dans l'architecture moderne, il est toujours nécessaire de stocker l'état d'un 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 que, une fois que l’objet est sauvegardé sous forme d’octets, il peut être transféré à 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 autre gestionnaire de volume 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 .
C'est l'interface qui permet à une classe d'être sérialisable.
Nous pouvons maintenant voir qu'une variable appelée serialVersionUID est initialisée à la variable Long. Ce nombre est calculé par le compilateur en fonction de l'état de la classe et des attributs de la classe. C'est le numéro qui aidera le JVM à identifier l'état d'un objet lorsqu'il lit l'état de l'objet à partir du fichier.
Pour cela, nous pouvons consulter la documentation officielle d'Oracle:
L'exécution de la sérialisation associe à chaque classe sérialisable un numéro de version, appelé serialVersionUID, utilisé lors de la désérialisation pour vérifier que l'expéditeur et le destinataire d'un numéro de série objet ont chargé pour cet objet des classes compatibles avec respect de la sérialisation. Si le destinataire a chargé une classe pour le objet qui a un serialVersionUID différent de celui du correspondant à la classe de l'expéditeur, la désérialisation entraînera une InvalidClassException. Une classe sérialisable peut déclarer sa 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 un La classe sérialisable ne déclare pas explicitement un serialVersionUID, alors l'exécution de la sérialisation calculera un défaut valeur serialVersionUID pour cette classe en fonction de divers aspects de la classe, comme décrit dans la sérialisation des objets Java (TM) Spécification. Cependant, il est fortement recommandé à tous Les classes sérialisables déclarent explicitement les valeurs serialVersionUID, puisque le calcul par défaut serialVersionUID est très sensible à la classe des détails qui peuvent varier en fonction de l’implémentation du compilateur et peuvent donc inattendues InvalidClassExceptions pendant désérialisation. Par conséquent, pour garantir un numéro de série cohérent valeur à travers différentes implémentations de compilateur java, un sérialisable La classe doit déclarer une valeur serialVersionUID explicite. C'est aussi fortement conseillé que les déclarations serialVersionUID explicites utilisent le modificateur privé dans la mesure du possible, car ces déclarations ne s'appliquent qu'aux la classe qui déclare immédiatement - les champs serialVersionUID ne sont pas utile en tant que membres hérités.
Si vous avez remarqué que nous avons utilisé un autre mot clé, transitoire .
Si un champ n'est pas sérialisable, il doit être marqué comme étant transitoire. Ici, nous avons marqué itemCostPrice comme transitoire et ne souhaitons pas qu'il soit écrit dans un fichier
Voyons maintenant comment écrire l'état d'un objet dans le fichier et 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();
}
}
}
Ci-dessus, 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 l'objet à partir du fichier. Il utilise readObject pour lire les données d'objet à partir 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 null 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.
Discutons-en en profondeur et son fonctionnement.
Commençons par serialversionuid.
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 de diverses propriétés de la classe Serializable.
Algorithme de calcul de série serialionion de Java (Plus de détails ici)
- Le nom de la classe.
- Les modificateurs de classe écrits sous forme d'entier 32 bits.
- Nom de chaque interface triée par nom.
- Pour chaque champ de la classe trié par nom de champ (sauf les champs privés statiques et transitoires privés: nom du champ. les modificateurs du champ écrits sous la forme d'un entier de 32 bits. Le descripteur du champ.
- Si un initialiseur de classe existe, é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 de méthode et signature: nom de la méthode,. Les modificateurs de la méthode écrite 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 de méthode et signature: nom de la méthode. Les modificateurs de la méthode écrite en tant que Nombre 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]. le la valeur de hachage est assemblée à partir des première et seconde valeurs 32 bits du Résumé du message SHA-1. Si le résultat du message est résumé, les cinq Mots 32 bits H0 H1 H2 H3 H4, est 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 permettant de sérialiser un objet est décrit ci-dessous:
1. Il écrit les métadonnées de la classe associée à une instance.
2. Il écrit de manière récursive la description de la superclasse jusqu'à ce qu'il trouve java.lang.object .
3. Une fois l’écriture des informations de métadonnées terminée, elle commence par les données réelles associées à l’instance. Mais cette fois, ça commence à partir de la superclasse supérieure.
4. Il écrit de manière récursive les données associées à l’instance, de la plus petite superclasse à la classe la plus dérivée.
Points à 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 serialversionuid est différent dans la classe de lecture, il générera une exception
InvalidClassException. -
Si une classe implémente sérialisable, toutes ses sous-classes le seront également.
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 Serializable, sinon le processus de sérialisation ne sera pas exécuté.méd. Dans ce cas, NotSerializableException est levée à l'exécution.
Par exemple:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
La sérialisation signifie des objets persistants en Java. Si vous souhaitez enregistrer l'état de l'objet et que vous souhaitez reconstruire l'état ultérieurement (éventuellement dans une autre machine virtuelle Java), vous pouvez utiliser la sérialisation.
Notez que les propriétés d'un objet ne vont être enregistrées. Si vous souhaitez ressusciter l’objet à nouveau, vous devez disposer du fichier de classe, car seules les variables membres seront stockées et non les fonctions membres.
par exemple:
ObjectInputStream oos = new ObjectInputStream(
new FileInputStream( new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();
Searializable est une interface de marqueur qui indique que votre classe est sérialisable. Interface de marqueur signifie qu’il s’agit simplement d’une interface vide et que cette interface avertira la machine virtuelle que cette classe peut être rendue sérialisable.
La sérialisation est le processus de conversion de l'état d'un objet en bits afin qu'il puisse être stocké sur un disque dur. Lorsque vous désérialisez le même objet, il conservera son état ultérieurement. Il vous permet de recréer des objets sans avoir à enregistrer les propriétés des objets à la main.
La sérialisation consiste à enregistrer un objet sur un support de stockage (tel qu'un fichier ou une mémoire tampon) ou à le transmettre via une connexion réseau sous forme binaire. Les objets sérialisés sont indépendants de la machine virtuelle Java et peuvent être resérialisés par n'importe quelle machine virtuelle Java. Dans ce cas, le & Quot; en mémoire & Quot; l'état des objets java est converti en un flux d'octets. Ce type de fichier ne peut pas être compris par l'utilisateur. Il s’agit d’un type d’objet spécial, réutilisé par la JVM (Java Virtual Machine). Ce processus de sérialisation d'un objet s'appelle également déflation ou marshalling d'un objet.
L'objet à sérialiser doit implémenter java.io.Serializable Interface.
Le mécanisme de sérialisation par défaut d'un objet écrit la classe de l'objet, la signature de la classe et les valeurs de tous les champs non transitoires et non statiques.
class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,
ObjectOutput étend l’interface DataOutput et ajoute des méthodes de sérialisation des objets et d’écriture d’octets dans le fichier. Le ObjectOutputStream étend java.io.OutputStream et implémente ObjectOutputStream( ) l'interface. Il sérialise des objets, des tableaux et d'autres valeurs dans un flux. Ainsi, le constructeur de FileOuputStream s’écrit:
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));
Le code ci-dessus a été utilisé pour créer l’instance de la classe ObjectInputStream avec le constructeur java.io.InputStream qui prend l’instance de ObjectInput en tant que paramètre.
L’interface FileInputStream est utilisée lors de l’implémentation de la classe ObjectInputStream(). Le <=> est construit pour sérialiser l'objet.
Désérialiser un objet en java
L’opération inverse de la sérialisation est appelée désérialisation, c’est-à-dire que l’extraction des données d’une série d’octets est appelée désérialisation, également appelée gonflement ou déformation.
<=> étend <=> et implémente <=> l'interface. Il désérialise les objets, les tableaux et les autres valeurs d'un flux d'entrée. Ainsi, le constructeur de <=> s’écrit:
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));
Le code ci-dessus du programme crée l'instance de la classe <=> pour désérialiser ce fichier qui a été sérialisé par la classe <=>. Le code ci-dessus crée l'instance à l'aide de l'instance de la classe <=> qui contient l'objet fichier spécifié qui doit être désérialisé car le constructeur <=> a besoin du flux d'entrée.
Serialization est un mécanisme permettant de transformer un graphe d'objets Java en un tableau d'octets destinés au stockage (to disk file) ou à la transmission (across a network), puis en utilisant la désérialisation , nous pouvons restaurer le graphe des objets.
Les graphiques d'objets sont restaurés correctement à l'aide d'un mécanisme de partage de référence. Mais avant de stocker, vérifiez si serialVersionUID du fichier d'entrée / réseau et le fichier .class serialVersionUID sont identiques. Sinon, lancez un java.io.InvalidClassException.
Chaque classe versionnée doit identifier la version de la classe d'origine pour laquelle elle est capable d'écrire des flux et à partir de laquelle elle peut lire. Par exemple, une classe versionnée doit déclarer:
Syntaxe serialVersionUID
// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L;
serialVersionUID est essentiel pour le processus de sérialisation. Mais il est facultatif pour le développeur de l'ajouter dans le fichier source Java. Si aucun serialVersionUID n'est inclus, l'exécution de la sérialisation générera un serialVersionUID et l'associera à la classe. L'objet sérialisé contiendra ce serialVersionUID avec d'autres données.
Remarque - Il est vivement recommandé à toutes les classes sérialisables de déclarer explicitement un serialVersionUID, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations , afin d'éviter tout conflit inattendu entre serialVersionUID lors de la désérialisation. échouer.
Inspection des classes sérialisables
Un objet Java est uniquement sérialisable. si une classe ou l'une de ses superclasses implémente l'interface java.io.Serializable ou sa sous-interface, java.io.Externalizable .
-
Une classe doit implémenter l'interface java.io.Serializable pour pouvoir sérialiser son objet. Serializable est une interface de marqueur utilisée pour informer le compilateur que la classe l'implémentant doit être ajoutée au comportement sérialisable. Ici, la machine virtuelle Java (JVM) est responsable de sa sérialisation automatique.
Mot clé transitoire:
java.io.Serializable interfaceLors de la sérialisation d'un objet, si nous ne voulons pas que certaines données membres de l'objet soient sérialisées, nous pouvons utiliser le modificateur transitoire. Le mot clé transitoire empêchera la sérialisation de ce membre de données.
- Les champs déclarés transitoires ou statiques sont ignorés par le processus de sérialisation.
+--------------+--------+-------------------------------------+ | Flag Name | Value | Interpretation | +--------------+--------+-------------------------------------+ | ACC_VOLATILE | 0x0040 | Declared volatile; cannot be cached.| +--------------+--------+-------------------------------------+ |ACC_TRANSIENT | 0x0080 | Declared transient; not written or | | | | read by a persistent object manager.| +--------------+--------+-------------------------------------+class Employee implements Serializable { private static final long serialVersionUID = 2L; static int id; int eno; String name; transient String password; // Using transient keyword means its not going to be Serialized. } -
L'implémentation de l'interface Externalizable permet à l'objet d'assumer un contrôle total sur le contenu et le format du formulaire sérialisé de l'objet. Les méthodes de l'interface Externalizable, writeExternal et readExternal, sont appelées pour enregistrer et restaurer l'état des objets. Lorsqu'elles sont implémentées par une classe, elles peuvent écrire et lire leur propre état en utilisanttoutes les méthodes de ObjectOutput et ObjectInput. Il est de la responsabilité des objets de gérer tout contrôle de version qui se produit.
class Emp implements Externalizable { int eno; String name; transient String password; // No use of transient, we need to take care of write and read. @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(eno); out.writeUTF(name); //out.writeUTF(password); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.eno = in.readInt(); this.name = in.readUTF(); //this.password = in.readUTF(); // java.io.EOFException } } -
Seuls les objets prenant en charge les interfaces java.io.Serializable ou java.io.Externalizable peuvent être des flux
written to/read from. La classe de chaque objet sérialisable est codée, y compris le nom de la classe et la signature de la classe, les valeurs des champs et des tableaux de l'objet et la fermeture de tout autre objet référencé à partir des objets initiaux.
Exemple sérialisable pour les fichiers
public class SerializationDemo {
static String fileName = "D:/serializable_file.ser";
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
Employee emp = new Employee( );
Employee.id = 1; // Can not Serialize Class data.
emp.eno = 77;
emp.name = "Yash";
emp.password = "confidential";
objects_WriteRead(emp, fileName);
Emp e = new Emp( );
e.eno = 77;
e.name = "Yash";
e.password = "confidential";
objects_WriteRead_External(e, fileName);
/*String stubHost = "127.0.0.1";
Integer anyFreePort = 7777;
socketRead(anyFreePort); //Thread1
socketWrite(emp, stubHost, anyFreePort); //Thread2*/
}
public static void objects_WriteRead( Employee obj, String serFilename ) throws IOException{
FileOutputStream fos = new FileOutputStream( new File( serFilename ) );
ObjectOutputStream objectOut = new ObjectOutputStream( fos );
objectOut.writeObject( obj );
objectOut.close();
fos.close();
System.out.println("Data Stored in to a file");
try {
FileInputStream fis = new FileInputStream( new File( serFilename ) );
ObjectInputStream ois = new ObjectInputStream( fis );
Object readObject;
readObject = ois.readObject();
String calssName = readObject.getClass().getName();
System.out.println("Restoring Class Name : "+ calssName); // InvalidClassException
Employee emp = (Employee) readObject;
System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password);
ois.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static void objects_WriteRead_External( Emp obj, String serFilename ) throws IOException {
FileOutputStream fos = new FileOutputStream(new File( serFilename ));
ObjectOutputStream objectOut = new ObjectOutputStream( fos );
obj.writeExternal( objectOut );
objectOut.flush();
fos.close();
System.out.println("Data Stored in to a file");
try {
// create a new instance and read the assign the contents from stream.
Emp emp = new Emp();
FileInputStream fis = new FileInputStream(new File( serFilename ));
ObjectInputStream ois = new ObjectInputStream( fis );
emp.readExternal(ois);
System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password);
ois.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
Exemple sérialisable sur le réseau
Distribution de l'état de l'objet dans différents espaces d'adressage, soit dans différents processus sur le même ordinateur, ou même dans plusieurs ordinateurs connectés via un réseau, mais qui fonctionnent ensemble en partageant des données et en invoquant des méthodes.
/**
* Creates a stream socket and connects it to the specified port number on the named host.
*/
public static void socketWrite(Employee objectToSend, String stubHost, Integer anyFreePort) {
try { // CLIENT - Stub[marshalling]
Socket client = new Socket(stubHost, anyFreePort);
ObjectOutputStream out = new ObjectOutputStream(client.getOutputStream());
out.writeObject(objectToSend);
out.flush();
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// Creates a server socket, bound to the specified port.
public static void socketRead( Integer anyFreePort ) {
try { // SERVER - Stub[unmarshalling ]
ServerSocket serverSocket = new ServerSocket( anyFreePort );
System.out.println("Server serves on port and waiting for a client to communicate");
/*System.in.read();
System.in.read();*/
Socket socket = serverSocket.accept();
System.out.println("Client request to communicate on port server accepts it.");
ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
Employee objectReceived = (Employee) in.readObject();
System.out.println("Server Obj : "+ objectReceived.name );
socket.close();
serverSocket.close();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
@see
La sérialisation est le processus de conversion d'un objet Java en tableau d'octets, puis de nouveau en objet avec son état préservé. Utile pour diverses choses comme l'envoi d'objets sur le réseau ou la mise en cache d'objets sur le disque.
Lisez-en davantage sur ce court article qui explique assez bien la programmation du processus. , puis passez à Serializable javadoc . Vous pouvez également être intéressé par la lecture de .
Renvoyez le fichier sous forme d'objet: http://www.tutorialspoint.com/java/ java_serialization.htm
import java.io.*;
public class SerializeDemo
{
public static void main(String [] args)
{
Employee e = new Employee();
e.name = "Reyan Ali";
e.address = "Phokka Kuan, Ambehta Peer";
e.SSN = 11122333;
e.number = 101;
try
{
FileOutputStream fileOut =
new FileOutputStream("/tmp/employee.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();
System.out.printf("Serialized data is saved in /tmp/employee.ser");
}catch(IOException i)
{
i.printStackTrace();
}
}
}
import java.io.*;
public class DeserializeDemo
{
public static void main(String [] args)
{
Employee e = null;
try
{
FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized Employee...");
System.out.println("Name: " + e.name);
System.out.println("Address: " + e.address);
System.out.println("SSN: " + e.SSN);
System.out.println("Number: " + e.number);
}
}
| * | Sérialisation d'une classe: Conversion d'un objet en octets et octet en objet (Désérialisation).
class NamCls implements Serializable
{
int NumVar;
String NamVar;
}
| = > La sérialisation d'objet est un processus de conversion de l'état d'un objet en une suite d'octets.
- | - > Implémentez-le lorsque vous souhaitez que l'objet existe au-delà de la durée de vie de la machine virtuelle Java.
- | - > L'objet sérialisé peut être stocké dans la base de données.
- | - > Les objets sérialisables ne peuvent pas être lus et compris par les humains, nous pouvons donc assurer la sécurité.
| = > La désérialisation d'objet est le processus consistant à obtenir l'état d'un objet et à le stocker dans un objet (java.lang.Object).
- | - > Avant de stocker son état, il vérifie si serialVersionUID du fichier d'entrée / réseau et du fichier .class serialVersionUID sont identiques.
& amp; nbsp & amp; nbspSi vous ne lancez pas java.io.InvalidClassException.
| = > Un objet Java n’est sérialisable que si sa classe ou l’une de ses superclasses
- implémente l'interface java.io.Serializable ou
- sa sous-interface, java.io.Externalizable.
| = > Les champs statiques d'une classe ne peuvent pas être sérialisés.
class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}
| = > Si vous ne souhaitez pas sérialiser une variable d'une classe, utilisez le mot clé transitoire
class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}
| = > Si une classe implémente sérialisable, toutes ses sous-classes le seront également.
| = > Si une classe a une référence d'une autre classe, toutes les références doivent être Serializable, sinon le processus de sérialisation ne sera pas exécuté. Dans ce cas, une exception NotSerializableException est levée à l'exécution.
