RxJava——被观察者

吴声子夜歌2026-02-11 21:11

被观察者

一、概述

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

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

二、Observable（基本）

2.1、核心结构

java 复制代码 
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() - 完全手动控制

java 复制代码 
// 基本用法
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() - 发射固定数据

java 复制代码 
// 单个数据
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系列 - 从集合/数组创建

java 复制代码 
// 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() - 延迟创建

java 复制代码 
// 每次订阅都创建新的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() - 特殊工厂

java 复制代码 
// 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

java 复制代码 
// 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() - 状态机模式生成

java 复制代码 
// 无状态生成
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、核心特性

java 复制代码 
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、创建方式

java 复制代码 
@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、背压处理示例

java 复制代码 
@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事件。

java 复制代码 
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种被观察者之间的最大区别。

java 复制代码 
@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。

java 复制代码 
// 创建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()方法来发射数据。

java 复制代码 
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个数据，即使发射多个数据，后面发射的数据也不会处理。

java 复制代码 
@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(),也不会发射任何数据。

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

//无任何输出

5.2、使用示例

java 复制代码 
// 创建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的源码中可以看到。

java 复制代码 
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。

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

Hello World

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

java 复制代码 
@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、使用示例

java 复制代码 
// 创建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();
相关推荐
雨白3 小时前
Android 快捷方式实战指南：静态、动态与固定快捷方式详解
android
hqk3 小时前
鸿蒙项目实战：手把手带你实现 WanAndroid 布局与交互
android·前端·harmonyos
LING3 小时前
RN容器启动优化实践
android·react native
恋猫de小郭6 小时前
Flutter 发布官方 Skills ，Flutter 在 AI 领域再添一助力
android·前端·flutter
Kapaseker11 小时前
一杯美式搞懂 Any、Unit、Nothing
android·kotlin
黄林晴11 小时前
你的 Android App 还没接 AI？Gemini API 接入全攻略
android
恋猫de小郭21 小时前
2026 Flutter VS React Native ，同时在 AI 时代 VS Native 开发，你没见过的版本
android·前端·flutter
冬奇Lab1 天前
PowerManagerService(上):电源状态与WakeLock管理
android·源码阅读
这个实现不了1 天前
echarts实例：可堆叠的立体柱形图+特殊symbol的折线图
echarts
这个实现不了1 天前
echarts实例：进度条加描述
echarts
热门推荐
01GitHub 镜像站点02OpenClaw 使用和管理 MCP 完全指南03OpenClaw + 飞书（Feishu）环境搭建指南04OpenClaw优化飞书API 额度已耗尽问题05Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services06本地部署 OpenClaw + DeepSeek-R1 完全指南07Window 10部署openclaw报错node.exe : npm error code 12808小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）09OpenClaw大龙虾机器人完整安装教程10Clawdbot部署教程：解决‘gateway token missing’授权问题的完整步骤