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

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个流程:
  1. 创建被观察者实例发送事件
  2. 创建观察者实例监听处理事件
  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 observer)中主要作了两件事:

  1. 封装并保存下游设置的观察者Observer实例,在接收事件及时响应事件
  2. 执行被观察者的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件事:

  1. 创建CreateEmitter包装观察者
  2. 执行调用观察者的onSubscribe方法,传入CreateEmitter实例,用于在请求时可以使用此对象控制或终止事件发送
  3. 执行传入的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的被观察者,其中主要执行三个操作:

  1. 创建ObservableMap中的观察者MapObserver的实例,保存下游传入的Observer和map()中设置的Function实例
  2. 调用父类Observable的subscribe()发送事件
  3. 在接收事件后,在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代替)

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

  1. 如果发送next()触发内部观察者onNext(),在onNext()中重新调用外部观察者订阅,所有程序会重新try;
  2. 如果发送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);
    }
}

执行流程如下:

  1. compose()首先执行apply()传入this,this为当前的Observable,此处表示为Observable添加几个统一的操作符
  2. 使用ObservableFromUnsafeSource封装包裹source
  3. 在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

  1. 调用CreateEmitter.dispose()取消订阅
@Override
public void dispose() {
    DisposableHelper.dispose(this); //设置解除订阅标识位
}
@Override
public boolean isDisposed() {
    return DisposableHelper.isDisposed(get()); //获取是否解除订阅
}
  1. 在每次发送事件之前都会判断是否解除订阅,如果设置了解除操作符就会停止事件发送
@Override
public void onNext(T t) {
    if (!isDisposed()) { 
        observer.onNext(t);
    }
}

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

你可能感兴趣的:(RxJava,Observable)