RxJava----使用

基本使用

        //一个最简单的实现
        //一个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

创建操作符

OperatorRxJava—-操作符:创建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发射的数据中进行选择

OperatorRxJava—-操作符:过滤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

条件和布尔操作符

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

算术和聚合操作符

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

转换操作符

OperatorRxJava—-操作符:转换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发射一组不同的数据

组合操作符

OperatorRxJava—-操作符:组合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

辅助操作符

OperatorRxJava—-操作符:辅助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转换为其它对象或数据结构

生命周期

subscribe

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();

结果:

Clean

项目源码 GitHub求赞,谢谢!
引用:
RxJava 教程第一部分:入门之 生命周期管理 - 云在千峰

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值