RxJava1.2源码解析（二）——变换过程

RxJava的变换过程
1.例子代码 (以map为例)

Observable.create(new Observable.OnSubscribe<Integer>() {
        @Override
        public void call(Subscriber<? super Integer> subscriber) {
            subscriber.onNext(2);
        }
        }).map(new Func1<Integer, String>() {
            @Override
            public String call(Integer o) {
                return "lichaojun" + o ;
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                // TO DO
            }
        });

2.Observable.create()方法在上一篇博客已经说明
创建一个Observable对象ob_1 该对象持有对应的onSubscribe对象onS_1
3.Observable.map()

 public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
         // 创建一个Observable对象ob_2, 该对象持有对应的onSubscribe对象onS_2,即  OnSubscribeMap
        return create(new OnSubscribeMap<T, R>(this, func));
 }
 // 注：OnSubscribeMap这个onSubscribe持有ob_1和func

调用Observable.subscribe()方法
此时是ob_2调用的subscribe

public final Subscription subscribe(final Action1<? super T> onNext) {
        if (onNext == null) {
            throw new IllegalArgumentException("onNext can not be null");
        }

        Action1<Throwable> onError = InternalObservableUtils.ERROR_NOT_IMPLEMENTED;
        Action0 onCompleted = Actions.empty();
        // 对我们传递进来的Action进行了封装，封装成一个Subscriber
        return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
    }

在上一篇博客，讲到了调用subscribe方法时会调用到如下；对应的就会调用到onS_2的call方法，即OnSubscribeMap的call方法

RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);

OnSubscribeMap的call方法

    @Override
    public void call(final Subscriber<? super R> o) {
        // 创建一个新的Subscriber,并且持有ActionSubscriber，和Func
        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
        o.add(parent);
        // 调用ob_1的subscribe()方法unsafeSubscribe
        source.unsafeSubscribe(parent);
    }

ob_1的subscribe方法unsafeSubscribe

public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
        try {
            // new Subscriber so onStart it
            subscriber.onStart();
            // 此处的call方法就是onS_1的call方法，即我们自己定义OnSubscribe  1
            RxJavaHooks.onObservableStart(this, onSubscribe).call(subscriber);
            return RxJavaHooks.onObservableReturn(subscriber);
        } catch (Throwable e) {
            // special handling for certain Throwable/Error/Exception types
            Exceptions.throwIfFatal(e);
            // if an unhandled error occurs executing the onSubscribe we will propagate it
            try {
                subscriber.onError(RxJavaHooks.onObservableError(e));
            } catch (Throwable e2) {
               ...
            }
            return Subscriptions.unsubscribed();
        }
    }

  // 在上面 1 处调用call方法的时候我们就会调用subscriber的onNext()方法，
  // 这个方法对应的就是MapSubscriber的onNext

MapSubscriber的onNext()方法

    @Override
    public void onNext(T t) {
         R result;
         try {
             // 调用Func的call方法
             result = mapper.call(t);
         } catch (Throwable ex) {
             Exceptions.throwIfFatal(ex);
             unsubscribe();
             onError(OnErrorThrowable.addValueAsLastCause(ex, t));
             return;
         }
         // 调用封装了Action的subscriber的onNext,即ActionSubscriber的onNext方法，
         // 在该onNext方法中会调用Action的call方法
         actual.onNext(result);
    }

总结：
在上面的例子代码中，总共涉及到一下东西
两个Observable 对应的两个OnSubscribe（真正订阅的地方call()方法）
Observable_1 —— OnSubscribe
Observable_2 —— OnSubscribeMap
两个观察者subscriber
ActionSubscriber
MapSubscriber 持有ActionSubscriber的对象和Func1的对象。
当触发MapSubscriber 的onNext方法时，会在该方法中调用Func1的call方法以及ActionSubscriber的call方法

流程：
1、ob_2.subscribe—创建ActionSubscriber
2、ob_2对应的OnSubscribe的call方法–创建对应的观察者MapSubscriber （持有ActionSubscriber）
3、ob_1.subscribe
4、ob_1对应的OnSubscribe的call方法–MapSubscriber的onNext方法
5、在MapSubscriber的onNext方法方法中就会依次调用Func的call和ActionSubscriber的onNext方法（即Action的call方法）

RxJava1.2源码解析（二）——变换过程

猜你喜欢