RxJava2 (一)订阅流程源码阅读

当前版本 2.2.19
RxJava2 (一)订阅流程源码阅读
RxJava2 (二)取消订阅流程 dispose( ) 源码阅读
RxJava2 (三)线程切换源码阅读
RxJava2 (四)切换UI主线程源码阅读
RxJava2 (五)just操作符源码阅读
RxJava2 (六)map操作符源码阅读

代码示例

// 创建被观察者
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("Hello World");
        emitter.onComplete();
    }
});
// 订阅观察者
observable.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
        System.out.println("onSubscribe");
        // 取消订阅后,ObservableEmitter发出的消息,观察者Observer将不会再收到.
        d.dispose();
    }
    @Override
    public void onNext(String s) {
        System.out.println("onNext: " + s);
    }
    @Override
    public void onError(Throwable e) {
        System.out.println("onError");
    }
    @Override
    public void onComplete() {
        System.out.println("onComplete");
    }
});

概述

• Observable.create(ObservableOnSubscribe)创建被观察者ObservableCreate对象,该对象中持有ObservableOnSubscribe对象引用.
• observable.subscribe(Observer)调用subscribe()方法最终ObservableOnSubscribe.subscribe(ObservableEmitter)方法最终被执行,用户在方法中写的发射数据逻辑代码将被调用.

Observable.create()

• Observable是一个抽象类,.create()返回Observable子类ObservableCreate对象,该对象持有用户创建的ObservableOnSubscribe对象的引用.

public abstract class Observable<T> implements ObservableSource<T> {
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ...
        // RxJavaPlugins.onAssembly(Observable<T> source) 如果source不为null,会将source直接返回.
        // 最终返回ObservableCreate对象,该对象中持有ObservableOnSubscribe引用
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }
}

Observable.subscribe()

• Observable.create()返回的ObservableCreate对象,该对象是Observable的子类. ObservableCreate没有重写父类的subscribe()方法,所以.subscribe()最终调用的是Observable中的.subscribe()
• .subscribe()中又调用.subscribeActual(),ObservableCreate重写了.subscribeActual()方法,所以最终调用到ObservableCreate.subscribeActual().

// Observable类
public abstract class Observable<T> implements ObservableSource<T> {
    ...
    public final void subscribe(Observer<? super T> observer) {
            // observer就是用户创建的观察者对象
        try {
            // RxJavaPlugins.onSubscribe(this, observer); : 最后返回当前通过参数传入的observer对象.
            observer = RxJavaPlugins.onSubscribe(this, observer);
            // 下面看`ObservableCreate.subscribeActual(Observer)`方法,
            subscribeActual(observer);
        } 
        ...
    }
}
// ObservableCreate类
public final class ObservableCreate<T> extends Observable<T> {
    // sourec就是调用Observable.create(ObservableOnSubscribe)传入的ObservableOnSubscribe对象,
    // 用户在该类的subscribe()方法中写发射数据的逻辑.
    final ObservableOnSubscribe<T> source;
    
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }    

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        // 创建CreateEmitter对象,然后传入观察者observer
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        // CreateEmitter父类是Disposable类,所以能被观察者中的onSubscribe(Disposable)方法接收
        observer.onSubscribe(parent);
        try {
            // 开始发射数据.用户在ObservableCreate.subscribe()方法中写发射数据逻辑,使用emitter调用观察者中的onNext()等方法
            // CreateEmitter持有观察者对象引用,最后使用CreateEmitter对象调用onNext()等方法最终都会被委托给真实的观察者去执行.
            source.subscribe(parent);
        } ...
    }
}
// 案例中创建ObservableOnSubscribe对象
Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        // 使用CreateEmitter发射数据,最终调用Oberver观察者中的onNext()方法
        emitter.onNext("Hello World");
        emitter.onComplete();
    }
})

emitter.onNext("Hello World")

• CreateEmitter对象中持有用户创建的观察者引用Observer.

// 数据发射开始
emitter.onNext("Hello World");
// ObservableCreate.CreateEmitter类
public final class ObservableCreate<T> extends Observable<T> {
    static final class CreateEmitter<T>extends AtomicReference<Disposable>implements ObservableEmitter<T>, Disposable {
        final Observer<? super T> observer; // 用户创建的Observer观察者引用
        
        @Override
        public void onNext(T t) {
            ...
            // 判断是否取消订阅
            if (!isDisposed()) {
                // CreateEmitter对象调用的onNext()方法最终委托给真实观察者执行
                observer.onNext(t);
            }
        }
        // 同理onComplete()也是一样的逻辑调用
        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    // 委托
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }

        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }
    }
}