RxJava流：条件运算符和错误处理

我是RxJava的新手，我尝试将我的头脑集中在一个更复杂的登录逻辑上，该逻辑有三个异步方法要处理。对我来说，这是“如果我把这个东西转换成RxJava，任何事情（）都是可能的”：

所以我想做的是：

Call A -> (Process A) -> Call B with results of A -> (Process B) -\
                    \                                              -> Combine and Subscribe
                     \-> Call C with results of A -> (Process C) -/

现在的问题是，

callc

分支只应在特定条件下执行，而不是在其他情况下执行（

Combine and Subscribe

然后可以从该分支接收

NULL

值，这是正常的）

此外，错误处理也非常重要：虽然

呼叫A

和

呼叫C

（如果运行此功能）需要通过

onError

将其错误传递给最终订户，但

呼叫B

的“成功”是可选的，在失败的情况下可以忽略

这就是我到目前为止提出的，它仍然忽略了“C”分支：

 mApi.callA(someArgs)
            // a transition operator to apply thread schedulers
            .compose(applySchedulers())
            // from rxlifecycle-components, unsubscribes automatically 
            // when the activity goes down  
            .compose(bindToLifecycle())
            // possibly other transformations that should work on the (error)
            // states of the first and the following, chained API calls
            .flatMap(response -> processA(response))
            .flatMap(response -> mApi.callB(response.token))
            .flatMap(response -> processB(response))
            // redirects HTTP responses >= 300 to onError()
            .lift(new SequenceOperators.HttpErrorOperator<>())
            // checks for application-specific error payload and redirects that to onError()
            .lift(new SequenceOperators.ApiErrorOperator<>())
            .subscribe(this::allDone this::failure);

mApi.callA（someArgs）
//用于应用线程调度程序的转换运算符
.compose（applySchedulers（））
//从rxlifecycle组件中，自动取消订阅
//当活动停止时
.compose（bindToLifecycle（））
//可能是其他应在上工作的转换（错误）
//第一个和后续链接API调用的状态
.flatMap（响应->过程A（响应））
.flatMap（response->mApi.callB（response.token））
.flatMap（响应->过程B（响应））
//将HTTP响应>=300重定向到OneError（）
.lift（新的SequenceOperators.HttpErrorOperator（））
//检查特定于应用程序的错误负载，并将其重定向到OneError（）
.lift（新的SequenceOperators.ApiErrorOperator（））
.subscribe（this:：allDone this:：failure）；

我环顾四周，但找不到如何启动

callc

分支的提示

另外，我不确定我的

SequenceOperators

是否能以这种方式工作，也就是说，可以放在链中所有请求之后，或者我是否需要几个请求，每个请求都放在触发新

调用的flatMap（）操作符之后

谁能给我指出正确的方向吗

谢谢
 应使用运算符：）结果应如下所示：

mApi.callA(someArgs)
        // ...
        .flatMap(response -> processA(response))
        .flatMap(response -> {
              return Observable.zip(
                    callB(response),
                    callC(response),
                    (rA,rB) -> {
                          // or just return a new Pair<>(rA, rB)
                          return combineAPlusB(rA,rB)
                    }
              )
        })
        // ...
        .subscribe(this::allDone this::failure);

mApi.callA（someArgs）
// ...
.flatMap（响应->过程A（响应））
.flatMap（响应->{
return-Observable.zip(
callB（响应），
callC（响应），
（rA，rB）->{
//或者只返回一对新的（rA、rB）
返回组合逻辑B（rA、rB）
}
)
})
// ...
.subscribe（this:：allDone this:：failure）；
好的，明白了，现在我不确定如何处理错误。我希望有一些运算符/组件/我在其中抛出的任何东西，它们通常作用于任何响应（因此是
HttpErrorOperator
和
apierrooperator
）。另外，你在G+上说过，过渡操作符应该放在最后（也就是说，
compose
）-我想我必须注意这里的“温度”，而不是我意外地将一个“冷”观测值变成了一个“热”观测值，对吧？如果callB和callC都需要，那么简单的解决方法就是调用。把它们都打开。否则，如果callB和callC都发出相同的类型，那么您可以Observable.merge（callB，callC）.lift（..）.toList（）.map（rarb->combineAplusB（rarb.get（0），rarb.get（1））；好的，我明白了。不幸的是，它们发出不同的（泛型）类型，因此合并将不起作用。非常感谢您的帮助！