Comment obtenir la persistance des objets en utilisant la sérialisation et la désérialisation en Java ?

Comment obtenir la persistance des objets en utilisant la sérialisation et la désérialisation en Java ?

Introduction : 
Dans le développement Java, la persistance des objets est un moyen important de parvenir à un stockage à long terme des données. La sérialisation et la désérialisation sont l'un des moyens couramment utilisés pour assurer la persistance des objets en Java. Cet article présentera les concepts de sérialisation et de désérialisation et comment utiliser la sérialisation et la désérialisation en Java pour obtenir la persistance des objets.

1. Que sont la sérialisation et la désérialisation ?
La sérialisation est le processus de conversion d'un objet en flux d'octets afin que l'objet puisse être copié et transmis lors d'opérations telles que la transmission réseau ou l'enregistrement sur disque. La désérialisation est le processus de reconversion d'un flux d'octets en objet et de restauration de l'état et des données de l'objet. En Java, la sérialisation et la désérialisation des objets sont réalisées en implémentant l'interface Serialisable.

2. Comment implémenter la sérialisation
Java propose deux méthodes de sérialisation principales, à savoir la sérialisation basée sur le flux d'octets et la sérialisation basée sur le flux de caractères.

1. Sérialisation basée sur un flux d'octets
La sérialisation basée sur un flux d'octets peut être implémentée via les classes ObjectOutputStream et ObjectInputStream. Voici un exemple de code qui montre comment sérialiser et désérialiser des objets à l'aide d'une approche basée sur le flux d'octets.

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

Dans le code ci-dessus, nous créons d'abord un objet Person à sérialiser, puis sérialisons l'objet dans un flux d'octets via les classes FileOutputStream et ObjectOutputStream et l'écrivons dans le fichier. Ensuite, nous désérialisons le flux d'octets du fichier en un objet via les classes FileInputStream et ObjectInputStream, et enfin imprimons les valeurs d'attribut de l'objet.

2. Sérialisation basée sur un flux de caractères
La sérialisation basée sur un flux de caractères peut être implémentée via les classes ObjectWriter et ObjectReader.

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

Dans le code ci-dessus, nous sérialisons l'objet dans un flux de caractères via les classes FileWriter, BufferedWriter et ObjectWriter et l'écrivons dans le fichier. Ensuite, le flux de caractères dans le fichier est désérialisé en un objet via les classes FileReader, BufferedReader et ObjectReader, et enfin les valeurs d'attribut de l'objet peuvent être imprimées.

3. Remarques
Lorsque vous utilisez la sérialisation et la désérialisation en Java pour obtenir la persistance d'un objet, vous devez faire attention aux points suivants :

1. La classe de l'objet doit implémenter l'interface Serialisable, sinon la sérialisation et la désérialisation ne peuvent pas être effectuées. . sérialisation.
2. Tous les objets référencés dans la classe sérialisée doivent également être sérialisables.
3. Les champs des classes sérialisées et désérialisées peuvent être de n'importe quel type, y compris des classes personnalisées, des types de données de base, des types de collection, etc.
4. Les champs des classes sérialisées et désérialisées peuvent être modifiés de manière transitoire et ils ne seront pas conservés.

Conclusion : 
Grâce à l'introduction de cet article, nous avons appris ce que sont la sérialisation et la désérialisation et démontré, à travers des exemples de code, comment utiliser la sérialisation et la désérialisation en Java pour obtenir la persistance des objets. Dans le développement réel, le stockage et la transmission à long terme des objets peuvent être obtenus en sélectionnant une méthode de sérialisation appropriée en fonction des besoins et en suivant les spécifications et précautions de sérialisation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!