订阅Vs订阅RxJava2（Android）？

Question

何时调用subscribeWith方法而不是普通订阅？ 什么是用例？

compositeDisposable.add(get()
    .observeOn(AndroidSchedulers.mainThread())
    .subscribeOn(Schedulers.io())
    .subscribe(this::handleResponse, this::handleError));

VS

   compositeDisposable.add(get()
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
              //  .subscribe(this::handleResponse, this::handleError);
                .subscribeWith(new DisposableObserver<News>() {
                    @Override public void onNext(News value) {
                        handleResponse(value);
                    }

                    @Override public void onError(Throwable e) {
                        handleError(e);
                    }

                    @Override public void onComplete() {
                       // dispose here ? why? when the whole thing will get disposed later
                       //via  compositeDisposable.dispose();  in onDestroy();
                    }
                }));

谢谢

---

稍后添加

根据文档，两者都返回一次性SingleObserver实例：

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <E extends SingleObserver<? super T>> E subscribeWith(E observer) {
    subscribe(observer);
    return observer;
}

@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(final Consumer<? super T> onSuccess, final Consumer<? super Throwable> onError) {
    ObjectHelper.requireNonNull(onSuccess, "onSuccess is null");
    ObjectHelper.requireNonNull(onError, "onError is null");
    ConsumerSingleObserver<T> s = new ConsumerSingleObserver<T>(onSuccess, onError);
    subscribe(s);
    return s;
}

ConsumerSingleObserver类实现SingleObserver和Disposable的位置。

Answer 1

可观察的＃订阅说明：

在您的第一个代码段中：

.subscribe（this :: handleResponse，this :: handleError））;

您实际上正在使用几个重载的Observable#subscribe方法之一：

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)

还有另一个也接受一个Action来执行onComplete：

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
        Action onComplete) {

另一个选项允许您简单地传入Observer （注意：void方法） （编辑2 - 此方法在ObservableSource定义，它是Observable扩展的接口。）

public final void subscribe(Observer<? super T> observer)

在你问题的第二个代码片段中，你使用了subscribeWith方法，它只返回你传入的Observer （为了方便/缓存等）：

public final <E extends Observer<? super T>> E subscribeWith(E observer)

观察者#onComplete解释：

在Observable发出流中的所有项后，将调用Observer＃onComplete。 来自java doc：

/**
 * Notifies the Observer that the {@link Observable} has finished sending push-based notifications.
 * <p>
 * The {@link Observable} will not call this method if it calls {@link #onError}.
 */
void onComplete();

因此，例如，如果代码片段中的get()返回了一个发出多个News对象的Observable ，则每个对象都将在Observer#onNext处理。 在这里，您可以处理每个项目。

在完成所有处理之后（假设没有发生错误），将调用onComplete 。 知道您已经处理了所有News对象，您可以在这里执行您需要执行的任何额外操作（例如，更新UI）。

这不要与Disposable#dispose混淆，后者在可观察流结束时（完成/错误）被调用，或者由您手动终止观察（这是CompositeDisposable进入的地方，因为它可以帮助您处理所有的Disposable s它立即包含）。

如果您的方案get()会返回一个Observable ，仅发出一个单一的项目，然后而不是使用Observable ，可考虑使用io.reactivex.Single ，你只处理一个项目（在onSuccess ），并且不会需要为onComplete指定一个Action :)

编辑 ：回复您的评论：

但是我仍然没有使用subscribeWith，你说它通过观察者进行缓存等，它传递到哪里？ 完成？ 从我所理解的订阅中，实际上并没有消费可观察（或单一）的权利？

为了进一步阐明subscribeWith解释，我的意思是它将使用你传递给subscribeWith的Observer对象（与subscribe方法完全相同），但是它还会将相同的Observer返回给你。 在撰写本文时，subscribeWith的实现是：

public final <E extends Observer<? super T>> E subscribeWith(E observer) {
    subscribe(observer);
    return observer;
}

因此， subscribeWith 可以与subscribe互换使用。

你能举例说明subscribeWith的用例吗？ 我想这完全可以回答这个问题

subscribeWith javadoc给出了以下用法示例：

Observable<Integer> source = Observable.range(1, 10);
CompositeDisposable composite = new CompositeDisposable();

ResourceObserver<Integer> rs = new ResourceObserver<>() {
     // ...
};

composite.add(source.subscribeWith(rs));

在这里看到subscribeWith的用法将返回实例化的相同ResourceObserver对象。 这样可以方便地执行订阅并将ResourceObserver添加到一行中的CompositeDisposable （请注意， ResourceObservable实现了Disposable 。）

编辑2回复第二条评论。

source.subscribeWith（RS）; source.subscribe（RS）; 两者都返回SingleObserver实例，

ObservableSource#subscribe(Observer <? super T> observer) 不返回Observer 。 它是一个void方法（参见上面Observable＃subscribe解释下的注释。） Observable#subscribeWith DOES返回Observer 。 如果我们使用ObservableSource#subscribe重写示例用法代码，我们必须在两行中这样做：

source.subscribe(rs); //ObservableSource#subscribe is a void method so nothing will be returned
composite.add(rs);

而Observable#subscribeWith方法使我们只需一行composite.add(source.subscribeWith(rs));

它可能会让所有看起来有点类似的重载订阅方法变得混乱，但是存在差异（其中一些是微妙的）。 查看代码和文档有助于区分它们。

---

编辑3 subscribeWith的另一个示例用例

当您具有可能要重用的Observer的特定实现时， subscribeWith方法很有用。 例如，在上面的示例代码中，它在订阅中提供了ResourceObserver的特定实现，从而继承了它的功能，同时仍允许您处理onNext onError和onComplete。

另一个示例用法：对于您问题中的示例代码，如果您想在多个位置为get()响应执行相同的订阅，该怎么办？

不是在不同的类中复制onNext和onError的Consumer实现，而是可以为例如定义一个新类。

 //sample code.. public class GetNewsObserver extends DisposableObserver<News> { //implement your onNext, onError, onComplete. .... } 

现在，无论何时执行get()请求，您都可以通过以下方式订阅：

 compositeDisposable.add(get() ... .subscribeWith(new GetNewsObserver())); 

现在看代码很简单，你保持处理响应的责任分离，现在可以在任何你想要的地方重用GetNewsObserver 。