JMS

ConnectionFactory 接口提供了一种标准方法来创建 Connection 以与 JMS 代理交互。尽管 Spring 需要一个 ConnectionFactory 来使用 JMS，但您通常无需自己直接使用它，而是可以依赖更高级别的消息抽象。（有关详细信息，请参阅 Spring Framework 参考文档的相关部分。）Spring Boot 也自动配置了发送和接收消息所需的基础设施。

ActiveMQ "Classic" 支持

当类路径中存在 ActiveMQ "Classic" 时，Spring Boot 可以配置一个 ConnectionFactory。如果存在代理，则会自动启动并配置一个嵌入式代理（前提是没有通过配置指定代理 URL 且在配置中没有禁用嵌入式代理）。

如果您使用 spring-boot-starter-activemq，则会提供连接到 ActiveMQ "Classic" 实例所需的依赖项，以及与 JMS 集成的 Spring 基础设施。将 org.apache.activemq:activemq-broker 添加到您的应用程序中，即可使用嵌入式代理。

ActiveMQ "Classic" 的配置由 spring.activemq.* 中的外部配置属性控制。

如果类路径中有 activemq-broker，则 ActiveMQ "Classic" 会被自动配置为使用 VM transport，这会在同一个 JVM 实例中启动一个嵌入式代理。

您可以通过配置 spring.activemq.embedded.enabled 属性来禁用嵌入式代理，如下例所示

属性
YAML

spring.activemq.embedded.enabled=false

spring:
  activemq:
    embedded:
      enabled: false

如果您配置了代理 URL，嵌入式代理也将被禁用，如下例所示

属性
YAML

spring.activemq.broker-url=tcp://192.168.1.210:9876
spring.activemq.user=admin
spring.activemq.password=secret

spring:
  activemq:
    broker-url: "tcp://192.168.1.210:9876"
    user: "admin"
    password: "secret"

如果您想完全控制嵌入式代理，请参阅ActiveMQ "Classic" 文档以获取更多信息。

默认情况下，一个 CachingConnectionFactory 会包装原生 ConnectionFactory，并使用可通过 spring.jms.* 中的外部配置属性控制的合理设置。

属性
YAML

spring.jms.cache.session-cache-size=5

spring:
  jms:
    cache:
      session-cache-size: 5

如果您宁愿使用原生连接池，可以通过添加 org.messaginghub:pooled-jms 依赖并相应地配置 JmsPoolConnectionFactory 来实现，如下例所示

属性
YAML

spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=50

spring:
  activemq:
    pool:
      enabled: true
      max-connections: 50

有关更多支持的选项，请参阅 ActiveMQProperties。您还可以注册任意数量实现 ActiveMQConnectionFactoryCustomizer 接口的 Bean，以进行更高级的自定义。

默认情况下，如果目的地尚不存在，ActiveMQ "Classic" 会创建它，这样目的地就可以根据其提供的名称进行解析。

ActiveMQ Artemis 支持

当 Spring Boot 检测到类路径中存在 ActiveMQ Artemis 时，它可以自动配置一个 ConnectionFactory。如果存在代理，则会自动启动并配置一个嵌入式代理（除非明确设置了 mode 属性）。支持的模式包括 embedded（明确表示需要嵌入式代理，如果代理不在类路径中应报告错误）和 native（使用 netty 传输协议连接到代理）。配置后一种模式时，Spring Boot 会配置一个 ConnectionFactory，该工厂使用默认设置连接到在本地机器上运行的代理。

如果您使用 spring-boot-starter-artemis，则会提供连接到现有 ActiveMQ Artemis 实例所需的依赖项，以及与 JMS 集成的 Spring 基础设施。将 org.apache.activemq:artemis-jakarta-server 添加到您的应用程序中，即可使用嵌入式模式。

ActiveMQ Artemis 的配置由 spring.artemis.* 中的外部配置属性控制。例如，您可以在 application.properties 中声明以下部分

属性
YAML

spring.artemis.mode=native
spring.artemis.broker-url=tcp://192.168.1.210:9876
spring.artemis.user=admin
spring.artemis.password=secret

spring:
  artemis:
    mode: native
    broker-url: "tcp://192.168.1.210:9876"
    user: "admin"
    password: "secret"

在嵌入式代理模式下，您可以选择是否启用持久化，并列出应可用的目的地。这些目的地可以指定为逗号分隔的列表，以使用默认选项创建它们，或者您可以定义类型为 JMSQueueConfiguration 或 TopicConfiguration 的 Bean，分别用于高级队列和主题配置。

默认情况下，一个 CachingConnectionFactory 会包装原生 ConnectionFactory，并使用可通过 spring.jms.* 中的外部配置属性控制的合理设置。

属性
YAML

spring.jms.cache.session-cache-size=5

spring:
  jms:
    cache:
      session-cache-size: 5

如果您宁愿使用原生连接池，可以通过添加 org.messaginghub:pooled-jms 依赖并相应地配置 JmsPoolConnectionFactory 来实现，如下例所示

属性
YAML

spring.artemis.pool.enabled=true
spring.artemis.pool.max-connections=50

spring:
  artemis:
    pool:
      enabled: true
      max-connections: 50

有关更多支持的选项，请参阅 ArtemisProperties。

不涉及 JNDI 查找，目的地根据其名称进行解析，可以使用 ActiveMQ Artemis 配置中的 name 属性或通过配置提供的名称。

使用 JNDI ConnectionFactory

如果您在应用程序服务器中运行您的应用程序，Spring Boot 会尝试使用 JNDI 查找 JMS ConnectionFactory。默认情况下，会检查 java:/JmsXA 和 java:/XAConnectionFactory 位置。如果需要指定其他位置，您可以使用 spring.jms.jndi-name 属性，如下例所示

属性
YAML

spring.jms.jndi-name=java:/MyConnectionFactory

spring:
  jms:
    jndi-name: "java:/MyConnectionFactory"

发送消息

Spring 的 JmsTemplate 会自动配置，您可以直接将其自动注入到您的 Bean 中，如下例所示

Java
Kotlin

import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

	private final JmsTemplate jmsTemplate;

	public MyBean(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}

	// ...

	public void someMethod() {
		this.jmsTemplate.convertAndSend("hello");
	}

}

import org.springframework.jms.core.JmsTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val jmsTemplate: JmsTemplate) {

	// ...

	fun someMethod() {
		jmsTemplate.convertAndSend("hello")
	}

}

JmsMessagingTemplate 可以以类似的方式注入。如果定义了 DestinationResolver 或 MessageConverter Bean，它们将自动关联到自动配置的 JmsTemplate。

接收消息

当存在 JMS 基础设施时，任何 Bean 都可以使用 @JmsListener 注解来创建监听器端点。如果没有定义 JmsListenerContainerFactory，则会自动配置一个默认的工厂。如果定义了 DestinationResolver、MessageConverter 或 ExceptionListener Bean，它们将自动关联到默认工厂。

在大多数情况下，消息监听器容器应该配置针对原生的 ConnectionFactory。这样每个监听器容器都有自己的连接，并且在本地恢复方面拥有完全的责任。自动配置使用 ConnectionFactoryUnwrapper 来从自动配置的工厂中解包出原生连接工厂。

自动配置只解包 CachedConnectionFactory。

默认情况下，默认工厂是事务性的。如果您在存在 JtaTransactionManager 的基础设施中运行，它会默认与监听器容器关联。如果没有，则启用 sessionTransacted 标志。在后一种情况下，您可以通过在监听器方法（或其委托方法）上添加 @Transactional 来将本地数据存储事务与处理传入消息关联起来。这确保在本地事务完成后，传入消息被确认。这也包括发送在同一 JMS 会话上执行的响应消息。

以下组件在 someQueue 目的地创建了一个监听器端点

Java
Kotlin

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

	@JmsListener(destination = "someQueue")
	public void processMessage(String content) {
		// ...
	}

}

import org.springframework.jms.annotation.JmsListener
import org.springframework.stereotype.Component

@Component
class MyBean {

	@JmsListener(destination = "someQueue")
	fun processMessage(content: String?) {
		// ...
	}

}

有关更多详细信息，请参阅 @EnableJms API 文档。

如果您需要创建更多 JmsListenerContainerFactory 实例或想覆盖默认设置，Spring Boot 提供了一个 DefaultJmsListenerContainerFactoryConfigurer，您可以使用它来初始化一个 DefaultJmsListenerContainerFactory，使其具有与自动配置的工厂相同的设置。

例如，以下示例展示了使用特定 MessageConverter 的另一个工厂

Java
Kotlin

import jakarta.jms.ConnectionFactory;

import org.springframework.boot.autoconfigure.jms.DefaultJmsListenerContainerFactoryConfigurer;
import org.springframework.boot.jms.ConnectionFactoryUnwrapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;

@Configuration(proxyBeanMethods = false)
public class MyJmsConfiguration {

	@Bean
	public DefaultJmsListenerContainerFactory myFactory(DefaultJmsListenerContainerFactoryConfigurer configurer,
			ConnectionFactory connectionFactory) {
		DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
		configurer.configure(factory, ConnectionFactoryUnwrapper.unwrapCaching(connectionFactory));
		factory.setMessageConverter(new MyMessageConverter());
		return factory;
	}

}

import jakarta.jms.ConnectionFactory
import org.springframework.boot.autoconfigure.jms.DefaultJmsListenerContainerFactoryConfigurer
import org.springframework.boot.jms.ConnectionFactoryUnwrapper
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.jms.config.DefaultJmsListenerContainerFactory

@Configuration(proxyBeanMethods = false)
class MyJmsConfiguration {

	@Bean
	fun myFactory(configurer: DefaultJmsListenerContainerFactoryConfigurer,
				  connectionFactory: ConnectionFactory): DefaultJmsListenerContainerFactory {
		val factory = DefaultJmsListenerContainerFactory()
		configurer.configure(factory, ConnectionFactoryUnwrapper.unwrapCaching(connectionFactory))
		factory.setMessageConverter(MyMessageConverter())
		return factory
	}

}

在上面的示例中，定制使用了 ConnectionFactoryUnwrapper，以与自动配置工厂相同的方式将原生连接工厂关联到消息监听器容器。

然后您可以在任何带有 @JmsListener 注解的方法中使用该工厂，如下所示

Java
Kotlin

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

	@JmsListener(destination = "someQueue", containerFactory = "myFactory")
	public void processMessage(String content) {
		// ...
	}

}

import org.springframework.jms.annotation.JmsListener
import org.springframework.stereotype.Component

@Component
class MyBean {

	@JmsListener(destination = "someQueue", containerFactory = "myFactory")
	fun processMessage(content: String?) {
		// ...
	}

}