Curs 4
Serializarea obiectelor

• Ce este serializarea ?
• Serializarea obiectelor
  • Clasa ObjectOutputStream
  • Clasa ObjectInputStream
• Obiecte serializabile
  • Implementarea interfetei Serializable
  • Personalizarea serializarii obiectelor
  • Implementarea interfetei Externalizable
• Controlul serializarii (cuvântul cheie transient)
• Exemplu de folosire a serializarii
• Folosirea serializarii pentru copierea obiectelor

Definitie

Serializarea este o metoda ce permite transformarea unui obiect într-o secventa de octeti din care sa poata fi refacut ulterior obiectul original. Cu alte cuvinte, serializarea permite salvarea într-o maniera unitara a datelor împreuna cu signatura unui obiect pe un mediu de stocare a informatiei extern programului. Procesul invers de citirea a unui obiect serializat pentru a-i reface starea originala se numeste deserializare. Intr-un cadru mai larg, prin serializare se întelege procesul de scriere/citire a obiectelor.

• Compensarea diferentelor între sisteme de operare, adica putem crea un obiect pe o masina Windows, îl serializam, apoi îl trimitem prin retea catre o masina UNIX unde va fi corect reconstruit. In acest fel comunicarea între sisteme diferite se realizeaza unitar, independent de reprezentarea datelor, ordinea octetilor sau alte detalii specifice sistemelor repective.
• Permite persistenta obiectelor, ceea ce înseamna ca durata de viata a unui obiect nu este determinata de executia unui program în care acesta este definit - obiectul poate exista si între apelurile programelor care îl folosesc. Acest lucru se realizeaza prin serializarea obiectului si scrierea lui pe disc înainte de terminarea unui program, apoi, la relansarea programului, obiectul va fi citit de pe disc si starea lui refacuta. Acest tip de persistenta a obiectelor se numeste persistenta usoara, întrucât ea trebuie efectuata explicit de catre programator si nu este realizeazata automat de catre sistem.
• RMI (Remote Method Invocation) - comunicarea obiectelor prin socket-uri: este o modalitate prin care obiectele de pe o alta masina se comporta ca si când ar exista pe masina pe care ruleaza programul nostru. Atunci când este trimis un mesaj catre un obiect "remote" (de pe alta masina), serializarea este necesara pentru transportul argumentelor prin retea si pentru returnarea valorilor.
• Java Beans - sunt componente grafice definite de utilizator si care pot fi folosite la fel ca si componentele grafice standard. Orice componenta Bean are o stare initiala a informatiilor sale, stare care este specificata la definirea sa. Atunci când ea este folosita într-un program aceasta stare trebuie încarcata de undeva, ceea ce înseamna ca aceste componente trebuie serializate si salvate pe disc.

	private void readObject(ObjectInputStream stream)	//salvare obiect
		throws IOException,ClassNotFoundException;

	private void writeObject(ObjectOutputStream stream)	//refacere obiect
		throws IOException;				

	final void defaultWriteObject() 
		throws IOException
	final void defaultReadObject() 
		throws IOException,ClassNotFoundException,NotActiveException

	FileOutputStream out = new FileOutputStream("theTime");
	ObjectOutputStream s = new ObjectOutputStream(out);
	s.writeObject("Today");
	s.writeObject(new Date());
	s.flush();
	s.close();

	FileOutputStream out = new FileOutputStream("t.tmp");
	ObjectOutputStream s = new ObjectOutputStream(out);
	s.writeInt(12345);
	s.writeDouble(12.345);
	s.writeUTF("Sir de caractere");
	s.flush();
	s.close();

	FileInputStream in = new FileInputStream("theTime");
	ObjectInputStream s = new ObjectInputStream(in);
	String today = (String)s.readObject();
	Date date = (Date)s.readObject();

	FileInputStream in = new FileInputStream("t.tmp");
	ObjectInputStream s = new ObjectInputStream(in);
	int n = s.readInt();
	double d = s.readDouble(12.345);
	String sir = s.readUTF();

Atentie

Ca si la celelate fluxuri de date (care implemeteaza interfata DataInput) citirea dintr-un flux de obiecte trebuie sa se faca exact în ordinea în carea acestea au fost scrise.

	Date date = s.readObject();		// ilegal
	Date date = (Date)s.readObject();	// corect

		package java.io;
		public interface Serializable {
			// nimic!
		}

	public class ClasaSerializabila implements Serializable {
		//putem sa nu scriem nici o metoda deoarece
		//interfata nu declara nici o metoda!
	}

	private void writeObject(ObjectOutputStream stream)
		throws IOException
	private void readObject(ObjectInputStream stream)
		throws IOException, ClassNotFoundException

	private void writeObject(ObjectOutputStream s)
			throws IOException {
		s.defaultWriteObject();
		// personalizarea serializarii
	}

	private void readObject(ObjectInputStream s)
			throws IOException,ClassNotFoundException {
		s.defaultReadObject();
		// personalizarea deserializarii
		. . .
		// actualizarea starii obiectului (daca e necesar)
	}

	package java.io;
	public interface Externalizable extends Serializable {
		public void writeExternal(ObjectOutput out)
			throws IOException;
		public void readExternal(ObjectInput in)
			throws IOException, ClassNotFoundException;
	}

	transient private String parola;	//ignorat la serializare

Atentie

Modificatorul static anuleaza efectul modificatorului transient;

	static transient private String parola;	//participa la serializare

De asemenea, nu participa la serializare sub-obiectele neserializabile ale unui obiect, adica cele ale caror clase nu au fost declarate ca implementând interfata Serializable (sau Externalizable).

Exemplu: (câmpurile marcate 'DA' participa la serializare, cele marcate 'NU', nu participa)
	class A { ... }
	class B implements Serializable { ... }
	public class Test implements Serializable {
		private int x;			// DA
		transient public int y;		// NU
		static int var1;		// DA
		transient static var2;		// DA
		A a;				// NU
		B b1;				// DA
		transient B b2;			// NU
	}

Atunci când o clasa serializabila deriva dintr-o alta clasa, salvarea câmpurilor clasei parinte se va face doar daca si aceasta este serializabila. In caz contrar, subclasa trebuie sa salveze explicit si câmpurile mostenite.

Ex1: class Parinte implements Serializable {
		int x;
	}
	class Fiu extends Parinte implements Serializable {
		int y;
	}//La serializarea obiectelor de tip Fiu se salveaza atât x cât si y.

Ex2: class Parinte {
		int x;
	}
	class Fiu extends Parinte implements Serializable {
		int y;
	}//Serializarea nu decurge normal.

Exemplu de folosire a serializarii

import java.io.*;
public class TestSerializare {
	public static void main(String args[]) throws IOException {
		MyObject obj = new MyObject(10, 20, 30);

		//salvam obiectul in fisierul "fisier.tmp"
		FileOutputStream fout = new FileOutputStream("fisier.tmp");
		ObjectOutputStream sout = new ObjectOutputStream(fout);
		
		sout.writeObject(obj);
		sout.flush();

		sout.close();
		fout.close();
		System.out.println("A fost salvat obiectul " + obj);

		System.out.println("Restauram...");
		FileInputStream fin = new FileInputStream("fisier.tmp");
		ObjectInputStream sin = new ObjectInputStream(fin);
		try {
			obj = (MyObject) sin.readObject();
		} catch (ClassNotFoundException e) {}
				
		sin.close();
		fin.close();
		System.out.println("A fost restaurat obiectul " + obj);
	}
}

class MyObject implements Serializable {
	int x;				//este salvat
	transient private int y;	//nu este salvat
	transient static int z;	//nu este salvat

	public MyObject(int x, int y, int z) {
		this.x = x;
		this.y = y;
		this.z = z;
	}
	public String toString() {
		return new String("x=" + x + ", y=" + y + ", z=" + z); 
	}
}

Rezultatul acestui program va fi :

	A fost salvat obiectul x=10, y=20, z=30
	Restauram...
	A fost restaurat obiectul x=10, y=0, z=30

Folosirea serializarii pentru copierea obiectelor

Se stie ca nu putem copia un obiect prin instructiunea de atribuire. O secventa de forma:

	MyObject o1 = new MyObject(10, 20, 30);
	MyObject o2 = o1;

nu face decât sa declare obiectul o2 ca fiind o referinta la obiectul o1 si prin urmarea orice schimbare într-unul din cele doua obiecte se va reflecta si în celalalt.

O posibilitate de a face o copie unui obiect este folosirea metodei clone() a clasei Object.

	MyObject o1 = new MyObject(10, 20, 30);
	MyObject o2 = (MyObject) o1.clone();

Conversia la clasa MyObject este necesara deoarece metoda clone() returneaza un obiect de tip Object. Deficienta acestei metode este ca nu functioneaza corect decât atunci când clasa clonata nu are câmpuri referinta ca alte obiecte, obiectele referite nemaifiind copiate la rândul lor.
O metoda clone() care sa realizeze o copie efectiva a unui obiect, împreuna cu copierea tuturor obiectelor referite de câmpurile acelui obiect poate fi implementata prin mecanismul serializarii astfel:

public Object clone() {
	try {
		ByteArrayOutputStream bout = new ByteArrayOutputStream();
		ObjectOutputStream out = new ObjectOutputStream(bout);
		out.writeObject(this);
		out.close();

		ByteArrayInputStream bin = new ByteArrayInputStream();
		ObjectInputStream in = new ObjectInputStream(bin);

		Object ret = in.readObject();
		in.close();
		return ret;

	} catch (Exception e) { 
		System.out.println(e); 
		return null;
	}
}

---