RxJava结合源码学习一

RxJava结合源码学习一

基本概念

1、首先，你得有个 Observable 被观察者

2、其次，你得有个 Observer 观察者，这是一个接口

3、接着，你得知道RxJava给了你一个观察者叫 Subscriber 订阅者,这是一个实现了Observer的抽象类，你可以直接用，那他跟 Observer 有什么区别呢？多了下面几个方法：

• add()
• unsubscribe() 取消订阅
• isUnsubscribed() 判断是否取消订阅了
• onStart() 这个方法在订阅者和被观察者一连接但还没开始提交或者发送通知的时候被调用，可以在这个方法写一些初始化
• request()
• addToRequested()
• setProducer()

4、了解了Observable和Observer，以及Subscriber，这三个概念之后，我们就可以开始动手创建一个被观察者了，如何创建呢？下面是基本的创建一个被观察者代码：

 Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Next1");
                subscriber.onNext("Next2");
                subscriber.onNext("Next3");
                subscriber.onCompleted();
            }
        })

分析下这段代码，我们可以通过Observable.create来创建一个Observable被观察者，需要传入一个Observable.OnSubscribe参数，这个参数是干嘛的呢？我们先通过源码来看下这个创建方法的注释

Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to it.

字面上的翻译是：返回一个被观察者，当一个订阅者订阅它，会执行指定的方法，所以知道这个 Observable.OnSubscribe 参数，实现的call方法，里面就是我们指定的要告诉订阅者执行的方法。具体要执行的方法就是 subscriber 执行三遍 onNext() ，然后执行一遍 onCompleted()

5、了解了如何创建被观察者了，在有了被观察者之后，我们就要创建观察者来执行这些方法了，那如何创建观察者呢？下面是基本的创建一个观察者代码：

    Observer<String> observer = new Observer<String>() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(String s) {

                }
            };

Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {

    }
}

这是基本的创建观察者的方式，可以选择Observer或者Subscriber，直接new一个对象，实现接口的方法即可，这个不难。

6、有了被观察者和观察者之后，我们就需要将两者关联起来了，就是观察者观察被观察者，或者订阅者订阅被观察者，但RxJava这边的实现方法是这样的：

//第一种订阅
observable.subscribe(observer);
//第二种订阅
observable.subscribe(subscriber);

RxJava按调用的顺序来讲是反着的，像是被观察者订阅了观察者，订阅了订阅者一样。但我们可以这样理解，在创建被观察者的时候，是被观察者主动指定观察者应该执行哪些方法的，所以这边被观察者订阅观察者也是可以接受的。

7、将被观察者和观察者联系起来后，我们稍微看下RxJava内部subscribe的源码，稍微简化了下：

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        subscriber.onStart();

        hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);

        return hook.onSubscribeReturn(subscriber);
    }

#RxJavaObservableExecutionHook.java

public abstract class RxJavaObservableExecutionHook {
    public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInstance, final OnSubscribe<T> onSubscribe) {
            // pass through by default
            return onSubscribe;
        }
    }

• 方法先调用subscriber观察者的onstart()方法
• 接着通过hook.onSubscribeStart()调用call()方法，其中通过源码可以知道hook.onSubscribeStart()返回的就是onSubscribe，也就是我们创建被观察者的时候指定的方法
• 最后返回subscriber，方便后续的操作。

8、到这里，我们整条线就通了，但是我们有时候会看到如下的RxJava代码

Action0 onCompleted = new Action0() {
        @Override
        public void call() {

        }
    };

    Action1<String> onNext = new Action1<String>() {
        @Override
        public void call(String s) {

        }
    };

    Action1<Throwable> onError = new Action1<Throwable>() {
        @Override
        public void call(Throwable throwable) {

        }
    } ;

    observable.subscribe(onNext)
    observable.subscribe(onNext,onError);
    observable.subscribe(onNext,onError,onCompleted);

这里的Action又是什么呢？我们看下RxJava这些调用相关内部的方法源码，简化后：

public final Subscription subscribe(final Action1<? super T> onNext) {
        Action1<Throwable> onError = InternalObservableUtils.ERROR_NOT_IMPLEMENTED;
        Action0 onCompleted = Actions.empty();
        return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
    }

public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError) {
        Action0 onCompleted = Actions.empty();
        return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
    }

public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onCompleted) {
        return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
    }

public final Subscription subscribe(Subscriber<? super T> subscriber) {
        return Observable.subscribe(subscriber, this);
    }

通过源码我们可以知道最终他会通过一个onError，一个onCompleted和一个onNext三个Action来构造一个ActionSubscriber对象，这个时候分三种情况：

• 当我们只传入一个 Action1 onNext 时，这个对象会给我们加一个 ERROR_NOT_IMPLEMENTED 没有实现的 Action1 onError 和一个空的 Actio0 onCompleted ，构造一个ActionSubscriber；
• 当我们传入的是 Action1 onNext 和 Action1 onError 时，它会帮我们再加一个空的 Action0 onCompleted ，构造一个ActionSubscriber；
• 当我们传入的是 Action1 onNext 、Action1 onError 、Action0 onCompleted 时，它刚好构造一个ActionSubscriber

细心的同学可能会发现了，onNext对应的是Action1，onError对应的Action1，onCompleted对应的Action0，下面是ActionSubscriber类的源码。

public final class ActionSubscriber<T> extends Subscriber<T> {

    final Action1<? super T> onNext;
    final Action1<Throwable> onError;
    final Action0 onCompleted;

    public ActionSubscriber(Action1<? super T> onNext, Action1<Throwable> onError, Action0 onCompleted) {
        this.onNext = onNext;
        this.onError = onError;
        this.onCompleted = onCompleted;
    }

    @Override
    public void onNext(T t) {
        onNext.call(t);
    }

    @Override
    public void onError(Throwable e) {
        onError.call(e);
    }

    @Override
    public void onCompleted() {
        onCompleted.call();
    }
}

通过代码可以知道，ActionSubscriber是继承Subscriber，也是属于一个订阅者。只是通过它我们可以分离出其中的Action。

9、下一节我将继续结合源码分析更RxJava更深入的知识点