RxJava-单一不运行

我正在尝试转换此异步任务：

private static class UpdateFeedTask extends AsyncTask<Void, Void, Void> {
    private WeakReference<FeedFragment> weakFeedFragment;

    private UpdateFeedTask(FeedFragment feedFragment) {
        this.weakFeedFragment = new WeakReference<>(feedFragment);
    }

    @Override
    protected void onPreExecute() {
        if (!weakFeedFragment.get().swipeRefreshLayout.isRefreshing()) {
            weakFeedFragment.get().feedProgressBar.setVisibility(View.VISIBLE);
        }
    }

    @Override
    protected final Void doInBackground(Void... voids) {
        weakFeedFragment.get().submissionList = weakFeedFragment.get().paginator.next();

        return null;
    }

    @Override
    protected void onPostExecute(Void value) {
        weakFeedFragment.get().feedProgressBar.setVisibility(View.INVISIBLE);
        weakFeedFragment.get().swipeRefreshLayout.setRefreshing(false);
        weakFeedFragment.get().isLoadingNextSubmissions = false;

        FeedAdapter feedAdapter = (FeedAdapter) weakFeedFragment.get().recyclerView.getAdapter();
        feedAdapter.updateItems(weakFeedFragment.get().submissionList);
    }
}

私有静态类UpdateFeedTask扩展了AsyncTask{
私有WeakReference weakFeedFragment；
私有UpdateFeedTask（FeedFragment FeedFragment）{
this.weakFeedFragment=新的WeakReference（feedFragment）；
}
@凌驾
受保护的void onPreExecute（）{
如果（！weakFeedFragment.get（）.swiperFreshLayout.isRefreshing（））{
weakFeedFragment.get（）.feedProgressBar.setVisibility（View.VISIBLE）；
}
}
@凌驾
受保护的最终空隙背景（空隙…空隙）{
weakFeedFragment.get（）.submissionList=weakFeedFragment.get（）.paginator.next（）；
返回null；
}
@凌驾
受保护的void onPostExecute（void值）{
weakFeedFragment.get（）.feedProgressBar.setVisibility（View.INVISIBLE）；
weakFeedFragment.get（）.swiperFreshLayout.setRefreshing（false）；
weakFeedFragment.get（）.isLoadingNextSubmissions=false；
FeedAdapter=（FeedAdapter）weakFeedFragment.get（）.recyclerView.getAdapter（）；
updateItems（weakFeedFragment.get（）.submissionList）；
}
}

变成一个单一的可观察的，但当我调用它时，它根本不会启动：

private void UpdateFeed() {
    if (swipeRefreshLayout.isRefreshing()) {
        feedProgressBar.setVisibility(View.VISIBLE);
    }

    updateFeedObservable()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeWith(new SingleObserver<Listing<Submission>>() {

                @Override public void onSubscribe(Disposable d) {
                    d.dispose();
                }

                @Override public void onSuccess(Listing<Submission> submissions) {
                    Log.d(TAG, "onSuccess: WORKS"); //Nope
                    feedProgressBar.setVisibility(View.INVISIBLE);
                    swipeRefreshLayout.setRefreshing(false);
                    isLoadingNextSubmissions = false;

                    FeedAdapter feedAdapter = (FeedAdapter) recyclerView.getAdapter();
                    feedAdapter.updateItems(submissions);
                }

                @Override public void onError(Throwable e) {
                    Log.e(TAG, e.getMessage());
                }
            });

}

public Single<Listing<Submission>> updateFeedObservable() {
    return Single.defer(() -> Single.fromCallable(() -> {
        Log.d(TAG, "updateFeedObservable: WORKS"); //Nope
        return paginator.next();
    }));
}

private void UpdateFeed（）{
if（swipeRefreshLayout.isRefreshing（））{
feedProgressBar.setVisibility（View.VISIBLE）；
}
updateFeedObservable（）
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.subscribowith（新的SingleObserver（）{
@覆盖订阅上的公共无效（d）{
d、 处置（）；
}
@成功时覆盖公共无效（列表提交）{
Log.d（标记“onSuccess:WORKS”）；//否
feedProgressBar.setVisibility（视图不可见）；
swipeRefreshLayout.setRefreshing（false）；
isLoadingNextSubmissions=false；
FeedAdapter=（FeedAdapter）recyclerView.getAdapter（）；
feedAdapter.updateItems（提交）；
}
@覆盖公共无效onError（可丢弃的e）{
Log.e（标记，e.getMessage（））；
}
});
}
公共单个updateFeedObservable（）{
返回Single.defer（（）->Single.fromCallable（（）->{
Log.d（标记“updateFeedObservable:WORKS”）；//否
返回paginator.next（）；
}));
}

我试图更改调度器，但据我所知，任何与IO相关的操作都需要使用Schedulers.IO

---

我不确定问题到底出在哪里，如果您在

新建SingleObserver（）：：onSubscribe（）

中得到任何帮助，我们将不胜感激。您将立即调用

d.dispose（）

，因此您将永远不会得到

onSuccess（）

调用，因为当您订阅时，您将处理

SingleObserver

删除：

d.dispose（）

还包括：

return Single.defer(() -> Single.fromCallable(() -> {
        Log.d(TAG, "updateFeedObservable: WORKS"); // Nope
        return paginator.next();
    }));

可简化为：

---

返回Single.fromCallable（Paginator:：next）；//方法引用

在

新建SingleObserver（）：onSubscribe（）

中，您会立即调用

d.dispose（）

，因此您永远不会得到

onSuccess（）

调用，因为当您订阅时，您会处理

SingleObserver

删除：

d.dispose（）

还包括：

return Single.defer(() -> Single.fromCallable(() -> {
        Log.d(TAG, "updateFeedObservable: WORKS"); // Nope
        return paginator.next();
    }));

可简化为：

---

返回Single.fromCallable（Paginator:：next）；//方法引用

是有效的，但是我如何处理可观察到的内容呢？一旦

onSuccess（）

完成（或任何终端事件），这将自动发生。如果您出于任何原因想要取消/处置，您将获得一个

一次性的
。我发现了一个更好的方法（我认为），创建一个CompositeDisposable，并在订阅期间将一次性的
添加到CompositeDisposable。这样，我在
onDestroy（）
期间调用
CompositeDisposable:：dispose
有多种方法可以做到这一点-您可以使用
subscribe
但是如果您使用
subscribe
直接返回一个
一次性的
。然而，这不是你最初的问题，也绝对不在我回答的问题的范围之内，应该被接受。是的，对不起。忘记接受了。谢谢你的帮助！这是可行的，但是我如何处理可观察到的内容呢？一旦
onSuccess（）
完成（或任何终端事件），这将自动发生。如果您出于任何原因想要取消/处置，您将获得一个
一次性的
。我发现了一个更好的方法（我认为），创建一个CompositeDisposable，并在订阅期间将一次性的
添加到CompositeDisposable。这样，我在
onDestroy（）
期间调用
CompositeDisposable:：dispose
有多种方法可以做到这一点-您可以使用
subscribe
但是如果您使用
subscribe
直接返回一个
一次性的
。然而，这不是你最初的问题，也绝对不在我回答的问题的范围之内，应该被接受。是的，对不起。忘记接受了。谢谢你的帮助！