Question

第一个API调用返回一个元素列表，然后我想随后调用另一个API，其中第一个API调用在列表的每个元素中返回String。我（我想）已经得到它，以便它使用列表的每个元素调用第二个API调用，但我不确定如何订阅它以获得从第二次调用返回的结果。

discogsService.getSearchResults(searchTerm, mContext.getString(R.string.token))
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                // Turns the result into individual elements
                .flatMapIterable(RootSearchResponse::getSearchResults)
                // I believe this then calls .getRelease() with each ID string
                .map(result -> discogsService.getRelease(result.getId()));

改造界面：

public interface DiscogsService
{
    @GET("database/search?")
    Observable<RootSearchResponse> getSearchResults(@Query("q") String searchTerm, @Query("token") String token);

    @GET("releases/")
    Observable<Release> getRelease(@Query("release_id") String releaseId);
}

我不确定从哪里开始。

我相信.subscribe(...)然后让我能够从每个Observable<Release>返回.getRelease(...)。由于在Model层中调用了上述方法，我需要在此模型层中设置订阅者以传递回Presenter，然后在Presenter中添加另一个订阅者来处理每个Observable 1}}因为Presenter可以访问View。

有没有办法让我可以从Model层返回每个Observable，这样我就不需要有两个单独的.subscribe(...)？或者我应该使用两个单独的.subscribe(...)，因为我可以捕获它们的错误？我只想要第二次通话的结果。

以下是我尝试过的完整代码：

在模型中：

discogsService.getSearchResults(searchTerm, mContext.getString(R.string.token))
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .flatMapIterable(RootSearchResponse::getSearchResults)
                .subscribeOn(Schedulers.io())
                .map(result -> discogsService.getRelease(result.getId()))
                .subscribe(new Observer<Observable<Release>>()
                {
                    @Override
                    public void onSubscribe(Disposable d)
                    {

                    }

                    @Override
                    public void onNext(Observable<Release> value)
                    {
                        mainPresenter.addToRecyclerView(value);
                    }

                    @Override
                    public void onError(Throwable e)
                    {

                    }

                    @Override
                    public void onComplete()
                    {

                    }
                });

在演示者中：

@Override
public void addToRecyclerView(Observable<Release> value)
{
    value       .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(new Observer<Release>()
                {
                    @Override
                    public void onSubscribe(Disposable d)
                    {

                    }

                    @Override
                    public void onNext(Release value)
                    {
                        Log.e(TAG, "Success! " + value);
                        results.add(value);
                    }

                    @Override
                    public void onError(Throwable e)
                    {
                        Log.e(TAG, "Error: " + e.toString());
                        Log.e(TAG, "Error: " + e.toString());
                    }

                    @Override
                    public void onComplete()
                    {

                    }
                });

Answer 1

我宁愿在模特级别公开Observable<Release>：

Observable<Release> getReleases(...) {
    return discogsService.getSearchResults(...)
        .flatMapIterable(RootSearchResponse::getSearchResults)
        .flatMap(result -> discogsService.getRelease(result.getId()));
}

Presenter会订阅它：

getReleases
    .observeOn(AndroidSchedulers.mainThread())
    .subscribeOn(Schedulers.io())
    .subscribe(new Observer<Release>()
    {
        @Override
        public void onSubscribe(Disposable d)
        {

        }

        @Override
        public void onNext(Release value)
        {
            Log.e(TAG, "Success! " + value);
            results.add(value);
        }

        @Override
        public void onError(Throwable e)
        {
            Log.e(TAG, "Error: " + e.toString());
            Log.e(TAG, "Error: " + e.toString());
        }

        @Override
        public void onComplete()
        {

        }
    });

只有一个Observable。请注意，map()中的第二个请求从flatMap()切换到getReleases(...)。在幕后，这是第二次订阅的地方。

最终订阅将从两个请求中收到错误。我更喜欢让消费者（Presenter）处理错误，因为它是关心响应并知道在发生错误时要做什么的人（例如显示消息）。

是那个开车的人。 Observable创建，处理它，所以它也有责任分配线程imho。

Observable可以很好地签订从一层暴露到另一层的合同。它描述了数据类型，如何使用它和模式（Observable？Single？Flowable？）。

RxJava 2，Retrofit 2 + Retrolambda - 将2个请求链接在一起

1 个答案: