从源码出发了解RxJava的使用（中）

---

序言

  RxJava牛逼的地方有两点：一是变换（map，flatMap），二是线程控制（subscribeOn，observeOn）。它们的底层实现比较复杂，特别是flatMap，为了了解它，我花了好多力气，很多次都被它的各种调用给绕晕了，不过皇天不负苦心人，终于让我揭开了它的神秘面纱。

变换–map

Integer[] array = new Integer[]{1, 2, 3};
Observable.from(array)
        .map(new Func1<Integer, String>() {
            @Override
            public String call(Integer i) {
                Log.i("My", "call " + i);
                return "str" + i;
            }
        })
        .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i("My", "call " + s);
            }
        });

  运行结果：
  

.map(new Func1<Integer, String>() {

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

new OperatorMap<T, R>(func)

public final class OperatorMap<T, R> implements Operator<R, T> {

    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) {
        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
        o.add(parent);
        return parent;
    }

    static final class MapSubscriber<T, R> extends Subscriber<T> {
        final Subscriber<? super R> actual;       
        final Func1<? super T, ? extends R> mapper;

        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 = mapper.call(t);
            actual.onNext(result);
        }
        @Override
        public void onError(Throwable e) {
            actual.onError(e);
        }
        @Override
        public void onCompleted() {
            actual.onCompleted();
        }
        @Override
        public void setProducer(Producer p) {
            actual.setProducer(p);
        }
    }
}

return lift(new OperatorMap<T, R>(func));

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

new OnSubscribeLift<T, R>(onSubscribe, operator)

public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {
    static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
    final OnSubscribe<T> parent;
    final Operator<? extends R, ? super T> operator;

    public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {
        this.parent = parent;
        this.operator = operator;
    }

    @Override
    public void call(Subscriber<? super R> o) {
        Subscriber<? super T> st = hook.onLift(operator).call(o);
        try {
            // new Subscriber created and being subscribed with so 'onStart' it
            st.onStart();
            parent.call(st);
        } catch (Throwable e) {
            st.onError(e);
        }
    }
}

hook.onLift(operator)

public <T, R> Operator<? extends R, ? super T> onLift(final Operator<? extends R, ? super T> lift) {
    return lift;
}

  总结：

public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
    return lift(new OperatorMap<T, R>(func));
}
1）return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
2）OnSubscribeLift对象的call方法
    public void call(Subscriber<? super R> o) {
        Subscriber<? super T> st = operator.call(o);
        st.onStart();
        onSubscribe.call(st);    
    }
3）OperatorMap对象的call方法
    public Subscriber<? super T> call(final Subscriber<? super R> o) {
        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
        return parent;
    }
4）MapSubscriber对象的onNext方法
    public void onNext(T t) {
        R result = mapper.call(t);
        actual.onNext(result);
    }

变换–flatMap

Student[] array = getStudentArray();
Observable.from(array)
        .flatMap(new Func1<Student, Observable<Course>>() {
            @Override
            public Observable<Course> call(Student student) {
                Log.i("My", "call " + student.getName());
                return Observable.from(student.getCourses());
            }
        })
        .subscribe(new Action1<Course>() {
            @Override
            public void call(Course course) {
                Log.i("My", "call " + course.getName());
            }
        });

  运行结果：
  

.flatMap(new Func1<Student, Observable<Course>>() {

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

return merge(map(func));

public static <T> Observable<T> merge(Observable<? extends Observable<? extends T>> source) {
    return source.lift(OperatorMerge.<T>instance(false));
}

OperatorMerge.<T>instance(false)

public final class OperatorMerge<T> implements Operator<T, Observable<? extends T>> {

    @Override
    public Subscriber<Observable<? extends T>> call(final Subscriber<? super T> child) {
        MergeSubscriber<T> subscriber = new MergeSubscriber<T>(child, delayErrors, maxConcurrent);
        MergeProducer<T> producer = new MergeProducer<T>(subscriber);
        subscriber.producer = producer;
        return subscriber;
    }

    static final class MergeProducer<T> extends AtomicLong implements Producer {

        final MergeSubscriber<T> subscriber;

        public MergeProducer(MergeSubscriber<T> subscriber) {
            this.subscriber = subscriber;
        }

    }

    static final class MergeSubscriber<T> extends Subscriber<Observable<? extends T>> {
        final Subscriber<? super T> child;

        public MergeSubscriber(Subscriber<? super T> child, boolean delayErrors, int maxConcurrent) {
            this.child = child;
        }

        @Override
        public void onNext(Observable<? extends T> t) {
            InnerSubscriber<T> inner = new InnerSubscriber<T>(this, uniqueId++);
            addInner(inner);
            t.unsafeSubscribe(inner);
        }

        void addInner(InnerSubscriber<T> inner) {
            InnerSubscriber<?>[] a = innerSubscribers;
            int n = a.length;
            InnerSubscriber<?>[] b = new InnerSubscriber<?>[n + 1];
            System.arraycopy(a, 0, b, 0, n);
            b[n] = inner;
            innerSubscribers = b;
        }

        void tryEmit(InnerSubscriber<T> subscriber, T value) {
            emitScalar(subscriber, value, r);
        }

        protected void emitScalar(InnerSubscriber<T> subscriber, T value, long r) {
            child.onNext(value);
        }

        static final class InnerSubscriber<T> extends Subscriber<T> {
            final MergeSubscriber<T> parent;

            public InnerSubscriber(MergeSubscriber<T> parent, long id) {
                this.parent = parent;
            }

            @Override
            public void onNext(T t) {
                parent.tryEmit(this, t);
            }
        }
    }
}

  总结：

Observable.from(array).flatMap
1. return create(new OnSubscribeFromArray<T>(array)); --> onSubscribe为OnSubscribeFromArray
2. return merge(map(func));
   1）map(func) --> return lift(new OperatorMap<T, R>(func));
      --> return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
      --> onSubscribe为OnSubscribeLift#OperatorMap
   2）merge(map(func)) --> return source.lift(OperatorMerge.<T>instance(false));
      --> return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
      --> onSubscribe为OnSubscribeLift#OperatorMerge
OnSubscribeFromArray --> OnSubscribeLift#OperatorMap --> OnSubscribeLift#OperatorMerge

1>> subscribe(mySubscriber)
    static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        subscriber.onStart();  // subscriber为mySubscriber
        observable.onSubscribe.call(subscriber);  // onSubscribe为OnSubscribeLift#OperatorMerge
        return subscription;
    }
2>> observable.onSubscribe.call(subscriber) --> OnSubscribeLift#OperatorMerge.call(mySubscriber)
    public void call(Subscriber<? super R> o) {  // o为mySubscriber
        Subscriber<? super T> st = operator.call(o);  // operator为OperatorMerge
        st.onStart();
        onSubscribe.call(st);  // onSubscribe为OnSubscribeLift#OperatorMap
    }
3>> operator.call(o) --> OperatorMerge.call(mySubscriber)
    public Subscriber<Observable<? extends T>> call(final Subscriber<? super T> child) {  // child为mySubscriber
        MergeSubscriber<T> subscriber = new MergeSubscriber<T>(child, delayErrors, maxConcurrent);
        MergeProducer<T> producer = new MergeProducer<T>(subscriber);
        subscriber.producer = producer;
        return subscriber;
    }
4>> onSubscribe.call(st) --> OnSubscribeLift#OperatorMap.call(MergeSubscriber st)
    public void call(Subscriber<? super R> o) {  // o为MergeSubscriber
        Subscriber<? super T> st = operator.call(o);  // operator为OperatorMap
        st.onStart();
        onSubscribe.call(st);  // onSubscribe为OnSubscribeFromArray     
    }
5>> operator.call(o) --> OperatorMap.call(MergeSubscriber o)
        public Subscriber<? super T> call(final Subscriber<? super R> o) {  // o为MergeSubscriber
        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
        return parent;
    }
6>> onSubscribe.call(st) --> OnSubscribeFromArray.call(MapSubscriber st)
    public void call(Subscriber<? super T> child) {  // child为MapSubscriber
        child.setProducer(new FromArrayProducer<T>(child, array));  // T为Student
    }
7>> MapSubscriber.setProducer --> FromArrayProducer.request
    public void request(long n) {
        final Subscriber<? super T> child = this.child;  // child为MapSubscriber
        for (T t : array)
            child.onNext(t);  // t为Student
        child.onCompleted();
    }
8>> child.onNext(t) --> MapSubscriber.onNext(Student t)
    public void onNext(T t) {  // t为Student
        R result = mapper.call(t);  // result为Observable<Course>，result.onSubscribe为OnSubscribeFromArray
        actual.onNext(result);  // actual为MergeSubscriber
    }
9>> actual.onNext(result) --> MergeSubscriber.onNext(Observable<Course> t)
    public void onNext(Observable<? extends T> t) {
        InnerSubscriber<T> inner = new InnerSubscriber<T>(this, uniqueId++);
        t.unsafeSubscribe(inner);
    }
10>> t.unsafeSubscribe(inner) --> Observable<Course>.unsafeSubscribe(InnerSubscriber<Course> inner)
    public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {  // subscriber为InnerSubscriber
        subscriber.onStart();
        onSubscribe.call(subscriber);  // onSubscribe为OnSubscribeFromArray
        return subscription;
    }
11>> onSubscribe.call(subscriber) --> OnSubscribeFromArray.call(InnerSubscriber subscriber)
    public void call(Subscriber<? super T> child) {  // child为InnerSubscriber
        child.setProducer(new FromArrayProducer<T>(child, array));  // T为Course
    }
12>> InnerSubscriber.setProducer --> FromArrayProducer.request
    public void request(long n) {
        final Subscriber<? super T> child = this.child;  // child为InnerSubscriber
        for (T t : array)
            child.onNext(t);  // t为Course
        child.onCompleted();
    }
13>> child.onNext(t) --> InnerSubscriber.onNext(Course t)
    public void onNext(T t) {  // t为Course
        parent.tryEmit(this, t);  // parent为MergeSubscriber
    }
14>> parent.tryEmit(this, t) --> MergeSubscriber.tryEmit(InnerSubscriber,Course)
    void tryEmit(InnerSubscriber<T> subscriber, T value) {  // subscriber为InnerSubscriber
        emitScalar(subscriber, value, r);
    }
15>> emitScalar(subscriber, value, r) --> MergeSubscriber.emitScalar(InnerSubscriber, T, r)
    protected void emitScalar(InnerSubscriber<T> subscriber, T value, long r) {
        child.onNext(value);  // child为mySubscriber
    }

过滤–filter

Observable.from(new String[]{"hello1", "world1", "hello2", "world2"})
        .filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                if (s.endsWith("1"))
                    return true;
                else
                    return false;
            }
        })
        .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i("My", "call " + s);
            }
        });

  运行结果：
  

.filter(new Func1<String, Boolean>() {

public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
    return create(new OnSubscribeFilter<T>(this, predicate));
}

new OnSubscribeFilter<T>(this, predicate)

public final class OnSubscribeFilter<T> implements OnSubscribe<T> {

    final Observable<T> source;
    final Func1<? super T, Boolean> predicate;

    public OnSubscribeFilter(Observable<T> source, Func1<? super T, Boolean> predicate) {
        this.source = source;
        this.predicate = predicate;
    }

    @Override
    public void call(final Subscriber<? super T> child) {
        FilterSubscriber<T> parent = new FilterSubscriber<T>(child, predicate);
        source.unsafeSubscribe(parent);
    }

    static final class FilterSubscriber<T> extends Subscriber<T> {

        final Subscriber<? super T> actual;
        final Func1<? super T, Boolean> predicate;

        public FilterSubscriber(Subscriber<? super T> actual, Func1<? super T, Boolean> predicate) {
            this.actual = actual;
            this.predicate = predicate;
        }

        @Override
        public void onNext(T t) {
            boolean result;
            result = predicate.call(t);
            if (result) {
                actual.onNext(t);
            }
        }

        @Override
        public void onError(Throwable e) {
            actual.onError(e);
        }

        @Override
        public void onCompleted() {
            actual.onCompleted();
        }

        @Override
        public void setProducer(Producer p) {
            actual.setProducer(p);
        }
    }
}

source.unsafeSubscribe(parent);

public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
    subscriber.onStart();
    onSubscribe.call(subscriber);
    return subscription;
}

  总结：

Observable.from(array).filter
1. return create(new OnSubscribeFromArray<T>(array)); --> onSubscribe为OnSubscribeFromArray
2. return create(new OnSubscribeFilter<T>(this, predicate)); --> onSubscribe为OnSubscribeFilter
OnSubscribeFromArray --> OnSubscribeFilter
// ***********************************************************************************************
1>> subscribe(mySubscriber)
    static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        subscriber.onStart();  // subscriber为mySubscriber
        onSubscribe.call(subscriber);  // onSubscribe为OnSubscribeFilter
        return subscription;
    }
2>> onSubscribe.call(subscriber) --> OnSubscribeFilter.call(mySubscriber)
    public void call(final Subscriber<? super T> child) {  // child为mySubscriber
        FilterSubscriber<T> parent = new FilterSubscriber<T>(child, predicate);
        source.unsafeSubscribe(parent);  // source为Observable#OnSubscribeFromArray
    }
3>> source.unsafeSubscribe(parent) --> Observable#OnSubscribeFromArray.unsafeSubscribe(FilterSubscriber)
    public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {  // subscriber为FilterSubscriber
        subscriber.onStart();
        onSubscribe.call(subscriber);  // onSubscribe为OnSubscribeFromArray
        return subscription;
    }
4>> onSubscribe.call(subscriber) --> OnSubscribeFromArray.call(FilterSubscriber)
    public void call(Subscriber<? super T> child) {  // child为FilterSubscriber
        child.setProducer(new FromArrayProducer<T>(child, array));
    }
5>> child.setProducer --> FromArrayProducer.request
    public void request(long n) {
        final Subscriber<? super T> child = this.child;  // child为FilterSubscriber
        for (T t : array)
            child.onNext(t);
        child.onCompleted();
    }
6>> child.onNext(t) --> FilterSubscriber.onNext(t)
    public void onNext(T t) {
        boolean result;
        result = predicate.call(t);
        if (result) {
            actual.onNext(t);  // actual为mySubscriber
        }
    }

  变换和过滤终于分析完了~，剩下的就是线程控制了，不知道你们对我这样的源码分析方式能否接受得了呢？如果觉得还行，就请看下一篇“从源码出发了解RxJava的使用（下）”。