Czym jest serializacja obiektów? [duplikat]

Serializacja może być traktowana jako proces przekształcania instancji obiektu w sekwencję bajtów(która może być binarna lub nie w zależności od implementacji).

Jest to bardzo przydatne, gdy chcemy przesyłać dane jednego obiektu przez sieć, na przykład z jednego JVM do drugiego.

W Javie mechanizm serializacji jest wbudowany w platformę, ale musisz zaimplementować interfejs Serializable , aby obiekt mógł być serializowany.

Możesz także zapobiega serializacji niektórych danych w obiekcie, zaznaczając atrybut jako transient .

Wreszcie możesz nadpisać domyślny mechanizm i podać swój własny; może to być odpowiednie w niektórych szczególnych przypadkach. Aby to zrobić, należy użyć jednej z ukrytych funkcji w Javie.

Ważne jest, aby zauważyć, że serializowana jest "wartość" obiektu lub jego zawartość, a nie definicja klasy. W ten sposób metody nie są serializowane.

Oto bardzo podstawowa próbka z komentarzami ułatwiającymi jej czytanie:

import java.io.*;
import java.util.*;

// This class implements "Serializable" to let the system know
// it's ok to do it. You as programmer are aware of that.
public class SerializationSample implements Serializable {

    // These attributes conform the "value" of the object.

    // These two will be serialized;
    private String aString = "The value of that string";
    private int    someInteger = 0;

    // But this won't since it is marked as transient.
    private transient List<File> unInterestingLongLongList;

    // Main method to test.
    public static void main( String [] args ) throws IOException  { 

        // Create a sample object, that contains the default values.
        SerializationSample instance = new SerializationSample();

        // The "ObjectOutputStream" class has the default 
        // definition to serialize an object.
        ObjectOutputStream oos = new ObjectOutputStream( 
                               // By using "FileOutputStream" we will 
                               // Write it to a File in the file system
                               // It could have been a Socket to another 
                               // machine, a database, an in memory array, etc.
                               new FileOutputStream(new File("o.ser")));

        // do the magic  
        oos.writeObject( instance );
        // close the writing.
        oos.close();
    }
}

Kiedy uruchamiamy ten program, tworzony jest plik "o. ser" i możemy zobaczyć, co się za nim stało.

Jeśli zmienimy wartość: someInteger Na, na przykład Integer.MAX_VALUE , możemy porównać wyjście, aby zobaczyć jaka jest różnica.

Oto zrzut ekranu pokazujący dokładnie tę różnicę:

_{czy można dostrzec różnice? ;)}

Jest dodatkowe istotne pole w serializacji Javy: serialversionUID , ale myślę, że jest to już zbyt długie, aby je pokryć.

Odważny odpowiedzieć na 6-letnie pytanie, dodając tylko bardzo wysoki poziom zrozumienia dla osób nowych w Javie

Co to jest serializacja?

Konwersja obiektu na bajty i bajty z powrotem na obiekt (Deserializacja).

Kiedy stosowana jest serializacja?

Kiedy chcemy utrzymać obiekt. Kiedy chcemy, aby obiekt istniał poza żywotnością JVM.

Przykład Ze Świata Rzeczywistego:

Jak serializacja jest wykonywana w Javie.

1. Implementacja java.io.Serializable interface (interfejs znacznika więc nie ma metody do implementacji).

2. Persist the object: Use java.io.ObjectOutputStream class, a filter stream that is a wrapper About a lower-level byte stream (zapisanie obiektu do systemów plików lub przeniesienie spłaszczonego obiektu przez przewód sieciowy i przebudowanie po drugiej stronie).

   • writeObject(<<instance>>) - aby napisać obiekt
   • readObject() - do odczytu obiektu serializowanego

Zapamiętaj:

Podczas serializacji obiektu, zostanie zapisany tylko jego stan, a nie jego plik klasy lub metody.

Gdy serializujesz obiekt dwubajtowy, zobaczysz 51 bajtów serializowanego pliku.

Określa sposób serializacji i de-serializacji obiektu.

Odpowiedź na: jak przekonwertować plik na 51 bajtów?

• najpierw zapisuje magiczne dane strumienia serializacji (STREAM_MAGIC=" AC ED " i STREAM_VERSION = wersja JVM).
• następnie zapisuje metadane klasy powiązanej z instancją (długość klasy, nazwa klasy, serialVersionUID).
• następnie rekurencyjnie zapisuje metadane klasy nadrzędnej, aż znajdzie java.lang.Object.
• następnie zaczyna się od rzeczywistych danych powiązanych z instancją.
• na koniec zapisuje dane obiektów powiązanych z instancją, począwszy od metadanych do rzeczywistej zawartości.

Jeśli interesuje cię więcej informacji na temat serializacji Javy, sprawdź ten link .

Edit : jeszcze jeden dobry link do przeczytania.

To odpowie na kilka częstych pytań:

1. Jak nie serializować żadnego pola w klasie.
   Odp: użyj słowa kluczowego transient

2. Czy gdy Klasa dziecka jest serializowana, Klasa rodzica jest serializowana?
   ODP: nie, jeśli parent nie rozszerza Serializowalnego interfejsu pola parents nie są serializowane.

3. Czy gdy rodzic jest serializowany, Klasa dziecięca jest serializowana?
   Ans: tak, domyślnie Klasa potomna również jest serializowana.

4. Jak uniknąć serializacji klasy dziecięcej?
   Ans: a. Override metody writeObject i readObject oraz throw NotSerializableException.
   

   B. Możesz również zaznaczyć wszystkie pola przejściowe w klasie potomnej.

5. Niektóre klasy na poziomie systemowym, takie jak Thread, OutputStream i jego podklasy oraz Socket nie są serializowalne.
   

Serializacja polega na pobraniu obiektu" na żywo " do pamięci i przekonwertowaniu go do formatu, który może być gdzieś zapisany (np. w pamięci, na dysku), a później "deserializowany" z powrotem do żywego obiektu.

Podobał mi się sposób, w jaki @OscarRyz prezentuje. Chociaż tutaj kontynuuję historię serializacji , która została pierwotnie napisana przez @amitgupta.

Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:

Serializacja oznacza utrzymujące się obiekty w Javie. Jeśli chcesz zapisać stan obiektu i chcesz odbudować stan później (może być w innym JVM) można użyć serializacji.

Zauważ, że właściwości obiektu będą tylko zapisywane. Jeśli chcesz ponownie wskrzesić obiekt, powinieneś mieć plik klasy, ponieważ będą przechowywane tylko zmienne członkowskie, a nie funkcje Członkowskie.

Eg:

ObjectInputStream oos = new ObjectInputStream(                                 
                                 new FileInputStream(  new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();

Searializable jest interfejsem znacznika, który oznacza, że twoja klasa jest serializowalna. Interfejs znacznika oznacza, że jest to tylko pusty interfejs i użycie tego interfejsu powiadomi JVM, że ta klasa może być serializowalna.

Moje dwa grosze z własnego bloga:

Oto szczegółowe wyjaśnienie serializacji : (mój własny blog)

Serializacja:

Jaka jest potrzeba Serializacja?

We współczesnej architekturze zawsze istnieje potrzeba przechowywania stanu obiektu, a następnie jego pobierania. Na przykład w Hibernate, aby zapisać obiekt powinniśmy uczynić klasę Serializowalną. Po zapisaniu stanu obiektu w postaci bajtów można go przenieść do innego systemu, który może odczytać ze stanu i pobrać klasę. Stan obiektu może pochodzić z bazy danych lub innego jvm lub z oddzielnego komponentu. Z pomocą Serializacja możemy pobrać stan obiektu.

Przykład kodu i Wyjaśnienie:

Najpierw przyjrzyjmy się klasie Item:

public class Item implements Serializable{

    /**
    *  This is the Serializable class
    */
    private static final long serialVersionUID = 475918891428093041L;
    private Long itemId;
    private String itemName;
    private transient Double itemCostPrice;
    public Item(Long itemId, String itemName, Double itemCostPrice) {
        super();
        this.itemId = itemId;
        this.itemName = itemName;
        this.itemCostPrice = itemCostPrice;
      }

      public Long getItemId() {
          return itemId;
      }

     @Override
      public String toString() {
          return "Item [itemId=" + itemId + ", itemName=" + itemName + ", itemCostPrice=" + itemCostPrice + "]";
       }


       public void setItemId(Long itemId) {
           this.itemId = itemId;
       }

       public String getItemName() {
           return itemName;
       }
       public void setItemName(String itemName) {
            this.itemName = itemName;
        }

       public Double getItemCostPrice() {
            return itemCostPrice;
        }

        public void setItemCostPrice(Double itemCostPrice) {
             this.itemCostPrice = itemCostPrice;
        }
}

W powyższym kodzie widać, że item class implementuje Serializable .

Jest to interfejs, który umożliwia serializowanie klasy.

Teraz możemy zobaczyć zmienną o nazwie serialVersionUID {[34] } jest inicjalizowana do zmiennej Long. Liczba ta jest obliczana przez kompilator na podstawie stanu klasy i atrybutów klasy. Jest to liczba, która pomoże jvm zidentyfikować stan obiektu podczas odczytu stanu obiektu z pliku.

W tym celu możemy zajrzeć do oficjalnej dokumentacji Oracle:

Środowisko uruchomieniowe serializacji kojarzy się z każdą klasą serializowalną a numer wersji, zwany serialVersionUID, który jest używany podczas deserializacja w celu sprawdzenia, czy nadawca i odbiorca serializowanego obiekt mają załadowane klasy dla tego obiektu, które są zgodne z szacunek do serializacji. Jeśli odbiornik załadował klasę dla obiekt, który ma inny identyfikator serialVersionUID niż odpowiedniej klasy nadawcy, wówczas deserializacja spowoduje InvalidClassException. Klasa serializowalna może zadeklarować własną serialVersionUID jawnie deklarując pole o nazwie "serialVersionUID", który musi być statyczny, końcowy i typu long: ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L; jeżeli a Klasa serializable nie deklaruje jawnie identyfikatora serialVersionUID, następnie środowisko uruchomieniowe serializacji obliczy domyślną serialVersionUID wartość dla tej klasy w oparciu o różne aspekty klasy, jak opisano w serializacji obiektów Java (TM) Specyfikacja. Jednak zdecydowanie zaleca się, aby wszystkie klasy serializowalne jawnie deklarują wartości serialVersionUID, ponieważ domyślne obliczenia serialVersionUID są bardzo wrażliwe na klasę szczegóły, które mogą się różnić w zależności od implementacji kompilatora i mogą w ten sposób powoduje nieoczekiwane InvalidClassExceptions podczas deserializacja. Dlatego, aby zagwarantować spójny serialVersionUID wartości w różnych implementacjach kompilatorów Javy, serializowalny klasa musi zadeklarować jawną wartość serialVersionUID. Jest to również zdecydowanie zaleca się, aby jawne deklaracje serialVersionUID korzystały z modyfikator prywatny, o ile to możliwe, ponieważ takie deklaracje dotyczą tylko na natychmiast deklarujące pola class--serialVersionUID nie są przydatny jako dziedziczny członek.

Jeśli zauważyłeś, że jest inne słowo kluczowe, którego użyliśmy, to transient.

Jeśli pole nie jest serializowalne, musi być oznaczone jako transient. W tym miejscu zaznaczyliśmy itemCostPrice jako transient i nie chcemy, aby został zapisany w pliku

Przyjrzyjmy się teraz, jak zapisać stan obiektu w pliku, a następnie odczytać go z tam.

public class SerializationExample {

    public static void main(String[] args){
        serialize();
       deserialize();
    } 

    public static void serialize(){

         Item item = new Item(1L,"Pen", 12.55);
         System.out.println("Before Serialization" + item);

         FileOutputStream fileOut;
         try {
             fileOut = new FileOutputStream("/tmp/item.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut);
             out.writeObject(item);
             out.close();
             fileOut.close();
             System.out.println("Serialized data is saved in /tmp/item.ser");
           } catch (FileNotFoundException e) {

                  e.printStackTrace();
           } catch (IOException e) {

                  e.printStackTrace();
           }
      }

    public static void deserialize(){
        Item item;

        try {
                FileInputStream fileIn = new FileInputStream("/tmp/item.ser");
                ObjectInputStream in = new ObjectInputStream(fileIn);
                item = (Item) in.readObject();
                System.out.println("Serialized data is read from /tmp/item.ser");
                System.out.println("After Deserialization" + item);
        } catch (FileNotFoundException e) {
                e.printStackTrace();
        } catch (IOException e) {
               e.printStackTrace();
        } catch (ClassNotFoundException e) {
               e.printStackTrace();
        }
     }
}

W powyższym przykładzie możemy zobaczyć przykład serializacji i deserializacji obiektu.

Do tego użyliśmy dwóch klas. Do serializacji obiektu użyliśmy ObjectOutputStream. Do zapisu obiektu w pliku użyliśmy metody writeObject.

Do deserializacji użyliśmy ObjectInputStream, który odczytuje obiekt z pliku. Do odczytu danych obiektu z pliku służy readObject.

Wyjście powyższego kodu będzie like:

Before SerializationItem [itemId=1, itemName=Pen, itemCostPrice=12.55]
Serialized data is saved in /tmp/item.ser
After DeserializationItem [itemId=1, itemName=Pen, itemCostPrice=null]

Zauważ, że itemCostPrice Z deserializowanego obiektu jest null , ponieważ nie został napisany.

Omówiliśmy już podstawy serializacji Javy w części I tego artykułu.

Zacznijmy od serialversionuid.

SerialVersionUID jest używany jako kontrola wersji w klasie Serializowalnej.

Jeśli nie zadeklarujesz wprost serialVersionUID, JVM zrobi to za ciebie automatycznie, w oparciu o różne właściwości klasy Serializable.

Algorytm obliczania serialversionuid (więcej szczegółów tutaj)

1. nazwa klasy.
   1. modyfikatory klasy zapisane jako 32-bitowa liczba całkowita.
   2. nazwa każdego interfejsu posortowana według nazwy.
   3. dla każdego pola klasy posortowanego według nazwy pola (z wyjątkiem prywatnych pól statycznych i prywatnych pól przejściowych: Nazwa pola. Na modyfikatory pola zapisane jako 32-bitowa liczba całkowita. Deskryptor z pola.
   4. jeśli istnieje inicjalizator klasy, napisz: nazwa metody, .
   5. modyfikator metody, java.lang.zastanów się.Modyfikator.Statyczna, zapisana jako 32-bitowa liczba całkowita.
   6. deskryptor metody, () V.
   7. dla każdego nie-prywatnego konstruktora posortowanego według nazwy metody i podpisu: nazwa metody, . Modyfikatory z metoda zapisana jako 32-bitowa liczba całkowita. Deskryptor metody.
   8. dla każdej Nie-prywatnej metody posortowane według nazwy metody i podpisu: nazwa metody. Modyfikatorów metody zapisanej jako 32-bitowa liczba całkowita. Deskryptor metody.
   9. algorytm SHA-1 jest wykonywany na strumieniu bajtów wytwarzanych przez DataOutputStream i generuje pięć 32-bitowych wartości sha[0..4]. Na wartość hash jest składana z pierwszej i drugiej 32-bitowej wartości SHA-1 message digest. Jeśli wynik wiadomości przetrawi, pięć 32-bitowych słów H0 H1 H2 H3 H4, znajduje się w tablicy pięciu wartości int o nazwie sha, wartość skrótu będzie obliczana w następujący sposób:

    long hash = ((sha[0] >>> 24) & 0xFF) |
>            ((sha[0] >>> 16) & 0xFF) << 8 |
>            ((sha[0] >>> 8) & 0xFF) << 16 |
>            ((sha[0] >>> 0) & 0xFF) << 24 |
>            ((sha[1] >>> 24) & 0xFF) << 32 |
>            ((sha[1] >>> 16) & 0xFF) << 40 |
>            ((sha[1] >>> 8) & 0xFF) << 48 |
>        ((sha[1] >>> 0) & 0xFF) << 56;

Algorytm serializacji Javy

Algorytm serializacji obiektu jest opisany poniżej:
1. Zapisuje metadane klasy powiązanej z instancją.
2. Rekurencyjnie wypisuje opis superklasy, dopóki nie znajdzie Javy.lang.obiekt .
3. Po zakończeniu zapisu informacji o metadanych rozpoczyna się od rzeczywistych danych powiązanych z instancją. Ale tym razem to zaczyna się od najwyższej klasy.
4. Rekurencyjnie zapisuje dane związane z instancją, zaczynając od najmniejszej klasy nadrzędnej do najbardziej pochodnej klasy.

O Czym Warto Pamiętać:

1. Pola statyczne w klasie nie może być serializowana.

   public class A implements Serializable{
        String s;
        static String staticString = "I won't be serializable";
   }
   

2. Jeśli serialversionuid jest inny w klasie read, rzuci on wyjątek InvalidClassException.

3. Jeśli klasa implementuje serializowalną, wtedy wszystkie jej podklasy będą również serializowalne.

   public class A implements Serializable {....};
   
   public class B extends A{...} //also Serializable
   

4. Jeśli klasa ma odniesienie do innej klasy, Wszystkie odniesienia muszą być Serializowalne, w przeciwnym razie proces serializacji nie zostanie wykonany. W takim przypadku NotSerializableException jest rzucany na runtime.

Eg:

public class B{
     String s,
     A a; // class A needs to be serializable i.e. it must implement Serializable
}

Serializacja to proces konwersji stanu obiektu na bity, tak aby mógł być przechowywany na dysku twardym. Po deserializacji tego samego obiektu zachowa on swój stan później. Umożliwia odtwarzanie obiektów bez konieczności ręcznego zapisywania ich właściwości.

Http://en.wikipedia.org/wiki/Serialization

Serializacja to proces zapisywania obiektu na nośniku pamięci (takim jak plik lub bufor pamięci) lub przesyłania go przez połączenie sieciowe w postaci binarnej. Serializowane obiekty są niezależne od JVM i mogą być ponownie serializowane przez dowolne JVM. W tym przypadku stan obiektów java "w pamięci" jest konwertowany do strumienia bajtów. Ten typ pliku nie może być zrozumiały przez użytkownika. Jest to obiekt specjalnego typu, tzn. ponownie wykorzystany przez JVM (Java Virtual Machine). Ten proces serializowanie obiektu jest również nazywane deflatowaniem lub marszowaniem obiektu.

Obiekt do serializacji musi zaimplementować interfejs java.io.Serializable. Domyślny mechanizm serializacji dla obiektu zapisuje klasę obiektu, sygnaturę klasy oraz wartości wszystkich pól niestatycznych i niestatycznych.

class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,

ObjectOutput interfejs rozszerza interfejs DataOutput i dodaje metody serializacji obiektów i zapisu bajtów do pliku. ObjectOutputStream rozszerza java.io.OutputStream i implementuje interfejs ObjectOutput. Serializuje obiekty, tablice i inne wartości do strumienia. Tak więc konstruktor ObjectOutputStream zapisywany jest jako:

ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));

Powyższy kod został użyty do utworzenia instancji klasy ObjectOutput z konstruktorem ObjectOutputStream( ), który przyjmuje instancję FileOuputStream jako parametr.

Interfejs ObjectOutput jest używany przez implementację klasy ObjectOutputStream. ObjectOutputStream jest skonstruowany w celu serializacji obiektu.

Deserializacja obiektu w Javie

Odwrotne działanie serializacja nazywa się deserializacją, tzn. aby wyodrębnić dane z serii bajtów, jest znana jako deserializacja, która jest również nazywana nadmuchiwaniem lub unmarshalingiem.

ObjectInputStream rozszerza java.io.InputStream i implementuje interfejs ObjectInput. Deserializuje obiekty, tablice i inne wartości ze strumienia wejściowego. Tak więc konstruktor ObjectInputStream zapisywany jest jako:

ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));

Powyższy kod programu tworzy instancję klasy ObjectInputStream do deserializacji tego pliku, który został serializowany przez klasę ObjectInputStream. Powyższy kod tworzy instancję za pomocą instancji klasy FileInputStream, która przechowuje określony obiekt file, który musi zostać deserializowany, ponieważ konstruktor ObjectInputStream() potrzebuje strumienia wejściowego.

Serializacja to proces przekształcania obiektu Java w tablicę bajtów, a następnie z powrotem w obiekt z zachowanym stanem. Przydatne do różnych rzeczy, takich jak wysyłanie obiektów przez sieć lub buforowanie rzeczy na dysk.

Przeczytaj więcej z tego krótkiego artykułu, który dość dobrze wyjaśnia programowanie części procesu, a następnie przejdź do Serializable javadoc. Możesz być również zainteresowany przeczytaniem tego związanego pytania .

Zwraca plik jako obiekt: http://www.tutorialspoint.com/java/java_serialization.htm

        import java.io.*;

        public class SerializeDemo
        {
           public static void main(String [] args)
           {
              Employee e = new Employee();
              e.name = "Reyan Ali";
              e.address = "Phokka Kuan, Ambehta Peer";
              e.SSN = 11122333;
              e.number = 101;

              try
              {
                 FileOutputStream fileOut =
                 new FileOutputStream("/tmp/employee.ser");
                 ObjectOutputStream out = new ObjectOutputStream(fileOut);
                 out.writeObject(e);
                 out.close();
                 fileOut.close();
                 System.out.printf("Serialized data is saved in /tmp/employee.ser");
              }catch(IOException i)
              {
                  i.printStackTrace();
              }
           }
        }

    import java.io.*;
    public class DeserializeDemo
    {
       public static void main(String [] args)
       {
          Employee e = null;
          try
          {
             FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn);
             e = (Employee) in.readObject();
             in.close();
             fileIn.close();
          }catch(IOException i)
          {
             i.printStackTrace();
             return;
          }catch(ClassNotFoundException c)
          {
             System.out.println("Employee class not found");
             c.printStackTrace();
             return;
          }
          System.out.println("Deserialized Employee...");
          System.out.println("Name: " + e.name);
          System.out.println("Address: " + e.address);
          System.out.println("SSN: " + e.SSN);
          System.out.println("Number: " + e.number);
        }
    }

Java Serializacja Obiektów

Serialization jest mechanizmem przekształcającym Wykres obiektów Javy w tablicę bajtów do przechowywania (to disk file) lub transmisji (across a network), wtedy za pomocą deserializacji możemy przywrócić Wykres obiektów. Wykresy obiektów są przywracane poprawnie za pomocą mechanizmu udostępniania odniesień. ale przed zapisaniem sprawdź czy serialVersionUID z input-file/network i .pliki klas serialVersionUID są takie same. Jeśli nie, rzuć java.io.InvalidClassException.

Każda wersjonowana klasa musi zidentyfikować oryginalną wersję klasy, dla której jest zdolna do pisania strumieni i z której może czytać. Na przykład klasa wersjonowana musi zadeklarować:

SerialVersionUID Składnia

// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L;
private static final long serialVersionUID = 3487495895819393L;

SerialVersionUID jest niezbędny w procesie serializacji. Ale jest to opcjonalne dla programisty, aby dodać go do pliku źródłowego java. Jeśli a serialVersionUID nie jest dołączony, środowisko uruchomieniowe serialization wygeneruje serialVersionUID i powiąże go z klasą. Serializowany obiekt będzie zawierał ten identyfikator serialVersionUID wraz z innymi danymi.

Uwaga - zaleca się, aby wszystkie klasy serializowalne jawnie deklarowały identyfikator serialVersionUID, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations, i może w ten sposób powodować nieoczekiwane konflikty serialVersionUID podczas deserializacji, powodując deserializację do porażka.

Sprawdzanie Klas Serializowalnych

Obiekt Java jest tylko serializowalny. jeśli klasa lub którakolwiek z jej superklas implementuje interfejs java. io. Serializable lub jego podinterface, java. io.Externalizable.

• Klasa musi zaimplementować interfejs java.io.Serializable , aby pomyślnie zserializować swój obiekt. Serializable jest znacznikiem interfejs i używany do informowania kompilatora, że Klasa implementująca go musi zostać dodana do zachowania serializowalnego. tutaj Wirtualna Maszyna Java (JVM) jest odpowiedzialna za jej automatyczną serializację.

  Transient Keyword: java.io.Serializable interface

  Podczas serializacji obiektu, jeśli nie chcemy, aby pewne elementy danych obiektu były serializowane, możemy użyć modyfikatora transient. Słowo kluczowe przejściowe uniemożliwi serializację tego elementu danych.

  • pola zadeklarowane jako przejściowe lub statyczne są ignorowane przez proces serializacji.

  PRZEMIJAJĄCE & LOTNE

  +--------------+--------+-------------------------------------+
  |  Flag Name   |  Value | Interpretation                      |
  +--------------+--------+-------------------------------------+
  | ACC_VOLATILE | 0x0040 | Declared volatile; cannot be cached.|
  +--------------+--------+-------------------------------------+
  |ACC_TRANSIENT | 0x0080 | Declared transient; not written or  |
  |              |        | read by a persistent object manager.|
  +--------------+--------+-------------------------------------+
  

  class Employee implements Serializable {
      private static final long serialVersionUID = 2L;
      static int id;
  
      int eno; 
      String name;
      transient String password; // Using transient keyword means its not going to be Serialized.
  }
  

• Implementacja interfejsu Externalizable pozwala obiektowi przejąć pełną kontrolę nad zawartością i formatem serializowanej formy obiektu. Metody interfejsu Externalizable, writeexternal i readExternal, są wywoływane w celu zapisania i przywrócenia stan obiektów. Zaimplementowane przez klasę mogą zapisywać i odczytywać swój stan przy użyciu wszystkich metod ObjectOutput i ObjectInput. Zadaniem obiektów jest obsługa każdej wersji, która ma miejsce.

  class Emp implements Externalizable {
      int eno; 
      String name;
      transient String password; // No use of transient, we need to take care of write and read.
  
      @Override
      public void writeExternal(ObjectOutput out) throws IOException {
          out.writeInt(eno);
          out.writeUTF(name);
          //out.writeUTF(password);
      }
      @Override
      public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
          this.eno = in.readInt();
          this.name = in.readUTF();
          //this.password = in.readUTF(); // java.io.EOFException
      }
  }
  

• Tylko obiekty obsługujące interfejs java. io. Serializable lub java. io. Externalizable mogą być written to/read from strumienie. Klasa każdego obiektu serializowalnego jest zakodowana wraz z nazwą klasy i podpisem klasy, wartości pól i tablic obiektu oraz zamknięcia wszelkich innych obiektów, do których odwołuje się obiekt początkowy.

Przykład Serializowalny Dla Plików

public class SerializationDemo {
    static String fileName = "D:/serializable_file.ser";

    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
        Employee emp = new Employee( );
        Employee.id = 1; // Can not Serialize Class data.
        emp.eno = 77;
        emp.name = "Yash";
        emp.password = "confidential";
        objects_WriteRead(emp, fileName);

        Emp e = new Emp( );
        e.eno = 77;
        e.name = "Yash";
        e.password = "confidential";
        objects_WriteRead_External(e, fileName);

        /*String stubHost = "127.0.0.1";
        Integer anyFreePort = 7777;
        socketRead(anyFreePort); //Thread1
        socketWrite(emp, stubHost, anyFreePort); //Thread2*/

    }
    public static void objects_WriteRead( Employee obj, String serFilename ) throws IOException{
        FileOutputStream fos = new FileOutputStream( new File( serFilename ) );
        ObjectOutputStream objectOut = new ObjectOutputStream( fos );
        objectOut.writeObject( obj );
        objectOut.close();
        fos.close();

        System.out.println("Data Stored in to a file");

        try {
            FileInputStream fis = new FileInputStream( new File( serFilename ) );
            ObjectInputStream ois = new ObjectInputStream( fis );
            Object readObject;
            readObject = ois.readObject();
            String calssName = readObject.getClass().getName();
            System.out.println("Restoring Class Name : "+ calssName); // InvalidClassException

            Employee emp = (Employee) readObject;
            System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password);

            ois.close();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void objects_WriteRead_External( Emp obj, String serFilename ) throws IOException {
        FileOutputStream fos = new FileOutputStream(new File( serFilename ));
        ObjectOutputStream objectOut = new ObjectOutputStream( fos );

        obj.writeExternal( objectOut );
        objectOut.flush();

        fos.close();

        System.out.println("Data Stored in to a file");

        try {
            // create a new instance and read the assign the contents from stream.
            Emp emp = new Emp();

            FileInputStream fis = new FileInputStream(new File( serFilename ));
            ObjectInputStream ois = new ObjectInputStream( fis );

            emp.readExternal(ois);

            System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password);

            ois.close();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Przykład Serializowalny Przez Sieć

Dystrybucja stanu obiektu w różnych przestrzeniach adresowych, albo w różnych procesach na tym samym komputerze, albo nawet w wielu komputerach podłączonych przez sieć, ale które współpracują ze sobą poprzez współdzielenie danych i wywołanie metody.

• Data Marshalling
• Stuby i szkielety

/**
 * Creates a stream socket and connects it to the specified port number on the named host. 
 */
public static void socketWrite(Employee objectToSend, String stubHost, Integer anyFreePort) {
    try { // CLIENT - Stub[marshalling]
        Socket client = new Socket(stubHost, anyFreePort);
        ObjectOutputStream out = new ObjectOutputStream(client.getOutputStream());
        out.writeObject(objectToSend);
        out.flush();
        client.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
// Creates a server socket, bound to the specified port. 
public static void socketRead(  Integer anyFreePort ) {
    try { // SERVER - Stub[unmarshalling ]
        ServerSocket serverSocket = new ServerSocket( anyFreePort );
        System.out.println("Server serves on port and waiting for a client to communicate");
            /*System.in.read();
            System.in.read();*/

        Socket socket = serverSocket.accept();
        System.out.println("Client request to communicate on port server accepts it.");

        ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
        Employee objectReceived = (Employee) in.readObject();
        System.out.println("Server Obj : "+ objectReceived.name );

        socket.close();
        serverSocket.close();
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
}

@zobacz

• implementacja Serializable vs Externalizable

/ * / Serializing a class : Konwersja obiektu do bajtów i bajtów z powrotem do obiektu (Deserializacja).

class NamCls implements Serializable
{
    int NumVar;
    String NamVar;
}

|=> object-serializacja to proces konwersji stanu obiektu na parę bajtów.

• / | > zaimplementuj, gdy chcesz, aby obiekt istniał poza okresem życia JVM.
  
• |-> obiekt serializowany może być przechowywany w bazie danych.
  
• / |> Serializable-obecs nie mogą być czytane i rozumiane przez ludzi, więc możemy osiągnąć Ochrona.
  

/ = > Object-Deserializacja to proces uzyskiwania stanu obiektu i zapisywania go do obiektu (java.lang.Obiekt).

• / |> przed zapisaniem swojego stanu sprawdza pogodę serialVersionUID w postaci pliku wejściowego / sieci i .plik klasy serialVersionUID jest taki sam.
  &nbsp & nbspIf nie rzucać java. io. InvalidClassException.
  

/ => obiekt Java można serializować tylko wtedy, gdy jego klasa lub którykolwiek z jego superklasy

• implementuje interfejs java. io. Serializable lub
  
• jego podinterface, java. io. Externalizable.
  

/ = > Statyczne pola w klasie nie mogą być serializowane.

class NamCls implements Serializable
{
    int NumVar;
    static String NamVar = "I won't be serializable";;
}

|= > Jeśli nie chcesz serializować zmiennej klasy użyj słowa kluczowego transient

class NamCls implements Serializable
{
    int NumVar;
    transient String NamVar;
}

|=> jeśli klasa implementuje serializable, to wszystkie jej podklasy będą również serializowalne.

/ = > If a class has a reference of inna klasa, wszystkie referencje muszą być Serializowalne inaczej proces serializacji nie zostanie wykonany. W takim przypadku,
NotSerializableException jest wyrzucane w czasie wykonywania.

Java dostarcza mechanizm zwany serializacją obiektów, w którym obiekt może być reprezentowany jako sekwencja bajtów, która zawiera dane obiektu, a także informacje o typie obiektu i typach danych przechowywanych w obiekcie. Służy głównie do podróżowania po stanie obiektu w sieci (tzw. marshaling).