简介
什么是RxJava? GitHub给出的介绍是:RxJava是ReactiveX(Reactive Extensions)的Java VM实现:用于通过使用可观察序列来编写异步和基于事件的程序的库。
在我的理解中RxJava主要可以实现异步任务,和事件总线的功能,这也是RxJava的厉害之处。
RxJava的GitHub地址:
使用
关于RxJava的使用详解,该篇文章会介绍更加详细,而且主要偏向于对RxJava的使用。
创建
创建一个观察者,有两种方式实现:创建Observer和Subscriber。
Observer:
Observer<String> observer = new Observer<String>() {
@Override
public void onError(Throwable e) {
Log.i("test", "onError");
}
@Override
public void onComplete() {
Log.i("test", "onComplete");
}
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.i("test", "onSubscribe");
}
@Override
public void onNext(String s) {
Log.i("test", "onNext----->" + s);
}
};
复制代码
Subscriber:
Subscriber subscriber = new Subscriber() {
@Override
public void onSubscribe(Subscription s) {
Log.i("test", "onSubscribe");
}
@Override
public void onNext(Object o) {
Log.i("test", "onNext");
}
@Override
public void onError(Throwable t) {
Log.i("test", "onError");
}
@Override
public void onComplete() {
Log.i("test", "onComplete");
}
}
复制代码
创建被观察者,并且需要和观察者订阅起来,在RxJava中的被观察者是Observable使用subscribe方法订阅。
创建被观察者有三种方式可以实现:
1)使用Observable.create创建
Observable.create(new ObservableOnSubscribe<String>(){
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
e.onNext("你好");
}
}).subscribe(observer);//订阅
复制代码
在创建方式需要在subscribe方法里,手动调用Observer的onNext、onError、onComplete方法,而onSubscribe方法是自动调用的。
2)Observable.just 可以使用Observable.just方式来创建一个Observable
Observable.just("你好","hello world").subscribe(observer);
复制代码
使用Observable.just创建,然后subscribe订阅,这种方式会自动调用onSubscribe、onNext、onError和onComplete方法。
3)Observable.fromArray
使用Observable.fromArray来创建一个Observable对象。
String[] quotations = {"热爱祖国", "热爱人民"};
Observable.fromArray(quotations).subscribe(observer);
复制代码
使用Observable.fromArray创建,然后订阅,和Observable.just一样,会自动调用观察者的方法。
观察者的方法
在上面我们已经创建了一个观察,创建一个观察者,其中包括四个方法:onError、onComplete、onSubscribe和onNext。
那么这几个方法都表示什么呢?
onSubscribe:被观察者订阅观察者的时候,就会触发该方法。
onCompleted:事件队列完结。RxJava 不仅把每个事件单独处理,还会把它们看做一个队列。RxJava 规定,当不会再有新的 onNext 发出时,需要触发 onCompleted方法作为标志。
onError: 事件队列异常。在事件处理过程中出异常时,onError方法会被触发,同时队列自动终止,不允许再有事件发出。
onNext:表示普通事件,可以在该方法做一些业务逻辑处理。
操作符
操作符包括普通的操作符、变换操作符、过滤操作符、组合操作符、辅助操作符、错误处理操作符、条件操作符、布尔操作符和转换操作符。
普通操作符包括:interval、repeat和intervalRange等等。
使用,如:
Observable.intervalRange(0,6,0,3,TimeUnit.SECONDS).create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
e.onNext("666");
}
}).subscribe(observer);
复制代码
intervalRange该操作符是用于延迟执行、并且定期执行。
变换操作符包括:map、flatMap、cast和concatMap等等。
map:指定一个Function对象,将Observable转换为一个新的Observable并发射。
Observable.just("你好","hello world").map(new Function<String, String>() {
@Override
public String apply(@NonNull String s) throws Exception {
return s;
}
}).subscribe(observer);
复制代码
flatMap、cast:
Observable.just("你好","hello world").flatMap(new Function<String, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(@NonNull String s) throws Exception {
return Observable.just(s);
}
}).cast(String.class).subscribe(observer);
复制代码
flatMap将Observable发射的数据集合变换为Observable集合,然后将这些Observable发射的数据平坦地放进一个单独的Observable,而cast则强制将Observable发射的所有数据转换为指定类型。
buffer操作符功能:
1、能一次性集齐多个结果到列表中,订阅后自动清空相应结果,直到完全清除
2、 也可以周期性的集齐多个结果到列表中,订阅后自动清空相应结果,直到完全清除
Observable
.range(0,5)
.buffer(2)
.subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onNext(@NonNull List<Integer> integers) {
Log.i("test","----------------->onNext:" + integers);
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
}
});
复制代码
Observable
.just("你好","hello world","我爱我家")
.buffer(3)
.subscribe(new Observer<List<String>>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onNext(@NonNull List<String> strings) {
Log.i("test",""+strings);
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
}
});
复制代码
除了以上的变换操作符,还有groupBy操作符,进行分组操作。
过滤操作符
过滤操作符包括filter、skip、take、element等等。
filter:对Observable产生的结果自定义规则进行过滤,只有满足条件的结果才提交给订阅者。
Observable
.just("你好","hello world","我爱我家")
.filter(new Predicate<String>() {
@Override
public boolean test(@NonNull String s) throws Exception {
Log.i("test",""+s);
return s.equals("你好");
}
}).subscribe(observer);
复制代码
distinct:去重
Observable
.just("你好","hello world","我爱我家","我爱我家")
.distinct()
.subscribe(observer);
复制代码
skip:过滤掉前n项
Observable
.just("你好","hello world","我爱我家","我爱我家")
.skip(2)
.subscribe(observer);
复制代码
take:取前n项
Observable
.just("你好","hello world","我爱我家","我爱我家")
.take(2)
.subscribe(observer);
复制代码
throttleWithTimeout:如果在限定的时间内,源Observable有新的数据发射出来,该数据就会被丢弃,同时throttleWithTimeout重新开始计时,如果每次都是在计时结束前发射数据,那么这个限流就会走向极端(只会发射最后一个数据)
Observable
.just("你好","hello world","我爱我家","我爱我家")
.throttleWithTimeout(200, TimeUnit.MILLISECONDS)
.subscribe(observer);
复制代码
组合操作符
组合操作符包括:merge、startWidth、concat、jion、switch和zip等等。
merge:将多个Observable合并到一个Observable中进行发射。
Observer<String> observer = new Observer<String>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.i("test", "onSubscribe");
}
@Override
public void onNext(@NonNull String s) {
Log.i("test", "onNext--->" + s);
}
@Override
public void onError(@NonNull Throwable e) {
Log.i("test", "onError");
}
@Override
public void onComplete() {
Log.i("test", "onComplete");
}
};
Observable<String> observable1 = Observable.just("你好", "hello World");
Observable<String> observable2 = Observable.just("new obj", "mergeobj");
Observable.merge(observable1, observable2).subscribe(observer);
复制代码
concat:将多个Observable发射的数据合并发射,其具有严格的顺序,发射顺序具有队列的特点。前一个数据没有发射完成不会发射后一个数据。
Observable<String> observable1 = Observable.just("你好", "hello World");
Observable<String> observable2 = Observable.just("new obj", "mergeobj");
Observable.concat(observable1, observable2).subscribe(observer);
复制代码
除了以上的组合操作符,还有zip、combineLastest等。
zip:合并两个或者多个Obserable发射出的数据项,根据指定的函数变换它们,并发射一个新值。
辅助操作符
辅助操作符包括DO、delay、observeOn、timeout、timeInterval、timestamp、subscribeOn、meterialize和to等。
delay:延迟执行发射数据
Observable<String> observable1 = Observable.just("你好", "hello World");
Observable<String> observable2 = Observable.just("new obj", "mergeobj");
Observable.concat(observable1, observable2).delay(5, TimeUnit.SECONDS).subscribe(observer);
复制代码
subscribeOn:指定Obserable自身在那个线程上运行。
observeOn:指定Obserable发射出的数据在那个线程运行。
其他的操作符读者可以自行实践。
错误操作符
在rxjava中,错误操作符包括catch和retry。
catch能够拦截原始Observable的onError通知,将它替换为其他数据项或者数据序列,让产生的Observable能够正常终止或者根本不终止。 catch实现分为三个不同的操作符:
1、onErrorReturn:返回原有Observable行为的备用Observable, 备用的Observable忽略原有的Observable的onError调用,即不会将错误传递给观察者,而是发射一个特殊的项,以及调用观察者的onCompleted。
2、onErrorResumeNext:跟onErrorReturn一样返回备用的Observable,不会调用原有的Observable的onError,它会发射备用的Observable数据。
3、onExceptionResumeNext:如果onError收到的Throwable不是一个Exception,它会将错误传递给观察者的onError方法,不会使用备用的Observable。
retry:不会将原有的Observable的onError通知传递给观察者,这会订阅这个Observable,再给它一次机会无错误地完成其数据序列,而它总会传递onNext通知给观察者。该操作符有可能造成数据重复,因为重新订阅。如果超过了重新订阅的次数,就不会再次订阅了,而是把最新的一个onError通知传递给观察者。
条件操作符
条件操作符包括:defaultEmpty、skipUntil、amb、skipWhile、takeUtil、takeWhile
defaultEmpty:如果原有的Observable没有发射数据,就发射一个默认的数据。
skipUntil:订阅原始的Observable,但是忽略它的发射物,直到第二个Observable发射了一项数据那一刻,它开始发射原始Observable。
布尔操作符
布尔操作符包括:all、isEmpty、contains、exists和sequenceEqual。
关于条件操作符和布尔操作符,读者可以关注《RxJava操作符(08-条件和布尔操作) 》这篇文章,文章地址:
转换操作符
转换操作符能够将Observable转换为另一个对象或者数据结构,其中转换操作符包括:toMap、toMultiMap、toList、toSortedList、nest和getIterator等。
toMap:将原始的Observable发射的所有数据项集合到一个Map中,然后发射该Map。
String s1 = "你好";
String s2 = "hello world";
String s3 = "lalala";
Observable.just(s1,s2,s3).toMap(new Function<String, String>() {
@Override
public String apply(@NonNull String s) throws Exception {
return s;
}
}).subscribe(new SingleObserver<Map<String, String>>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onSuccess(@NonNull Map<String, String> stringStringMap) {
Log.i("test",""+stringStringMap);
}
@Override
public void onError(@NonNull Throwable e) {
}
});
复制代码
toMultiMap:类似于toMap,不同的地方在于map的value是一个集合。
toList:将发射的数据组成一个List。
String s1 = "你好";
String s2 = "hello world";
String s3 = "lalala";
Observable.just(s1,s2,s3).toList().subscribe(new SingleObserver<List<String>>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onSuccess(@NonNull List<String> strings) {
Log.i("test",""+strings);
}
@Override
public void onError(@NonNull Throwable e) {
}
});
复制代码
关于其他操作符,读者可以参考《RxJava操作符大全》这篇文章。
RxJava的线程控制
前面讲解辅助操作符的时候,我们知道使用subscribeOn可以指定Obserable自身在那个线程上运行。使用observeOn可以指定Obserable发射出的数据在那个线程运行。RxJava默认线程是在调用subcribe方法的线程上进行回调,但是如果想切换线程,就需要使用Scheduler。
在RxJava中内置了以下几个Scheduler:
1、Scheduler.immediate():运行在当前线程,是timeout、timestamp和timeInterval操作符的默认调度器。
2、Scheduler.io():I/O操作使用的Scheduler。
3、Scheduler.newThread():开启一个新的线程执行操作。
2和3的区别就是:2的内部实现了一个无数量上限的线程池,重用空闲的线程,因此2具有更高的效率。
4、Scheduler.trampoline():可以将任务通过trampoline方法加入队列,该调度器会按顺序处理队列的任务,是repeat和retry操作符的默认调度器。
5、Scheduler.computation():计算所使用的调度器,它具有固定的线程池,大小为cpu核数,注意不要将io操作放到computation中,否则io操作的等待时间会浪费cpu。该调度器是buffer、delay、sample、debounce、interval和skip的默认调度器。
6、AndroidSchedulers.mainThread():表示在主线程中运行,该调度器是RxAndroid提供的。
Observable.just("你好","hello world")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(observer);
复制代码
写到这里,关于RxJava的知识基本讲解完了,相信读者读完该文,也懂得使用RxJava了,接下来我更新RxJava结合Retrofix和OkHttp的使用,敬请关注,谢谢!