Warum java.util.Optional nicht serialisierbar ist, wie das Objekt mit solchen Feldern serialisiert wird

Die Enum-Klasse ist serialisierbar, sodass es kein Problem gibt, Objekte mit Enums zu serialisieren. Der andere Fall ist, wenn die Klasse Felder der Klasse java.util.Optional enthält. In diesem Fall wird die folgende Ausnahme ausgelöst: java.io.NotSerializableException: java.util.Optional

Wie gehe ich mit solchen Klassen um, wie serialisiere ich sie? Ist es möglich, solche Objekte an Remote EJB oder über RMI zu senden?

Dies ist das Beispiel:

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Optional;

import org.junit.Test;

public class SerializationTest {

    static class My implements Serializable {

        private static final long serialVersionUID = 1L;
        Optional<Integer> value = Optional.empty();

        public void setValue(Integer i) {
            this.i = Optional.of(i);
        }

        public Optional<Integer> getValue() {
            return value;
        }
    }

    //java.io.NotSerializableException is thrown

    @Test
    public void serialize() {
        My my = new My();
        byte[] bytes = toBytes(my);
    }

    public static <T extends Serializable> byte[] toBytes(T reportInfo) {
        try (ByteArrayOutputStream bstream = new ByteArrayOutputStream()) {
            try (ObjectOutputStream ostream = new ObjectOutputStream(bstream)) {
                ostream.writeObject(reportInfo);
            }
            return bstream.toByteArray();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

Diese Antwort ist eine Antwort auf die Frage im Titel: "Sollte Optional nicht serialisierbar sein?" Die kurze Antwort lautet, dass die Expertengruppe Java Lambda (JSR-335) dies geprüft und abgelehnt hat . Dieser und dieser sowie dieser Hinweis geben an, dass das primäre Entwurfsziel für darin Optionalbesteht, als Rückgabewert von Funktionen verwendet zu werden, wenn möglicherweise kein Rückgabewert vorhanden ist. Die Absicht ist, dass der Anrufer Optionalden aktuellen Wert sofort überprüft und extrahiert, falls vorhanden. Wenn der Wert nicht vorhanden ist, kann der Aufrufer einen Standardwert ersetzen, eine Ausnahme auslösen oder eine andere Richtlinie anwenden. Dies erfolgt normalerweise durch Verketten fließender Methodenaufrufe am Ende einer Stream-Pipeline (oder anderer Methoden), die OptionalWerte zurückgeben.

Es war niemals dafür gedacht Optional, auf andere Weise verwendet zu werden, beispielsweise für optionale Methodenargumente oder als Feld in einem Objekt gespeichert zu werden . Durch die OptionalSerialisierung kann es dauerhaft gespeichert oder über ein Netzwerk übertragen werden. Beides fördert die Verwendung weit über das ursprüngliche Entwurfsziel hinaus.

Normalerweise gibt es bessere Möglichkeiten, die Daten zu organisieren, als sie Optionalin einem Feld zu speichern . Wenn ein Getter (wie die getValueMethode in der Frage) das Ist Optionalaus dem Feld zurückgibt , zwingt er jeden Aufrufer, eine Richtlinie für den Umgang mit einem leeren Wert zu implementieren. Dies führt wahrscheinlich zu einem inkonsistenten Verhalten aller Anrufer. Es ist oft besser, wenn die Codesätze in diesem Feld zum Zeitpunkt der Festlegung eine Richtlinie anwenden.

Manchmal möchten Leute Optionalin Sammlungen setzen, wie List<Optional<X>>oder Map<Key,Optional<Value>>. Auch das ist normalerweise eine schlechte Idee. Oft ist es besser, diese Verwendungen Optionaldurch Null-Objekt- Werte (keine tatsächlichen nullReferenzen) zu ersetzen oder diese Einträge einfach vollständig aus der Sammlung zu streichen.

Viel Serialization verwandte Probleme können gelöst werden, indem Sie das persistente serialisierte Formular von der tatsächlichen Laufzeitimplementierung entkoppeln, mit der Sie arbeiten.

/** The class you work with in your runtime */
public class My implements Serializable {
    private static final long serialVersionUID = 1L;

    Optional<Integer> value = Optional.empty();

    public void setValue(Integer i) {
        this.value = Optional.ofNullable(i);
    }

    public Optional<Integer> getValue() {
        return value;
    }
    private Object writeReplace() throws ObjectStreamException
    {
        return new MySerialized(this);
    }
}
/** The persistent representation which exists in bytestreams only */
final class MySerialized implements Serializable {
    private final Integer value;

    MySerialized(My my) {
        value=my.getValue().orElse(null);
    }
    private Object readResolve() throws ObjectStreamException {
        My my=new My();
        my.setValue(value);
        return my;
    }
}

Die Klasse Optional implementiert ein Verhalten, das es ermöglicht, guten Code zu schreiben, wenn möglicherweise fehlende Werte verarbeitet werden (im Vergleich zur Verwendung von null). Eine dauerhafte Darstellung Ihrer Daten bietet jedoch keinen Vorteil. Es würde nur Ihre serialisierten Daten größer machen ...

Die obige Skizze mag kompliziert aussehen, aber das liegt daran, dass sie das Muster nur mit einer Eigenschaft demonstriert. Je mehr Eigenschaften Ihre Klasse hat, desto mehr sollte ihre Einfachheit offenbart werden.

Und nicht zu vergessen, die Möglichkeit, die Implementierung Mykomplett zu ändern, ohne die persistente Form anpassen zu müssen…

Wenn Sie eine serialisierbare Option wünschen, sollten Sie stattdessen die optionale Option der Guave verwenden, die serialisierbar ist.

Es ist eine merkwürdige Auslassung.

Sie müssten das Feld als markieren transientund Ihre eigene benutzerdefinierte writeObject()Methode angeben , mit der das get()Ergebnis selbst geschrieben wurde, sowie eine readObject()Methode, mit der Optionaldas Ergebnis wiederhergestellt wird, indem das Ergebnis aus dem Stream gelesen wird. Nicht zu vergessen , rufen defaultWriteObject()und defaultReadObject()jeweils.

Die Vavr.io-Bibliothek (ehemals Javaslang) hat auch die OptionKlasse, die serialisierbar ist:

public interface Option<T> extends Value<T>, Serializable { ... }

Wenn Sie eine konsistentere Typliste pflegen und die Verwendung von Null vermeiden möchten, gibt es eine verrückte Alternative.

Sie können den Wert über einen Schnittpunkt von Typen speichern . In Verbindung mit einem Lambda ermöglicht dies Folgendes:

private final Supplier<Optional<Integer>> suppValue;
....
List<Integer> temp = value
        .map(v -> v.map(Arrays::asList).orElseGet(ArrayList::new))
        .orElse(null);
this.suppValue = (Supplier<Optional<Integer>> & Serializable)() -> temp==null ? Optional.empty() : temp.stream().findFirst();

Wenn die tempVariable getrennt ist, wird vermieden, dass der Eigentümer des valueMitglieds geschlossen wird und zu viel serialisiert wird.