Java-Serialisierung und Deserialisierung

1. Was ist Serialisierung? Warum serialisieren?

　Java-Serialisierung bezieht sich auf den Prozess der Konvertierung eines Objekts in eine Bytesequenz, während Deserialisierung der Prozess ist, bei dem nur eine Bytesequenz in ein Zielobjekt konvertiert wird.

Wir alle wissen, dass beim Zugriff auf den Browser der Text, die Bilder, das Audio, das Video usw., die wir sehen, über Binärsequenzen übertragen werden. Wenn wir also Java-Objekte übertragen müssen, sollte das Objekt zuerst serialisiert werden? Die Antwort lautet: Ja, wir müssen das Java-Objekt zuerst serialisieren und es dann über das Netzwerk und E/A übertragen. Wenn es das Ziel erreicht, deserialisieren wir es, um das gewünschte Objekt zu erhalten, und schließen schließlich die Kommunikation ab.

2. So implementieren Sie die Serialisierung

2.1. Verwenden Sie die Schlüsselklassen ObjectOutputStream und ObjectInputStream im JDK

In der ObjectOutputStream-Klasse: Durch Verwendung der Methode writeObject(Object object). , das Objekt im Binärformat schreiben.

In der ObjectInputStream-Klasse: Lesen Sie den Binärstrom aus dem Eingabestrom und konvertieren Sie ihn mithilfe der Methode readObject() in ein Objekt.

2.2. Das Zielobjekt muss zuerst die Serialable-Schnittstelle implementieren

Wir erstellen eine Student-Klasse:

public class Student implements Serializable {
    private static final long serialVersionUID = 3404072173323892464L;
    private String name;
    private transient String id;
    private String age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public Student(String name, String id) {
        System.out.println("args Constructor");
        this.name = name;
        this.id = id;
    }

    public Student() {
        System.out.println("none-arg Constructor");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

}

Die Student-Klasse im Code implementiert die Serializable-Schnittstelle und generiert eine Versionsnummer:

private static final long serialVersionUID = 3404072173323892464L;

Zunächst einmal:

1. Die Funktion der Serializable-Schnittstelle besteht nur darin Identifizieren Sie, ob unsere Klasse Serialisierung sein muss und die Serializable-Schnittstelle keine Methoden bereitstellt.

2. serialVersionUid Die Serialisierungsversionsnummer wird verwendet, um die Version der von uns geschriebenen Klasse zu unterscheiden und um zu bestimmen, ob die Version der Klasse während der Deserialisierung konsistent ist. Wenn sie inkonsistent ist, tritt eine Versionsinkonsistenzausnahme auf.

3. Das Schlüsselwort transient wird hauptsächlich verwendet, um Variablen zu ignorieren, die wir nicht serialisieren möchten

2.3. Objekte serialisieren oder deserialisieren

　　2.3.1 Die erste Schreibmethode:

public static  void main(String[] args){
        File file = new File("D:/test.txt");
        Student student = new Student("孙悟空","12");
        try {
            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));
            outputStream.writeObject(student);
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
            Student s = (Student) objectInputStream.readObject();
            System.out.println(s.toString());
            System.out.println(s.equals(student));
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

　　 Erstellen Sie das Objekt Student und geben Sie das Objekt dann über die Methode writeObject() in der Klasse ObjectOutputStream in die Datei aus.

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 　　　　　　　　　　　　　　　　　　　cco Groom inwn und deserialisiert dann über die readObject()-Methode in der ObjectinputStream-Klasse, um das Objekt zu erhalten.

　　　2.3.2 Die zweite Schreibmethode:

Implementieren Sie die Methoden writeObject() und readObject() in der Student-Klasse:

private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
        objectOutputStream.defaultWriteObject();
        objectOutputStream.writeUTF(id);

    }

    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
        objectInputStream.defaultReadObject();
        id = objectInputStream.readUTF();
    }

Durch die Serialisierung auf diese Weise können wir die Variablen, die wir serialisieren möchten, anpassen, den Eingabe- und Ausgabestream an die Zeileninstanz übergeben und dann serialisieren und deserialisieren.

　

　　　2.3.3 Die dritte Schreibmethode:

Der Student implementiert die Externalnalizable-Schnittstelle, implementiert jedoch nicht die Serializable-Schnittstelle

Die Externaliable-Schnittstelle ist eine Unterklasse von Serializable hat die gleiche Funktion wie die Serializable-Schnittstelle:

public class Student implements Externalizable {
    private static final long serialVersionUID = 3404072173323892464L;
    private String name;
    private transient String id;
    private String age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public Student(String name, String id) {
        System.out.println("args Constructor");
        this.name = name;
        this.id = id;
    }

    public Student() {
        System.out.println("none-arg Constructor");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }


    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeObject(id);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        id = (String) in .readObject();
    }

}

Durch Vergleich mit der vorherigen zweiten Schreibmethode können wir feststellen, dass ihre Implementierungsprinzipien sehr ähnlich sind, die Implementierung der Externalnalizable-Schnittstelle jedoch nicht Unterstützt Die erste Serialisierungsmethode kann Objekte nur durch Implementierung der Methoden writeExternal() und readExternal() in der Schnittstelle serialisieren.

3. Fragen zur Serialisierung im Vorstellungsgespräch:

1. Was ist Serialisierung und wie implementiert man Serialisierung

Serialisierung von Objekten in Java besteht darin, Objekte in Binärsequenzen umzuwandeln, und Deserialisierung darin, Binärsequenzen in Objekte umzuwandeln

　Es gibt viele Möglichkeiten, die Serialisierung in Java zu implementieren

1. Zuerst benötigen Sie zwei IO Es werden die Klassen ObjectInputStream und ObjectOutputStream verwendet: 2. Implementieren Sie die Serializable-Schnittstelle:

Es gibt zwei spezifische Serialisierungsmethoden:

2.1 Direkt über die Klassen ObjectOutputStream und ObjectInputStream Die writeObject() und readObject() Methoden in

　　　2.2 Durch Implementierung der Methoden writeObject() und readObject() im serialisierten Objekt und Übergabe der ObjectOutputStream- und ObjectInputStream-Objekte wird die Serialisierung abgeschlossen

　　3, implementieren Sie die Externalizable-Schnittstelle:

　　　　　Objektserialisierung kann nur durch Implementierung der Methoden writeExternal() und readExternal() in der Schnittstelle erreicht werden


2. Schlüsselwort „Transient“? Wie serialisiere ich Variablen, die mit dem Transientenmodifikator geändert wurden?
Die Funktion von transient besteht darin, Variablen abzuschirmen, die wir nicht serialisieren möchten. Das Objekt ignoriert die Variable während des Serialisierungs- und Deserialisierungsprozesses.
Wir können die Methoden writeObject und readObject in der obigen Serialisierungsmethode implementieren und in der Methode die Methoden writeUTF() und readUTF() des Ausgabestreams oder Eingabestreams aufrufen.
Oder implementieren Sie die Externalizable-Schnittstelle, implementieren Sie die Methoden writeExternal() und readExternal() und passen Sie dann das Sequenzobjekt an.

3. Wie kann sichergestellt werden, dass die Objekte nach der Serialisierung und Deserialisierung konsistent sind? (Bitte korrigieren Sie mich, wenn Sie Einwände haben)
Nachdem ich einige Informationen zu diesem Problem konsultiert hatte, stellte ich fest, dass es keine Garantie dafür gibt, dass die Objekte nach der Serialisierung und Deserialisierung konsistent sind, da wir während des Deserialisierungsprozesses zunächst ein Objekt erstellen.
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ｗ 　　 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 richider >> Nach dem Erstellen eines neuen Objekts verweisen die Objektreferenz und das Originalobjekt nicht auf dasselbe Ziel.
Daher können wir nur sicherstellen, dass ihre Daten und Versionen konsistent sind, wir können jedoch nicht garantieren, dass die Objekte konsistent sind.