被观察者:Observable (可以想象成一个button) 创建包括:
1.Observable.just("Hello", "World")
2. 2.String [] words = {"Hello", "World"};Observable observable3 = Observable.from(words);
3.List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
Observable observable4 = Observable.from(list);
观察者:Observer Subscriber Action0 Action1 Func1(可以想象成onclicklistener)
观察者各区别:
1.Observer 和Subscriber(都有onNext,onError onCompleted())
Subscriber新增onStart()和unsubscribe()
onstart:可以用于做一些准备工作,例如数据的清零或重置
unsubscribe():用于取消订阅
2.Action0 和Action1(比较简洁,只有一个call方法,都无返回)
Action0无参无返回 Action1有参无返回
3.Action和Func1的区别:
无返回和有返回。
操作符分类
按照官方的分类,操作符大致分为以下几种:
- Creating Observables(Observable的创建操作符),比如:Observable.create()、Observable.just()、Observable.from()等等;
- Transforming Observables(Observable的转换操作符),比如:observable.map()、observable.flatMap()、observable.buffer()等等;
- Filtering Observables(Observable的过滤操作符),比如:observable.filter()、observable.sample()、observable.take()等等;
- Combining Observables(Observable的组合操作符),比如:observable.join()、observable.merge()、observable.combineLatest()等等;
- Error Handling Operators(Observable的错误处理操作符),比如:observable.onErrorResumeNext()、observable.retry()等等;
- Observable Utility Operators(Observable的功能性操作符),比如:observable.subscribeOn()、observable.observeOn()、observable.delay()等等;
- Conditional and Boolean Operators(Observable的条件操作符),比如:observable.amb()、observable.contains()、observable.skipUntil()等等;
- Mathematical and Aggregate Operators(Observable数学运算及聚合操作符),比如:observable.count()、observable.reduce()、observable.concat()等等;
- 其他如observable.toList()、observable.connect()、observable.publish()等等;
1.创建型操作符
create操作符
create操作符是所有创建型操作符的“根”,也就是说其他创建型操作符最后都是通过create操作符来创建Observable的,其流程图例如下:
Observable.create(
newObservable.OnSubscribe<Integer>() {
@Override
publicvoidcall
(Subscriber<?
superInteger> observer) {
try
{
if
(!observer.isUnsubscribed()) {
for
(
inti =
1; i <
5; i++) {
observer.onNext(i);
}
observer.onCompleted();
}
}
catch(Exception e) {
observer.onError(e);
}
}
} ).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下: Next: 1 Next: 2 Next: 3 Next: 4 Sequence complete.
在使用create操作符时,最好要在回调的call函数中增加isUnsubscribed的判断,以便在subscriber在取消订阅时不会再执行call函数中相关代码逻辑,从而避免导致一些意想不到的错误出现;
from操作符
from操作符是把其他类型的对象和数据类型转化成Observable,其流程图例如下:
调用例子如下:
Integer[] items = {
0,
1,
2,
3,
4,
5};
Observable myObservable = Observable.
from(items);
myObservable.subscribe(
new
Action1<Integer>() {
@Override
publicvoidcall
(Integer item) {
System.
out.println(item);
}
},
new
Action1<Throwable>() {
@Override
publicvoidcall
(Throwable error) {
System.
out.println(
"Error encountered: "+ error.getMessage());
}
},
new
Action0() {
@Override
publicvoidcall
() {
System.
out.println(
"Sequence complete");
}
}
);
运行结果如下: 0 1 2 3 4 5 Sequence complete
调用例子如下:
Observable.just(
1,
2,
3)
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
just操作符
just操作符也是把其他类型的对象和数据类型转化成Observable,它和from操作符很像,只是方法的参数有所差别
调用例子如下:
Observable.just(
1,
2,
3)
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
defer操作符
defer操作符是直到有订阅者订阅时,才通过Observable的工厂方法创建Observable并执行,defer操作符能够保证Observable的状态是最新的
i=
10;
Observable justObservable = Observable.just(i);
i=
12;
Observable deferObservable = Observable.defer(
newFunc0<Observable<Object>>() {
@Override
public
Observable<Object>
call() {
return
Observable.just(i);
}
});
i=
15;
justObservable.subscribe(
newSubscriber() {
@Override
publicvoidonCompleted
() {
}
@Override
publicvoidonError
(Throwable e) {
}
@Override
publicvoidonNext
(Object o) {
System.out.println(
"just result:"+ o.toString());
}
});
deferObservable.subscribe(
newSubscriber() {
@Override
publicvoidonCompleted
() {
}
@Override
publicvoidonError
(Throwable e) {
}
@Override
publicvoidonNext
(Object o) {
System.out.println(
"defer result:"+ o.toString());
}
});
}
Just输出10
Defer输出15
timer操作符
timer操作符是创建一串连续的数字,产生这些数字的时间间隔是一定的
一种是隔一段时间产生一个数字,然后就结束,可以理解为延迟产生数字
一种是每隔一段时间就产生一个数字,没有结束符,也就是是可以产生无限个连续的数字
//每隔两秒产生一个数字
Observable.timer(
2,
2, TimeUnit.SECONDS).subscribe(
newSubscriber<Long>() {
@Override
publicvoidonCompleted
() {
System.
out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.
out.println(
"error:"+ e.getMessage());
}
@Override
publicvoidonNext
(Long aLong) {
System.
out.println(
"Next:"+ aLong.toString());
}
});
运行结果如下:
Next:0
Next:1
Next:2
Next:3
interval操作符
interval操作符是每隔一段时间就产生一个数字,这些数字从0开始,一次递增1直至无穷大;interval操作符的实现效果跟上面的timer操作符的第二种情形一样
调用例子同上
range操作符
range操作符是创建一组在从n开始,个数为m的连续数字,比如range(3,10),就是创建3、4、5…12的一组数字,其流程实例如下
//产生从3开始,个数为10个的连续数字
Observable.range(
3,
10).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.
out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.
out.println(
"error:"+ e.getMessage());
}
@Override
publicvoidonNext
(Integer i) {
System.
out.println(
"Next:"+ i.toString());
}
});
repeat/repeatWhen操作符
repeat操作符是对某一个Observable,重复产生多次结果
repeatWhen操作符是对某一个Observable,有条件地重新订阅从而产生多次结果,其流程实例如下
repeat调用例子如下:
//连续产生两组(3,4,5)的数字
Observable.range(
3,
3).repeat(
2).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.
out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.
out.println(
"error:"+ e.getMessage());
}
@Override
publicvoidonNext
(Integer i) {
System.
out.println(
"Next:"+ i.toString());
}
});
Next:3
Next:4
Next:5
Next:3
Next:4
Next:5
Sequence complete.
repeatWhen调用例子如下
Observable
.just(
1,
2,
3).repeatWhen(
new Func1<Observable<? extends Void>, Observable<?>>() {
@Override
public
Observable<?>
call(Observable<? extends Void> observable) {
//重复3次
return
observable.zipWith(Observable.range(
1,
3),
newFunc2<Void, Integer, Integer>() {
@Override
public
Integer
call(Void aVoid, Integer integer) {
return
integer;
}
}).flatMap(
newFunc1<Integer, Observable<?>>() {
@Override
public
Observable<?>
call(Integer integer) {
System.out.println(
"delay repeat the "+ integer +
" count");
//1秒钟重复一次
return
Observable.timer(
1, TimeUnit.SECONDS);
}
});
}
}).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Integer value) {
System.out.println(
"Next:"+ value);
}
});
运行结果如下: Next:1 Next:2 Next:3 repeat the 1 count Next:1 Next:2 Next:3 repeat the 2 count Next:1 Next:2 Next:3 repeat the 3 count Next:1 Next:2 Next:3 Sequence complete.
2.TransformingObservables(Observable的转换操作符)
Buffer操作符
buffer操作符周期性地收集源Observable产生的结果到列表中,并把这个列表提交给订阅者,订阅者处理后,清空buffer列表,同时接收下一次收集的结果并提交给订阅者,周而复始
调用例子如下:
//定义邮件内容
//每隔1秒就随机发布一封邮件
Observable<String> endlessMail = Observable.create(
newObservable.OnSubscribe<String>() {
@Override
publicvoidcall
(Subscriber<?
superString> subscriber) {
try
{
if
(subscriber.isUnsubscribed())
return;
Random random =
newRandom();
while
(
true) {
String mail mails[random.nextInt(mails.length)];
subscriber.onNext(mail);
Thread.sleep(
1000);
}
}
catch(Exception ex) {
subscriber.onError(ex);
}
}
}).subscribeOn(Schedulers.io());
//把上面产生的邮件内容缓存到列表中,并每隔3秒通知订阅者
endlessMail.buffer(
3, TimeUnit.SECONDS).subscribe(
newAction1<List<String>>() {
@Override
publicvoidcall
(List<String> list) {
System.out.println(String.format(
"You've got %d new messages! Here they are!", list.size()));
for
(
inti =
0; i < list.size(); i++)
System.out.println(
"**"+ list.get(i).toString());
}
});
运行结果如下:
You’ve got 3 new messages! Here they are!(after 3s)
**Here is an email!
**Another email!
**Another email!
You’ve got 3 new messages! Here they are!(after 6s)
**Here is an email!
**Another email!
**Here is an email!
map操作符
map操作符是把源Observable产生的结果,通过映射规则转换成另一个结果集,并提交给订阅者进行处理。
map操作符的流程图如下:
调用例子如下:
Observable
.just(
1,
2,
3,
4,
5,
6)
.map(
newFunc1
<Integer,
Integer>() {
@Override
public
String call(
Integerinteger) {
//对源Observable产生的结果,都统一乘以3处理
return
Sting.valueof
}
})
.subscribe(
newAction1
<Integer>() {
@Override
publicvoid
call(
String integer) {
System
.out
.println(
"next:"+integer);
}
});
运行结果如下:
next:3
next:6
next:9
next:12
next:15
next:18
flatMap操作符
flatMap操作符是把Observable产生的结果转换成多个Observable,然后把这多个Observable“扁平化”成一个Observable,并依次提交产生的结果给订阅者。
flatMap操作符通过传入一个函数作为参数转换源Observable,在这个函数中,你可以自定义转换规则,最后在这个函数中返回一个新的Observable,然后flatMap操作符通过合并这些Observable结果成一个Observable,并依次提交结果给订阅者。
值得注意的是,flatMap操作符在合并Observable结果时,有可能存在交叉的情况,。,
假设有一个id数组,通过每一个id数组去获取数据返回observable<Object>
如果是map 返回值只能是一个Object
二者的区别
调用例子如下:
ApiManger.getState()
.flatMap(newFunc1<StateModel, Observable<ChargeModel>>() {
@Override
publicObservable<ChargeModel> call(StateModel stateModel) {
returnstateModel.getState() != 1? Observable.empty() : apiManger.getCharge();
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(newSubscriber<ChargeNodel>() {
@Override
public void onCompleted() {
//hideLoading();
}
@Override
public voidonError(Throwable e) {
//hideLoading();
}
@Override
public voidonNext(ChargeModel chargeModel) {
//充电
}
});
flatMap操作符
privateObservable<File>
listFiles(File f){
if
(f.isDirectory()){
return
Observable.from(f.listFiles).flatMap(
newFunc1<File, Observable<File>>() {
@Override
public
Observable<File>
call(File file) {
return
listFiles(f);
}
});
}
else{
return
Observable.just(f);
}
}
@Override
publicvoidonClick
(View v) {
Observable.just(getApplicationContext().getExternalCacheDir())
.flatMap(
newFunc1<File, Observable<File>>() {
@Override
public
Observable<File>
call(File file) {
//参数file是just操作符产生的结果,这里判断file是不是目录文件,如果是目录文件,则递归查找其子文件flatMap操作符神奇的地方在于,返回的结果还是一个Observable,而这个Observable其实是包含多个文件的Observable的,输出应该是ExternalCacheDir下的所有文件
return
listFiles(file);
}
})
.subscribe(
newAction1<File>() {
@Override
publicvoidcall
(File file)
System.out.println(file.getAbsolutePath());
}
});
}
concatMap操作符
ConcatMap操作符与flatMap操作符类似,都是把Observable产生的结果转换成多个Observable,然后把这多个Observable“扁平化”成一个Observable,并依次提交产生的结果给订阅者。
与flatMap操作符不同的是,concatMap操作符在处理产生的Observable时,采用的是“连接(concat)”的方式,而不是“合并(merge)”的方式,这就能保证产生结果的顺序性,也就是说提交给订阅者的结果是按照顺序提交的,不会存在交叉的情况。
concatMap的调用例子与flatMap类似,这里不做重复
switchMap操作符
switchMap操作符与flatMap操作符类似,都是把Observable产生的结果转换成多个Observable,然后把这多个Observable“扁平化”成一个Observable,并依次提交产生的结果给订阅者。
与flatMap操作符不同的是,switchMap操作符会保存最新的Observable产生的结果而舍弃旧的结果,举个例子来说,比如源Observable产生A、B、C三个结果,通过switchMap的自定义映射规则,映射后应该会产生A1、A2、B1、B2、C1、C2,但是在产生B2的同时,C1已经产生了,这样最后的结果就变成A1、A2、B1、C1、C2,B2被舍弃掉了!流程图如下:
以下是flatMap、concatMap和switchMap的运行实例对比:
//flatMap操作符的运行结果
Observable.just(
10,
20,
30).flatMap(
newFunc1<Integer, Observable<Integer>>() {
@Override
public
Observable<Integer>
call(Integer integer) {
//10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
int
delay =
200;
if
(integer >
10)
delay =
180;
return
Observable.
from(
newInteger[]{integer, integer /
2}).delay(delay, TimeUnit.MILLISECONDS);
}
}).observeOn(AndroidSchedulers.mainThread()).subscribe(
newAction1<Integer>() {
@Override
publicvoidcall
(Integer integer) {
System.
out.println(
"flatMap Next:"+ integer);
}
});
//concatMap操作符的运行结果
Observable.just(
10,
20,
30).concatMap(
newFunc1<Integer, Observable<Integer>>() {
@Override
public
Observable<Integer>
call(Integer integer) {
//10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
int
delay =
200;
if
(integer >
10)
delay =
180;
return
Observable.
from(
newInteger[]{integer, integer /
2}).delay(delay, TimeUnit.MILLISECONDS);
}
}).observeOn(AndroidSchedulers.mainThread()).subscribe(
newAction1<Integer>() {
@Override
publicvoidcall
(Integer integer) {
System.
out.println(
"concatMap Next:"+ integer);
}
});
//switchMap操作符的运行结果
Observable.just(
10,
20,
30).switchMap(
newFunc1<Integer, Observable<Integer>>() {
@Override
public
Observable<Integer>
call(Integer integer) {
//10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
int
delay =
200;
if
(integer >
10)
delay =
180;
return
Observable.
from(
newInteger[]{integer, integer /
2}).delay(delay, TimeUnit.MILLISECONDS);
}
}).observeOn(AndroidSchedulers.mainThread()).subscribe(
newAction1<Integer>() {
@Override
publicvoidcall
(Integer integer) {
System.
out.println(
"switchMap Next:"+ integer);
}
});
groupBy操作符
groupBy操作符是对源Observable产生的结果进行分组,形成一个类型为GroupedObservable的结果集,GroupedObservable中存在一个方法为getKey(),可以通过该方法获取结果集的Key值(类似于HashMap的key)。
值得注意的是,由于结果集中的GroupedObservable是把分组结果缓存起来,如果对每一个GroupedObservable不进行处理(既不订阅执行也不对其进行别的操作符运算),就有可能出现内存泄露。因此,如果你对某个GroupedObservable不进行处理,最好是对其使用操作符take(0)处理。
调用例子如下:
Observable.interval(
1, TimeUnit.SECONDS).take(
10).groupBy(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long
value) {
//按照key为0,1,2分为3组
returnvalue
%
3;//%N
就是分成
N
份
}
}).subscribe(
newAction1<GroupedObservable<Long, Long>>() {
@Override
publicvoidcall
(GroupedObservable<Long, Long> result) {
result.subscribe(
newAction1<Long>() {
@Override
publicvoidcall
(Long
value) {
System.
out.println(
"key:"+ result.getKey() +
", value:"+
value);
}
});
}
});
运行结果如下:
Next:key 0 value0
Next:key 0 value1
Next:key 0 value2
cast操作符
cast操作符类似于map操作符,不同的地方在于map操作符可以通过自定义规则,把一个值A1变成另一个值A2,A1和A2的类型可以一样也可以不一样;而cast操作符主要是做类型转换的,传入参数为类型class,如果源Observable产生的结果不能转成指定的class,则会抛出ClassCastException运行时异常
Observable.just(
1,
2,
3,
4,
5,
6).cast(String.class).subscribe(
newAction1<Integer>() {
@Override
publicvoidcall
(Integer
value) {
System.
out.println(
"next:"+
value);
}
});
运行结果如下:
next:1
next:2
next:3
next:4
next:5
next:6
scan操作符
scan操作符通过遍历源Observable产生的结果,依次对每一个结果项按照指定规则进行运算,计算后的结果作为下一个迭代项参数,每一次迭代项都会把计算结果输出给订阅者。
Observable.just(
“
1”
,
“
2
”
,
“
3
”
,
“
4
”
,
“
5
”
)
//
第一次运行会略过
.scan(
newFunc2<Integer, Integer, String>() {
@Override
public
String
call(Integer sum, Integer item) {
//参数sum就是上一次的计算结果,第一次不执行运算
return
sum + item;
}
}).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 1
Next: 3
Next: 6
Next: 10
Next: 15
如果将+换成*得出结果
Next: 1
Next: 2
Next: 6
Next: 24
Next: 120
Sequence complete.
window操作符
window操作符非常类似于buffer操作符,区别在于buffer操作符产生的结果是一个List缓存,而window操作符产生的结果是一个Observable,订阅者可以对这个结果Observable重新进行订阅处理。
window操作符有很多个重载方法,这里只举一个简单的例子,其流程图如下:
调用例子:
Observable.interval(
1, TimeUnit
.SECONDS)
.take(
12)
.window
(
3, TimeUnit
.SECONDS)
.subscribe
(new Action1<Observable<Long>>() {
@Override
public void
call(Observable<Long> observable) {
System
.out.println(
"subdivide begin......")
;
observable
.subscribe(new Action1<Long>() {//
重新订阅
@Override
public void
call(Long aLong) {
System
.out.println(
"Next:"+ aLong)
;
}
})
;
}
})
;
运行结果如下:
subdivide begin……
Next:0
Next:1
subdivide begin……
Next:2
Next:3
Next:4
subdivide begin……
Next:5
Next:6
Next:7
subdivide begin……
Next:8
Next:9
Next:10
subdivide begin……
Next:11
3.Filtering Observables(Observable的过滤操作符)
debounce操作符
调用例子如下:
Observable.create(
newObservable.OnSubscribe<Integer>() {
@Override
publicvoidcall
(Subscriber<?
superInteger> subscriber) {
if
(subscriber.isUnsubscribed())
return;
try
{
//产生结果的间隔时间分别为100、200、300...900毫秒
for
(
inti =
1; i <
10; i++) {
subscriber.onNext(i);
Thread.sleep(i *
100);
}
subscriber.onCompleted();
}
catch(Exception e){
subscriber.onError(e);
}
}
}).subscribeOn(Schedulers.newThread())
//
采集在一定时间内产生的数据
.debounce(
400, TimeUnit.MILLISECONDS)
//超时时间为400毫秒
.subscribe(
new
Action1<Integer>() {
@Override
publicvoidcall
(Integer integer) {
System.out.println(
"Next:"+ integer);
}
},
newAction1<Throwable>() {
@Override
publicvoidcall
(Throwable throwable) {
System.out.println(
"Error:"+ throwable.getMessage());
}
},
newAction0() {
@Override
publicvoidcall
() {
System.out.println(
"completed!");
}
});
运行结果如下: Next:4 Next:5 Next:6 Next:7 Next:8 Next:9 completed!
distinct操作符
distinct操作符对源Observable产生的结果进行过滤,把重复的结果过滤掉,只输出不重复的结果给订阅者,非常类似于SQL里的distinct关键字
调用例子如下:
Observable.just(
1,
2,
1,
1,
2,
3)
.distinct()
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 1
Next: 2
Next: 3
Sequence complete.
elementAt操作符
elementAt操作符在源Observable产生的结果中,仅仅把指定索引的结果提交给订阅者,索引是从0开始的。
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6).elementAt(
2)
.subscribe(
new
Action1<Integer>() {
@Override
publicvoidcall
(Integer integer) {
System.
out.println(
"Next:"+ integer);
}
},
newAction1<Throwable>() {
@Override
publicvoidcall
(Throwable throwable) {
System.
out.println(
"Error:"+ throwable.getMessage());
}
},
newAction0() {
@Override
publicvoidcall
() {
System.
out.println(
"completed!");
}
});
运行结果如下:
Next:3
completed!
filter操作符
filter操作符是对源Observable产生的结果按照指定条件进行过滤,只有满足条件的结果才会提交给订阅者
调用例子如下:
Observable.just(
1,
2,
3,
4,
5)
.filter(
newFunc1<Integer, Boolean>() {
@Override
public
Boolean
call(Integer item) {
return
( item <
4);
}
}).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 1
Next: 2
Next: 3
Sequence complete.
ofType操作符
ofType操作符类似于filter操作符,区别在于ofType操作符是按照类型对结果进行过滤,
调用例子如下:
Observable.just(
1,
"hello world",
true,
200L,
0.23f)
.ofType(Float.class)
.subscribe(
newSubscriber<Object>() {
@Override
publicvoidonNext
(Object item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 0.23
Sequence complete.
first操作符
first操作符是把源Observable产生的结果的第一个提交给订阅者,first操作符可以使用elementAt(0)和take(1)替代。
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6,
7,
8)
.first()
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 1
Sequence complete.
single操作符
single操作符是对源Observable的结果进行判断,如果产生的结果满足指定条件的数量不为1,则抛出异常,否则把满足条件的结果提交给订阅者,
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6,
7,
8,11)
.single(
newFunc1<Integer, Boolean>() {
@Override
public
Boolean
call(Integer integer) {
//取大于10的第一个数字
return
integer>
10;
}
})
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Error: Sequence contains no elements
last操作符
last操作符把源Observable产生的结果的最后一个提交给订阅者,last操作符可以使用takeLast(1)替代。
调用例子如下:
Observable.just(
1,
2,
3)
.last()
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 3
Sequence complete.
ignoreElements操作符
ignoreElements操作符忽略所有源Observable产生的结果,只把Observable的onCompleted和onError事件通知给订阅者。ignoreElements操作符适用于不太关心Observable产生的结果,只是在Observable结束时(onCompleted)或者出现错误时能够收到通知。
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6,
7,
8).ignoreElements()
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Sequence complete.
sample操作符
sample操作符定期扫描源Observable产生的结果,在指定的时间间隔范围内对源Observable产生的结果进行采样。
调用例子如下:
Observable.create(
newObservable.OnSubscribe<Integer>() {
@Override
publicvoidcall
(Subscriber<?
superInteger> subscriber) {
if
(subscriber.isUnsubscribed())
return;
try
{
//前8个数字产生的时间间隔为1秒,后一个间隔为3秒
for
(
inti =
1; i <
9; i++) {
subscriber.onNext(i);
Thread.sleep(
1000);
}
Thread.sleep(
2000);
subscriber.onNext(
9);
subscriber.onCompleted();
}
catch(Exception e){
subscriber.onError(e);
}
}
}).subscribeOn(Schedulers.newThread())
.sample(
2200, TimeUnit.MILLISECONDS)
//采样间隔时间为2200毫秒
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 3
Next: 5
Next: 7
Next: 8
Sequence complete.
skip操作符
skip操作符针对源Observable产生的结果,跳过前面n个不进行处理,而把后面的结果提交给订阅者处理,
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6,
7).skip(
3)
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 4
Next: 5
Next: 6
Next: 7
Sequence complete.
skipLast操作符
skipLast操作符针对源Observable产生的结果,忽略Observable最后产生的n个结果,而把前面产生的结果提交给订阅者处理,
可以看到skipLast操作符把最后的天蓝色球、蓝色球、紫色球忽略掉了,但是前面的红色球等并不是源Observable一产生就直接提交给订阅者,这里有一个延迟的效果
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6,
7).skipLast(
3)
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下:
Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.
take操作符
take操作符是把源Observable产生的结果,提取前面的n个提交给订阅者,而忽略后面的结果
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6,
7,
8)
.take(
4)
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下: Next: 1 Next: 2 Next: 3 Next: 4 Sequence complete.
takeFirst操作符
takeFirst操作符类似于take操作符,同时也类似于first操作符,都是获取源Observable产生的结果列表中符合指定条件的前一个或多个,与first操作符不同的是,first操作符如果获取不到数据,则会抛出NoSuchElementException异常,而takeFirst则会返回一个空的Observable,该Observable只有onCompleted通知而没有onNext通知。
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6,
7).takeFirst(
newFunc1<Integer, Boolean>() {
@Override
public
Boolean
call(Integer integer) {
//获取数值大于3的数据
return
integer>
3;
}
})
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下: Next: 4 Sequence complete.
takeLast操作符
takeLast操作符是把源Observable产生的结果的后n项提交给订阅者,提交时机是Observable发布onCompleted通知之时。
调用例子如下:
Observable.just(
1,
2,
3,
4,
5,
6,
7).takeLast(
2)
.subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonNext
(Integer item) {
System.out.println(
"Next: "+ item);
}
@Override
publicvoidonError
(Throwable error) {
System.err.println(
"Error: "+ error.getMessage());
}
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
});
运行结果如下: Next: 6 Next: 7 Sequence complete.
4.CombiningObservables(Observable的组合操作符)
combineLatest操作符
combineLatest操作符把两个Observable产生的结果进行合并,合并的结果组成一个新的Observable。这两个Observable中任意一个Observable产生的结果,都和另一个Observable最后产生的结果,按照一定规则拼接
调用例子如下:
//产生0,5,10,15,20数列
Observable<Long> observable1 = Observable.timer(
0,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
5;
}
}).take(
5);
//产生0,10,20,30,40数列
Observable<Long> observable2 = Observable.timer(
500,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
10;
}
}).take(
5);
Observable.combineLatest(observable1, observable2,
newFunc2<Long, Long, Long>() {
@Override
public
Long
call(Long aLong, Long aLong2) {
return
aLong+aLong2;
}
}).subscribe(
newSubscriber<Long>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Long aLong) {
System.out.println(
"Next: "+ aLong);
}
});
运行结果如下:(observable1
的
1
、
2
和
observable2
的
1
,
observable1
的
2
、
3
和
observable2
的
2
以此类推
)
Next: 0
Next: 5
Next: 15
Next: 20
Next: 30
Next: 35
Next: 45
Next: 50
Next: 60
Sequence complete.
join操作符
join操作符把类似于combineLatest操作符,也是两个Observable产生的结果进行合并,合并的结果组成一个新的Observable,但是join操作符可以控制每个Observable产生结果的生命周期,在每个结果的生命周期内,可以与另一个Observable产生的结果按照一定的规则进行合并(与combineLatest相比只是通过observable多处理了一层,所以说可以控制生命周期(delay操作符))
第四个参数的Func的参数是以Long的形式
join方法的用法如下:
observableA.join(observableB,
observableA产生结果生命周期控制函数,
observableB产生结果生命周期控制函数,
observableA产生的结果与observableB产生的结果的合并规则)
调用例子如下:
//产生0,5,10,15,20数列
Observable<Long> observable1 = Observable.timer(
0,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
5;
}
}).take(
5);
//产生0,10,20,30,40数列
Observable<Long> observable2 = Observable.timer(
500,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
10;
}
}).take(
5);
observable1.join(observable2,
newFunc1<Long, Observable<Long>>() {
@Override
public
Observable<Long>
call(Long aLong) {
//使Observable延迟600毫秒执行
return
Observable.just(aLong).delay(
600, TimeUnit.MILLISECONDS);
}
},
newFunc1<Long, Observable<Long>>() {
@Override
public
Observable<Long>
call(Long aLong) {
//使Observable延迟600毫秒执行
return
Observable.just(aLong).delay(
600, TimeUnit.MILLISECONDS);
}
},
newFunc2<Long, Long, Long>() {
@Override
public
Long
call(Long aLong, Long aLong2) {
return
aLong + aLong2;
}
}).subscribe(
newSubscriber<Long>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Long aLong) {
System.out.println(
"Next: "+ aLong);
}
});
运行结果如下: Next: 0 Next: 5 Next: 15 Next: 20 Next: 30 Next: 35 Next: 45 Next: 50 Next: 60 Sequence complete.
groupJoin操作符
groupJoin操作符非常类似于join操作符,区别在于join操作符中第四个参数的传入函数不一致(第四个参数的Func的参数是以Observable的形式)
调用例子如下:
//产生0,5,10,15,20数列
Observable<Long> observable1 = Observable.timer(
0,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
5;
}
}).take(
5);
//产生0,10,20,30,40数列
Observable<Long> observable2 = Observable.timer(
500,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
10;
}
}).take(
5);
observable1.groupJoin(observable2,
newFunc1<Long, Observable<Long>>() {
@Override
public
Observable<Long>
call(Long aLong) {
return
Observable.just(aLong).delay(
1600, TimeUnit.MILLISECONDS);
}
},
newFunc1<Long, Observable<Long>>() {
@Override
public
Observable<Long>
call(Long aLong) {
return
Observable.just(aLong).delay(
600, TimeUnit.MILLISECONDS);
}
},
newFunc2<Long, Observable<Long>, Observable<Long>>() {
@Override
public
Observable<Long>
call(Long aLong, Observable<Long> observable) {
return
observable.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong2) {
return
aLong + aLong2;
}
});
}
}).subscribe(
newSubscriber<Observable<Long>>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Observable<Long> observable) {
observable.subscribe(
newSubscriber<Long>() {
@Override
publicvoidonCompleted
() {
}
@Override
publicvoidonError
(Throwable e) {
}
@Override
publicvoidonNext
(Long aLong) {
System.out.println(
"Next: "+ aLong);
}
});
}
});
运行结果如下:
Next: 0
Next: 5
Next: 10
Next: 15
Next: 20
Next: 25
Next: 30
Next: 35
Next: 40
Next: 45
Next: 50
Next: 60
Next: 55
Sequence complete.
merge操作符(发生错误时中断。)
merge操作符是按照两个Observable提交结果的时间顺序,对Observable进行合并,如ObservableA每隔500毫秒产生数据为0,5,10,15,20;而ObservableB每隔500毫秒产生数据0,10,20,30,40,其中第一个数据延迟500毫秒产生,最后合并结果为:0,0,5,10,10,20,15,30,20,40;其流程图如下
调用例子如下:
//产生0,5,10,15,20数列
Observable<Long> observable1 = Observable.timer(
0,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
5;
}
}).take(
5);
//产生0,10,20,30,40数列
Observable<Long> observable2 = Observable.timer(
500,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
10;
}
}).take(
5);
Observable.merge(observable1, observable2)
.subscribe(
newSubscriber<Long>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Long aLong) {
System.out.println(
"Next:"+ aLong);
}
});
运行结果如下:
Next:0
Next:0
Next:5
Next:10
Next:10
Next:20
Next:15
Next:30
Next:20
Next:40
Sequence complete.
mergeDelayError操作符(发生错误时不中断,最后才执行)
从merge操作符的流程图可以看出,一旦合并的某一个Observable中出现错误,就会马上停止合并,并对订阅者回调执行onError方法,而mergeDelayError操作符会把错误放到所有结果都合并完成之后才执行,其流程图如下:
调用例子如下:
//产生0,5,10数列,最后会产生一个错误
Observable<Long> errorObservable = Observable.error(
newException(
"this is end!"));
Observable < Long > observable1 = Observable.timer(
0,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
5;
}
}).take(
3).mergeWith(errorObservable.delay(
3500, TimeUnit.MILLISECONDS));
//产生0,10,20,30,40数列
Observable<Long> observable2 = Observable.timer(
500,
1000, TimeUnit.MILLISECONDS)
.map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
10;
}
}).take(
5);
Observable.mergeDelayError(observable1, observable2)
.subscribe(
newSubscriber<Long>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Long aLong) {
System.out.println(
"Next:"+ aLong);
}
});
运行结果如下:
Next:0
Next:0
Next:5
Next:10
Next:10
Next:20
Next:30
Next:40
Error: this is end!
startWith操作符(将插入的值放前面)
startWith操作符是在源Observable提交结果之前,插入指定的某些数据
调用例子如下:
Observable.just(
10,
20,
30).startWith(
2,
3,
4).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.
out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Integer
value) {
System.
out.println(
"Next:"+
value);
}
});
运行结果如下:
Next:2
Next:3
Next:4
Next:10
Next:20
Next:30
Sequence complete.
switchOnNext操作符
switchOnNext操作符是把一组Observable转换成一个Observable,转换规则为:对于这组Observable中的每一个Observable所产生的结果,如果在同一个时间内存在两个或多个Observable提交的结果,只取最后一个Observable提交的结果给订阅者,
调用例子如下:
//每隔500毫秒产生一个observable
Observable<Observable<Long>> observable = Observable.timer(
0,
500, TimeUnit.MILLISECONDS).map(
newFunc1<Long, Observable<Long>>() {
@Override
public
Observable<Long>
call(Long aLong) {
//每隔200毫秒产生一组数据(0,10,20,30,40)
return
Observable.timer(
0,
200, TimeUnit.MILLISECONDS).map(
newFunc1<Long, Long>() {
@Override
public
Long
call(Long aLong) {
return
aLong *
10;
}
}).take(
5);
}
}).take(
2);
Observable.switchOnNext(observable).subscribe(
newSubscriber<Long>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Long aLong) {
System.out.println(
"Next:"+ aLong);
}
});
运行结果如下:
Next:0
Next:10
Next:20
Next:0
Next:10
Next:20
Next:30
Next:40
Sequence complete.
Zip操作符
zip操作符是把两个observable提交的结果,严格按照顺序进行合并
调用例子如下:
Observable<Integer> observable1 = Observable.just(
10,
20,
30);
Observable<Integer> observable2 = Observable.just(
4,
8,
12,
16);
Observable.zip(observable1, observable2,
newFunc2<Integer, Integer, Integer>() {
@Override
public
Integer
call(Integer integer, Integer integer2) {
return
integer + integer2;
}
}).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.
out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Integer
value) {
System.
out.println(
"Next:"+
value);
}
});
运行结果如下:
Next:14
Next:28
Next:42
Sequence complete.
zipWith操作符
ApiManger apiManger= RetrofitHelper.getManger();
apiManger.getMoney()
.zipWith(apiManger.getCharge(), new Func2<MoneyModel, ChargeModel, int >() {
@Override
public int call(MoneyModel moneyModel,ChargeModel chargeModel) {
return moneyModel.getMoney()+ chargeModel.getPrice();
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber<Boolean>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Boolean aBoolean){
//购买
If{!aBoolean}{
//余额不足
}else{
//购买
}
}
});
5.Error HandlingOperators(Observable的错误处理操作符)
onErrorReturn操作符
onErrorReturn操作符是在Observable发生错误或异常的时候(即将回调oError方法时),拦截错误并执行指定的逻辑,返回一个跟源Observable相同类型的结果,最后回调订阅者的onComplete方法
调用例子如下:
Observable<Integer> observable = Observable.create(
newObservable.OnSubscribe<Integer>() {
@Override
publicvoidcall
(Subscriber<?
superInteger> subscriber) {
if
(subscriber.isUnsubscribed())
return;
//循环输出数字
try
{
for
(
inti =
0; i <
10; i++) {
if
(i ==
4) {
thrownew
Exception(
"this is number 4 error!");
}
subscriber.onNext(i);
}
subscriber.onCompleted();
}
catch(Exception e) {
subscriber.onError(e);
}
}
});
observable.onErrorReturn(
newFunc1<Throwable, Integer>() {
@Override
public
Integer
call(Throwable throwable) {
return1004
;
}
}).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Integer value) {
System.out.println(
"Next:"+ value);
}
});
运行结果如下:
Next:0
Next:1
Next:2
Next:3
Next:1004
Sequence complete.
onErrorResumeNext操作符
onErrorResumeNext操作符跟onErrorReturn类似,只不过onErrorReturn只能在错误或异常发生时只返回一个和源Observable相同类型的结果,而onErrorResumeNext操作符是在错误或异常发生时返回一个Observable,也就是说可以返回多个和源Observable相同类型的结果,
调用例子如下:
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
publicvoidcall
(Subscriber<?
superInteger> subscriber) {
if
(subscriber.isUnsubscribed())
return;
//循环输出数字
try
{
for
(
inti =
0; i <
10; i++) {
if
(i ==
4) {
thrownew
Exception(
"this is number 4 error!");
}
subscriber.onNext(i);
}
subscriber.onCompleted();
}
catch(Exception e) {
subscriber.onError(e);
}
}
});
observable.onErrorResumeNext(
newFunc1<Throwable, Observable<? extends Integer>>() {
@Override
public
Observable<? extends Integer>
call(Throwable throwable) {
return
Observable.just(
100,
101,
102);
}
}).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Integer value) {
System.out.println(
"Next:"+ value);
}
});
运行结果如下:
Next:0
Next:1
Next:2
Next:3
Next:100
Next:101
Next:102
Sequence complete.
onExceptionResumeNext操作符
onExceptionResumeNext操作符和onErrorResumeNext操作符类似,不同的地方在于onErrorResumeNext操作符是当Observable发生错误或异常时触发,而onExceptionResumeNext是当Observable发生异常时才触发。
调用例子如下:
Observable<Integer> observable = Observable.create(
newObservable.OnSubscribe<Integer>() {
@Override
publicvoidcall
(Subscriber<?
superInteger> subscriber) {
if
(subscriber.isUnsubscribed())
return;
//循环输出数字
try
{
for
(
inti =
0; i <
10; i++) {
if
(i ==
4) {
thrownew
Exception(
"this is number 4 error!");
}
subscriber.onNext(i);
}
subscriber.onCompleted();
}
catch(Throwable e) {
subscriber.onError(e);
}
}
});
observable.onExceptionResumeNext(Observable.just(
100,
101,
102)).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Integer value) {
System.out.println(
"Next:"+ value);
}
});
运行结果如下:
Next:0
Next:1
Next:2
Next:3
Next:100
Next:101
Next:102
Sequence complete.
retry操作符
retry操作符是当Observable发生错误或者异常时,重新尝试执行Observable的逻辑,如果经过n次重新尝试执行后仍然出现错误或者异常,则最后回调执行onError方法;当然如果源Observable没有错误或者异常出现,则按照正常流程执行。其流程图如下:
调用例子如下:
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
publicvoidcall
(Subscriber<?
superInteger> subscriber) {
if
(subscriber.isUnsubscribed())
return;
//循环输出数字
try
{
for
(
inti =
0; i <
10; i++) {
if
(i ==
4) {
thrownew
Exception(
"this is number 4 error!");
}
subscriber.onNext(i);
}
subscriber.onCompleted();
}
catch(Throwable e) {
subscriber.onError(e);
}
}
});
observable.retry(
2).subscribe(
newSubscriber<Integer>() {
@Override
publicvoidonCompleted
() {
System.out.println(
"Sequence complete.");
}
@Override
publicvoidonError
(Throwable e) {
System.err.println(
"Error: "+ e.getMessage());
}
@Override
publicvoidonNext
(Integer value) {
System.out.println(
"Next:"+ value);
}
});
运行结果如下
Next:0
Next:1
Next:2
Next:3
Next:0
Next:1
Next:2
Next:3
Next:0
Next:1
Next:2
Next:3
Error: this is number 4 error!
retry和repeatwhen的区别
一个是调用oncomplete后执行再次执行
一个是调用onError后再次执行
一些参考资料:
1.RxJava api查询
http://reactivex.io/RxJava/1.x/javadoc/
2.RxJava实际运用运用的小场景
http://www.jianshu.com/p/91ec3676ddbb
3.RxJava操作符运用的demo
https://github.com/rengwuxian/RxJavaSamples