¿Cómo excluir campos de la serialización en Java…

Hay varias formas de excluir campos de la serialización:

Uso de la palabra clave transient: La forma más sencilla y común. Un campo marcado con este modificador será ignorado por el mecanismo de serialización estándar de Java.

public class MyClass implements java.io.Serializable {
    private String essentialField;
    private transient String secretField; // Este campo no será serializado

    public MyClass(String essentialField, String secretField) {
        this.essentialField = essentialField;
        this.secretField = secretField;
    }

    // Getters y setters
}

Sobrescribir los métodos writeObject y readObject: Permite controlar completamente el proceso de serialización y deserialización, definiendo qué campos guardar (en writeObject) y restaurar (en 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 queremos excluir

    public MyClass(String fieldToSerialize, String fieldToExclude) {
        this.fieldToSerialize = fieldToSerialize;
        this.fieldToExclude = fieldToExclude;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        // Serializamos solo los campos necesarios
        out.defaultWriteObject(); // Serializa los campos no transient y no excluidos manualmente
        // Si hay campos marcados como transient pero que se desean serializar,
        // o campos que se quieren serializar de forma específica,
        // se pueden serializar manualmente aquí
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // Deserializamos solo los campos necesarios
        in.defaultReadObject(); // Deserializa los campos no transient y no excluidos manualmente
        // Si hay campos marcados como transient pero que se desean deserializar,
        // se pueden deserializar manualmente aquí
    }

    // Getters y setters
}

Uso de la interfaz Externalizable: Ofrece control total sobre la serialización, requiriendo la implementación de los métodos writeExternal y readExternal. Es un enfoque más flexible que Serializable, pero requiere más gestión 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 queremos excluir

    // Constructor público sin argumentos obligatorio 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 explícitamente qué serializar
        out.writeObject(fieldToSerialize);
        // fieldToExclude no se serializa
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // Especificamos explícitamente qué deserializar
        fieldToSerialize = (String) in.readObject();
        // fieldToExclude no se deserializa
    }

    // Getters y setters
}

La elección del método depende de la tarea específica y del nivel de control requerido sobre el proceso de serialización. Para la mayoría de los casos, el uso de transient es lo más sencillo.

¿Cómo excluir campos de la serialización en Java?