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>里面的数据类型决定了后面的所有的数据类型。