Opzionale oElse Opzionale in Java

Ho lavorato con il nuovo tipo opzionale in Java 8 e ho riscontrato quella che sembra un'operazione comune che non è supportata funzionalmente: un "orElseOptional"

Considera il seguente modello:

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

Esistono molte forme di questo modello, ma si riduce a desiderare un "orElse" su un opzionale che accetta una funzione producendo un nuovo opzionale, chiamato solo se quello attuale non esiste.

La sua implementazione sarebbe simile a questa:

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

Sono curioso di sapere se esiste un motivo per cui un tale metodo non esiste, se sto semplicemente usando Opzionale in modo non intenzionale e quali altri modi sono stati inventati per affrontare questo caso.

Dovrei dire che penso che le soluzioni che coinvolgono classi / metodi di utilità personalizzati non siano eleganti perché le persone che lavorano con il mio codice non sapranno necessariamente che esistono.

Inoltre, se qualcuno lo sa, un tale metodo sarà incluso in JDK 9 e dove potrei proporlo? Mi sembra un'omissione piuttosto evidente all'API.

Questo fa parte di JDK 9 nella forma di or, che prende a Supplier<Optional<T>>. Il tuo esempio sarebbe quindi:

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

Per i dettagli vedere Javadoc o questo post che ho scritto.

L'approccio più pulito ai "servizi di prova" data l'API corrente sarebbe:

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

L'aspetto importante non è la (costante) catena di operazioni che devi scrivere una volta, ma quanto è facile aggiungere un altro servizio (o modificare l'elenco dei servizi è generale). Qui, ()->serviceX(args)è sufficiente aggiungere o rimuovere un singolo .

A causa della valutazione lenta dei flussi, nessun servizio verrà richiamato se un servizio precedente ha restituito un valore non vuoto Optional.

Non è carino, ma funzionerà:

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)è un modello abbastanza utile da usare con Optional. Significa "Se questo Optionalcontiene valore v, dammi func(v), altrimenti dammi sup.get()".

In questo caso, chiamiamo serviceA(args)e riceviamo un Optional<Result>. Se questo Optionalcontiene valore v, vogliamo ottenere Optional.of(v), ma se è vuoto, vogliamo ottenere serviceB(args). Risciacqua-ripeti con più alternative.

Altri usi di questo modello sono

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

Forse questo è ciò che stai cercando: ottieni valore da un Opzionale o da un altro

Altrimenti, potresti dare un'occhiata Optional.orElseGet. Ecco un esempio di ciò che penso che tu stia cercando:

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

Supponendo che tu sia ancora su JDK8, ci sono diverse opzioni.

Opzione n. 1: crea il tuo metodo di supporto

Per esempio:

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

In modo che tu possa fare:

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

Opzione n. 2: utilizzare una libreria

Ad esempio Opzionale di google guava supporta un corretto or()funzionamento (proprio come JDK9), ad esempio:

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

(Dove ritorna ciascuno dei servizi com.google.common.base.Optional, piuttosto che java.util.Optional).

Questo sembra un buon adattamento per il pattern matching e un'interfaccia Option più tradizionale con implementazioni Some e None (come quelle in Javaslang , FunctionalJava ) o un'implementazione pigra di forse in cyclops- reag. Sono l'autore di questa libreria.

Con il ciclope-reazione puoi anche usare la corrispondenza del modello strutturale sui tipi JDK. Per Opzionale puoi abbinare i casi presenti e assenti tramite il modello visitatore . sarebbe simile a questo -

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

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