Serialization. Ang simula.

"Maaalala mo ba na ngayon ay sinisiyasat namin ang pag-save ng mga bagay at binabasa ang mga ito mula sa isang file?"

"Oo, nag-save lang kami sa isang output stream, isang nabasa mula sa isang input stream."

"Magaling, Amigo. Nakakatuwang marinig na napapansin mo ang mga detalyeng ito. Makukumpleto mo ba ang code para ma-save ito at mabasa mula sa isang file?"

"Kumpletuhin ang ano?! Magdeklara ng isang FileInputStream at FileOutputStream at ipasa ang mga ito sa mga paraan ng pag-save at pag-load. Walang dapat malito dito. Super simple."

"I'm happy for you. Now for a new topic: serialization ."

Ang pagse-serye ay halos kapareho ng ginawa namin, ngunit mas cool at binuo mismo sa Java machine. Ang Java machine ay maaaring mag-imbak at mag-load ng mga bagay nito. Hindi nito kailangan ang mga paraan ng pag-save at pag-load para magawa ito: Ang lahat ng mga bagay ay nakaimbak sa loob ng Java machine, at mayroon itong ganap na access sa mga ito."

Kinukuha lang namin ang bagay at i-save ito sa isang stream at basahin mula sa isang stream:

public static void main(String[] args) throws Exception
{
 Cat cat = new Cat();

 //Save a cat to file
 FileOutputStream fileOutput = new FileOutputStream("cat.dat");
 ObjectOutputStream outputStream = new ObjectOutputStream(fileOutput);
 outputStream.writeObject(cat);
 fileOutput.close();
 outputStream.close();

 //Load a cat from file
 FileInputStream fiStream = new FileInputStream("cat.dat");
 ObjectInputStream objectStream = new ObjectInputStream(fiStream);
 Object object = objectStream.readObject();
 fiStream.close();
 objectStream.close();

 Cat newCat = (Cat)object;
}

"Ayan yun?"

"Eksakto. Mayroong napakalaki at kumplikadong mekanismo ng serialization na hinahayaan kaming mag-save sa isang stream at magbasa mula sa isang stream ng halos anumang uri ng data."

"Halos kahit ano. So walang data type?"

"Oo, ang katotohanan ay hindi lahat ng mga bagay ay may likas na kakayahang i-save . Ang ilang mga bagay ay hindi nag-iimbak ng lahat ng kanilang data sa loob. Sa halip, sila ay sumangguni lamang sa iba pang mga bagay at/o mga mapagkukunan ng data. Halimbawa, ang console (System. in), isang input stream (InputStream), at iba pang mga bagay."

Iyon ang dahilan kung bakit ang mga tagalikha ng Java ay nagkaroon ng espesyal na Serializable interface marker . Tinatawag itong marker , dahil hindi ito naglalaman ng anumang data at pamamaraan. Ginagamit lang ito sa "tag" o "mark" ng mga klase. Kung naniniwala kami na iniimbak ng aming klase ang lahat ng data nito sa loob, maaari naming markahan ito ng mga implement na Serializable .

Narito ang isang halimbawa ng «cat» na may suporta para sa serialization:

class Cat implements Serializable
{
 public String name;
 public int age;
 public int weight;
}

Kapag sinubukan naming i-serialize (i-save) ang isang bagay, sinusuri ng Java machine kung sinusuportahan nito ang serialization: Ipinapatupad ba nito ang Serializable interface? Kung gagawin nito, pagkatapos ay sine-save nito ang bagay. Kung hindi, pagkatapos ay magtapon ito ng isang pagbubukod upang ipahiwatig na ang serialization ay imposible.
Dito kailangan mong maunawaan na ang isang serializable na bagay ay dapat lamang binubuo ng mga serializable na bagay.

"Well, that makes sense. Hindi mo maililigtas ang kabuuan nang hindi nai-save ang mga bahagi nito."

"Eksakto."

"At paano naman ang ints, Strings, at ArrayLists?"

"Lahat sila ay sumusuporta sa serialization. Espesyal na pangangalaga ng mga tagalikha ng Java upang matiyak na nangyari ito. Hindi dapat magkaroon ng anumang mga problema dito."

Bukod dito, ang uri ng isang bagay ay nai-save kapag ang bagay ay serialized. Ngayon ay makakapag-save ka ng reference sa isang Cat object sa isang Object variable. Lahat ay magse-serialize at magde-deserialize nang maayos.

"Deserialize?"

" Ang deserialization ay ang proseso ng pag-reverse ng serialization: pagbabasa at muling pagbuo ng isang bagay mula sa isang stream/file."

"Ah, wala nang tanong."