我们用Observable提供的静态方法just来写一个简单的列子

Observable.just(1).subscribe(object: Observer<Int>{
           override fun onComplete() {
               Log.d(Constants.TAG, "rx -- onComplete")
           }

           override fun onSubscribe(d: Disposable) {
               Log.d(Constants.TAG, "rx -- onSubscribe")
           }

           override fun onNext(t: Int) {
               Log.d(Constants.TAG, "rx -- onNext --$t")
           }

           override fun onError(e: Throwable) {
               Log.d(Constants.TAG, "rx -- onError")
           }
       })

打印结果

D/cat: rx -- onSubscribe
D/cat: rx -- onNext --1
D/cat: rx -- onComplete

RxJava采用观察者模式实现的，我们知道简单的观察者模式，一定是可观察者(Observable)发生变化，触发观察者(Observer)的方法，实现实时监听

那么问题来了，仅仅一个just方法，如何实现触发操作的呢？

我们来看源码

    public static <T> Observable<T> just(T item) {
        ObjectHelper.requireNonNull(item, "The item is null");
        return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
    }

比较重要是创建了ObservableJust实例，ObservableJust是Observable的实例类

public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {
    private final T value;
    public ObservableJust(final T value) {
        this.value = value;
    }
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        ScalarDisposable<T> sd = new ScalarDisposable<T>(observer, value);
        observer.onSubscribe(sd);
        sd.run();
    }
    @Override
    public T call() {
        return value;
    }
}

看到这，可能也没有明白，构造方法只是传入个一个value值，还是没有讲解到如何触发。

我们先去看下Observable的subscribe方法，代码最终执行

public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, 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;
        }
    }

从上面可以看到最终会调用subscribeActual方法。

再来分析subscribeActual方法

 @Override
    protected void subscribeActual(Observer<? super T> observer) {
        ScalarDisposable<T> sd = new ScalarDisposable<T>(observer, value);
        // 会执行到 onSubscribe()方法
        observer.onSubscribe(sd);
        // next complete方法会在这里执行
        sd.run();
    }

这个ScalarDisposable又是什么呢？

Represents a Disposable that signals one onNext followed by an onComplete.

 @Override
        public void run() {
            if (get() == START && compareAndSet(START, ON_NEXT)) {
                // 执行onNext()方法
                observer.onNext(value);
                if (get() == ON_NEXT) {
                    lazySet(ON_COMPLETE);
                    执行onComplete()方法
                    observer.onComplete();
                }
            }
        }

从整个流程可以看到，当我们Observer订阅了Observable之后，才会触发Observable产出数据，进而触发Observer的监听方法。