Was ist Objektserialisierung?

Question

Was ist mit "Objektserialisierung" gemeint? Können Sie das bitte anhand einiger Beispiele erklären?

Answer 1

Meine zwei Cents aus meinem eigenen Blog:

Hier finden Sie eine ausführliche Erklärung der Serialisierung : (mein eigener Blog)

Serialisierung:

Die Serialisierung ist der Prozess, bei dem der Zustand eines Objekts erhalten bleibt. Er wird in Form einer Folge von Bytes dargestellt und gespeichert. Diese kann in einer Datei gespeichert werden. Der Prozess, den Zustand des Objekts aus der Datei zu lesen und wiederherzustellen, wird Deserialisierung genannt.

Wozu dient die Serialisierung?

In der modernen Architektur besteht immer die Notwendigkeit, den Zustand von Objekten zu speichern und dann abzurufen. Um ein Objekt zu speichern, sollten wir zum Beispiel in Hibernate die Klasse serialisierbar machen. Sobald der Objektstatus in Form von Bytes gespeichert ist, kann er an ein anderes System übertragen werden, das dann aus dem Status lesen und die Klasse abrufen kann. Der Objektstatus kann aus einer Datenbank, einem anderen JVM oder einer separaten Komponente stammen. Mit Hilfe der Serialisierung können wir den Objektstatus abrufen.

Code Beispiel und Erklärung:

Werfen wir zunächst einen Blick auf die Item Class:

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

Im obigen Code ist zu erkennen, dass Artikel Klasse implementiert Serialisierbar .

Dies ist die Schnittstelle, die es ermöglicht, dass eine Klasse serialisierbar ist.

Jetzt können wir eine Variable namens serialVersionUID wird als Long-Variable initialisiert. Diese Zahl wird vom Compiler auf der Grundlage des Zustands der Klasse und der Klassenattribute berechnet. Anhand dieser Zahl kann der JVM den Zustand eines Objekts identifizieren, wenn er den Zustand des Objekts aus der Datei liest.

Dazu können wir einen Blick in die offizielle Oracle-Dokumentation werfen:

Die Serialisierungs-Laufzeit assoziiert mit jeder serialisierbaren Klasse eine Versionsnummer, genannt serialVersionUID, die bei der Deserialisierung verwendet wird Deserialisierung verwendet wird, um zu überprüfen, ob der Sender und der Empfänger einer serialisierten Objekts Klassen für dieses Objekt geladen haben, die in Bezug auf die hinsichtlich der Serialisierung kompatibel sind. Wenn der Empfänger eine Klasse für das Objekt geladen hat, die eine andere serialVersionUID hat als die der Klasse des Senders hat, dann führt die Deserialisierung zu einer InvalidClassException. Eine serialisierbare Klasse kann ihre eigene serialVersionUID explizit deklarieren, indem sie ein Feld namens "serialVersionUID" deklariert, das statisch, final und vom Typ long sein muss: ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L; Wenn eine serialisierbare Klasse nicht explizit eine serialVersionUID deklariert, deklariert, berechnet die Serialisierungslaufzeit einen Standard serialVersionUID-Wert für diese Klasse auf der Grundlage verschiedener Aspekte der Klasse, wie im Abschnitt Java(TM) Object Serialization Spezifikation beschrieben. Es wird jedoch dringend empfohlen, dass alle serialisierbaren Klassen ausdrücklich serialVersionUID-Werte zu deklarieren, da die standardmäßige serialVersionUID-Berechnung sehr empfindlich auf Klassendetails auf Klassendetails reagiert, die je nach Compiler-Implementierung variieren können, und kann zu unerwarteten InvalidClassExceptions während der Deserialisierung führen kann. Um daher einen konsistenten serialVersionUID Wert über verschiedene Java-Compiler-Implementierungen hinweg zu gewährleisten, sollte daher eine serialisierbare Klasse einen expliziten serialVersionUID-Wert deklarieren. Es wird außerdem wird dringend empfohlen, dass explizite serialVersionUID-Deklarationen die privaten Modifikator verwenden, da solche Deklarationen nur für die die unmittelbar deklarierende Klasse gelten - serialVersionUID-Felder sind nicht als geerbte Mitglieder nützlich.

Wenn Sie bemerkt haben, dass wir ein weiteres Schlüsselwort verwendet haben, nämlich transient .

Wenn ein Feld nicht serialisierbar ist, muss es als transient gekennzeichnet werden. Hier haben wir das Feld artikelKostenPreis als flüchtig eingestuft und nicht in eine Datei geschrieben werden soll

Schauen wir uns nun an, wie man den Zustand eines Objekts in die Datei schreibt und dann von dort liest.

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 der obigen Abbildung sehen wir ein Beispiel für die Serialisierung und Deserialisierung eines Objekts.

Hierfür haben wir zwei Klassen verwendet. Für die Serialisierung des Objekts haben wir ObjectOutputStream verwendet. Wir haben die Methode writeObject verwendet, um das Objekt in die Datei zu schreiben.

Zum Deserialisieren haben wir ObjectInputStream verwendet, der das Objekt aus der Datei liest. Es verwendet readObject, um die Objektdaten aus der Datei zu lesen.

Die Ausgabe des obigen Codes würde wie folgt aussehen:

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]

Beachten Sie, dass artikelKostenPreis vom deserialisierten Objekt ist null da es nicht geschrieben wurde.

Wir haben die Grundlagen der Java-Serialisierung bereits in Teil I dieses Artikels besprochen.

Lassen Sie uns nun ausführlich darüber sprechen, wie es funktioniert.

Beginnen wir mit der serialversionuid.

En serialVersionUID wird als Versionskontrolle in einer serialisierbaren Klasse verwendet.

Wenn Sie nicht explizit eine serialVersionUID deklarieren, wird die JVM dies automatisch für Sie tun, basierend auf verschiedenen Eigenschaften der Klasse Serializable.

Javas Algorithmus zur Berechnung von serialversionuid (Weitere Informationen finden Sie hier)

1. Der Name der Klasse.
   2. Die Klassenmodifikatoren in Form einer 32-Bit-Ganzzahl.
   3. Der Name der einzelnen Schnittstellen, sortiert nach Namen.
   4. Für jedes Feld der Klasse, sortiert nach Feldnamen (außer private statische und private transiente Felder: Der Name des Feldes. Die Modifikatoren des Feldes in Form einer 32-Bit-Ganzzahl. Der Deskriptor des Feldes.
   5. Wenn ein Klasseninitialisierer vorhanden ist, geben Sie Folgendes an: Den Namen der Methode, .
   6. Der Modifikator der Methode, java.lang.reflect.Modifier.STATIC, geschrieben als 32-Bit-Ganzzahl.
   7. Der Deskriptor der Methode, ()V.
   8. Für jeden nicht-privaten Konstruktor, sortiert nach Methodenname und Signatur: Der Name der Methode, . Die Modifikatoren der Methode in Form einer 32-Bit-Ganzzahl. Der Deskriptor der Methode.
   9. Für jede nicht-private Methode, sortiert nach Methodenname und Signatur: Der Name der Methode. Die Modifikatoren der Methode in Form einer 32-Bit-Ganzzahl. Der Deskriptor der Methode.
   10. Der SHA-1-Algorithmus wird auf den von DataOutputStream erzeugten Bytestrom angewendet und erzeugt fünf 32-Bit-Werte sha[0..4]. Der Hash-Wert wird aus dem ersten und zweiten 32-Bit-Wert der SHA-1 Message Digest zusammengesetzt. Wenn das Ergebnis des Message Digest, die fünf 32-Bit-Worte H0 H1 H2 H3 H4, in einem Array von fünf int-Werten namens sha befindet, würde der Hash-Wert wie folgt berechnet werden:

    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;

Java's Serialisierungsalgorithmus

Der Algorithmus zur Serialisierung eines Objekts wird im Folgenden beschrieben:
1. Es schreibt die Metadaten der Klasse aus, die mit einer Instanz verbunden ist.
2. Es schreibt rekursiv die Beschreibung der Oberklasse aus, bis es die java.lang.object .
3. Sobald das Schreiben der Metadaten abgeschlossen ist, beginnt es mit den eigentlichen Daten, die mit der Instanz verbunden sind. Aber dieses Mal beginnt er mit der obersten Superklasse.
4. Es schreibt die mit der Instanz verbundenen Daten rekursiv, beginnend mit der kleinsten Oberklasse bis zur am weitesten abgeleiteten Klasse.

Was Sie beachten sollten:

1. Statische Felder in einer Klasse können nicht serialisiert werden.

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

2. Wenn die serialversionuid in der Leseklasse unterschiedlich ist, wird ein InvalidClassException Ausnahme.

3. Wenn eine Klasse serializable implementiert, sind alle ihre Unterklassen ebenfalls serialisierbar.

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

4. Wenn eine Klasse einen Verweis auf eine andere Klasse hat, müssen alle Verweise serialisierbar sein, sonst wird der Serialisierungsprozess nicht durchgeführt. In einem solchen Fall, NotSerializableException wird zur Laufzeit ausgelöst.

Beispiel:

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

Answer 2

Serialisierung bedeutet, dass Objekte in Java persistiert werden. Wenn Sie den Zustand des Objekts speichern und später wiederherstellen wollen (möglicherweise in einer anderen JVM), kann die Serialisierung verwendet werden.

Beachten Sie, dass die Eigenschaften eines Objekts nur gespeichert werden. Wenn Sie das Objekt wieder aufleben lassen wollen, sollten Sie die Klassendatei haben, da nur die Mitgliedsvariablen gespeichert werden und nicht die Mitgliedsfunktionen.

z. B:

ObjectInputStream oos = new ObjectInputStream(                                 
                                 new FileInputStream(  new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();

Die Searializable ist eine Marker-Schnittstelle, die kennzeichnet, dass Ihre Klasse serialisierbar ist. Marker-Schnittstelle bedeutet, dass es sich nur um eine leere Schnittstelle handelt und die Verwendung dieser Schnittstelle der JVM mitteilt, dass diese Klasse serialisierbar gemacht werden kann.

Answer 3

Bei der Serialisierung wird der Zustand eines Objekts in Bits umgewandelt, damit er auf einer Festplatte gespeichert werden kann. Wenn Sie das gleiche Objekt deserialisieren, behält es später seinen Zustand bei. So können Sie Objekte neu erstellen, ohne die Eigenschaften der Objekte von Hand speichern zu müssen.

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

Answer 4

Java Objekt-Serialisierung

Serialization ist ein Mechanismus zur Umwandlung eines Graphen von Java-Objekten in ein Array von Bytes zur Speicherung( to disk file ) oder Übertragung( across a network ), dann durch Verwendung von Deserialisierung können wir den Graphen der Objekte wiederherstellen. Graphen von Objekten werden mithilfe eines Mechanismus zur gemeinsamen Nutzung von Referenzen korrekt wiederhergestellt. Prüfen Sie jedoch vor dem Speichern, ob die serialVersionUID aus der Eingabedatei/dem Netzwerk und die serialVersionUID der .class-Datei übereinstimmen. Wenn nicht, wird ein java.io.InvalidClassException .

Jede versionierte Klasse muss die ursprüngliche Klassenversion angeben, für die sie Streams schreiben kann und aus der sie lesen kann. Zum Beispiel muss eine versionierte Klasse deklarieren:

serialVersionUID Syntax

// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L;
private static final long serialVersionUID = 3487495895819393L;

---

serialVersionUID ist für den Serialisierungsprozess unerlässlich. Es ist dem Entwickler jedoch freigestellt, sie in die Java-Quelldatei einzufügen. Wenn keine serialVersionUID angegeben wird, erzeugt die Laufzeit der Serialisierung eine serialVersionUID und ordnet sie der Klasse zu. Das serialisierte Objekt wird diese serialVersionUID zusammen mit anderen Daten enthalten.

Hinweis - Es wird dringend empfohlen, dass alle serialisierbaren Klassen ausdrücklich eine serialVersionUID deklarieren, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations und kann daher bei der Deserialisierung zu unerwarteten serialVersionUID-Konflikten führen, die die Deserialisierung fehlschlagen lassen.

Serialisierbare Klassen inspizieren

---

Ein Java-Objekt ist nur serialisierbar, wenn eine Klasse oder eine ihrer Oberklassen entweder die java.io.Serializable Schnittstelle oder ihre Unterschnittstelle, java.io.Externalizable .

• Eine Klasse muss implementieren java.io.Serializable Schnittstelle um sein Objekt erfolgreich zu serialisieren. Serializable ist eine Marker-Schnittstelle und wird verwendet, um dem Compiler mitzuteilen, dass die Klasse, die sie implementiert, serialisierbares Verhalten hinzufügen muss. Hier ist die Java Virtual Machine (JVM) für die automatische Serialisierung zuständig.

  transient Stichwort: java.io.Serializable interface

  Wenn beim Serialisieren eines Objekts bestimmte Datenelemente des Objekts nicht serialisiert werden sollen, können wir den transienten Modifikator verwenden. Das Schlüsselwort transient verhindert die Serialisierung dieses Datenelements.

  • Felder, die als transient oder statisch deklariert sind, werden vom Serialisierungsprozess ignoriert.

  TRANSIENT & 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.
  }

• Die Implementierung der Schnittstelle Externalizable ermöglicht es dem Objekt, die vollständige Kontrolle über den Inhalt und das Format der serialisierten Form des Objekts zu übernehmen. Die Methoden der Externalizable-Schnittstelle, writeExternal und readExternal, werden aufgerufen, um den Zustand des Objekts zu speichern und wiederherzustellen. Wenn sie von einer Klasse implementiert werden, können sie ihren eigenen Zustand mit Hilfe aller Methoden von ObjectOutput und ObjectInput schreiben und lesen. Es liegt in der Verantwortung der Objekte, jede auftretende Versionierung zu handhaben.

  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
      }
  }

• Nur Objekte, die die Schnittstelle java.io.Serializable oder java.io.Externalizable unterstützen, können written to / read from Ströme. Die Klasse jedes serialisierbaren Objekts wird kodiert, einschließlich des Klassennamens und der Signatur der Klasse, der Werte der Felder und Arrays des Objekts und der Schließung aller anderen Objekte, auf die von den ursprünglichen Objekten verwiesen wird.

Serialisierbares Beispiel für Dateien

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

Serialisierbares Beispiel über Netzwerk

Verteilendes Objekt in verschiedenen Adressräumen, entweder in verschiedenen Prozessen auf demselben Computer oder sogar in mehreren Computern, die über ein Netz verbunden sind, die aber zusammenarbeiten, indem sie Daten gemeinsam nutzen und Methoden aufrufen.

• Daten-Marshalling

• Stümpfe und Skelette

  /**

  • 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

• Implementierung von Serializable vs. Externalizable

Answer 5

Unter Serialisierung versteht man das Speichern eines Objekts in einem Speichermedium (z. B. einer Datei oder einem Speicherpuffer) oder seine Übertragung über eine Netzverbindung in binärer Form. Die serialisierten Objekte sind JVM-unabhängig und können von jeder JVM reserialisiert werden. In diesem Fall wird der Zustand der Java-Objekte "im Speicher" in einen Byte-Stream umgewandelt. Diese Art der Datei kann vom Benutzer nicht verstanden werden. Es handelt sich um eine besondere Art von Objekt, das von der JVM (Java Virtual Machine) wiederverwendet wird. Dieser Prozess der Serialisierung eines Objekts wird auch als Deflatieren oder Marshalling eines Objekts bezeichnet.

Das zu serialisierende Objekt muss Folgendes implementieren java.io.Serializable Schnittstelle. Der Standard-Serialisierungsmechanismus für ein Objekt schreibt die Klasse des Objekts, die Klassensignatur und die Werte aller nicht-transienten und nicht-statischen Felder.

class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,

ObjectOutput Schnittstelle erweitert die DataOutput Schnittstelle und fügt Methoden zur Serialisierung von Objekten und zum Schreiben von Bytes in die Datei hinzu. Die ObjectOutputStream erweitert java.io.OutputStream und implementiert ObjectOutput Schnittstelle. Sie serialisiert Objekte, Arrays und andere Werte in einen Stream. Daher ist der Konstruktor von ObjectOutputStream wird geschrieben als:

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

Der obige Code wurde verwendet, um die Instanz der ObjectOutput Klasse mit der ObjectOutputStream( ) Konstruktor, der die Instanz der FileOuputStream als Parameter.

En ObjectOutput Schnittstelle wird durch die Implementierung der ObjectOutputStream Klasse. Die Website ObjectOutputStream wird zur Serialisierung des Objekts erstellt.

Deserialisieren eines Objekts in Java

Der umgekehrte Vorgang der Serialisierung wird als Deserialisierung bezeichnet, d.h. die Daten aus einer Reihe von Bytes zu extrahieren, ist als Deserialisierung bekannt, die auch als Aufblasen oder Unmarshalling bezeichnet wird.

ObjectInputStream erweitert java.io.InputStream und implementiert ObjectInput Schnittstelle. Sie deserialisiert Objekte, Arrays und andere Werte aus einem Eingabestrom. Daher ist der Konstruktor von ObjectInputStream wird geschrieben als:

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

Der obige Code des Programms erzeugt die Instanz der ObjectInputStream Klasse, um die Datei zu deserialisieren, die von der ObjectInputStream Klasse. Der obige Code erzeugt die Instanz unter Verwendung der Instanz der FileInputStream Klasse, die das angegebene Dateiobjekt enthält, das deserialisiert werden muss, weil die ObjectInputStream() Konstruktor benötigt den Eingabestrom.