Subjects

Subject可以看成是一个桥梁或者代理，在某些ReactiveX实现中(如RxJava)，它同时充当了Observer和Observable的角色。因为它是一个Observer，它可以订阅一个或多个 Observable;又因为它是一个Observable，它可以转发它收到(Observe)的数据，也可以发射新的数据。

对我来说为什么用subjects呢？所有Subject都可以直接发射,不需要发射器的引用和 Observable.create()不同

AsyncSubject:简单的说使用AsyncSubject无论输入多少参数，永远只输出最后一个参数。
但是如果因为发生了错误而终止，AsyncSubject将不会发射任何数据，只是简单的向前传递这个错误通知。

BehaviorSubject:会发送离订阅最近的上一个值，没有上一个值的时候会发送默认值。

如果原始的Observable因为发生了一个错误而终止，BehaviorSubject将不会发射任何数据，只是简单的向前传递这个错误通知。

publishSubject(subject里最常用的):可以说是最正常的Subject，从那里订阅就从那里开始发送数据。

如果原始的Observable因为发生了一个错误而终止，PublishSubject将不会发射任何数据，只是简单的向前传递这个错误通知。

PublishSubject bs = PublishSubject.create();
        bs.subscribe(o -> System.out.println("1:"+o));
        bs.onNext(1);
        bs.onNext(2);
        bs.subscribe(o -> System.out.println("2:"+o));
        bs.onNext(3);
        bs.onComplete();
        bs.subscribe(o -> System.out.println("3:"+o));
        日志：
        1:1
        1:2
        1:3
        2:3

replaySubject: 无论何时订阅，都会将所有历史订阅内容全部发出

Single与Completable

参考: 这里写链接内容

使用场景:其实这个网络请求并不是一个连续事件流，你只会发起一次 Get 请求返回数据并且只收到一个事件。我们都知道这种情况下 onComplete 会紧跟着 onNext 被调用，那为什么不把它们合二为一呢？

Single:它总是只发射一个值，或者一个错误通知，而不是发射一系列的值。因此，不同于Observable需要三个方法onNext, onError, onCompleted，订阅Single只需要两个方法:

Single只会调用这两个方法中的一个，而且只会调用一次，调用了任何一个方法之后，订阅关系终止。

onSuccess - Single发射单个的值到这个方法

onError - 如果无法发射需要的值，Single发射一个Throwable对象到这个方法

<!--  retrofit 范例-->
 public interface APIClient {
     @GET("my/api/path")
     Single<MyData> getMyData();
 }
 apiClient.getMyData()
     .subscribe(new Consumer<MyData>() {
         @Override
         public void accept(MyData myData) throws Exception {
             // handle data fetched successfully and API call completed
         }
     }, new Consumer<Throwable>() {
         @Override
         public void accept(Throwable throwable) throws Exception{
             // handle error event
         }
     });
     <!-- 单独使用范例： -->
        Single.just("Amit")
            .subscribe(s -> System.out.println(s)
                    , throwable -> System.out.println("异常"));

使用场景:通过 PUT 请求更新数据我只关心 onComplete 事件。使用 Completable 时我们忽略 onNext 事件，只处理 onComplete 和 onError 事件

Completable:本质上来说和 Observable 与 Single 不一样，因为它不发射数据。

<!--  retrofit 范例-->
public interface APIClient {
    @PUT("my/api/updatepath")
    Completable updateMyData(@Body MyData data);
}
apiClient.updateMyData(myUpdatedData)
    .subscribe(new Action() {
        @Override
        public void run() throws Exception {
            // handle completion
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception{
            // handle error
        }
    });
    <!-- 单独使用范例： -->
     Completable.timer(1000, TimeUnit.MILLISECONDS)
                    .subscribe(() -> System.out.println("成功")
                            , throwable -> System.out.println("异常"));

andThen( Completable中的方法最常用):在这个操作符中你可以传任何Observable、Single、Flowable、Maybe或者其他Completable，它们会在原来的 Completable 结束后执行

apiClient.updateMyData(myUpdatedData)
    .andThen(performOtherOperation()) // a Single<OtherResult>
    .subscribe(new Consumer<OtherResult>() {
        @Override
        public void accept(OtherResult result) throws Exception {
            // handle otherResult
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception{
            // handle error
        }
    });

全栈开发者微信公众号

RxJava2 总结之 Subjects、Single 与 Completable

Subjects

Single与Completable

猜你喜欢