本篇文章是针对 rxjava 1.3.8 的源码进行分析,适用于刚会简单使用 rxjava 的新手阅读。
本片文章的主要内容是:
- Observable
- rxjava 简单的流程源码分析
- Func1 Func2 这几个是什么东西
预备知识
简单介绍下在这篇文章中提到的几个对象
- Observable :翻译过来的意思是可以被观察的,即被观察者
- Observer :即观察者对象
- 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);
...
}
这里只留下了核心代码,可以看到主要有三个操作:
- subscriber.onStart() 方法
- RxJavaHooks.onObservableStart()
- 第二个返回的 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 对象;所以对我们前面的流程分析并没有太大影响。