rxjava1源码笔记（一）

rxjava大致流程

Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("1");
        subscriber.onCompleted();
    }
}).subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {

    }
});

这是一个简单的rxjava调用。
当我们调用到subscribe方法的时候，程序最终会执行到这段

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
   ...
   RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
   return RxJavaHooks.onObservableReturn(subscriber);
   ...
}

这里对Observerable进行了一层封装，并最终将调用我们传入Observerable的onSubscribe对象的call方法，然后在onSubscribe对象的call方法中可以获得订阅的Subscriber对象，我们就在这里调用Subscriber的onNext方法。

rxjava中的map方法

public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
    return unsafeCreate(new OnSubscribeMap<T, R>(this, func));
}

可以看到map方法需要我们传入一个Func1的类，然后返回一个对应变换后的Observable。

首先来介绍一下Func这个接口。RxJava中有一系列Action+数字，Func+数字的接口，这些接口中都只有一个call方法，其中Action接口的call方法都没有返回值， Func接口的call方法都有返回值，后面的那个数字表示call方法接受几个泛型类型的参数。

这里map方法接收的参数类型为Func1

public final class OnSubscribeMap<T, R> implements OnSubscribe<R>

public OnSubscribeMap(Observable<T> source, Func1<? super T, ? extends R> transformer) {
    this.source = source;
    this.transformer = transformer;
}

观察到这个类OnSubscribe的泛型是map转化后的类，这保证了rxjava的方法调用可以以链条的形式进行。

我们再看OnSubscribeMap的call方法

public void call(final Subscriber<? super R> o) {
    MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
    o.add(parent);
    source.unsafeSubscribe(parent);
}

在这个方法里重新创建了一个Subscriber对象，并且订阅了之前传入的Observable，也就是说对之前Observable直接进行处理的将会是新创建的Subscriber对象，这里可以猜测到在MapSubscriber里面将会对Observable传递过来的事件进行转化后再传递订阅了该OnSubscribeMap的Subscriber对象。观察OnSubscribeMap的onNext的实现果然如此。

public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
    this.actual = actual;
    this.mapper = mapper;        
}

@Override
public void onNext(T t) {
    R result;

    try {
        result = mapper.call(t);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        unsubscribe();
        onError(OnErrorThrowable.addValueAsLastCause(ex, t));
        return;
    }

    actual.onNext(result);
}

可以看到在onNext里面通过之前传入的Func1类的call方法来对原始的事件进行加工，加工完后再传递给订阅的Subscriber对象，从而实现了事件的转化。

从上面可以看出，Observable的map方法实际上是新建了一个Observable来给下方的Subscriber订阅，并且在call方法中创建一个新的Subscriber来订阅上方的Observable，这个Subscriber收到事件再对事件进行一次加工后再通知下方的Subscriber接受加工之后的事件，从而实现一个事件的转化，并且依旧能保持函数链式调用。