抱着陌生的态度再看Rxjava(一)

把它当做陌生人再一次去认识

环境集成

首先废话不多说,先把Rxjava集成到我们项目中来。

rxjava1和rxjava2

当你在app项目的module setting中添加dependency的时候,会出现让你选择使用rx1还是2的窘境,那1和2有什么不一样呢
在此,作为并没有对rxjava有所了解的陌生者,我先告诉你,2是1的improvement,所以我们集成的时候使用 2即可。

    compile 'io.reactivex.rxjava2:rxjava:2.0.6'

OK,环境配置算是完成了。

先随便撸一段代码看看

首先你需要普及一段知识,这个所谓的rxjava是基于观察者模式,或者子通俗一点,你总归听说这玩意儿使用来做响应式编程的吧。
那么我接下去,所要写的第一段代码从Observer和Subscriber开始应该可以理解了吧
  • Observer

在MainActivity中直接开了一个private的方法,写上Observer,选择reactx的包,发现需要输入一个泛型,先什么都不管,我们输入一个String,然后new之后自动跳出来一大坨如下:

Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                
            }

            @Override
            public void onNext(String s) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };

我们点到Observer的源码看,发现这个“观察者”是个接口,总共就上述的四个方法,具体用来干什么我们先放一放。

  • Subscriber

国内的rxjava鱼龙混杂,绝大部分是基于rxjava1去进行讲解的,你就会发现他们会跟你这么讲

Subscriber和Observer是一样的接口,唯一不同的是,它里面有自己的两个独有的方法,onStart,unSubscribe方法

结果你在听信了我的话导入了rxjava2之后发现结果是这样的:

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {

            }

            @Override
            public void onNext(String s) {

            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onComplete() {

            }
        };

没错,跟Observer一模一样,你疑惑的点到源码里面看,发现也是一模一样。完全一样的接口,完全一样的四个接口方法。

这里我要告诉你,在rxjava1中确实是Subscriber这个类存在(rxjava1主包名为rxrxjava2主包名为io.reactivex),存在于rx包下,但是我们在io.reactivex包下却没有发现Subscriber,我们使用的Subscriber实际上来自于org.reactivestreams.Subscriber,rxjava2已经将Subscriber这个抽象类移除了,代替它的是具体的Subscriber,在io.reactivex.subscribers包下的比如DefaultSubscriber, ResourceSubscriberDisposableSubscriber等抽象类。

  • Observable

当我们在前面想要创建Observer的时候,IDE会跳出来Observable,字面翻译的意思是观察者的东西,猜测应该是用来传递的对象,我们来看一下,进到源码中我们发现,这个Observable是个抽象类,那照理来说应该是被继承而非直接创建实例才对。

这种时候我们一般怎么做,大家知道我们通常不去使用抽象类new对象,那么如果这个抽象类有其他的一些构造方法,肯定就是在static方法中,结果我们发现他有个create方法,上面的注释下的很明白,将相应与回调联系起来的一个API,我们不妨用用看

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                
            }
        });

我们可以看到create方法对传参的描述

the emitter that is called when an Observer subscribes to the returned

翻译成人话的意思是当观察者订阅了之后所回调的一个发射器(这里的发射器我们就把他理解成一个相当迅速的回调),我们再来看一下这个ObservableOnSubscribe接口,按照之前的理解,他就是观察者做了订阅动作之后返回的一个回调。
只有一个接口方法:

/**
     * Called for each Observer that subscribes.
     * @param e the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(ObservableEmitter<T> e) throws Exception;

我们看到每一个观察者订阅了之后都会触发这个subscribe方法

继续看这个ObservableEmitter,观察者发射器,继承Emitter,就是发射器,一看是个接口,接口里面有三个方法,onNextonError, onComplete。是不是有点印象,没错跟之前的Observer和Subscriber接口的方法一模一样。

那好,根据之前的注释和接口里的方法,我们可以笃定,这几个类之间一定是有关系的,主要是怎么把他们联系起来。

  • 把Observable,Observer,Subscriber联系起来
    由于ObserverSubscriber都是接口,方法又都只有四个且都是onXXX这种非主动性方法,那我们只有从Observable入手,我们开始在Observable方法中全局搜索Observer类,看哪个方法的传参类型是Observer,发现:
    public final void subscribe(Observer<? super T> observer) 

但是没有发现Subscriber。不管了,我们先用用看,我们在刚才的Observer和Observable的方法中打上log。

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("hello on next");
                Log.e("observable", "subscribe    ");
            }
        });

结果发现,subscribe方法内调什么,Observer就回调什么。

OK,这两者的关系已经很明显了。那么到底Subscriber是和谁联系起来的呢

  • Flowable横空出世

    想来想去不知道Subscriber被谁用,你如果之前不知道Rxjava,再或者你即使用过Rxjava1,到了这儿你也不知道怎么去用Subscriber。

    无奈,点开了github的Rxjava2目录,你会在包的根目录中发现如下四个跟Observable很像的类,分别是Completable,Flowable,Maybe,Single。


    Observable.png

    Completable.png

    Flowable.png

    Maybe.png

    Single.png

    我们去一个一个的看这几个类的subscribe方法,我们会发现Completable对应的传参是onComplete的actionSingle对应的是SingleObserverMaybe对应的是MaybeObserverFlowable对应的是Subscriber。终于找到了!!!赶紧拿来用一用。

Flowable<String> flowable = Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                e.onNext("hello flowable1");
            }
        }, BackpressureStrategy.DROP);
flowable.subscribe(subscriber);

效仿Observable的构造方法,我们同样用create去创建Flowable对象,new了之后IDE帮我们自动生成,结果发现传参有两个,我们点到create方法中看到还需要传一个BackpressureStrategy。。。

这是个啥

点开BackpressureStrategy,发现是个enum,先不管那么多了随便传一个进去看看,我就用了BackpressureStrategy.DROP

发现,发现,什么都没出来!!

不过,我不管了,我把这个关系给找出来已经很累了,先歇会儿,喝杯茶~~~

  • 关于onNext,onError,onComplete要说的一些话
    • 你可以在Subscribe方法(我们可以称之为上游)中发送无限个onNext,在onSubScribe方法中(我们称之为下游)就可以接受无限个onNext。
    • 但是倘若你在上游发送了onComplete,或者是onError之后,下游接受到了,上游之后的事件下游就不再接受了。(这个想想就可以理解)
    • onComplete和onError是互相排斥的,你不能在上游发了onComplete之后又发onError,当然你发了下游也接受不到,hohoho~
    • 你不能发送多个onComplete和多个onError,虽然后续都不会再接受。但是要注意哦。发送多个onComplete系统不会崩溃,发送多个onError,你试试~~
  • Disposable,Subscription怎么用呢
    • Disposable
      我们在上面讲Observer的时候并没有涉及到Disposable的用法,我们点到这个类里看一下

/**

  • Represents a disposable resource.
    /
    public interface Disposable {
    /
    *

    • Dispose the resource, the operation should be idempotent.
      */
      void dispose();

    /**

    • Returns true if this resource has been disposed.
    • @return true if this resource has been disposed
      */
      boolean isDisposed();
      }
   是个接口,只有两个方法,Disposable字面意思是一次性东西。dispose我们看到注释是处理这个资源,操作等幂。

   这个`idempotent`是什么鬼,这个词语之后可能会在注释中一直看见,表示这个方法你使用多次跟使用一次的效果是一样的。

   其实很好理解,dispose就是销毁这个资源,如果放在响应式编程中,我猜,算了,不猜了,意思再明显不过了,就是断开观察者和被观察者之间的关系。也就是说接下去下游不会再收到上游的任何通知。

   使用过程中我们需要注意什么呢?

   如果我们的activity已经退出了,如果上游和下游还连着,下游如果做UI改动,会导致程序崩溃。
    我们需要在onSubscribe中将Disposable进行缓存,然后在activity退出的时候,调用它的Disposable.dispose方法断开连接。如果有多个Disposable,那我们可以使用官方提供的容器类`CompositeDisposable`,这个类提供了add和clear方法,可以对Disposable群体进行管理。
   * Subscription
    记得前面讲Flowable的时候,什么东西都没有出来么,现在看看好像只能从这个家伙入手了,让我们一起点开它的源码看个究竟。
   
     一看,是个接口,只有两个方法,一个`request`,一个`cancel`。我又要猜了,一个是请求,一个是断开。但是request后面还会跟着一个参数,这什么意思呢?

    来看下它的parm解释,大体翻译成老百姓看的懂得意思就是接受上游的事件数,你上游可以发很多事件,但是我这里就接受那么多个,接下去的我不接受。
 
    我们在Subscriber的onSubscribe方法中添加  `subscription.request(2)`这行代码。(随便写了个2),然后程序一跑,发现onNext打印出来了。

     在经过各种组合打印之后,最终得出的结论是,request传入的个数是接受的onNext的个数,onComplete和onError不算在接受事件的个数之中。

* #####subscribe方法的重载
   无论是Observable或者是flowable,他们的subscrib方法都有相同的重载
public final Disposable subscribe() {}
public final Disposable subscribe(Consumer<? super T> onNext) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
public final void subscribe(Observer/Subscriber<? super T> observer/subscriber) {}
   几个重载的意思分别是,什么都不监听,就是只管上游发事件,没有监听的下游;只监听onNext方法,其他不监听;只监听onNext和onError;。。。

-------

##电梯
  [抱着陌生的态度再看Rxjava(二)](http://www.jianshu.com/p/f435dc51221f)
    [抱着陌生的态度再看Rxjava(三)](http://www.jianshu.com/p/96df60fd35c6)
    [抱着陌生的态度再看Rxjava(四)](http://www.jianshu.com/p/de8af3fadede)

推荐阅读更多精彩内容