Jak wykluczyć pola z serializacji w Java?

Istnieje kilka sposobów wykluczenia pól z serializacji:

1. Użycie słowa kluczowego transient: Najprostszy i najczęściej stosowany sposób. Pole oznaczone tym modyfikatorem jest ignorowane przez standardowy mechanizm serializacji Java.

   public class MyClass implements java.io.Serializable {
       private String essentialField;
       private transient String secretField; // To pole nie będzie serializowane
   
       public MyClass(String essentialField, String secretField) {
           this.essentialField = essentialField;
           this.secretField = secretField;
       }
   
       // Gettery i settery
   }
   

2. Nadpisanie metod writeObject i readObject: Pozwala na pełną kontrolę nad procesem serializacji i deserializacji, określając, które pola zapisać (w writeObject) i odtworzyć (w readObject).

   import java.io.IOException;
   import java.io.ObjectInputStream;
   import java.io.ObjectOutputStream;
   import java.io.Serializable;
   
   public class MyClass implements Serializable {
       private String fieldToSerialize;
       private String fieldToExclude; // To pole chcemy wykluczyć
   
       public MyClass(String fieldToSerialize, String fieldToExclude) {
           this.fieldToSerialize = fieldToSerialize;
           this.fieldToExclude = fieldToExclude;
       }
   
       private void writeObject(ObjectOutputStream out) throws IOException {
           // Serializujemy tylko potrzebne pola
           out.defaultWriteObject(); // Serializuje pola nie- transient i nie wykluczone ręcznie
           // Jeśli są pola oznaczone jako transient, ale które chcemy serializować,
           // lub pola, które mają być serializowane w specjalny sposób,
           // można je serializować ręcznie tutaj
       }
   
       private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
           // Deserializujemy tylko potrzebne pola
           in.defaultReadObject(); // Deserializuje pola nie- transient i nie wykluczone ręcznie
           // Jeśli są pola oznaczone jako transient, ale które mają być deserializowane,
           // można je deserializować ręcznie tutaj
       }
   
       // Gettery i settery
   }
   

3. Użycie interfejsu Externalizable: Zapewnia pełną kontrolę nad serializacją, wymagając implementacji metod writeExternal i readExternal. To bardziej elastyczne podejście niż Serializable, ale wymaga więcej ręcznego zarządzania.

   import java.io.Externalizable;
   import java.io.IOException;
   import java.io.ObjectInput;
   import java.io.ObjectOutput;
   
   public class MyClass implements Externalizable {
       private String fieldToSerialize;
       private String fieldToExclude; // To pole chcemy wykluczyć
   
       // Publiczny konstruktor bezargumentowy jest obowiązkowy dla Externalizable
       public MyClass() {
       }
   
       public MyClass(String fieldToSerialize, String fieldToExclude) {
           this.fieldToSerialize = fieldToSerialize;
           this.fieldToExclude = fieldToExclude;
       }
   
       @Override
       public void writeExternal(ObjectOutput out) throws IOException {
           // Wyraźnie wskazujemy, co serializujemy
           out.writeObject(fieldToSerialize);
           // fieldToExclude nie jest serializowane
       }
   
       @Override
       public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
           // Wyraźnie wskazujemy, co deserializujemy
           fieldToSerialize = (String) in.readObject();
           // fieldToExclude nie jest deserializowane
       }
   
       // Gettery i settery
   }
   

Wybór metody zależy od konkretnego zadania i poziomu kontroli nad procesem serializacji. Dla większości przypadków najprostszym jest użycie transient.