RxJava的使用入门
RxJava是一个使用可观察序列来编写异步和基于事件的程序的库。
首先添加依赖
implementation 'io.reactivex.rxjava2:rxjava:2.2.6'
1. Hello World
1.1
先写一个简单版本的，创建一个消费者consumer，也可以称之为订阅者或观察者，消费者实现了accept方法，接受一个字符串类型数据或事件，被观察者Observable通过just方法发出一个“Hello World”，我们使用subscribe方法指定呼唤的接收者或消费者，即consumer。那么consumer就能接收到被观察者的呼唤，打印log
private static void helloWorldSimple() {
//创建消费者，消费者接受一个String类型的事件
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
};
//被观察者发出Hello World，且指定该事件的消费者为consumer
Observable.just("Hello World").subscribe(consumer);
}
也可以通过just发送多个Hello World
Observable.just("Hello World","Hello World","Hello World").subscribe(consumer);
1.2
下面写一个复杂的版本，创建了一个观察者Observer而不是Consumer，Observer在接口方法上要多很多，有onSubscribe表示开始观察被观察者了，onNext表示收到被观察者信息，onError，onComplete表示接收消息结束。被观察者还是Observable，然后通过subscribe指定观察者Observer
private static void helloWorldComplex() {
//创建观察者
Observer<String> observer = new Observer<String>() {
//当Observable用subscribe方法时会回调
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
//调用onSubscribe方法后
@Override
public void onNext(String s) {
Log.d(TAG, "onNext" + s);
}
//错误回调
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError");
}
//onNext方法后
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
};
Observable.just("Hello World").subscribe(observer);
}
在onSubscribe方法中会收到一个Disposable，该对象相当于一个开关，如果开关关闭，则观察者不会收到任何事件和数据，使用方法如下
Observer<String> observer1 = new Observer<String>() {
//声明一个Disposable
Disposable disposable;
@Override
public void onSubscribe(Disposable d) {
//保存Disposable
disposable = d;
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: " + s);
//当字符串为！时，关闭开关
if (s.equals("!")) {
disposable.dispose();
}
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
};
Observable.just("Hello World","!","Hello World").subscribe(observer1);
这时发现！后面的Hello World接收不到了，onComplete方法也不会执行
1.3
下面写一个升级版，观察者还是原来的观察者，被观察者使用create方法创建出来，并实现了subscribe方法，接收一个ObservableEmitter，即被观察者的发射器，能够发出数据和事件
private static void helloWorldPlus() {
Observer<String> observer = new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext" + s);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
};
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
Log.d(TAG, "send hello world");
emitter.onNext("hello world");
Log.d(TAG, "send 111");
emitter.onNext("111");
Log.d(TAG, "send 222");
emitter.onNext("222");
emitter.onComplete();
}
});
observable.subscribe(observer);
}
发射器每发出一个数据或者事件，观察者就会收到，也可以链式调用，让代码更整洁，上面发送数据和事件，下面接收数据和事件。
private static void helloWorldPlus1(){
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
Log.d(TAG, "send hello world");
emitter.onNext("hello world");
Log.d(TAG, "send 111");
emitter.onNext("111");
Log.d(TAG, "send 222");
emitter.onNext("222");
emitter.onComplete();
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext" + s);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
});
}
2.操作符
RxJava提供了大量的操作符完成对数据的处理，这些操作符也可以理解为函数，如果把RxJava比作一条数据流水线，那么一个操作符就是一道工序，数据通过他们加工变换、组装，最后生产出数据。
2.1 filter
过滤数据。内部通过OnSubscribeFilter过滤数据。
private static void filter() {
Observable.just("a", "b", "c", "d").filter(new Predicate<String>() {
@Override
public boolean test(String s) throws Exception {
Log.d(TAG, "test" + s);
return s.equals("c");
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept" + s);
}
});
}
2.2 map
map能完成数据类型的转换，对Observable发射的每一项数据都应用一个函数来变换。比如被观察者发送一个student，而观察者想接受一个developer，那么在发送之前需要对student进行一些“培训”，让他转换成一个developer。
private static void map(){
Student student=new Student("map-student");
Observable.just(student).map(new Function<Student, Developer>() {
@Override
public Developer apply(Student student) throws Exception {
System.out.println("apply"+student.toString());
Developer developer=new Developer();
developer.setName(student.getName());
developer.setSkill("android");
return developer;
}
}).safeSubscribe(new Observer<Developer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Developer developer) {
Log.d(TAG, "onNext: "+developer.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
2.3 flatMap
他也能实现map的功能，完成数据类型的转换，不同的是他能实现一对多的转换
//flatMap 操作符,它可以把一个发射器Observable 通过某种方法转换为多个Observables，然后再把这些分散的Observables装进一个单一的发射器Observable。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
})
.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("I am value " + integer);
}
//随机生成一个时间
int delayTime = (int) (1 + Math.random() * 10);
return Observable.fromIterable(list).delay(delayTime, TimeUnit.MILLISECONDS);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e("observerTest.flatMap", "accept: " + s);
}
});
2.4 concatMap
//concatMap 操作符,concatMap 与 FlatMap 的唯一区别就是 concatMap 保证了顺序，
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
})
.concatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("I am value " + integer);
}
//随机生成一个时间
int delayTime = (int) (1 + Math.random() * 10);
return Observable.fromIterable(list).delay(delayTime, TimeUnit.MILLISECONDS);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e("observerTest.concatMap", "accept: " + s);
}
});
2.5 zip
zip 操作符,构建一个 String 发射器 和 Integer 发射器 zip 组合事件的过程就是分别从发射器A和发射器B各取出一个事件来组合，并且一个事件只能被使用一次，组合的顺序是严格按照事件发送的顺序来进行的，所以上面截图中，可以看到，1永远是和A 结合的，2永远是和B结合的。
最终接收器收到的事件数量是和发送器发送事件最少的那个发送器的发送事件数目相同
Observable.zip(getStringObservable(), getIntegerObservable(), new BiFunction<String, Integer, String>() {
@Override
public String apply(@NonNull String s, @NonNull Integer integer) throws Exception {
return s + integer;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e("observerTest.zip", "accept: " + s);
}
});
3.异步
RxJava提供了方便的API来完成线程的调度，内置的线程调度器有：
- Schedulers.single() ，单线程调度器，线程可复用
- Schedulers.newThread() ，为每个任务创建新线程
- Schedulers.io() ，处理I/O密集型任务，内部线程池实现，可根据需求增长
- Schedulers.computation() ，处理计算任务，如事件循环和回调任务
- AndroidSchedulers.mainThread() ，Android主线程调度器，属于RxAndroid
线程调度器是指事件或者数据在什么样的线程中执行，默认情况下被观察者和观察者在同一个线程执行，通过2个API指定调度器：
（1）subscribeOn()
是指被观察者的代码在那种线程执行
private static void testSubscribeOn() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
Log.d(TAG, "subscribe: " + Thread.currentThread().getName());
emitter.onNext("hello");
}
}).subscribeOn(Schedulers.newThread()).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "subscribe accept: " + Thread.currentThread().getName());
}
});
sleep(1000);
}
private static void sleep(int millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log如下，发现被观察者和观察者代码都在新的线程执行
subscribe: RxNewThreadScheduler-3
subscribe accept: RxNewThreadScheduler-3
他的调用位置没有特殊规定，可以放在其他操作符前面后面中间，也可被多次调用，但只有第一次有效。
（2）observeOn()
他指的是后续操作的操作符以及观察者的代码在什么线程执行，且可以被多次调用，每次都会生效。
private static void testObserveOn() {
Observable.just("hello")
.observeOn(Schedulers.newThread())
.filter(new Predicate<String>() {
@Override
public boolean test(String s) throws Exception {
Log.d(TAG, "test1: " + Thread.currentThread().getName());
return true;
}
})
.observeOn(Schedulers.io())
.filter(new Predicate<String>() {
@Override
public boolean test(String s) throws Exception {
Log.d(TAG, "test2: " + Thread.currentThread().getName());
return true;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept: " + Thread.currentThread().getName());
}
});
sleep(1000);
}
log如下，发现observeOn()每次指定都会生效
testObserveOn test1: RxNewThreadScheduler-4
testObserveOn test2: RxCachedThreadScheduler-2
testObserveOn accept: RxCachedThreadScheduler-2
4.背压
backpressure，即背部的压力，是指被观察者发出很多数据或事件，观察者来不及处理，都被积压在那里，严重时还可能导致OOM。
写一个被观察者，一直发送hello
private static void testBackPressure() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
while (true) {
Log.d(TAG, "subscribe: hello");
emitter.onNext("hello");
}
}
}).subscribeOn(Schedulers.io()).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept: hello");
}
});
}
运行起来发现cpu有一定的波动，但是内存比较稳定，因为被观察者和观察者在同一个线程执行，所以代码是按照顺序来的，被观察者发送一个hello，观察者接收之后才能继续发下一个。
现在让被观察者和观察者在不同线程执行，让观察者处理速度慢一些。
private static void testBackPressure2() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
while (true) {
Log.d(TAG, "subscribe2: hello");
emitter.onNext("hello");
}
}
}).subscribeOn(Schedulers.io())
.observeOn(Schedulers.newThread())
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
sleep(10000);
Log.d(TAG, "accept2: hello");
}
});
}
用Android profiler查看，发现内存迅速上升，如果不加出来可能会出现OOM，因为发送的是一个线程，接收的是另一个线程，如果两个线程步调不一致，发送那么多数据处理不了就缓存起来，直到内存耗尽，这就是背压。
如何阻止这种情况呢，阻止被观察者发送数据，或者让被观察者发送的速度与观察者处理的速度一致或稍低于观察者，就不需要缓存那么多数据了。
RxJava提供了支持背压处理的被观察者和观察者，Flowable和Subscriber
private static void testBackPressure3() {
Flowable.create(new FlowableOnSubscribe<String>() {
@Override
public void subscribe(FlowableEmitter<String> emitter) throws Exception {
Log.d(TAG, "subscribe: hello1");
emitter.onNext("hello1");
Log.d(TAG, "subscribe: hello2");
emitter.onNext("hello2");
Log.d(TAG, "subscribe: hello3");
emitter.onNext("hello3");
}
}, BackpressureStrategy.ERROR).subscribe(new Subscriber<String>() {
@Override
public void onSubscribe(Subscription s) {
Log.d(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable t) {
Log.d(TAG, "onError: " + t.toString());
}
@Override
public void onComplete() {
}
});zhezhpn
}
设置的背压策略为ERROR，当出现问题时候会抛出一个错误，log如下
subscribe: hello1
onError: io.reactivex.exceptions.MissingBackpressureException: create: could not emit value due to lack of requests
subscribe: hello2
subscribe: hello3
发现当第一个hello发出后，Subscriber并没有收到，而是收到了一个错误，告诉我们缺少请求，在Flowable模式下，Subscriber需要向Flowable请求处理的数据或事件个数，如果不这样做将会收不到事件或数据，也就是onNext方法不会执行，需要在onSubscribe中请求。
@Override
public void onSubscribe(Subscription s) {
s.request(3);
Log.d(TAG, "onSubscribe: ");
}
这个效果和同线程Observable效果是相似的，发送一个马上接收下一个，当申请request为2 时，发送的第三个hello也是会收到Exception。下面研究一下不同线程使用Flowable，增加代码
......
}, BackpressureStrategy.ERROR)
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.newThread())
.subscribe(new Subscriber<String>() {
@Override
public void onSubscribe(Subscription s) {
//不请求处理数据
Log.d(TAG, "onSubscribe: ");
}
......
运行发现并没有发生错误，实际上由于发送和接收在不同线程上，即使没有观察者来请求接收，也会缓存起来，我们可以把onSubscribe传过来的Subscription对象存起来在代码块外面触发请求处理数据
@Override
public void onSubscribe(Subscription s) {
mSubscription=s;
Log.d(TAG, "onSubscribe: ");
}
public void onRequest(View view) {
mSubscription.request(3);
}
在一个按钮的单击事件中触发onRequest调用，进而向被观察者请求处理3条数据
subscribe: hello1
subscribe: hello2
subscribe: hello3
发现正常输出，之前发送的hello都没有被丢掉，而是缓存起来了。
这个缓存他肯定限制了大小否则就和Observable一样了，可以通过Flowable.bufferSize()获取到缓存大小
Flowable.create(new FlowableOnSubscribe<String>() {
@Override
public void subscribe(FlowableEmitter<String> emitter) throws Exception {
for (int i = 0; i < Flowable.bufferSize(); i++) {
Log.d(TAG, "subscribe: hello" + i);
emitter.onNext("hello" + i);
}
}
......
执行代码后会返回128个hello，默认缓存的数据个数为128个，加入多发一个hello的话，由于Subscriber并没有请求处理数据，缓存已经存满，又因为配置的ERROR背压策略，所以会通知Subscribe发生错误，调用onError。
除了ERROR还有其他的背压策略
- MISSING 不使用背压，没有缓存
- BUFFER 缓存所有数据，直到观察者处理，也是不设置缓存大小，如果观察者处理不及时，也会出现OOM，等同于使用Observable的效果
- DROP 丢弃超过缓存大小的数据
- LATEST 超出缓存大小时用新数据覆盖老数据
如果不使用create方法创建Flowable，而是使用其他方法，如range，interval等创建操作符，这时就不能配置BackpressureStrategy了，RxJava还提供了onBackpressureLatest(),onBackpressureBuffer(),onBackpressureDrop()方法对应那几种策略，比如
Flowable.range(0,300)
.onBackpressureLatest()
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.newThread())
.subscribe(new Subscriber<String>() {
5.RxJava与Retrofit集成
1.在build.gradle下添加依赖
implementation 'com.squareup.retrofit2:retrofit:2.4.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.4.0'
implementation 'io.reactivex.rxjava2:rxjava:2.1.16'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'
2.定义网络接口
public interface Api {
@GET("top250")
Observable<MovieBean> listTop250(@Query("start") int start, @Query("count") int count);
}
3.实现接口
public class MovieRetrofit {
private static MovieRetrofit sMovieRetrofit;
private final Api mApi;
//单例模式
public static MovieRetrofit getInstance() {
if (sMovieRetrofit == null) {
synchronized (MovieRetrofit.class) {
if (sMovieRetrofit == null) {
sMovieRetrofit = new MovieRetrofit();
}
}
}
return sMovieRetrofit;
}
private MovieRetrofit() {
Retrofit retrofit = new Retrofit.Builder().baseUrl("https://api.douban.com/v2/movie/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
//创建网络接口代理
mApi = retrofit.create(Api.class);
}
//返回Api接口的实现
public Api getApi() {
return mApi;
}
}
4.发送网络请求刷新列表
<!--添加网络权限-->
<uses-permission android:name="android.permission.INTERNET"/>
Observable<MovieBean> movieBeanObservable = MovieRetrofit.getInstance().getApi().listTop250(0, 10);
movieBeanObservable.subscribeOn(Schedulers.io())//在io线程池中执行map
//将网络的结果转换成我们要的电影名的列表
.map(new Function<MovieBean, List<String>>() {
@Override
public List<String> apply(MovieBean movieBean) throws Exception {
List<String> array = new ArrayList<String>();
for (int i = 0; i < movieBean.getSubjects().size(); i++) {
String title = movieBean.getSubjects().get(i).getTitle();
array.add(title);
}
return array;
}
})
.observeOn(AndroidSchedulers.mainThread())//在主线程中执行onNext
.subscribe(new Observer<List<String>>() {
......
@Override
public void onNext(List<String> value) {
ArrayAdapter<String> arrayAdapter = new ArrayAdapter<String>(MovieListActivity.this, android.R.layout.simple_list_item_1, value);
setListAdapter(arrayAdapter);
}
......
});