响应式拿手好道-RxJava-RxAndroid实战指南

w风雨无阻w

于 2024-05-21 08:51:31 发布

阅读量714

点赞数 20

分类专栏： java 文章标签： rxjava android rxandroid

本文链接：https://blog.csdn.net/lizhong2008/article/details/139075887

版权

java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

面对移动开发中异步场景的复杂性，有了RxJava/RxAndroid这一利器在手，我们就能如虎添翼，大幅简化异步编程的难度。本文将引导你深入理解RxJava的核心概念和使用方式，并在Android平台下合理运用RxAndroid，掌握响应式编程的精髓。

一、RxJava的响应式编程思想

RxJava的核心思想就是基于观察者模式构建的响应式编程。我们从最基本的概念开始:

Observable/Observer、Subscriber
操作符:map/flatMap/filter等
线程调度:Scheduler

响应式编程是一种编程范式，它允许程序组件之间异步传递数据，并且数据的变化可以被观察和响应。RxJava 是实现响应式编程的一个流行库。下面我将通过示例代码，循序渐进地介绍 RxJava 中的几个基本概念：Observable、Observer、Subscriber 以及一些常用的操作符和线程调度器。

1、Observable（可观察者）

Observable 是一个核心概念，代表了一个数据源，它可以发出三种类型的回调：onNext、onError 和 onCompleted。Observable 是一个抽象类，你需要通过创建它的实例来发出数据。

（1）、Observer（观察者）

Observer 是一个接口，它定义了对 Observable 发出的回调进行响应的方法。

（2）、Subscriber（订阅者）

Subscriber 是 Observer 的一个扩展，它允许你订阅 Observable 并管理订阅的生命周期。

2、操作符

RxJava 提供了多种操作符来处理 Observable 发出的数据，例如 map、flatMap 和 filter。

map：对每个发射的数据项应用一个函数。
flatMap：将发射的数据项转换成 Observable，然后将它们扁平化为一个单一的 Observable。
filter：根据某种条件过滤发射的数据项。

3、线程调度器（Scheduler）

Scheduler 用于控制并发，允许你指定 Observable 在特定的线程或线程池中执行。

4、示例代码

下面是一个简单的例子，演示了如何创建一个 Observable，使用 map 操作符处理数据，并在主线程中订阅它。

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.Observer;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.schedulers.Schedulers;

// 创建 Observer
Observer<String> observer = new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
        System.out.println("Subscribed!");
    }

    @Override
    public void onNext(String s) {
        System.out.println("Received: " + s);
    }

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

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

// 创建 Observable
Observable<String> observable = Observable.create(emitter -> {
    emitter.onNext("Hello");
    emitter.onNext("World");
    emitter.onComplete();
});

// 使用 map 操作符
observable
    .map(string -> string.toUpperCase()) // 将字符串转换为大写
    .subscribeOn(Schedulers.io()) // 在 IO 线程执行
    .observeOn(AndroidSchedulers.mainThread()) // 在主线程观察
    .subscribe(observer); // 订阅 Observable

在这个例子中，我们首先创建了一个 Observer，它定义了如何处理 Observable 发出的每个数据项。然后我们创建了一个 Observable，它发出 “Hello” 和 “World” 字符串，然后完成发射。

我们使用 map 操作符将每个字符串转换为大写形式。接着，我们指定 Observable 在 IO 线程中执行，并通过 observeOn 方法指定观察者在主线程中接收数据。

最后，我们调用 subscribe 方法订阅 Observable，并将我们创建的 Observer 传递给它。这样，每当 Observable 发出数据时，我们的 Observer 就会收到通知。

这个简单的例子展示了响应式编程的基本思想：创建数据流，处理数据流，并在适当的时候响应数据流中的数据变化。通过 RxJava，你可以构建复杂的异步程序，同时保持代码的清晰和简洁。

二、RxJava的应用实战

对RxJava有了一定认识后，我们便可以动手在实际项目中使用它了。下面我们模拟几个移动开发中常见的异步场景:

1、网络请求与数据合并

场景描述：在移动应用中，经常需要从多个网络接口获取数据，并将这些数据合并为一个统一的响应。

使用技巧：

使用 Observable 来表示每个网络请求。
使用 flatMap 或 concatMap 来处理多个网络请求的响应。
使用 zip 或 merge 操作符来合并多个数据流。

示例代码：

复制
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.android.schedulers.Schedulers;
import io.reactivex.rxjava3.schedulers.Schedulers;

Observable<String> userObservable = apiService.getUser()
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread());

Observable<String> postObservable = apiService.getPosts()
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread());

// 使用 zip 操作符合并两个 Observable
Observable.zip(userObservable， postObservable， (user， posts) -> {
    // 合并数据
    return "User: " + user + "， Posts: " + posts;
}).subscribe(result -> {
    // 处理合并后的结果
});

2、事件流的变换处理

场景描述：在用户交互中，可能需要对用户的输入或行为进行监听，并根据这些事件进行相应的变换处理。

使用技巧：

使用 Observable.create 创建一个自定义的事件流。
使用 map 或 flatMap 对事件流进行变换处理。

示例代码：

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.subjects.PublishSubject;
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.observers.DisposableObserver;

PublishSubject<String> inputSubject = PublishSubject.create();

// 创建一个观察者监听输入事件
inputSubject
    .map(input -> input.trim()) // 移除输入的首尾空白
    .filter(input -> !input.isEmpty()) // 过滤掉空字符串
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new DisposableObserver<String>() {
        @Override
        public void onNext(String input) {
            // 处理有效的输入
        }

        @Override
        public void onError(Throwable e) {
            // 处理错误
        }

        @Override
        public void onComplete() {
            // 完成
        }
    });

// 模拟用户输入
inputSubject.onNext(" Hello World ");

3、RxBus/RxRelay事件总线

场景描述：在复杂的应用中，可能需要在组件之间传递消息，RxBus 是一个基于 RxJava 的事件总线实现，用于解耦事件的发送者和接收者。

使用技巧：

使用 PublishSubject 或 BehaviorSubject 作为事件的中心存储。
使用 filter 操作符来过滤不需要的事件。

示例代码：

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.subjects.PublishSubject;
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.observers.DisposableObserver;

public class RxBus {
    private final PublishSubject<Object> bus = PublishSubject.create();

    public void post(Object event) {
        bus.onNext(event);
    }

    public Observable<Object> toObservable() {
        return bus;
    }
}

// 使用 RxBus 发送和接收事件
RxBus rxBus = new RxBus();

// 发送事件
rxBus.post(new SomeEvent());

// 接收事件
rxBus.toObservable()
    .filter(event -> event instanceof SomeEvent)
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new DisposableObserver<Object>() {
        @Override
        public void onNext(Object event) {
            // 处理事件
        }

        @Override
        public void onError(Throwable e) {
            // 处理错误
        }

        @Override
        public void onComplete() {
            // 完成
        }
    });

注意事项

内存泄漏：在使用 Subscriber 或 Observer 时，确保在 onComplete 或 onError 后取消订阅，避免内存泄漏。
线程管理：合理使用 subscribeOn 和 observeOn 来控制数据流的线程。
错误处理：使用 onErrorResumeNext 或 onErrorReturn 来处理流中可能出现的错误。
响应式链的设计：合理设计响应式链，避免过度使用操作符导致性能问题。
生命周期管理：特别是在 Android 中，需要考虑组件的生命周期，避免在组件销毁后仍然接收数据。

通过这些实战案例，你可以看到 RxJava 在处理异步逻辑、事件变换和组件间通信方面的强大能力。它不仅可以简化代码，还可以提高代码的可读性和可维护性。

三、RxAndroid在Android平台的应用

RxAndroid 是 RxJava 的一个扩展库，专门为 Android 开发设计，它解决了在 Android 上进行响应式编程时的一些常见问题。RxAndroid 提供了一系列绑定 Android API 的操作符，以及一些特定于 Android 的功能。

1、主线程调度：AndroidSchedulers

在 Android 中，某些操作需要在主线程（UI 线程）上执行，比如更新 UI 组件。AndroidSchedulers 是 RxAndroid 提供的一个工具类，它包含了几个预定义的调度器，允许你将流绑定到 Android 的主线程。

使用方式：

import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.observers.DisposableObserver;

Observable.just("Hello， Android!")
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new DisposableObserver<String>() {
        @Override
        public void onNext(String value) {
            // 这将在主线程执行
            updateTextView(value);
        }

        @Override
        public void onError(Throwable e) {
            // 处理错误
        }

        @Override
        public void onComplete() {
            // 完成
        }
    });

2、生命周期感知：RxLifecycle

在 Android 开发中，一个常见的问题是内存泄漏，这通常是因为订阅者（Subscriber）在组件（如 Activity 或 Fragment）销毁后仍然存活。RxLifecycle 是一个库，它提供了一种方法来自动地在组件的生命周期事件（如 onCreate、onStart、onStop、onDestroy）中订阅和取消订阅。

使用方式：

首先，你需要定义一个 LifecycleProvider，并在你的组件中管理它。

getLifecycle().addObserver(new LifecycleBoundariesObserver(this));

然后，你可以使用 RxLifecycle 来绑定你的 Observable。

import io.reactivex.rxjava3.android.lifecycle.LifecycleTransformer;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.subjects.BehaviorSubject;

Observable.just("Hello， Lifecycle!")
    .compose(bindToLifecycle(getLifecycle()))
    .subscribe(new DisposableObserver<String>() {
        // ...
    });

LifecycleTransformer<Object> bindToLifecycle(Lifecycle lifecycle) {
    return RxLifecycle.from(lifecycle)
            .until(Lifecycle.Event.ON_STOP);
}

3、RxBinding: View 事件绑定

RxBinding 是 RxAndroid 的一个子库，它提供了一种方式来绑定 Android 的视图事件（如点击、滚动等）到 Observable。这样，你可以很容易地对这些事件进行响应式处理。

使用方式：

import com.jakewharton.rxbinding3.view.RxView;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.observers.DisposableObserver;

Observable<Object> clicks = RxView.clicks(someButton);
clicks
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new DisposableObserver<Object>() {
        @Override
        public void onNext(Object event) {
            // 按钮被点击了
        }

        @Override
        public void onError(Throwable e) {
            // 处理错误
        }

        @Override
        public void onComplete() {
            // 完成
        }
    });

内部原理分析

AndroidSchedulers：内部使用 Handler 来检查当前线程是否为主线程，如果是，则直接执行；如果不是，它将使用主线程的 Looper 来调度执行。
RxLifecycle：通过监听组件的生命周期事件，并在适当的时刻调用 onSubscribe 和 onDispose，来管理 Subscription 的生命周期。
RxBinding：通过封装 Android 的监听器模式，创建了 Observable 对象，它可以发出视图的事件。

使用 RxAndroid 和它的相关库，你可以在 Android 应用中构建出强大且易于管理的响应式系统。这些工具不仅简化了异步编程和事件处理，还提高了代码的可读性和可维护性。

四、RxJava/RxAndroid实战经验分享

在具体使用RxJava/RxAndroid过程中，我也遇到了一些常见的挑战，总结了一些经验教训:

1、内存泄漏

问题：在 Android 中，如果 Observable 的生命周期比 Activity 或 Fragment 的生命周期长，那么可能会导致内存泄漏，因为 Observable 仍然持有对 Activity 或 Fragment 的引用。

解决方案：

使用弱引用：对于需要在 Observable 中引用 Activity 或 Fragment 的情况，可以使用 WeakReference 来避免强引用。
绑定生命周期：使用 RxLifecycle 库来自动管理订阅的生命周期，确保在组件（如 Activity 或 Fragment）的生命周期结束时取消订阅。
及时取消订阅：确保在组件销毁时取消所有活跃的订阅。

示例代码：

CompositeDisposable compositeDisposable = new CompositeDisposable();
// 订阅时
compositeDisposable.add(observable.subscribe(...));
// 在 Activity 的 onDestroy() 中
compositeDisposable.clear();

2、异常处理

问题：在 RxJava 链中，如果任何一个操作符抛出异常，那么整个流就会错误终止，除非被捕获和处理。

解决方案：

使用 onErrorReturn：为 Observable 链添加 onErrorReturn 操作符，返回一个默认值。
使用 onErrorResumeNext：继续发射另一个 Observable。
使用 doOnError：处理错误，比如打印日志或通知用户。

示例代码：

observable
    .onErrorReturn(new Function<Throwable， String>() {
        @Override
        public String apply(Throwable throwable) throws Exception {
            // 返回默认值
            return "Default Value";
        }
    })
    .subscribe(...);

3、背压问题

问题：当数据的生成速度大于消费速度时，可能会导致内存溢出或降低应用性能，这就是所谓的背压问题。

解决方案：

使用 buffer：使用 buffer 操作符收集数据并批量处理。
使用 sample 或 throttleLast：采样或限制发射数据的频率。
使用 observeOn：在不同的线程中生成和消费数据，以减少背压。

示例代码：

observable
    .throttleLast(1， TimeUnit.SECONDS) // 每秒只处理一个数据项
    .observeOn(Schedulers.io()) // 在 IO 线程消费数据
    .subscribe(...);

其他经验教训

避免创建太多 Observable 对象：尽量重用 Observable 链，避免为每个订阅都创建新的 Observable。
谨慎使用 flatMap：flatMap 可以很容易地产生大量并发任务，导致性能问题或内存溢出。
线程管理：合理使用 subscribeOn 和 observeOn 来管理线程，避免不必要的线程切换。
资源管理：确保在 Observable 完成或出现错误时，释放外部资源，如文件句柄或网络连接。

通过这些解决方案和经验教训，可以帮助您在使用 RxJava/RxAndroid 时避免一些常见的陷阱，构建更加稳定和高效的应用。

结语：

总的来说，掌握了RxJava/RxAndroid这一宝贵的响应式编程利器，必将使我们在移动开发的道路上阔步前行，逐步解锁高阶异步编程的大门。当然，这绝非止步之路，Kotlin协程等新兴技术的涌现，也将给响应式编程领域注入新的活力。保持开放的学习心态，我们定能驾驭更多先进工具，创造出更卓越的作品。

w风雨无阻w

关注

20
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
0
评论
响应式拿手好道-RxJava-RxAndroid实战指南

总的来说，掌握了RxJava/RxAndroid这一宝贵的响应式编程利器，必将使我们在移动开发的道路上阔步前行，逐步解锁高阶异步编程的大门。当然，这绝非止步之路，Kotlin协程等新兴技术的涌现，也将给响应式编程领域注入新的活力。保持开放的学习心态，我们定能驾驭更多先进工具，创造出更卓越的作品。
复制链接

扫一扫