Neden java.util.Optional Serileştirilemez, nesneyi bu tür alanlarla nasıl serileştirebilirim?

Enum sınıfı Serializable olduğundan, nesneyi numaralandırmalarla serileştirmede sorun yoktur. Diğer durum, sınıfın java.util.Optional sınıfının alanlarına sahip olmasıdır. Bu durumda aşağıdaki istisna atılır: java.io.NotSerializableException: java.util.Optional

Bu tür sınıflarla nasıl baş edilir, nasıl serileştirilir? Bu tür nesneleri Remote EJB'ye veya RMI aracılığıyla göndermek mümkün müdür?

Bu örnek:

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

Bu yanıt, başlığındaki "İsteğe Bağlı Serileştirilebilir Olmamalı mı?" Sorusuna yanıttır. Kısa cevap, Java Lambda (JSR-335) uzman grubunun bunu dikkate alması ve reddetmesidir . Bu not ve bu ve bu , birincil tasarım hedefinin Optional, bir dönüş değeri olmadığında işlevlerin dönüş değeri olarak kullanılması olduğunu gösterir. Amaç, arayanın hemen kontrol etmesi Optionalve varsa gerçek değeri çıkarmasıdır. Değer yoksa, arayan kişi varsayılan bir değeri değiştirebilir, bir istisna atabilir veya başka bir politika uygulayabilir. Bu tipik olarak, Optionaldeğerleri döndüren bir akış ardışık düzeninin (veya diğer yöntemlerin) sonundan akıcı yöntem çağrıları zincirlenerek yapılır .

Opsiyonel yöntem argümanlarıOptional gibi başka şekillerde kullanılması veya bir nesnede bir alan olarak depolanması asla amaçlanmamıştır . Ve uzantı olarak, serileştirilebilir hale getirmek, kalıcı olarak depolanmasını veya bir ağ üzerinden iletilmesini mümkün kılar ve her ikisi de orijinal tasarım hedefinin çok ötesinde kullanımları teşvik eder.Optional

Genellikle verileri Optionalbir alanda depolamaktan daha iyi organize etmenin daha iyi yolları vardır . Bir alıcı (söz konusu getValueyöntem gibi ) Optionalalandan gerçek olanı döndürürse, her arayanı boş bir değerle başa çıkmak için bir politika uygulamaya zorlar. Bu muhtemelen arayanlar arasında tutarsız davranışlara yol açacaktır. Bu alanın, ayarlandığı anda bir politika uygulayacağı kod kümelerine sahip olmak genellikle daha iyidir.

Bazen insanlar veya Optionalgibi koleksiyonlara koymak isterler . Bu da genellikle kötü bir fikirdir. Bu bu kullanımlarını yerine çoğu zaman daha iyi olan Null-Nesne değerlerinin (değil gerçek tamamen koleksiyonundan, ya da sadece omit bu girişler referanslar).List<Optional<X>>Map<Key,Optional<Value>>Optionalnull

SerializationKalıcı serileştirilmiş formu, üzerinde çalıştığınız gerçek çalışma zamanı uygulamasından ayırarak birçok ilgili sorun çözülebilir.

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

Sınıf , muhtemelen bulunmayan değerlerle uğraşırken (kullanımıyla karşılaştırıldığında) iyi kod yazmaya izin veren davranışıOptional uygular . Ancak verilerinizin kalıcı bir temsiline herhangi bir fayda sağlamaz. Sadece serileştirilmiş verilerinizi büyütür ...null

Yukarıdaki taslak karmaşık görünebilir, ancak bunun nedeni, deseni yalnızca bir özellik ile göstermesidir. Sınıfınız ne kadar çok özelliğe sahipse, basitliği de o kadar fazla ortaya çıkmalıdır.

Ve unutmamak Mygerekir ki, kalıcı forma adapte etmeye gerek kalmadan tamamen uygulama değişikliği imkanı ...

Bir serileştirilebilir isteğe bağlı istiyorsanız, bunun yerine guava'nın serileştirilebilir isteğe bağlı olanını kullanmayı düşünün .

Tuhaf bir ihmal.

Alanı olarak işaretlemeniz ve sonucun kendisini yazan transientkendi özel writeObject()yönteminizi get()ve bu sonucu akıştan okuyarak readObject()geri yükleyen bir yöntem sağlamanız gerekir Optional. Sırasıyla defaultWriteObject()ve aramayı unutmamak defaultReadObject().

Vavr.io kitaplığı (eski Javaslang) ayrıca Optionserileştirilebilir sınıfa sahiptir:

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

Daha tutarlı bir tür listesi tutmak ve null kullanmaktan kaçınmak istiyorsanız, garip bir alternatif var.

Sen edebilirsiniz türlerinden bir kavşak kullanarak değeri depolamak . Bir lambda ile birleştiğinde, bu aşağıdaki gibi bir şeye izin verir:

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

tempDeğişkenin ayrı olması, valueüyenin sahibini kapatmayı ve dolayısıyla çok fazla serileştirmeyi önler .