RxJava是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。简单来说就是异步操作工具库。它可以在碰到繁琐、复杂的异步的功能,依然能用保持代码的简洁。
RxJava使用的是观察者模式,Observable(被观察者)与Observer(观察者)通过 subscribe (订阅)实现订阅关系。下面来先写一个简单的例子。来说明他们之间的关系
/*
* 简单的例子
*/
private void SimpleExample() {
getObservable()
//上游,被观察者所在线程为io线程
//多次设置第一次有效
.subscribeOn(Schedulers.io())
//下游,观察者所在线程为UI线程
//可以设置多次,每次都可切换线程
.observeOn(AndroidSchedulers.mainThread())
//订阅
.subscribe(getObserver());
}
/**
* 三种创建观察者的方式
* @return
*/
private Observable<String> getObservable() {
Observable<String> observable=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
observableEmitter.onNext("cricket");
observableEmitter.onNext("football");
observableEmitter.onComplete();
}
});
return observable;
//第二种通过fromXXX方式
// return Observable.fromArray("cricket","football");
//第三种通过just
// return Observable.just("cricket", "football");
}
/**
* 观察者
* @return
*/
private Observer<String> getObserver() {
return new Observer<String>() {
/**
* 这个最先会被调用
* Disposable 对象调用dispose()方法可以切断与被观察直接的联系,切断后不再接受到数据
* @param d
*/
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, " onSubscribe : " + d.isDisposed());
}
@Override
public void onNext(String value) {
Log.d(TAG, " onNext : value : " + value);
}
/**
* onError 和 onComplete()方法互斥,一个事件流里是互斥存在的
* 不能发送了onError事件又发送onComplete事件
* @param e
*/
@Override
public void onError(Throwable e) {
Log.d(TAG, " onError : " + e.getMessage());
}
@Override
public void onComplete() {
Log.d(TAG, " onComplete");
}
};
}
输出结果:
onNext : value : cricket
onNext : value : football
onComplete
map操作符
map操作符可以转换被观察者发射的数据类型,如把Integer转换成String,如下:
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return integer + "发射";
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i(TAG, "value=" + value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete");
}
});
输出结果:
value=1发射
value=2发射
value=3发射
onComplete
flatmap、concatmap 操作符
flatmap和concatmap也数据转换
/**
* concatmap flatmap用法 concatmap确保顺序
* 转换成 Observable<T>
*/
public void Example04() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
return Observable.just("I am value"+integer+"");
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, s);
}
});
}
输出结果:
I am value1
I am value2
I am value3
zip操作符
zip可以把两个被观察者合成一个被观察者对象,如下面的例子
/**
* zip操作符的使用
* 管道少的为准
*/
public void Example05() {
//创建一个被观察者
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).subscribeOn(Schedulers.io());
//创建另一个被观察者
Observable<String> observable1=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
e.onNext("A");
e.onNext("B");
e.onComplete();
}
}).subscribeOn(Schedulers.io());
Observable.zip(observable, observable1, new BiFunction<Integer, String, String>() {
@Override
public String apply(Integer integer, String s) throws Exception {
Log.i(TAG,"apply"+integer+s);
return integer+s;
}
}).observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i(TAG,value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG,"onComplete");
}
});
}
打印的日志
04-04 19:36:46.400 1823-1881/com.liuxin.rxjavademo I/RxjavaUtil: apply1A
04-04 19:36:46.400 1823-1881/com.liuxin.rxjavademo I/RxjavaUtil: apply2B
04-04 19:36:46.428 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: 1A
04-04 19:36:46.429 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: 2B
04-04 19:36:46.429 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: onComplet
take操作符
使用take操作符,限制发送数据的数量,只会发送被要求数据的数量,如下面有5个数据要发送,但使用take操作符,只发送3个数据
private void test() {
getObservable()
// 被观察者所在线程
.subscribeOn(Schedulers.io())
// 观察者线程
.observeOn(AndroidSchedulers.mainThread())
//只发送3个
.take(3)
.subscribe(getObserver());
}
private Observable<Integer> getObservable() {
//这里有5个数据
return Observable.just(1, 6, 3, 4, 5);
}
private Observer<Integer> getObserver() {
return new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, " onSubscribe : " + d.isDisposed());
}
@Override
public void onNext(Integer value) {
Log.d(TAG, " onNext value : " + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, " onError : " + e.getMessage());
}
@Override
public void onComplete() {
Log.d(TAG, " onComplete");
}
};
}
打印日志
onNext value : 1
onNext value : 6
onNext value : 3
onComplete
这一节就先介绍到这里,下节再介绍其他操作符。