RxJava2.0教程
这是9篇基础版讲的最好的文章
给初学者的RxJava2.0教程(一)
给初学者的RxJava2.0教程(二)
给初学者的RxJava2.0教程(三)
给初学者的RxJava2.0教程(四)
给初学者的RxJava2.0教程(五)
给初学者的RxJava2.0教程(六)
给初学者的RxJava2.0教程(七)
给初学者的RxJava2.0教程(八)
给初学者的RxJava2.0教程(九)
关于RxJava1中的Subscription的一些误解
上面文章中的知识点
ObservableEmitter： Emitter是发射器的意思，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。
Disposable：这个单词的字面意思是一次性用品,用完即可丢弃的. 那么在RxJava中怎么去理解它呢, 对应于上面的水管的例子, 我们可以把它理解成两根管道之间的一个机关, 当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件。
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onNext(4);
emitter.onComplete();
}
}).subscribe(new Observer() {
private Disposable mDisposable;
private int i;
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "subscribe");
mDisposable = d;
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "onNext: " + value);
i++;
if (i == 2) {
Log.d(TAG, "dispose ：" + mDisposable.isDisposed());
mDisposable.dispose();
Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
}
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "error");
}
@Override
public void onComplete() {
Log.d(TAG, "complete");
}
}); 打印的结果：
com.example.pioneerchang.demo D/chang-->: subscribe
com.example.pioneerchang.demo D/chang-->: onNext: 1
com.example.pioneerchang.demo D/chang-->: onNext: 2
com.example.pioneerchang.demo D/chang-->: dispose ：false
com.example.pioneerchang.demo D/chang-->: isDisposed : true 等于2的时候，通过mDisposable.dispose();切断水管，之后下游就收不到了。
Activity中请求网络，如果在请求的过程中Activity已经退出了, 这个时候如果回到主线程去更新UI, 那么APP肯定就崩溃了, 怎么办呢, 上一节我们说到了Disposable , 说它是个开关, 调用它的dispose()方法时就会切断水管, 使得下游收不到事件, 既然收不到事件, 那么也就不会再去更新UI了. 因此我们可以在Activity中将这个Disposable 保存起来, 当Activity退出时, 切断它即可.
那如果有多个Disposable 该怎么办呢, RxJava中已经内置了一个容器CompositeDisposable, 每当我们得到一个Disposable时就调用CompositeDisposable.add()将它添加到容器中, 在退出的时候, 调用CompositeDisposable.clear() 即可切断所有的水管。Map.
map是RxJava中最简单的一个变换操作符了, 它的作用就是对上游发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化。
如代码所示，在上游我们发送的是数字类型, 而在下游我们接收的是String类型。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "This is result " + integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, s);
}
});- FlatMap.
FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里。
上游每发送一个事件, flatMap都将创建一个新的水管, 然后发送转换之后的新的事件, 下游接收到的就是这些新的水管发送的数据. 这里需要注意的是, flatMap并不保证事件的顺序, 也就是图中所看到的, 并不是事件1就在事件2的前面. 如果需要保证顺序则需要使用concatMap。
代码示例：
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
}).flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
final List<String> list = new ArrayList<>();
for (int i = 0; i < 2; i++) {
list.add("I am value " + integer);
}
return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, s);
}
});log打印
com.example.pioneerchang.demo D/chang-->: I am value 1
com.example.pioneerchang.demo D/chang-->: I am value 1
com.example.pioneerchang.demo D/chang-->: I am value 3
com.example.pioneerchang.demo D/chang-->: I am value 3
com.example.pioneerchang.demo D/chang-->: I am value 2
com.example.pioneerchang.demo D/chang-->: I am value 2- 通过FlatMap实现注册和登录
public interface Api {
@GET
Observable login(@Body LoginRequest request);
@GET
Observable register(@Body RegisterRequest request);
}
//可以看到登录和注册返回的都是一个上游Observable,
// 而我们的flatMap操作符的作用就是把一个Observable转换为另一个Observable,因此结果就很显而易见了:
public void register() {
api.register(new RegisterRequest())
//发起注册请求
.subscribeOn(Schedulers.io())
//在IO线程进行网络请求
.observeOn(AndroidSchedulers.mainThread())
//回到主线程去处理请求注册结果
.doOnNext(new Consumer() {
@Override
public void accept(RegisterResponse registerResponse) throws Exception {
//先根据注册的响应结果去做一些操作
}
})
.observeOn(Schedulers.io())
//回到IO线程去发起登录请求
.flatMap(new Function>() {
@Override
public ObservableSource apply(RegisterResponse registerResponse) throws Exception {
return api.login(new LoginRequest());
}
})
.observeOn(AndroidSchedulers.mainThread())
//回到主线程去处理请求登录的结果
.subscribe(new Consumer() {
@Override
public void accept(LoginResponse loginResponse) throws Exception {
Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
}
}, new Consumer() {
@Override
public void accept(Throwable throwable) throws Exception {
Toast.makeText(MainActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
}
});
} - Zip通过一个函数将多个Observable发送的事件结合到一起，然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。
Observable observable1 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onNext(4);
emitter.onComplete();
}
});
Observable observable2 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext("A");
emitter.onNext("B");
emitter.onNext("C");
emitter.onComplete();
}
});
Observable.zip(observable1, observable2, new BiFunction() {
@Override
public String apply(Integer integer, String s) throws Exception {
return integer + s;
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
@Override
public void onNext(String value) {
Log.d(TAG, value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
}); log输出：
com.example.pioneerchang.demo D/chang-->: onSubscribe
com.example.pioneerchang.demo D/chang-->: 1A
com.example.pioneerchang.demo D/chang-->: 2B
com.example.pioneerchang.demo D/chang-->: 3C
com.example.pioneerchang.demo D/chang-->: onComplete 应用场景：
比如一个界面需要展示用户的一些信息, 而这些信息分别要从两个服务器接口中获取, 而只有当两个都获取到了之后才能进行展示, 这个时候就可以用Zip了。
- sample操作符，这个操作符每隔指定的时间就从上游中取出一个事件发送给下游。虽然上游仍然一直在不停的发事件, 但是我们只是每隔一定时间取一个放进对列里。
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
for (int i = 0; ; i++) {
emitter.onNext(i);
}
}
}).subscribeOn(Schedulers.io())
.sample(2, TimeUnit.SECONDS) //sample取样
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "" + integer);
}
});
- Flowable里默认有一个大小为128的队列。如果队列存储的事件源超过128，就会报MissingBackpressureException异常。