Какие знаешь сущности в RxJava?

Основные сущности в RxJava

RxJava — это библиотека для реактивного программирования, основанная на концепции Observable (наблюдаемый источник данных) и Observer (наблюдатель). В RxJava 2.x и 3.x архитектура была расширена и теперь включает несколько ключевых сущностей, которые представляют различные типы потоков данных. Основные сущности можно разделить на Source (источники) и Consumer (потребители).

Основные источники данных (Source)

Observable

Это самый базовый и универсальный источник. Он может emit (emit — излучать, отправлять) любое количество элементов (включая нулевое) и завершиться успешно (onComplete) или с ошибкой (onError). Он не поддерживает backpressure (обратное давление). Пример:

Observable<String> observable = Observable.create(emitter -> {
    emitter.onNext("Hello");
    emitter.onNext("RxJava");
    emitter.onComplete();
});

observable.subscribe(
    item -> System.out.println("Received: " + item), // onNext
    error -> System.out.println("Error: " + error),   // onError
    () -> System.out.println("Completed")             // onComplete
);

Flowable

Аналог Observable, но с поддержкой backpressure, что критично для обработки больших объемов данных или когда Producer (производитель) emits быстрее, чем Consumer (потребитель) может обрабатывать. Flowable использует стратегии backpressure, такие как BUFFER, DROP, LATEST.

Flowable<Integer> flowable = Flowable.range(1, 1000)
    .onBackpressureBuffer(500); // Стратегия буферизации

flowable.subscribe(new Subscriber<Integer>() {
    @Override
    public void onSubscribe(Subscription s) {
        s.request(100); // Явное управление потоком данных
    }
    // ... другие методы
});

Single

Источник, который emits только один элемент или ошибку. Аналог Future или Promise. Часто используется для сетевых запросов или операций, где ожидается единственный результат.

Single<User> single = Single.fromCallable(() -> fetchUserFromApi());
single.subscribe(
    user -> System.out.println("User: " + user),
    error -> System.out.println("Failed: " + error)
);

Maybe

Источник, который может emit один элемент, завершиться без элемента (onComplete) или с ошибкой. Подходит для операций, которые могут возвращать null или отсутствующие данные.

Maybe<String> maybe = Maybe.create(emitter -> {
    String data = findData();
    if (data != null) {
        emitter.onSuccess(data);
    } else {
        emitter.onComplete(); // Нет данных, но нет ошибки
    }
});

Completable

Источник, который не emits элементов, только сигнал о успешном завершении (onComplete) или ошибке (onError). Используется для выполнения действий, где результат не нужен (например, логирование или отправка данных без ожидания ответа).

Completable completable = Completable.fromAction(() -> {
    performBackgroundTask();
});
completable.subscribe(
    () -> System.out.println("Task done"),
    error -> System.out.println("Error in task")
);

Основные потребители данных (Consumer)

Observer

Базовый интерфейс для потребителей Observable. Он имеет методы:

• onSubscribe(Disposable d) — уведомление о подписке, дает возможность управления жизненным циклом через Disposable.
• onNext(T item) — получение элемента.
• onError(Throwable e) — получение ошибки.
• onComplete() — уведомление о успешном завершении потока.

Subscriber

Аналог Observer для Flowable, но с дополнительной поддержкой backpressure через метод onSubscribe(Subscription s), где Subscription позволяет явно управлять потоком данных с помощью request(long n).

Subscriber<String> subscriber = new Subscriber<String>() {
    Subscription subscription;
    @Override
    public void onSubscribe(Subscription s) {
        this.subscription = s;
        s.request(1); // Запрос первого элемента
    }
    @Override
    public void onNext(String item) {
        // обработка item
        subscription.request(1); // Запрос следующего элемента
    }
    // ... другие методы
};

Disposable и Subscription

Сущности для управления жизненным циклом подписки:

• Disposable используется для Observable, Single, Maybe, Completable. Позволяет отменить подписку (dispose()).
• Subscription используется для Flowable. Помимо отмены (cancel()), позволяет контролировать backpressure через request(long n).

Дополнительные важные сущности

Schedulers

Обеспечивают многопоточность и управление потоками выполнения. Основные:

• Schedulers.io() — для I/O операций (сеть, файлы).
• Schedulers.computation() — для вычислений (CPU-intensive tasks).
• Schedulers.newThread() — создает новый поток для каждой задачи.
• Schedulers.single() — один общий поток для последовательных задач.
• Schedulers.from(Executor) — адаптация пользовательского Executor.

Operators (Операторы)

Функции для преобразования, фильтрации, комбинирования потоков. Примеры: map, filter, flatMap, merge, concat, debounce, distinct.

Subject

Специальный тип, который одновременно является и Observable и Observer (мультиплексор). Он может subscribe к другим источникам и сам emit элементы. Типы Subject:

• PublishSubject — emits элементы только после подписки.
• BehaviorSubject — emits последний элемент и все следующие новым подписчикам.
• ReplaySubject — emits все элементы (или часть) новым подписчикам.
• AsyncSubject — emits только последний элемент перед onComplete.

PublishSubject<String> subject = PublishSubject.create();
subject.subscribe(item -> System.out.println("Subscriber 1: " + item));
subject.onNext("Hello");
subject.subscribe(item -> System.out.println("Subscriber 2: " + item));
subject.onNext("World");

Резюме

RxJava предоставляет богатый набор сущностей для моделирования различных потоков данных:

• Observable и Flowable для многозначных потоков (Flowable с backpressure).
• Single, Maybe, Completable для специальных случаев с одним или нулем элементов.
• Observer, Subscriber как потребители.
• Disposable/Subscription для управления подписками.
• Schedulers для многопоточности.
• Operators для трансформации данных.
• Subject для гибридного поведения.

Выбор конкретной сущности зависит от требований: объема данных, необходимости backpressure, ожидаемого количества элементов и модели ошибок. В современных Android проектах часто используются Single для сетевых запросов и Observable для локальных потоков данных, а Flowable применяется при высоконагруженных потоках (например, события UI или сенсоров).