简化Retrofit2和Rxjava2链式调用，以在最终结果中使用Single而不是Observable

Question

我要完成的工作是将调用更新到预订结束时的所有位置，以返回Single而不是Observable，因为我只收到1个结果，但是由于合并调用的性质，我不得不移至可观察对象，以利用可观察方法将结果重新结合为单个结果。

我遇到的问题是试图弄清楚如何将1次调用的结果用于另一个调用，然后将该结果与另一个调用合并，然后返回两者的组合。

我的呼叫顺序如下：

1. 上载徽标列表
   • 接收徽标上传的结果，这是我刚刚上传的徽标的更多详细数据。
2. 使用我刚得到的结果列表，并将其用于我提出的创建书的新请求中。
   • 接收刚刚创建的书响应，但包含更多自动生成的数据
3. 获取当前的作者/用户信息（由于Single不适用于.zip运算符，因此我不得不将其设为Observable）
4. 使用作者结果和书籍详细信息来创建POJO对象。 将其返回为最终结果。 当前，将其作为可观察对象返回，但实际上实际上只会返回1个条目，因此返回可观察对象几乎没有意义。 我不确定如何将其转换为返回Single，因此我将不胜感激。

这是我现在拥有的代码。 对象等仅是示例，但是序列和调用正是我所拥有的：

翻新服务：

@GET("/api/Profile/Author")
Observable<AuthorJson> getAuthor();

@POST("/api/Logo")
Observable<BookLogoJson> uploadBookLogos(@Header("Content-Type") String content_type, @Body RequestBody logo);

@POST("/api/Book")
Single<BookDetailsJson> newBook(@Body BookDetailRequest request);

实际执行

List<Book> bookLogos = ...;

Observable.fromIterable(bookLogos)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .flatMap(new Function<String, ObservableSource<BookLogoJson>>() {
                    @Override
                    public ObservableSource<BookLogoJson> apply(@NonNull String bookLogos) throws Exception {
                        return mApi.uploadBookLogos(mContentType, getRequestBody(bookLogos, context));
                    }
                }).toList().flatMap(new Function<List<BookLogoJson>, SingleSource<BookDetailsJson>>() {
                    @Override
                    public SingleSource<BookDetailsJson> apply(@NonNull List<BookLogoJson> bookLogosRaw) throws Exception {
                        BookDetailRequest request = new BookDetailRequest();
                        for(BookLogoJson logo : bookLogosRaw){
                            request.mLogos.add(logo.mId);
                        }
                        return mApi.newBook(request);
                    }
                }).toObservable().flatMap(new Function<BookDetailsJson, ObservableSource<Book>>() {
                    @Override
                    public ObservableSource<Book> apply(@NonNull BookDetailsJson BookDetailsJson) throws Exception {
                        return Observable.zip(mApi.getAuthor(),
                                Observable.just(BookDetailsJson),
                                new BiFunction<AuthorJson, BookDetailsJson, Book>() {
                                    @Override
                                    public Book apply(AuthorJson author, BookDetailsJson bookDetails) throws Exception {
                                        return mConverter.getBook(author, bookDetails);
                                    }
                                });
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(new Observer<Book>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                    }

                    @Override
                    public void onNext(@NonNull Book book) {
                        // Here, I will only ever get 1 Book so an observable makes no sense.
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
                    }

                    @Override
                    public void onComplete() {
                    }
                });

Answer 1

实际上，这非常简单，因为toList().flatMap(...)的结果已经是Single 。

只需删除对toObservable()的调用，然后修改flatMap即可返回Single ：

mApi.getAuthor().firstOrError().map(new Function<AuthorJson, Book>() {
                        public Book apply(@NonNull AuthorJson author) throws Exception {
        // bookDetails captured by anonymous function
        return mConverter.getBook(author, bookDetails);
    }
});

此外，Retrofit的RxJava转换器还接受Single替代Observable 。 这在这里可能适用，因为请求总是产生单个结果或错误。 （ Completable可用于无响应的请求）