Opcjonalne lubElse Opcjonalne w Javie

Pracowałem z nowym typem opcjonalnym w Javie 8 i natknąłem się na coś, co wygląda na typową operację, która nie jest obsługiwana funkcjonalnie: „orElseOptional”

Rozważ następujący wzór:

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

Istnieje wiele form tego wzorca, ale sprowadza się on do chęci użycia „orElse” na opcji, która przyjmuje funkcję produkującą nową opcję, wywoływaną tylko wtedy, gdy bieżąca nie istnieje.

Jego implementacja wyglądałaby tak:

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

Ciekaw jestem, czy istnieje powód, dla którego taka metoda nie istnieje, czy po prostu używam Optional w niezamierzony sposób i jakie inne sposoby wymyślili ludzie, aby poradzić sobie z tym przypadkiem.

Powinienem powiedzieć, że uważam, że rozwiązania obejmujące niestandardowe klasy / metody narzędziowe nie są eleganckie, ponieważ ludzie pracujący z moim kodem niekoniecznie wiedzą, że istnieją.

Poza tym, jeśli ktoś wie, czy taka metoda zostanie uwzględniona w JDK 9 i gdzie mogę zaproponować taką metodę? Wydaje mi się to dość rażącym pominięciem API.

Jest to część JDK 9 w postaci or, która ma rozszerzenie Supplier<Optional<T>>. Twój przykład byłby wtedy:

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

Aby uzyskać szczegółowe informacje, zobacz Javadoc lub ten post, który napisałem.

Najczystszym podejściem „wypróbuj usługi” przy obecnym API byłoby:

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

Ważnym aspektem nie jest (stały) łańcuch operacji, który trzeba raz napisać, ale to, jak łatwo jest dodać kolejną usługę (lub zmodyfikować listę usług jest ogólna). Tutaj ()->serviceX(args)wystarczy dodać lub usunąć singiel .

Ze względu na leniwą ocenę strumieni żadna usługa nie zostanie wywołana, jeśli poprzednia usługa zwróciła wartość niepustą Optional.

To nie jest ładne, ale to zadziała:

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)jest dość poręcznym wzorem do użytku z Optional. To znaczy „Jeśli to Optionalzawiera wartość v, daj mi func(v), w przeciwnym razie daj mi sup.get()”.

W takim przypadku dzwonimy serviceA(args)i otrzymujemy Optional<Result>. Jeśli Optionalzawiera wartość v, chcemy otrzymać Optional.of(v), ale jeśli jest pusta, chcemy pobrać serviceB(args). Powtórz płukanie z większą liczbą alternatyw.

Inne zastosowania tego wzoru to

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

Być może właśnie tego szukasz: Uzyskaj wartość z jednego lub drugiego opcjonalnego

W przeciwnym razie warto rzucić okiem Optional.orElseGet. Oto przykład tego, czego myślę , że szukasz:

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

Zakładając, że nadal korzystasz z JDK8, istnieje kilka opcji.

Opcja nr 1: stwórz własną metodę pomocniczą

Na przykład:

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

Abyś mógł:

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

Opcja nr 2: użyj biblioteki

Np. Opcja opcjonalna google guava obsługuje prawidłowe or()działanie (podobnie jak JDK9), np .:

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

(Gdzie każda z usług powraca com.google.common.base.Optional, a nie java.util.Optional).

Wygląda na to, że dobrze pasuje do dopasowywania wzorców i bardziej tradycyjnego interfejsu Option z implementacjami Some i None (takich jak te w Javaslang , FunctionalJava ) lub leniwą implementacją Może w cyclops-react. Jestem autorem tej biblioteki.

Z cyklopem-reagować możesz także używać strukturalnego dopasowywania wzorców na typach JDK. W przypadku opcji Opcjonalne można dopasować do obecnych i nieobecnych przypadków według wzorca gości . wyglądałoby to mniej więcej tak -

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

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