子流支持

一些if…​else和发布-订阅组件提供了使用子流程来指定其逻辑或映射的能力。最简单的示例是.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"));
}

您可以使用单独的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"))));
}

类似的发布-订阅子流程组合提供了.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"));
}

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

有时，您需要从.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");
}


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

Caused by: org.springframework.beans.factory.BeanCreationException:
    The 'currentComponent' (org.springframework.integration.router.MethodInvokingRouter@7965a51c)
    is a one-way 'MessageHandler' and it isn't appropriate to configure 'outputChannel'.
    This is the end of the integration flow.

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

子流程可以嵌套到任何深度，但我们不建议这样做。事实上，即使在路由器的情况下，在流程中添加复杂的子流程也会很快看起来像一盘意大利面，并且人类难以解析。

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

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

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