Serialisierung und Deserialisierung in Java

In fortgeschrittenem Java sind Serialisierung und Deserialisierung Prozesse zum Speichern und Wiederherstellen des Zustands eines Objekts, wodurch es möglich wird, Objekte in Dateien oder Datenbanken zu speichern oder über ein Netzwerk zu übertragen. Hier ist eine Aufschlüsselung dieser Konzepte und ihrer Anwendung

1️⃣ Serialisierung

Serialisierung ist der Prozess der Konvertierung eines Objekts in einen Bytestrom. Dieser Bytestrom kann in einer Datei gespeichert, über ein Netzwerk gesendet oder in einer Datenbank gespeichert werden. In Java wird die Serializable-Schnittstelle verwendet, um anzugeben, dass eine Klasse serialisiert werden kann.

✍ Schritte zum Serialisieren eines Objekts:

▶️ Implementieren Sie die Serializable-Schnittstelle.

▶️ Verwenden Sie ObjectOutputStream und FileOutputStream, um das Objekt in eine Datei oder einen Ausgabestream zu schreiben.

▶️ Rufen Sie die writeObject()-Methode für ObjectOutputStream auf.

?Codebeispiel:

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Employee implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }
}

public class SerializeDemo {
    public static void main(String[] args) {
        Employee emp = new Employee("John Doe", 101);

        try (FileOutputStream fileOut = new FileOutputStream("employee.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(emp);
            System.out.println("Serialized data is saved in employee.ser");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Mitarbeiter.ser ist hier eine serialisierte Datei, die den Bytestream des Objekts speichert.

2️⃣ Deserialisierung
Bei der Deserialisierung handelt es sich um den umgekehrten Prozess, bei dem der Bytestrom wieder in eine Kopie des Originalobjekts umgewandelt wird. Dadurch können Sie den Zustand des Objekts wiederherstellen, nachdem es gespeichert oder übertragen wurde.

✍ Schritte zum Deserialisieren eines Objekts:

▶️ Verwenden Sie ObjectInputStream und FileInputStream, um das Objekt aus der Datei oder dem Eingabestream zu lesen.

▶️ Rufen Sie die readObject()-Methode auf ObjectInputStrea auf

?Codebeispiel:

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class DeserializeDemo {
    public static void main(String[] args) {
        Employee emp = null;

        try (FileInputStream fileIn = new FileInputStream("employee.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            emp = (Employee) in.readObject();
            System.out.println("Deserialized Employee...");
            System.out.println("Name: " + emp.name);
            System.out.println("ID: " + emp.id);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Dadurch wird der ursprüngliche Zustand des Objekts abgerufen und der Zugriff auf seine Felder im Zustand vor der Serialisierung ermöglicht.

3️⃣ Fortgeschrittene Serialisierungsthemen

▶️ Benutzerdefinierte Serialisierung: Überschreiben Sie writeObject() und readObject() für eine benutzerdefinierte Serialisierung.

▶️ Externalisierbare Schnittstelle: Bietet vollständige Kontrolle über die Serialisierung und erfordert die Implementierung der Methoden writeExternal() und readExternal().

▶️ Transient Fields: Verwenden Sie das Schlüsselwort transient, um die Serialisierung bestimmter Felder (z. B. sensible Daten wie Passwörter) zu vermeiden.

✍ Vorteile der Serialisierung:

▶️ Ermöglicht das Speichern des Status eines Objekts für die zukünftige Verwendung.

▶️ Erleichtert die Übertragung komplexer Datenobjekte über Netzwerke.

? Codebeispiel kurz erläutern

import java.io.*;

class Student implements Serializable {
    private  static   final long serialVersionUId = 1l;
    private String name ;
    private int  age;
    private String Address;

    public Student(String name,int age,String Address){
        this.name = name;
        this.age = age;
        this.Address = Address;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public void setAddress(String Address){
        this.Address = Address;
    }

    public String getName(){
        return name;
    }
    public String getAddress(){
        return Address;
    }
    public int getAge(){
        return age;
    }


    public String toString(){
        return ("Student name is "+this.getName()+", age is "+this.getAge()+", and address is "+this.getAddress());
    }
}

public class  JAVA3_Serialization {
    // when you implement Serializable then you must be write a serialVersionUId because when it serialise and deserialize it uniquely identify in the network
    // when u update ur object or anything then you have to update the serialVersionUId increment .
    // private  static   final long serialVersionUId = 1l;

    // transient  int x ;
    // If you do not want a particular value to serialise and Deserialize.
    // the value x, when you don't serialise and Deserialize Then transient you used.

    public static void main(String[] args) {

        Student student = new Student("kanha",21,"angul odisha");

        String filename = "D:\Advance JAVA\CLS3 JAVA\Test.txt"; // store the data in this location
        FileOutputStream fileOut = null; // write file
        ObjectOutputStream objOut = null; // create object
        //Serialization
        try {
            fileOut = new FileOutputStream(filename);
            objOut = new ObjectOutputStream(fileOut);
            objOut.writeObject(student);

            objOut.close();
            fileOut.close();

            System.out.println("Object has been serialise =\n"+student);
        } catch (IOException ex){
            System.out.println("error will occure");
        }

        //Deserialization
        FileInputStream fileIn = null;
        ObjectInputStream objIn = null;
        try {
            fileIn = new FileInputStream(filename);
            objIn = new ObjectInputStream(fileIn);
            Student object =(Student) objIn.readObject();
            System.out.println("object has been Deserialization =\n"+object);

            objIn.close();
            fileIn.close();

        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

✍ Wichtige Hinweise:

▶️ Nur nicht-statische und nicht-transiente Datenelemente werden standardmäßig serialisiert.

▶️ Serialisierbare Objekte müssen die Kompatibilität zwischen Versionen gewährleisten, wenn die Klasse nach der Serialisierung geändert wird.

Für weitere Einblicke können Sie gerne Ihren GitHub für ausführliche Beispiele und Codebeispiele erwähnen! Lassen Sie mich wissen, wenn Sie spezifische Anpassungen wünschen.

GitHub – https://github.com/Prabhanjan-17p

Das obige ist der detaillierte Inhalt vonSerialisierung und Deserialisierung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!