Bagaimana untuk mencapai kegigihan objek menggunakan serialisasi dan deserialisasi di Jawa?

Bagaimana untuk mencapai ketekunan objek menggunakan pensirilan dan penyahserikatan dalam Java?

Pengenalan:
Dalam pembangunan Java, ketekunan objek ialah cara penting untuk mencapai penyimpanan data jangka panjang. Pensirian dan penyahserikatan adalah salah satu cara yang biasa digunakan untuk mencapai kegigihan objek di Jawa. Artikel ini akan memperkenalkan konsep bersiri dan penyahserikatan dan cara menggunakan pensirilan dan penyahserikatan dalam Java untuk mencapai kegigihan objek.

1. Apakah pesirilan dan penyahserilan?
Siri ialah proses menukar objek kepada aliran bait supaya objek boleh disalin dan dihantar semasa operasi seperti penghantaran rangkaian atau menyimpan ke cakera. Deserialisasi ialah proses menukar semula aliran bait kepada objek dan memulihkan keadaan dan data objek. Di Java, pensirilan objek dan penyahserikatan dicapai dengan melaksanakan antara muka Boleh Bersiri.

2. Cara melaksanakan siri
Java menyediakan dua kaedah siri utama, iaitu siri berasaskan aliran bait dan siri berasaskan aliran aksara.

1. Pensirian berdasarkan aliran bait
Pensirian berdasarkan aliran bait boleh dilaksanakan melalui kelas ObjectOutputStream dan ObjectInputStream. Berikut ialah kod sampel yang menunjukkan cara mensiri dan menyahsiri objek menggunakan pendekatan berasaskan aliran bait.

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

Dalam kod di atas, kami mula-mula mencipta objek Orang untuk disiri, dan kemudian mensirikan objek itu ke dalam aliran bait melalui kelas FileOutputStream dan ObjectOutputStream dan menulisnya pada fail. Seterusnya, kami menyahsiri aliran bait dalam fail menjadi objek melalui kelas FileInputStream dan ObjectInputStream, dan akhirnya mencetak nilai atribut objek.

2. Pensirian berdasarkan aliran aksara
Pensiran berdasarkan aliran aksara boleh dilaksanakan melalui kelas ObjectWriter dan 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;
    }
}

Dalam kod di atas, kami menyerikan objek ke dalam aliran aksara melalui kelas FileWriter, BufferedWriter dan ObjectWriter dan menulisnya pada fail. Kemudian, aliran aksara dalam fail dinyahsiri menjadi objek melalui kelas FileReader, BufferedReader dan ObjectReader, dan akhirnya nilai atribut objek boleh dicetak.

3. Nota
Apabila menggunakan pensirilan dan penyahserilan dalam Java untuk mencapai ketekunan objek, anda perlu memberi perhatian kepada perkara berikut:

1 Kelas objek mesti melaksanakan antara muka Bersiri, jika tidak, pensirilan dan penyahserilan tidak boleh dilakukan .
2. Semua objek yang dirujuk dalam kelas bersiri juga mesti boleh bersiri.
3 Medan kelas bersiri dan desiri boleh terdiri daripada sebarang jenis, termasuk kelas tersuai, jenis data asas, jenis pengumpulan, dsb.
4. Medan kelas bersiri dan desiri boleh diubah suai sementara, dan ia tidak akan berterusan.

Kesimpulan:
Melalui pengenalan artikel ini, kami mempelajari apa itu serialisasi dan deserialisasi, dan menunjukkan melalui contoh kod cara menggunakan serialisasi dan deserialisasi dalam Java untuk mencapai kegigihan objek. Dalam pembangunan sebenar, penyimpanan jangka panjang dan penghantaran objek boleh dicapai dengan memilih kaedah bersiri yang sesuai mengikut keperluan dan mengikut spesifikasi dan langkah berjaga-jaga bersiri.

Atas ialah kandungan terperinci Bagaimana untuk mencapai kegigihan objek menggunakan serialisasi dan deserialisasi di Jawa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!