Qu'est-ce que sérialisation d'un objet? [dupliquer]

Vous pouvez considérer la sérialisation comme le processus de conversion d'une instance d'objet en une séquence d'octets (qui peut être binaire ou non selon l'implémentation).

Il est très utile lorsque vous souhaitez transmettre des données d'un objet à travers le réseau, par exemple d'une JVM à 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 aussi empêchez la sérialisation de certaines données de votre objet en marquant l'attribut comme transient.

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 cachées dans java .

Il est important de noter que ce qui est sérialisé est la "valeur" de l'objet, ou le contenu, et non la définition de classe. Ainsi, les méthodes ne sont pas sérialisées.

Voici un très échantillon de base avec commentaires pour faciliter sa 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 s'est passé derrière.

Si nous changeons la valeur de: someInteger, par exemple Entier.MAX_VALUE , nous pouvons comparer la sortie 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 y a un champ pertinent supplémentaire dans la sérialisation Java: Le serialversionUID mais je suppose que c'est déjà trop long pour le couvrir.

Oser répondre à une question vieille de 6 ans, en ajoutant juste une compréhension de très haut niveau pour les personnes novices en Java

Qu'est-ce que la sérialisation?

Conversion d'un objet en octets et d'octets en objet (désérialisation).

Quand la sérialisation est-elle utilisée?

Lorsque nous voulons conserver l'objet. Lorsque nous voulons que l'objet existe au-delà de la durée de vie de la JVM.

Exemple du monde réel:

ATM: Lorsque le titulaire du compte essaie de retirer de l'argent du serveur via ATM, les informations du titulaire du compte telles que les détails de retrait seront 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 effectuée en java.

1. Implémenter java.io.Serializable interface (interface de marqueur donc pas de méthode à implémenter).

2. Persister l'objet: Utilisez la classe java.io.ObjectOutputStream, un flux de filtre qui est un wrapper autour d'un octet de niveau inférieur flux (pour écrire un objet dans des systèmes de fichiers ou transférer un objet aplati sur un fil réseau et reconstruit de l'autre côté).

   • writeObject(<<instance>>) - pour écrire un objet
   • readObject() - pour lire un Objet sérialisé

Rappelez-vous:

Lorsque vous sérialisez un objet, seul l'état de l'objet sera enregistré, pas le fichier de classe ou 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.

Étapes de la sérialisation et de la désérialisation de l'objet.

Réponse à: 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 JVM).
• Ensuite, il écrit les métadonnées de la classe associée à une instance (longueur de la classe, nom de la classe, serialVersionUID).
• Ensuite, il écrit récursivement les métadonnées de la superclasse jusqu'à ce qu'il trouve java.lang.Object.
• commence alors par les données réelles associées à l'instance.
• écrit enfin les données des objets associés à l'instance à partir des métadonnées vers le contenu réel.

Si vous êtes intéressé par plus d'informations dans le département sur la sérialisation Java, veuillez vérifier ce lien.

Edit : Un bon lien lire.

Cela répondra à quelques questions fréquentes:

1. Comment ne pas sérialiser un champ dans la classe.
   Ans: utiliser le mot-clé transitoire

2. Lorsque la classe enfant est sérialisé n'classe parente être sérialisé?
   Ans: Non, si le parent n'étend pas le champ parents de l'interface sérialisable, il n'est pas sérialisé.

3. Lorsque le parent est sérialisé, la classe enfant est-elle sérialisée?
   Ans: Oui, par défaut, la classe enfant est également sérialisée.

4. Comment éviter que la classe enfant ne soit sérialisée?
   Réponse: une. Remplacer Méthode writeObject et readObject et lancer NotSerializableException.
   

   B. vous pouvez également marquer tous les champs transitoires dans la classe enfant.

5. Certaines classes au niveau système telles que Thread, OutputStream et ses sous-classes, et Socket ne sont pas sérialisables.
   

La sérialisation consiste à prendre un objet "vivant" en mémoire et à le convertir dans un format qui peut être stocké quelque part (par exemple. en mémoire, sur disque) et plus tard "désérialisé" dans un objet vivant.

J'ai aimé la façon dont @OscarRyz présente. Bien qu'ici je continue l'histoire de la sérialisation qui a été écrite à l'origine par @amitgupta.

Bien que connaissant la structure des classes de robots et ayant sérialisé les données, les scientifiques de la Terre n'ont pas été en mesure de désérialiser les données qui peuvent 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 partagé le serialversionUID avec Terre des scientifiques. Le scientifique de la Terre l'a mis en classe robot et tout est devenu bien.

La sérialisation signifie la persistance d'objets en java. Si vous souhaitez enregistrer l'état de l'objet et que vous souhaitez reconstruire l'état plus tard (peut-être dans une autre JVM), la sérialisation peut être utilisée.

Notez que les propriétés d'un objet ne seront enregistrées que. Si vous voulez ressusciter l'objet à nouveau, vous devriez avoir le fichier de classe, car les variables membres seulement 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();

Le Searializable est une interface de marqueur qui marque que votre classe est sérialisable. L'interface de marqueur signifie qu'il s'agit simplement d'une interface vide et que l'utilisation de cette interface informera la JVM que cette classe peut être sérialisable.

Mes deux cents de mon propre blog:

Voici une explication détaillée de la Sérialisation: (mon propre blog)

La Sérialisation:

La sérialisation est le processus de persistance de l'état d'un objet. Il est représenté et stockées sous la forme d'une séquence d'octets. Ceci 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 La 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 Sérialisable. Ce qu'il fait, c'est qu'une fois que l'état de l'objet est enregistré sous la forme d'octets, il peut être transféré vers un autre système qui peut ensuite lire à partir de l'état et récupérer la classe. L'état de l'objet peut provenir d'une base de données ou d'une jvm différente ou d'un composant séparé. Avec l'aide de Sérialisation nous pouvons récupérer l'état de l'objet.

Exemple de code et explication:

Jetons d'abord un coup d'œil à la classe Item:

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 Item classe implémente Serializable.

C'est l'interface qui permet à une classe sérialisable.

Maintenant, nous pouvons voir une variable appelée serialVersionUID est initialisée en variable longue. Ce nombre est calculé par le compilateur basé sur l'état de la classe et les attributs de classe. C'est le nombre qui aidera la jvm à identifier l'état d'un objet lorsqu'elle lit l'état de l'objet à partir du fichier.

Pour cela, nous pouvons consulter la documentation officielle d'Oracle:

Le runtime de sérialisation s'associe à chaque classe sérialisable a numéro de version, appelé serialVersionUID, qui est utilisé pendant désérialisation pour vérifier que l'expéditeur et le destinataire objet avoir chargé des classes pour cet objet qui sont compatibles avec respect de la sérialisation. Si le récepteur a chargé une classe pour le objet qui a un serialVersionUID différent de celui du la classe de l'expéditeur correspondant, puis la désérialisation entraînera un InvalidClassException. Une classe sérialisable peut déclarer la sienne serialVersionUID explicitement en déclarant un champ nommé "serialVersionUID" qui doit être statique, final et de type long: TOUT-ACCESS-MODIFICATEUR statique finale longue serialVersionUID = 42L; Si un la classe serializable ne déclare pas explicitement un serialVersionUID, ensuite, le runtime de sérialisation calculera une valeur par défaut Valeur serialVersionUID pour cette classe basée sur divers aspects de la classe, comme décrit dans la sérialisation de l'objet Java(TM) Spécification. Cependant, il est fortement recommandé que tous les classes sérialisables déclarent explicitement les valeurs serialVersionUID, puisque le calcul serialVersionUID par défaut est très sensible à la classe des détails qui peuvent varier en fonction des implémentations du compilateur, et peuvent ainsi entraîner des InvalidClassExceptions inattendues pendant désérialisation. Par conséquent, pour garantir un serialVersionUID cohérent valeur à travers différentes implémentations de compilateur java, une sérialisable la classe doit déclarer une valeur serialVersionUID explicite. Il est également fortement conseillé que les déclarations serialVersionUID explicites utilisent le modificateur privé lorsque cela est possible, puisque de telles déclarations ne s'appliquent qu'à le déclarer immédiatement les champs class ser serialVersionUID ne sont pas utile en tant que membres hérités.

Si vous avez remarqué qu'il y a un autre mot-clé que nous avons utilisé qui est transient.

Si un champ n'est pas sérialisable, il doit être marqué transitoire. Ici, nous avons marqué le itemCostPrice {[34] } 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 y.

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 à partir de l'objet à partir du fichier. Il utilise readObject pour lire les données de l'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 les itemCostPrice de l'objet désérialisé est null, comme 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 par le serialversionuid.

Le serialVersionUID est utilisé comme contrôle de version dans une classe Serializable.

Si vous ne déclarez pas explicitement serialVersionUID, JVM le fera pour vous automatiquement, en fonction de diverses propriétés de la classe Serializable.

Algorithme de Java de calcul serialversionuid (Lire plus de détails ici)

1. Le nom de la classe.
   1. Les modificateurs de classe écrits comme un entier 32 bits.
   2. Le nom de chaque interface triée par nom.
   3. Pour chaque champ de la classe trié par nom de champ (sauf les champs statiques privés et transitoires privés: Le nom du champ. Le modificateurs du champ écrit sous la forme d'un entier 32 bits. Descripteur du champ.
   4. Si un initialiseur de classe existe, écrivez ce qui suit: Le nom de la méthode, .
   5. Le modificateur de la méthode, java.lang.refléter.Modificateur.STATIQUE, écrit comme un entier 32 bits.
   6. le descripteur de La méthode, ()V.
   7. Pour chaque constructeur non privé trié par nom de méthode et signature: Le nom de la méthode, . Modificateur de la méthode écrite comme un entier 32 bits. Le descripteur de la méthode.
   8. Pour chaque méthode non privée triée par nom de méthode et signature: Le nom de la méthode. Les modificateurs de la méthode écrite comme un entier 32 bits. Le descripteur de la méthode.
   9. L'algorithme SHA-1 est exécuté sur le flux d'octets produit par DataOutputStream et produit cinq valeurs 32 bits sha[0..4]. Le la valeur de hachage est assemblée à partir des première et deuxième valeurs 32 bits du Résumé du message SHA - 1. Si le résultat du message digère, 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 de Java

L'algorithme pour sérialiser un objet est décrit comme suit:
1. Il écrit les métadonnées de la classe associée à une instance.
2. Il écrit récursivement le description de la superclasse jusqu'à ce qu'elle trouve java.lang.objet.
3. Une fois qu'il a fini d'écrire les informations de métadonnées, il commence par les données réelles associées à l'instance. Mais cette fois, il commence à partir de la superclasse la plus élevée.
4. Il écrit récursivement les données associées à l'instance, en commençant par la superclasse la plus faible à la classe la plus dérivée.

Les Choses À Garder À L'Esprit:

1. Champs Statiques dans une classe ne peut pas être sérialisé.

   public class A implements Serializable{
        String s;
        static String staticString = "I won't be serializable";
   }
   

2. Si le serialversionuid est différent dans la classe read, il lancera une exception InvalidClassException.

3. Si une classe implémente serializable alors toutes ses sous-classes seront également serializable.

   public class A implements Serializable {....};
   
   public class B extends A{...} //also Serializable
   

4. 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 {[34] } est lancé à Runtime.

Par exemple:

public class B{
     String s,
     A a; // class A needs to be serializable i.e. it must implement Serializable
}

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 plus tard. Il vous permet de recréer des objets sans avoir à enregistrer les propriétés des objets à la main.

Http://en.wikipedia.org/wiki/Serialization

La sérialisation est le processus qui consiste à enregistrer un objet dans un support de stockage (tel qu'un fichier ou un tampon mémoire) ou à le transmettre via une connexion réseau sous forme binaire. Les objets sérialisés sont indépendants de la JVM et peuvent être re-sérialisés par n'importe quelle JVM. Dans ce cas, l'état des objets java "en mémoire" est converti en un flux d'octets. Ce type de fichier ne peut pas être comprise par l'utilisateur. C'est un type spécial d'objet, c'est-à-dire réutilisé par la JVM (Machine virtuelle Java). Ce processus de la sérialisation d'un objet est également appelée dégonflage ou marshalling un objet.

L'objet à sérialiser doit implémenter l'interface java.io.Serializable. Le mécanisme de sérialisation par défaut d'un objet écrit la classe de l'objet, la signature de classe et les valeurs de tous les champs non transitoires et non statiques.

class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,

ObjectOutput interface étend l'interface DataOutput et ajoute des méthodes pour sérialiser des objets et écrire des octets dans le fichier. Le ObjectOutputStream étend java.io.OutputStream et implémente ObjectOutput interface. Il sérialise des objets, des tableaux et d'autres valeurs dans un flux. Ainsi, le constructeur de ObjectOutputStream s'écrit:

ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));

Le code ci-dessus a été utilisé pour créer l'instance de la classe ObjectOutput avec le constructeur ObjectOutputStream( ) qui prend l'instance du FileOuputStream comme paramètre.

L'interface ObjectOutput est utilisée en implémentant la classe ObjectOutputStream. Le ObjectOutputStream est construit pour sérialiser l'objet.

la Désérialisation d'un Objet en java

L'opération inverse de la sérialisation est appelée désérialisation, c'est-à-dire que pour extraire les données d'une série d'octets, on parle de désérialisation, également appelée gonflage ou décompression.

ObjectInputStream étend java.io.InputStream et implémente l'interface ObjectInput. Il désérialise les objets, les tableaux et autres valeurs d'un flux d'entrée. Ainsi, le constructeur de ObjectInputStream s'écrit:

ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));

Le code ci-dessus du programme crée l'instance de la classe ObjectInputStream pour désérialiser ce fichier qui avait été sérialisé par la classe ObjectInputStream. Le code ci-dessus crée l'instance en utilisant l'instance de la classe FileInputStream qui contient l'objet file spécifié qui doit être désérialisé car le constructeur ObjectInputStream() a besoin du flux d'entrée.

La sérialisation est le processus de transformation 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 de choses sur le disque.

Lire la suite dece court article qui explique assez bien la programmation d'une partie du processus , puis passez àjavadoc sérialisable . Vous pouvez également être intéressé par la lecture de cette question connexe.

Renvoie le fichier en tant qu'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);
        }
    }

Java Sérialisation D'Un Objet

Serialization c'est un mécanisme pour la transformation d'un graphe d'objets Java dans un tableau d'octets pour le stockage(to disk file) ou de transmission(across a network), puis en utilisant désérialisation, nous pouvons restaurer le graphe d'objets. Les graphes d'objets sont restaurés correctement à l'aide d'un mécanisme de partage. Mais avant de stocker, vérifiez si serialVersionUID de input-file / network et .les fichiers de classe serialVersionUID sont les mêmes. Sinon, lancez un java.io.InvalidClassException.

Chaque classe versionnée doit identifier la version originale de la classe 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 au processus de sérialisation. Mais il est facultatif pour le développeur de l'ajouter dans le fichier source java. Si un serialVersionUID n'est pas inclus, le runtime de sérialisation générera un serialVersionUID et l'associera à la classe. L'objet sérialisé contiendra ce serialVersionUID avec d'autres données.

Note - Il est fortement recommandé que toutes les classes sérialisables déclarent explicitement un serialVersionUID, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations, et peut ainsi entraîner des conflits serialVersionUID inattendus pendant la désérialisation, provoquant la désérialisation à échouer.

Inspection des classes sérialisables

Un objet Java est seulement 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 java.io.Serializable interface afin de sérialiser son objet avec succès. Serializable est un marqueur interface et utilisé pour informer le compilateur que la classe qui l'implémente doit être ajoutée comportement sérialisable. Ici, la machine virtuelle Java (JVM) est responsable de sa sérialisation automatique.

  Mot clé Transitoire: java.io.Serializable interface

  Lors de la sérialisation d'un objet, si nous ne voulons pas que certains membres de données de l'objet soient sérialisés, nous pouvons utiliser le modificateur transitoire. Le mot-clé transitoire empêchera ce membre de données d'être sérialisé.

  • Les champs déclarés comme transitoires ou statiques sont ignorés par le processus de sérialisation.

  TRANSITOIRE & VOLATILE

  +--------------+--------+-------------------------------------+
  |  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 Externalisable permet à l'objet d'assumer un contrôle complet sur le contenu et le format de la forme sérialisée de l'objet. Les méthodes de l'interface Externalisable, writeExternal et readExternal, sont appelées pour enregistrer et restaurer le les objets de l'état. Lorsqu'ils sont implémentés par une classe, ils peuvent écrire et lire leur propre état en utilisant toutes les méthodes de ObjectOutput et ObjectInput. Il est de la responsabilité des objets de gérer tout versionnage 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 l'interface java.io.Serializable ou java.io.Externalizable peuvent être written to/read from flux. La classe de chaque objet sérialisable est codée, y compris le nom de classe et la signature de la classe, les valeurs des champs et des tableaux de l'objet, et la fermeture de tous les autres objets référencés à 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

Distribuer l'état de l'objet dans différents espaces d'adressage, soit dans différents processus sur le même ordinateur, soit même dans plusieurs ordinateurs connectés via un réseau, mais qui fonctionnent ensemble en partageant des données et en invoquant méthode.

• Ordonnancement Des Données
• des Talons et des Squelettes

/**
 * 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();
    }
}

@voir

• la mise en œuvre de Serializable vs Externalizable

|*| Sérialisation d'une classe : Conversion d'un objet en octets et d'octets en objet (désérialisation).

class NamCls implements Serializable
{
    int NumVar;
    String NamVar;
}

|=> Object-Serialization est un processus de conversion de l'état d'un objet en steam d'octets.

• |-> Implémenter lorsque vous voulez que l'objet existe au-delà de la durée de vie de la JVM.
  
• |-> L'objet sérialisé peut être stocké dans la base de données.
  
{[10]|/ - > Serializable-les obects ne peuvent pas être lus et compris par les humains afin que nous puissions réaliser sécurité.

|=> Object-la désérialisation est le processus d'obtention de l'état d'un objet et de son stockage dans un objet(java.lang.Objet).

{[10]| / - > Avant de stocker son état, vérifiez la météo serialVersionUID form input-file/network et.les fichiers de classe serialVersionUID sont les mêmes.
Si vous ne lancez pas java. io. InvalidClassException.

• 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";;
}

class NamCls implements Serializable
{
    int NumVar;
    transient String NamVar;
}

|=> Si une classe implémente serializable alors toutes ses sous-classes seront également serializable.

Java fournit un mécanisme, appelé sérialisation d'objet où un objet peut être représenté comme une séquence d'octets qui inclut les données de l'objet ainsi que des informations sur le type de l'objet et les types de données stockées dans l'objet. Il est principalement utilisé pour voyager l'état de l'objet sur le réseau (connu sous le nom de marshaling).