Bagaimana Pensirian Berfungsi di Java

Dalam artikel ini, kami akan menerangkan apa itu serialisasi dan cara ia berfungsi dalam Java.

pengenalan

Pensirian objek ialah keupayaan objek untuk menyimpan salinan lengkap dirinya dan sebarang objek lain yang dirujuknya menggunakan aliran keluaran (contohnya, ke fail luaran). Dengan cara ini, objek boleh dicipta semula daripada salinan bersiri (disimpan) sedikit kemudian apabila diperlukan. Pensirian objek, ciri baharu yang diperkenalkan dalam JDK 1.1, menyediakan fungsi untuk menukar kumpulan atau objek individu, menjadi aliran bit atau tatasusunan bait, untuk penyimpanan atau penghantaran melalui rangkaian. Dan seperti yang dinyatakan, aliran bit atau tatasusunan bait yang diberikan boleh ditukar kembali ke objek Java. Ini terutamanya berlaku secara automatik terima kasih kepada ObjectInputStreamdan kelas ObjectOutputStream. Pengaturcara boleh memutuskan untuk melaksanakan fungsi ini dengan melaksanakan antara muka Serializablesemasa mencipta kelas. Proses penyiaran juga dikenali sebagai pemarshaling objek , manakala penyahserikatan dikenali sebagai pembongkaran . Serialisasi ialah mekanisme yang membenarkan objek menyimpan salinan dirinya sendiri dan semua objek lain yang dirujuk oleh objek itu ke fail luaran menggunakan ObjectOutputStream. Objek yang disimpan boleh menjadi struktur data, gambar rajah, objek kelas JFrameatau sebarang objek lain, tanpa mengira jenisnya. Pada masa yang sama, bersiri menyimpan maklumat tentang jenis objek supaya kemudian, apabila dinyahsiri, maklumat itu digunakan untuk mencipta semula jenis objek yang tepat. Jadi, serialisasi menyediakan keupayaan berikut:

• Sistem untuk menyimpan objek, iaitu: menyimpan sifatnya ke fail luaran, ke cakera atau ke pangkalan data.
• Sistem panggilan prosedur jauh.
• Sistem pengedaran objek, contohnya, dalam komponen perisian seperti COM, COBRA.
• Sistem untuk mengenal pasti perubahan dalam data berubah mengikut masa.

Untuk memahami sepenuhnya konsep bersiri, anda perlu mempunyai pemahaman yang jelas tentang dua konsep yang lain—kegigihan objek dan kegigihan benang. Di sini kita akan bercakap sedikit tentang setiap daripada mereka untuk diingati. Penjelasan penuh tentang mereka akan memerlukan bab yang berasingan untuk setiap konsep ini.

Strim:

Setiap program mesti menulis datanya ke lokasi storan atau paip, dan setiap program mesti membaca data dari paip atau lokasi storan. Di Java, saluran ini tempat program menulis kepada dan dari mana program membaca data dipanggil Streams ( Stream) . Rajah 1. Perwakilan grafik bagi Benang Aliran terutamanya dibahagikan kepada dua jenis:

• Kelas aliran bait dipanggil *Strim
• Kelas aliran aksara dipanggil *Pembaca dan *Penulis

Setiap aliran penulisan data mengandungi satu set kaedah penulisan. Dan setiap utas bacaan data, oleh itu, mempunyai set kaedah membaca yang serupa. Setelah benang dibuat, semua kaedah ini mesti dipanggil.

Kegigihan

Kegigihan objek ialah keupayaan objek untuk hidup atau, dengan kata lain, untuk "bertahan" dalam pelaksanaan program. Ini bermakna bahawa mana-mana objek yang dicipta semasa runtime dimusnahkan oleh JVM scavenger apabila objek itu tidak lagi digunakan. Tetapi jika API kegigihan dilaksanakan, objek ini tidak akan dimusnahkan oleh JVM scavenger, sebaliknya mereka akan dibenarkan untuk "hidup", yang juga memungkinkan untuk mengaksesnya pada kali berikutnya aplikasi dilancarkan. Dalam erti kata lain, ketekunan bermakna terdapat seumur hidup untuk objek, bebas daripada hayat aplikasi yang sedang berjalan. Salah satu cara untuk melaksanakan kegigihan adalah dengan menyimpan objek di suatu tempat dalam fail luaran atau pangkalan data, dan kemudian memulihkannya kemudian menggunakan fail atau pangkalan data tersebut sebagai sumber. Di sinilah siri memainkan peranan. Sebarang objek tidak berterusan wujud selagi JVM sedang berjalan. Objek bersiri hanyalah objek yang ditukar menjadi strim, yang kemudiannya disimpan ke fail luaran atau dipindahkan melalui rangkaian untuk penyimpanan dan pemulihan.

Pelaksanaan antara muka Serializable

Mana-mana kelas mesti melaksanakan antara muka java.io.Serializableuntuk menyerikan objek kelas itu. Antara muka Serializabletidak mempunyai kaedah dan hanya menandakan kelas supaya ia boleh dikenal pasti sebagai boleh bersiri. Hanya medan objek kelas bersiri boleh disimpan. Kaedah atau pembina tidak disimpan sebagai sebahagian daripada aliran bersiri. Jika mana-mana objek bertindak sebagai rujukan kepada objek lain, maka medan objek itu juga bersiri jika kelas objek itu melaksanakan antara muka Serializable. Dalam erti kata lain, graf objek yang diperolehi ini boleh bersiri sepenuhnya. Graf objek termasuk pokok atau struktur medan objek dan subobjeknya. Dua kelas utama yang membantu melaksanakan antara muka Seriliazable:

• ObjectInputStream
• ObjectOutputStream

Penyenaraian 1. Contoh kelas mudah untuk menunjukkan siri

import java.io.*;
public class RandomClass implements Serializable {
 // Генерация рандомного значения
 private static int r() {
        return (int)(Math.random() * 10);
 }
    private int data[];
    // Конструктор
public RandomClass() {
        datafile = new int[r()];
        for (int i=0; i<datafile.length; i++)
        datafile[i]=r();
 }
    public void printout() {
 System.out.println("This RandomClass has "+datafile.length+" random integers");
 for (int i=0; i<datafile.length; i++) {
        System.out.print(datafile[i]+":");
        System.out.println();
    }
}

Dalam kod di atas, kelas dicipta yang boleh bersiri kerana "ditanda" oleh antara muka bersiri. Kelas mencipta tatasusunan integer rawak apabila contoh daripadanya dicipta. Kod di bawah menunjukkan keupayaan untuk menulis objek ke aliran menggunakan ObjectOutputStream. Program ini mempunyai tatasusunan integer, tetapi untuk bersiri kita tidak perlu mengulangi objek dalamannya. Antara muka Seriliazablemengurus ini secara automatik. Penyenaraian 2. Contoh mudah mensiri objek untuk output ke fail

import java.io.*;
import java.util.*;
public class OutSerialize {
    public static void main (String args[]) throws IOException {
        RandomClass rc1 = new RandomClass();
        RandomClass rc2 = new RandomClass();
//создание цепи потоков с потоком вывода an object в конце
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("objects.dat"));
        Date now = new Date(System.currentTimeMillis());
//java.util.* был импортирован для использования класса Date
        out.writeObject(now);
        out.writeObject(rc1);
        out.writeObject(rc2);
out.close();
        System.out.println("I have written:");
System.out.println("A Date object: "+now);
        System.out.println("Two Group of randoms");
rc1.printout();
rc2.printout();
 }
}

Kod di bawah menunjukkan keupayaan kelas ObjectInputStream, yang membaca data bersiri daripada fail luaran ke dalam atur cara. Ambil perhatian bahawa objek dibaca dalam susunan yang sama di mana ia ditulis pada fail. Penyenaraian 3. Membaca objek bersiri atau Desirialisasi

import java.io.*;
import java.util.*;
public class InSerialize {
 public static void main (String args[]) throws  IOException, ClassNotFoundException {
    ObjectInputStream in =  new ObjectInputStream (new FileInputStream("objects.dat"));
 Date d1 = (Date)in.readObject();
 RandomClass rc1 = (RandomClass)in.readObject();
    RandomClass rc2 = (RandomClass)in.readObject();
    System.out.println("I have read:");
    System.out.println("A Date object: "+d1);
    System.out.println("Two Group of randoms");
    rc1.printout();
rc2.printout();
 }
}

Hampir semua kelas Java boleh bersiri, termasuk kelas AWT. Bingkai, iaitu tetingkap, mengandungi satu set komponen grafik. Jika bingkai bersiri, enjin bersiri menguruskan perkara ini dan mensiri semua komponen dan datanya (kedudukan, kandungan, dsb.). Sesetengah objek kelas Java tidak boleh bersiri kerana ia mengandungi data yang merujuk sumber sistem pengendalian yang tidak kekal. Contohnya kelas java.io.FileInputStreamdan java.lang.Thread. Jika objek mengandungi rujukan kepada elemen tidak boleh bersiri, keseluruhan operasi bersiri akan gagal dan pengecualian akan dibuang NotSerializableException. Jika mana-mana objek merujuk kepada rujukan objek tidak bersiri, maka ia boleh disiri menggunakan kata kunci sementara . Penyenaraian 4. Mencipta objek boleh bersiri menggunakan kata kunci sementara

public class Sclass implements Serializable{
public transient Thread newThread;
//помните, что поток(поток параллельного исполнения) по умолчанию не сериализуемый класс
    private String studentID;
    private int sum;
}

Keselamatan dalam Serialisasi

Mensiri kelas dalam Java melibatkan penghantaran semua datanya ke fail luaran atau pangkalan data melalui aliran. Kami boleh mengehadkan data yang akan disiri bila-bila masa kami mahu. Terdapat dua cara untuk melakukan ini:

• Setiap parameter kelas yang diisytiharkan sebagai sementara tidak bersiri (secara lalai, semua parameter kelas bersiri)
• Atau, setiap parameter kelas yang ingin kita sirikan ditandakan dengan teg Externalizable(secara lalai, tiada parameter disiri).

Medan data tidak akan bersiri dengan ObjectOutputStream, apabila dipanggil pada objek, jika medan data objek itu ditandakan sementara . Sebagai contoh: private transient String password. Sebaliknya, untuk mengisytiharkan secara eksplisit data objek sebagai boleh bersiri, kita mesti menandakan kelas sebagai ExternalizablewriteExternalsecara eksplisit readExteranlmenulis dan membaca data objek itu.

Kesimpulan

Ciri siri objek digunakan dalam banyak sistem teragih sebagai cara untuk memindahkan data. Tetapi serialisasi mendedahkan butiran tersembunyi, sekali gus memusnahkan keaslian jenis data abstrak, yang seterusnya memusnahkan enkapsulasi. Pada masa yang sama, adalah baik untuk mengetahui bahawa data objek bersiri adalah data yang sama yang terdapat dalam objek asal yang asal. Ini juga merupakan peluang yang baik untuk melaksanakan antara muka ObjectInputValidationdan mengatasi kaedah validateObject(), walaupun berbilang baris kod digunakan. Jika objek tidak dijumpai, maka kita boleh membuang pengecualian dengan sewajarnya InvalidObjectException. Artikel asal: Cara bersiri berfungsi dalam Java