Como excluir campos da serialização em Java?

Existem várias formas de excluir campos da serialização:

1. Uso da palavra-chave transient: A forma mais simples e comum. Um campo marcado com este modificador será ignorado pelo mecanismo de serialização padrão do Java.

   public class MyClass implements java.io.Serializable {
       private String essentialField;
       private transient String secretField; // Este campo não será serializado
   
       public MyClass(String essentialField, String secretField) {
           this.essentialField = essentialField;
           this.secretField = secretField;
       }
   
       // Getters e setters
   }
   

2. Sobrescrever os métodos writeObject e readObject: Permite controlar completamente o processo de serialização e desserialização, definindo quais campos guardar (em writeObject) e restaurar (em 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; // Este campo que queremos excluir
   
       public MyClass(String fieldToSerialize, String fieldToExclude) {
           this.fieldToSerialize = fieldToSerialize;
           this.fieldToExclude = fieldToExclude;
       }
   
       private void writeObject(ObjectOutputStream out) throws IOException {
           // Serializamos apenas os campos necessários
           out.defaultWriteObject(); // Serializa os campos não transient e não excluídos manualmente
           // Se houver campos marcados como transient mas que devem ser serializados,
           // ou campos que se deseja serializar de forma específica,
           // podem ser serializados manualmente aqui
       }
   
       private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
           // Desserializamos apenas os campos necessários
           in.defaultReadObject(); // Desserializa os campos não transient e não excluídos manualmente
           // Se houver campos marcados como transient mas que devem ser desserializados,
           // podem ser desserializados manualmente aqui
       }
   
       // Getters e setters
   }
   

3. Uso da interface Externalizable: Oferece controle total sobre a serialização, exigindo a implementação dos métodos writeExternal e readExternal. É uma abordagem mais flexível que Serializable, mas requer mais gestão manual.

   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; // Este campo que queremos excluir
   
       // Construtor público sem argumentos obrigatório para Externalizable
       public MyClass() {
       }
   
       public MyClass(String fieldToSerialize, String fieldToExclude) {
           this.fieldToSerialize = fieldToSerialize;
           this.fieldToExclude = fieldToExclude;
       }
   
       @Override
       public void writeExternal(ObjectOutput out) throws IOException {
           // Especificamos explicitamente o que serializamos
           out.writeObject(fieldToSerialize);
           // fieldToExclude não é serializado
       }
   
       @Override
       public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
           // Especificamos explicitamente o que deserializamos
           fieldToSerialize = (String) in.readObject();
           // fieldToExclude não é deserializado
       }
   
       // Getters e setters
   }
   

A escolha do método depende da tarefa específica e do nível de controlo desejado sobre o processo de serialização. Para a maioria dos casos, o uso de transient é o mais simples.