Opsional orElse Opsional di Java

Saya telah bekerja dengan tipe Opsional baru di Java 8 , dan saya menemukan apa yang tampak seperti operasi umum yang tidak didukung secara fungsional: sebuah "orElseOptional"

Perhatikan pola berikut:

Optional<Result> resultFromServiceA = serviceA(args);
if (resultFromServiceA.isPresent) return result;
else {
    Optional<Result> resultFromServiceB = serviceB(args);
    if (resultFromServiceB.isPresent) return resultFromServiceB;
    else return serviceC(args);
}

Ada banyak bentuk dari pola ini, tetapi intinya adalah menginginkan "orElse" pada opsional yang mengambil fungsi yang menghasilkan opsional baru, yang dipanggil hanya jika yang sekarang tidak ada.

Implementasinya akan terlihat seperti ini:

public Optional<T> orElse(Supplier<Optional<? extends T>> otherSupplier) {
    return value != null ? this : other.get();
}

Saya ingin tahu apakah ada alasan mengapa metode seperti itu tidak ada, jika saya hanya menggunakan Opsional dengan cara yang tidak disengaja, dan cara lain apa yang dilakukan orang untuk menangani kasus ini.

Saya harus mengatakan bahwa menurut saya solusi yang melibatkan kelas / metode utilitas khusus tidak elegan karena orang yang bekerja dengan kode saya belum tentu tahu bahwa mereka ada.

Juga, jika ada yang tahu, apakah metode seperti itu akan dimasukkan dalam JDK 9, dan di mana saya bisa mengusulkan metode seperti itu? Bagi saya, ini sepertinya kelalaian yang cukup mencolok ke API.

Ini adalah bagian dari JDK 9 dalam bentuk or, yang mengambil Supplier<Optional<T>>. Contoh Anda kemudian akan menjadi:

return serviceA(args)
    .or(() -> serviceB(args))
    .or(() -> serviceC(args));

Untuk detailnya lihat Javadoc atau posting ini yang saya tulis.

Pendekatan "coba layanan" terbersih yang diberikan API saat ini adalah:

Optional<Result> o = Stream.<Supplier<Optional<Result>>>of(
    ()->serviceA(args), 
    ()->serviceB(args), 
    ()->serviceC(args), 
    ()->serviceD(args))
.map(Supplier::get)
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst();

Aspek pentingnya bukanlah rangkaian operasi (konstan) yang harus Anda tulis satu kali tetapi betapa mudahnya menambahkan layanan lain (atau mengubah daftar layanan secara umum). Di sini, menambahkan atau menghapus satu saja ()->serviceX(args)sudah cukup.

Karena evaluasi streaming yang lambat, tidak ada layanan yang akan dipanggil jika layanan sebelumnya menampilkan non-kosong Optional.

Ini tidak cantik, tapi ini akan berhasil:

return serviceA(args)
  .map(Optional::of).orElseGet(() -> serviceB(args))
  .map(Optional::of).orElseGet(() -> serviceC(args))
  .map(Optional::of).orElseGet(() -> serviceD(args));

.map(func).orElseGet(sup)adalah pola yang cukup berguna untuk digunakan dengan Optional. Artinya "Jika ini Optionalmengandung nilai v, beri aku func(v), jika tidak beri aku sup.get()".

Dalam hal ini, kami menelepon serviceA(args)dan mendapatkan Optional<Result>. Jika itu Optionalmengandung nilai v, kami ingin mendapatkannya Optional.of(v), tetapi jika kosong, kami ingin mendapatkannya serviceB(args). Bilas-ulangi dengan lebih banyak alternatif.

Kegunaan lain dari pola ini adalah

• .map(Stream::of).orElseGet(Stream::empty)
• .map(Collections::singleton).orElseGet(Collections::emptySet)

Mungkin inilah yang Anda cari: Dapatkan nilai dari satu Opsional atau lainnya

Jika tidak, Anda mungkin ingin melihatnya Optional.orElseGet. Berikut adalah contoh dari apa yang menurut saya Anda cari:

result = Optional.ofNullable(serviceA().orElseGet(
                                 () -> serviceB().orElseGet(
                                     () -> serviceC().orElse(null))));

Dengan asumsi Anda masih menggunakan JDK8, ada beberapa opsi.

Opsi # 1: Buat metode pembantu Anda sendiri

Misalnya:

public class Optionals {
    static <T> Optional<T> or(Supplier<Optional<T>>... optionals) {
        return Arrays.stream(optionals)
                .map(Supplier::get)
                .filter(Optional::isPresent)
                .findFirst()
                .orElseGet(Optional::empty);
    }
}

Sehingga Anda dapat melakukan:

return Optionals.or(
   ()-> serviceA(args),
   ()-> serviceB(args),
   ()-> serviceC(args),
   ()-> serviceD(args)
);

Opsi # 2: Gunakan perpustakaan

Misalnya Opsional jambu google mendukung or()operasi yang benar (seperti JDK9), misalnya:

return serviceA(args)
  .or(() -> serviceB(args))
  .or(() -> serviceC(args))
  .or(() -> serviceD(args));

(Di mana setiap layanan kembali com.google.common.base.Optional, bukan java.util.Optional).

Ini adalah tampak seperti cocok untuk pencocokan pola dan antarmuka Option yang lebih tradisional dengan beberapa dan ada implementasi (seperti di Javaslang , FunctionalJava ) atau malas Mungkin implementasi di cyclops-bereaksi .Saya penulis perpustakaan ini.

Dengan cyclops-react, Anda juga dapat menggunakan pencocokan pola struktural pada tipe JDK. Untuk Opsional, Anda dapat mencocokkan kasus saat ini dan yang tidak ada melalui pola pengunjung . itu akan terlihat seperti ini -

  import static com.aol.cyclops.Matchables.optional;

  optional(serviceA(args)).visit(some -> some , 
                                 () -> optional(serviceB(args)).visit(some -> some,
                                                                      () -> serviceC(args)));