RxJava中文文档:https://mcxiaoke.gitbooks.io/rxdocs/content/
RxJava2.0的基本使用
基于观察者模式,我们开始RxJava2.0的学习。首先引入RxJava2.0相关的类库。
compile 'io.reactivex.rxjava2:rxjava:2.0.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
第一步:创建被观察者Observable
Observable mObservable=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("one");
e.onComplete();
}
});
Observable中文意思就是被观察者,通过create方法生成对象,里面放的参数ObservableOnSubscribe<T>,可以理解为一个计划表,泛型T是要操作对象的类型,重写subscribe方法,里面写具体的计划,在subscribe中的ObservableEmitter<String>对象的Emitter是发射器的意思。ObservableEmitter有三种发射的方法,分别是void onNext(T value)、void onError(Throwable error)、void onComplete(),onNext方法可以无限调用,Observer(观察者)所有的都能接收到,onError和onComplete是互斥的,Observer(观察者)只能接收到一个,OnComplete可以重复调用,但是Observer(观察者)只会接收一次,而onError不可以重复调用,第二次调用就会报异常。
第二步:创建观察者Observer
Observer<String> reader = new Observer<String>(){
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i(TAG, "onNext: "+value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
通过new创建接口,并实现其内部的方法,看方法其实就应该差不多知道干嘛的,onNext、onError、onComplete都是跟被观察者发射的方法一一对应的,这里就相当于接收了。onSubscribe(Disposable d)里面的Disposable对象要说一下,Disposable英文意思是可随意使用的,可以调用 mDisposable.dispose()取消订阅。
第三步:读者和连载小说建立订阅关系
mObservable.subscribe(reader);
这里我们先看一下输出效果
RxJava2.0的异步编程
RxJava是支持异步的,但是RxJava是如何做到的呢?这里就需要Scheduler。Scheduler,英文名调度器,它是RxJava用来控制线程。当我们没有设置的时候,RxJava遵循哪个线程产生就在哪个线程消费的原则,也就是说线程不会产生变化,始终在同一个。然后我们一般使用RxJava都是后台执行,前台调用,本着这个原则,我们需要调用observeOn(AndroidSchedulers.mainThread()),observeOn是事件回调的线程,AndroidSchedulers.mainThread()一看就知道是主线程,subscribeOn(Schedulers.io()),subscribeOn是事件执行的线程,Schedulers.io()是子线程,这里也可以用Schedulers.newThread(),只不过io线程可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。前面的代码根据异步和链式编程的原则,我们可以写成
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
e.onNext("two");
e.onComplete();
}
})
.observeOn(AndroidSchedulers.mainThread())
.subscribeOn(Schedulers.io())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i(TAG, "onNext: "+value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
类型
RxJava
功能强大,所以其对应的操作符的类型也非常多- 根据功能作用的不同,RxJava的操作符分类如下:
示意图
interval
创建一个按固定时间间隔发射整数序列的Observable
Observer<Long> invreader = new Observer<Long>(){
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long value) {
Log.i("invreader", "onNext: "+value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
Observable.interval(0,3,TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(invreader);
...
just
创建一个发射指定值的Observable
map
对Observable发射的每一项数据应用一个函数,执行变换操作
Observer<String> mapreader = new Observer<String>(){
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i("mapreader", "onNext: "+value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
Function<String,String> mFunction =new Function<String,String>(){
@Override
public String apply(String s) throws Exception {
return s.toUpperCase(); //字符转为大写
}
};
Observable.just("zhongdan","yasuo","caiji")
.map(mFunction)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(mapreader);
zip
通过一个函数将多个Observables的发射物结合到一起,基于这个函数的结果为每个结合体发射单个数据项。
Observer<String> zipObserver = new Observer<String>(){
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i("zipObserver", "onNext: "+value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
BiFunction mFunctionab =new BiFunction<String,String,String>(){
@Override
public String apply(String s, String s2) throws Exception {
return s+s2;
}
};
Observable.zip(getObservableA(),getObservableB(),mFunctionab)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(zipObserver);
Observable <String> getObservableA(){
return Observable.fromCallable(new Callable<String>(){
@Override
public String call() throws Exception {
SystemClock.sleep(3000);
return "kuaile";
}
});
}
Observable <String> getObservableB(){
return Observable.fromCallable(new Callable<String>(){
@Override
public String call() throws Exception {
SystemClock.sleep(3000);
return "fengnan";
}
});
运行结果:I/zipObserver: onNext: kuailefengnan
merge
合并多个Observables的发射物,与zip功能类似
Observable.merge(getObservableA(),getObservableB())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(zipObserver);
I/zipObserver: onNext: kuaile
I/zipObserver: onNext: fengnan
Scan
连续地对数据序列的每一项应用一个函数,然后连续发射结果
range
创建一个发射特定整数序列的Observable
Observer<Integer> scanObserver = new Observer<Integer>(){
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer value) {
Log.i("scanObserver", "onNext: "+value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
BiFunction mFunctionaScan =new BiFunction<Integer,Integer,Integer>(){
@Override
public Integer apply(Integer s, Integer s2) throws Exception {
Log.i("scanObserver", "apply: "+s+","+s2);
return Math.min(s,s2);
}
};
Observable.range(0,5)
.scan(mFunctionaScan)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(scanObserver);
I/scanObserver: apply: 0,1
I/scanObserver: apply: 0,2
I/scanObserver: apply: 0,3
I/scanObserver: apply: 0,4
I/scanObserver: onNext: 0
I/scanObserver: onNext: 0
I/scanObserver: onNext: 0
I/scanObserver: onNext: 0
I/scanObserver: onNext: 0
filter
只发射通过了谓词测试的数据项
Observer<Integer> filtObserver = new Observer<Integer>(){
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer value) {
Log.i("filtObserver", "onNext: "+value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
Observable.range(0,5)
.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
int res=integer%2;
boolean b= (res==0);
return b;
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(filtObserver);
I/filtObserver: onNext: 0
I/filtObserver: onNext: 2
I/filtObserver: onNext: 4