学习资料：
1. 辅助操作符
1.1 delay延迟
延迟发送接收到的每一个数据项，暂时一段时间再发送。最终，所有的数据项，整体向后延迟指定的时间段
1.1.1 delay(long,TimeUnit,Schedulers)
指定延迟的时间，单位
默认在computation调度器上执行
简单使用：
/**
* 指定延迟时间 ，单位 ， 调度线程
*/
private static void delayCount() {
Observable
.just(1,2,3)
.delay(3, TimeUnit.SECONDS, Schedulers.immediate())
.subscribe(System.out::println);
}
延迟3秒发送数据项，后一项依次延时3秒，当发送过3时，并不会立刻结束，也会延迟3秒后才结束
注意：delay不会延迟onError()通知，会立即将错误信号发送给订阅者，并将所有呆发射的onNext()通知全部丢弃。但delay会延迟onCompleted()通知
1.1.2 delay(Func1)
在Func1函数中返回一个新的Observable，这个新的Observable被当作原始Observable的延时定时器。当新的Observable被返回时，就会发射与之相关联的数据项
默认不在任何特定的线程执行，在默认线程
简单使用
/**
* Func1中的Observable当作延时定时器
*/
private static void delayFunc1() {
Observable
.just(1, 2, 3)
.delay(new Func1<Integer, Observable<Long>>() {
@Override
public Observable<Long> call(Integer integer) {
return Observable
.timer(1,TimeUnit.SECONDS,Schedulers.immediate());
// .flatMap(new Func1<Long, Observable<Integer>>() {
// @Override
// public Observable<Integer> call(Long aLong) {
// return Observable.just(integer + 10);//函数结果不会作用于原始数据项
// }
// });
}
})
.subscribe(System.out::println);
}
由于新的Observable只是当作一个定时器，在新的Observable中，再使用函数对原始数据项进行修改，无效
1.2 Do占位符
注册一个动作，作为原始Observable的生命周期
1.2.1 doOnNext(Action1)
注册一个回调，产生的Observable每发送出一个数据项，当触发onNext()时就会回调一次
可以考虑使用这个关键字来对网络请求结果进行缓存处理
doOnEach(Action1)则会在触发onNext(),onError(),onCompleted()时都进行回调
简单使用
/**
* 当产生的随机数大于 0.8 时 ，抛出异常
*/
private static void doOnNext() {
Observable
.just(1, 2, 3)
.doOnNext(new Action1<Integer>() {
@Override
public void call(Integer integer) {
if (Math.random() > 0.8)
throw new RuntimeException("throw Exception");
}
})
.subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println(e.getMessage());
}
@Override
public void onNext(Integer integer) {
System.out.println("This is --> " + integer);
}
});
}
doOnEach简单使用
private static void doOnEach() {
Observable
.just(1, 2, 3, 4)
.doOnEach(new Action1<Notification<? super Integer>>() {
@Override
public void call(Notification<? super Integer> notification) {
System.out.println(notification.getKind()
+ "---" + notification.getThrowable()
+ "---" + notification.getValue());
}
})
.subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println(e.getMessage());
}
@Override
public void onNext(Integer integer) {
System.out.println("This is --> " + integer);
}
});
}
运行结果：
OnNext---null---1
This is --> 1
OnNext---null---2
This is --> 2
OnNext---null---3
This is --> 3
OnNext---null---4
This is --> 4
OnCompleted---null---null
onCompleted
getKind()的值可以直接看作是触发信号
getThrowable()获取异常信息对象Throwable
getValue()值就是数据项
在输出结果的最后，当触发onCompleted()时，又进行了一次doOnEach()回调
1.2.2 doOnSubscribe(Action0)
当Observable订阅Observer之前，会回调doOnSubcribe()，默认在subscribe()订阅线程执行，但可以通过subscribeOn()来指定执行线程，受其后最近的一个subscribeOn()影响
简单使用：
private static void doOnSubscribe() {
Observable
.just(1,2,3,4)
.doOnSubscribe(new Action0() {
@Override
public void call() {
System.out.println("-1");
}
})
.subscribeOn(Schedulers.io())
.map(integer -> integer + 10)
.subscribeOn(Schedulers.immediate())
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.print(integer +", ");
}
}); }
运行结果：
-1
11, 12, 13, 14
1.2.3 doOnTerminate(Action0)
doOnTerminate订阅了一个动作后，当它产生的Observable终止之前会被调用，无论是正常还是异常终止
简单使用：
private static void doOnTerminate() {
Observable
.just(1, 2, 3, 4)
.map(integer -> {
if (Math.random() < 0.8)
return integer + 10;
else
throw new RuntimeException("Throw Exception");
})
.doOnTerminate(new Action0() {
@Override
public void call() {
System.out.println("doOnTerminate --> -1");
}
})
.subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println(e.getMessage());
}
@Override
public void onNext(Integer integer) {
System.out.println("This is --> " + integer);
}
});
}
无论是否抛出异常，都会在最终结束之前，输出打印doOnTerminate --> -1
1.3 TimeOut
原始Observable在指定的时间内没有发送任何数据项，就会发出onError()错误信号通知
简单使用：
/**
* 根据随机数，线程睡眠
*/
private static void timeoutLong() {
Observable
.interval(1, TimeUnit.SECONDS, Schedulers.immediate())
.map(aLong -> {
if (Math.random() > 0.8) {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return "This is -->" + aLong;
})
.timeout(2, TimeUnit.SECONDS)
.limit(5)
.subscribe(System.out::println);
}
1.4 ObserveOn和SubscribeOn
-
ObserveOn：指定观察者在哪个线程进行调度。可以理解为也就是指定onNext,onError,onCompleted执行的线程 -
SubscribeOn：指定Observable被观察者自身所在的线程。
注意：遇到异常时，ObserveOn会立刻发送onError通知，不会等待慢速消费的Observable接受任何之前已经收到但还没有发送出去的数据项。
2. 最后
本人很菜，有错误，请指出
共勉 ：）
