RxJava事件流传递与线程切换

因安卓中UI操作只能在安卓主线程进行，而网络数据传输又不能在主线程进行，所以可以使用RxJava来实现。

RxAndroid等原理类似。

代码：

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                String s = "oh yeah...";
                //执行耗时任务
                emitter.onNext(s);
            }
        }).map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) throws Exception {
                return Integer.parseInt(s);
            }
        }).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Observer<Integer>(){
　　　　　　　　@Override
　　　　　　　　public void onNext(Integer i) {
　　　　　　　　　　//订阅者操作，UI操作
　　　　　　　　}
　　　　　　});

摘一张大概流程图：

 

图中描绘了RxJava中重要的三条流：构建流、订阅流、响应流

构建流：从source到observer，每个节点都会生成对应的observable（ObservableOnSubsribe等，根据不同功能重写subscribeActual方法）

订阅流：当调用最后一个subscribe时，从observer往source依次订阅，每个节点的订阅其实是对上游订阅者（从右往左）的不同功能的封装，比如map对数据进行处理映射、subscribeOn对下游执行线程（往source方向）的切换（通过提交SubscribeTask）、observeOn包装上游observer向下订阅

响应流：通过create创建生成ObservableCreate，看看简要源码：

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
　　　　　//先执行我们手动创建的事件源的onSubscribe，然后把emitter传递给事件源的subscribe　　　　　
        observer.onSubscribe(parent);
　　　　　//事件源的subscribe中处理耗时任务后调用parent即emitter的onNext往后传递
        source.subscribe(parent);
    }
}

再看看CreateEmitter：

static final class CreateEmitter<T> extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {
      
        final Observer<? super T> observer;
      
        CreateEmitter(Observer<? super T> observer) {
            this.observer = observer;
        }
        @Override
        public void onNext(T t) {
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }
      //省略
    }

可以看出响应流从我们写的事件源的subscribe处发生转向，开始向下游响应数据，observeOn操作符生成的observableOnSubscribe由重写subscribe产生一个包装observer，将下游observer的onNext包装到异步任务执行

先写到这，以后用到再补充