Serializacja

Z Wikipedii

Serializacja – w programowaniu komputerów proces przekształcania obiektów, tj. instancji określonych klas, do postaci szeregowej, czyli w strumień bajtów, z zachowaniem aktualnego stanu obiektu. Serializowany obiekt może zostać utrwalony w pliku dyskowym, przesłany do innego procesu lub innego komputera poprzez sieć. Procesem odwrotnym do serializacji jest deserializacja. Proces ten polega na odczytaniu wcześniej zapisanego strumienia danych i odtworzeniu na tej podstawie obiektu klasy wraz z jego stanem bezpośrednio sprzed serializacji.

Serializacja służy do zapisu stanu obiektu, a później do odtworzenia jego stanu. Mechanizm ten jest używany między innymi w platformach .NET, Java, PHP.

Dalsza część opisu traktuje o serializacjii na gruncie platformy .NET Framework.

Spis treści 1 Jak działa serializacja? 2 Serializacja w .NET Framework 3 Formatery 4 Serializacja w języku Java

[edytuj] Jak działa serializacja?

[edytuj] Serializacja w .NET Framework

Istnieją dwa sposoby serializacji:

• poprzez użycie atrybutu Serializable
• poprzez implementację interfejsu ISerializable

Poniżej znajduje się przykład klasy serializowanej w języku Delphi for .NET:

 type
 [Serializable] // Serializuj klasę
 TSerializableClass = class
   FName: System.&String;
   FValue: System.Int32;
   [NonSerialized] // Nie serializuj poniższego pola
   FNonSerialized: System.Int16;
 end;

Klasa zawiera trzy pola, przy czym jedno z nich - FNonSerialized - nie będzie serializowane (wskazuje na to atrybut NonSerialized).

Środowisko .NET oferuje dwa podstawowe formaty zapisu (formatery) serializowanych klas: binarny oraz SOAP.

Środowisko uruchomieniowe CLR podczas procesu serializacji tworzy graf obiektu. Każdy obiekt posiada swój identyfikator. Wszystkie obiekty odwołujące się do serializowanego obiektu są wiązane z obiektem głównym.

[edytuj] Formatery

Zadaniem formatera jest konwersja obiektu do formatu, w którym zostanie zserializowany obiekt, lub z którego zostanie zdeserializowany. Platforma .NET udostępnia dwa podstawowe formatery: binarny (obiekt zostanie zapisany jako ciąg zero-jedynkowy; formater zdefiniowany w przestrzeni nazw System.Runtime.Serialization.Formatters.Binary) oraz SOAP (obiekt zostanie zapisany w formacie XML; formater zdefiniowany w przestrzeni nazw System.Runtime.Serialization.Formatters.SOAP). System formaterów jest rozszerzalny..

[edytuj] Serializacja w języku Java

By obiekt mógł być serializowany musi implementować interface Serializable. Dla wygody sporo standardowych klas javy implementuje ten interface, nie ma więc potrzeby wyprowadzć np. własnego obiektu będącego dzieckiem klasy Vector.

Jeśli będziesz serializował obiekt który agreguje inne obiekty to serializacji ulegnie cała hierarchia obiektów, jednak każdy z nich musi implementować interface Serializable. Przykładem może być serializacja wyżej wspomnianego wektora.

Ważna uwaga Jeśli zmieni się klasa obiektu który zserializowałeś to nie uda Ci się takiego obiektu zdeserializować używając nowej implementacji obiektu. Unikaj więc przenoszenia logiki do serializowanych danych.

Popatrz na przykład:

 package test;
 
 import java.io.Serializable;
 
 public class Acount implements Serializable {
   private String surname = null;
   private String firstname = null;
   
   public Acount (String surname, String firstname) {
     this.surname = surname;
     this.firstname = firstname;
   }
   
   public String getFirstname() {
     return firstname;
   }
   
   public String getSurname() {
     return surname;
   }
   
 }

Zauważ, że interface Serializable nie wymaga od Ciebie implementacji żadnej metody. Każdy obiekt który zaimplementował interface Serializable możesz serializować/deserializować do/ze strumienia. Dla naszego powyższego przykładu i serializacji do pliku o nazwie test.ser mogło by to wyglądać tak jak poniżej:

 Acount a = new Acount("Jan","Nowak");
 FileOutputStream fos = null;
 ObjectOutputStream oos = null;
 /*
  * Zapis do strumienia (plikowego, ale może być dowolne)
  */
 try {
   fos= new FileOutputStream("test.ser"); //utworzenie strumienia wyjściowego
   oos = new ObjectOutputStream(fos);  //utworzenie obiektu zapisującego do strumienia
   
   oos.writeObject(a); //serializacja obiektu
   
 } catch (FileNotFoundException e) {
   e.printStackTrace();
 } catch (IOException e) {
   e.printStackTrace();
 } finally {
   // zasoby zwalniamy w finally a nie na pałe!!
   try {
     if (oos != null) oos.close();
   } catch (IOException e) {}
   try {
     if (fos != null) fos.close();
   } catch (IOException e) {}
 }

Odczytuje się tak samo, ale używa obiektów odczytu a nie zapisu:

 Acount b = null;
 /*
  * Odczyt ze strumienia plikowego (ale może być dowolne)
  */
 FileInputStream fis = null;
 ObjectInputStream ois = null;
 try {
   fis = new FileInputStream("test.ser"); //utworzenie strumienia wejściowego  
   ois = new ObjectInputStream(fis); //utworzenie obiektu odczytującego obiekty ze strumienia
   
   b = (Acount) ois.readObject(); //deserializacja obiektu
 
 } catch (FileNotFoundException e) {
   e.printStackTrace();
 } catch (IOException e) {
   e.printStackTrace();
 } catch (ClassNotFoundException e) {
   e.printStackTrace();
 } finally {
   // zasoby zwalniamy w finally a nie na pałe!!
   try {
     if (ois != null) ois.close();
   } catch (IOException e) {}
   try {
     if (fis != null) fis.close();
   } catch (IOException e) {}
 }