public void hystrix(String username){

        /**
         * R call();
         */
        Func0<Observable<Object>> defer = new Func0<Observable<Object>>(){
            @Override
            public Observable<Object> call() {
                System.out.println("4.username = " + username);
                return Observable.just(2);
            }
        };
        /**
         * R call(T t);
         */
        Func1<Object,Object> map = new Func1<Object,Object>(){

            @Override
            public Object call(Object observable) {
                System.out.println("5.username = " + username);
                if(observable instanceof Integer){
                    return ((Integer) observable)* 3;
                }
                return null;
            }
        };

        Observable.defer(new Func0<Observable<Object>>() {
            @Override
            public Observable<Object> call() {
                System.out.println("1.username = " + username);
                return Observable.defer(new Func0<Observable<Object>>() {
                    @Override
                    public Observable<Object> call() {
                        System.out.println("2.username = " + username);
                        Observable rtn = Observable.defer(defer);
//                                .map(map);
                          return rtn.doOnNext(new Action1() {
                              @Override
                              public void call(Object o) {
                                  System.out.println("this is doOnNext 1");
                              }
                          });
//                        return rtn.doOnCompleted(new Action0() {
//                            @Override
//                            public void call() {
//                                System.out.println("3.username = " + username);
//                            }
//                        });
                    }
                }).doOnNext(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        System.out.println("this is doOnNext");
                    }
                }).doOnSubscribe(new Action0() {
                    @Override
                    public void call() {
                        System.out.println("this is doOnSubscribe");
                    }
                });
            }
        }).subscribe(new Subscriber<Object>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {
                System.out.println("this is onNext o = " + o);
            }
        });
    }

1、OperatorDoOnSubscribe

OperatorDoOnSubscribe是Operator的实现类。

public class OperatorDoOnSubscribe<T> implements Operator<T, T> {
    private final Action0 subscribe;

    /**
     * Constructs an instance of the operator with the callback that gets invoked when the modified Observable is subscribed
     * @param subscribe the action that gets invoked when the modified {@link rx.Observable} is subscribed
     */
    public OperatorDoOnSubscribe(Action0 subscribe) {
        this.subscribe = subscribe;
    }

    @Override
    public Subscriber<? super T> call(final Subscriber<? super T> child) {
        subscribe.call();
        // Pass through since this operator is for notification only, there is
        // no change to the stream whatsoever.
        return Subscribers.wrap(child);
    }
}

public final Observable<T> doOnSubscribe(final Action0 subscribe) {
    return lift(new OperatorDoOnSubscribe<T>(subscribe));
}

当前的操作符OperatorDoOnSubscribe是由被观察者OnSubscribeDoOnEach【doOnNext】的。

public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
    return unsafeCreate(new OnSubscribeLift<T, R>(onSubscribe, operator));
}

所以onSubscribe指的是OnSubscribeDoOnEach。

2、OnSubscribeLift

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

所以当前被观察者OperatorDoOnSubscribe对应的onSubscribe为OnSubscribeLift。

public void call(Subscriber<? super R> o) {
    try {
        Subscriber<? super T> st = RxJavaHooks.onObservableLift(operator).call(o);
        try {
            st.onStart();
            parent.call(st);
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            st.onError(e);
        }
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        o.onError(e);
    }
}

由此得知，处理订阅是优先处理当前被观察者订阅信息。