Android框架源码分析——RxJava源码分析

最新推荐文章于 2021-12-09 11:10:34 发布

Alex@W

最新推荐文章于 2021-12-09 11:10:34 发布

阅读量414

点赞数

分类专栏： Android源码分析和框架编写文章标签： RxJava Observable

本文链接：https://blog.csdn.net/Alexwll/article/details/94206902

版权

Android源码分析和框架编写专栏收录该内容

22 篇文章 2 订阅

订阅专栏

1、基本订阅流程

使用实例

Observable.create(ObservableOnSubscribe<String> { e -> e.onNext("A") })
    .subscribe(object : Observer<String>{
    override fun onComplete() {
    }
    override fun onSubscribe(d: Disposable) {
    }
    override fun onNext(t: String) {
    }
    override fun onError(e: Throwable) {
    }
})

RxJava的使用很简单概括为3个流程：

创建被观察者实例发送事件
创建观察者实例监听处理事件
被观察者订阅观察者，订阅成功后被观察者发送事件

2、源码分析

2.1、Observable创建

Observable的基本使用是调用Observable.create()，create()最终创建的Observable的实现类ObserveCreate，封装传入的ObservableOnSubscribe，ObservableOnSubscribe负责最终的事件发送

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source)); 
}

ObserveCreate：继承Observable类，在内部保存创建时传入的ObservableOnSubscribe实例

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source; //保存传入参数
    }
}

2.2、创建观察者实例

实现Observer接口的实例

interface Observer<T>

2.3、订阅观察者

public final void subscribe(Observer<? super T> observer) {
        observer = RxJavaPlugins.onSubscribe(this, observer); //保存观察者
        subscribeActual(observer); //执行观察者的subscribeActual抽象方法，从上面知道这里执行的是ObservableCreate（）中重写的抽象方法
    }
}

Observable.subscribe(Observer<? super T> observer)中主要作了两件事：

封装并保存下游设置的观察者Observer实例，在接收事件及时响应事件
执行被观察者的subscribeActual（）触发Observable发送事件，这里执行的是 ObservableCreate.subscribeActual（）

subscribeActual（）：此处调用的是ObservableCreate中实现的方法

@Override
protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer); 
    observer.onSubscribe(parent);  
        source.subscribe(parent); 
}

subscribeActual（）中主要作以下3件事：

创建CreateEmitter包装观察者
执行调用观察者的onSubscribe方法,传入CreateEmitter实例，用于在请求时可以使用此对象控制或终止事件发送
执行传入的source.subscribe（）开始发送事件，这里传入的是封装后的观察者

ObservableOnSubscribe.subscribe()：执行onNext（）发送事件

ObservableOnSubscribe<String> { e -> e.onNext("A") } //此处的e为CreateEmitter实例

CreateEmitter.onNext()：调用观察者的方法响应事件

@Override
public void onNext(T t) {
    if (!isDisposed()) { //检查是否取消订阅事件
        observer.onNext(t); //（1）响应接收事件
    }
}
@Override
public void onComplete() { //响应onComplete事件
    if (!isDisposed()) {
       observer.onComplete();
    }
}
@Override
public void onError(Throwable t) { //响应onError事件
}

事件发送从调用传入CreateEmitter的next（），在next（）中直接调用Observer的onNext（）响应发送的事件，这里的Observer就是前面订阅时传入的，此处可以看出发送的事件onNext（）、onComplete（）、onError（）事件和观察者监听事件一一对应；

3、复杂订阅流程

上面的整个流程是最基本的订阅流程，即一层发送事件一层观察事件，虽然简单但却是RxJava的原理所在，很多复杂的程序也是利用此原理一步一步封装拓展过来的，在他们的内部是很多层简单的逻辑，下面分析复杂的流程是如何实现的：

Observable.create(object:ObservableOnSubscribe<String>{ //第一个Observable
    override fun subscribe(e: ObservableEmitter<String>) {
        e.onNext("A")
    }
}).map(object : Function<String,String>{ //第二个Observable
    override fun apply(t: String): String {
       return "a"
    }
}).flatMap { Observable.just("A -> a”)} 第三个Observable
    .subscribe(object : Observer<String>{…})

由上面的分析知道，事件订阅是由下向上一次传递的过程，首先还是从订阅subscribe开始分析，由上面知道订阅观察者在包装Observer的同时，会触发执行订阅的Observable的subscribeActual()，此处为第三个Observable对象，flatMap（）对应Observable具体实现类为ObservableFlatMap

AbstractObservableWithUpstream(ObservableSource<T> source) {
    this.source = source; 
}
@Override
public void subscribeActual(Observer<? super U> t) {
    source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}

从ObservableFlatMap的构造函数中看出内部保存着source实例，使用flatMap（）时会创建ObservableFlatMap实例并传入上面创建的被观察者实例，在subscribeActual（）中首先封装传入的Observer，再向上调用subscribe（）并传入MergeObserver观察者，此处的mapper就是flatMap中设置的转换方法

ObservableMap

ObservableFlatMap的subscribe（）方法向上调用，同样会触发上级Observable的subscribeActual（），向上一层执行的是map（）操作符，map（）的具体实现类是ObservableMap，ObservableMap中像ObservableFlatMap保存着上游的被观察者实例和下游的观察者实例，而且在subscribeActual（）中同样封装Observer并调用subscribe（）向上传递

public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
    super(source); // 保存传入的被观察者source
    this.function = function;  //保存map中设置的function
} 
@Override
public void subscribeActual(Observer<? super U> t) {
    source.subscribe(new MapObserver<T, U>(t, function)); //（1）步骤和上面一样，先封装下游传入的观察者继续向上调用，并传递MapObserver
}

经过map向上调用，程序再次进入ObservableCreate中，从上面分析我们知道ObservableCreate中会执行事件的发送，并触发Observer的响应，此处第一层响应的观察者即为MapObserver

MapObserver

MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
    super(actual);  //（1）保存下游传来的Observer
    this.mapper = mapper; //（1）在创建map时保存传入的转换方法
}
@Override
public void onNext(T t) {
    U v;
    try { // （2）执行设置Function方法，获取 经过方法处理后的数据
        v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
    } catch (Throwable ex) {
        fail(ex);
        return;
    }
    actual.onNext(v); //（3）调用下游Observer的onNext（）
}

前面的分析知道，MapObserver中保存这下游传递的观察者observer和map中设置的转换方法mapper，发送事件后执行到MapObserver的onNext（）中，onNext（）中首先执行mapper方法转换发送的事件，然后调用 actual.onNext(v)向下游传递事件

MergeObserver：在flatMap（）中创建的

MergeObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> mapper,boolean delayErrors, int maxConcurrency, int bufferSize) {
    this.actual = actual; 
    this.mapper = mapper; /
    this.observers = new AtomicReference<InnerObserver<?, ?>[]>(EMPTY);
}
@Override
public void onNext(T t) {
    ObservableSource<? extends U> p;
    try { //（2）调用设置的Function方法，此时返回的是另一个Observable对象
        p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
    } catch (Throwable e) {
        return;
    }
    subscribeInner(p); // 
}
@SuppressWarnings("unchecked")
void subscribeInner(ObservableSource<? extends U> p) {
    for (;;) {
            InnerObserver<T, U> inner = new InnerObserver<T, U>(this, uniqueId++); //创建观察者
            if (addInner(inner)) {
                p.subscribe(inner); //（3）flapMap返回的是一个新的Observable，所以此处为新的Observer订阅观察者，（单层的整个订阅流程在flatMap（）内部再走一次）
            }
            break;
    }
}
//InnerObserver
InnerObserver(MergeObserver<T, U> parent, long id) {
    this.id = id;
    this.parent = parent;  //保存MergeObserver观察者
}
@Override
public void onNext(U t) {
    parent.drain(); //（4）新的Observable订阅后响应观察者，调用MergeObserver的drain（）
}
void drainLoop() {
    final Observer<? super U> child = this.actual;
    child.onNext(o);
}

经上游传递方法执行到MergeObserver的onNext（），onNext（）中首先执行转换方法，因为faltMap中转换后返回新的Observable实例，所以在MergeObserver中会创建新的Observer对象即InnerObserver，然后对新的Observable对象订阅InnerObserver对象，发送的事件会执行到InnerObserver.onNext()中，然后调用MergeObserver的drain（），在drain中获取下游的Observer执行onNext（）事件继续向下传递，方法到此执行到了订阅的Observer中，响应onNext（）接收事件，最后的Observe接收事件！

4、基本操作符源码

4.1、just（）

just（）方法用于传递单个数据，在使用just（）操作符后会创建ObservableJust实例，基本功能和其他Observable一样，在subscribeActual（）中会执行run（），run（）方法中调用observer.onNext(value)发送事件

protected void subscribeActual(Observer<? super T> s) {
    ScalarDisposable<T> sd = new ScalarDisposable<T>(s, value); //（1）封装观察者和数据
    s.onSubscribe(sd); // 
    sd.run();  //（2）执行发送内部的run（）
}
@Override
public void run() {
    if (get() == START && compareAndSet(START, ON_NEXT)) {
        observer.onNext(value); //（3）接收发送事件
    }
}

4.2、ObservableFromArray

ObservableFromArray和ObservableJust功能一致，只是ObservableFromArray允许发送多个数据，在ObservableFromArray的run（）方法中会循环依次发送数据

@Override
public void subscribeActual(Observer<? super T> s) {
    FromArrayDisposable<T> d = new FromArrayDisposable<T>(s, array); （1）
    s.onSubscribe(d);
    d.run();
}
void run() {
    T[] a = array;
    int n = a.length;
    for (int i = 0; i < n && !isDisposed(); i++) { //（2）循环发送事件
        T value = a[i];
        actual.onNext(value);
    }
    if (!isDisposed()) {
        actual.onComplete();
    }
}

4.3、map（）

由前面的源码分析知道map（）操作符创建的是ObservableMap的被观察者，其中主要执行三个操作：

创建ObservableMap中的观察者MapObserver的实例，保存下游传入的Observer和map（）中设置的Function实例
调用父类Observable的subscribe（）发送事件
在接收事件后，在MapObserver的onNext（）中先调用Function.apply()执行数据转换，然后将结果下发到下游Observer中

4.4、 flatMap（）

具体的执行逻辑和map（）一致，只是在Observer中处理不同，因为flatMap返回的是一个新的Observable，所以要对新的被观察者进行订阅观察，在接受新的事件后调用下层的观察者发送事件

4.5、 zip（）

将多个Observable的事件组合一一对应发送,zip（）操作符最终会创建ObservableZip实例，查看ObservableZip方法

public void subscribeActual(Observer<? super R> s) {
    ObservableSource<? extends T>[] sources = this.sources;
    int count = 0;
    count = sources.length;
    //创建ZipCoordinator实例，传参：1、观察者Observer；2、传入的Function；3、Observable集合数量；4、是否推迟Error
    ZipCoordinator<T, R> zc = new ZipCoordinator<T, R>(s, zipper, count, delayError);
    zc.subscribe(sources, bufferSize); //调用subscribe（）
}

ZipCoordinator.subscribe（）：为集合中每个Observable订阅观察者

public void subscribe(ObservableSource<? extends T>[] sources, int bufferSize) {
    ZipObserver<T, R>[] s = observers; //创建观察者数组，长度为count
    int len = s.length;
    for (int i = 0; i < len; i++) {
        s[i] = new ZipObserver<T, R>(this, bufferSize); //遍历创建ZipObserver
    }
    this.lazySet(0);
    actual.onSubscribe(this);  //响应观察者的onSubscribe（）
    for (int i = 0; i < len; i++) {
        sources[i].subscribe(s[i]); //遍历Observable集合依次订阅观察者
    }
}

ZipObserver：从上面我们知道，数组中的Observable都会发送事件到对应的ZipObserver中，在onNext（）中将发送的数据加入队列然后调用parent.drain()方法

ZipObserver(ZipCoordinator<T, R> parent, int bufferSize) {
    this.parent = parent; 
    this.queue = new SpscLinkedArrayQueue<T>(bufferSize); //实例化一个队列，默认大小128
}
@Override
public void onNext(T t) { //响应事件的onNext（）
    queue.offer(t); 
    parent.drain(); 
}

在drain（）方法中使用死循环不断查找发送的事件，直到同一组Observable的都接收到发送事件，然后调用设置的方法统一进行转换最后返送事件

public void drain() {
    final ZipObserver<T, R>[] zs = observers;
    final Observer<? super R> a = actual; // 下游传递的Observer
    for (; ; ) { //两层死循环
        for (;; ) { 
            int i = 0;
            int emptyCount = 0;
            for (ZipObserver<T, R> z : zs) {
                if (os[i] = null) { 
                    T v = z.queue.poll();  //从Observer的队列中获取事件
                    boolean empty = v == null;
                    if (!empty) { //如果获取的事件不为空，则复制os[i],否则emptyCount++
                        os[i] = v;
                    } else {
                        emptyCount++;
                    }
                } else {  ………. }
                i++; //下标++
            }
            if (emptyCount != 0) { //如果取出数据不为空，则跳出循环，确保每个Observable都取到了值
                break;
            }
            // 执行zipper中传入的压缩方法
            v = ObjectHelper.requireNonNull(zipper.apply(os.clone()), "The zipper returned a null value");
            a.onNext(v); //执行下游onNext（）
        }
    }
}

简述工作过程：（第一、第二个观察者用 first、second代替）

当first发送数据1时会存储到ZipObserver的队列中，此时os[0] = null,从first_observer的队列中取出1，赋值os[0]=1;
然后for循环继续执行，此时os[1]= null,会从second_observer缓存区中获取数据，如果为空则跳出内部死循环
由于外部循环存在方法会继续循环，内部在从os[0]开始，此时os[0] = 1,second此时也会发送数据4到队列中
继续执行此时os[1]=null,从second的队列中回去数据赋值os[1] = 4；
此时emptyCount = 0方法向下执行，调用设置的Function.apply()处理数据(关于Function（）这里采用了嵌套方法)
调用下游Obserber.onNext()传递事件

4.5、onErrorReturn（）

@Override
public void subscribeActual(Observer<? super T> t) {
    source.subscribe(new OnErrorReturnObserver<T>(t, valueSupplier)); //创建OnErrorReturnObserver
}
//OnErrorReturnObserver
@Override
public void onError(Throwable t) { //在onError（）方法中触发
    T v;
    v = valueSupplier.apply(t); //（1）在拦截onError时调用设置的方法，生成要发送的数据
    actual.onNext(v); //（2）发送新生成的数据
    actual.onComplete(); 
}

最终创建ObservableOnErrorReturn和OnErrorReturnObserver，在拦截到error后发送特定的值

4.6、retryWhen：重试操作符

创建ObservableRetryWhen实例，在使用retryWhen时会传入一个返回新的Observable的功能方法，在ObservableRetryWhen内部首先调用方法获取创建的newObservable，并对newObservable订阅观内部察查者Inner.Observer，在外部订阅观察者时当发生异常回调onError（）时，调用newObservable发送事件，

如果发送next（）触发内部观察者onNext（），在onNext（）中重新调用外部观察者订阅，所有程序会重新try；
如果发送onError（）会直接回到外部Observer的onError（）结束程序；

4.7、compose（）:构成操作符

compose（）可以将一系列的相同的操作封装在一起使用，将功能封装在ObservableTransformer的实例中，在接口方法中可以对传入的Observable执行操作然后重新返回，系统会将重新返回的Observable封装在新的ObservableFromUnsafeSource中继续执行

创建ObservableTransformer实例对Observable执行统一的操作

public static <T> ObservableTransformer<T, T> rxSchedulerHelper() {
    return new ObservableTransformer<T, T>() {
        @Override
        public ObservableSource<T> apply(Observable<T> upstream) { //对传入的Observable进行指定线程操作
            return upstream.subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
        }
    };
}

使用compose（）

Observable.just(1)
        .compose(RxHelper.<Integer>rxSchedulerHelper())
        .subscribe()
//效果等同于
Observable.just(1)
      .subscribeOn(Schedulers.io())
      .observeOn(AndroidSchedulers.mainThread())
      .subscribe();

源码分析

public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) {
    return wrap(((ObservableTransformer<T, R>) composer.apply(this)); 
}
public static <T> Observable<T> wrap(ObservableSource<T> source) {
    return RxJavaPlugins.onAssembly(new ObservableFromUnsafeSource<T>(source));
}
//ObservableFromUnsafeSource只是作为了一层中转站
public final class ObservableFromUnsafeSource<T> extends Observable<T> {
    final ObservableSource<T> source;
    public ObservableFromUnsafeSource(ObservableSource<T> source) {
        this.source = source;
    }
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        source.subscribe(observer);
    }
}

执行流程如下：

compose（）首先执行apply（）传入this，this为当前的Observable，此处表示为Observable添加几个统一的操作符
使用ObservableFromUnsafeSource封装包裹source
在ObservableFromUnsafeSource.subscribeActual（）中触发source.subscribe(observer)完成订阅；

5、RxJava取消订阅

RxJava取消订阅（ObservableOnCreate）

@Override
protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer); //（1）创建
    observer.onSubscribe(parent); //回调返回parent
}

由上面的分析知道，在ObservableOnCreate（）的subscribeActual（）会创建CreateEmitter对象封装Observer，并回调onSubscribe（）返回parent

调用CreateEmitter.dispose()取消订阅

@Override
public void dispose() {
    DisposableHelper.dispose(this); //设置解除订阅标识位
}
@Override
public boolean isDisposed() {
    return DisposableHelper.isDisposed(get()); //获取是否解除订阅
}

在每次发送事件之前都会判断是否解除订阅，如果设置了解除操作符就会停止事件发送

@Override
public void onNext(T t) {
    if (!isDisposed()) { 
        observer.onNext(t);
    }
}

到此RxJava的基本原理和常用的操作符就分析完了，RxJava的操作符之多功能之强大真的不是几句话能说完的，但了解其内部原理有利于更好的封装和使用它，除了本篇之外还有关于Schedule的部分也很重要会放在下一篇文章整理。

Alex@W

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android框架源码分析——RxJava源码分析

1、基本订阅流程使用实例Observable.create(ObservableOnSubscribe<String> { e -> e.onNext("A") }) .subscribe(object : Observer<String>{ override fun onComplete() { } override fun ...
复制链接

扫一扫