1. Serialisierung und Deserialisierung

Serialisierung: Bezieht sich auf die Java-Objektdaten im Heap-Speicher auf irgendeine Weise in einer Festplattendatei koppeln oder an andere Netzwerkknoten weitergeben (Netzwerkübertragung). Dieser Vorgang wird Serialisierung genannt und bezieht sich normalerweise auf den Vorgang der Konvertierung einer Datenstruktur oder eines Objekts in eine Bin?rdatei.

即將對象轉化為二進制，用于保存，或者網絡傳輸。

Deserialisierung: Der Prozess der Wiederherstellung der Objektdaten in der Festplattendatei oder der Objektdaten auf dem Netzwerkknoten im Java-Objektmodell. Das hei?t, der Prozess der Konvertierung der w?hrend des Serialisierungsprozesses generierten Bin?rzeichenfolge in eine Datenstruktur oder ein Objekt

與序列化相反，將二進制轉化成對象。

2 Die Rolle der Serialisierung

① M?chten Sie speichern? Speicher Wenn die Objekte in einer Datei oder Datenbank gespeichert werden;

② Wenn Sie Sockets zum übertragen von Objekten über das Netzwerk verwenden m?chten

③ Wenn Sie Objekte über RMI übertragen m?chten; >

一些應用場景，涉及到將對象轉化成二進制，序列化保證了能夠成功讀取到保存的對象。

3. Java-Serialisierungsimplementierung

Um die Serialisierung von Objekten zu realisieren, besteht die direkteste Operation darin, die serialisierbare Schnittstelle zu implementieren

Verwenden Sie Objekte im IO Stream Streams k?nnen Serialisierungsvorg?nge implementieren, Objekte in Dateien speichern und sie dann auslesen.

Erstellen Sie zun?chst ein Objekt und implementieren Sie die serialisierbare Schnittstelle:

import java.io.Serializable;
public class User implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }
}

Verwenden Sie den Objektstrom, um eine Toolklasse zum Speichern und Lesen von Objekten zu schreiben:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializeUtil {
    // 保存對象，序列化
    public static void saveObject(Object object) throws Exception {
        ObjectOutputStream out = null;
        FileOutputStream fout = null;
        try {
            fout = new FileOutputStream("D:/1.txt");
            out = new ObjectOutputStream(fout);
            out.writeObject(object);
        } finally {
            fout.close();
            out.close();
        }
    }
    // 讀取對象，反序列化
    public static Object readObject() throws Exception {
        ObjectInputStream in = null;
        FileInputStream fin = null;
        try {
            fin = new FileInputStream("D:/1.txt");
            in = new ObjectInputStream(fin);
            Object object = in.readObject();
            return object;
        } finally {
            fin.close();
            in.close();
        }
    }
}

Test:

public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.setName("旭旭寶寶");
        user.setAge(33);
        // 保存
        try {
            SerializeUtil.saveObject(user);
        } catch (Exception e) {
            System.out.println("保存時異常：" + e.getMessage());
        }
        // 讀取
        User userObject;
        try {
            userObject = (User) SerializeUtil.readObject();
            System.out.println(userObject);
        } catch (Exception e) {
            System.out.println("讀取時異常：" + e.getMessage());
        }
    }
}

Testergebnisse:

Hier haben wir das Objekt erfolgreich in einer Datei gespeichert und dann ausgelesen. Wenn wir die Serialisierungsschnittstelle zu diesem Zeitpunkt nicht implementieren, tritt eine Ausnahme auf. Wir brechen den implementierten Serialiable-Schnittstellencode ab:

public class User {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }
}

und testen dann die Main-Methode:

Sie k?nnen sehen, dass zu diesem Zeitpunkt ein Fehler gemeldet wird, verwenden Sie e.printStackTrace( ); Sehen Sie sich die Details der Ausnahme an:

Da sie nicht serialisiert ist, kann sie nicht gespeichert und gelesen werden.

4. Die Rolle der Serialisierungs-ID

Wie Sie sehen k?nnen, fügen wir beim Serialisieren ein serialVersionUID-Feld hinzu, das die Serialisierungs-ID ist

private static final long serialVersionUID = 1L;

Diese Serialisierungs-ID spielt eine Schlüsselrolle, sie bestimmt, ob die Deserialisierung erfolgreich sein kann! Der Serialisierungsmechanismus von Java überprüft die Versionskonsistenz, indem er die serialVersionUID der Laufzeitklasse beurteilt. W?hrend der Deserialisierung vergleicht die JVM die serialVersionUID im eingehenden Bytestrom mit der serialVersionUID in der lokalen Entit?tsklasse Andernfalls wird eine Ausnahme inkonsistenter serialisierter Versionen gemeldet.

即序列化ID是為了保證成功進行反序列化

5. Standard-Serialisierungs-ID

Wenn wir in einer unserer Entit?tsklassen nicht explizit eine Variable mit dem Namen ?serialVersionUID“ vom Typ long definieren, wird der Java-Serialisierungsmechanismus verwendet generiert automatisch eine serialVersionUID basierend auf der kompilierten Klasse als Serialisierungsversionsvergleich. In diesem Fall generieren nur die durch dieselbe Kompilierung generierten Klassen dieselbe serialVersionUID. Wenn wir beispielsweise eine Klasse schreiben, müssen wir im Laufe der Zeit aufgrund ge?nderter Anforderungen weitere Felder zur lokalen Klasse hinzufügen. Zu diesem Zeitpunkt ist die SerialVersionUID w?hrend der Deserialisierung inkonsistent, was dazu führt, dass die Deserialisierung fehlschl?gt. Wie kann man es also l?sen? Fügen Sie einfach eine Variable ?serialVersionUID“ zur lokalen Klasse hinzu, der Wert bleibt unver?ndert und Serialisierung und Deserialisierung k?nnen durchgeführt werden.

如果沒有顯示指定serialVersionUID，會自動生成一個。
只有同一次編譯生成的class才會生成相同的serialVersionUID。
但是如果出現需求變動，Bean類發(fā)生改變，則會導致反序列化失敗。為了不出現這類的問題，所以我們最好還是顯式的指定一個
serialVersionUID。

6. Andere Probleme mit der Serialisierung

1 Statische Variablen werden nicht serialisiert (statisch, vorübergehend)

Wenn ein Das übergeordnete Element Die Klasse implementiert die Serialisierung und die Unterklasse implementiert die Serialisierung automatisch. Es ist nicht erforderlich, die Serializable-Schnittstelle explizit zu implementieren.

3. Wenn die Instanzvariablen eines Objekts auf andere Objekte verweisen, wird bei der Serialisierung des Objekts auch das referenzierte Objekt serialisiert.

子類序列化時：
如果父類沒有實現Serializable接口，沒有提供默認構造函數，那么子類的序列化會出錯；
如果父類沒有實現Serializable接口，提供了默認的構造函數，那么子類可以序列化，父類的成員變量不會被序列化。如果父類
實現了Serializable接口，則父類和子類都可以序列化。

7. Verwenden Sie ein effizienteres Serialisierungsframework – Protostuff

Tats?chlich ist die native Serialisierungsmethode von Java (durch Implementierung der Serialiable-Schnittstelle) nicht so effizient als Nicht die h?chste.

Auf Github gibt es ein Projekt zur Analyse der Serialisierungseffizienz: https://github.com/eihay/jvm-serializers/wiki

Sehen Sie sich das an Eines mit der besten Leistung ist Colfer, das von Google entwickelt wurde. Da Colfer jedoch zu schwierig zu verwenden ist, verwenden immer mehr Menschen das Serialisierungs-Framework ProtoStuff. Um das Framework anzuwenden, müssen zwei Bibliotheken (Core und Runtime) eingeführt werden.

①Github-Adresse: https://github.com/protostuff/protostuff

③Wenn Sie Maven verwenden, fügen Sie Abh?ngigkeiten hinzu:

<dependency>
  <groupId>io.protostuff</groupId>
  <artifactId>protostuff-core</artifactId>
  <version>1.5.9</version>
</dependency>

<dependency>
  <groupId>io.protostuff</groupId>
  <artifactId>protostuff-core</artifactId>
  <version>1.5.9</version>
</dependency>

?ndern Sie den Hauptcode

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.setName("旭旭寶寶");
        user.setAge(33);
        Schema<User> schema = RuntimeSchema.getSchema(User.class);
        // 保存對象，序列化，轉化二進制數據
        LinkedBuffer buffer = LinkedBuffer.allocate(512);
        final byte[] protostuff;
        try {
            protostuff = ProtobufIOUtil.toByteArray(user, schema, buffer);
        } finally {
            buffer.clear();
        }
        // 讀取對象，反序列化
        User userObject = schema.newMessage();
        ProtostuffIOUtil.mergeFrom(protostuff, userObject, schema);
        System.out.println(userObject);
    }
}

Benutzerklasse implementiert die serialisierbare Schnittstelle nicht

public class User {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }
}

Testergebnisse:

若要要整合Redis使用，也可以寫成一個工具類：

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
public class SerializeUtil {
    private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<>();
    @SuppressWarnings("unchecked")
    public static <T> byte[] serializer(T obj) {
        Class<T> clazz = (Class<T>) obj.getClass();
        Schema<T> schema = getSchema(clazz);
        return ProtobufIOUtil.toByteArray(obj, schema, LinkedBuffer.allocate(256));
    }
    public static <T> T deSerializer(byte[] bytes, Class<T> clazz) {
        T message;
        try {
            message = clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        Schema<T> schema = getSchema(clazz);
        ProtobufIOUtil.mergeFrom(bytes, message, schema);
        return message;
    }
    @SuppressWarnings("unchecked")
    public static <T> Schema<T> getSchema(Class<T> clazz) {
        Schema<T> schema = (Schema<T>) cachedSchema.get(clazz);
        if (schema == null) {
            schema = RuntimeSchema.createFrom(clazz);
            if (schema != null) {
                cachedSchema.put(clazz, schema);
            }
        }
        return schema;
    }
}

這樣即使我們的User類就不用再實現Serialiable接口了，同樣可以進行序列化，效率也更高。

php中文網，大量的免費Java入門教程，歡迎在線學習！

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