一张图看懂Rxjava的原理

最新推荐文章于 2024-07-25 11:40:41 发布

卖火柴的小男孩2020

最新推荐文章于 2024-07-25 11:40:41 发布

阅读量717

点赞数

分类专栏： RxJava2.0

本文链接：https://blog.csdn.net/u014644594/article/details/109021725

版权

RxJava2.0 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

https://www.cnblogs.com/jymblog/p/11731546.html

一张图看懂Rxjava的原理

Observable.create ObservableOnSubscribe

create map subscribeOn map observeOn flatMap

subscribe observer subscribeActual

ObservableXXX

subscribe注入观察者

从左往右的构建流：用来构建整个事件序列，这个流表征了整个链路的构建过程，相当于构造方法。
从右往左的订阅流：当最终订阅(subscribe方法)这个行为发生的时候，每个节点从右向左依次执行订阅行为。
从左往右的观察者回调流：当事件发生以后，会通过这个流依次通知给各个观察者。

构建流订阅流回调流 subscribe

构建流订阅流
ObservableSource subscribe observer

ObserverOn SubscribeOn

onSubscribe observer

subscribeActual observer

ObserverOn

ObserverSubscribeon

ObservableOnSubscribe

Observable subscribe

.map Function
.subscribeOn Schedulers.io
observeOn AndroidSchedulers.mainThread
.subscribe

Observable subscribe Observer observer

RxJavaPlugins.onSubscribe

subscribeActual

observable去订阅observer，所以在rxjava中，subscribe可以理解“注入”观察者。

ObservableSource

observeOn subscribeOn

create map subscribeOn observeOn

public final Observable<T> subscribeOn(Scheduler scheduler) {

subscribeActual

observeOn
ObservableSubscribeOn

Observable.class

protected abstract void subscribeActual(Observer<? super T> observer);

subscribeActual observer

执行订阅行为，这里的source是该节点构造函数传入的source，通过源码得知其实就是N5节点的上一个节点N4，因此，这里的订阅行为本质上是让当前节点的上一个节点订阅当前节点新生成的Observer。

Android：图文解析带你快速了解RxJava原理

https://www.jianshu.com/p/d52ef3ad7460

总结：RxJava 是一个基于事件流、实现异步操作的库

Observable Observer

Event

RxJava原理可总结为：

被观察者（Observable）通过订阅（Subscribe）按顺序发送事件给观察者（Observer）
观察者（Observer）按顺序接收事件 & 作出对应的响应动作。具体如下图：

Observable Subscribe Observer

Android Rxjava：这是一篇清晰 & 易懂的Rxjava 入门教程

https://www.jianshu.com/p/a406b94f3188
create subscribe

just from

Subscriber Observer），

-特别注意：2种方法的区别，即Subscriber 抽象类与Observer 接口的区别 --

确定被观察者Observable是否还持有观察者Subscriber的引用

Subscribe）

observable.subscribe(observer);
// 或者 observable.subscribe(subscriber)；

onSubscribe.call subscriber

注：整体方法调用顺序：观察者.onSubscribe（）> 被观察者.subscribe（）> 观察者.onNext（）>观察者.onComplete()

Action

整体方法调用顺序：观察者.onSubscribe（）> 被观察者.subscribe（）> 观察者.onNext（）>观察者.onComplete()

onSubscribe subscribe onNext onComplete

BiCon

Consumer

Observable<Integer>

create ObservableOnSubscribe

observable.subscribe observer

onSubscribe onComplete

public final void subscribe(Observer<? super T> observer) {}
// 表示观察者对被观察者发送的任何事件都作出响应

subscribe Observer observer

Android RxJava：最基础的操作符详解 - 创建操作符

https://www.jianshu.com/p/e19f8ed863b1

Observable.empty

error

never

defer

call just
subscribe

observable new Observer

Observable.timer .subscribe

onSubscribe

create just fromArray fromIterable
empty
error never defer

timer interval
intervalRange range
rangeLong（）

Android RxJava：图文详解变换操作符

https://www.jianshu.com/p/904c14d253ba

Observable 变换操作符Subscriber Observer

Map变换操作符 FlatMap（） ConcatMap（） buffer

create

ObservableOnSubscribe

ObservableEmitter

create

FlatMap（）

Function ObservableSource

Observable.fromIterable（）

concatMap
Buffer（）

just buffer subscribe

new Observer<List<Integer>>()

onSubscribe

new Observer<List<Integer>>()

Android RxJava：组合 / 合并操作符详细教程

https://www.jianshu.com/p/c2a7c03da16d

Zip（）

combineLatest combineLatestDelayError（）

concat

concatArray

merge mergeArray（）
Obervable）需要发送的事件中

Observable.intervalRange
Observable.merge

ObservableOnSubscribe

concat
create

Observable

concatArrayDelayError

ObservableOnSubscribe

Zip（）组合过后的事件序列

Observable1 Observable2 Subscriber Observer

ObservableOnSubscribe subscribe

.subscribeOn Schedulers.io 设置被观察者1在工作线程1中工作

ObservableEmitter subscribe ObservableOnSubscribe

Schedulers.newThread

Observable.zipf(observable1, observable2, new BiFunction<Integer, String, String>() {
@Override
public String apply(Integer integer, String string) throws Exception {
return integer + string;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}

BiFunction

combineLatest

1,2,3 TimeUnit.SECONDS
just intervalRange

Observable.combineLatest Observable.just

intervalRange
BiFunction long long long

apply

subscribe Consumer accept

;just

collect Callable call

new BiConsumer

ArrayList<Integer>,Integer

startWith startWithArray
Observable.just
.subscribe Observer

onSubscribe

Android RxJava 实际应用讲解：从磁盘 / 内存缓存中获取缓存数据

https://www.jianshu.com/p/6f3b6b934787--

磁盘缓存中的数据内存缓存中

内存-磁盘-网络

memoryCache diskCache
//12

ObservableOnSubscribe

just concat firstElement

Retrofit Eventbus）
Android RxJava 实际应用讲解：合并数据源 & 同时展示

https://www.jianshu.com/p/fc2e551b907c

RxJava
Android RxJava实际应用合并数据源需求同时展示

Merge（）例子 Zip（）例子：结合Retrofit

数据源多样
RxJava组合操作符

just

Observable
merge subscribe Observer

onSubscribe

GET
Observable<Translation2> getCall_2

addConverterFactory GsonConverterFactory
addCallAdapterFactory RxJava2CallAdapterFactory

create

subscribeOn (被观察者-Observable)

observeOn(观察者)

AndroidSchedulers.mainThread

Android RxJava 实际应用讲解：联合判断多个事件

https://www.jianshu.com/p/2becc0eaedab

combineLatest RxJava

concat（）的使用请看文章()
//

RxTextView.textChanges.skip

Function3 CharSequence

apply

Android RxJava：细说线程控制（切换 / 调度）（含Retrofit实例讲解）
https://www.jianshu.com/p/5225b2baaecd

Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点
subscribeOn

observeOn（）进行讲解

Observable Observer

create ObservableOnSubscribe

subscribe ObservableEmitter

Observer

onSubscribe subscribe

observable.subscribe observer

被观察者（Observable）在子线程中生产事件（如实现耗时操作等等）
观察者（Observer）在主线程接收 & 响应事件（即实现UI操作）

Observable Observer

newThread io Schedulers

mainThread AndroidSchedulers
try{
}
subscribeOn observeOn（）进行讲解

<-- 使用说明 -->
// Observable.subscribeOn（Schedulers.Thread）：指定被观察者发送事件的线程（传入RxJava内置的线程类型）
// Observable.observeOn（Schedulers.Thread）：指定观察者接收 & 响应事件的线程（传入RxJava内置的线程类型）

<-- 实例使用 -->
// 步骤3：通过订阅（subscribe）连接观察者和被观察者
observable.subscribeOn(Schedulers.newThread()) // 1. 指定被观察者生产事件的线程
.observeOn(AndroidSchedulers.mainThread()) // 2. 指定观察者接收 & 响应事件的线程
.subscribe(observer); // 3. 最后再通过订阅（subscribe）连接观察者和被观察者

observeOn

doOnNext Consumer accept
observeOn Schedulers.newThread
subscribe observer

// 注：
// 1. 整体方法调用顺序：观察者.onSubscribe（）> 被观察者.subscribe（）> 观察者.doOnNext（）>观察者.onNext（）
>观察者.onComplete()

// 2. 观察者.onSubscribe（）固定在主线程进行

onSubscribe subscribe doOnNext onNext

Retrofit

retrofit retrofit2 rxjava2 -adapter

retrofit2 converter-gson

rxandroid rxjava

Observable getCall

retrofit.create

request.getCall Observable observable

observable.subscribeOn mainThread

Disposable.dispose

CompositeDisposable.add
CompositeDisposable.clear

Android RxJava 实际应用讲解：网络请求出错重连（结合Retrofit）

https://www.jianshu.com/p/508c30aef0c1
事件流
retryWhen
RxJava
Android RxJava：功能性操作符全面讲解
https://www.jianshu.com/p/b0c3669affdb

1. 作用
辅助被观察者（Observable）在发送事件时实现一些功能性需求

如错误处理、线程调度等等

功能性操作符

do
onSubscribe

onErrorReturn
onErrorResumeNext
onExceptionResumeNext

retry

retryUntil（）

retryWhen

observable subscriber）观察者

ObservableOnSubscribe
subscribe

onSubscribe subscribe

Observer

onSubscribe

doOnSubscribe

ObservableOnSubscribe

subscribe subscribe

onSubscribe

Observable.subscribe Subscriber

subscriber）观察者.onStart

onErrorResumeNext

Function Throwable ObservableSource
apply

.onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
@Override
public ObservableSource<? extends Integer> apply(@NonNull Throwable throwable) throws Exception {

// 1. 捕捉错误异常
Log.e(TAG, "在onErrorReturn处理了错误: "+throwable.toString() );

// 2. 发生错误事件后，发送一个新的被观察者 & 发送事件序列
return Observable.just(11,22);

ObservableSource<? extends Integer>

onExceptionResumeNext Observable<Integer>

subscribeActual Observer

observer.onNext

BiPredicate

Predicate Throwable

test

retryWhen

Function Observable<Throwable>,ObservableSource<?>

888r事件才会回调
.retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {

@Override
public ObservableSource<?> apply(@NonNull Observable<Throwable> throwableObservable) throws Exception {
// 参数Observable<Throwable>中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型
// 返回Observable<?> = 新的被观察者 Observable（任意类型）
// 此处有两种情况：
// 1. 若新的被观察者 Observable发送的事件 = Error事件，那么原始Observable则不重新发送事件：
// 2. 若新的被观察者 Observable发送的事件 = Next事件，那么原始的Observable则重新发送事件：
return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(@NonNull Throwable throwable) throws Exception {

// 1. 若返回的Observable发送的事件 = Error事件，则原始的Observable不重新发送事件
// 该异常错误信息可在观察者中的onError（）中获得
return Observable.error(new Throwable("retryWhen终止啦"));

// 2. 若返回的Observable发送的事件 = Next事件，则原始的Observable重新发送事件（若持续遇到错误，则持续重试）
// return Observable.just(1);
}
});88

                       Function
                   Observable Throwable , ObservableSource

                   apply
                   .flatMap
                   ObservableSource apply throwable

                       .error just       .flatMap Function Throwable ObservableSource

               vvvvvvvvv Observable.just(1,2,4).repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {

               Function<Observable《Object》》》》>
               {

               }
@Override
// 在Function函数中，必须对输入的 Observable<Object>进行处理，这里我们使用的是flatMap操作符接收上游的数据
public ObservableSource<?> apply(@NonNull Observable<Object> objectObservable) throws Exception {
// 将原始 Observable 停止发送事件的标识（Complete（） / Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable）
// 以此决定是否重新订阅 & 发送原来的 Observable
// 此处有2种情况：
// 1. 若新被观察者（Observable）返回1个Complete（） / Error（）事件，则不重新订阅 & 发送原来的 Observable
// 2. 若新被观察者（Observable）返回其余事件，则重新订阅 & 发送原来的 Observable
return objectObservable.flatMap(new Function<Object, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(@NonNull Object throwable) throws Exception {

// 情况1：若新被观察者（Observable）返回1个Complete（） / Error（）事件，则不重新订阅 & 发送原来的 Observable
return Observable.empty();
// Observable.empty() = 发送Complete事件，但不会回调观察者的onComplete（）

// return Observable.error(new Throwable("不再重新订阅事件"));
// 返回Error事件 = 回调onError（）事件，并接收传过去的错误信息。

// 情况2：若新被观察者（Observable）返回其余事件，则重新订阅 & 发送原来的 Observable
// return Observable.just(1);
// 仅仅是作为1个触发重新订阅被观察者的通知，发送的是什么数据并不重要，只要不是Complete（） / Error（）事件
}
});

}
})
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}

@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件" + value);
}

@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应：" + e.toString());
}

@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}

});vertical



观察者订阅被观察者

retrofit.create

getCall

Observable

observable.retryWhen Function<Observable>

throwableObservable
Function
.flatMap () {Throwable ,ObservableSource<?>

}

Observable.just(1).delay TimeUnit.