跳到主要内容

支持子流程

QWen Plus 中英对照 Sub-flows support

一些 if…​else 和 publish-subscribe 组件提供了使用子流程来指定其逻辑或映射的能力。最简单的例子是 .publishSubscribeChannel()，如下例所示：

@Bean
public IntegrationFlow subscribersFlow() {
    return flow -> flow
            .publishSubscribeChannel(Executors.newCachedThreadPool(), s -> s
                    .subscribe(f -> f
                            .<Integer>handle((p, h) -> p / 2)
                            .channel(c -> c.queue("subscriber1Results")))
                    .subscribe(f -> f
                            .<Integer>handle((p, h) -> p * 2)
                            .channel(c -> c.queue("subscriber2Results"))))
            .<Integer>handle((p, h) -> p * 3)
            .channel(c -> c.queue("subscriber3Results"));
}
java

你可以通过单独的 IntegrationFlow @Bean 定义来实现相同的结果，但我们希望您发现子流风格的逻辑组合是有用的。我们认为这会使代码更短（因此更具可读性）。

从 5.3 版本开始，提供了一个基于 BroadcastCapableChannel 的 publishSubscribeChannel() 实现，用于在代理支持的消息通道上配置子流订阅者。例如，我们现在可以在 Jms.publishSubscribeChannel() 上将多个订阅者配置为子流：

@Bean
public JmsPublishSubscribeMessageChannelSpec jmsPublishSubscribeChannel() {
    return Jms.publishSubscribeChannel(jmsConnectionFactory())
                .destination("pubsub");
}

@Bean
public IntegrationFlow pubSubFlow(BroadcastCapableChannel jmsPublishSubscribeChannel) {
    return f -> f
            .publishSubscribeChannel(jmsPublishSubscribeChannel,
                    pubsub -> pubsub
                            .subscribe(subFlow -> subFlow
                                .channel(c -> c.queue("jmsPubSubBridgeChannel1")))
                            .subscribe(subFlow -> subFlow
                                .channel(c -> c.queue("jmsPubSubBridgeChannel2"))));
}
java

类似的 publish-subscribe 子流组合提供了 .routeToRecipients() 方法。

另一个例子是在 .filter() 方法中使用 .discardFlow() 而不是 .discardChannel()。

.route() 需要特别关注。考虑以下示例：

@Bean
public IntegrationFlow routeFlow() {
    return f -> f
            .<Integer, Boolean>route(p -> p % 2 == 0,
                    m -> m.channelMapping("true", "evenChannel")
                            .subFlowMapping("false", sf ->
                                    sf.<Integer>handle((p, h) -> p * 3)))
            .transform(Object::toString)
            .channel(c -> c.queue("oddChannel"));
}
java

.channelMapping() 继续像在常规 Router 映射中那样工作，但 .subFlowMapping() 将子流绑定到了主流。换句话说，任何路由器的子流在 .route() 之后都会返回到主流。

important

有时，您需要从 .subFlowMapping() 引用一个现有的 IntegrationFlow @Bean。以下示例展示了如何做到这一点：

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

@Bean
public IntegrationFlow oddFlow() {
    return f -> f.handle(m -> System.out.println("odd"));
}

@Bean
public IntegrationFlow evenFlow() {
    return f -> f.handle((p, h) -> "even");
}
java

在这种情况下，当您需要从这样的子流接收回复并继续主流程时，这个 IntegrationFlow bean 引用（或其输入通道）必须像前面的示例那样用 .gateway() 包装。在前面的示例中，oddFlow() 引用没有被包装到 .gateway() 中。因此，我们不期望从这个路由分支得到回复。否则，您最终会遇到类似于以下的异常：

Caused by: org.springframework.beans.factory.BeanCreationException:
    'currentComponent' (org.springframework.integration.router.MethodInvokingRouter@7965a51c)
    是一个单向的 'MessageHandler'，配置 'outputChannel' 是不合适的。
    这是集成流的终点。

当您将子流配置为 lambda 表达式时，框架会处理与子流的请求-回复交互，而不需要网关。

子流可以嵌套到任意深度，但我们不建议这样做。实际上，即使在路由器的情况下，在流中添加复杂的子流会很快变得像一团意大利面，让人难以理解。

备注

在 DSL 支持子流配置的情况下，当通常需要为正在配置的组件设置一个通道，并且该子流以 channel() 元素开始时，框架会在组件输出通道和流的输入通道之间隐式放置一个 bridge()。例如，在这个 filter 定义中：

.filter(p -> p instanceof String, e -> e
	.discardFlow(df -> df
                         .channel(MessageChannels.queue())
                         ...)
java

框架内部创建一个 DirectChannel bean 以注入到 MessageFilter.discardChannel 中。然后它将子流包装成一个从这个隐式通道开始的 IntegrationFlow 用于订阅，并在指定流中的 channel() 之前放置一个 bridge。当使用现有的 IntegrationFlow bean 作为子流引用（而不是内联子流，例如 lambda）时，不需要这样的桥接，因为框架可以从流 bean 解析第一个通道。对于内联子流，输入通道尚未可用。