一、概述
在 RxJava 中，一个实现了 Observer 接口的对象可以订阅一个 Observable 类的实例。订阅者对 Observable 发射的任何数据或数据序列作出响应。这种模式简化了并发操作，因为它不需要阻塞等待 Observable 发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应 Observable 的通知。RxJava 提供了一套异步编程的 API，并且支持链式调用，所以使用 RxJava 编写的代码的逻辑会非常简洁
RxJava 有以下三个最基本的元素：
- 被观察者（Observable）
- 观察者（Observer）
- 订阅（subscribe）
创建被观察者
Observable observable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) {
Log.e(TAG, “subscribe”);
Log.e(TAG, "currentThread name: " + Thread.currentThread().getName());
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
});
创建观察者
Observer observer = new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, “onSubscribe”);
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
}
};
完成观察者与被观察者之间的订阅关系
observable.subscribe(observer);
也可以以链式调用的方式来完成订阅
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) {
Log.e(TAG, “subscribe”);
Log.e(TAG, "currentThread name: " + Thread.currentThread().getName());
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, “onSubscribe”);
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
}
});
最终的输出结果是一样的
onSubscribe
subscribe
currentThread name: main
onNext: 1
onNext: 2
onNext: 3
onComplete
被观察者发送的事件类型有以下几种
onNext()
发送该事件时，观察者会回调 onNext() 方法
onError()
发送该事件时，观察者会回调 onError() 方法，当发送该事件之后，其他事件将不会继续发送
onComplete()
发送该事件时，观察者会回调 onComplete() 方法，当发送该事件之后，其他事件将不会继续发送
下面来讲解 RxJava 中各种常见的操作符
二、创建操作符
2.1、create()
用于创建一个 Observable。一个正确的 Observable 必须尝试调用观察者的 onCompleted 方法或者 onError 方法有且仅有一次，而且此后不能再调用Observable 的任何其它方法
Observable observable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) {
Log.e(TAG, “subscribe”);
Log.e(TAG, "currentThread name: " + Thread.currentThread().getName());
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
});
2.2、just()
创建一个 Observable并发送事件，发送的事件总数不可以超出十个
Observable.just(1, 2, 3).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, “onSubscribe”);
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
}
});
onSubscribe
onNext: 1
onNext: 2
onNext: 3
onComplete
2.3、fromArray
和 just() 类似，但 fromArray 可以传入多于十个的变量，并且可以传入一个数组
Integer[] arrays = new Integer[]{1, 2, 3};
Observable.fromArray(arrays).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, “onSubscribe”);
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
}
});
2.4、fromCallable
这里的 Callable 是指 java.util.concurrent 中的 Callable，Callable 和 Runnable 的用法基本一致，只是它包含一个返回值，这个结果值就是发给观察者的
Observable.fromCallable(new Callable() {
@Override
public Integer call() {
return 100;
}
});
2.5、fromFuture
这里的 Future 是指 java.util.concurrent 中的 Future，Future 的作用是增加了 cancel() 等方法操作 Callable，它可以通过 get() 方法来获取 Callable 返回的值
final FutureTask futureTask = new FutureTask<>(new Callable() {
@Override
public Integer call() {
return 12;
}
});
Observable.fromFuture(futureTask).doOnSubscribe(new Consumer() {
@Override
public void accept(Disposable disposable) {
futureTask.run();
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) {
Log.e(TAG, "accept: " + integer);
}
});
2.6、fromIterable()
用于发送一个 List 集合数据给观察者
List<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(2);
integerList.add(3);
Observable.fromIterable(integerList).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
Log.e(TAG, "accept: " + integer);
}
});
2.7、defer()
defer 操作符会一直等待直到有观察者订阅它，然后它使用 Observable 工厂方法生成一个 Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个 Observable ，实际上每个订阅者获取到的都是它们自己的单独的数据序列。在某些情况下，直到发生订阅时才生成 Observable 可以确保 Observable 包含最新的数据
//全局变量
private Integer value = 100;
Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
@Override
public ObservableSource<? extends Integer> call() {
return Observable.just(value);
}
});
value = 200;
observable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
Log.e(TAG, "accept: " + integer);
}
});
value = 300;
observable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
Log.e(TAG, "accept: " + integer);
}
});
accept: 200 accept: 300
defer() 操作符能使得每次订阅操作都创建被观察者，因此两次订阅操作会创建不同的被观察者对象，因此两次打印操作返回的值并不一样
2.8、timer()
延迟指定时间后会发送一个大小为 0L 的值给观察者
Observable.timer(2, TimeUnit.SECONDS)
.subscribe(new Consumer() {
@Override
public void accept(Long aLong) {
}
});
2.9、interval()
每隔一段时间就发送一个事件，传递的值从 0 开始并不断增 1
Observable.interval(2, TimeUnit.SECONDS)
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) {
Log.e(TAG, "value is: " + aLong);
}
});
2.10、intervalRange()
可以指定发送事件的开始值和数量，其他与 interval() 的功能一样
Observable.intervalRange(2, 3, 4, 5, TimeUnit.SECONDS)
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, “onSubscribe”);
}
@Override
public void onNext(Long aLong) {
Log.e(TAG, "onNext：" + aLong);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
}
});
起始值从 2 开始递增，事件共传递三次，第一次事件在订阅后延迟 4 秒触发，之后每次延迟 5 秒
10-06 10:48:40.017 17976-17976/leavesc.hello.rxjavademo
E/MainActivity: onSubscribe 10-06 10:48:44.017
17976-17990/leavesc.hello.rxjavademo E/MainActivity: onNext：2 10-06
10:48:49.017 17976-17990/leavesc.hello.rxjavademo E/MainActivity:
onNext：3 10-06 10:48:54.017 17976-17990/leavesc.hello.rxjavademo
E/MainActivity: onNext：4 10-06 10:48:54.017
17976-17990/leavesc.hello.rxjavademo E/MainActivity: onComplete
2.11、range()
发送指定范围的事件序列
Observable.range(2, 5)
.subscribe(new Consumer() {
@Override
public void accept(Integer integer) {
Log.e(TAG, “values is :” + integer);
}
});
values is :2
values is :3
values is :4
values is :5
values is :6
2.12、rangeLong()
作用与 range() 一样，只是数据类型是 Long
Observable.rangeLong((2, 5)
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) {
Log.e(TAG, "values is :" + aLong);
}
});
2.13、empty() & never() & error()
empty() 直接发送 onComplete() 事件
Observable.empty().subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe");
}
@Override
public void onNext(Object object) {
Log.e(TAG, "onNext: " + object);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
}
});
打印结果
onSubscribe
onComplete
换成 never()
onSubscribe
换成 error()
Observable.error(new Throwable("Hello")).subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe");
}
@Override
public void onNext(Object object) {
Log.e(TAG, "onNext: " + object);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
}
});
onSubscribe onError: Hello
