学习笔记-RxJava 复习每一个 RxJava 事件流总是以 Create 创建开始，以 subscribe 订阅结

RxJava

RxJava 操作符

RxJava 原理流程

以如下代码为例：

            Observable.create(object :ObservableOnSubscribe<String> {
                override fun subscribe(emitter: ObservableEmitter<String>) {
                 Log.e(TAG, "onComplete:  ${Thread.currentThread()}" )
                    emitter.onNext("create =======")
                }
            })
                .flatMap(object : Function<String, Observable<String>>{
                    override fun apply(t: String): Observable<String> {
                        return Observable.just("flatMap ===== ")
                    }
                } )
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(object : Observer<String> {
                    override fun onComplete() {
                        Log.e(TAG, "onComplete:  " )
                    }

                    override fun onSubscribe(d: Disposable) {
                        Log.e(TAG, "onSubscribe:  " )
                    }

                    override fun onNext(t: String) {
                        Log.e(TAG, "onNext:  ${t.toString()}  " )
                    }

                    override fun onError(e: Throwable) {
                        Log.e(TAG, "onError:  ${e.message}" )
                    }



                })

流程简述
每一个 RxJava 事件流总是以 Create 创建开始，以 subscribe 订阅结束，Create 和 subscribe 直接由若干个操作符或者线程调度操作符(subscribeOn 、 observeOn) 组成。

具体流程：

create创建方法

Observable.create() 需要传入 ObservableOnSubscribe 接口对象并返回一个 ObservableCreate 对象， RxJavaPlugins.onAssembly 默认为空实现。

RxJava操作符

RxJava操作符 是在 create() 创建之后， subscribe() 订阅之前调用，以 flatMap() 为例:
flatMap() 需要传入一个 Function 对象，返回一个 ObservableFlatMap 对象，并将自身Source传入进去，相当于给当前方法的调用对象(即 Create() 方法返回的 ObservableCreate)封装一层再次返回。

subscribeOn 和 subscribe

subscribeOn 和 subscribe 操作符是用来做线程调度的，后面在看，这里只关注返回
这两个方法返回的都是 ObservableObserveOn 对象，和 flatMap() 一样，都是对调用对象做了一层封装并返回。

subscribe 订阅方法是 RxJava 事件流的结尾，需要传入一个观察者(Observer 对象)，源码可以看到，subscribe()最终调用了当前对象的 subscribeActual()方法( 也就是上个操作符，这里是observeOn操作符返回的 Observable 对象)，并且将自定义观察者(observer)传入了进去

回到上个操作符返回的 Observable 对象 subscribeActual()，可以看到调用了 source.subscribe()方法并将观察者 observer 包装了一层继续传递

而 source 其实就是再上个操作符返回给我们的 Observable对象

查看源码可以看到，所以的操作符都是同样的流程，也就是说，每个操作符都会多 observer 包装一层，同时将它传给上一层的操作符，直到最开始的 create() 方法返回的ObservableCreate，可以看到，这时候调用了我们传入的 observer 的 onSubscribe()方法，此时订阅成功，事件开始。然后调用了我们自定义 source 的 subscribe() 也就是下图部分