RxJava——被观察者

被观察者

• 一、概述
• 二、Observable（基本）
• • 2.1、核心结构
  • 2.2、7种创建方式
• 三、Flowable（背压）
• • 3.1、核心特性
  • 3.2、创建方式
  • 3.3、背压处理示例
• 四、Single（单个结果）
• • 4.1、核心特性
  • 4.2、使用示例
• 五、Maybe（0或1个结果）
• • 5.1、核心特性
  • 5.2、使用示例
• 六、Completable（只关心完成）
• • 6.1、核心特性
  • 6.2、使用示例

一、概述

被观察者（Observable/Flowable）是RxJava中数据流的源头，负责发射数据项和通知。

类型	特性	背压支持	适用场景
Observable	基础被观察者	无	数据量小、无需背压控制
Flowable	支持背压的被观察者	有	大数据流、需要背压控制
Single	发射单个数据或错误	无	单次请求响应
Maybe	发射0或1个数据项	无	可能为空的操作
Completable	只关心完成或错误	无	只关注操作是否完成

二、Observable（基本）

2.1、核心结构

public abstract class Observable<T> implements ObservableSource<T> {
    // 核心方法
    protected abstract void subscribeActual(Observer<? super T> observer);
    
    // 静态工厂方法
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source);
    public static <T> Observable<T> just(T item);
    public static <T> Observable<T> fromIterable(Iterable<? extends T> iterable);
    public static <T> Observable<T> fromArray(T... items);
    public static <T> Observable<T> range(int start, int count);
    public static <T> Observable<T> interval(long period, TimeUnit unit);
    public static <T> Observable<T> timer(long delay, TimeUnit unit);
    
    // 操作符方法
    public final Observable<T> filter(Predicate<? super T> predicate);
    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper);
    public final Observable<T> doOnNext(Consumer<? super T> onNext);
    public final Disposable subscribe();
    public final void subscribe(Observer<? super T> observer);
}

2.2、7种创建方式

方式1：create() - 完全手动控制

// 基本用法
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("Item 1");
        emitter.onNext("Item 2");
        emitter.onNext("Item 3");
        emitter.onComplete();
    }
});

// Lambda简化
Observable<String> observable = Observable.create(emitter -> {
    try {
        emitter.onNext("Data 1");
        emitter.onNext("Data 2");
        
        if (!emitter.isDisposed()) {
            emitter.onNext("Data 3");
        }
        
        emitter.onComplete();
    } catch (Exception e) {
        emitter.onError(e);
    }
});

// Emitter接口详解
public interface ObservableEmitter<T> extends Emitter<T> {
    void setDisposable(Disposable d);
    void setCancellable(Cancellable c);
    boolean isDisposed();
    ObservableEmitter<T> serialize();  // 串行化发射
    boolean tryOnError(Throwable t);   // 尝试发射错误
}

方式2：just() - 发射固定数据

// 单个数据
Observable<String> single = Observable.just("Hello");

// 多个数据（最多10个）
Observable<String> multiple = Observable.just("A", "B", "C", "D");

// 内部实现原理（简化版）
public static <T> Observable<T> just(T item) {
    return new ObservableFromArray<>(item);
}

// 等价于
Observable<String> equivalent = Observable.create(emitter -> {
    emitter.onNext("A");
    emitter.onNext("B");
    emitter.onNext("C");
    emitter.onComplete();
});

方式3：from系列 - 从集合/数组创建

// fromIterable
List<String> list = Arrays.asList("A", "B", "C");
Observable<String> fromList = Observable.fromIterable(list);

// fromArray
String[] array = {"A", "B", "C"};
Observable<String> fromArray = Observable.fromArray(array);

// fromCallable（延迟计算）
Observable<String> fromCallable = Observable.fromCallable(() -> {
    // 只在订阅时执行
    return expensiveComputation();
});

// fromFuture（异步执行）
Future<String> future = executor.submit(() -> "Result");
Observable<String> fromFuture = Observable.fromFuture(future);

// fromPublisher（与Reactive Streams互操作）
Publisher<String> publisher = ...;
Observable<String> fromPublisher = Observable.fromPublisher(publisher);

方式4：defer() - 延迟创建

// 每次订阅都创建新的Observable
Observable<String> deferred = Observable.defer(() -> {
    long time = System.currentTimeMillis();
    return Observable.just("Time: " + time);
});

// 测试：每次订阅时间都不同
deferred.subscribe(System.out::println);  // Time: 1234567890
Thread.sleep(1000);
deferred.subscribe(System.out::println);  // Time: 1234568890

// 解决just()的立即求值问题
String value = computeValue();  // 立即执行
Observable<String> immediate = Observable.just(value);

Observable<String> lazy = Observable.defer(() -> 
    Observable.just(computeValue())  // 订阅时执行
);

方式5：range()/interval()/timer() - 特殊工厂

// range: 发射整数序列
Observable<Integer> numbers = Observable.range(1, 10);  // 1到10

// interval: 定时发射（从0开始的递增Long）
Observable<Long> ticks = Observable.interval(1, TimeUnit.SECONDS);  // 每秒发射
Observable<Long> delayedTicks = Observable.interval(1, 1, TimeUnit.SECONDS);  // 延迟1秒开始

// timer: 延迟发射一个0L
Observable<Long> timer = Observable.timer(5, TimeUnit.SECONDS);  // 5秒后发射0

// intervalRange: 区间定时发射
Observable<Long> intervalRange = Observable.intervalRange(
    10,      // 起始值
    5,       // 数量
    0,       // 初始延迟
    1,       // 间隔
    TimeUnit.SECONDS
);  // 每秒发射：10, 11, 12, 13, 14

方式6：empty()/error()/never() - 特殊Observable

// empty: 立即完成，不发射任何数据
Observable<String> empty = Observable.empty();
empty.subscribe(
    item -> System.out.println("Never called"),
    error -> System.out.println("Never called"),
    () -> System.out.println("Completed")  // 立即执行
);

// error: 立即发射错误
Observable<String> error = Observable.error(new RuntimeException("Test Error"));
error.subscribe(
    item -> System.out.println("Never called"),
    error -> System.out.println("Error: " + error),  // 立即执行
    () -> System.out.println("Never called")
);

// never: 什么都不做（用于测试）
Observable<String> never = Observable.never();
never.subscribe(
    item -> System.out.println("Never called"),
    error -> System.out.println("Never called"),
    () -> System.out.println("Never called")
);  // 什么都不发生

方式7：generate() - 状态机模式生成

// 无状态生成
Observable<Integer> simpleGenerate = Observable.generate(
    () -> 0,  // 初始状态
    (state, emitter) -> {
        emitter.onNext(state);
        return state + 1;  // 新状态
    }
).take(5);  // 生成：0, 1, 2, 3, 4

// 有状态生成（带资源清理）
Observable<BigInteger> fibonacci = Observable.generate(
    () -> new BigInteger[]{BigInteger.ZERO, BigInteger.ONE},  // 初始状态
    (state, emitter) -> {
        emitter.onNext(state[0]);
        BigInteger next = state[0].add(state[1]);
        state[0] = state[1];
        state[1] = next;
    },
    state -> System.out.println("Clean up")  // 状态清理
).take(10);

三、Flowable（背压）

3.1、核心特性

public abstract class Flowable<T> implements Publisher<T> {
    // 背压策略枚举
    enum BackpressureStrategy {
        MISSING,      // 不处理背压
        ERROR,        // 缓冲满时抛MissingBackpressureException
        BUFFER,       // 无限缓冲（可能OOM）
        DROP,         // 丢弃溢出数据
        LATEST        // 保留最新数据
    }
    
    // 支持背压的create
    public static <T> Flowable<T> create(
        FlowableOnSubscribe<T> source, 
        BackpressureStrategy mode
    );
}

3.2、创建方式

@Test
public void testCreate() {
    //1. 使用BackpressureStrategy
    Flowable<Integer> flowable = Flowable.create(new FlowableOnSubscribe<Integer>() {
        @Override
        public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; i < 1000; i++) {
                if (!emitter.isCancelled()) {
                    emitter.onNext(i);
                }
            }
            emitter.onComplete();
        }
    }, BackpressureStrategy.BUFFER);//背压策略
    
    // 2. 从Observable转换（需要指定背压策略）
    Observable<Integer> observable = Observable.range(1, 1000);
    Flowable<Integer> fromObservable = observable.toFlowable(BackpressureStrategy.BUFFER);
    
    // 3. 使用generate（自动支持背压）
    Flowable<Integer> generated = Flowable.generate(
            () -> 0,
            (state, emitter) -> {
                emitter.onNext(state);
                if (state < 10) {
                    return state + 1;
                } else {
                    emitter.onComplete();
                    return state;
                }
            }
    );
    
    // 4. interval支持背压
    Flowable<Long> intervalFlowable = Flowable.interval(1, TimeUnit.SECONDS)
            .onBackpressureBuffer(100);
}

3.3、背压处理示例

@Test
public void testBackPressure() {
    //生产者
    Flowable<Integer> producer = Flowable.create(emitter -> {
        for (int i = 0; i < 1000000; i++) {
            if (emitter.requested() == 0) {
                //等待消费者请求
                while (emitter.requested() == 0) {
                    if (emitter.isCancelled())
                        return;
                    Thread.sleep(10);
                }
            }
            emitter.onNext(i);
        }
        emitter.onComplete();
    }, BackpressureStrategy.ERROR);

    //消费者
    producer
            .observeOn(Schedulers.io(), false, 16)//缓冲区大小16
            .subscribe(new Subscriber<Integer>() {
                private Subscription subscription;
                private int count = 0;

                @Override
                public void onSubscribe(Subscription subscription) {
                    this.subscription = subscription;
                    subscription.request(16);//初始请求16个
                }

                @Override
                public void onNext(Integer integer) {
                    //慢速处理
                    process(integer);
                    count++;
                    if (count % 16 == 0) {
                        subscription.request(16);//每处理16个请求16个
                    }
                }

                private void process(Integer integer) {
                    //处理方法
                    System.out.println("process:" + integer);
                }

                @Override
                public void onError(Throwable throwable) {
                    throwable.printStackTrace();
                }

                @Override
                public void onComplete() {
                    System.out.println("Completed");
                }
            });

}

四、Single（单个结果）

4.1、核心特性

从SingleEmitter的源码可以看出，Single只有onSuccess和onError事件。

public interface SingleEmitter<T> {
    void onSuccess(@NonNull T t);
    void onError(@NonNull Throwable t);
    
    void setDisposable(@Nullable Disposable d);
    void setCancellable(@Nullable Cancellable c);
    boolean isDisposed();
    boolean tryOnError(@NonNull Throwable t);
}

其中，onSuccess()用于发射数据（在Observable/Flowable中使用onNext()来发射数据），而且只能发射一个数据，后面即使再发射数据也不会做任何处理。

4.2、使用示例

Single的SingleObserver中只有onSuccess和onError,并没有onComplete.这也是Single与其他4种被观察者之间的最大区别。

@Test
public void testSingle() {
    Single.create(new SingleOnSubscribe<String>() {
        @Override
        public void subscribe(SingleEmitter<String> emitter) throws Exception {
            emitter.onSuccess("test");
        }
    }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            System.out.println(s);
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception {
            throwable.printStackTrace();
        }
    });

    //简化
    Single.create(emitter -> {
        emitter.onSuccess("test");
        emitter.onError(new Throwable("error"));
    }).subscribe(
            e -> System.out.println("onSuccess:" + e),
            t -> System.out.println("onError:" + t.getMessage())
    );
}

Single可以通过toXXX方法转换成Observable、Flowable、Completable及Maybe。

// 创建Single
Single<String> single = Single.create(emitter -> {
    String result = fetchFromNetwork();
    if (result != null) {
        emitter.onSuccess(result);
    } else {
        emitter.onError(new NoDataException());
    }
});

// 等价于Observable的单元素版本
Single<String> fromObservable = Observable.just("Hello")
    .singleOrError();  // 必须只有一个元素

Single<String> fromMaybe = Maybe.just("Hello").toSingle();

// 转换
Single<String> single = Single.fromCallable(() -> "Result");
Observable<String> observable = single.toObservable();

// 使用场景：网络请求
Single<Response> apiCall = apiService.getUser(userId)
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread());

apiCall.subscribe(
    response -> updateUI(response),
    error -> showError(error)
);

五、Maybe（0或1个结果）

5.1、核心特性

Maybe创建之后，MaybeEmitter和SingleEmitter一样，并没有onNext()方法，同样需要通过onSuccess()方法来发射数据。

public interface MaybeEmitter<T> {
    void onSuccess(@NonNull T t);
    void onError(@NonNull Throwable t);
    void onComplete();
    void setDisposable(@Nullable Disposable d);
    void setCancellable(@Nullable Cancellable c);
    boolean isDisposed();
    boolean tryOnError(@NonNull Throwable t);
}

Maybe也只能发射0或者1个数据，即使发射多个数据，后面发射的数据也不会处理。

@Test
public void testMaybe() {
    Maybe.create(emitter -> {
        emitter.onSuccess("testA");
        emitter.onSuccess("testB");
    }).subscribe(s -> System.out.println("s=" + s));
}

s=testA

如果MaybeEmitter先调用了onComplete0,即使后面再调用onSuccess(),也不会发射任何数据。

@Test
public void testMaybe() {
    Maybe.create(emitter -> {
        emitter.onComplete();
        emitter.onSuccess("testA");
    }).subscribe(s -> System.out.println("s=" + s));
}

//无任何输出

5.2、使用示例

// 创建Maybe
Maybe<String> maybe = Maybe.create(emitter -> {
    String data = getDataFromCache();
    if (data != null) {
        emitter.onSuccess(data);
    } else {
        emitter.onComplete();  // 没有错误，只是没有数据
    }
});

// 可能为空的操作
Maybe<String> findUser = userRepository.findUser(userId);

findUser.subscribe(
    user -> System.out.println("Found: " + user),
    error -> System.err.println("Error: " + error),
    () -> System.out.println("No user found")  // 完成但没有数据
);

// 转换
Observable<String> observable = maybe.toObservable();  // 发射0或1个元素
Single<String> single = maybe.toSingle("Default");  // 提供默认值

六、Completable（只关心完成）

6.1、核心特性

Completable在创建后，不会发射任何数据。从CompletableEmitter的源码中可以看到。

public interface CompletableEmitter {
    void onComplete();
    void onError(@NonNull Throwable t);
    void setDisposable(@Nullable Disposable d);
    void setCancellable(@Nullable Cancellable c);
    boolean isDisposed();
    boolean tryOnError(@NonNull Throwable t);
}

Completable只有onComplete和onError事件，同时Completable并没有map、flatMap等操作符，它的操作符比起Observable/Flowable要少得多。

可以通过fromXXX操作符来创建一个Completable。这是一个Completable版本的HelloWorld。

@Test
public void testCompletable() {
    Completable.fromAction(() -> {
        System.out.println("Hello World");
    }).subscribe();
}

Hello World

Completable经常结合andThen操作符使用。

@Test
public void testCompletable() {
    Completable.create(emitter -> {
        try {
            TimeUnit.SECONDS.sleep(1);
            emitter.onComplete();
        }catch (InterruptedException e) {
            emitter.onError(e);
        }
    }).andThen(Observable.range(1, 10))
            .subscribe(System.out::println);
}

1
2
3
4
5
6
7
8
9
10

在这里，emitter...onComplete(执行完成之后，表明Completable己经执行完毕，接下来执行andThen里的操作。

6.2、使用示例

// 创建Completable
Completable completable = Completable.create(emitter -> {
    performOperation();  // 执行操作
    emitter.onComplete();
});

// 异步操作
Completable deleteTask = Completable.fromAction(() -> 
    database.deleteAll()
).subscribeOn(Schedulers.io());

// 使用场景：只关心操作是否成功
Completable saveOperation = userRepository.saveUser(user)
    .andThen(Completable.fromAction(() -> 
        cache.invalidate(user.getId())
    ));

saveOperation.subscribe(
    () -> System.out.println("Save successful"),
    error -> System.err.println("Save failed: " + error)
);

// 与Observable转换
Completable.fromObservable(Observable.just(1, 2, 3));
Observable<Void> observable = completable.toObservable();