Wie erreicht man die Persistenz von Objekten durch Serialisierung und Deserialisierung in Java?

Wie erreicht man Objektpersistenz durch Serialisierung und Deserialisierung in Java?

Einführung:
In der Java-Entwicklung ist Objektpersistenz ein wichtiger Weg, um eine langfristige Speicherung von Daten zu erreichen. Serialisierung und Deserialisierung sind eine der am häufigsten verwendeten Methoden, um in Java Objektpersistenz zu erreichen. In diesem Artikel werden die Konzepte der Serialisierung und Deserialisierung vorgestellt und erläutert, wie Serialisierung und Deserialisierung in Java verwendet werden, um Objektpersistenz zu erreichen.

1. Was sind Serialisierung und Deserialisierung?
Serialisierung ist der Prozess der Konvertierung eines Objekts in einen Bytestrom, sodass das Objekt bei Vorgängen wie Netzwerkübertragung oder Speichern auf der Festplatte kopiert und übertragen werden kann. Unter Deserialisierung versteht man den Prozess der Rückkonvertierung eines Bytestroms in ein Objekt und der Wiederherstellung des Status und der Daten des Objekts. In Java wird die Serialisierung und Deserialisierung von Objekten durch die Implementierung der Serializable-Schnittstelle erreicht.

2. So implementieren Sie die Serialisierung: Java bietet zwei Hauptserialisierungsmethoden, nämlich die Bytestrom-basierte Serialisierung und die Zeichenstrom-basierte Serialisierung.

1. Serialisierung basierend auf dem Byte-Stream

Die Serialisierung basierend auf dem Byte-Stream kann über die Klassen ObjectOutputStream und ObjectInputStream implementiert werden. Im Folgenden finden Sie einen Beispielcode, der zeigt, wie Objekte mithilfe eines bytestreambasierten Ansatzes serialisiert und deserialisiert werden.

import java.io.*;

public class ByteStreamSerializationDemo {
    public static void main(String[] args) {
        // 将对象序列化为字节流
        try {
            // 创建一个待序列化的对象
            Person person = new Person("Tom", 30);
            
            // 创建一个输出流
            FileOutputStream fileOutputStream = new FileOutputStream("person.obj");
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            
            // 将对象写入输出流
            objectOutputStream.writeObject(person);
            
            // 关闭输出流
            objectOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // 将字节流反序列化为对象
        try {
            // 创建一个输入流
            FileInputStream fileInputStream = new FileInputStream("person.obj");
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            
            // 读取对象数据
            Person person = (Person) objectInputStream.readObject();
            
            // 打印对象数据
            System.out.println(person.getName());   // 输出：Tom
            System.out.println(person.getAge());    // 输出：30
            
            // 关闭输入流
            objectInputStream.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Person implements Serializable {
    private String name;
    private int age;
    
    // 构造方法、getter和setter省略
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Im obigen Code erstellen wir zunächst ein zu serialisierendes Personenobjekt, serialisieren das Objekt dann über die Klassen FileOutputStream und ObjectOutputStream in einen Bytestream und schreiben es in die Datei. Als Nächstes deserialisieren wir den Bytestream in der Datei über die Klassen FileInputStream und ObjectInputStream in ein Objekt und geben schließlich die Attributwerte des Objekts aus.

2. Zeichenstrombasierte Serialisierung

Zeichenstrombasierte Serialisierung kann über die Klassen ObjectWriter und ObjectReader implementiert werden.

import java.io.*;

public class CharacterStreamSerializationDemo {
    public static void main(String[] args) {
        // 将对象序列化为字符流
        try {
            // 创建一个待序列化的对象
            Person person = new Person("Tom", 30);
            
            // 创建一个Writer
            FileWriter fileWriter = new FileWriter("person.txt");
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            ObjectWriter objectWriter = new ObjectWriter(bufferedWriter);
            
            // 将对象写入字符流
            objectWriter.writeObject(person);
            
            // 关闭字符流
            objectWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // 将字符流反序列化为对象
        try {
            // 创建一个Reader
            FileReader fileReader = new FileReader("person.txt");
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            ObjectReader objectReader = new ObjectReader(bufferedReader);
            
            // 读取对象数据
            Person person = (Person) objectReader.readObject();
            
            // 打印对象数据
            System.out.println(person.getName());   // 输出：Tom
            System.out.println(person.getAge());    // 输出：30
            
            // 关闭字符流
            objectReader.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Person implements Serializable {
    private String name;
    private int age;
    
    // 构造方法、getter和setter省略
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Im obigen Code serialisieren wir das Objekt über die Klassen FileWriter, BufferedWriter und ObjectWriter in einen Zeichenstrom und schreiben es in die Datei. Anschließend wird der Zeichenstrom in der Datei über die Klassen FileReader, BufferedReader und ObjectReader in ein Objekt deserialisiert, und schließlich können die Attributwerte des Objekts ausgedruckt werden.

3. Hinweise

Wenn Sie in Java Serialisierung und Deserialisierung verwenden, um Objektpersistenz zu erreichen, müssen Sie die folgenden Punkte beachten:

1. Die Klasse des Objekts muss die serialisierbare Schnittstelle implementieren, andernfalls können Serialisierung und Deserialisierung nicht durchgeführt werden . Serialisierung.

2. Alle referenzierten Objekte innerhalb der serialisierten Klasse müssen ebenfalls serialisierbar sein.
3. Die Felder serialisierter und deserialisierter Klassen können von beliebigem Typ sein, einschließlich benutzerdefinierter Klassen, Basisdatentypen, Sammlungstypen usw.
4. Die Felder serialisierter und deserialisierter Klassen können vorübergehend geändert werden und bleiben nicht bestehen.

Fazit:

Durch die Einleitung dieses Artikels haben wir gelernt, was Serialisierung und Deserialisierung sind, und anhand von Codebeispielen gezeigt, wie Serialisierung und Deserialisierung in Java verwendet werden, um Objektpersistenz zu erreichen. In der tatsächlichen Entwicklung kann eine langfristige Speicherung und Übertragung von Objekten erreicht werden, indem je nach Bedarf eine geeignete Serialisierungsmethode ausgewählt und Serialisierungsspezifikationen und Vorsichtsmaßnahmen befolgt werden.

Das obige ist der detaillierte Inhalt vonWie erreicht man die Persistenz von Objekten durch Serialisierung und Deserialisierung in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!