В чем разница между возможностями rxjava2 и необязательными?

Question

Док говорит

Концептуально, это объединение одного и Completable обеспечение означает, чтобы захватить образец излучения там, где может быть 0 или 1 элемент или ошибка сигнализируют какой-реактивного источника.

Но я не уверен, что это на самом деле означает. Кажется, это java8's Optional.

Следующие два кода имеют одинаковый результат, но я не знаю, что может сделать Maybe, и Optional не может (или громоздко) сделать.

@Test 
    public void testMaybe1() { 
    Observable.just(3, 2, 1, 0, -1) 
     .map(i -> { 
     try { 
      int result = 6/i; 
      return Maybe.just(result); 
     } catch (Exception e) { 
      return Maybe.empty(); 
     } 
     }) 
     .blockingForEach(maybe -> { 
      logger.info("result = {}", maybe.blockingGet()); 
     } 
    ); 
    } 


    @Test 
    public void testMaybe2() { 
    Observable.just(3, 2, 1, 0, -1) 
     .map(i -> { 
     try { 
      int result = 6/i; 
      return Optional.of(result); 
     } catch (Exception e) { 
      return Optional.empty(); 
     } 
     }) 
     .blockingForEach(opt -> { 
      logger.info("result = {}", opt.orElse(null)); 
     } 
    ); 
    } 

Результаты одинаковы:

result = 2 
result = 3 
result = 6 
result = null 
result = -6 

В rxJava1 мой API используется для возврата Observable<Optional<T>>, Является ли это плохой запах? Должен ли я перейти на Observable<Maybe<T>>?

Answer 1

Maybe обертка вокруг операции/события, которые могут иметь либо

1. Один результат
2. Нет результата
3. результат ошибки

Однако Необязательно является оберткой значения, которые могут быть либо

1. Присутствуют
2. Отсутствуют

В вашем примере, в map операциях, вычисление является синхронным (т.е. 6/i является синхронным и может привести к значению сразу), и вы хотите распространять значение (если возможно деление) или пустое значение (если деление невозможно). Следовательно, использование смысла Optional имеет больше смысла.

Есть однако другие варианты также:

• Если вы хотите распространять, почему разделение не представляется возможным, то вы хотите сообщить исключение, которое произошло. В таком случае использование Maybe будет иметь больше смысла.

• Если вас не интересуют как пустое значение, так и причина ошибки, вы просто хотите пропустить распространение этих результатов. В таком сценарии я бы использовал flatMap вместо map. Тогда я не буду использовать ни один из Optional или Maybe.

  .flatMap(i -> { 
      try { 
      int result = 6/i; 
      return Observable.just(result); 
      } catch (Exception e) { 
      return Observable.empty(); 
      } 
  }) 
  

Maybe также полезно, когда у вас есть Observable, которые могут испускать несколько значений, но вы заинтересованы в, скажем, только первый и, следовательно, вы используете оператор firstElement() на Observable. Это возвращает значение Maybe, потому что либо есть одно значение, либо нет значения (если источник Observable не выдаёт никакого значения перед завершением), либо возникает ошибка (если исходные ошибки наблюдаются перед выдачей какого-либо значения).

Answer 2

rxjava [2] цели Java6. Это означает, что нет встроенной поддержки Optional, и они должны принести свои собственные. Подобно тому, как они должны приносить свои собственные типы Function.

Если ваше приложение/библиотека поддерживает только Java> = 8, вы можете использовать все, что вам подходит.

Answer 3

Разница, относящаяся к вашему вопросу, заключается в том, что Maybe может распространять ошибку, а Optional не может - в вашем примере нельзя различать ошибку и пустой результат. Если обработка ошибок важна, Optional бесполезен, а Maybe имеет Maybe.error(Throwable). API-накрест, для случая использования я бы предпочел Single к Maybe - потому что он дает либо ошибки или одного результата, поэтому тип возвращаемого будет Observable<Single<T>>

Answer 4

Maybe - это ленивый поток нуль или одна вещь (и поток может привести к ошибке). Optional не ленив, он либо присутствует, либо отсутствует. Нет смысла отсроченного расчета с Optional, тогда как есть Maybe.