RxJava#just 操作符源码分析

说明

• just将单个数据转换为发射这个单个数据的Observable。
• 类似于from，但是from会将数组或Iterable的数据取出然后逐个发射，而just只是简单地照样发射，将数组或Iterable当作单个数据。

源码分析

• 先是写的一个实例

Observable.just(1,2,3).subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        
                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        
                    }
                }, new Consumer<Disposable>() {
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        
                    }
                });

• 先是just()

just(T item)
...
just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10)

• 查看源码可以发现有很多重载的方法，接收不同数量的item（1-10个），然后分别发送。

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

    @CheckReturnValue
    @SchedulerSupport("none")
    public static <T> Observable<T> just(T item1, T item2) {
        ObjectHelper.requireNonNull(item1, "The first item is null");
        ObjectHelper.requireNonNull(item2, "The second item is null");
        return fromArray(item1, item2);
    }

@CheckReturnValue
    @SchedulerSupport("none")
    public static <T> Observable<T> fromArray(T... items) {
        ObjectHelper.requireNonNull(items, "items is null");
        if (items.length == 0) {
            return empty();
        } else {
            return items.length == 1 ? just(items[0]) : RxJavaPlugins.onAssembly(new ObservableFromArray(items));
        }
    }

• 如果传入的item只有一个，则直接调用RxJavaPlugins.onAssembly(new ObservableJust(item))，若两个以上，则先判断item合法性然后调用RxJavaPlugins.onAssembly(new ObservableFromArray(items))。先来看看一个item的情况：
• 先是通过item生成ObservableJust类

public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {
    private final T value;

    public ObservableJust(T value) {
        this.value = value;
    }

    protected void subscribeActual(Observer<? super T> s) {
        ScalarDisposable<T> sd = new ScalarDisposable(s, this.value);
        s.onSubscribe(sd);
        sd.run();
    }

    public T call() {
        return this.value;
    }
}

• 这个类比较简单，比较重要的是subscribeActual()方法，这里先提一下，后面会用到。
• 然后就是去调用RxJavaPlugins.onAssembly()方法：

@NonNull
    public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        return f != null ? (Observable)apply(f, source) : source;
    }

• 这里的f为null，所以返回的是source，也就是刚刚我们新建的ObservableJust对象。到这里就已经完成了Observable的初始化，接着订阅观察者，这里观察者我用的是consumer：

public interface Consumer<T> {
    void accept(T var1) throws Exception;
}

• 这个就更简单了，就是一个普通的接口类，里面只有一个函数。
• 说完观察者和被观察者，接下来就是把两个关联起来的subscribe()方法：

@SchedulerSupport("none")
    public final Disposable subscribe() {
        return this.subscribe(Functions.emptyConsumer(), Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }

    @CheckReturnValue
    @SchedulerSupport("none")
    public final Disposable subscribe(Consumer<? super T> onNext) {
        return this.subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }

    @CheckReturnValue
    @SchedulerSupport("none")
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {
        return this.subscribe(onNext, onError, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }

    @CheckReturnValue
    @SchedulerSupport("none")
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {
        return this.subscribe(onNext, onError, onComplete, Functions.emptyConsumer());
    }

    @CheckReturnValue
    @SchedulerSupport("none")
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {
        ObjectHelper.requireNonNull(onNext, "onNext is null");
        ObjectHelper.requireNonNull(onError, "onError is null");
        ObjectHelper.requireNonNull(onComplete, "onComplete is null");
        ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
        LambdaObserver<T> ls = new LambdaObserver(onNext, onError, onComplete, onSubscribe);
        this.subscribe((Observer)ls);
        return ls;
    }

• 同样地，这里也是有多个重载方法，也就是说，你用consumer的时候，最多可以传入四个参数，如果没传，则为emptyxxx，然后通过这四个参数来创建LambdaObserver对象，并作为参数调用this.subscribe()方法：

@SchedulerSupport("none")
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");

        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);
            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
            this.subscribeActual(observer);
        } catch (NullPointerException var4) {
            throw var4;
        } catch (Throwable var5) {
            Exceptions.throwIfFatal(var5);
            RxJavaPlugins.onError(var5);
            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(var5);
            throw npe;
        }
    }

• 这里主要是执行try代码块里面的this.subscribeActual(observer)，这是个Observable类的抽象方法，前面分析知道这里的Observable的具体实现类是ObservableJust，显然这里就是调用该类的subscribeActual()方法：

protected void subscribeActual(Observer<? super T> s) {
        ScalarDisposable<T> sd = new ScalarDisposable(s, this.value);
        s.onSubscribe(sd);
        sd.run();
    }

• 先是通过传进来的LambdaObserver对象和value值创建ScalarDisposable对象，有没有觉得这个方法很眼熟，没错，就是上面新建ObservableJust类时我让你注意的方法，忘了可以回去看看。然后执行onSubscribe()：

public void onSubscribe(Disposable s) {
        if (DisposableHelper.setOnce(this, s)) {
            try {
                this.onSubscribe.accept(this);
            } catch (Throwable var3) {
                Exceptions.throwIfFatal(var3);
                s.dispose();
                this.onError(var3);
            }
        }

    }

• 首先，这里的onSubscribe实例就是LambdaObserver对象实例化时传进来的第四个参数，调用的是对应的accept()方法，而前面创建的ScalarDisposable对象则是用来观察ObservableJust状态有没有断开的。
• 接着就执行sd.run()：

public void run() {
            if (this.get() == 0 && this.compareAndSet(0, 2)) {
                this.observer.onNext(this.value);
                if (this.get() == 2) {
                    this.lazySet(3);
                    this.observer.onComplete();
                }
            }

        }

• 这里的observer还是前面的LambdaObserver，执行它的onNext()方法：

public void onNext(T t) {
        if (!this.isDisposed()) {
            try {
                this.onNext.accept(t);
            } catch (Throwable var3) {
                Exceptions.throwIfFatal(var3);
                ((Disposable)this.get()).dispose();
                this.onError(var3);
            }
        }

    }

• 这里执行的是LambdaObserver实例化的第一个参数的accept()方法，如果出现异常则会调用onError()方法；数据发完时就会调用onComplete()方法：

public void onComplete() {
        if (!this.isDisposed()) {
            this.lazySet(DisposableHelper.DISPOSED);

            try {
                this.onComplete.run();
            } catch (Throwable var2) {
                Exceptions.throwIfFatal(var2);
                RxJavaPlugins.onError(var2);
            }
        }
    }

• 执行实例化时第二个参数的run()方法。

总结

- 所以，整个的顺序就是new Consumer<Disposable>().accept()—>new Consumer<Integer>().accept()—>new Action().run()，若抛出异常则调用new Consumer<Throwable>().accept()。

• 如有不足或建议，欢迎指出！