RxJava 1.x 参数和参数的类型

前面说过，RxJava的数据是不可变的。

RxJava 与面向对象的Java编程不同，面向对象的Java类可以通过类属性和参数两种方式为方法提供业务数据；而RxJava 运行过程中，唯一获取数据的方式是通过参数传递。

一、Observable的三个标注式接口

RxJava 在 Observable 内部定义了三个标注式接口：

public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {}

 public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> {}

public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> {}

这三个标注式接口分别继承自Action1和Funcation1接口。

二、RxJava中的标注式接口

RxJava 定义了两种类型的标注式接口，所谓标注式接口(marker interface)是一种不包含任何方法的接口声明。目的仅仅是为了用于类型检查，通过标注式接口的名称，判断和检查参数数量和类型。

1、分类

一种是 Function ，另外一种是 Action：

public interface Function {}public interface Action extends Function {}

2、关系

Function和Action的关系是: Action 继承了 Function接口。

3、区别

Function 的子类包含输入参数的类型和返回参数类型；

public interface Func1<T, R> extends Function {    R call(T t);}

Action 的子类只包含输入参数的类型，没有返回值。

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

Funcation包括11个子类：

Func0<R>、Func1<T1,R>、Func2<T1,T2,R>、Func3<T1,T2,T3,R>、Func4<T1,T2,T3,T4,R>、Func5<T1,T2,T3,T4,T5,R>、Func6<T1,T2,T3,T4,T5,T6,R>、Func7<T1,T2,T3,T4,T5,T6,T7,R>、Func8<T1,T2,T3,T4,T5,T6,T7,T8,R>、Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>、FunN<R>

Action提供了11个子类：包括

Action0、Action1<T1>、Action2<T1,T2>、Action3<T1,T2,T3>、Action4<T1,T2,T3,T4>、Action5<T1,T2,T3,T4,T5>、Action6<T1,T2,T3,T4,T5,T6>、Action7<T1,T2,T3,T4,T5,T6,T7>、Action8<T1,T2,T3,T4,T5,T6,T7,T8>、Action9<T1,T2,T3,T4,T5,T6,T7,T8,T9>、ActionN

根据Funcation或者Action 名称后面的数字判断参数的数量和是否有返回值。

4、Observable入口参数 OnSubscribe

前面说到的 OnSubscribe 是一个继承了 Action1 的接口，本身就是一个可以接收一个Subscriber参数，没有返回值的Action1子类。

RxJava 在 Observable 内部包含唯一一个属性，类型就是OnSubscribe。

从Funcation到OnSubscribe的继承关系：

Funcation–>Action–>Action1–>OnSubscribe

当使用Observable 的from()和just()方法构造 Observable 实例的时候，传入的数据就被封装到 OnSubscribe 类型的属性中：

final OnSubscribe<T> onSubscribe;

5、OnSubscribe的继承和实现

RxJava 1.x提供了很多 OnSubscribe 的实现类。下面是一部分类的截图：

OnSubscribe接口在 Observable 的 subscribe() 方法被调用时继承自Action1的call()方法被执行,call()方法的参数是 Subscriber<T> ，也就是 subscribe()在订阅了 Observable 的 observer 实例。

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

OnSubscribe 的实现类是封装了原始数据的、继承了Action1的、接收一个参数Subscriber 、提供call()方法的 OnSubscribe 子类。

在这之前，我们提到的数据都是 Observable 类型。
在Observable内部，数据被保存在OnSubscribe类型中，使得原来的被封装的数据有了与外界交互的机会，就是当OnSubscribe的实现类call()方法被调用时，只有在那个时候，也只有在call()方法内部，被 Observable 封装起来的数据，才是可见的。

6、Observable的subscribe()方法

前面说过subscribe()方法是连接Observable和Observe的起点。

RxJava 1.x 提供了6个公共静态方法：

subscribe()subscribe(Action1<? super T>)subscribe(Action1<? super T>, Action1<Throwable>)subscribe(Action1<? super T>, Action1<Throwable>, Action0)subscribe(Observer<? super T>)subscribe(Subscriber<? super T>)

最后这些方法都指向：

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable){...//简化的写法     observable.onSubscribe.call(subscriber);...}

call()方法的逻辑如下：

// this.child 是call()方法传入的参数 subscriberfinal Subscriber<? super T> child = this.child;//array 是 Observable.from(T[] array)中传入的array数据            for (T t : array) {                if (child.isUnsubscribed()) {                    return;                }                child.onNext(t);            }            if (child.isUnsubscribed()) {                return;            }            child.onCompleted();

总结一下：
1、Observable通过 from()和just()将数据封装在OnSubscribe中；
2、OnSubscribe接受 Subscriber 类型的参数，在call()方法中将数据传递给Subscriber的方法。
下面就看看 Subscriber。