【Android RxJava】Observal与Subject深入理解

原创 已于 2025-10-15 23:23:50 修改 · 1k 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android #rxjava

于 2025-10-15 23:11:40 首次发布

文章目录

一. 基本定义

1. Observal(冷流)

  • Observable 是 RxJava 中最基本的响应式流数据源。
  • 它是只读的，只能被观察，不能主动发射数据。
  • 它遵循观察者模式（Observer Pattern），只能由数据源向观察者（Observer）单向推送数据。
Observable<String> observable = Observable.just("Hello", "World");

observable.subscribe(item -> System.out.println("Observer 1: " + item));
observable.subscribe(item -> System.out.println("Observer 2: " + item));

2. Subject(热流)

  • Subject 是一个特殊的对象，它既是 Observable 又是 Observer。
  • 它可以主动发射数据（作为 Observer 接收数据），也可以被其他观察者订阅（作为 Observable 发送数据）。可以在运行时主动调用 onNext()、onError()、onComplete()。
  • 可以实现多播（Multicast），即一个数据流被多个观察者共享。
PublishSubject<String> subject = PublishSubject.create();

subject.subscribe(item -> System.out.println("Observer 1: " + item));
subject.onNext("Hello");
subject.onNext("World");

subject.subscribe(item -> System.out.println("Observer 2: " + item));
subject.onNext("RxJava");

3. Subject分类

3.1 PublishSubject：只发送订阅后接收到的数据

PublishSubject只会把在订阅发生的时间点之后来自原始Observable的数据发射给观察者。需要注意的是，PublishSubject可能会一创建完成就立刻开始发射数据（除非你可以阻止它发生），因此这里有一个风险：在Subject被创建后到有观察者订阅它之前这个时间段内，一个或多个数据可能会丢失。如果要确保来自原始Observable的所有数据都被分发，你需要这样做：或者使用Create创建那个Observable以便手动给它引入"冷"Observable的行为（当所有观察者都已经订阅时才开始发射数据），或者改用ReplaySubject。

 private void testPublishSubject(){
        PublishSubject<String> publishSubject = PublishSubject.create();
        Subscriber subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }
 
            @Override
            public void onError(Throwable e) {
                System.out.println("onError:"+e.getMessage());
            }
 
            @Override
            public void onNext(String s) {
                System.out.println("onNext:"+s);
            }
        };
        publishSubject.onNext("1");
        publishSubject.onNext("2");
        publishSubject.onNext("3");
        publishSubject.subscribe(subscriber);
        publishSubject.onNext("4");
        publishSubject.onCompleted();
    }
    //输出的结果是：
onNext:4
onCompleted

//这就是丢失了1,2,3这三个数据

3.2 BehaviorSubject：发送订阅时最近的一个数据或默认值

当观察者订阅BehaviorSubject时，它开始发射原始Observable最近发射的数据（如果此时还没有收到任何数据，它会发射一个默认值），然后继续发射其它任何来自原始Observable的数据。然而，如果原始的Observable因为发生了一个错误而终止，BehaviorSubject将不会发射任何数据，只是简单的向前传递这个错误通知。

 private void testBehaviorSubject(){
        BehaviorSubject<String> behaviorSubject = BehaviorSubject.create("default");
        Subscriber subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }
 
            @Override
            public void onError(Throwable e) {
                System.out.println("onError:"+e.getMessage());
            }
 
            @Override
            public void onNext(String s) {
                System.out.println("onNext:"+s);
            }
        };
 
        behaviorSubject.onNext("1");
        behaviorSubject.onNext("2");
        behaviorSubject.onNext("3");
        behaviorSubject.subscribe(subscriber);
        behaviorSubject.onNext("4");
        behaviorSubject.onNext("5");
        behaviorSubject.onCompleted();
    }
   // 输出的结果是：
onNext:3
onNext:4
onNext:5
onCompleted

3.3 ReplaySubject：发送所有历史数据

ReplaySubject会发射所有来自原始Observable的数据给观察者，无论它们是何时订阅的。也有其它版本的ReplaySubject，在重放缓存增长到一定大小的时候或过了一段时间后会丢弃旧的数据（原始Observable发射的）。
如果你把ReplaySubject当作一个观察者使用，注意不要从多个线程中调用它的onNext方法（包括其它的on系列方法），这可能导致同时（非顺序）调用，这会违反Observable协议，给Subject的结果增加了不确定性。

 private void testReplaySubject(){
        ReplaySubject<String> replaySubject = ReplaySubject.create();
        Subscriber subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }
 
            @Override
            public void onError(Throwable e) {
                System.out.println("onError:"+e.getMessage());
            }
 
            @Override
            public void onNext(String s) {
                System.out.println("onNext:"+s);
            }
        };
        replaySubject.onNext("1");
        replaySubject.onNext("2");
        replaySubject.onNext("3");
        replaySubject.subscribe(subscriber);
        replaySubject.onNext("4");
        replaySubject.onCompleted();
    }
    //输出的结果是：
onNext:1
onNext:2
onNext:3
onNext:4
onCompleted
// 没有丢失数据
// 假如第一行代码改成         ReplaySubject<String> replaySubject = ReplaySubject.createWithSize(2);
// 输出结果是：(会丢失数据1)
onNext:2
onNext:3
onNext:4
onCompleted

3.4 AsyncSubject：只在 onComplete 后发送最后一个数据

一个AsyncSubject只在原始Observable完成后，发射来自原始Observable的最后一个值。（如果原始Observable没有发射任何值，AsyncSubject也不发射任何值）它会把这最后一个值发射给任何后续的观察者。然而，如果原始的Observable因为发生了错误而终止，AsyncSubject将不会发射任何数据，只是简单的向前传递这个错误通知

  • 场景1：AsyncSubject当做Observer
 private void testAsyncSubject() {
        AsyncSubject<String> asyncSubject = AsyncSubject.create();
 
        Observable.just("1", "2", "3")
                .subscribe(asyncSubject);
 
        asyncSubject.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }
 
            @Override
            public void onError(Throwable e) {
                System.out.println("onError:" + e.getMessage());
            }
 
            @Override
            public void onNext(String s) {
                System.out.println("onNext:" + s);
            }
        });
    }
    //输出
onNext:3
onCompleted
  • 场景2：如果Observable因为错误发了终止
 private void testAsyncSubject() {
        AsyncSubject<String> asyncSubject = AsyncSubject.create();
 
        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("1");
                subscriber.onError(new Exception("asyncSubjectError"));
                subscriber.onNext("2");
                subscriber.onNext("3");
                subscriber.onCompleted();
            }
        }).subscribe(asyncSubject);
 
        asyncSubject.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }
 
            @Override
            public void onError(Throwable e) {
                System.out.println("onError:" + e.getMessage());
            }
 
            @Override
            public void onNext(String s) {
                System.out.println("onNext:" + s);
            }
        });
    }
    // 输出
    onError:asyncSubjectError
  • 场景3：AsyncSubject当做Observable
 private void testAsyncSubject(){
            AsyncSubject<String> asyncSubject =AsyncSubject.create();
            asyncSubject.subscribe(new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    System.out.println("onCompleted");
                }
 
                @Override
                public void onError(Throwable e) {
                    System.out.println("onError:"+e.getMessage());
                }
 
                @Override
                public void onNext(String s) {
                    System.out.println("onNext:"+s);
                }
            });
 
            asyncSubject.onNext("1");
            asyncSubject.onNext("2");
            asyncSubject.onNext("3");
            asyncSubject.onCompleted();
        }
        // 输出的结果是：
onNext:3
onCompleted

4. 冷流和热流

一句话理解：Hot Observable 意思是如果他开始传输数据，你不主动喊停(dispose()/cancel())，那么他就不会停，一直发射数据，即使他已经没有Subscriber了。而Cold Observable则是subscribe时才会发射数据。

4.1 冷流

  • 冷流会在每个观察者订阅时重新开始发射数据。
  • 数据流是独立的，每个观察者都会收到完整的数据序列。
  • 适用于一次性任务，如网络请求、读取文件等。
Observable<Long> coldObservable = Observable.intervalRange(0, 5, 0, 1, TimeUnit.SECONDS)
                                            .map(i -> i);

coldObservable.subscribe(i -> System.out.println("Observer 1: " + i));
Thread.sleep(2000);
coldObservable.subscribe(i -> System.out.println("Observer 2: " + i));

Thread.sleep(5000);

输出:
Observer 1: 0
Observer 1: 1
Observer 1: 2
Observer 1: 3
Observer 1: 4
Observer 2: 0
Observer 2: 1
Observer 2: 2
Observer 2: 3
Observer 2: 4

4.2 热流

  • 热流在整个生命周期中只发射一次数据流。
  • 所有订阅者共享同一个数据流。
  • 如果观察者订阅得晚，就不会收到之前的数据（除非使用 ReplaySubject 等缓存机制）。
ConnectableObservable<Long> hotObservable = Observable.interval(1, TimeUnit.SECONDS)
                                                     .take(5)
                                                     .publish();

hotObservable.connect();

hotObservable.subscribe(i -> System.out.println("Observer 1: " + i));
Thread.sleep(2000);
hotObservable.subscribe(i -> System.out.println("Observer 2: " + i));

Thread.sleep(4000);
// 输出：
Observer 1: 0
Observer 1: 1
Observer 1: 2
Observer 2: 2
Observer 1: 3
Observer 2: 3
Observer 1: 4
Observer 2: 4
(Observer2延迟2s因此0和1输出没打印出来)

在这里插入图片描述

4.3 冷流转换为热流

**publish()：**适用于需要手动控制热流生命周期的场景。
需要手动调用 connect() 才会开始发射数据。

Observable<Long> cold = Observable.interval(1, TimeUnit.SECONDS).take(5);
ConnectableObservable<Long> hot = cold.publish();

hot.subscribe(i -> System.out.println("Observer 1: " + i));
hot.subscribe(i -> System.out.println("Observer 2: " + i));

hot.connect(); // 手动触发数据流

Thread.sleep(3000);

二. 业务场景应用的探索

1. APP与服务端建立单一持久的连接

建议采用Subject，更准确地说，使用 PublishSubject 或 BehaviorSubject 是因为它们的“热流”特性，能够很好地支持异步通信、事件广播、状态共享等需求
使用 Subject 可以让多个观察者共享同一个连接通道，避免重复建立连接。

2. APP 用户登录、注册、验证码

OBSERVABLE 是一次性的“请求-响应”模型；每次订阅都应重新发起网络请求（冷流特性）

探索移动开发中RxJava的Subject类型
移动开发前沿的博客
07-22 793
本文旨在全面解析RxJava中Subject类型的设计原理和使用方法，帮助移动开发者掌握这一强大工具，提升应用架构的响应式能力。内容涵盖基础概念、核心类型、线程安全及实际应用场景。从观察者模式引出Subject概念详细解析四种主要Subject类型通过实际案例展示应用场景讨论线程安全和使用注意事项提供进阶使用技巧和资源推荐Observable：可观察对象，数据/事件的发射源Observer：观察者，接收并处理数据/事件Subject。
Android RxJava：Subject使用及示例
weixin_42814000的博客
05-06 1205
RxJava的四种Subjects：PublishSubject、ReplaySubject、BehaviorSubject、AsyncSubject的理解 Subject：它既是Observable，又是observer。也就是既可以发送事件，也可以接收事件。 Subject将观察者和被观察者结合为一体，是观察者和被观察者的代理。 下面是四个子类PublishSubject、ReplaySubject、BehaviorSubject、AsyncSubject的区别： PublishSubject<I
Android RxJava2.0：4种Subject
weixin_42814000的博客
05-06 1354
4种Subject 分别为：PublishSubject、ReplaySubject、BehaviorSubject、AsyncSubject Subject将观察者和被观察者结合为一体，是观察者和被观察者的代理。 （1）AsyncSubject AsyncSubject asyncSubject = AsyncSubject.create(); asyncSubject.onNext("A"); asyncSubject.onNext("B"); asyncSubject.
RxJava Subject
qq_40194724的博客
02-07 1086
在Rxjava中，Subject可以同时表示Observer和Observable, 允许从单个源到多个子观察者。除了, 其他方法都是线程安全的，可以使用使它们线程安全。Subject有6个继承类，分别是: 释放接收到的所有数据:释放订阅前最后一个数据和订阅后接收到的所有数据:释放订阅后接收到的数据:仅释放接收到的最后一个数据:串行Subject:仅支持订阅一次的Subject。
Android RxJava和Kotlin Flow的使用场景和优缺点
要乐观，要积极，多笑，多照镜子
09-27 784
摘要 RxJava的Observable和Kotlin的Flow均用于异步数据流处理，但各有侧重： Observable：成熟生态、丰富操作符，适合Java/Kotlin混合项目及复杂流处理，但需手动管理生命周期，学习成本高。 Flow：轻量简洁，深度集成Kotlin协程与Jetpack，支持自动背压和生命周期管理，但仅限Kotlin，冷流特性需适配热流场景。 选择建议：纯Kotlin项目优先用Flow；混合项目或复杂流操作选Observable。
RxJava2（三）Subject和Processor
qq_39507260的博客
11-11 2268
一， Subject 它既是一个Observable可不断调用onNext发射数据，直到遇到onComplete结束，又是一个Observer可订阅数据。它可以将订阅的数据作为自己的数据发射出去。 包含4种类型：AsyncSubject，BehaviorSubject，ReplaySubject，PublishSubject。 AsyncSubject 观察者/订阅者只会接受到onComplete...
android rxjava 多线程,你真的了解RxJava的线程切换吗？
weixin_42511887的博客
05-25 1269
使用RxJava可以轻松地实现线程切换，所以在Android中常被用来替代AsyncTask、Handler等原生工具类。使用起来虽然简单，但如果不了解其背后的基本原理，很可能因为使用不当而写出bug。本文将带大家简单了解一下RxJava线程切换的实现原理以及开发中的注意事项1. Basic UsageSchedulerIf you want to introduce multithreading...
Android RxJava 自定义操作符基础和Subject介绍
baiiu
07-16 1029
前言掌握RxJava自定义操作符能大大方便开发，所以本文将介绍RxJava自定义操作符。一般在自定义操作符会和Subject类连用，所以文章有两个部分：自定义操作符和Subject。1. 自定义操作符RxJava提供了两种自定义操作符的方式： 使用Observable.lift(Operator) 使用Observable.compose(Transformer). lift是对 Subscriber 进行操作
Android观察者模式，Rxjava观察者模式简介
weixin_46039528的博客
04-09 2091
Observable: 被观察者 (Subject)。Observer/Subscriber: 观察者。Subscribe:订阅。Observable 和 Observer 通过 subscribe0)方法实现订阅关系，可以理解为绑定关联起来。
Android中Rxjava实现三级缓存的两种方式
08-30
在Android开发中，数据缓存是一种常见的优化策略，它可以提高应用的响应速度和用户体验，特别是在网络请求时。这里我们讨论如何使用RxJava来实现三级缓存机制，即内存缓存、磁盘缓存和网络缓存。RxJava是一个强大的...
android使用RxJava实现预加载
08-31
在本文中，我们将深入探讨如何利用RxJava库来实现预加载功能，特别是通过BehaviorSubject的特性。 RxJava是一个强大的响应式编程库，它允许开发者以声明式的方式处理异步数据流。在预加载场景中，BehaviorSubject...
给 Android 开发者的 RxJava 详解.zip_android
09-23
本文将深入探讨RxJava在Android开发中的应用及其核心概念。 1. **什么是RxJava** RxJava是Reactive Extensions的Java实现，它将观察者模式、发布者模式和函数式编程的概念结合在一起，形成了一种反应式编程范式。...
【Android FrameWork】延伸阅读：AssetManager
u012739527的博客
11-19 676
AssetManager 功能与使用解析 AssetManager 是 Android 中管理 APK 内 assets 目录的核心工具类，主要负责处理未编译的原始文件访问。它与处理 res 目录编译资源的 Resources 不同：AssetManager 通过相对路径访问 assets 下的任意格式文件，支持多级目录结构；而 Resources 通过资源 ID 访问预定义类型的编译后资源。 AssetManager 的核心功能包括： 加载 APK 中的 assets 目录（通过 addAssetPath
Bagisto单独将后台设置成中文
CHINAHEAO的专栏
11-23 148
趣玩游戏 游戏礼包 [!--empirenews.listtemp--] [!--empirenews.listtemp--] 安卓app下载 苹果app下载×-->
android 反编译
Cailand的专栏
11-20 308
参考：https://blog.youkuaiyun.com/m0_57836225/article/details/154300720​​​​​。JADX下载后可以直接打开apk文件阅读源码。
安卓15+Compose全面屏适配
xiangzhihong8的专栏
11-21 79
随着Android 15(API 35)的发布，Google继续推动沉浸式全面屏UI设计。虽然这种设计提升了现代应用的视觉体验，但也引入了一些细微变化，可能会破坏现有布局——特别是如果你的应用依赖精确处理系统栏的话。本文将探讨如何为API 35迁移你的Jetpack Compose应用，并讨论管理全面屏UI过渡的最佳实践。
【Android】浅析View的事件分发机制
LiuYaoheng的博客
11-23 916
《Android 进阶之光》学习笔记
Android13后长按电源键实现关机
crl6的博客
11-19 230
结果 就百度了一下，出来的全是csdn的收费博客，找免费实现的花了我十几分钟也没有找到，结果自己看一下源码几分钟就搞定了。（csdn你是穷疯了吗，怎么还不倒闭）这个需求不难，只是活太多，太多了，大脑分时复用一下百度一下看看有没有人已经实现了，不想自己花时间去研究。Android13后需要长按组合键才能弹关机对话框。
Android Gradle工程引入三方so库的方法
最新发布
胡同老道的博客
11-23 88
在做安卓逆向工程的时候，有时候需要引入三方开发好的jni库，这些库可能非常老旧，甚至是32位的，本文记录引入的过程，便于快速查找。5.完成上述步骤后，即可在java文件中通过Jni.xxx引用so库中的静态方法了。3.在工程任意处加入加载so的代码，一般放到MainActivity.java中。注意，不要带lib，不要带后缀，上述so实际文件名是libplay.so。2.拷贝原工程中的jni函数定义到新工程中，1.把so库拷贝到工程中。
Rxjava中observal subject的区别
10-16
在 RxJava 中，`Observable` 和 `Subject` 都是用于处理响应式数据流的重要组件，但它们在用途和行为上有显著的区别。 ### 1. `Observable` - `Observable` 是 RxJava 中最基本的响应式流数据源。 - 它是只读的，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值