RxJava操作符学习

RxJava操作符学习

操作符学习推荐阅读：官方英文 翻译中文

两个重要的方法

subscribe()

先来看一个简单的例子

//被观察者
Observable.OnSubscribe<Integer> integerOnSubscribe = new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> subscriber) {
        subscriber.onNext(1);
        subscriber.onNext(2);
        subscriber.onNext(3);
        subscriber.onCompleted();
    }
};

//观察者
Subscriber<Integer> integerSubscriber = new Subscriber<Integer>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }

    @Override
    public void onError(Throwable e) {}

    @Override
    public void onNext(Integer i) { System.out.println(i); }
};

//订阅
Observable.create(integerOnSubscribe)
        .subscribe(integerSubscriber);

执行上面的例子，将看到以下结果：

1
2
3
onCompleted

那么在这过程中发生了什么呢？一起到源码里看看！
先来看看create（），在Observable类中，有这样的定义：

final OnSubscribe<T> onSubscribe;

protected Observable(OnSubscribe<T> f) {
    this.onSubscribe = f;
}

public final static <T> Observable<T> create(OnSubscribe<T> f) {
    return new Observable<T>(f);
}  

也就是说，上面的例子中，我们的integerOnSubscribe对象被onSubscribe变量引用了。
接着来再看与subscribe()有关的关键的代码：

public final Subscription subscribe(Subscriber<? super T> subscriber) {
    //this - 即当前对象传递给下面的函数，主要使用this.onSubscriber引用
    return Observable.subscribe(subscriber, this);  
}

private static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
    //删除了大部分代码，只保留关键代码，并且假设执行过程没有异常抛出
    observable.onSubscribe.call(subscriber);
    return subscriber;
}

注意最关键的代码observable.onSubscribe.call(subscriber)，这里的observable.onSubscribe也就是我们的integerOnSubscribe对象引用，而subscriber就是我们传入subscribe()的integerSubscriber对象。所以这句代码的中变量替换为上面例子的对象就变为：

integerOnSubscribe.call(integerSubscriber);

也就是说在integerOnSubscribe.call()中执行了

integerSubscriber.onNext(1);
integerSubscriber.onNext(2);
integerSubscriber.onNext(3);
integerSubscriber.onCompleted();

因此，我们的程序也就依次输出了

1
2
3
onCompleted

总结一下整个过程就是：有一个被观察者integerSubscriber和一个观察者integerSubscriber，使用subscribe()使他们产生订阅关系，subscribe()所做的事情就是，将观察者传递给被观察者的call(),并在call()中执行观察者的onNext()和onCompleted()。

integerSubscriber.call(integerSubscriber);

lift()

由于lift()接受一个操作符参数，所以我们这里使用map()来讲lift(),也可以随便了解map(),假设代码是这样的：

Observable.OnSubscribe<Integer> myOnSubscribe = new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> subscriber) {
        subscriber.onNext(1);
    }
};
Subscriber<String> mySubscriber = new Subscriber<String>() {
    @Override
    public void onNext(String s) {
        System.out.print(s);
    }
};
Func1<Integer, String> myFunc = new Func1<Integer, String>() {
    @Override
    public String call(Integer i) {
        return i + " programmer";
    }
};

Observable.create(myOnSubscribe)
        .map(myFunc)
        .subscribe(mySubscriber);

这里只看.map(myFunc)这一句代码，其他部分分析可以查看开头的例子。先看看map()的源码：

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

出现了lift(),进入看看：

//经过删减和修改的代码
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
    Observable.OnSubscribe<String> onSub = new OnSubscribe<R>() {
        @Override
        public void call(Subscriber<? super R> o) {
            Subscriber<? super T> st = operator.call(o);
                st.onStart();
                onSubscribe.call(st);
        }
    }
    //总是返回新被观察者对象
    return new Observable<R>(onSub);
}

可以看到，lift()总是创建一个新的被观察者。在看看new OperatorMap<T, R>(func)干了什么：

public final class OperatorMap<T, R> implements Operator<R, T> {
    //转换操作函数
    private final Func1<? super T, ? extends R> transformer;
    //构造函数
    public OperatorMap(Func1<? super T, ? extends R> transformer) {
        this.transformer = transformer;
    }

    @Override
    public Subscriber<? super T> call(final Subscriber<? super R> o) {
        return new Subscriber<T>(o) {
            @Override
            public void onNext(T t) {
                o.onNext(transformer.call(t));
            }
        };
    }
}

换成上面例子的变量，则lift()中

Observable.OnSubscribe<String> onSub = new OnSubscribe<String>(){
    @Override
    public void call(Subscriber<? super String> o) {
        Subscriber<Integer> st = new OperatorMap<Integer,String>(myFunc).call(o);
                               = new Subscriber<Integer>(Subscriber<? super String> o){
                                    onNext(Integer t){
                                        o.onNext(myFunc.call(t));
                                    }
                                }
        onSubscribe.call(st);   <===    myOnSubscribe.call(st)
    }
}

订阅时：

Observable.create(myOnSubscribe)

        .map(myFunc)  <===  return new Observable<String>(onSub)

        .subscribe(mySubscriber);  <===   onSub.call(mySubscriber)

所以运行流程为：

//本例中t=1    
myOnSubscribe.call(st) -> st.onNext(t) -> mySubscriber.onNext(myFunc.call(t))