RxJava2复习笔记一、操作符Create

create操作符应该是最常见的操作符，主要是观察者Observer（我们也称为下游事件）用来创建一个被观察者对象Obserable（我们也称为上游事件）。被观察者对象Obserable用于发送事件，观察者Observer用于接收事件。

好了，废话不多说，直接上代码：

    //创建一个上游 Observable：
    Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> e) throws Exception {
            e.onNext(1);
            logTag("上游：" + 1);

            e.onNext(2);
            logTag("上游：" + 2);

            e.onNext(3);
            logTag("上游：" + 3);

            e.onNext(4);
            logTag("上游：" + 4);
        }
    });
    //创建一个下游 Observer
    Observer<Integer> observer = new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            mDisposable = d;
            logTag("下游onSubscribe是否被拦截: " + d.isDisposed());
        }

        @Override
        public void onNext(Integer value) {
            logTag("下游onNext : value==" + value);
        }

        @Override
        public void onError(Throwable e) {
            logTag("下游onError : value : " + e.getMessage());
        }

        @Override
        public void onComplete() {
            logTag("下游执行onComplete");
        }
    };
    //建立连接
    observable.subscribe(observer);

把上面这段代码连起来写就成了RxJava2引以为傲的链式调用：

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        e.onNext(1);
        logTag("上游：" + 1);
        e.onNext(2);
        logTag("上游：" + 2);
        //e.onComplete();
        //e.onError(new Throwable());
        e.onNext(3);
        logTag("上游：" + 3);
        e.onNext(4);
        logTag("上游：" + 4);
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
        mDisposable = d;
        logTag("下游onSubscribe是否被拦截: " + d.isDisposed());
    }

    @Override
    public void onNext(Integer value) {
        logTag("下游onNext : value==" + value);
        //i++;
        //if (i == 2) {
            // 在RxJava 2.x 中，新增的Disposable可以做到切断的操作，让Observer观察者不再接收上游事件
            //mDisposable.dispose();
            //logTag("下游onNext : isDisposable : " + mDisposable.isDisposed());
        //}
    }

    @Override
    public void onError(Throwable e) {
        logTag("下游onError : value : " + e.getMessage());
    }

    @Override
    public void onComplete() {
        logTag("下游执行onComplete");
    }
});

private void logTag(String string) {
    Log.i("TAG", "logTag: string===" + string);
}

上面代码运行结果如下：

logTag: string===下游onSubscribe是否被拦截: false
logTag: string===下游onNext : value==1
logTag: string===上游：1
logTag: string===下游onNext : value==2
logTag: string===上游：2
logTag: string===下游onNext : value==3
logTag: string===上游：3
logTag: string===下游onNext : value==4
logTag: string===上游：4

可以看出，上游执行subscribe()，下游再没有出现异常的情况下，只执行了onNext()方法。
另外，这里或许会觉得很奇怪，为什么是先执行的下游的onSubscribe()方法，上游不都还没发送数据么？下游先动起来了？
其实，原因是这样的的：RxJava2是只有当上游和下游建立连接之后, 上游才会开始发送事件. 也就是调用了subscribe() 方法之后确定连接已经建立了，才开始发送事件.

现在我们把上游被注销掉的代码：

//e.onComplete();

注回来，然后再执行，结果如下：

logTag: string===下游onSubscribe是否被拦截: false
logTag: string===下游onNext : value==1
logTag: string===上游：1
logTag: string===下游onNext : value==2
logTag: string===上游：2
logTag: string===下游执行onComplete
logTag: string===上游：3
logTag: string===上游：4

可以发现，当我们上游发送两个事件后调用e.onComplete()，下游就不再执行onNext()方法，而是调用onComplete()方法，表示执行结束；但是上游依然实在持续的发送事件，直到事件发送完成。

现在我们再次把e.onComplete()代码注销掉，然后把：

//e.onError(new Throwable());

注回来，然后再执行，结果如下：

logTag: string===下游onSubscribe是否被拦截: false
logTag: string===下游onNext : value==1
logTag: string===上游：1
logTag: string===下游onNext : value==2
logTag: string===上游：2
logTag: string===下游onError : value : null
logTag: string===上游：3
logTag: string===上游：4

可以发现，当我们上游发送两个事件后调用e.onError(new Throwable())，下游就不再执行onNext()方法，而是调用onError()方法，并抛出异常，程序执行结束；但是上游依然实在持续的发送事件，直到事件发送完成。

现在我们再次把e.onError(new Throwable())代码注销掉。然后把下游onNext()方法里面的if条件语句再注回来：

@Override
public void onNext(Integer value) {
    logTag("下游onNext : value==" + value);
    i++;
    if (i == 2) {
        // 在RxJava 2.x 中，新增的Disposable可以做到切断的操作，让Observer观察者不再接收上游事件
        mDisposable.dispose();
        logTag("下游onNext : isDisposable : " + mDisposable.isDisposed());
    }
}

if条件判断语句的作用是：

当满足我们制定的条件的时候，就调用mDisposable.dispose()方法来截断销毁下游对上游事件的接收

运行结果如下：

logTag: string===下游onSubscribe是否被拦截: false
logTag: string===下游onNext : value==1
logTag: string===上游：1
logTag: string===下游onNext : value==2
logTag: string===下游onNext : isDisposable : true
logTag: string===上游：2
logTag: string===上游：3
logTag: string===上游：4

可以发现，在下游的onNext()方法里面，当满足我们的条件：i == 2时，我们就调用mDisposable.dispose()来切断操作，让Observer观察者不再接收上游事件。但不影响上游继续发送事件。

经过上面的代码学习，我们可以发现以下规律：

1、只有当上游和下游建立连接之后, 上游才会开始发送事件. 也就是调用了subscribe() 方法之后确定连接已经建立了，才开始发送事件；

2、上游的事件发送与下游的事件接收是一一对应的，上游发送一个下游接收一个。没有也不好逾越；

3、当上游调用e.complete()方法后，上游会继续发送事件，但下游接收到complete事件之后会停止接收事件并执行onComplete()方法；

4、当上游调用e.onError(new Throwable())方法后，上游会继续发送事件，但下游收到onError事件之后会停止接收事件并执行onError()方法同时抛出异常；

5、上游根据需要发送e.complete()方法或e.onError(new Throwable())方法，也可以不发送；

6、特别注意到，上游的e.complete()方法和e.onError(new Throwable())方法都可以终止上游事件的继续发送，但他们是绝对互斥的，具有绝对排他性，也就是subscribe()方法中要么出现e.complete()方法，要么出现e.onError(new Throwable())方法。不能二者同时出现；

7、下游onSubscribe()方法中Disposable对象的dispose()方法可以理解为上下游直接的一个开关，它也可以截断下游对上游事件的接收，但不影响上游继续发送事件。另外，它可以与e.complete()方法和e.onError(new Throwable())方法之一同时出现；

8、上下游建立联系的Subscribe()方法有多个重载的方法，这个我们留待后面分析源码的时候探讨。

9、对象的数据类型要保持一致：

new ObservableOnSubscribe<T>、subscribe(ObservableEmitter<T> e)、
new Observer<T>、onNext(T value)这几个对象里面的数据类型要保持一致。
准确的说，new ObservableOnSubscribe<T>里面的数据类型决定了后面的所有的数据类型。