İsteğe bağlı veya Java'da isteğe bağlı

Java 8'deki yeni İsteğe bağlı türle çalışıyorum ve işlevsel olarak desteklenmeyen ortak bir işlem gibi görünen bir şeyle karşılaştım: bir "orElseOptional"

Aşağıdaki modeli düşünün:

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

Bu modelin birçok formu vardır, ancak yeni bir isteğe bağlı üreten bir işlevi alan, yalnızca geçerli olanı yoksa, isteğe bağlı bir "orElse" istemekle kaynar.

Uygulanması şu şekilde görünecektir:

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

Böyle bir yöntemin var olmamasının bir nedeni olup olmadığını, isteğe bağlı olarak sadece isteğe bağlı olmayan bir şekilde kullanıyorsam ve insanların bu dava ile başa çıkmak için başka hangi yollarla geldiklerini merak ediyorum.

Kodumla çalışan insanlar mutlaka var olduklarını bilmeyeceklerinden, özel yardımcı sınıflar / yöntemler içeren çözümlerin zarif olmadığını düşünüyorum.

Ayrıca, herhangi biri bilirse, böyle bir yöntem JDK 9'a dahil edilir ve böyle bir yöntemi nereden önerebilirim? Bu benim için API için oldukça göze çarpan bir ihmal gibi görünüyor.

Bu JDK 9'un ora Supplier<Optional<T>>. Bu durumda örneğin:

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

Ayrıntılar için Javadoc ya da yazdığım bu gönderiye bakınız .

Mevcut API verildiğinde en temiz "deneme hizmetleri" yaklaşımı şöyle olacaktır:

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

Önemli olan, bir kez yazmanız gereken (sabit) işlem zinciri değil, başka bir hizmet eklemenin (veya hizmetlerin listesini genel olarak değiştirmenin ne kadar kolay) olmasıdır. Burada, bir tek eklemek veya kaldırmak ()->serviceX(args)yeterlidir.

Akışların tembel değerlendirmesi nedeniyle, önceki bir hizmet boş olmayan bir değer döndürdüğünde hizmet çağrılmaz Optional.

Güzel değil, ama bu işe yarayacak:

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)ile kullanım için oldukça kullanışlı bir modeldir Optional. "Bu Optionaldeğer içeriyorsa vbana ver func(v), yoksa bana versup.get() " .

Bu durumda, biz arar serviceA(args)ve alırız Optional<Result>. Bu Optionaldeğer içeriyorsa v, almak istiyoruz Optional.of(v), ama boşsa, almak istiyoruzserviceB(args) . Daha fazla alternatifle durulayın.

Bu modelin diğer kullanımları

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

Belki de peşinde olduğun şey budur: Birinden veya başka birinden değer al

Aksi takdirde, bir göz atmak isteyebilirsiniz Optional.orElseGet. İşte benim bir örnek peşinde olduğunu düşündüğüm :

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

Hala JDK8'de olduğunuzu varsayarsak, birkaç seçenek vardır.

Seçenek # 1: Kendi Yardımcı Yöntemi Yapın

Örneğin:

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

Böylece şunları yapabilirsiniz:

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

Seçenek # 2: Kütüphane Kullanın

Google guava's Optional isteğe bağlı olarak düzgün bir or()işlemi destekler (JDK9 gibi), örneğin:

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

(Hizmetlerin her birinin com.google.common.base.Optionalyerine geri döndüğü yer java.util.Optional).

Bu desen eşleşmesi için iyi bir uyum ve bazı ile daha geleneksel bir seçenek arayüzü ve (örneğin içinde olanlar gibi Yok uygulamaları gibi görünüyor olduğunu Javaslang , FunctionalJava ) ya da tembel Belki de uygulama tepki Cyclops .Çok bu kütüphaneye yazarı.

İle Tepegöz-tepki de yapısal kullanabilirsiniz modeli eşleşmesi JDK türlerinde. İsteğe bağlı olarak, mevcut ve olmayan vakaları ziyaretçi kalıbı üzerinden eşleştirebilirsiniz . şöyle bir şey olurdu -

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

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