RxJava
一、RxJava简介
1.RxJava
Reactive Extensions for the JVM，基于JVM的Rx。
Reactive Extensions(Rx)原来是由微软提出的一个综合了异步和基于事件驱动编程的库。
RxJava的核心就是异步数据流和响应式编程:
1把所有的事件(数据)看成一条河流，它可以被观察、过滤或操作，也可以和另外一条河流汇合成一条新的河流。
2一旦事件产生或发生变化，就可以触发观察这些事件的角色(观察者/订阅者)做出响应处理。
2.RxJava优势及适用场景
RxJava当然是优秀而且强大的，有以下优势:
1具备响应式编程该有的特性。
2为异步而生，无需手动创建线程，并具备线程切换能力。
3支持链式调用，保证代码的简洁性。
4各种操作符，功能非常强大，满足各种业务需求。
5简化了异常的处理。
RxJava适用场景:网络请求、数据库读写、文件读写、定时任务等各种耗时操作需要通过异步来完成的操作都可以使用RxJava。
3.RxJava几个重要概念
观察者:Observer，观察事件变化并处理的主要角色。消费者(Consumer)也可以理解成―种特殊的观察者。
被观察者:触发事件并决定什么时候发送事件的主要角色。(异常和完成也是一种事件)
1Observable、Flowable、Single、Completable、Maybe都是被观察者。
2Flowable是支持背压的一种被观察者。
3Single、Completable、Maybe是简化版的Observable。
4几种被观察者通过toObservable/toFlowable/toSingle/toCompletable/toMaybe相互转换。
订阅(subscribe):观察者和被观察者建立关联的操作。
二、RxJava实操
1.导库
注：查找对应库的地址：https://mvnrepository.com/
// https://mvnrepository.com/artifact/io.reactivex.rxjava2/rxjava
implementation 'io.reactivex.rxjava2:rxjava:2.2.21'
// https://mvnrepository.com/artifact/io.reactivex.rxjava2/rxandroid
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
2.create — 被观察者与观察者
private void createOperatorTest() {
Observable.create(new ObservableOnSubscribe<Object>() { //被观察者
@Override
public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
//事件产生的地方
emitter.onNext("Observable test_01");
emitter.onNext("Observable test_02");
emitter.onNext("Observable test_03");
//emitter.onError(new Throwable("Manual Error!"));
emitter.onComplete();
}
}).subscribe(new Observer<Object>() { //观察者
@Override
public void onSubscribe(Disposable d) {
System.out.println("Observer onSubscribe");
}
@Override
public void onNext(Object o) {
System.out.println("Observer onNext o: " + o);
}
@Override
public void onError(Throwable e) {
System.out.println("Observer onError: " + e.toString());
}
@Override
public void onComplete() {
System.out.println("Observer onComplete");
}
});
}
执行结果：
注：onError与onComplete方法互斥，如果被观察者两个事件都包含，两个事件都会被执行，但是观察者只能观察到先执行的那个事件。
3.create — 被观察者与消费者
private void createOperatorTest() {
Observable.create(new ObservableOnSubscribe<Object>() { //被观察者
@Override
public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
//事件产生的地方
emitter.onNext("Observable test_01");
emitter.onNext("Observable test_02");
emitter.onNext("Observable test_03");
// emitter.onComplete();
emitter.onError(new Throwable("Manual Error!"));
}
}).subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) throws Exception {
System.out.println("Consumer o: " + o);
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
System.out.println("Consumer throwable：" +throwable.toString());
}
});
}
执行结果：
3.just — 被观察者与观察者
Just操作符最多能传10个参数。
private void justOperatorTest(){
Observable.just("msg_01", "msg_02", "msg_03")
.subscribe(new Observer<Object>() { //观察者
@Override
public void onSubscribe(Disposable d) {
System.out.println("Observer onSubscribe");
}
@Override
public void onNext(Object o) {
System.out.println("Observer onNext o: " + o);
}
@Override
public void onError(Throwable e) {
System.out.println("Observer onError: " + e.toString());
}
@Override
public void onComplete() {
System.out.println("Observer onComplete");
}
});
}
执行结果：
4.from
public static Observable fromArray(T… items)；
fromArray方法不限制传入参数的个数，just方法内部也是使用的fromArray。
Observable.fromArray("msg_01", "msg_02", "msg_03", "msg_04", "msg_05", "msg_06", "msg_07", "msg_08", "msg_09", "msg_10", "msg_11")
.subscribe(myObserver);
执行结果：
public static Observable fromIterable(Iterable source)；
可以传入实现了Iterable接口的类型值。
ArrayList list = new ArrayList<>();
list.add("msg_01");
list.add("msg_02");
list.add("msg_03");
Observable.fromIterable(list)
.subscribe(myObserver);
5.map
map: 对被观察者传入的事件进行处理，返回一个新的被观察者。
Observable.just("msg_01", "msg_02")
.map(new Function() {
@Override
public Object apply(String s) throws Exception {
System.out.println("Function apply " + s);
return "fun_msg";
}
}).subscribe(myObserver);
6.flatMap
多线程无序
Observable.just("msg_01", "msg_02")
.flatMap(new Function>() {
@Override
public ObservableSource apply(String s) throws Exception {
System.out.println("Function apply " + s);
return Observable.just("apply_msg_01", "apply_msg_02");
}
}).subscribe(myObserver);
7.concatMap
有序
Observable.just("msg_01", "msg_02")
.concatMap(new Function<String, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(String s) throws Exception {
System.out.println("Function apply " + s);
return Observable.just("apply_msg_01", "apply_msg_02");
}
}).subscribe(myObserver);
8.buffer
Observable.just("msg_01", "msg_02", "msg_03",
"msg_04", "msg_05", "msg_06", "msg_07")
.buffer(3).subscribe(myObserver);
