Android 仅在接收到第二个可观测值后发射可观测值

我正在使用Rx调用我们的API进行改造。在某个时刻，我需要调用我们的API，等待响应1，从中提取一些元数据，然后再次调用API，等待响应2。在我得到响应2后，我可以发出我的可观察到的。我的问题是，我不知道如何： 拨打电话2并仅在收到响应2后发出

下面是我的类中的函数，它们应该发出Model-Observable。方法get2不必对外部世界可见

public Observable<Model> get1(String slug) {
    return api1
            .getInfo(slug)
            .subscribeOn(Schedulers.io())
            .map(resonse1 -> {
                String metadata = response1.getMetadata();

                //Make call2 with metadata
                //call(2)

                Model model = response1.getModel();
                model.setInfo(/*Info from call2*/) 

                return model;
            })
            .observeOn(AndroidSchedulers.mainThread());
}


private Observable<Info> get2(String metadata) {
    return api2.getInfo(new InfoAsset(metadata))
            .subscribeOn(Schedulers.io())
            .map(response2 -> {
                return response2.getInfo;
            })
            .observeOn(AndroidSchedulers.mainThread());
}

公共可观测get1（字符串段塞）{
返回api1
.getInfo（slug）
.subscribeOn（Schedulers.io（））
.map（第1条->{
字符串元数据=response1.getMetadata（）；
//使用元数据生成call2
//电话（2）
Model Model=response1.getModel（）；
model.setInfo（/*来自call2的信息*/）
收益模型；
})
.observeOn（AndroidSchedulers.mainThread（））；
}
私有可观察get2（字符串元数据）{
返回api2.getInfo（新信息资产（元数据））
.subscribeOn（Schedulers.io（））
.map（响应2->{
返回response2.getInfo；
})
.observeOn（AndroidSchedulers.mainThread（））；
}

使用

flatMap

代替

map

：

.flatMap(response1 -> {
            String metadata = response1.getMetadata();
            return get2(metadata)
              .map(info -> {
                     Model model = response1.getModel();
                     model.setInfo(info); 
                     return model;
                   });
         })
...

---

但是要小心，因为您正在跨线程使用可变对象，所以可能存在可见性问题。考虑使用不可变对象，或者确保更改是同步的。

< P>使用嵌套的FLATAMPS，除非您想执行线程跳转，否则不要使用观察程序：

private Observable<Info> get2(String metadata) {
    return api2.getInfo(new InfoAsset(metadata))
        .subscribeOn(Schedulers.io())
        .map(response2 -> {
            return response2.getInfo;
        });
        // no ObserveOn here.
} 

public Observable<Model> get1(String slug) {
    return api1
        .getInfo(slug)
        .subscribeOn(Schedulers.io())
        .flatMap (response1 -> {
            Model model = response1.getModel();
            return get2(response1.getMetadata())
                   .map(response2 -> {
                        model.setInfo(response2); 
                        return model;
                   });
        );
    });
}

private Observable get2（字符串元数据）{
返回api2.getInfo（新信息资产（元数据））
.subscribeOn（Schedulers.io（））
.map（响应2->{
返回response2.getInfo；
});
//这里没有观测到。
} 
公共可观测get1（字符串段塞）{
返回api1
.getInfo（slug）
.subscribeOn（Schedulers.io（））
.flatMap（响应1->{
Model Model=response1.getModel（）；
返回get2（response1.getMetadata（））
.map（响应2->{
model.setInfo（response2）；
收益模型；
});
);
});
}