目录
基础用法
使用步骤:
- 初始化 Observable
- 初始化 Observer
- 订阅
当然不要忘了根据github地址添加依赖。
private static Observable<Integer> getObservable() {
return Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {
Log.i(TAG, "subscribe: 发送 1 " + Thread.currentThread().getName());
observableEmitter.onNext(1);
Log.i(TAG, "subscribe: 发送 2 " + Thread.currentThread().getName());
observableEmitter.onNext(2);
Log.i(TAG, "subscribe: 发送 3 " + Thread.currentThread().getName());
observableEmitter.onNext(3);
Log.i(TAG, "subscribe: 发送 4 " + Thread.currentThread().getName());
observableEmitter.onNext(4);
}
});
}
public static void step1() {
// 1.初始化Obervable
Observable<Integer> observable = getObservable();
// 2.初始化Observer
Observer<Integer> observer = new Observer<Integer>() {
@Override
public void onSubscribe(Disposable disposable) {
mDisposable = disposable;
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: 接收数据" + integer);
if (integer == 3) {
Log.i(TAG, "onNext: 主动销毁数据" + integer);
mDisposable.dispose();
}
}
@Override
public void onError(Throwable throwable) {
Log.i(TAG, "onError: 错误数据" + throwable.getMessage());
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: 完成");
}
};
// 3.创建订阅关系
observable.subscribe(observer);
}
single
单个数据发射器。SingleObserver只回调onSuccess和onError。
public static void single(){
Single.just(1)
.subscribe(new SingleObserver<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onSuccess(Integer integer) {
Log.i(TAG, "onSuccess: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
});
}
Completable
不发射数据,只处理 onComplete 和 onError 事件。一般配合andThen使用。
例如:提交信息到服务器,只关注成功与否,不关注数据,成功后弹出Toast。
public static void completable() {
Completable.create(new CompletableOnSubscribe() {
@Override
public void subscribe(CompletableEmitter emitter) throws Exception {
Log.i(TAG, "subscribe: 完成");
emitter.onComplete();
}
}).andThen(Observable.just(1))
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
}
Maybe
Single和Completable的结合,适用于:有可能发射数据,有可能不发射数据前的情况。调用onSucces/onComplete都会关闭流。
public static void maybe() {
Maybe.create(new MaybeOnSubscribe<String>() {
@Override
public void subscribe(MaybeEmitter<String> emitter) throws Exception {
// emitter.onSuccess("1");
emitter.onComplete();
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.i(TAG, "accept: " + s);
}
}, new Consumer<Throwable>() {
@Override
public void accept(@NonNull Throwable throwable) throws Exception {
}
}, new Action() {
@Override
public void run() throws Exception {
Log.i(TAG, "run: complate");
}
});
}
Flowable
唯一支持backpressure的Observable。类似Observable。
线程调度
subscribeOn:指定被订阅数据线程,即发送数据上游线程。多次调用仅第一次有效。
observeOn:指定观察者线程,即接收数据下游线程。多次调用多次生效,根据最近一次调用调度线程。
public static void scheduler() {
Observable<Integer> observable = getObservable();
observable
.subscribeOn(AndroidSchedulers.mainThread()) // 主线程发射数据
.subscribeOn(Schedulers.newThread()) // 子线程发射数据
.subscribeOn(Schedulers.io()) // io线程发射数据
.observeOn(AndroidSchedulers.mainThread()) // 主线程接收数据
.doOnNext(new Consumer<Integer>() { // 在accept之前调用
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: AndroidSchedulers.mainThread() 当前线程" + Thread.currentThread().getName());
Log.i(TAG, "accept: AndroidSchedulers.mainThread() 接收数据" + integer);
}
})
.observeOn(Schedulers.io()) // io线程接收数据
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: AndroidSchedulers.io() 当前线程" + Thread.currentThread().getName());
Log.i(TAG, "accept: AndroidSchedulers.io() 接收数据" + integer);
}
});
}
doOnNext:在下游接收数据前调用。onNext()之前。
doAfterNext:在接收数据之后调用。onNext()之后。
关键字
create
产生一个 Obserable
被观察者对象,即上游发射器。
map
将发射出来的数据一一映射处理一遍。
public static void map() {
Observable<Integer> observable = getObservable();
// 将 int --> String
observable.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "map " + integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: ==" + s);
}
});
}
flatMap/concatMap
将一组上游发射数据转换为N个Observable,之后无序/有序的发射这N个发射器的数据。
public static void flatMap() {
getIntObservable()
.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < integer; i++) {
list.add("第" + integer + "波数据:" + i);
}
return Observable.fromIterable(list).delay(3-integer, TimeUnit.SECONDS);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: 接收数据 " + s);
}
});
}
timer
定时任务。订阅后延时多久开始发射数据。
public static void timer() {
final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
Log.i(TAG, "timer: 开始时间 " + dateFormat.format(System.currentTimeMillis()));
Observable.timer(2,TimeUnit.SECONDS)
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i(TAG, "timer: 结束时间 " + dateFormat.format(System.currentTimeMillis()));
}
});
}
interval/intervalRange
计时任务。每隔一段时间发射一次数据。intervalRange有限次。
延迟1s后开始计时,每次间隔1s,5s后标记任务为处理状态。
public static void interval() {
final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
Log.i(TAG, "timer: 开始时间 " + dateFormat.format(System.currentTimeMillis()));
Disposable disposable = Observable.interval(1, 1, TimeUnit.SECONDS)
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i(TAG, "timer: 计时 " + dateFormat.format(System.currentTimeMillis()));
}
});
try {
Thread.sleep(5000);
disposable.dispose();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
zip
将两个或以上发射器数据合并在一起,按一一对应方式合并,所以最终结果是按照最小数量发射器,多的数据直接舍弃。从下例可以看出结果只能到 " three is 3" ,"four" 被舍弃了。
public static void zip() {
Observable.zip(getIntObservable(), getStringObservable(),
new BiFunction<Integer, String, String>() {
@Override
public String apply(Integer integer, String s) throws Exception {
return s + " is " + integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: " + s);
}
});
}
private static Observable<Integer> getIntObservable() {
return Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {
// Log.i(TAG, "subscribe: 发送 1 " + Thread.currentThread().getName());
observableEmitter.onNext(1);
// Log.i(TAG, "subscribe: 发送 2 " + Thread.currentThread().getName());
observableEmitter.onNext(2);
// Log.i(TAG, "subscribe: 发送 3 " + Thread.currentThread().getName());
observableEmitter.onNext(3);
// 通知下游数据发送完成 后续数据不在接收
observableEmitter.onComplete();
// Log.i(TAG, "subscribe: 发送 4 " + Thread.currentThread().getName());
observableEmitter.onNext(4);
}
});
}
private static Observable<String> getStringObservable() {
return Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
observableEmitter.onNext("one");
observableEmitter.onNext("two");
observableEmitter.onNext("three");
observableEmitter.onNext("four");
// 通知下游数据发送完成 后续数据不在接收
observableEmitter.onComplete();
}
});
}
concat/merge
将两个上游发射器合并在一起,按照顺序依次发送数据/无序发送数据。合并的observable的数据类型必须相同。
public static void concat(){
Observable.concat(getIntObservable(),getIntObservable())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
}
从结果可以看concat出是在第一个observable之后有序发射第二个observable的数据。
distinct
去重,去除重复的数据。
class DistinctBean {
String name;
int id;
public DistinctBean(String name, int id) {
this.name = name;
this.id = id;
}
@Override
public String toString() {
return "DistinctBean{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof DistinctBean)) return false;
DistinctBean that = (DistinctBean) o;
return id == that.id &&
Objects.equals(name, that.name);
}
@Override
public int hashCode() {
return Objects.hash(name, id);
}
}
private static Observable<DistinctBean> getDistinctObservable() {
return Observable.create(new ObservableOnSubscribe<DistinctBean>() {
@Override
public void subscribe(ObservableEmitter<DistinctBean> observableEmitter) throws Exception {
observableEmitter.onNext(new DistinctBean("a", 1));
observableEmitter.onNext(new DistinctBean("b", 1));
observableEmitter.onNext(new DistinctBean("b", 1));
observableEmitter.onNext(new DistinctBean("b", 2));
// 通知下游数据发送完成 后续数据不在接收
observableEmitter.onComplete();
}
});
}
1.不指定key,直接进行对象比较,过滤掉一个数据 {b,1}
getDistinctObservable().distinct()
.subscribe(new Consumer<DistinctBean>() {
@Override
public void accept(DistinctBean distinctBean) throws Exception {
Log.i(TAG, "accept: " + distinctBean.toString());
}
});
2.指定比较的key是name字段,过滤掉后两个数据
getDistinctObservable().distinct(new Function<DistinctBean, String>() {
@Override
public String apply(DistinctBean distinctBean) throws Exception {
return distinctBean.name;
}
}).subscribe(new Consumer<DistinctBean>() {
@Override
public void accept(DistinctBean distinctBean) throws Exception {
Log.i(TAG, "accept: " + distinctBean.toString());
}
});
filter
根据条件过滤掉无用数据。
public static void filter(){
getDistinctObservable().filter(new Predicate<DistinctBean>() {
@Override
public boolean test(DistinctBean distinctBean) throws Exception {
// true 通过筛选
return "b".equals(distinctBean.name);
}
}).subscribe(new Consumer<DistinctBean>() {
@Override
public void accept(DistinctBean distinctBean) throws Exception {
Log.i(TAG, "accept: " + distinctBean.toString());
}
});
}
buffer
分组截取,将上游发射器数据分组,新的发射器每次发射一组数据。
或者是一个参数,既:将上游的所有的数据缓存,之后按照参数一起发射(转成List<>)。
下例,每次游标滑动4,然后取后面的3个数为一个List发射。
结果为:[1,2,3] [5,6,7]
public static void buffer() {
Observable.just(1, 2, 3, 4, 5, 6, 7, 8)
.buffer(3, 4)
.subscribe(new Consumer<List<Integer>>() {
@Override
public void accept(List<Integer> integers) throws Exception {
Log.i(TAG, "accept: " + integers.toString());
}
});
}
skip/skipLast
舍弃一些数据后开始接收数据。从前/从后
public static void skip(){
Observable.just(1,2,3,4,5)
.skipLast(2)
// .skip(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
}
take/takeLast
只接收一定量的数据。从前/从后
public static void take(){
Observable.just(1,2,3,4,5,6)
.take(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer); // 结果 1 2
}
});
}
debounce/ThrottleWithTimeout
去抖动,覆盖掉间隔过短的数据,即有效数据为短间隔的后一个数据。
public static void debounce() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1); // 被覆盖
Thread.sleep(200);
emitter.onNext(2); // 接收
Thread.sleep(600);
emitter.onNext(3); // 被覆盖
Thread.sleep(300);
emitter.onNext(4); // 被覆盖
Thread.sleep(300);
emitter.onNext(5); // 接收
}
}).throttleWithTimeout(400, TimeUnit.MILLISECONDS)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer); // 结果 2 5
}
});
}
last
只接收最后一个数据,当没有数据时,发射传入的默认值。
public static void last() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onComplete();
}
}).last(3)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer); // 结果 3
}
});
}
reduce/scan
将数据按照方法依次两两操作,可以设置一个初始值。
reduce只关注结果的一次数据。
scan每一步的数据都发射一次。seed也会发射一次。
public static void reduce(){
Observable.just(1,2,3,4)
.reduce(2, new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
return integer + integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer); // 结果 12 scan结果:2 3 5 8 12
}
});
}
takeUntil
订阅并开始发射原始数据Observable,同时提供一个阀门Observable。如果阀门Observable发射了数据或者完成发送,数据Observable停止发射。
public static void takeUntil() {
// 数据Observable 200ms发射一次数据
// 阀门Observable 700ms发射数据,终止数据Observable
Observable.interval(200, TimeUnit.MILLISECONDS)
.takeUntil(Observable.timer(700, TimeUnit.MILLISECONDS))
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
// 结果返回数据 0 1 2
Log.i(TAG, "accept: " + aLong);
}
});
}
takeWhile
返回一个镜像原始Observable行为的Observable,直到某一项数据你指定的函数返回false
那一刻,这个新的Observable发射onCompleted
终止通知。
public static void takeWhile() {
Observable.just(1, 2, 3, 4, 5, 6)
.takeWhile(new Predicate<Integer>() {
@Override
public boolean test(Integer i) throws Exception {
// 数据大于等于5 停止数据流
return i < 5;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
// 返回数据 1 2 3 4
Log.i(TAG, "accept: " + integer);
}
});
}
compose
结构流、拆串。
和flatMap区别:
不同之处在于它
compose()
是更高级别的抽象:它在整个流上运行,而不是单独发出的item数据。更具体的说法:
compose()
是Observable<T>
从流中获取原始数据流的唯一方法。因此,影响整个流的操作(如subscribeOn()
和observeOn()
)需要使用compose()
。相反,如果你把
subscribeOn()
/observeOn()放在
中flatMap()
,它只会影响Observable
您创建的flatMap()
,但不是后续的流。
compose()
在创建Observable
流时立即执行,就像您已将运算符内联编写一样。flatMap()
在onNext()
每次调用它时调用它。换句话说,flatMap()
转换每个item数据,而compose()
转换整个流。
flatMap()
效率必然较低,因为Observable
每次onNext()
调用都必须创建一个新的。compose()
按原样在流上运行。如果要使用可重用代码替换某些运算符,请使用
compose()
。flatMap()
有很多用途,但这不是其中之一。
public static void compose() {
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.i(TAG, "subscribe: " + Thread.currentThread().getName());
emitter.onNext(1);
}
});
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: " + Thread.currentThread().getName());
}
};
ObservableTransformer<Integer, String> composer = new ObservableTransformer<Integer, String>() {
@Override
public ObservableSource<String> apply(Observable<Integer> upstream) {
return upstream.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
Log.i(TAG, "apply: " + Thread.currentThread().getName());
return "转换数据" + integer;
}
});
}
};
observable.compose(composer)
.subscribeOn(AndroidSchedulers.mainThread())
.observeOn(Schedulers.io())
.subscribe(consumer);
}