Optional orElse Optional in Java

Ich habe mit dem neuen optionalen Typ in Java 8 gearbeitet und bin auf eine allgemeine Operation gestoßen, die funktional nicht unterstützt wird: eine "orElseOptional"

Betrachten Sie das folgende Muster:

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

Es gibt viele Formen dieses Musters, aber es läuft darauf hinaus, ein "orElse" für ein optionales Element zu wollen, das eine Funktion übernimmt, die ein neues optionales Element erzeugt, das nur aufgerufen wird, wenn das aktuelle nicht vorhanden ist.

Die Implementierung würde folgendermaßen aussehen:

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

Ich bin gespannt, ob es einen Grund gibt, warum es eine solche Methode nicht gibt, ob ich Optional nur unbeabsichtigt verwende und welche anderen Möglichkeiten die Leute gefunden haben, um mit diesem Fall umzugehen.

Ich sollte sagen, dass ich denke, dass Lösungen mit benutzerdefinierten Dienstprogrammklassen / -methoden nicht elegant sind, da Leute, die mit meinem Code arbeiten, nicht unbedingt wissen, dass sie existieren.

Wenn jemand weiß, wird eine solche Methode in JDK 9 enthalten sein, und wo könnte ich eine solche Methode vorschlagen? Dies scheint mir eine ziemlich krasse Auslassung der API zu sein.

Dies ist Teil von JDK 9 in Form von or, das a Supplier<Optional<T>>. Ihr Beispiel wäre dann:

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

Für Details siehe den Javadoc oder diesen Beitrag, den ich geschrieben habe.

Der sauberste Ansatz für "Try Services" angesichts der aktuellen API wäre:

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

Der wichtige Aspekt ist nicht die (konstante) Kette von Operationen, die Sie einmal schreiben müssen, sondern wie einfach es ist, einen anderen Dienst hinzuzufügen (oder die Liste der Dienste zu ändern, ist allgemein). Hier reicht es aus, eine einzelne hinzuzufügen oder zu entfernen ()->serviceX(args).

Aufgrund der verzögerten Auswertung von Streams wird kein Dienst aufgerufen, wenn ein vorhergehender Dienst einen nicht leeren zurückgegeben hat Optional.

Es ist nicht schön, aber das wird funktionieren:

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)ist ein ziemlich praktisches Muster für die Verwendung mit Optional. Es bedeutet "Wenn dies OptionalWert enthält v, gib mir func(v), sonst gib mir sup.get()".

In diesem Fall rufen wir an serviceA(args)und bekommen eine Optional<Result>. Wenn das OptionalWert enthält v, wollen wir bekommen Optional.of(v), aber wenn es leer ist, wollen wir bekommen serviceB(args). Spülen-Wiederholen mit mehr Alternativen.

Andere Verwendungen dieses Musters sind

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

Vielleicht ist es das, wonach Sie suchen: Holen Sie sich den Wert von der einen oder anderen Option

Andernfalls möchten Sie vielleicht einen Blick darauf werfen Optional.orElseGet. Hier ist ein Beispiel dafür, was Sie meiner Meinung nach suchen:

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

Angenommen, Sie arbeiten noch mit JDK8, gibt es mehrere Optionen.

Option 1: Erstellen Sie Ihre eigene Hilfsmethode

Z.B:

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

Damit Sie tun können:

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

Option 2: Verwenden Sie eine Bibliothek

Zum Beispiel unterstützt Google Guavas Optional einen ordnungsgemäßen or()Betrieb (genau wie JDK9), z.

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

(Wo jeder der Dienste zurückkehrt com.google.common.base.Optional, anstatt java.util.Optional).

Dies scheint eine gute Lösung für den Mustervergleich und eine traditionellere Optionsoberfläche mit einigen und keiner Implementierungen (wie die in Javaslang , FunctionalJava ) oder eine faule Vielleicht- Implementierung in Cyclops- React zu sein. Ich bin der Autor dieser Bibliothek.

Mit cyclops reagieren Sie auch strukturelle verwenden können Pattern - Matching auf JDK - Typen. Optional können Sie aktuelle und fehlende Fälle über das Besuchermuster abgleichen . es würde ungefähr so ​​aussehen -

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

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