Hoe sluit je velden uit van serialisatie in Java…

Er zijn verschillende manieren om velden uit de serialisatie uit te sluiten:

Gebruik van het sleutelwoord transient: De eenvoudigste en meest gebruikte manier. Een veld gemarkeerd met deze modifier wordt genegeerd door het standaard serialisatie-mechanisme van Java.

public class MyClass implements java.io.Serializable {
    private String essentialField;
    private transient String secretField; // Dit veld wordt niet geserialiseerd

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

    // Getters en setters
}

Overschrijven van de methoden writeObject en readObject: Hiermee heb je volledige controle over het serialisatie- en deserialisatieproces, waarbij je bepaalt welke velden worden opgeslagen (writeObject) en hersteld (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; // Dit veld willen we uitsluiten

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

    private void writeObject(ObjectOutputStream out) throws IOException {
        // Alleen de benodigde velden serialiseren
        out.defaultWriteObject(); // Seriëleert niet-transient en niet-uitgesloten velden
        // Als er velden zijn gemarkeerd als transient maar die geserialiseerd moeten worden,
        // of velden die op een speciale manier geserialiseerd moeten worden,
        // kunnen deze hier handmatig worden geserialiseerd
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // Alleen de benodigde velden deserialiseren
        in.defaultReadObject(); // Deserialiseert niet-transient en niet-uitgesloten velden
        // Als er velden zijn gemarkeerd als transient maar die gedeserialiseerd moeten worden,
        // kunnen deze hier handmatig worden gedeserialiseerd
    }

    // Getters en setters
}

Gebruik van de interface Externalizable: Biedt volledige controle over de serialisatie, vereist de implementatie van de methoden writeExternal en readExternal. Dit is een meer flexibele aanpak dan Serializable, maar vereist meer handmatige controle.

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; // Dit veld willen we uitsluiten

    // Publieke constructor zonder argumenten is verplicht voor Externalizable
    public MyClass() {
    }

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

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // Expliciet aangeven wat wordt geserialiseerd
        out.writeObject(fieldToSerialize);
        // fieldToExclude wordt niet geserialiseerd
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // Expliciet aangeven wat wordt gedeserialiseerd
        fieldToSerialize = (String) in.readObject();
        // fieldToExclude wordt niet gedeserialiseerd
    }

    // Getters en setters
}

De keuze van de methode hangt af van de specifieke taak en het gewenste controleniveau over het serialisatieproces. Voor de meeste gevallen is het gebruik van transient het eenvoudigst.

Hoe sluit je velden uit van serialisatie in Java?