RxJava2源码解析

基础解析

我们看下RxJava最简单的写法

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("1");
                emitter.onComplete();
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("onSubscribe");
            }

            @Override
            public void onNext(String s) {
                System.out.println(s);
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError"+e.getLocalizedMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        })

很简单的3个步骤：

1. 创建 Observable ：被观察者
2. 创建 Observer ：观察者
3. 通过 subscribe() 方法建立订阅关系

一个个来看

被观察者的创建

public static  Observable create(ObservableOnSubscribe source) {
    ObjectHelper.requireNonNull(source, "source is null");
    //创建了一个ObservableCreate类，里面包装了我们传入的source参数
    return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}

public final class ObservableCreate extends Observable {
    final ObservableOnSubscribe source;

    public ObservableCreate(ObservableOnSubscribe source) {
        this.source = source;
    }

观察者的创建

这里很简单，只是通过new方法生成了一个简单的Observer对象。

订阅

订阅是通过subscribe方法来执行的，我们来跟踪一下，这个方法是属于Observable类的

public final void subscribe(Observer observer) {
    //校验观察者不为空
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
        //调用subscribeActual方法，然后入参是observer（被观察者）。这个方法是抽象方法，具体的实现是交给子类的
        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);

        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(e);
        throw npe;
    }
}
    /**
     * Operator implementations (both source and intermediate) should implement this method that
     * performs the necessary business logic.
     * 
There is no need to call any of the plugin hooks on the current Observable instance or
     * the Subscriber.
     * @param observer the incoming Observer, never null
     */
    protected abstract void subscribeActual(Observer observer);

最终通过 subscribeActual(observer) 来实现功能，而这个方法是有具体的子类去实现的。从第一步中我们通过Observable.create()来生成的被观察者。里面最终的生成的是 ObservableCreate 这个类。也就是说，这个subscribeActual(observer) 方法是由 ObservableCreate 这个类去实现的，我们去里面找一下。

@Override
protected void subscribeActual(Observer observer) {
    //这里将我们传入的被观察者进行了一层封装，里面实现了ObservableEmitter, Disposable等接口->装饰者模式
    CreateEmitter parent = new CreateEmitter(observer);
    //调用被观察者的onSubscribe方法（这里很神奇，调起者是observer，而不是被订阅者，是为了兼容Rxajva1么？）
    observer.onSubscribe(parent);
    try {
        //这里的source就是我们自己写的那个ObservableOnSubscribe了，调用了里面的subscriber方法，然后参数是封装后的观察者。
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

Observable.create(new ObservableOnSubscribe() {
            //看到了哈，实际是执行的这个方法，这里面的emitter是我们封装之后的CreateEmitter,那么这里面的onNext()，onComplete()又是谁呢？
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("1");
                emitter.onComplete();
            }
        })

我们现在回到我们封装生成的 CreateEmitter 这个类

static final class CreateEmitter
extends AtomicReference
implements ObservableEmitter, Disposable {
    private static final long serialVersionUID = -3434801548987643227L;
    final Observer observer;
    //定义的观察者
    CreateEmitter(Observer observer) {
        this.observer = observer;
    }
    
    @Override
    public void onNext(T t) {
        if (t == null) {
            onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
            return;
        }
        //调用的是观察者的onNext()方法
        if (!isDisposed()) {
            observer.onNext(t);
        }
    }

    @Override
    public void onComplete() {
        if (!isDisposed()) {
            try {
                //调用的是观察者的onComplete()方法
                observer.onComplete();
            } finally {
                //执行完onComplete()方法后要取消订阅
                dispose();
            }
        }
    }
    .....
}

到这里为知，最简单的一个流程基本已经走通了。。

高级用法

线程切换

下层切换

RxJava中我们使用的最多的应该就是进行线程切换了吧？通过 observeOn() 方法来进行线程的随意切换，舒舒服服，再也不用进行恶心的线程处理了。

Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("1");
                emitter.onComplete();
            }
        }).observeOn(Schedulers.io())

observeOn() 方法是属于Observable这个类的。我们跟踪进去这个方法去看看。

public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        //进行空校验
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
    }

这里创建了一个 ObservableObserveOn 对象，所以和之前基础里面将的一样，当调用 subscribe() 方法的时候，会先调用观察者的 onSubscribe() 方法，然后通过subscribe的层层处理，调用这个被观察者里面的 subscribeActual() 方法。

@Override
protected void subscribeActual(Observer observer) {
    if (scheduler instanceof TrampolineScheduler) {//如果传入的scheduler是TrampolineScheduler，那么线程不需要切换，直接调用subscribe方法即可
        source.subscribe(observer);
    } else {
        //根据传入的scheduler，创建Worker
        Scheduler.Worker w = scheduler.createWorker();
        //将传入的observer进行包装，包装为ObserveOnObserver类。
        source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
    }
}

这里可以依据基础篇的进行整理一下，这里将观察者进行了一层包装，也就是我们的观察者由原来的observaer变为了ObserveOnObserver对象。而被观察者还是之前的ObservableCreate（注意，这里只是依据基础中.create()创建的类，所以是ObservableCreate，如果是其他方式创建的被观察者，那么这里可能就是另一个具体的实现类了），并未改变。之前我们讲过，当调用subscribe方法的onNext()，onComplete()方法，其实是调用的观察者的方法。我们现在看一下ObserveOnObserver的onNext和onComplete方法又是做了什么神奇的操作。

@Override
public void onNext(T t) {
    if (done) {//如果已经完成，直接返回
        return;
    }
    if (sourceMode != QueueDisposable.ASYNC) {
        //将onNext的数据放入队列queue
        queue.offer(t);
    }
    //进行线程切换
    schedule();
}

void schedule() {
    if (getAndIncrement() == 0) {
        //调用了worker的方法，这里通过调用线程池，调用了自身的run方法
        worker.schedule(this);
    }
}

这里我们使用的是IO线程，那么在 scheduler.createWorker() 中的生成worker时

@NonNull
@Override
public Worker createWorker() {
    return new EventLoopWorker(pool.get());
}

那么跟到这个类里面的 schedule 方法

@Override
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
    if (tasks.isDisposed()) {
        // don't schedule, we are unsubscribed
        return EmptyDisposable.INSTANCE;
    }
    //这里调用了线程worker的scheduleActual方法，并把Runable对象传进去
    return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}

public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        //留下钩子
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
        ....
        Future f;
        try {
            if (delayTime <= 0) {
                //在线程池中调用封装之后的Runnable
                f = executor.submit((Callable