Rxjava源码解析之监听回调

原创 2018年04月16日 11:34:27

Rxjava源码解析之监听回调


前言

该篇分析Rxjava接口回调流程的逻辑, 为了方便理解,用最简单的实例分析。

  1. 实例代码;
  2. 接口回调流程分析;

实例代码

导入第三方Rxjava RxAndroid(用到了UI线程)

compile 'io.reactivex.rxjava2:rxjava:2.0.7'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

简单的实例如下:

Observable.just("test")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(String o) {
                        // println o: test
                    }
                    @Override
                    public void onError(Throwable e) {

                    }
                    @Override
                    public void onComplete() {

                    }
                });

接口回调分析

根据实例代码,我们一行一行分析。

ObserverableJust

1.由实例代码1行:通过传入一个实例调用Observable的静态just(T item)方法生成ObservableJust(item)实例(该实例也是继承Observable);

public static <T> Observable<T> just(T item) {
    ObjectHelper.requireNonNull(item, "The item is null");
    return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
}

ObservableSubscribeOn

2.由实例代码2行:由上,observableJust实例的subscribeOn(Scheduler)如下(实际上该子类没有重写该方法,该方法还是父类Observale实现的),传入ObservableSource和scheduler生成ObservableSubscribeOn对象并返回;该方法的ObservableSource是上面的ObservableJust(最终继承ObservableSource)对象, scheduler是创建的IoScheduler对象;

public final Observable<T> subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
    }

public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
    super(source);
    this.scheduler = scheduler;
}

ObservableObserveOn

3.由实例代码3行:由上,observableSubscribeOn实例的observeOn(Scheduler)如下(实际上该子类没有重写该方法,该方法还是父类Observale实现的),该方法调用了重载方法observeOn(Scheduler scheduler, boolean delayError, int bufferSize) ;由8行,传入ObservableSource和scheduler生成ObservableObserveOn对象(其他2个参数先不管)并返回;该方法的ObservableSource是上面的ObservableSubscribeOn(最终继承ObservableSource)对象, scheduler是创建的HandlerScheduler对象;

public final Observable<T> observeOn(Scheduler scheduler) {
    return observeOn(scheduler, false, bufferSize());
}

 public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }

4.由实例代码4行:由4行,通过传入this(当前是上一步产生的ObservableObserveOn), observer(我们实例代码创建的)调用RxJavaPlugins的静态onSubscribe(observable, observer)由21-29行,该方法最终返回实例代码传入的observe对象;由6行,调用subscribeActual(observer);该方法ObservableObserveOn实例实现了如33-40行,由39行,通过传入的observer(实例创建的Observer对象)创建一个ObservableObserveOn的内部ObserveOnObserver实例,再通过source.subscribe(observer)把刚刚创建的ObserveOnObserver实例传入;(source是创建ObservableObserveOn传入的observableSubscribeOn对象)

    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);
            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because no way to know if a Disposable has been set or not
            // can't call onSubscribe because the call might have set a Subscription already
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }
    }

  public static <T> Observer<? super T> onSubscribe(@NonNull Observable<T> source, 
  @NonNull Observer<? super T> observer) {
    BiFunction<? super Observable, ? super Observer, ? extends Observer> f = 
    onObservableSubscribe;
    if (f != null) {
        return apply(f, source, observer);
    }
    return observer;
}

**// ObservableObserveOn实例实现了父类Observable抽象subscribeActual(Observer<? super T> observer) 方法:**
 @Override
    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));
        }
    }

5.由上,observableSubscribeOn.subscribe(Observer

 @Override
    public void subscribeActual(final Observer<? super T> s) {
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
        s.onSubscribe(parent);
        parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
            @Override
            public void run() {
                source.subscribe(parent);
            }
        }));
    }

6.我们看最后一步,由上知道,source.subscribe(observer)方法,最终会通过传入observer调用子类实现的subscribeActual(observer);ObservableJust类的subscribeActual方法如下,首先通过传入observer和value(实例中传入的”test”对象)创建ScalarDisposable, 然后执行run()方法;由9行,调用observer.onNext(value)方法;也是这个最终回调;

protected void subscribeActual(Observer<? super T> s) {
        ScalarDisposable<T> sd = new ScalarDisposable<T>(s, value);
        s.onSubscribe(sd);
        sd.run();
    }

     public void run() {
            if (get() == START && compareAndSet(START, ON_NEXT)) {
                observer.onNext(value);  // 结果回调
                if (get() == ON_NEXT) {
                    lazySet(ON_COMPLETE);
                    observer.onComplete(); // 回调
                }
            }
        }

最后用一个简陋的流程图表示一下

这里写图片描述

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/yang_yang1994/article/details/79958505

Rxjava 封装异步回调代码, 新时代来临

Yammer 应用开发团队介绍了如何使用 RxJava v1.1.7 版本的 Observable.fromAsync() 函数来把异步回调操作数据发射到 RxJava 数据流中。 现有的 API ...
  • wangyun522
  • wangyun522
  • 2016-10-23 23:01:00
  • 756

RxJava源代码剖析

转载请注明出处:何时夕的博客 很多人想学习RxJava,但是总不知道如何下手,所以我之前总结了一篇RxJava的用法。这次我举了一个例子,结合源码,深入剖析了一下,RxJava运行的机制。有爱者自...
  • a1018998632
  • a1018998632
  • 2016-05-15 23:46:05
  • 3982

Rxjava 实现接口回调的功能

上一遍文章中写了接口回调的模板,这篇文章用rxjava来实现接口回调的功能 (接口回调:http://blog.csdn.net/michael1112/article/details/535738...
  • michael1112
  • michael1112
  • 2016-12-13 15:39:03
  • 1365

RxJava 源码解读

转载请注明本文出自maplejaw的博客(http://blog.csdn.net/maplejaw_)开源库地址:https://github.com/ReactiveX/RxJava 解读版本:...
  • maplejaw_
  • maplejaw_
  • 2016-08-31 07:50:41
  • 3001

RxJava基本流程和lift源码分析

首先感谢 扔物线 哥哥给的配图,实在太赞了。基本结构我们先来看一段最基本的代码,分析这段代码在RxJava中是如何实现的。Observable.OnSubscribe onSubscriber1 = ...
  • lzyzsd
  • lzyzsd
  • 2015-11-30 11:54:13
  • 25170

RxJava2 源码解析(一)

概述最近事情太多了,现在公司内部的变动,自己岗位的变化,以及最近决定找工作。所以博客耽误了,准备面试中,打算看一看RxJava2的源码,遂有了这篇文章。不会对RxJava2的源码逐字逐句的阅读,只寻找...
  • zxt0601
  • zxt0601
  • 2017-03-12 19:42:21
  • 6550

Android RxJava:一步步带你源码分析 RxJava

前言 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点,深受各大 Android开发者的欢迎。 如果还不了解RxJava,请看文章:Android:这是一篇 清晰...
  • carson_ho
  • carson_ho
  • 2018-01-26 09:07:55
  • 2571

retrofit&rxjava&gson请求成功后回调的统一处理

假设网络请求接口后返还的json数据存在如下形式: error==0 { "error": 0, "msg": "suc", "data":{ "basename"...
  • LegendSpinach
  • LegendSpinach
  • 2017-05-18 16:23:20
  • 485

我的RxJava源码解读笔记

我的RxJava源码解读笔记      RxJava是一个用于处理异步任务的库,本篇文章我将把我在学习RxJava源码时的分析思路记载下来,一方面用来加强记忆,另一方面可以供大家参考。 首先梳...
  • changsimeng
  • changsimeng
  • 2016-11-14 12:38:37
  • 4004

RXjava2_3:数据的转换和回调嵌套的解决

RXjava2_3:数据的转换和回调嵌套的解决 参考: http://blog.csdn.net/jdsjlzx/article/details/51493552 https://jueji...
  • u011486491
  • u011486491
  • 2017-07-23 17:01:53
  • 811
收藏助手
不良信息举报
您举报文章:Rxjava源码解析之监听回调
举报原因:
原因补充:

(最多只允许输入30个字)