Rxjava 基本流程 源码分析

本篇文章是针对 rxjava 1.3.8 的源码进行分析，适用于刚会简单使用 rxjava 的新手阅读。
本片文章的主要内容是：

• Observable 
• rxjava 简单的流程源码分析
• Func1 Func2 这几个是什么东西

 预备知识

简单介绍下在这篇文章中提到的几个对象

1. Observable ：翻译过来的意思是可以被观察的，即被观察者
2. Observer ：即观察者对象
3. OnSubscribe :

   public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
           // cover for generics insanity
       }

   继承自 Action1 ，不了解的可以先跳过，后面会解释这个，知道他有个 call() 方法即可。

源码简单分析

先来看最基本的使用方法：

Subscription subscription = rx.Observable.create(new rx.Observable.OnSubscribe<Object>() {
            @Override
            public void call(Subscriber<? super Object> subscriber) {
                subscriber.onNext(1);
                subscriber.onCompleted();
            }
        }).subscribe(new Subscriber<Object>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {

            }
}

这里 Observable 调用过 create 方法来创建了一个 Obserable，然后用 Observable 调用 subscribe 订阅了 Subscriber 对象。

这里与我们平时理解的观察者去订阅被观察者是相反的，反而是一个被观察者对象订阅了观察者对象。

来看一下代码

public static <T> Observable<T> create(OnSubscribe<T> f) {
        return new Observable<T>(RxJavaHooks.onCreate(f));
    }

传入的参数是一个 OnSubscribe，在 new Observable  的时候用 RxJavaHooks.onCreate 处理这个 OnSubscribe ；

public static <T> Observable.OnSubscribe<T> onCreate(Observable.OnSubscribe<T> onSubscribe) {
        Func1<Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableCreate;
        if (f != null) {
            return f.call(onSubscribe);
        }
        return onSubscribe;
    }

Func1 f = onObservableCreate 这步暂时不看，不影响流程，下面会对这个一起解释一下
这里对参数的操作是直接返回了传过来的 onSubscribe, 也就是相当于调用 new Observable(onSubscribe) ;那 new Observable 的时候做了什么呢？

protected Observable(OnSubscribe<T> f) {
        this.onSubscribe = f;
    }

仅仅是把 onSubscribe 传进来。

以上 create() 的这几步我们暂时可以简单理解为 new 了一个参数为 OnSubscribe 的 Observable 对象。

现在有了 Observable 了，再往下看他会调用 subscribe() 方法，继续看代码

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

发现又调到 Observable.subscribe(subscribe,this);这里的两个参数， subscribe 是 Subscriber 观察者对象，this 是 Observable 本身。

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

...
  // allow the hook to intercept and/or decorate
            RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
            return RxJavaHooks.onObservableReturn(subscriber);
...
 }

这里只留下了核心代码，可以看到主要有三个操作：

1.  subscriber.onStart() 方法
2. RxJavaHooks.onObservableStart() 
3. 第二个返回的 Observable.OnSubscribe 调用call。

 分别来看

public void onStart() {
        // do nothing by default
    }

第一个的 onStart() 方法什么都没做，看来是想留给我们自己来重写的

public static <T> Observable.OnSubscribe<T> onObservableStart(Observable<T> instance, Observable.OnSubscribe<T> onSubscribe) {
        Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableStart;
        if (f != null) {
            return f.call(instance, onSubscribe);
        }
        return onSubscribe;
    }

同样 Func2 的这步跳过，所以直接返回了 onSubscribe 对象。
然后就是返回的 onSubscribe 对象调用了 call() 方法。并传入了 subscriber 作为参数。

是不是发现了什么，对的；这就是我们平时方法的执行顺序，先会走到 onSubscribe 的 call() ,然后在 call() 里面我们用传入的 subscriber 执行 onNext(),onComplete() 等操作。

这就是最基本的 rxjava 执行流程。

Func 和 Action 接口

还记得上面跳过的关于 Func1 和 Func2 吗？现在来看下吧

我们先来看看 Func1 和 Func2 是什么
 

/**
 * Represents a function with one argument.
 * @param <T> the first argument type
 * @param <R> the result type
 */
public interface Func1<T, R> extends Function {
    R call(T t);
}

```

```
/**
 * Represents a function with two arguments.
 * @param <T1> the first argument type
 * @param <T2> the second argument type
 * @param <R> the result type
 */
public interface Func2<T1, T2, R> extends Function {
    R call(T1 t1, T2 t2);
}

看到这个是不是有点无语， Func1 和 Func2 分别代表有一个和两个参数的接口，他们都是通过泛型来定义参数类型和 call() 返回值类型的，也都继承自 Function 接口。

public interface Function {

}

Function 接口又是个空接口，那除了一个参数，两个参数，是不是还有没有参数或者很多个参数的情况呢，去看目录会发现是的，还有 Func0 一直到 FuncN 这些接口，是不是很有趣呢。同理的还有 Action 

public interface Action extends Function {

}

Action 接口是继承自 Function ，然后看 Action1 呢

public interface Action1<T> extends Action {
    void call(T t);
}

看到这儿我们也明白了，Action 就是不带返回值的 Function 啊

知道了Func1() 接口只是有个 call() 方法而已，再来看代码

public static <T> Observable.OnSubscribe<T> onCreate(Observable.OnSubscribe<T> onSubscribe) {
        Func1<Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableCreate;
        if (f != null) {
            return f.call(onSubscribe);
        }
        return onSubscribe;
    }

前面在创建 Observable 的时候会调这个方法，这个 onCreate() 方法，可以看到 Func1的call方法的传入参数类型是 Onsubscribe ,返回值类型也是 Onsubscribe。并且是由 onObservableCreate 赋值的。

onObservableCreate 是什么呢，它是一个静态变量，会在静态代码块中作如下初始化。

onObservableCreate = new Func1<Observable.OnSubscribe, Observable.OnSubscribe>() {
            @Override
            public Observable.OnSubscribe call(Observable.OnSubscribe f) {
                return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);
            }
        };

再回到上一步的 onCreate() 里，f 这时就是这个onObservableCreate ，并因为是在 static 静态代码块中初始化的，所以 f 不为 null，会调用他的 call(onSubscribe) 方法；也就是 new Func1() 的这里的 call() 方法,也就是

RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);

这里也是获取到 ObservableExecuteionHook() 调他的 onCreate(f)

 public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
        return f;
    }

又是什么都没做，直接返回了 f ，即 onSubscribe 对象；所以对我们前面的流程分析并没有太大影响。