Rxjava2源码学习(二)

上一篇中看了Rxjava的通过链式调用来实现数据的传输,这一篇接着看加上线程切换之后,整个流程是怎样的。

还是以下面这个流程为例:

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("数据");
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

通过上一篇我们可以知道,Observable.create()之后返回的是一个ObservableCreate对象,而ObservableCreate对象是继承自Observable对象。所以create之后,实际上是Observable.subscribeOn(Schedulers.io()),同样的它返回一个继承了Observable的对象。关于链式调用这一块这里就不再做详细的说明了。

这里的重点是包括线程切换在内的整个的流程是怎样的,以上面的代码块为例,今天我们要搞懂,数据在传输过程中到底经历了什么。
这里我们先记录一下每个操作返回的对象

操作返回的Observable对象
Observable.create()ObservableCreate对象
Observable.subscribeOn(Schedulers.io())ObservableSubscribeOn对象
Observable.observeOn(AndroidSchedulers.mainThread())ObservableObserveOn对象
Observable. subscribe(Observer对象)

ObservableCreate、ObservableSubscribeOn、ObservableObserveOn都是继承自Observable,并且实现了subscribeActual(Observer observer) 方法(调用Observable.subscribe(Observer) 最终都会调用该方法)
通过断点调试,我们可以发现上面的这几个对象最终都调用了各自的subscribeActual,而且调用的顺序是从下到上的(它们的创建顺序是从上到下的)。这里我就直接上图了,贴上我自己的理解:
这里写图片描述

对照上图我们具体来看一下,当走到Observable. subscribe(Observer对象)这一步的时候,实际上是D:ObservableObserveOn.subscribe(Observer对象),而且会把上一层的Observable(这里是C:ObservableSubscribeOn对象)作为source(构造函数里的参数)传入D中,之前说过,调用subscribe方法,都会调用各自的subscribeActual方法,
在ObservableObserveOn的subscribeActual方法中:

protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
        Scheduler.Worker w = scheduler.createWorker();

        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}

如果在同一个线程,就可以直接订阅observer,如果不在同一个线程,就需要用之前传入的指定线程,并将订阅的操作指定在该线程中。这里的source就是作为构造函数参数传入D的C。这里相当于又调用了C.subscribe,经历的流程和上面的过程差不多。
这里的核心思想都是上一个Observable作为下一个的Observable的一部分,当下层的Observable开始调用subscribe方法之后,其实是会调用上一层的Observable的subscribe方法,经过这样一层一层的递归,最终会到最初create这里。

同理,一开始订阅的时候,传入的是一个Observer对象的引用,经过一层一层的将这个对象传入或者封装之后再传入。这样就实现了数据上下游的连通。

最后看一下线程切换
subscribeOn(Schedulers.io())
最终进入的是ObservableSubscribeOn对象中

public void subscribeActual(final Observer<? super T> s) {
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);

    s.onSubscribe(parent);

    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}

这边scheduler是之前传入的Schedulers.io(),新建了一个订阅的线程:

final class SubscribeTask implements Runnable {
   private final SubscribeOnObserver<T> parent;

    SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
    }

    @Override
    public void run() {
        source.subscribe(parent);
    }
}

这里另起了一个线程执行订阅操作

再来看看observeOn(AndroidSchedulers.mainThread())

protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
        Scheduler.Worker w = scheduler.createWorker();

        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}

这里如果是同一个线程,就不用再切换了,如果不是同一个线程,需要创建一个新的。

到这里Rxjava基本流程就看的差不多了,其他的就算换一些操作符,本质上的流程还是一样的(Flowable可能有点区别)

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RxJava中的flatMap操作符是一个非常常用的操作符,它可以将一个Observable发射的事件序列转换成多个Observables,然后将这些Observables发射的事件序列合并后再发射出去。 下面是flatMap操作符的源码解析: ```java public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) { ObjectHelper.requireNonNull(mapper, "mapper is null"); return RxJavaPlugins.onAssembly(new ObservableFlatMap<>(this, mapper, false, Integer.MAX_VALUE, bufferSize())); } ``` 可以看到,flatMap操作符的实现是通过创建一个ObservableFlatMap对象来完成的。其中,mapper参数表示将原始Observable发射的事件转换成的新Observable,它是一个Function类型的参数,即接受一个T类型的参数并返回一个ObservableSource类型的结果。 ObservableFlatMap的构造函数如下所示: ```java ObservableFlatMap(ObservableSource<T> source, Function<? super T, ? extends ObservableSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) { this.source = source; this.mapper = mapper; this.delayErrors = delayErrors; this.maxConcurrency = maxConcurrency; this.bufferSize = bufferSize; } ``` ObservableFlatMap的核心实现是在subscribeActual方法中完成的: ```java @Override public void subscribeActual(Observer<? super R> observer) { if (ObservableScalarXMap.tryScalarXMapSubscribe(source, observer, mapper)) { return; } source.subscribe(new FlatMapObserver<>(observer, mapper, delayErrors, maxConcurrency, bufferSize)); } ``` 在subscribeActual方法中,首先判断源Observable是否可以直接转换为ObservableScalarXMap,如果可以的话直接进行转换,否则创建一个FlatMapObserver对象并进行订阅。 FlatMapObserver是flatMap的核心实现类,它实现了Observer接口,并且在接收到源Observable发射的事件时,会先将事件转换成新的Observable,然后将新Observable的发射事件序列合并到一个新的Observable中,最后再将新的Observable发射出去。 ```java static final class FlatMapObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable { // ... @Override public void onNext(T t) { ObservableSource<? extends R> o; try { o = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource"); } catch (Throwable e) { Exceptions.throwIfFatal(e); upstream.dispose(); onError(e); return; } if (cancelled) { return; } if (maxConcurrency != Integer.MAX_VALUE) { synchronized (this) { if (wip == maxConcurrency) { queue.offer(t); return; } wip++; } } o.subscribe(new InnerObserver(inner, delayErrors, this)); } // ... } ``` 在FlatMapObserver的onNext方法中,首先调用mapper将源Observable发射的事件转换成新的Observable,并进行非空检查。然后判断当前的并发度是否达到了最大值,如果达到了最大值,就将源Observable发射的事件放到队列中。否则,就将并发度加1,并订阅新Observable。 InnerObserver是FlatMapObserver的内部类,它实现了Observer接口,并在接收到来自新Observable的发射事件序列时,将它们合并到一个新的Observable中,并将新的Observable发射出去。 ```java static final class InnerObserver<R> implements Observer<R> { // ... @Override public void onNext(R t) { if (done) { return; } inner.onNext(t); } // ... } ``` 当所有的新Observable都完成后,FlatMapObserver会调用onComplete方法通知观察者。如果发生了异常,FlatMapObserver会调用onError方法通知观察者。同时,FlatMapObserver还实现了Disposable接口,可以通过dispose方法取消订阅。 综上所述,flatMap操作符的实现是比较复杂的,它通过创建ObservableFlatMap对象,并在subscribeActual方法中创建FlatMapObserver对象来完成转换操作。在FlatMapObserver中,它还需要实现对新Observable的订阅以及将新Observable发射的事件合并到一个新的Observable中。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值