改造2个RxJava，将类似请求干净地链接在一起

Question

球门

在我的应用程序中，我希望使用改装2上传一些文件到我的网络服务器（一次多个，在这种情况下是图片。）到那个特定的文件。

尝试

我对使用函数式编程范式不熟悉，所以我的理解可能会被误导。我有两个不同的对象，一个文件响应（DTO表示从我的网络服务器上传文件后的响应）和一个照片对象。这个Photo对象有两个字段，并充当在我的后端服务器中持久化的实体。它的字段对应于列，并且单独上传这些对象可以很好地工作。我想做的是一次扫描完成双重操作。

以下是我尝试过的：

List<Observable<FileResponse>> mObservables = new ArrayList<>(3);

...
...

Observable.merge(mObservables).
            map(new Func1<FileResponse, Observable<Photo>>() {
                @Override
                public Observable<Photo> call(FileResponse fileResponse) {
                    Photo photo = new Photo();
                    photo.setPath(fileResponse.getUrl());
                    photo.setId("demo123");
                    return mPhotoService.createPhoto(photo);
                }
            }).forEach(
                new Action1<Observable<Photo>>() {
                    @Override
                    public void call(Observable<Photo> photoObservable) {

                    }
                },
                new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e(TAG, "Error: " + throwable.getMessage());
                    }
                }
            );

以下是我的逻辑：

合并( ) — 将多个观测值合并为一个。

我希望我创建的观察对象列表合并在一起，这样我就可以对它们中的每一个执行相同的操作。在这种情况下，可观察对象的类型为FileResponse。这是到文件web服务的上载。

map（）-通过对每个项应用函数来转换可观察项发出的项。

在本例中，我想对FileResponse Observable应用一个函数，该函数返回一个新的Observable，Observable。

弗雷奇( ) — 对可观察对象发出的每个项调用函数；阻塞，直到可观察对象完成。

然后，这将获取每个发出的可观察对象并上传它。但在这种情况下，这部分失败了。文件已成功上载，但forEach部分仅返回“Error:null”。

问题

这种理解是否接近我正在努力实现的目标？同样，我只是希望将多个请求链接在一起，当其他请求成功时执行新的请求。有没有更好/正确的方法来做这件事？

编辑注：

我忘了提一下，我可以像这样实现我想要的：

Observable.merge(mObservables)
            .map(new Func1<FileResponse, Observable<Photo>>() {
                @Override
                public Observable<Photo> call(FileResponse fileResponse) {
                    Photo photo = new Photo();
                    photo.setPath(fileResponse.getUrl());
                    photo.setDogId("123");
                    return mPhotoService.createPhoto(photo);
                }
            })
           .subscribe(new Subscriber<Observable<Photo>>() {
                    @Override
                    public void onCompleted() {
                        Log.d(TAG, "Save complete!");
                    }

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

                    @Override
                    public void onNext(Observable<Photo> photoObservable) {
                        photoObservable.subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread())
                                .subscribe(new Subscriber<Photo>() {
                                    @Override
                                    public void onCompleted() {
                                        Log.d(TAG, "Here!");
                                    }

                                    @Override
                                    public void onError(Throwable e) {
                                        Log.d(TAG, "Error! " + e.getMessage());
                                    }

                                    @Override
                                    public void onNext(Photo photo) {
                                        Log.d(TAG, "Woo!!");
                                    }
                                });
                    }
                }
            );

但我试图找到一种可能更干净的方法。如果这是唯一的办法，那就很公平了。只是想得到更多关于我在想什么的意见，看看我能做些什么使它看起来更好（或最佳实践）。

Answer 1

要使其更干净（并避免对onNext中的项目进行额外订阅），您可以将map（）切换为flatMap（）：

java prettyprint-override">Observable.merge(mObservables)
                .flatMap(new Func1<FileResponse, Observable<Photo>>() {
                    @Override
                    public Observable<Photo> call(FileResponse fileResponse) {
                        Photo photo = new Photo();
                        return mPhotoService.createPhoto(photo);
                    }
                })
                .forEach(new Action1<Photo>() {
                    @Override
                    public void call(Photo photo) {

                    }
                });

正如您在代码片断中看到的，在平面地图之后的下一个运算符将看到Photo对象（与可观察对象进行比较）