RxJava简要分析

首先看一下RxJava简单使用

//被观察者，它决定何时触发事件及触发事件orderObservable observable = Observable.create(new Observable.OnSubscribe<String>() {    @Override    public void call(Subscriber<? super String> subscriber) {        subscriber.onNext("Hello");        subscriber.onNext("world");        subscriber.onCompleted();    }}).map(new Func1<String, String>() {//onNext调用前做的中间处理（即数据过滤转换）public String call(String t) {return t+"mapAction";}});observable.subscribe(subscriber);

//消息订阅，观察者Subscriber<String> subscriber = new Subscriber<String>() {    @Override    public void onNext(String s) {       println("nextCallback-->"+s);    }    @Override    public void onCompleted() {    println("onCompleted");    }    @Override    public void onError(Throwable e) {        println("onError");    }};

输出结果：

nextCallback-->HellomapAction
nextCallback-->worldmapAction
onCompleted

从例子中看出RxJava主要组成：

Observable：被观察者,被观察者本身
OnSubscribe：通知观察者执行哪些行为
Subscriber：观察者，通过实现对应方法做具体处理

一：订阅过程

 public final Subscription subscribe(Subscriber<? super T> subscriber) {        return Observable.subscribe(subscriber, this);    }    static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {     // validate and proceed        ....        // new Subscriber so onStart it        subscriber.onStart();...        // if not already wrapped        if (!(subscriber instanceof SafeSubscriber)) {            // assign to `observer` so we return the protected version            subscriber = new SafeSubscriber<T>(subscriber);        }        // The code below is exactly the same an unsafeSubscribe but not used because it would        // add a significant depth to already huge call stacks.        try {            // allow the hook to intercept and/or decorate            RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);            return RxJavaHooks.onObservableReturn(subscriber);        } catch (Throwable e) {            // special handling for certain Throwable/Error/Exception types            Exceptions.throwIfFatal(e);            // in case the subscriber can't listen to exceptions anymore            if (subscriber.isUnsubscribed()) {                RxJavaHooks.onError(RxJavaHooks.onObservableError(e));            } else {                // if an unhandled error occurs executing the onSubscribe we will propagate it                try {                    subscriber.onError(RxJavaHooks.onObservableError(e));                } catch (Throwable e2) {                    Exceptions.throwIfFatal(e2);                    // if this happens it means the onError itself failed (perhaps an invalid function implementation)                    // so we are unable to propagate the error correctly and will just throw                    RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);                    // TODO could the hook be the cause of the error in the on error handling.                    RxJavaHooks.onObservableError(r);                    // TODO why aren't we throwing the hook's return value.                    throw r; // NOPMD                }            }            return Subscriptions.unsubscribed();        }    }

subscribe.onStart()默认空（重写做一些初始化操作），对subscriber包装成SafeSubscriber，这个SafeSubscriber对原subscriber的一系列方法做了更完善的处理，包括：onError()与onCompleted()只有一个被执行，一旦onError()或者onCompleted()被调用，将从订阅列表SubscriptionList中移除该subscriber将不再调用onNext()等。这里封装为SafeSubscriber后，调onSubscribe.call()，并将subscriber传入，我们看到observerable,onSubscriber,subcreber,被传给RxJavaHooks中，把三者装在里面

  * Hook to call before the child subscriber is subscribed to the OnSubscribe action.         */    @SuppressWarnings({ "rawtypes", "unchecked" })    public static <T> Observable.OnSubscribe<T> onObservableStart(Observable<T> instance, Observable.OnSubscribe<T> onSubscribe) {        Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableStart;        if (f != null) {            return f.call(instance, onSubscribe);        }        return onSubscribe;    }    /**     * Hook to call before the Observable.subscribe() method is about to return a Subscription.     * @param subscription the original subscription     * @return the original or alternative subscription that will be returned     */    public static Subscription onObservableReturn(Subscription subscription) {        Func1<Subscription, Subscription> f = onObservableReturn;        if (f != null) {            return f.call(subscription);        }        return subscription;    }

这里存储subscriber,obseverable,管理回调。这样就完成了一次订阅。

二：数据转换

收到Observable的消息之前我们有可能会对数据流进行处理，例如map()、flatMap()、deBounce()、buffer()等方法，
这里使用了map()方法，它接收了observeable的数据并将通过该方法将数据进行转换后的新数据发出去，即做了中间转化

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

具体操作交给内部类MapSubscriber

static final class MapSubscriber<T, R> extends Subscriber<T> {        final Subscriber<? super R> actual;        final Func1<? super T, ? extends R> mapper;        boolean done;...        @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);        }        @Override        public void onError(Throwable e) {            if (done) {                RxJavaHooks.onError(e);                return;            }            done = true;            actual.onError(e);        }        @Override        public void onCompleted() {            if (done) {                return;            }            actual.onCompleted();        }        @Override        public void setProducer(Producer p) {            actual.setProducer(p);        }    }

MapSubscriber实现Subscriber，持有传入的Subscriber，通过Func1的mapper.call(t)进行转换后再传递给subscriber onNext()，

public interface Func1<T, R> extends Function {    R call(T t);//通过参数t转换为类型T}

三：任务调度（scheduler）

通过使用subscribeOn()、observeOn()方法传入对应的Scheduler去指定每个操作应该运行在何种线程之中

Observable.create(...)
        ...
        .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
        ...
        .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
        .subscribe(...)

public final Observable<T> subscribeOn(Scheduler scheduler) {        if (this instanceof ScalarSynchronousObservable) {            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);        }        return create(new OperatorSubscribeOn<T>(this, scheduler));    }

创建了一个新的Observable，并为新的Observable创建了新的计划表OperatorSubscribeOn对象，新的计划表保存了原始Observable对象和调度器scheduler

public final class OperatorSubscribeOn<T> implements OnSubscribe<T> {    final Scheduler scheduler;    final Observable<T> source;//原observable...    @Override    public void call(final Subscriber<? super T> subscriber) {        final Worker inner = scheduler.createWorker();        subscriber.add(inner);//使用传入的scheduler创建Worker对象,调用schedule方法切换线程        inner.schedule(new Action0() {            @Override            public void call() {                final Thread t = Thread.currentThread();//创建了新的观察者                Subscriber<T> s = new Subscriber<T>(subscriber) {                    @Override                    public void onNext(T t) {                        subscriber.onNext(t);                    }@Override                    public void setProducer(final Producer p) {                        subscriber.setProducer(new Producer() {                            @Override                            public void request(final long n) {                                if (t == Thread.currentThread()) {                                    p.request(n);                                } else {                                    inner.schedule(new Action0() {                                        @Override                                        public void call() {                                            p.request(n);                                        }                                    });                                }                            }                        });                    }...                source.unsafeSubscribe(s);            }        });    }

可以看出调度又scheduler Worker执行

Scheduler io = hook.getIOScheduler();        if (io != null) {            ioScheduler = io;        } else {            ioScheduler = RxJavaSchedulersHook.createIoScheduler();        }...public static Scheduler createIoScheduler(ThreadFactory threadFactory) {        if (threadFactory == null) {            throw new NullPointerException("threadFactory == null");        }        return new CachedThreadScheduler(threadFactory);    }

@Override    public Worker createWorker() {        return new EventLoopWorker(pool.get());    }final AtomicReference<CachedWorkerPool> pool;

这里的pool是一个原子变量引用AtomicReference，所持有的则是CachedWorkerPool，因而这个pool是用来保存worker的缓存池，
我们从缓存池里拿到需要的worker并作了一层封装成为EventLoopWorker：最后调用NewThreadWorker 的scheduleActual

 public NewThreadWorker(ThreadFactory threadFactory) {        ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, threadFactory);        // Java 7+: cancelled future tasks can be removed from the executor thus avoiding memory leak        boolean cancelSupported = tryEnableCancelPolicy(exec);        if (!cancelSupported && exec instanceof ScheduledThreadPoolExecutor) {            registerExecutor((ScheduledThreadPoolExecutor)exec);        }        executor = exec;    }    @Override    public Subscription schedule(final Action0 action) {        return schedule(action, 0, null);    }    @Override    public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {        if (isUnsubscribed) {            return Subscriptions.unsubscribed();        }        return scheduleActual(action, delayTime, unit);    }    public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {        Action0 decoratedAction = RxJavaHooks.onScheduledAction(action);//        ScheduledAction run = new ScheduledAction(decoratedAction);//将传进来的Action分给ScheduledAction        Future<?> f;        if (delayTime <= 0) {            f = executor.submit(run);//提交到线程池执行        } else {            f = executor.schedule(run, delayTime, unit);        }        run.add(f);        return run;    }

Scheduled实现Runable接口

 @Override    public void run() {        try {            lazySet(Thread.currentThread());            action.call();//调用action call方法，实现线程切换        } catch (OnErrorNotImplementedException e) {            signalError(new IllegalStateException("Exception thrown on Scheduler.Worker thread. Add `onError` handling.", e));        } catch (Throwable e) {            signalError(new IllegalStateException("Fatal Exception thrown on Scheduler.Worker thread.", e));        } finally {            unsubscribe();        }    }

再看看observeOn

public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {        if (this instanceof ScalarSynchronousObservable) {            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);        }        return lift(new OperatorObserveOn<T>(scheduler, delayError, bufferSize));    }

 public final class OperatorObserveOn<T> implements Operator<T, T> {    private final Scheduler scheduler;......    public Subscriber<? super T> call(Subscriber<? super T> child) {        if (scheduler instanceof ImmediateScheduler) {            // avoid overhead, execute directly            return child;        } else if (scheduler instanceof TrampolineScheduler) {            // avoid overhead, execute directly            return child;        } else {//创建代理观察者，接收上一级Obsevable传递的数据            ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(scheduler, child, delayError, bufferSize);            parent.init();            return parent;        }    }......//代理观察者，实现Action，调用Scheduler schedule方法实现线程调度 static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {        final Subscriber<? super T> child;        final Scheduler.Worker recursiveScheduler;       ......                public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child, boolean delayError, int bufferSize) {            this.child = child;            this.recursiveScheduler = scheduler.createWorker();            ......            // signal that this is an async operator capable of receiving this many            request(calculatedSize);        }        @Override        public void onNext(final T t) {            ......            schedule();        }        @Override        public void onCompleted() {           ......            schedule();        }        @Override        public void onError(final Throwable e) {            ......            schedule();        }       //任务调度，交给线程池回调Action        protected void schedule() {            if (counter.getAndIncrement() == 0) {                recursiveScheduler.schedule(this);            }        }        // only execute this from schedule()        @Override        public void call() {            ......}}

未完待续。。。