Por qué java.util.Optional no es serializable, cómo serializar el objeto con tales campos

La clase Enum es serializable, por lo que no hay ningún problema para serializar objetos con enumeraciones. El otro caso es donde la clase tiene campos de clase java.util.Optional. En este caso, se lanza la siguiente excepción: java.io.NotSerializableException: java.util.Optional

¿Cómo lidiar con tales clases, cómo serializarlas? ¿Es posible enviar tales objetos a Remote EJB oa través de RMI?

Este es el ejemplo:

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);
        }
    }
}

Esta respuesta es en respuesta a la pregunta en el título, "¿No debería ser opcional serializable?" La respuesta corta es que el grupo de expertos Java Lambda (JSR-335) lo consideró y lo rechazó . Esa nota, y esta y esta, indican que el objetivo principal del diseño Optionales que se utilice como valor de retorno de funciones cuando un valor de retorno puede estar ausente. La intención es que la persona que llama verifique inmediatamente Optionaly extraiga el valor real si está presente. Si el valor está ausente, la persona que llama puede sustituir un valor predeterminado, lanzar una excepción o aplicar alguna otra política. Por lo general, esto se hace encadenando llamadas de método fluidas al final de una canalización de flujo (u otros métodos) que devuelven Optionalvalores.

Nunca fue pensado para Optionalser usado de otras formas, como para argumentos de métodos opcionales o para ser almacenado como un campo en un objeto . Y, por extensión, hacer Optionalserializable permitiría almacenarlo de forma persistente o transmitirlo a través de una red, lo que fomenta usos mucho más allá de su objetivo de diseño original.

Por lo general, hay mejores formas de organizar los datos que almacenarlos Optionalen un campo. Si un captador (como el getValuemétodo de la pregunta) devuelve el valor real Optionaldel campo, obliga a cada llamador a implementar alguna política para tratar con un valor vacío. Esto probablemente dará lugar a un comportamiento inconsistente entre las personas que llaman. A menudo es mejor que cualquier conjunto de códigos de ese campo aplique alguna política en el momento en que se establece.

A veces la gente quiere poner Optionalen colecciones, como List<Optional<X>>o Map<Key,Optional<Value>>. Esto también suele ser una mala idea. A menudo es mejor reemplazar estos usos de Optionalcon valores de objeto nulo (no nullreferencias reales ), o simplemente omitir estas entradas de la colección por completo.

Se Serializationpueden resolver muchos problemas relacionados desacoplando la forma serializada persistente de la implementación real en tiempo de ejecución en la que opera.

/** 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;
    }
}

La clase Optionalimplementa un comportamiento que permite escribir un buen código cuando se trata de valores posiblemente ausentes (en comparación con el uso de null). Pero no agrega ningún beneficio a una representación persistente de sus datos. Solo haría que sus datos serializados fueran más grandes ...

El dibujo anterior puede parecer complicado, pero eso se debe a que muestra el patrón con una sola propiedad. Cuantas más propiedades tenga su clase, más se revelará su simplicidad.

Y no olvidar, la posibilidad de cambiar la implementación de Mycompletamente sin necesidad de adaptar la forma persistente ...

Si desea un opcional serializable, considere usar en su lugar el opcional de guava, que es serializable.

Es una omisión curiosa.

Tendría que marcar el campo como transienty proporcionar su propio writeObject()método personalizado que escribió el get()resultado en sí, y un readObject()método que restauró al Optionalleer ese resultado de la secuencia. Sin olvidar llamar defaultWriteObject()y defaultReadObject()respectivamente.

La biblioteca Vavr.io (antes Javaslang) también tiene la Optionclase que es serializable:

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

Si desea mantener una lista de tipos más consistente y evitar el uso de null, hay una alternativa chiflada.

Puede almacenar el valor utilizando una intersección de tipos . Junto con una lambda, esto permite algo como:

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();

Tener la tempvariable separada evita cerrar sobre el propietario del valuemiembro y, por lo tanto, serializar demasiado.