首页 > 编程 > Java > 正文

Rxjava 快速上手

2019-11-09 16:31:57
字体:
来源:转载
供稿:网友

Rxjava 是一个响应式编程框架,采用观察者设计模式。

RxJava 好在哪

使用Rxjava的好处在于,我们可以方便的切换方法的执行线程,对线程动态切换,该过程无需我们自己手动创建和启动线程。使用Rxjava创建的代码虽然出现在同一个线程中,但是我们可以设置使得不同方法在不同线程中执行。上述功能的实现主要归功于RxJava的Scheduler实现,Scheduler 提供了『后台处理,前台回调』的异步机制。

 

基本概念

Observable:发射源,英文释义“可观察的”,在观察者模式中称为“被观察者”或“可观察对象”;

Observer:接收源,英文释义“观察者”,没错!就是观察者模式中的“观察者”,可接收Observable、Subject发射的数据;

Subject:Subject是一个比较特殊的对象,既可充当发射源,也可充当接收源,为避免初学者被混淆,本章将不对Subject做过多的解释和使用,重点放在Observable和Observer上,先把最基本方法的使用学会,后面再学其他的都不是什么问题;

Subscriber:“订阅者”,也是接收源,那它跟Observer有什么区别呢?Subscriber实现了Observer接口,比Observer多了一个最重要的方法unsubscribe( ),用来取消订阅,当你不再想接收数据了,可以调用unsubscribe( )方法停止接收,Observer 在 subscribe() 过程中,最终也会被转换成 Subscriber 对象,一般情况下,建议使用Subscriber作为接收源;

Subscription :Observable调用subscribe( )方法返回的对象,同样有unsubscribe( )方法,可以用来取消订阅事件;

Action0:RxJava中的一个接口,它只有一个无参call()方法,且无返回值,同样还有Action1,Action2...Action9等,Action1封装了含有 1 个参的call()方法,即call(T t),Action2封装了含有 2 个参数的call方法,即call(T1 t1,T2 t2),以此类推;

Func0:与Action0非常相似,也有call()方法,但是它是有返回值的,同样也有Func0、Func1...Func9;

RxJava2.0中的观察者模式

RxJava始终以观察者模式为骨架,在2.0中依然如此。

在RxJava2.0中,有五种观察者模式:

Observable/ObserverFlowable/SubscriberSingle/SingleObserverCompletable/CompletableObserverMaybe/MaybeObserver

后面三种观察者模式差不多,Maybe/MaybeObserver可以说是Single/SingleObserverCompletable/CompletableObserver的复合体。

下面列出这五个观察者模式相关的接口。

Observable/Observer

public abstract class Observable<T> implements ObservableSource<T>{...}public interface ObservableSource<T> { void subscribe(Observer<? super T> observer);}public interface Observer<T> { void onSubscribe(Disposable d); void onNext(T t); void onError(Throwable e); void onComplete();}

Completable/CompletableObserver

//代表一个延迟计算没有任何价值,但只显示完成或异常。类似事件模式Reactive-Streams:onSubscribe(onError | onComplete)?public abstract class Completable implements CompletableSource{...}//没有子类继承Completablepublic interface CompletableSource { void subscribe(CompletableObserver cs);}public interface CompletableObserver { void onSubscribe(Disposable d); void onComplete(); void onError(Throwable e);}

Flowable/Subscriber

public abstract class Flowable<T> implements Publisher<T>{...}public interface Publisher<T> { public void subscribe(Subscriber<? super T> s);}public interface Subscriber<T> { public void onSubscribe(Subscription s); public void onNext(T t); public void onError(Throwable t); public void onComplete();}

Maybe/MaybeObserver

//Maybe类似Completable,它的主要消费类型是MaybeObserver顺序的方式,遵循这个协议:onSubscribe(onSuccess | onError | onComplete)public abstract class Maybe<T> implements MaybeSource<T>{...}public interface MaybeSource<T> { void subscribe(MaybeObserver<? super T> observer);}public interface MaybeObserver<T> { void onSubscribe(Disposable d); void onSuccess(T t); void onError(Throwable e); void onComplete();}

Single/SingleObserver

//Single功能类似于Observable,除了它只能发出一个成功的值,或者一个错误(没有“onComplete”事件),这个特性是由SingleSource接口决定的。public abstract class Single<T> implements SingleSource<T>{...}public interface SingleSource<T> { void subscribe(SingleObserver<? super T> observer);}public interface SingleObserver<T> { void onSubscribe(Disposable d); void onSuccess(T t); void onError(Throwable e);}其实从API中我们可以看到,每一种观察者都继承自各自的接口(都有一个共同的方法subscrib()),但是参数不一样),正是各自接口的不同,决定了他们功能不同,各自独立(特别是Observable和Flowable),同时保证了他们各自的拓展或者配套的操作符不会相互影响。

下面我们重点说说在实际开发中经常会用到的两个模式:Observable/Observer和Flowable/Subscriber。

Observable/Observer

Observable正常用法:

Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { emitter.onNext(1); emitter.onNext(2); emitter.onComplete(); }}).subscribe(new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { }@Override public void onNext(Integer integer) { }   @Override public void onError(Throwable e) { }   @Override public void onComplete() { }});@OverridepublicvoidonNext(Integer integer) { } @OverridepublicvoidonError(Throwable e) { } @OverridepublicvoidonComplete() { }});
发表评论 共有条评论
用户名: 密码:
验证码: 匿名发表