Выберите подходящий объект Observable в соответствии с вашими требованиями

Если у вас нет базовых представлений о RxJava, прочтите сообщение RxJava: многопоточность в Android. Если у вас есть базовое представление о RxJava, вы должны знать, что Observable - это компонент, который передает значения в Observer. Этот пост посвящен изучению различных типов Observables, доступных в RxJava.

Различные типы наблюдаемых

Наблюдаемый объект может доставлять несколько значений любого типа - литералы, сообщения или события, в зависимости от контекста. В зависимости от того, как Observable испускает данные, они были разделены на следующие категории:

  1. Наблюдаемый
  2. Одинокий
  3. Завершенный
  4. Может быть
  5. Текучий

Для каждого Observable у нас есть следующие Observers.

  • Наблюдатель
  • SingleObservable
  • CompletableObserver
  • Может быть, наблюдаемый

Как и в посте RxJava: многопоточность в Android, мы уже исследовали Observable. Итак, давайте разберемся с другими типами подробнее.

Одинокий

Single - это наблюдаемое, которое выдает только один элемент или выдает ошибку. Другими словами, Single - это реактивный базовый тип, который может генерировать одиночный onSuccess или onError. Простейшее использование Single в Android - это когда мы выполняем сетевой вызов для потребления некоторых данных. Single - один из наиболее часто используемых Observable, потому что у нас есть сетевые вызовы в большинстве приложений. Это реализация интерфейса io.reactivex.SingleObserver<T>, имеющего три метода.

interface SingleObserver<T> {
    void onSubscribe(Disposable d);
    void onSuccess(T value);
    void onError(Throwable error);
}
  • onSubscribe: будет вызываться всякий раз, когда наблюдатель подписан
  • onError: будет вызываться всякий раз, когда в какой-либо точке потока возникает ошибка
  • onSuccess: будет вызываться, если мы получим ответ от потока, в этом случае мы можем обработать ответ

Предположим, что существует приложение TvShows с TvShowsRepo, которое представляет собой модифицированный интерфейс с методами для получения подробных сведений.

interface TvShowsRepo {
@Get(Constants.BaseUrl +"/show-detaisl/")
fun getShowDetails(showId: Int):Single<SeriesResponse>
}

Здесь мы используем Single, потому что это разовая задача. Мы внедрим репо в ViewModel и потребляем данные, как показано ниже.

Этот метод getShowDetails() запускается и возвращает либо ответ от сервера, либо ошибку. Вот как мы обычно используем Single Observable для одноразового использования. Узнайте больше о Single.

Завершенный

Completable касается только завершения выполнения без выдачи значения. Completable observable не будет генерировать никаких данных, вместо этого он уведомляет о статусе задачи: успех или сбой.

interface CompletableObserver<T> {
    void onSubscribe(Disposable d);
    void onComplete();    
    void onError(Throwable error);
}
  • onSubscribe будет вызываться один раз из Completable для установки Disposable в этом экземпляре, который затем может быть использован для отмены подписки в любое время в будущем.
  • onError будет вызываться один раз, если отложенное вычисление вызовет исключение.
  • onComplete будет вызываться после того, как отложенное вычисление завершится нормально без каких-либо ошибок.

Обычно мы используем Completable для хранения значений в настройках или локальной базе данных SQLite и т. Д., Где ответ не требуется.

@Singleton
class CachedRepoImpl @Inject constructor(private val cacheService: CacheService) : CacheRepo {
fun saveUserData(userModel: String): Completable {
    return Completable.fromAction {
        cacheService.saveProfile(userModel)
    }
}
}

В приведенном выше примере cacheService - это класс, в который добавлены общие настройки для сохранения и извлечения данных.

Мы потребляем это как подачу

Метод saveUserDetails() выполняется и возвращает успешный или неудачный обратный вызов выполнения задачи. Вот как мы обычно используем Completable Observable для обратных вызовов успеха или неудачи. Узнайте больше о Completable.

Может быть

Может быть, наблюдаемое может или не может выдавать значение. Эту наблюдаемую можно использовать в том случае, если вы ожидаете, что элемент будет отправлен по желанию.

interface MaybeObserver<T> {
    void onSubscribe(Disposable d);
    void onSuccess(T value);
    void onError(Throwable error);
    void onComplete();
}

onSubscribe() предоставляет MaybeObserver средства отмены или удаления соединения с Maybe как синхронно, так и асинхронно.

onSuccess() уведомляет MaybeObserver одним элементом и о том, что он завершил отправку push-уведомлений.

onError уведомляет MaybeObserver, в котором возникла ошибка.

onComplete вызывается после нормального завершения отложенного вычисления.

Давайте посмотрим на следующий фрагмент

Когда он будет выполнен, вывод будет:

Hello

Затем давайте посмотрим на еще один фрагмент

Когда приведенный выше фрагмент будет выполнен, вывод будет следующим:

Completed. No items.

Второй излучает onComplete Completed. No items, потому что нет элементов для излучения. Первый выводит Hello внутри onSuccess и не генерирует onComplete после этого выброса. Может быть, в некоторой степени. похож на Single Observable, за исключением того, что в Maybe это необязательная функция для генерации значения. Узнайте больше о Maybe.

Текучий

Flowable - это наблюдаемое, которое следует использовать, когда Observable генерирует огромные объемы данных, которые Observer не может обработать эти выбросы данных. Наблюдаемые источники не поддерживают противодавление. Есть два основных аспекта, в которых мы используем Flowable:

  1. Сложные случаи, когда огромные объемы данных, которые пользовательский интерфейс не может обработать
  2. Чтобы получать уведомления, когда уже наблюдаются изменения в данных

Второе использование распространено в приложениях для чата для частого обновления пользовательского интерфейса.

public interface Publisher<T> {
public void subscribe(Subscriber<? super T> s);
}

Запросы метода подписки для начала потоковой передачи данных. Это заводской метод, который можно вызывать несколько раз, каждый раз при запуске новой подписки. Каждая подписка будет работать только для одного подписчика. Подписчик должен подписаться только один раз на одного издателя. Если издатель отклоняет попытку подписки или терпит неудачу, он сигнализирует об ошибке через обратный вызов onError.

Flowable.fromArray(1, 2, 3, 4).subscribe(
        { i: Int? -> Timber.v("Entry %d\n", i) },
        { e: Throwable? ->Timber.v("Failed to process: %s\n", e) }
) { Timber.v("Done") }

Выше было простое использование Flowable, которое печатает числа из массива.

Когда используется Flowable, необходимо обрабатывать выбросы через край, используя стратегию, называемую противодавлением. В противном случае генерируется исключение, такое как MissingBackpressureException или OutOfMemoryError. Мы обсудим это подробно в наших следующих публикациях.

Узнайте больше о Flowable.

Бонус

Чтобы узнать больше о RxJava, прочтите предыдущие части этой серии от базового до продвинутого по Rx:

использованная литература

Https://github.com/ReactiveX/RxJava