Rxjava源码——订阅

看完订阅的源码发现Rxjava包装了被观察者对象，然后其它比较容易理解。

1.创建被观察者

Observable observable = Observable.create(
                new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> emitter)
                            throws Exception {
                        emitter.onNext("Hello1");
                        emitter.onNext("Hello2");
                        emitter.onNext("Hello3");
                        emitter.onComplete();
                    }
                });

2.创建观察者

Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("donghe", "onSubscribe");
            }

            @Override
            public void onNext(String s) {
                Log.d("donghe", "onNext : " + s);
            }

            @Override
            public void onError(Throwable e) {
                Log.d("donghe", "onError : " + e.toString());
            }

            @Override
            public void onComplete() {
                Log.d("donghe", "onComplete");
            }
        };

3.订阅观察者

observable.subscribe(observer);

---

分析被观察者创建的过程

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    //省略非核心代码
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

跟进 new ObserableCreate(source)看到了两个信息，第一ObserableCreate继承Obserable,第二ObservableOnSubscribe是其中的一个成员变量。

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

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

Observer创建比较简单，现实了内部的抽象方法。

分析被观察者订阅观察者

public final void subscribe(Observer<? super T> observer) {
    
    //省略非核心代码
    subscribeActual(observer) ;
}

subscribeActual()是一个抽象方法，而它的实现是ObservableCreate这个子类。跟进此类中的subscribeActual方法。

protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    source.subscribe(parent);   
}

CreateEmitter包装了观察者，CreateEmitter实现如下：

static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {
        final Observer<? super T> observer;

        CreateEmitter(Observer<? super T> observer) {
            this.observer = observer;
        }

        @Override
        public void onNext(T t) {
            observer.onNext(t); 
        }

        @Override
        public boolean tryOnError(Throwable t) {
            observer.onError(t);    
        }

        @Override
        public void onComplete() {
             observer.onComplete();  
            }
        }
}

订阅的核心逻辑结束了总结一下