Rxjava2 Maybe

Maybe.create(new MaybeOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NotNull MaybeEmitter<Integer> emitter) throws Exception {
                emitter.onSuccess(1); //可以发送到下游
                emitter.onSuccess(2); //不会发送到下游
                emitter.onComplete(); //不会发送到下游
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println(integer);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                System.out.println(throwable.getMessage());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                System.out.println("onComplete");
            }
        });

Maybe可以发送事件，要么onSuccess，要么onError，要么onComplete，三个只会执行一个。 下面看看源码是怎么做到的

   public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe) {
        ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
        return RxJavaPlugins.onAssembly(new MaybeCreate<T>(onSubscribe));
    }

create方法创建一个MaybeCreate类，

public final class MaybeCreate<T> extends Maybe<T> {

    final MaybeOnSubscribe<T> source;

    public MaybeCreate(MaybeOnSubscribe<T> source) {
        this.source = source;
    }
    ...

调用subscribe

  public final Disposable subscribe(Consumer<? super T> onSuccess, Consumer<? super Throwable> onError,
            Action onComplete) {
         ...
        return subscribeWith(new MaybeCallbackObserver<T>(onSuccess, onError, onComplete));
    }

public final class MaybeCallbackObserver<T> extends AtomicReference<Disposable>
implements MaybeObserver<T>, Disposable, LambdaConsumerIntrospection {

    private static final long serialVersionUID = -6076952298809384986L;

    final Consumer<? super T> onSuccess;

    final Consumer<? super Throwable> onError;

    final Action onComplete;

    public MaybeCallbackObserver(Consumer<? super T> onSuccess, Consumer<? super Throwable> onError,
            Action onComplete) {
        super();
        this.onSuccess = onSuccess;
        this.onError = onError;
        this.onComplete = onComplete;
    }
    ....
}

回到MaybeCreate

public final class MaybeCreate<T> extends Maybe<T> {

    final MaybeOnSubscribe<T> source;

    public MaybeCreate(MaybeOnSubscribe<T> source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(MaybeObserver<? super T> observer) {
        Emitter<T> parent = new Emitter<T>(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
    ...

里面的observer就是MaybeCallbackObserver对象 source.subscribe(parent); 这个参数parent就是我们的emitter。 好了，现在我们可以调用emitter发送我们希望的事件了。 比如发送

  emitter.onSuccess(1); //可以发送到下游

 static final class Emitter<T>  extends AtomicReference<Disposable>
    implements MaybeEmitter<T>, Disposable {

      ....

        @Override
        public void onSuccess(T value) {
            if (get() != DisposableHelper.DISPOSED) {
                Disposable d = getAndSet(DisposableHelper.DISPOSED);
                if (d != DisposableHelper.DISPOSED) {
                    try {
                        if (value == null) {
                            downstream.onError(new NullPointerException("onSuccess called with null. Null values are generally not allowed in 2.x operators and sources."));
                        } else {
                            downstream.onSuccess(value);
                        }
                    } finally {
                        if (d != null) {
                            d.dispose();
                        }
                    }
                }
            }
        }

onSuccess经过重重验证，后调用 downstream.onSuccess(value);， 最后dispose事件，接下来的onComplete也没机会执行了。onError也是一样。

 @Override
        public void onComplete() {
            if (get() != DisposableHelper.DISPOSED) {
                Disposable d = getAndSet(DisposableHelper.DISPOSED);
                if (d != DisposableHelper.DISPOSED) {
                    try {
                        downstream.onComplete();
                    } finally {
                        if (d != null) {
                            d.dispose();
                        }
                    }
                }
            }
        }

基于源码2.2.4版本