RxJava基础
使用RxJava之前，先了解四个基本概念：
- Observable：被观察者
- Observer：观察者
- subscribe：订阅
- 事件
工作流程：
RxJava采用的是观察者模式，首先建立被观察者Observable和观察者Observer，他们通过subscribe来建立联系（Observable.subscribe(Observer)），然后Observable在特定的时刻（完成某些操作，获得返回结果等）可以发送事件给Observer，Observer根据接收到的事件作出相应的动作。
来看一个简单的例子：
//创建被观察者
Observable observable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
//执行一些其他操作
//.............
//执行完毕，触发回调，通知观察者
e.onNext("事件");
}
});
//创建观察者
Observer observer = new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
//观察者接收到通知,进行相关操作
public void onNext(String aLong) {
System.out.println("收到事件");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
};
//订阅
observable.subscribe(observer);
这就是一个完整的RxJava观察者模式。被观察者的创建使用 Observable.create，内部实现了subscribe方法。一旦Observable被订阅（observable.subscribe(observer)），subscribe方法就会被调用，开始发送事件。
事件的发送由ObservableEmitter来完成，Emitter是事件的发送者，可以调用它的onNext(), onComplete(), onError()方法来发送不同的事件。
观察者Observer包含四个方法：onSubscribe方法在订阅完成以后，第一个onNext事件之前调用，只调用一次。其他三个方法则由被观察者决定是否调用。
onSubscribe方法接收一个Disposable对象作为参数，它用来切断observable和observer之间的联系。一旦调用了Disposable对象的dispose()方法，observer就停止动作，不再响应观察对象发送的事件了。
将上面的例子加工一下，验证Disposable的作用：
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("a");
e.onNext("b");
e.onNext("c");
}
})
.subscribe(new Observer() {
private Disposable mDisposable;
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.d("RxJava", "onSubscribe" );
mDisposable = d;
}
@Override
public void onNext(@NonNull String s) {
Log.d("RxJava", "Received Message: " + s );
if (s.equals("b")) mDisposable.dispose();
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
Log.d("RxJava", "onComplete" );
}
});
代码做了一点修改，采用链式操作，看起来更简洁一些，另外发送完第二个事件之后，调用了dispose方法。可以看到运行结果如下：
D/RxJava: onSubscribe
D/RxJava: Received Message: a
D/RxJava: Received Message: b
介绍到这里，整个RxJava的工作流程就完成了。总结一下事件的发送和接收规则：
- onNext()事件不限制发送次数，被观察者可以发送无限多个onNext，下游也可以接收无限多个onNext
- onComplete()/onError()并不会自动发送，需要被观察者指定什么时间发送
- onComplete()/onError()发送之后，被观察者仍然可以继续发送事件，但是观察者接收到onComplete()/onError()之后就不再接收事件了。
- onComplete()/onError()是唯一且互斥的。也就是说，发送的事件中，只能存在一个onComplete()或者onError()。否则可能会引起崩溃
- dispose()方法可以在观察者一端决定是够继续接收事件
Observable创建
在上面的例子中创建Observable使用的是create方法，除此之外，还有其他不同的创建方法：
- just
使用该方式创建的Observable对象在创建完成后会自动调用onNext方法，依次发送创建时传入的数据。
Observable observable = Observable.just("aa","bb","cc");
- fromIterable
这种方式接收一个List集合作为参数，创建完成后会遍历该集合并调用onNext方法来发送数据：
List list = new ArrayList<>() ;
list.add( "aa" ) ;
list.add( "bb" ) ;
list.add( "cc" ) ;
Observable observable2 = Observable.fromIterable(list) ;
- defer
defer是推迟的意思，observable在观察者进行订阅的时候才创建对象，针对每一个观察者，都会创建一个新的observable对象：
Observable observable4 = Observable.defer(new Callable>() {
@Override
public ObservableSource call() throws Exception {
return Observable.just("aa" , "bb" , "cc");
}
});
- interval
采用该方式创建的observable会按照指定的时间间隔，从0开始发送整数序列。
//每隔两秒发送一个整数
Observable.interval(2, TimeUnit.SECONDS).subscribe(new Consumer() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
Log.d("RxJava", "accept " + aLong );
}
});
- range
range接收两个整型参数，第一个表示起始值，第二个表示发送次数N。observable会从初始值开始，调用N次onNext，发送数据从初始值开始依次加1.
Observable.range(10, 20).subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
Log.d("RxJava", "accept1 " + integer );//输出结果为10,11,12,......29
}
});
- timer
observable在指定的时间发送事件调用onNext：
//表示5秒后发送事件
Observable.timer(5, TimeUnit.SECONDS).subscribe(new Consumer() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
Log.d("RxJava", "timer " + aLong );//默认发送值为0
}
});
- repeat
repeat修饰的observable对象可以重复发送事件，并且可以指定重复次数。如果不指定，默认为一直重复。
Observable.timer(5, TimeUnit.SECONDS).repeat()//.repeat(3);
Observer创建
Observer的创建很简单，上面的例子中已经给出来了：
Observer observer = new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
//观察者接收到通知,进行相关操作
public void onNext(String aLong) {
System.out.println("收到事件");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
};
为了代码简洁易读，通常会在订阅的时候直接创建Observer，订阅的方法subscribe有以下几种重载：
public final Disposable subscribe() {}/
public final Disposable subscribe(Consumer onNext) {}
public final Disposable subscribe(Consumer onNext, Consumer onError) {}
public final Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete) {}
public final Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete, Consumer onSubscribe) {}
public final void subscribe(Observer observer) {}
最开始的例子中，采用的是最后一种方法，传入一个Observer对象。
不带参数的subscribe，第一种方法，表示Observable负责发送数据，但是没有观察者去接收。
只有一个参数Consumer onNext表示Observer只需要处理onNext 方法。剩余的几种重载同理。