RxJava----使用

最新推荐文章于 2024-03-19 21:06:06 发布

pepe_士奇

最新推荐文章于 2024-03-19 21:06:06 发布

阅读量1.4k

点赞数

分类专栏：开源框架文章标签： RxJava

本文链接：https://blog.csdn.net/qq_20198405/article/details/51243504

版权

开源框架专栏收录该内容

19 篇文章 0 订阅

订阅专栏

基本使用

        //一个最简单的实现
        //一个Observable（被观察者）
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello RxJava");
                subscriber.onCompleted();
            }
        });
        //一个Subscriber（订阅者）
        Subscriber<String> subscriber = new Subscriber<String>() {
            public void onCompleted() {
                log("Complete!");
            }

            @Override
            public void onError(Throwable e) {
                log(e.getMessage().toString());
            }

            @Override
            public void onNext(String s) {
                log(s);
            }
        };
        //订阅，Observable执行subscribe之后，调用call方法
        observable.subscribe(subscriber);

        // Outputs:
        // Hello RxJava
        // Complete!

操作符

ReactiveX - Operators

创建操作符

Operator	RxJava—-操作符：创建Observable
just	将一个或多个对象转换成发射这个或这些对象的一个Observable
from	将一个Iterable, 一个Future, 或者一个数组转换成一个Observable
defer	在观察者订阅之前不创建这个Observable，为每一个观察者创建一个新的Observable
range	创建发射指定范围的整数序列的Observable
interval	创建一个定时发射整数序列的Observable
timer	创建在一个指定的延迟之后发射单个数据的Observable
empty	创建一个什么都不做直接通知完成的Observable
never	创建一个不发射任何数据的Observable
error	创建一个什么都不做直接通知错误的Observable
create	通过调用观察者的方法从头创建一个Observable

过滤操作符

这些操作符用于从Observable发射的数据中进行选择

Operator	RxJava—-操作符：过滤Observable
filter	过滤数据
elementAt	发射第N项数据
sample	定期发射Observable最近的数据
debounce	只有在空闲了一段时间后才发射数据，通俗的说，就是如果一段时间没有操作，就执行一次操作
ignoreElements	忽略所有的数据，只保留终止通知(onError或onCompleted)
take	只发射开始的N项数据
skip	跳过开始的N项数据
take和skip的重载	take(250, TimeUnit.MILLISECONDS)，只发射前250毫秒的数据
takeLast	只发射最后的N项数据和
skipLast	跳过最后的N项数据
takeWhile	发射原始Observable的数据，直到一个特定的条件为真，然后跳过剩余的数据
skipWhile	丢弃原始Observable发射的数据，直到一个特定的条件为假，然后发射原始Observable剩余的数据
takeUntil 和	发射来自原始Observable的数据，直到第二个Observable发射了一个数据或一个通知
skipUntil	丢弃原始Observable发射的数据，直到第二个Observable发射了一个数据，然后发射原始Observable的剩余数据
first and last	首项（和末项），只发射满足条件的第一条（或者最后一条）数据
distinct	去重，过滤掉重复数据项
distinctkeySelector
distinctUntilChanged	过滤掉连续重复的数据
distinctUntilChangedkeySelector

条件和布尔操作符

Operator	RxJava—-操作符：检查Observable
all	判断Observable发射的所有的数据项是否都满足某个条件
ofType	只发射指定类型的数据
single	强制返回单个数据，否则抛出异常
exists
isEmpty
contains	判断Observable是否会发射一个指定的数据项
defaultIfEmpty
sequenceEqual

算术和聚合操作符

Operator	RxJava—-操作符：聚合Observable
count	来统计源 Observable 完成的时候一共发射了多少个数据
reudce	按顺序对数据序列的每一个应用某个函数，然后返回这个值
collect
toList
toSortedList
toMap
toMultimap
concat	不交错的连接多个Observable的数据
concatWith
amb	给定多个Observable，只让第一个发射数据的Observable发射全部数据
ambWith

转换操作符

Operator	RxJava—-操作符：转换Observable
map	对序列的每一项都应用一个函数来变换Observable发射的数据序列
cast
materialize	将Observable转换成一个通知列表convert an Observable into a list of Notifications
dematerialize	将上面的结果逆转回一个Observable
flatMap	将Observable发射的数据集合变换为Observables集合，然后将这些Observable发射的数据平坦化的放进一个单独的Observable
concatMap
switchMap	将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射的数据
flatMapIterable
buffer	它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个
window	定期将来自Observable的数据分拆成一些Observable窗口，然后发射这些窗口，而不是每次发射一项
scan	对Observable发射的每一项数据应用一个函数，然后按顺序依次发射每一个值
groupBy	分组，将原来的Observable分拆为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据

组合操作符

Operator	RxJava—-操作符：组合Observable
repeat	创建一个重复发射指定数据或数据序列的Observable
repeatWhen	创建一个重复发射指定数据或数据序列的Observable，它依赖于另一个Observable发射的数据
startWith	在发射原来的Observable的数据序列之前，先发射一个指定的数据序列或数据项
merge	将多个Observable合并为一个
mergeWith
mergeDelayError	合并多个Observables，让没有错误的Observable都完成后再发射错误通知
switchOnNext	将一个发射Observables的Observable转换成另一个Observable，后者发射这些Observables最近发射的数据
switchMap	将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射的数据
zip	使用一个函数组合多个Observable发射的数据集合，然后再发射这个结果
zipWith
combineLatest	当两个Observables中的任何一个发射了一个数据时，通过一个指定的函数组合每个Observable发射的最新数据（一共两个数据），然后发射这个函数的结果
join	无论何时，如果一个Observable发射了一个数据项，只要在另一个Observable发射的数据项定义的时间窗口内，就将两个Observable发射的数据合并发射
groupJoin

辅助操作符

Operator	RxJava—-操作符：辅助Observable
materialize( )	将Observable转换成一个通知列表convert an Observable into a list of Notifications
dematerialize( )	将上面的结果逆转回一个Observable
timestamp( )	给Observable发射的每个数据项添加一个时间戳
serialize( )	强制Observable按次序发射数据并且要求功能是完好的
cache( )	记住Observable发射的数据序列并发射相同的数据序列给后续的订阅者
observeOn( )	指定观察者观察Observable的调度器
subscribeOn( )	指定Observable执行任务的调度器
doOnEach( )	注册一个动作，对Observable发射的每个数据项使用
doOnCompleted( )	注册一个动作，对正常完成的Observable使用
doOnError( )	注册一个动作，对发生错误的Observable使用
doOnTerminate( )	注册一个动作，对完成的Observable使用，无论是否发生错误
doOnSubscribe( )	注册一个动作，在观察者订阅时使用
doOnUnsubscribe( )	注册一个动作，在观察者取消订阅时使用
finallyDo( )	注册一个动作，在Observable完成时使用
delay( )	延时发射Observable的结果
delaySubscription( )	延时处理订阅请求
timeout	如果在一个指定的时间段后还没发射数据，就发射一个异常
timestamp	给Observable发射的每个数据项添加一个时间戳
timeInterval	定期发射数据
using( )	创建一个只在Observable生命周期存在的资源
single( )	强制返回单个数据，否则抛出异常
singleOrDefault( )	如果Observable完成时返回了单个数据，就返回它，否则返回默认数据
toFuture( ), toIterable( ), toList( )	将Observable转换为其它对象或数据结构

生命周期

Observable.subscribe 有好几个重载函数，每个函数都是某种情况的简化形式。

Subscription    subscribe()
Subscription    subscribe(Action1<? super T> onNext)
Subscription    subscribe(Action1<? super T> onNext, Action1<java.lang.Throwable> onError)
Subscription    subscribe(Action1<? super T> onNext, Action1<java.lang.Throwable> onError,Action0 onComplete)
Subscription    subscribe(Observer<? super T> observer)
Subscription    subscribe(Subscriber<? super T> subscriber)

第一个 subscribe() 函数只是订阅事件，但是不去处理这些事件。
带有一个或者多个 Action 参数的，使用这些参数来构造一个 Subscriber 对象。
这些参数分别对应 onNext、onError和 onComplete这三种类型的事件，如果没有提供则代表不处理这个类型的事件。
下面的示例演示处理 error 的情况：

        Subject<Integer, Integer> s = ReplaySubject.create();
        s.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                log(integer + "");
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                log(throwable.getMessage().toString());
            }
        });
        s.onNext(0);
        s.onError(new Exception("Oops"));

结果：

0
Oops

如果你不处理 error，则在发生错误的时候，会抛出 OnErrorNotImplementedException 异常。该异常发生在生产者这边，上面的示例生产者和消费者位于同一线程，所以你可以直接 try- catch 住，但是在实际应用中，生产者和消费者通常不再同一个线程，所以最好还是提供一个错误处理函数，否则你不知道错误发生了并导致事件流结束了。

unsubscribe

在事件流结束发射之前，你可以主动停止接收事件。
每个 subscribe（） 都会返回一个 Subscription 示例，该示例有两个函数：

boolean isUnsubscribed()
void unsubscribe()

只需要调用 unsubscribe 函数就可以停止接收数据了。

        Subject<Integer, Integer>  values = ReplaySubject.create();
        Subscription subscription = values.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                log(integer + "");
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                log(throwable.getMessage().toString());
            }
        }, new Action0() {
            @Override
            public void call() {
                log("Done");
            }
        });
        values.onNext(0);
        values.onNext(1);
        subscription.unsubscribe();
        values.onNext(2);

结果：

0
1

一个 observer 调用 unsubscribe 取消监听并不妨碍同一个 observable 上的其他 Observer 对象。
同时，RxJava的另外一个好处就是它处理unsubscribing的时候，会停止整个调用链。如果你使用了一串很复杂的操作符，调用unsubscribe将会在他当前执行的地方终止。不需要做任何额外的工作！


        Subject<Integer, Integer>  values = ReplaySubject.create();
        Subscription subscription1 = values.subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                log("Complete!" );
            }
            @Override
            public void onError(Throwable e) {
                log("First: "+e.getMessage().toString() );
            }
            @Override
            public void onNext(Integer integer) {
                log("First: "+integer);
            }
        });
        Subscription subscription2 = values.subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                log("Complete!" );
            }
            @Override
            public void onError(Throwable e) {
                log("Second: "+e.getMessage().toString() );
            }
            @Override
            public void onNext(Integer integer) {
                log("Second: "+integer);
            }
        });
        values.onNext(0);
        values.onNext(1);
        subscription1.unsubscribe();
        log("Unsubscribed first" );
        values.onNext(2);

结果：

First: 0
Second: 0
First: 1
Second: 1
Unsubscribed first
Second: 2

onError 和 onCompleted

onError 和 onCompleted 意味着结束事件流。
observable 需要遵守该规范，在 onError 或者 onCompleted 发生后就不应该再发射事件了。

        Subject<Integer, Integer>  values = ReplaySubject.create();
        Subscription subscription1 = values.subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                log("Complete!" );
            }

            @Override
            public void onError(Throwable e) {
                log("First: "+e.getMessage().toString() );
            }

            @Override
            public void onNext(Integer integer) {
                log("First: "+integer);
            }
        });
        values.onNext(0);
        values.onNext(1);
        values.onCompleted();
        values.onNext(2);

结果：

First: 0
First: 1
Complete！

释放资源

Subscription 和其使用的资源绑定在一起。
所以你应该记得释放 Subscription 来释放资源。
使用 Subscriptions 的工厂函数可以把 Subscription 和需要的资源绑定在一起，然后可以使用 unsubscribe 来释放绑定的资源。


Subscription s= Subscriptions.create(new Action0() {
            @Override
            public void call() {
                log("Clean" );
            }
        });  
s.unsubscribe();

结果：