此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Integration 6.4.0！spring-doc.cn

JMS 支持

Spring 集成提供了用于接收和发送 JMS 消息的通道适配器。spring-doc.cn

您需要将此依赖项包含在您的项目中：spring-doc.cn

Mavenspring-doc.cn
Gradlespring-doc.cn

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-jms</artifactId>
    <version>6.3.7-SNAPSHOT</version>
</dependency>

compile "org.springframework.integration:spring-integration-jms:6.3.7-SNAPSHOT"

必须通过某些特定于 JMS 供应商的实现（例如 Apache ActiveMQ）显式添加。jakarta.jms:jakarta.jms-apispring-doc.cn

实际上有两个基于 JMS 的入站 Channel Adapters。第一个使用 Spring 的 for receive based on a polling period。第二个是 “消息驱动” 的，依赖于 Spring 容器。出站通道适配器使用来按需转换和发送 JMS 消息。JmsTemplateMessageListenerJmsTemplatespring-doc.cn

通过使用和容器， Spring 集成依赖于 Spring 的 JMS 支持。理解这一点很重要，因为这些适配器上公开的大多数属性都配置了底层和容器。有关容器的更多详细信息，请参阅 Spring JMS 文档。JmsTemplateMessageListenerJmsTemplateMessageListenerJmsTemplateMessageListenerspring-doc.cn

虽然 JMS 通道适配器旨在用于单向消息传递（仅发送或仅接收），但 Spring 集成还为请求和回复操作提供了入站和出站 JMS 网关。入站网关依赖于 Spring 的容器实现之一进行消息驱动的接收。它还能够将返回值发送到目标，如收到的消息所提供。出站网关将 JMS 消息发送到（或），然后接收回复消息。您可以显式配置引用（或或）。否则，出站网关将使用 JMS TemporaryQueue。MessageListenerreply-torequest-destinationrequest-destination-namerequest-destination-expressionreply-destinationreply-destination-namereply-destination-expressionspring-doc.cn

在 Spring Integration 2.2 之前，如有必要，将为每个请求或回复创建（并删除）。从 Spring Integration 2.2 开始，你可以将出站网关配置为使用容器来接收回复，而不是直接使用新的（或缓存的）来接收每个请求的回复。如果进行了此类配置，并且未提供显式回复目标，则每个网关都使用 single，而不是每个请求使用 1。TemporaryQueueMessageListenerConsumerTemporaryQueuespring-doc.cn

从版本 6.0 开始，出站网关会创建一个 instead of if 选项设置为。某些 JMS 供应商处理这些目标的方式不同。TemporaryTopicTemporaryQueuereplyPubSubDomaintruespring-doc.cn

入站通道适配器

入站通道适配器需要对单个实例的引用，或者同时引用 a 和 a（您可以提供 'destinationName' 来代替 'destination' 引用）。以下示例使用引用定义入站通道适配器：JmsTemplateConnectionFactoryDestinationDestinationspring-doc.cn

@Bean
public IntegrationFlow jmsInbound(ConnectionFactory connectionFactory) {
    return IntegrationFlow.from(
                    Jms.inboundAdapter(connectionFactory)
                       .destination("inQueue"),
                    e -> e.poller(poller -> poller.fixedRate(30000)))
            .handle(m -> System.out.println(m.getPayload()))
            .get();
}

@Bean
fun jmsInbound(connectionFactory: ConnectionFactory) =
    integrationFlow(
            Jms.inboundAdapter(connectionFactory).destination("inQueue"),
            { poller { Pollers.fixedRate(30000) } })
       {
            handle { m -> println(m.payload) }
       }

@Bean
@InboundChannelAdapter(value = "exampleChannel", poller = @Poller(fixedRate = "30000"))
public MessageSource<Object> jmsIn(ConnectionFactory connectionFactory) {
    JmsDestinationPollingSource source = new JmsDestinationPollingSource(new JmsTemplate(connectionFactory));
    source.setDestinationName("inQueue");
    return source;
}

<int-jms:inbound-channel-adapter id="jmsIn" destination="inQueue" channel="exampleChannel">
    <int:poller fixed-rate="30000"/>
</int-jms:inbound-channel-adapter>

请注意，从前面的配置中可以看出是轮询使用者。这意味着它在触发时调用。您应该仅在轮询相对不频繁且及时性不重要的情况下使用它。对于所有其他情况（绝大多数基于 JMS 的用例），（稍后介绍）是更好的选择。inbound-channel-adapterreceive()message-driven-channel-adapter

默认情况下，所有需要引用的 JMS 适配器都会自动查找名为 . 这就是为什么在许多示例中看不到属性的原因。但是，如果您的 JMS 具有不同的 Bean 名称，则需要提供该属性。ConnectionFactoryjmsConnectionFactoryconnection-factoryConnectionFactory

如果设置为（默认值），则收到的 JMS 消息将通过 . 当依赖 default 时，这意味着生成的 Spring Integration Message 将 JMS 消息的主体作为其有效负载。 JMS 生成基于字符串的有效负载，JMS 生成字节数组有效负载，JMS 的可序列化实例成为 Spring 集成消息的有效负载。如果您希望将原始 JMS 消息作为 Spring Integration 消息的有效负载，请将选项设置为。extract-payloadtrueMessageConverterSimpleMessageConverterTextMessageBytesMessageObjectMessageextractPayloadfalsespring-doc.cn

从版本 5.0.8 开始，默认值为（no wait） for and ，否则为 1 秒。 JMS Inbound Channel Adapter 根据提供的和选项进行 crate。如果需要外部（例如在 Spring Boot 环境中），或者没有缓存，或者没有，建议设置是否需要非阻塞消耗：receive-timeout-1org.springframework.jms.connection.CachingConnectionFactorycacheConsumersDynamicJmsTemplateConnectionFactoryJmsTemplateConnectionFactorycacheConsumersjmsTemplate.receiveTimeout(-1)spring-doc.cn

Jms.inboundAdapter(connectionFactory)
        .destination(queueName)
        .configureJmsTemplate(template -> template.receiveTimeout(-1))

交易

从版本 4.0 开始，入站通道适配器支持该属性。在早期版本中，您必须注入一个设置为 . （适配器确实允许您将属性设置为，但这是不正确的，因此不起作用）。session-transactedJmsTemplatesessionTransactedtrueacknowledgetransactedspring-doc.cn

但请注意，该设置为 for for for the transaction is committed 在操作之后和消息发送到之前。session-transactedtruereceive()channelspring-doc.cn

如果您希望整个流是事务性的（例如，如果存在下游出站通道适配器），则必须使用带有 . 或者，考虑使用 a 设置为（默认值）。transactionalJmsTransactionManagerjms-message-driven-channel-adapteracknowledgetransactedspring-doc.cn

消息驱动的通道适配器

这需要对 Spring 容器的实例（任何子类）的引用，或者两者兼而有之（可以提供 'destinationName' 代替 'destination' 引用）。下面的示例定义一个带有引用的消息驱动的通道适配器：message-driven-channel-adapterMessageListenerAbstractMessageListenerContainerConnectionFactoryDestinationDestinationspring-doc.cn

@Bean
public IntegrationFlow jmsMessageDrivenRedeliveryFlow() {
    return IntegrationFlow
            .from(Jms.messageDrivenChannelAdapter(jmsConnectionFactory())
                     .destination("inQueue"))
            .channel("exampleChannel")
            .get();
}

@Bean
fun jmsMessageDrivenFlowWithContainer() =
        integrationFlow(
                Jms.messageDrivenChannelAdapter(jmsConnectionFactory())
                             .destination("inQueue")) {
            channel("exampleChannel")
        }

@Bean
public JmsMessageDrivenEndpoint jmsIn() {
    JmsMessageDrivenEndpoint endpoint = new JmsMessageDrivenEndpoint(container(), listener());
    return endpoint;
}
@Bean
public AbstractMessageListenerContainer container() {
    DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
    container.setConnectionFactory(cf());
    container.setDestinationName("inQueue");
    return container;
}

@Bean
public ChannelPublishingJmsMessageListener listener() {
    ChannelPublishingJmsMessageListener listener = new ChannelPublishingJmsMessageListener();
    listener.setRequestChannelName("exampleChannel");
    return listener;
}

<int-jms:message-driven-channel-adapter id="jmsIn" destination="inQueue" channel="exampleChannel"/>

消息驱动的适配器还接受与容器相关的多个属性。只有在您不提供引用时，才会考虑这些值。在这种情况下，将根据这些属性创建和配置的实例。例如，您可以指定 reference、value 以及其他几个属性引用和值。有关更多详细信息，请参见 Javadoc 和 Spring 集成的 JMS 模式（）。MessageListenercontainerDefaultMessageListenerContainertransaction-managerconcurrent-consumersspring-integration-jms.xsdspring-doc.cn

如果您有自定义侦听器容器实现（通常是的子类），则可以使用该属性提供对其实例的引用，也可以使用该属性提供其完全限定的类名。在这种情况下，适配器上的属性将传输到自定义容器的实例。DefaultMessageListenerContainercontainercontainer-classspring-doc.cn

你不能使用 Spring JMS 命名空间元素来配置容器引用，因为该元素实际上并不引用容器。每个子元素都有自己的（在父元素上定义了 shared 属性）。您可以为每个侦听器子元素指定一个，并使用它注入通道适配器，但是，命名空间需要一个真正的侦听器。<jms:listener-container/><int-jms:message-driven-channel-adapter><jms:listener/>DefaultMessageListenerContainer<jms:listener-container/>id<jms:/>spring-doc.cn

建议为配置 regular 并将其用作 channel adapter 中的参考。<bean>DefaultMessageListenerContainerspring-doc.cn

从版本 4.2 开始，默认模式为，除非您提供外部容器。在这种情况下，您应该根据需要配置容器。我们建议与一起使用，以避免消息丢失。acknowledgetransactedtransactedDefaultMessageListenerContainer

'extract-payload' 属性具有相同的效果，其默认值为 'true'。该元素不适用于消息驱动的通道适配器，因为它是主动调用的。对于大多数方案，消息驱动方法更好，因为一旦从底层 JMS 使用者收到消息，就会将其传递给。pollerMessageChannelspring-doc.cn

最后，该元素还接受 'error-channel' 属性。这提供了相同的基本功能，如进入GatewayProxyFactoryBean中所述。下面的示例说明如何在消息驱动的通道适配器上设置错误通道：<message-driven-channel-adapter>spring-doc.cn

<int-jms:message-driven-channel-adapter id="jmsIn" destination="inQueue"
    channel="exampleChannel"
    error-channel="exampleErrorChannel"/>

将前面的示例与通用网关配置或我们稍后讨论的 JMS “inbound-gateway” 进行比较时，关键的区别在于我们处于单向流中，因为这是一个 'channel-adapter'，而不是网关。因此，从 'error-channel' 下游的流也应该是单向的。例如，它可以发送到日志记录处理程序，或者可以连接到不同的 JMS 元素。<outbound-channel-adapter>spring-doc.cn

当从 topics 使用时，将 attribute 设置为 true。设置为长期订阅或共享订阅（需要 JMS 2.0 代理，并且自版本 4.2 起可用）。用于命名订阅。pub-sub-domainsubscription-durabletruesubscription-sharedsubscription-namespring-doc.cn

从版本 5.1 开始，当终端节点停止而应用程序保持运行时，底层侦听器容器将关闭，从而关闭其共享连接和使用者。以前，连接和使用者保持打开状态。要恢复到之前的行为，请将上的设置为。shutdownContainerOnStopJmsMessageDrivenEndpointfalsespring-doc.cn

从版本 6.3 开始，现在可以为下游 send 和 send-and-receive 操作提供和 for 重试。这些选项也公开在 Java DSL 中。ChannelPublishingJmsMessageListenerRetryTemplateRecoveryCallback<Message<?>>JmsMessageDrivenChannelAdapterSpecspring-doc.cn

入站转换错误

从版本 4.2 开始，'error-channel' 也用于转换错误。以前，如果 JMS 或由于转换错误而无法传递消息，则会将异常抛回到容器中。如果容器配置为使用事务，则消息将回滚并重复重新传递。转换过程发生在消息构造之前和期间，因此此类错误不会发送到 'error-channel'。现在，此类转换异常会导致 an 被发送到 'error-channel'，异常为 . 如果您希望事务回滚，并且您定义了 'error-channel'，则 'error-channel' 上的集成流必须重新抛出异常（或其他异常）。如果错误流没有引发异常，则提交事务并删除消息。如果未定义 'error-channel'，则像以前一样将异常抛回到容器中。<message-driven-channel-adapter/><inbound-gateway/>ErrorMessagepayloadspring-doc.cn

出站通道适配器

它实现了接口，并且能够将 Spring Integration 转换为 JMS 消息，然后发送到 JMS 目标。它需要一个参考文献或两者兼而有之，而参考文献（可以代替提供）。与入站通道适配器一样，配置此适配器的最简单方法是使用名称空间支持。以下配置生成一个适配器，该适配器从接收 Spring 集成消息，将这些消息转换为 JMS 消息，并将它们发送到 bean 名称为：JmsSendingMessageHandlerMessageHandlerMessagesjmsTemplatejmsConnectionFactorydestinationdestinationNamedestinationexampleChanneloutQueuespring-doc.cn

@Bean
public IntegrationFlow jmsOutboundFlow() {
    return IntegrationFlow.from("exampleChannel")
                .handle(Jms.outboundAdapter(cachingConnectionFactory())
                    .destinationExpression("headers." + SimpMessageHeaderAccessor.DESTINATION_HEADER)
                    .configureJmsTemplate(t -> t.id("jmsOutboundFlowTemplate")));
}

@Bean
fun jmsOutboundFlow() =
        integrationFlow("exampleChannel") {
            handle(Jms.outboundAdapter(jmsConnectionFactory())
                    .apply {
                        destinationExpression("headers." + SimpMessageHeaderAccessor.DESTINATION_HEADER)
                        deliveryModeFunction<Any> { DeliveryMode.NON_PERSISTENT }
                        timeToLiveExpression("10000")
                        configureJmsTemplate { it.explicitQosEnabled(true) }
                    }
            )
        }

@Bean
jmsOutboundFlow() {
    integrationFlow('exampleChannel') {
        handle(Jms.outboundAdapter(new ActiveMQConnectionFactory())
                .with {
                    destinationExpression 'headers.' + SimpMessageHeaderAccessor.DESTINATION_HEADER
                    deliveryModeFunction { DeliveryMode.NON_PERSISTENT }
                    timeToLiveExpression '10000'
                    configureJmsTemplate {
                        it.explicitQosEnabled true
                    }
                }
        )
    }
}

@Bean
@ServiceActivator(inputChannel = "exampleChannel")
public MessageHandler jmsOut() {
    JmsSendingMessageHandler handler = new JmsSendingMessageHandler(new JmsTemplate(connectionFactory));
    handler.setDestinationName("outQueue");
    return handler;
}

<int-jms:outbound-channel-adapter id="jmsOut" destination="outQueue" channel="exampleChannel"/>

与入站通道适配器一样，有一个 'extract-payload' 属性。但是，出站适配器的含义相反。 boolean 属性不是应用于 JMS 消息，而是应用于 Spring 集成消息有效负载。换句话说，决定是将 Spring 集成消息本身作为 JMS 消息正文传递，还是将 Spring 集成消息有效负载作为 JMS 消息正文传递。默认值为 'true'。因此，如果您传递的 Spring 集成消息的有效负载为 a ，则会创建一个 JMS。另一方面，如果你想通过 JMS 将实际的 Spring Integration 消息发送到另一个系统，请将其设置为'false'。StringTextMessagespring-doc.cn

无论有效负载提取的布尔值如何，只要您依赖默认转换器或提供对另一个实例的引用，Spring 集成就会映射到 JMS 属性。（这同样适用于“入站”适配器，除了在这些情况下，JMS 属性映射到 Spring Integration ）。MessageHeadersMessageConverterMessageHeaders

从版本 5.1 开始，可以使用和属性配置（），以评估 JMS 消息在运行时根据请求 Spring 发送的适当 QoS 值。的 new 和 options 可能有助于作为 dynamic 和 from 消息标头的信息来源：<int-jms:outbound-channel-adapter>JmsSendingMessageHandlerdeliveryModeExpressiontimeToLiveExpressionMessagesetMapInboundDeliveryMode(true)setMapInboundExpiration(true)DefaultJmsHeaderMapperdeliveryModetimeToLivespring-doc.cn

<int-jms:outbound-channel-adapter delivery-mode-expression="headers.jms_deliveryMode"
                        time-to-live-expression="headers.jms_expiration - T(System).currentTimeMillis()"/>

交易

从版本 4.0 开始，出站通道适配器支持该属性。在早期版本中，您必须注入一个设置为 . 该属性现在在内置 default 上设置属性。如果存在事务（可能来自 upstream ），则在同一事务中执行 send 操作。否则，将启动新事务。session-transactedJmsTemplatesessionTransactedtrueJmsTemplatemessage-driven-channel-adapterspring-doc.cn

入站网关

Spring 集成的消息驱动的 JMS 入站网关委托给容器，支持动态调整并发消费者，还可以处理回复。入站网关需要对 a 和 a 请求（或“requestDestinationName”）的引用。以下示例定义了一个 JMS，该 JMS 从 bean id 引用的 JMS 队列接收，并发送到名为：MessageListenerConnectionFactoryDestinationinbound-gatewayinQueueexampleChannelspring-doc.cn

<int-jms:inbound-gateway id="jmsInGateway"
    request-destination="inQueue"
    request-channel="exampleChannel"/>

由于网关提供请求-回复行为而不是单向发送或接收行为，因此它们还具有两个不同的 “payload extraction” 属性（如前所述，通道适配器的 'extract-payload' 设置）。对于入站网关，'extract-request-payload' 属性确定是否提取收到的 JMS 消息正文。如果为'false'，则 JMS 消息本身将成为 Spring 集成消息有效负载。默认值为 'true'。spring-doc.cn

同样，对于入站网关，'extract-reply-payload'属性适用于要转换为回复 JMS 消息的 Spring 集成消息。如果要传递整个 Spring 集成消息（作为 JMS ObjectMessage的主体），请将value this设置为'false'。默认情况下，Spring 集成消息有效负载转换为 JMS 消息也是“true”的（例如，有效负载变成 JMS TextMessage）。Stringspring-doc.cn

与其他任何事情一样，网关调用可能会导致错误。默认情况下，创建者不会收到使用者端可能发生的错误的通知，并且会超时等待回复。但是，有时您可能希望将错误条件传回给使用者（换句话说，您可能希望通过将异常映射到消息来将异常视为有效回复）。为了实现这一点，JMS 入站网关提供了对消息通道的支持，错误可以发送到该通道进行处理，这可能会导致回复消息有效负载符合某些约定，该约定定义了调用方可能期望的“错误”回复。您可以使用 error-channel 属性来配置此类通道，如下例所示：spring-doc.cn

<int-jms:inbound-gateway request-destination="requestQueue"
          request-channel="jmsInputChannel"
          error-channel="errorTransformationChannel"/>

<int:transformer input-channel="exceptionTransformationChannel"
        ref="exceptionTransformer" method="createErrorResponse"/>

你可能会注意到，这个示例看起来与EnterGatewayProxyFactoryBean中包含的示例非常相似。同样的想法也适用于这里：它可以是一个创建错误响应对象的 POJO，你可以引用 the 来抑制错误，或者你可以省略 'error-channel' 来让异常传播。exceptionTransformernullChannelspring-doc.cn

请参阅入站转换错误。spring-doc.cn

从版本 4.2 开始，默认模式为，除非提供了外部容器。在这种情况下，您应该根据需要配置容器。我们建议您与一起使用，以避免消息丢失。acknowledgetransactedtransactedDefaultMessageListenerContainer

从版本 5.1 开始，当终端节点停止而应用程序保持运行时，底层侦听器容器将关闭，从而关闭其共享连接和使用者。以前，连接和使用者保持打开状态。要恢复到之前的行为，请将上的设置为。shutdownContainerOnStopJmsInboundGatewayfalsespring-doc.cn

默认情况下，将在收到的消息中查找属性以确定将回复发送到何处。否则，可以使用 static 、或或进行配置。此外，从版本 6.1 开始，如果请求上有 standard 属性，则可以在 provided 上配置 a 以动态确定回复目标。收到的 is used the root evaluation context object. 以下示例演示如何使用 Java DSL API 配置入站 JMS 网关，并从请求消息中解析自定义回复目标：JmsInboundGatewayjakarta.jms.Message.getJMSReplyTo()defaultReplyDestinationdefaultReplyQueueNamedefaultReplyTopicNamereplyToExpressionChannelPublishingJmsMessageListenerJMSReplyTonulljakarta.jms.Messagespring-doc.cn

@Bean
public IntegrationFlow jmsInboundGatewayFlow(ConnectionFactory connectionFactory) {
    return IntegrationFlow.from(
                    Jms.inboundGateway(connectionFactory)
                            .requestDestination("requestDestination")
                            .replyToFunction(message -> message.getStringProperty("myReplyTo")))
            .<String, String>transform(String::toUpperCase)
            .get();
}

从版本 6.3 开始，API 公开了用于重试内部发送和接收操作的 and 选项。Jms.inboundGateway()retryTemplate()recoveryCallback()spring-doc.cn

出站网关

出站网关从 Spring Integration 消息创建 JMS 消息，并将它们发送到 . 然后，它通过使用选择器从您配置的接收，或者，如果未提供，则通过创建 JMS（或 if ）实例来处理 JMS 回复消息。request-destinationreply-destinationreply-destinationTemporaryQueueTemporaryTopicreplyPubSubDomain= truespring-doc.cn

将（or ）与设置为 cacheConsumers 的 a 一起使用可能会导致内存不足情况。这是因为每个请求都会获得一个具有新选择器的新使用者（在值上选择，或者在没有时选择发送的 JMSMessageID）。鉴于这些选择器是唯一的，因此在当前请求完成后，它们仍保留在缓存中（未使用）。reply-destinationreply-destination-nameCachingConnectionFactorytruecorrelation-keycorrelation-keyspring-doc.cn

如果指定了回复目标，则建议不要使用缓存的消费者。或者，考虑使用如下所述的 a。<reply-listener/>spring-doc.cn

以下示例显示如何配置出站网关：spring-doc.cn

<int-jms:outbound-gateway id="jmsOutGateway"
    request-destination="outQueue"
    request-channel="outboundJmsRequests"
    reply-channel="jmsReplies"/>

'outbound-gateway' 有效负载提取属性与 'inbound-gateway' 的有效负载提取属性成反比（请参阅前面的讨论）。这意味着 'extract-request-payload' 属性值适用于被转换为 JMS 消息以作为请求发送的 Spring 集成消息。 'extract-reply-payload'属性值适用于作为回复接收的 JMS 消息，然后转换为 Spring 集成消息，随后发送到'reply-channel'，如前面的配置示例所示。spring-doc.cn

使用`<reply-listener/>`

Spring Integration 2.2 引入了一种处理回复的替代技术。如果向网关添加子元素，而不是为每个回复创建使用者，则使用容器来接收回复并将其移交给请求线程。这提供了许多性能优势，并缓解了前面警告中描述的缓存使用者内存利用率问题。<reply-listener/>MessageListenerspring-doc.cn

当将 a 与没有的出站网关一起使用时，将使用 single ，而不是为每个请求创建一个。（如果与代理的连接丢失并恢复，网关会根据需要创建一个附加的。如果设置为，则从版本 6.0 开始，将创建 a。<reply-listener/>reply-destinationTemporaryQueueTemporaryQueueTemporaryQueuereplyPubSubDomaintrueTemporaryTopicspring-doc.cn

使用时，多个网关可以共享相同的回复目标，因为侦听器容器使用每个网关唯一的选择器。correlation-keyspring-doc.cn

如果您指定回复侦听器并指定回复目标（或回复目标名称），但未提供关联键，则网关将记录警告并回退到版本 2.2 之前的行为。这是因为在这种情况下无法配置选择器。因此，无法避免应答发送到可能配置了相同应答目标的不同网关。spring-doc.cn

请注意，在这种情况下，每个请求都会使用一个新的使用者，并且使用者可以按照上面的警告中所述在内存中构建;因此，在这种情况下，不应使用缓存的使用者。spring-doc.cn

以下示例显示了具有 default 属性的回复侦听器：spring-doc.cn

<int-jms:outbound-gateway id="jmsOutGateway"
        request-destination="outQueue"
        request-channel="outboundJmsRequests"
        reply-channel="jmsReplies">
    <int-jms:reply-listener />
</int-jms-outbound-gateway>

侦听器非常轻量级，我们预计在大多数情况下，您只需要一个使用者。但是，您可以添加、等属性。有关受支持属性的完整列表，请参见模式，以及 Spring JMS 文档以了解其含义。concurrent-consumersmax-concurrent-consumersspring-doc.cn

空闲回复侦听器

从版本 4.2 开始，您可以根据需要启动回复侦听器（并在空闲时间后停止它），而不是在网关的生命周期内运行。如果应用程序上下文中有许多网关，而这些网关大多处于空闲状态，则这可能很有用。一种这样的情况是具有许多（非活动）分区 Spring Batch 作业的上下文，这些作业使用 Spring Integration 和 JMS 进行分区分发。如果所有回复侦听器都处于活动状态，则 JMS 代理的每个网关都有一个活动的使用者。通过启用空闲超时，每个使用者仅在相应的批处理作业运行时存在（并且在批处理作业完成后的短时间内存在）。spring-doc.cn

请参见属性参考。idle-reply-listener-timeoutspring-doc.cn

网关回复关联

本节介绍用于回复关联的机制（确保原始网关仅接收对其请求的回复），具体取决于网关的配置方式。有关此处讨论的属性的完整描述，请参阅 Attribute Reference。spring-doc.cn

以下列表描述了各种情况（数字用于识别 — 顺序无关紧要）：spring-doc.cn

无属性，无reply-destination*<reply-listener>spring-doc.cn

将为每个请求创建 A，并在请求完成（成功或失败）时删除 A。无关紧要。TemporaryQueuecorrelation-keyspring-doc.cn
提供 a 属性，但既未提供 a 也不提供 areply-destination*<reply-listener/>correlation-keyspring-doc.cn

等于传出消息用作使用者的消息选择器：JMSCorrelationIDspring-doc.cn

messageSelector = "JMSCorrelationID = '" + messageId + "'"spring-doc.cn

响应系统应在回复中返回入站。这是一种常见模式，由 Spring 集成入站网关以及 Spring 的消息驱动 POJO 实现。JMSMessageIDJMSCorrelationIDMessageListenerAdapterspring-doc.cn

使用此配置时，不应将主题用于回复。回复可能会丢失。
提供属性，不提供 no，并且reply-destination*<reply-listener/>correlation-key="JMSCorrelationID"spring-doc.cn

网关生成唯一的关联 IS 并将其插入报头中。消息选择器为：JMSCorrelationIDspring-doc.cn

messageSelector = "JMSCorrelationID = '" + uniqueId + "'"spring-doc.cn

响应系统应在回复中返回入站。这是一种常见模式，由 Spring 集成入站网关以及 Spring 的消息驱动 POJO 实现。JMSCorrelationIDJMSCorrelationIDMessageListenerAdapterspring-doc.cn
提供属性，不提供 no，并且reply-destination*<reply-listener/>correlation-key="myCorrelationHeader"spring-doc.cn

网关将生成唯一的相关 ID 并将其插入 message 属性中。可以是任何用户定义的值。消息选择器为：myCorrelationHeadercorrelation-keyspring-doc.cn

messageSelector = "myCorrelationHeader = '" + uniqueId + "'"spring-doc.cn

响应系统应在回复中返回入站。myCorrelationHeadermyCorrelationHeaderspring-doc.cn
提供了 a property， no is provided，以及（请注意关联键中的。reply-destination*<reply-listener/>correlation-key="JMSCorrelationID*"*spring-doc.cn

网关使用请求消息的标头（如果存在）中的值，并将其插入到标头中。消息选择器为：jms_correlationIdJMSCorrelationIDspring-doc.cn

messageSelector = "JMSCorrelationID = '" + headers['jms_correlationId'] + "'"spring-doc.cn

用户必须确保此值是唯一的。spring-doc.cn

如果标头不存在，则网关的行为与中相同。3spring-doc.cn

响应系统应在回复中返回入站。这是一种常见模式，由 Spring 集成入站网关以及 Spring 的消息驱动 POJO 实现。JMSCorrelationIDJMSCorrelationIDMessageListenerAdapterspring-doc.cn
未提供任何属性，并且提供了reply-destination*<reply-listener>spring-doc.cn

将创建一个临时队列，并将其用于此网关实例中的所有回复。消息中不需要关联数据，但在网关内部使用传出数据，以将回复定向到正确的请求线程。JMSMessageIDspring-doc.cn
提供属性、提供 a 和 noreply-destination*<reply-listener>correlation-keyspring-doc.cn

不允许。spring-doc.cn

配置将被忽略，网关的行为与中所示。将写入一条警告日志消息以指示这种情况。<reply-listener/>2spring-doc.cn
提供 a 属性， a 提供，并且reply-destination*<reply-listener>correlation-key="JMSCorrelationID"spring-doc.cn

网关具有唯一的相关 ID 并将其与标头（）中的递增值一起插入。消息选择器为：JMSCorrelationIDgatewayId + "_" + ++seqspring-doc.cn

messageSelector = "JMSCorrelationID LIKE '" + gatewayId%'"spring-doc.cn

响应系统应在回复中返回入站。这是一种常见模式，由 Spring 集成入站网关以及 Spring 的消息驱动 POJO 实现。由于每个网关都有一个唯一的 ID，因此每个实例都只能获得自己的回复。完整的关联数据用于将回复路由到正确的请求线程。JMSCorrelationIDJMSCorrelationIDMessageListenerAdapterspring-doc.cn
提供 a 属性，并且reply-destination*<reply-listener/>correlation-key="myCorrelationHeader"spring-doc.cn

网关具有唯一的相关 ID 并将其与属性（）中的递增值一起插入。可以是任何用户定义的值。消息选择器为：myCorrelationHeadergatewayId + "_" + ++seqcorrelation-keyspring-doc.cn

messageSelector = "myCorrelationHeader LIKE '" + gatewayId%'"spring-doc.cn

响应系统应在回复中返回入站。由于每个网关都有一个唯一的 ID，因此每个实例只获得自己的回复。完整的关联数据用于将回复路由到正确的请求线程。myCorrelationHeadermyCorrelationHeaderspring-doc.cn
提供 a 属性， a 提供，并且reply-destination*<reply-listener/>correlation-key="JMSCorrelationID*"spring-doc.cn

（请注意 correlation key 中的）*spring-doc.cn

不允许。spring-doc.cn

回复侦听器不允许使用用户提供的相关 ID。网关不使用此配置进行初始化。spring-doc.cn

异步网关

从版本 4.3 开始，您现在可以在配置出站网关时指定（或在 Java 中指定）。async="true"setAsync(true)spring-doc.cn

默认情况下，当请求发送到网关时，请求线程将暂停，直到收到回复。然后，流在该线程上继续。如果为 is ，则请求线程在完成后立即释放，并在侦听器容器线程上返回回复（并且流继续）。当在 poller 线程上调用网关时，这可能很有用。线程已释放，可用于框架中的其他任务。asynctruesend()spring-doc.cn

您需要一个（或使用 Java 配置时）。它还需要指定 a （通常）。如果不满足这些条件中的任何一个，则忽略。async<reply-listener/>setUseReplyContainer(true)correlationKeyJMSCorrelationIDasyncspring-doc.cn

属性参考

以下清单显示了：outbound-gatewayspring-doc.cn

<int-jms:outbound-gateway
    connection-factory="connectionFactory" (1)
    correlation-key="" (2)
    delivery-persistent="" (3)
    destination-resolver="" (4)
    explicit-qos-enabled="" (5)
    extract-reply-payload="true" (6)
    extract-request-payload="true" (7)
    header-mapper="" (8)
    message-converter="" (9)
    priority="" (10)
    receive-timeout="" (11)
    reply-channel="" (12)
    reply-destination="" (13)
    reply-destination-expression="" (14)
    reply-destination-name="" (15)
    reply-pub-sub-domain="" (16)
    reply-timeout="" (17)
    request-channel="" (18)
    request-destination="" (19)
    request-destination-expression="" (20)
    request-destination-name="" (21)
    request-pub-sub-domain="" (22)
    time-to-live="" (23)
    requires-reply="" (24)
    idle-reply-listener-timeout="" (25)
    async=""> (26)
  <int-jms:reply-listener /> (27)
</int-jms:outbound-gateway>

1 对 . 默认的 .jakarta.jms.ConnectionFactoryjmsConnectionFactory

包含关联数据以将响应与回复关联的属性的名称。如果省略，则网关希望响应系统在标头中返回出站标头的值。如果指定，网关将生成相关 ID 并使用该 ID 填充指定的属性。响应系统必须在同一属性中回显该值。它可以设置为，在这种情况下，使用标准报头而不是属性来保存关联数据。使用时，必须指定如果提供显式 . 从版本 4.0.1 开始，此属性还支持 value ，这意味着如果出站消息已经具有（映射自）标头，则使用它而不是生成新的标头。请注意，当您使用时不允许使用该键，因为容器需要在初始化期间设置消息选择器。JMSMessageIDJMSCorrelationIDJMSCorrelationIDString<reply-container/>correlation-keyreply-destinationJMSCorrelationID*JMSCorrelationIDjms_correlationIdJMSCorrelationID*<reply-container/>

您应该了解，网关无法确保唯一性，如果提供的相关 ID 不唯一，则可能会发生意外的副作用。

3 一个布尔值，指示传递模式应为（）还是（）。此设置仅在为时生效。DeliveryMode.PERSISTENTtrueDeliveryMode.NON_PERSISTENTfalseexplicit-qos-enabledtrue

4 一个。默认值为 a ，它将目标名称映射到该名称的队列或主题。DestinationResolverDynamicDestinationResolver

5 设置为时，它允许使用服务质量属性：、和。trueprioritydelivery-modetime-to-live

6 当设置为（默认值）时，将从 JMS Reply 消息的正文（通过使用）创建 Spring 集成应答消息的有效负载。当设置为时，整个 JMS 消息将成为 Spring Integration 消息的有效负载。trueMessageConverterfalse

7 当设置为（默认值）时，Spring 集成消息的有效负载将转换为（通过使用）。当设置为时，整个 Spring 集成消息将转换为 . 在这两种情况下，Spring 集成消息头都使用 .trueJMSMessageMessageConverterfalseJMSMessageHeaderMapper

8 用于将 Spring 集成消息头映射到 JMS 消息头和属性或从 JMS 消息头和属性映射。HeaderMapper

9 对 a 的引用，用于在 JMS 消息和 Spring 集成消息有效负载（或 messages if is ）之间进行转换。默认值为 .MessageConverterextract-request-payloadfalseSimpleMessageConverter

10 请求消息的默认优先级。被消息优先级标头（如果存在）覆盖。其范围是。此设置仅在为时生效。09explicit-qos-enabledtrue

11 等待回复的时间（以毫秒为单位）。默认值为（5 秒）。5000

12 将回复消息发送到的通道。

13 对的引用，该引用设置为 header。最多只允许，，或中的一个。如果未提供任何内容，则使用 a 回复此网关。DestinationJMSReplyToreply-destinationreply-destination-expressionreply-destination-nameTemporaryQueue

14 一个 SPEL 表达式的计算结果为，该表达式将被设置为 header。表达式可以生成 object 或 . 它被用于解析实际的 . 最多只允许，，或中的一个。如果未提供任何内容，则使用 a 回复此网关。DestinationJMSReplyToDestinationStringDestinationResolverDestinationreply-destinationreply-destination-expressionreply-destination-nameTemporaryQueue

15 设置为 JMSReplyTo 标头的目标的名称。它被用于解析实际的 . 最多只允许，，或中的一个。如果未提供任何内容，则使用 a 回复此网关。DestinationResolverDestinationreply-destinationreply-destination-expressionreply-destination-nameTemporaryQueue

16 当设置为时，它表示由解析的任何回复都应该是 a 而不是。trueDestinationDestinationResolverTopicQueue

17 网关在向发送回复消息时等待的时间。这仅在 can 阻止时有效 — 例如容量限制当前已满的 a。默认值为 infinity。reply-channelreply-channelQueueChannel

18 此网关接收请求消息的通道。

19 对请求消息发送到的 a 的引用。、、或中的一个是必需的。您只能使用这三个属性中的一个。Destinationreply-destinationreply-destination-expressionreply-destination-name

20 一个 SPEL 表达式，计算结果为请求消息发送到的 a。表达式可以生成 object 或 . 它被用于解析实际的 . 、、或之一是必需的。您只能使用这三个属性中的一个。DestinationDestinationStringDestinationResolverDestinationreply-destinationreply-destination-expressionreply-destination-name

21 请求消息发送到的目标的名称。它被用于解析实际的 . 、、或中的一个是必需的。您只能使用这三个属性中的一个。DestinationResolverDestinationreply-destinationreply-destination-expressionreply-destination-name

22 当设置为时，它表示解析的任何请求都应该是 a 而不是。trueDestinationDestinationResolverTopicQueue

23 指定消息生存时间。此设置仅在为时生效。explicit-qos-enabledtrue

24 指定此出站网关是否必须返回非 null 值。默认情况下，这个值为，当底层服务在 . 请注意，如果服务从未期望返回回复，则最好使用 a 而不是 with 。对于后者，发送线程将被阻塞，等待该时间段的回复。trueMessageTimeoutExceptionreceive-timeout<int-jms:outbound-channel-adapter/><int-jms:outbound-gateway/>requires-reply="false"receive-timeout

25 当您使用 a 时，默认情况下，其生命周期（start 和 stop）与网关的生命周期匹配。当此值大于时，容器将按需启动（发送请求时）。容器将继续运行，至少直到此时间过去，没有收到任何请求（并且直到没有未完成的回复）。容器将在下一个请求中再次启动。停止时间是最小值，实际上可能高达此值的 1.5 倍。<reply-listener />0

26 请参阅异步网关。

27 当包含此元素时，回复由异步接收，而不是为每个回复创建一个使用者。在许多情况下，这可能更有效。MessageListenerContainer

将消息头映射到 JMS 消息或从 JMS 消息映射消息

JMS 消息可以包含元信息，例如 JMS API 标头和简单属性。您可以使用 Map 这些消息头和 Spring 集成消息头。 JMS API 标头将传递给相应的 setter 方法（例如），而其他标头将复制到 JMS Message 的常规属性中。 JMS 出站网关是使用的默认实现引导的，它将映射标准 JMS API 头以及原始或消息头。您还可以使用入站网关和出站网关的属性提供自定义标头映射器。JmsHeaderMappersetJMSReplyToJmsHeaderMapperStringheader-mapperspring-doc.cn

许多特定于 JMS 供应商的客户端不允许直接在已创建的 JMS 消息上设置、和属性。它们被视为 QoS 属性，因此必须传播到目标 API。因此，没有将适当的 Spring 集成头（或表达式结果）映射到提到的 JMS 消息属性中。相反，a 被用于将标头值从请求消息传播到 API。要启用此功能，您必须为出站终端节点配置 a，并将其属性设置为 true。 Spring 集成 Java DSL 默认配置 a，但你仍然必须设置该属性。deliveryModeprioritytimeToLiveMessageProducer.send(message, deliveryMode, priority, timeToLive)DefaultJmsHeaderMapperDynamicJmsTemplateJmsSendingMessageHandlerMessageProducer.send()DynamicJmsTemplateexplicitQosEnabledDynamicJmsTemplateexplicitQosEnabled

从版本 4.0 开始，标头映射到入站消息的标准标头。以前，标头仅用于出站消息。要恢复到以前的行为（即不映射入站优先级），请将的属性设置为。JMSPrioritypriorityprioritymapInboundPriorityDefaultJmsHeaderMapperfalse

从版本 4.3 开始，通过调用其方法（通常是，JMS 不支持）将标准标头映射为消息属性。在入站端，它被映射为 . 这与 header 无关，header 映射到 header 或从 header 映射。通常用于关联请求和回复，而 the 通常用于将相关消息合并到一个组中（例如与聚合器或重新排序器）。DefaultJmsHeaderMappercorrelationIdtoString()correlationIdUUIDStringjms_correlationIdJMSCorrelationIDJMSCorrelationIDcorrelationId

从版本 5.1 开始，可以配置映射入站和属性：DefaultJmsHeaderMapperJMSDeliveryModeJMSExpirationspring-doc.cn

@Bean
public DefaultJmsHeaderMapper jmsHeaderMapper() {
    DefaultJmsHeaderMapper mapper = new DefaultJmsHeaderMapper();
    mapper.setMapInboundDeliveryMode(true)
    mapper.setMapInboundExpiration(true)
    return mapper;
}

这些 JMS 属性分别映射到 Spring Message 头。JmsHeaders.DELIVERY_MODEJmsHeaders.EXPIRATIONspring-doc.cn

消息转换、封送处理和解组

如果需要转换消息，所有 JMS 适配器和网关都允许您通过设置属性来提供。为此，请提供在同一ApplicationContext中可用的实例的 bean 名称。此外，为了提供与 marshaller 和 unmarshaller 接口的一些一致性， Spring 提供了，您可以使用自己的自定义 marshallers 和 unmarshallers 对其进行配置。以下示例说明如何执行此操作MessageConvertermessage-converterMessageConverterMarshallingMessageConverterspring-doc.cn

<int-jms:inbound-gateway request-destination="requestQueue"
    request-channel="inbound-gateway-channel"
    message-converter="marshallingMessageConverter"/>

<bean id="marshallingMessageConverter"
    class="org.springframework.jms.support.converter.MarshallingMessageConverter">
    <constructor-arg>
        <bean class="org.bar.SampleMarshaller"/>
    </constructor-arg>
    <constructor-arg>
        <bean class="org.bar.SampleUnmarshaller"/>
    </constructor-arg>
</bean>

当您提供自己的实例时，它仍包装在 . 这意味着 'extract-request-payload' 和 'extract-reply-payload' 属性可以影响传递给转换器的实际对象。本身委托给目标，同时还将 Spring 集成映射到 JMS 消息属性，然后再映射回来。MessageConverterHeaderMappingMessageConverterHeaderMappingMessageConverterMessageConverterMessageHeaders

JMS 支持的消息通道

前面介绍的通道适配器和网关都适用于与其他外部系统集成的应用程序。入站选项假定其他系统正在向 JMS 目标发送 JMS 消息，出站选项假定其他系统正在从目标接收消息。另一个系统可能是也可能不是 Spring 集成应用程序。当然，当将 Spring 集成消息实例作为 JMS 消息本身的主体发送时（将 'extract-payload' 值设置为），则假定另一个系统基于 Spring Integration。然而，这绝不是必需的。这种灵活性是使用基于消息的集成选项和抽象的 “channels”（或 JMS 中的目标）的好处之一。falsespring-doc.cn

有时，给定 JMS Destination 的创建者和使用者都希望成为同一应用程序的一部分，运行在同一进程中。您可以通过使用一对入站和出站通道适配器来实现此目的。这种方法的问题在于您需要两个适配器，即使从概念上讲，目标是拥有单个消息通道。从 Spring Integration 版本 2.0 开始，支持更好的选择。现在，在使用 JMS 名称空间时可以定义单个 “channel”，如下例所示：spring-doc.cn

<int-jms:channel id="jmsChannel" queue="exampleQueue"/>

前面示例中的通道的行为很像主 Spring Integration 命名空间中的普通元素。它可以被任何端点的 the 和属性引用。区别在于，此通道由名为的 JMS Queue 实例提供支持。这意味着可以在生产终端节点和使用终端节点之间进行异步消息收发。但是，与通过在非 JMS 元素中添加元素创建的更简单的异步消息通道不同，消息不存储在内存中队列中。相反，这些消息在 JMS 消息正文中传递，然后底层 JMS 提供程序的全部功能可用于该通道。使用这种替代方法的最常见理由可能是利用 JMS 消息传递的存储转发方法提供的持久性。<channel/>input-channeloutput-channelexampleQueue<queue/><channel/>spring-doc.cn

如果配置正确，JMS 支持的消息通道还支持事务。换句话说，如果生产者的发送操作是回滚事务的一部分，则生产者实际上不会写入事务性 JMS 支持的通道。同样，如果 JMS 消息的接收是回滚事务的一部分，则使用者不会从通道中物理删除该消息。请注意，在这种情况下，生产者和使用者事务是分开的。这与事务上下文在没有子元素的简单同步元素之间传播明显不同。<channel/><queue/>spring-doc.cn

由于前面的示例引用了一个 JMS Queue 实例，因此它充当点对点通道。另一方面，如果您需要发布-订阅行为，则可以使用单独的元素并引用 JMS 主题。以下示例显示了如何执行此操作：spring-doc.cn

<int-jms:publish-subscribe-channel id="jmsChannel" topic="exampleTopic"/>

对于任一类型的 JMS 支持的通道，都可以提供目标的名称而不是引用，如下例所示：spring-doc.cn

<int-jms:channel id="jmsQueueChannel" queue-name="exampleQueueName"/>

<jms:publish-subscribe-channel id="jmsTopicChannel" topic-name="exampleTopicName"/>

在前面的示例中，目标名称由 Spring 的默认实现解析，但你可以提供接口的任何实现。此外，JMS 是通道的必需属性，但默认情况下，预期的 bean 名称将是 . 以下示例提供了用于解析 JMS 目标名称的自定义实例和用于的不同名称：DynamicDestinationResolverDestinationResolverConnectionFactoryjmsConnectionFactoryConnectionFactoryspring-doc.cn

<int-jms:channel id="jmsChannel" queue-name="exampleQueueName"
    destination-resolver="customDestinationResolver"
    connection-factory="customConnectionFactory"/>

对于，将属性设置为 for a durable subscription 或 for shared subscription （需要 JMS 2.0 代理，并且自 4.2 版起可用）。用于命名订阅。<publish-subscribe-channel />durabletruesubscription-sharedsubscriptionspring-doc.cn

使用 JMS 消息选择器

使用 JMS 消息选择器，您可以根据 JMS 标头和 JMS 属性筛选 JMS 消息。例如，如果要侦听其自定义 JMS 标头属性， equals 的消息，则可以指定以下表达式：myHeaderPropertysomethingspring-doc.cn

myHeaderProperty = 'something'

消息选择器表达式是 SQL-92 条件表达式语法的子集，定义为 Java 消息服务规范的一部分。你可以通过使用以下 Spring 集成 JMS 组件的 XML 名称空间配置来指定 JMS 消息属性：selectorspring-doc.cn

JMS 通道spring-doc.cn
JMS 发布订阅频道spring-doc.cn
JMS 入站通道适配器spring-doc.cn
JMS 入站网关spring-doc.cn
JMS 消息驱动的通道适配器spring-doc.cn

不能使用 JMS 消息选择器引用消息正文值。

JMS 示例

要试验这些 JMS 适配器，请查看 Spring 集成示例 Git 存储库中提供的 JMS 示例，网址为 https://github.com/spring-projects/spring-integration-samples/tree/master/basic/jms。spring-doc.cn

该存储库包括两个示例。一个提供入站和出站通道适配器，另一个提供入站和出站网关。它们被配置为使用嵌入式 ActiveMQ 进程运行，但您可以修改每个样本的 common.xml Spring 应用程序上下文文件，以支持不同的 JMS 提供程序或独立的 ActiveMQ 进程。spring-doc.cn

换句话说，您可以拆分配置，以便入站和出站适配器在单独的 JVM 中运行。如果已安装 ActiveMQ，请修改文件中要使用的属性（而不是）。这两个样本都接受来自 stdin 的 input 并回显回 stdout。查看配置以了解这些消息是如何通过 JMS 路由的。brokerURLcommon.xmltcp://localhost:61616vm://localhostspring-doc.cn

JMS 支持

入站通道适配器

交易

消息驱动的通道适配器

入站转换错误

出站通道适配器

交易

入站网关

出站网关

使用<reply-listener/>

空闲回复侦听器

网关回复关联

异步网关

属性参考

将消息头映射到 JMS 消息或从 JMS 消息映射消息

消息转换、封送处理和解组

JMS 支持的消息通道

使用 JMS 消息选择器

JMS 示例

使用`<reply-listener/>`