简单的发射方法：
情景：加入一个方法init非常耗时需要异步执行，并且后续操作需要等待init执行完后再去调用，原来的做法通常都是Handler+Thread的组合，RXjava方法如下。
private String getName() {
//比较费时间的操作
return "lc";
}
Observable.just(getName())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.d("ff", "value="+s);
}
});
Consumer 是缩减版的Observer,只接收onNext方法。
Observer 的构建:
Observer observer = new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Object o) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
};
时间操作符：
timer()：用于创建Observable，延迟发送一次。
interval()：用于创建Observable，跟TimerTask类似，用于周期性发送。
delay()：用于事件流中，可以延迟发送事件流中的某一次发送。 相当于map, flatmap。
延迟发射 timer：
Observable.timer(milliseconds, TimeUnit.MILLISECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable disposable) {
mDisposable=disposable;
}
@Override
public void onNext(@NonNull Long number) {
if(next!=null){
next.doNext(number);
}
}
@Override
public void onError(@NonNull Throwable e) {
//取消订阅
cancel();
}
@Override
public void onComplete() {
//取消订阅
cancel();
}
});
}
/**
* 取消订阅
*/
public static void cancel() {
if (mDisposable != null && !mDisposable.isDisposed()) {
mDisposable.dispose();
}
}
延迟发射 delay:
Observable.just(0L).doOnNext(new Consumer() {
@Override
public void accept(Long aLong) throws Exception {
Log.d("rx", "执行第一个任务");
}
}).delay(1000, TimeUnit.MILLISECONDS).subscribe(disposableObserver);
周期发射 interval：
情景：购买倒计时
DisposableObserver disposableObserver = getTimeDemoObserver();
Observable.interval(0, 1000, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.io()).subscribe(disposableObserver);
拦截错误并且重试的操作符：
retry(): 让被观察者重新发射数据，要是一直错误就一直发送了
retry(BiPredicate)： interger是第几次重新发送，Throwable是错误的内容
retry(long time): 最多让被观察者重新发射数据多少次
retry(long time,Predicate predicate)： 最多让被观察者重新发射数据多少次，在predicate里面进行判断拦截 返回是否继续
使用情景：如果一个方法出错，我们会希望给它几次机会，如果给完机会也不中用的话，就会做一些处理。
例如下面的样例的执行顺序：
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
for (int i = 0; i <= 3; i++) {
if (i == 2) {
e.onError(new Exception("出现错误了"));
} else {
e.onNext(i + "");
}
try {
Thread.sleep(1000);
} catch (Exception ex) {
ex.printStackTrace();
}
}
e.onComplete();
}
})
.subscribeOn(Schedulers.newThread())
.retry(3, new Predicate() {
@Override
public boolean test(@NonNull Throwable throwable) throws Exception {
Log.e(TAG, "retry错误: " + throwable.toString());
//最多让被观察者重新发射数据3次，但是这里返回值可以进行处理
//返回假就是不让重新发射数据了，调用观察者的onError就终止了。
//返回真就是让被观察者重新发射请求
return true;
}
})
.subscribe(new Consumer() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.e(TAG, "收到消息: " + s);
}
}, new Consumer() {
@Override
public void accept(@NonNull Throwable throwable) throws Exception {
Log.e(TAG, "结果错误: " + throwable.toString());
}
});
12-10 17:55:12.645 18650 18671 E rx : 收到消息: 0
12-10 17:55:13.645 18650 18671 E rx : 收到消息: 1
12-10 17:55:14.645 18650 18671 E rx : retry错误: java.lang.Exception: 出现错误了
12-10 17:55:14.645 18650 18686 E rx : 收到消息: 0
12-10 17:55:15.645 18650 18686 E rx : 收到消息: 1
12-10 17:55:16.655 18650 18686 E rx : retry错误: java.lang.Exception: 出现错误了
12-10 17:55:16.665 18650 18688 E rx : 收到消息: 0
12-10 17:55:17.675 18650 18688 E rx : 收到消息: 1
12-10 17:55:18.675 18650 18688 E rx : retry错误: java.lang.Exception: 出现错误了
12-10 17:55:18.675 18650 18689 E rx : 收到消息: 0
12-10 17:55:19.675 18650 18689 E rx : 收到消息: 1
12-10 17:55:20.685 18650 18689 E rx : 结果错误: java.lang.Exception: 出现错误了
执行指定次数后，会抛到onError里面处理。
retry(retry(Predicate predicate)):
在predicate里面进行判断拦截 返回是否继续
和rxjava2中的retryUntil操作符用法类似
.subscribeOn(Schedulers.newThread())
/*.retry(new Predicate() {
@Override
public boolean test(@NonNull Throwable throwable) throws Exception {
Log.e(TAG, "retry错误: "+throwable.toString());
//返回假就是不让重新发射数据了，调用观察者的onError就终止了。
//返回真就是让被观察者重新发射请求
return true;
}
})*/
错误处理操作符:
onErrorReturn():
让Observable遇到错误时发射一个特殊的项并且正常终止，onErrorRetrun能够捕获在它之前发生的异常，它之后流中的操作发生的异常就它就不会管了。
Observable.just(getName())
.map(new Function() {
@Override
public String apply(String s) throws Exception {
return s + ": age=18";
}
})
.map(new Function() {
@Override
public Object apply(String s) throws Exception {
throw new NullPointerException();
}
})
.subscribeOn(Schedulers.io())
.onErrorReturn(new Function() {
@Override
public String apply(@NonNull Throwable throwable) throws Exception {
Log.d("rx", "onErrorReturn");
return "1";
}
}).map(new Function() {
@Override
public String apply(Object o) throws Exception {
throw new NullPointerException();
}
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe(observer);
onErrorResumeNext() 拦截之前的错误，并且返回一个Observable:
和onErrorReturn不同的是，拦截错误后返回的是Observable
.subscribeOn(Schedulers.newThread())
.onErrorResumeNext(new Function>() {
@Override
public ObservableSource apply(@NonNull Throwable throwable) throws Exception {
//拦截到错误之后，重新定义了被观察者
return Observable.just("重新定义了被观察者");
}
})
.subscribe(new Consumer() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.e(TAG, "收到消息: " + s);
}
}, new Consumer() {
@Override
public void accept(@NonNull Throwable throwable) throws Exception {
Log.e(TAG, "结果错误: " + throwable.toString());
}
});
onExceptionResumeNext :拦截的错误是Exception,不能拦截Throwable:
如果onErrorResumeNext收到的Throwable不是一个Exception，它会将错误传递给观察者的onError方法，onExceptionResumeNext则会继续拦截。
.subscribeOn(Schedulers.newThread())
.onExceptionResumeNext(new Observable() {
@Override
protected void subscribeActual(Observer observer) {
observer.onNext("错误替换的消息");
observer.onComplete();
}
})
.subscribe(new Consumer() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.e(TAG, "收到消息: " + s);
}
}, new Consumer() {
@Override
public void accept(@NonNull Throwable throwable) throws Exception {
Log.e(TAG, "结果错误: " + throwable.toString());
}
});