一 引言
RxJava2.0中出现了两种观察者模式：
● Observable(被观察者)/Observer（观察者）
● Flowable(被观察者)/Subscriber(观察者)
其中Observable和Flowable可以相互切换，但是观察者却不能共用。
除了这两种，还有4种：
● Single/SingleObserver
● Completable/CompletableObserver
● Maybe/MaybeObserve
● Subject/Observer
1.Observable的创建
Observable的创建是通过操作函数,例如：create(),defer(),just()，from(),rang(),timer(),interval()等方法来创建。
Observable.create()
创建Observable最基本的创建方式。 传入了一个 ObservableOnSubscribe对象作为参数，它的作用相当于一个计划表，当 Observable被订阅的时候，ObservableOnSubscribe的subscribe()方法会自动被调用，数据发射源ObservableEmitter对事件依照设定依次发射
使用实例：
//数据发射源对象
ObservableEmitter observableEmitter ;
private void sendData(){
if(observableEmitter != null){
for(int i = 0;i < 10; i++){
//数据发射源对象发射数据
observableEmitter .onNext("Observable 数据data " +i);
}
observableEmitter .onComplete();
}
}
private ObservableOnSubscribe<String> observableOnSubscribe = new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
printThread("subscribe");
observableEmitter = e;
observableEmitter .onNext("Observable 数据data");
sendData();
}
};
Observable observable = Observable.create(observableOnSubscribe )
Observable.just()
● Just将单个数据转换为发射那个数据的Observable，创建一个发射指定值的Observable
● Just类似于From，但是From会将数组或Iterable的素具取出然后逐个发射，而Just只是简单的原样发射，将数组或Iterable当做单个数据
● 注意：如果你传递null给Just，它会返回一个发射null值的Observable。 如果需要空Observable你应该使用Empty操作符
● RxJava将这个操作符实现为just函数，它接受1-10个参数，返回一个按参数列表顺序发射这些数据的Observable。
Observable observable = Observable.just(1);//单个
Observable observable = Observable.just(1,2,3,4,5,6,7,8,9,10);//最多10个参数
Observable.range()
它接受两个参数，一个是范围的起始值，一个是范围的数据的数目。如果你将第二个参数设为0，将导致Observable不发射任何数据（如果设置为负数，会抛异常）。
Observable observable = Observable.range(0,10);//发射0,1,2,3,4,5,6,7,8,9
Observable.defer()
直到有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable，该操作符能保证订阅执行时数据源是最新的数据
String test="old data";
final Observable observable=Observable.just(test);
Observable observable_defer = Observable.defer(new Callable<ObservableSource<String>>() {
@Override
public ObservableSource<String> call() throws Exception {
return observable;
}
});
test="new data";
observable.subscribe(consumer2);//打印 old data
observable_defer.subscribe(consumer2);//打印 new data
Observable.fromArray()/fromIterable/fromPublisher/fromFuture
from操作符可以转换Future、Iterable和数组。对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据。对于Future，它会发射Future.get()方法返回的单个数据，并且还可以增加通过: from(Future,timeout, timeUnit)指定超时时间，如果执行的时候Future超时会回调onError（）方法。
Observable.Interval()/intervalRange()
Interval操作符返回一个Observable，它按固定的时间间隔发射一个无限递增的整数序列
//1秒后，每隔1秒发射从0发射，直到取消订阅
Observable.interval(500,1000,TimeUnit.MILLISECONDS).subscribe(consumer1);
//2秒后，每隔1秒发射从0发射，直到发射10个数据后停止
Observable.intervalRange(10,10,2,1,TimeUnit.SECONDS).subscribe(consumer1);
Observable.timer()
Timer操作符创建一个在给定的时间段之后返回一个特殊值的Observable。它在延迟一段给定的时间后发射一个简单的数字0.
![enter description here][13]
//3 秒后发射数字0
Observable.timer(3,TimeUnit.SECONDS).subscribe(consumer1);
//3 秒后发射数字0 数据在主线程发射
Observable.timer(3,TimeUnit.SECONDS,AndroidSchedulers.mainThread()).subscribe(consumer1)
Observable.empty()/never()/error()
● Empty：创建一个不发射任何数据但是正常终止的Observable
● Never：创建一个不发射数据也不终止的Observable
● Error：创建一个不发射数据以一个错误终止的Observable
Flowable.toObservable()
通过Flowable切换
2.Observer观察者的创建
创建一个Observer，需要实现四个方法onSubscribe(),onNext(),onError(),onComplete()
回调onSubscribe(Disposable d)返回Disposable 对象，让观察者管理订阅状态。回调onNext(Object o）数据源,onError(),onComplete()标志事件流终止。两者只会回调执行一个。
Observer<Object> observer= new Observer<Object>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
// 回调返回Disposable 对象，让观察者管理订阅状态， 例如取消订阅
printThread(tag+" onSubscribe ");
}
@Override
public void onNext(@NonNull Object o) {
//数据接收处理
printThread(tag+" onNext "o.toString());
}
@Override
public void onError(@NonNull Throwable e) {
//发生异常，终止事件流
printThread(tag+" onError "+e.getMessage());
}
@Override
public void onComplete() {
//事件流结束
printThread(tag+" onComplete ");
}
};
3.subscribe() 订阅
- subscribe(Observer o)
- subscribe()//参数为空，即使观察者为null,Observeable也会在subscribe()的时候创建，处理，发射数据。
- subscribe( Consumer<? super T> onNext)
- subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)
- subscribe( Consumer<? super T> onNext) subscribe(Consumer<? super T>
onNext, Consumer<? super Throwable> onError) - subscribe( Consumer<? super T> onNext) subscribe(Consumer<? super T>
onNext, Consumer<? super Throwable> onError) subscribe(Consumer<?
super T> onNext, Consumer<? super Throwable> onError,Action
onComplete)
后面 四个subscribe( )最终都是调用了subscribe(Observer o)来实现订阅的，如下面截取的源码：
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe)
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe) {
.......
LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
}
我们看到subscribe（）返回值是Disposable 对象，RxJava给我们一个类CompositeDisposable ，可以让我们管理所有Disposable。
使用实例：
CompositeDisposable disposables = new CompositeDisposable();
Disposable d1 = Observable.timer(3,TimeUnit.SECONDS).subscribe(consumer1);
Disposable d2 = Observable.interval(1,1 ,TimeUnit.SECONDS).subscribe(consumer1);
disposables.add(d1);
disposables.add(d2);
........
disposables.clear();/d1,d2的事件流停止发射数据,//结束d1,d2任务，
