Java Spring集成路由到不同类中的子流

我挣扎了几天才让这项工作成功。我试图完成的是根据消息内容，在子流结束后，从主流调用不同的子流（即集成流），以返回到主流。它类似于将责任委托给特定的类来完成某些事情并返回到主流程。这一责任也可能需要一些步骤，因此其实现也需要流程。以下是我的主要流程：

public IntegrationFlow processingFlow(
  MessageChannel eventIn,
  MessageChannel eventOut,
  ChangedEventsLoader changedEventsLoader,
  CalculatorRouter calculatorRouter) {

return IntegrationFlows.from(eventIn)
    .handle(changedEventsLoader)
    .route(
        CalculatorRouter::getSportId,
        CalculatorRouter::routeCalculation)
    .channel(eventOut)
    .get();

    @Bean
    fun splitRouteAggregate() =
            IntegrationFlow { f ->
                f.split()
                        .route<Int, Boolean>({ o -> o % 2 == 0 },
                                { m ->
                                    m.subFlowMapping(true) { sf -> sf.gateway(oddFlow()) }
                                            .subFlowMapping(false) { sf -> sf.gateway(evenFlow()) }
                                })
                        .aggregate()
            }

    @Bean
    fun oddFlow() =
            IntegrationFlow { flow ->
                flow.handle<Any> { _, _ -> "odd" }
            }

    @Bean
    fun evenFlow() =
            IntegrationFlow { flow ->
                flow.handle<Any> { _, _ -> "even" }
            }

}

以下是路由器的实现：

@Service
@AllArgsConstructor
public class CalculatorRouter {
  private final MessageChannel eventOut;

  public RouterSpec<Integer, MethodInvokingRouter> routeCalculation(
      RouterSpec<Integer, MethodInvokingRouter> mapping) {
    return mapping
        .channelMapping(1, "subflowCalculationChannel")
        .defaultOutputToParentFlow();
  }

  public Integer getSportId(Event event) {
    return 1;
  }

  @Bean
  public MessageChannel subflowCalculationChannel() {
    return MessageChannels.direct().get();
  }
}

@服务
@AllArgsConstructor
公共类计算器{
私有最终消息通道事件输出；
公共路由器专用路由器计算(
RouterSpec映射）{
返回映射
.通道映射（1，“子流计算通道”）
.DefaultOutputParentFlow（）；
}
公共整数getSportId（事件）{
返回1；
}
@豆子
公共消息通道子流计算通道（）{
返回MessageChannels.direct（）.get（）；
}
}

下面是一个子流的示例：

@Configuration
@AllArgsConstructor
public class CalculatorExample {

  @Bean
  public IntegrationFlow calculateProbabilities(MessageChannel subflowCalculationChannel) {
    return IntegrationFlows.from(subflowCalculationChannel)
        .<Event>handle((p, m) -> p * 2)
        .get();
  }
}

@配置
@AllArgsConstructor
公共类计算器示例{
@豆子
公共集成流计算概率（MessageChannel subflowCalculationChannel）{
返回IntegrationFlows.from（子流计算通道）
.手柄（（p，m）->p*2）
.get（）；
}
}

---

问题是，子流与主流之间缺少一些连接。我试图通过在路由部分使用DefaultOutputParentFlow（）来解决这个问题，但这还不够。

在开始某个版本时，我们决定将Java DSL路由器行为与带有注释或XML的标准配置相一致。因此，如果我们发送到路由器，我们不能期望那里的回复。我们只能继续将通道作为子流的输出

在您的情况下，主流中有一个

.channel（eventOut）

。因此，所有路由子流都应准确响应此通道：

    .<Event>handle((p, m) -> corners1H2HCustomBet.getCalculation(p))
    .channel(eventOut)
    .get();

*@param-key这个键。 *@param子流-子流。 *@返回路由器规格。 */ 公共RouterSpec子流映射（K键，集成流子流）{ 与基于通道的路由配置无关，但在将来可能有用

更新

下面是一个用于

子流映射的示例（Kotlin）并返回到主流：

public IntegrationFlow processingFlow(
  MessageChannel eventIn,
  MessageChannel eventOut,
  ChangedEventsLoader changedEventsLoader,
  CalculatorRouter calculatorRouter) {

return IntegrationFlows.from(eventIn)
    .handle(changedEventsLoader)
    .route(
        CalculatorRouter::getSportId,
        CalculatorRouter::routeCalculation)
    .channel(eventOut)
    .get();

    @Bean
    fun splitRouteAggregate() =
            IntegrationFlow { f ->
                f.split()
                        .route<Int, Boolean>({ o -> o % 2 == 0 },
                                { m ->
                                    m.subFlowMapping(true) { sf -> sf.gateway(oddFlow()) }
                                            .subFlowMapping(false) { sf -> sf.gateway(evenFlow()) }
                                })
                        .aggregate()
            }

    @Bean
    fun oddFlow() =
            IntegrationFlow { flow ->
                flow.handle<Any> { _, _ -> "odd" }
            }

    @Bean
    fun evenFlow() =
            IntegrationFlow { flow ->
                flow.handle<Any> { _, _ -> "even" }
            }

@Bean
趣味splitRouteAggregate（）=
集成流{f->
f、 拆分（）
.route（{o->o%2==0}，
{m->
m、 子流映射（true）{sf->sf.gateway（oddFlow（））}
.subFlowMapping（false）{sf->sf.gateway（evenFlow（））}
})
.aggregate（）
}
@豆子
有趣的奇流（）=
集成流{flow->
flow.handle{{{，{->“奇数”}
}
@豆子
风流=
集成流{flow->
flow.handle{{{，{->“偶数”}
}
感谢您的回复。我希望有某种方法可以在子流之外指定输出通道。好的，您可以在
路由（）之前使用
enrichHeaders（）
将其添加到
replyChannel
头中
在主流程中。您是否有将子流程映射用于集成流程的示例。这看起来更好，因为我不需要指定通道。我刚刚添加了一个关于子流程和网关的Kotlin示例。非常感谢。我将尝试使其适用于我的案例。