ob USER_SEQUENCES在哪个schema下 observablesource

转载

mob6454cc74c0fc 2024-03-27 06:40:46

基本概念

Observable 是一个可观察源，可以发出一些事件。事件发出时，会通知注册了该可观察源的观察者，观察者收到事件做出相应的动作。
它发布的onNext、onComplete、onError 三个事件类型可被观察。
它实现了 ObservableSource 接口，该接口只有一个subscribe方法，方法参数为 Observer，该方法称为订阅。

public interface ObservableSource<T> {
    void subscribe(@NonNull Observer<? super T> observer);
}

Observer 是观察者，它是一个接口，内部定义的方法用于响应各类型的事件。

public interface Observer<T> {
   
    void onSubscribe(@NonNull Disposable d);//订阅时被调用

    void onNext(@NonNull T t);//接收到 onNext 事件

    void onError(@NonNull Throwable e);//接收到 onError 事件
    
    void onComplete();//接收到 onComplete 事件
}

可观察源发布事件，称为上游，观察者接收事件，称为下游。上游和下游通过 subscribe 方法建立订阅关系，也就是 Observer 订阅了 Observable，订阅后事件便会从上游传递到下游。

简单使用

Observable.create(new ObservableOnSubscribe<Object>() {
    @Override
    public void subscribe(ObservableEmitter<Object> e) throws Exception {
        e.onNext(0);
		e.onNext(1);
		e.onNext(2);
        e.onComplete();
        //e.onError(new Throwable());
    }
}).subscribe(new Observer<Object>() {
    @Override
    public void onSubscribe(Disposable d) {
    	System.out.println("onSubscribe");
    }
    @Override
    public void onNext(Object o) {
        System.out.println("onNext " + o);
    }
    @Override
    public void onError(Throwable e) {
   		System.out.println("onError " + e);
    }
    @Override
    public void onComplete() {
    	System.out.println("onComplete ");
    }
});

代码中创建 Observable 后调用 subscribe 订阅了 Observer，和上面说的 Observer 订阅 Observer 相反，这是为了能够链式调用而设计的，关系并没有乱。

上游可以发送多个 onNext 事件，下游也可以接收多个onNext 事件。
上游可以只发送 onNext 、onComplete 和 onError 其中的一个事件。
下游接收到上游发送 onComplete 或 onError 事件后，将会结束本次订阅，不再接受事件，即使后面上游又发布了任何类型的事件。
一次订阅中，要么发送 onComplete，要么发送 onError，两者互斥，不要都发送，也不要多次发送。若发布了 onComplete，接着又发布onError ，代码运行时会出错。
上游的事件在订阅之后才开始发布。

ObservableEmitter 是发射器，用来发布事件。
Disposable 可以用来取消订阅，调用它的 dispose() 方法后，上游和下游被切断，将不会再接受到上游的事件，但它并影响上游继续发布事件。

另外，subscribe 方法还可以不传参数或者传其他类型参数。

Observable.create(new ObservableOnSubscribe<Object>() {
    @Override
    public void subscribe(ObservableEmitter<Object> e) throws Exception {
        e.onNext(0);
    }
}).subscribe();//不传参数

不传参数，表示你上游尽管发布事件吧，我下游不关心也不处理事件。其实这个方法内部是有设置下游的观察者，看看源码：

public final Disposable subscribe() {
    return subscribe(Functions.emptyConsumer(), Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
}

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<T>(onNext, onError, onComplete, onSubscribe);
    subscribe(ls);//这里调用了ObservableSource的subscribe方法设置观察者
    return ls;
}

可以看到该方法最终还是会调用 ObservableSource 的 subscribe 方法，并且该方法会返回一个Disposable 用于取消订阅。如果有多个Disposable 需要管理怎么办呢，可以使用 CompositeDisposable，它有add,remote,clear 等方法来管理。
若下游只关心 onNext 事件，则可以只传一个消费者 Consumer 参数：

Observable.create(new ObservableOnSubscribe<Object>() {
    @Override
    public void subscribe(ObservableEmitter<Object> e) throws Exception {
        e.onNext(0);
    }
}).subscribe(new Consumer<Object>() {
    @Override
    public void accept(Object o) throws Exception {
        System.out.println("onNext " + o);
    }
});

若下游只关心 onNext 和 onError，可以在后面再加一个 Consumer 参数。类似还可以传更多参数，来设置你只关心的事件，其实方法最终都会调用 ObservableSource 的 subscribe 方法。