Необязательный orElse Необязательный в Java

Я работал с новым опциональным типом в Java 8 , и я столкнулся с тем, что кажется обычной операцией, которая не поддерживается функционально: "orElseOptional"

Рассмотрим следующую схему:

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

Существует много форм этого паттерна, но он сводится к желанию "orElse" для необязательного параметра, который принимает функцию, создающую новый необязательный параметр, вызываемый только в том случае, если текущий не существует.

Его реализация будет выглядеть так:

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

Мне любопытно, есть ли причина, по которой такой метод не существует, если я просто использую Optional непреднамеренным образом, и какие другие способы люди придумали для решения этого случая.

Я должен сказать, что я думаю, что решения, включающие пользовательские служебные классы / методы, не элегантны, потому что люди, работающие с моим кодом, не обязательно будут знать, что они существуют.

Кроме того, если кто-нибудь знает, будет ли такой метод включен в JDK 9, и где я мог бы предложить такой метод? Мне кажется, это довольно вопиющее упущение в API.

Это часть JDK 9 в форме or, которая занимает Supplier<Optional<T>>. Ваш пример будет:

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

Для деталей смотрите Javadoc или этот пост, который я написал.

Самый чистый подход «попробуй сервисы», учитывая текущий API, будет:

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

Важным аспектом является не (постоянная) цепочка операций, которую вы должны написать один раз, а то, насколько просто добавить другую службу (или изменить список служб, как правило). Здесь, добавление или удаление одного ()->serviceX(args)достаточно.

Из-за ленивой оценки потоков никакая служба не будет вызвана, если предыдущая служба вернула непустую Optional.

Это не красиво, но это будет работать:

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)это довольно удобный шаблон для использования с Optional. Это означает «Если это Optionalсодержит ценность v, дай мне func(v), иначе дай мне sup.get()».

В этом случае мы звоним serviceA(args)и получаем Optional<Result>. Если это Optionalсодержит значение v, мы хотим получить Optional.of(v), но если оно пустое, мы хотим получить serviceB(args). Промыть-повторить с большим количеством альтернатив.

Другое использование этого шаблона

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

Возможно, это то, что вам нужно: получить значение от одного дополнительного или другого

В противном случае, вы можете посмотреть Optional.orElseGet. Вот пример того, что я думаю, что вы после:

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

Предполагая, что вы все еще на JDK8, есть несколько вариантов.

Вариант № 1: создайте свой собственный вспомогательный метод

Например:

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

Чтобы вы могли сделать:

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

Вариант № 2: использовать библиотеку

Например, google guava Optional поддерживает правильную or()работу (так же, как JDK9), например:

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

(Где каждая из услуг возвращается com.google.common.base.Optional, а не java.util.Optional).

Это выглядит как подходящее для сопоставления с образцом и более традиционного интерфейса Option с реализациями Some и None (например, в Javaslang , FunctionalJava ) или с отложенной реализацией Maybe в cyclops-реагировать. Я являюсь автором этой библиотеки.

С помощью циклоп-реакции вы также можете использовать структурное сопоставление с образцом в типах JDK. Для Необязательного вы можете сопоставить существующие и отсутствующие случаи с помощью шаблона посетителя . это будет выглядеть примерно так -

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

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