SpringBoot学习笔记14-Messaging消息传递
以spring官方文档为基础，官方地址：Spring Boot_Messaging
Spring框架为消息传递提供了广泛的支持，从使用JmsTemplate简化JMS API的使用，到完整的基础设施来异步接收消息。Spring AMQP为高级消息队列协议提供了类似的特性集。Spring Boot还为RabbitTemplate和RabbitMQ提供了自动配置选项。Spring WebSocket原生地包含了对STOMP消息传递的支持，而Spring Boot则通过启动器和少量的自动配置来支持这一点。Spring Boot也支持Apache Kafka。
1. JMS
javax.jms.ConnectionFactory接口提供了创建javax.jms.Connection的标准方法，用于与JMS broker进行交互。尽管Spring需要ConnectionFactory来处理JMS，但通常不需要直接使用它，而是可以依赖于更高级别的消息传递抽象。(详情请参阅Spring Framework参考文档的JMS相关章节)Spring Boot还自动配置必要的基础设施来发送和接收消息。
1.1 ActiveMQ 支持
ActiveMQ 是开源，多协议，基于Java的消息服务器。
当ActiveMQ在类路径上可用时，Spring Boot还可以配置ConnectionFactory。如果存在broker，则会自动启动并配置嵌入式broker(前提是配置中没有指定broker URL，且在配置中没有禁用嵌入式broker)。
如果使用spring-boot-starter-activemq，就会提供连接或嵌入ActiveMQ实例所需的依赖项，就像与JMS集成的Spring基础设施一样。
ActiveMQ配置由spring.activemq.*中的外部配置属性控制。
默认情况下，ActiveMQ被自动配置为使用VM传输，它会启动嵌入在同一个JVM实例中的broker。
可以通过配置spring.activemq.in-memory来禁用嵌入式broker，如下所示：
spring.activemq.in-memory=false
如果配置broker URL，嵌入式broker也会被禁用，如下所示：
spring.activemq.broker-url=tcp://192.168.1.210:9876
spring.activemq.user=admin
spring.activemq.password=secret
如果想完全控制嵌入式broker，请参阅ActiveMQ文档了解更多信息。
默认情况下，CachingConnectionFactory用合理的设置包装了本地的ConnectionFactory，可以通过spring.jms.*中的外部配置属性来控制这些设置。
spring.jms.cache.session-cache-size=5
如果更愿意使用原生池，可以通过向org.messaginghub:pooled-jms添加依赖项来实现，并相应地配置JmsPoolConnectionFactory，如下例所示：
spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=50
更多支持的选项请参见ActiveMQProperties。还可以注册实现ActiveMQConnectionFactoryCustomizer的任意数量的bean，以便进行更高级的定制。
1.2 ActiveMQ Artemis 支持
Artemis是下一代的ActiveMQ：下一代高性能，非阻塞架构，基于事件驱动的消息系统。
当Spring Boot检测到ActiveMQ Artemis在类路径上可用时，它可以自动配置ConnectionFactory。如果存在broker，则会自动启动并配置嵌入式broker(除非已显式设置mode属性)。受支持的模式分为嵌入式模式(明确表示需要嵌入式broker，如果broker在类路径上不可用就会发生错误)和原生模式(使用netty传输协议连接到broker)。在配置后一种模式时，Spring Boot会配置一个ConnectionFactory，它使用默认设置broker到运行在本地机器上的broker。
如果使用spring-boot-starter-artemis，将提供连接到现有ActiveMQ Artemis实例所需的依赖项，以及与JMS集成的Spring基础设施。增加org.apache.activemq:artemis-jms-server将允许使用嵌入式模式。
ActiveMQ Artemis配置由spring.artemis.*中的外部配置属性控制。例如，可以在application.properties中声明以下部分：
spring.artemis.mode=native
spring.artemis.broker-url=tcp://192.168.1.210:9876
spring.artemis.user=admin
spring.artemis.password=secret
在嵌入broker时，可以选择是否启用持久性，并列出应该提供的路径。可以将它们指定为逗号分隔的列表，以使用默认选项创建它们，或者可以定义类型为org.apache.activemq.artemis.jms.server.config.JMSQueueConfiguration或org.apache.activemq.artemis.jms.server.config.TopicConfiguration，分别用于高级队列和主题配置。
默认情况下，CachingConnectionFactory用合理的设置包装了本地的ConnectionFactory，可以通过spring.jms中的外部配置属性来控制这些设置。
spring.jms.cache.session-cache-size=5
如果更愿意使用原生池，可以通过向org.messaginghub:pooled-jms添加依赖项来实现，并相应地配置JmsPoolConnectionFactory，如下例所示：
spring.artemis.pool.enabled=true
spring.artemis.pool.max-connections=50
1.3 使用JNDI ConnectionFactory
应用服务器上运行应用程序时，Spring Boot会尝试使用JNDI来定位JMS ConnectionFactory。缺省情况下，检查java:/JmsXA和java:/XAConnectionFactory位置。可以使用spring.jms.jndi-name指定一个位置，示例如下：
spring.jms.jndi-name=java:/MyConnectionFactory
1.4 发送消息
Spring的JmsTemplate是自动配置的，可以自动将它直接连接到自己的bean中，如下面的例子所示：
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");
}
}
JmsMessagingTemplate可以以类似的方式注入。如果定义了DestinationResolver或MessageConverter bean，它会自动关联到自动配置的JmsTemplate。
1.5 接收消息
使用JMS时，可以用@JmsListener对任何bean进行注释，以创建侦听器端点。如果没有定义JmsListenerContainerFactory，则会自动配置一个默认的JmsListenerContainerFactory。如果定义了DestinationResolver、MessageConverter或javax.jms.ExceptionListener bean，它们就会自动与默认工厂关联起来。
默认情况下，默认工厂是事务性的。如果在存在JtaTransactionManager的基础设施中运行，默认情况下，它与侦听器容器相关联。如果没有，则启用sessionTransacted标志。在后一种场景中，可以通过在侦听器方法(或其委托)上添加@Transactional，将本地数据存储事务与传入消息的处理关联起来。这确保在本地事务完成后确认传入的消息。这还包括发送在同一JMS会话上执行的响应消息。
下面的Component是在someQueue目标上创建了一个监听器端点：
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
@JmsListener(destination = "someQueue")
public void processMessage(String content) {
// ...
}
}
如果需要创建多个JmsListenerContainerFactory实例或者想覆盖默认的，Spring Boot提供了一个类：DefaultJmsListenerContainerFactoryConfigurer，它可以用来初始化DefaultJmsListenerContainerFactory，并在使用相同配置下实现自动配置。
例如，下面的例子给出了另一个使用特定MessageConverter的工厂：
import javax.jms.ConnectionFactory;
import org.springframework.boot.autoconfigure.jms.DefaultJmsListenerContainerFactoryConfigurer;
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) {
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
ConnectionFactory connectionFactory = getCustomConnectionFactory();
configurer.configure(factory, connectionFactory);
factory.setMessageConverter(new MyMessageConverter());
return factory;
}
private ConnectionFactory getCustomConnectionFactory() {
return ...
}
}
然后可以在任何@JmsListener注释的方法中使用工厂，如下所示：
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) {
// ...
}
}
2. AMQP
高级消息队列协议(AMQP)是面向消息的中间件的平台中立、连线级协议。Spring AMQP项目将核心Spring概念应用到基于AMQP的消息传递解决方案的开发中。Spring Boot为通过RabbitMQ使用AMQP提供了几个便利条件，包括spring-boot-starter-amqp " Starter "。
2.1 RabbitMQ 支持
RabbitMQ是一个轻量级、可靠、可扩展、可移植的消息代理，基于AMQP协议。Spring通过AMQP协议使用RabbitMQ进行通信。
RabbitMQ的配置由spring.rabbitmq.*中的外部配置属性控制。例如，可以在application.properties中声明以下部分：
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=secret
或者，可以使用addresses属性配置相同的连接：
spring.rabbitmq.addresses=amqp://admin:secret@localhost
当以这种方式指定地址时，主机和端口属性将被忽略。如果该地址使用amqps协议，则自动启用SSL支持。
更多支持的基于属性的配置选项请参见RabbitProperties。要配置Spring AMQP使用的RabbitMQ ConnectionFactory的低层细节，需要定义一个ConnectionFactoryCustomizer bean。
如果在上下文中存在ConnectionNameStrategy bean，它将被自动用于命名由自动配置的CachingConnectionFactory创建的连接。
更好理解 AMQP及 RabbitMQ，可参考Understanding AMQP, the protocol used by RabbitMQ 获取更多细节。
2.2 发送消息
Spring的AmqpTemplate和AmqpAdmin是自动配置的，可以自动将它们直接装配到自己的bean中，如下面的例子所示：
import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
private final AmqpAdmin amqpAdmin;
private final AmqpTemplate amqpTemplate;
public MyBean(AmqpAdmin amqpAdmin, AmqpTemplate amqpTemplate) {
this.amqpAdmin = amqpAdmin;
this.amqpTemplate = amqpTemplate;
}
public void someMethod() {
this.amqpAdmin.getQueueInfo("someQueue");
}
public void someOtherMethod() {
this.amqpTemplate.convertAndSend("hello");
}
}
RabbitMessagingTemplate也可以通过类似的方式注入。如果定义了MessageConverter bean，它就会自动关联到自动配置的AmqpTemplate。
如果需要，任何定义为bean的org.springframework.amqp.core.Queue都会自动在RabbitMQ实例中声明一个相应的queue。
要重试操作，则可以在AmqpTemplate上启用重试(例如，在broker 连接丢失的情况下)：
spring.rabbitmq.template.retry.enabled=true
spring.rabbitmq.template.retry.initial-interval=2s
默认情况下禁用重试。也可以通过声明一个RabbitRetryTemplateCustomizer bean来通过编程方式定制RetryTemplate。
如果需要创建更多的RabbitTemplate实例，或者想要覆盖默认值，Spring Boot提供了一个RabbitTemplateConfigurer bean，可以用它来初始化一个RabbitTemplate，使用与自动配置中使用的工厂相同的设置。
2.3 接收消息
使用Rabbit 时，任何bean都可以用@RabbitListener进行注释，以创建一个侦听器端点。如果没有定义RabbitListenerContainerFactory，会自动配置一个默认的SimpleRabbitListenerContainerFactory，可以使用spring.rabbitmq.listener.type属性切换到一个直接的容器。如果定义了MessageConverter或MessageRecoverer bean，它将自动与默认工厂关联。
下面的示例组件在someQueue队列上创建了一个侦听器端点：
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
@RabbitListener(queues = "someQueue")
public void processMessage(String content) {
// ...
}
}
如果需要创建更多的RabbitListenerContainerFactory实例，或者想重写这个默认值，Spring Boot提供SimpleRabbitListenerContainerFactoryConfigurer和DirectRabbitListenerContainerFactoryConfigurer，可以用它来初始化一个SimpleRabbitListenerContainerFactory和DirectRabbitListenerContainerFactory。
选择哪种容器类型无关紧要。这两个bean由自动配置公开。例如，下面的配置类公开了另一个使用特定MessageConverter的工厂：
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration(proxyBeanMethods = false)
public class MyRabbitConfiguration {
@Bean
public SimpleRabbitListenerContainerFactory myFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer) {
SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
ConnectionFactory connectionFactory = getCustomConnectionFactory();
configurer.configure(factory, connectionFactory);
factory.setMessageConverter(new MyMessageConverter());
return factory;
}
private ConnectionFactory getCustomConnectionFactory() {
return ...
}
}
然后就可以在任何@RabbitListenerr注释的方法中使用工厂，如下所示：
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
@RabbitListener(queues = "someQueue", containerFactory = "myFactory")
public void processMessage(String content) {
// ...
}
}
可以启用retries来处理侦听器抛出异常的情况。默认情况下，使用RejectAndDontRequeueRecoverer，但也可以定义自己的MessageRecoverer。当重试耗尽时，消息被拒绝，并被丢弃或路由到一个死信交换(如果broker被配置为这样做的话)。缺省情况下，不允许重试。也可以通过声明一个RabbitRetryTemplateCustomizer bean来通过编程方式定制RetryTemplate。
默认情况下，如果禁用重试且侦听器抛出异常，则会无限期地重试传递。可以通过两种方式修改此行为:将defaultrequeuereject属性设置为false，以便尝试零次重新传递，或者抛出一个AmqpRejectAndDontRequeueException来表示该消息应该被拒绝。后者是在启用重试并达到传递尝试的最大次数时使用的机制。
3. Apache Kafka支持
Apache Kafka是通过提供spring-kafka项目的自动配置来支持的。
Kafka配置是由spring.kafka.*中的外部配置属性控制的。例如，可以在application.properties中声明以下部分：
spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=myGroup
要在启动时创建主题，请添加一个NewTopic类型的bean。如果主题已经存在，则忽略bean。
想了解更多有关kafka的配置参数，可以参考KafkaProperties。
3.1 发送消息
Spring的KafkaTemplate是自动配置的，可以直接在自己的bean中自动装配它，如下面的例子所示：
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
private final KafkaTemplate<String, String> kafkaTemplate;
public MyBean(KafkaTemplate<String, String> kafkaTemplate) {
this.kafkaTemplate = kafkaTemplate;
}
public void someMethod() {
this.kafkaTemplate.send("someTopic", "Hello");
}
}
如果属性spring.kafka.producer.transaction-id-prefix 一旦被定义，就会自动配置一个KafkaTransactionManager。另外，如果定义了RecordMessageConverter bean，它会自动关联到自动配置的KafkaTemplate。
3.2 接收消息
使用Apache Kafka时，任何bean都可以用@KafkaListener进行注释，以创建一个侦听器端点。如果没有定义过KafkaListenerContainerFactory，默认的一个会被自动配置为在spring.kafka.listener.*中定义的键。
下面的组件在someTopic topic上创建了一个监听器端点：
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
@KafkaListener(topics = "someTopic")
public void processMessage(String content) {
// ...
}
}
如果定义了一个KafkaTransactionManager bean，它会自动关联到容器工厂。类似地，如果定义了RecordFilterStrategy、ErrorHandler、CommonErrorHandler、AfterRollbackProcessor或consumeraware balancelistener bean，它会自动关联到默认工厂。
根据侦听器类型的不同，RecordMessageConverter或BatchMessageConverter bean与默认工厂相关联。如果批处理侦听器只有一个RecordMessageConverter bean，那么它将被包装在BatchMessageConverter中。
一个自定义的ChainedKafkaTransactionManager必须被标记为@Primary，因为它通常引用自动配置的KafkaTransactionManager bean。
3.3 Kafka流
Spring for Apache Kafka提供了一个工厂bean来创建一个StreamsBuilder对象，并管理其流的生命周期。Spring Boot会自动配置所需的KafkaStreamsConfiguration bean，只要Kafka - Streams在类路径上，并且KafkaStreams被@EnableKafkaStreams注释启用。
启用Kafka Streams意味着必须设置应用程序id和引导服务器。前者可以使用spring.kafka.streams配置。应用id，如果没有设置，默认为spring.application.name。后者可以全局设置或专门为流重写。
使用专用属性可以获得几个额外的属性;其他任意的Kafka属性可以使用spring.kafka.streams.properties命名空间来设置。
要使用工厂bean，需将StreamsBuilder连接到@Bean中，如下所示：
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KeyValue;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.Produced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafkaStreams;
import org.springframework.kafka.support.serializer.JsonSerde;
@Configuration(proxyBeanMethods = false)
@EnableKafkaStreams
public class MyKafkaStreamsConfiguration {
@Bean
public KStream<Integer, String> kStream(StreamsBuilder streamsBuilder) {
KStream<Integer, String> stream = streamsBuilder.stream("ks1In");
stream.map(this::uppercaseValue).to("ks1Out", Produced.with(Serdes.Integer(), new JsonSerde<>()));
return stream;
}
private KeyValue<Integer, String> uppercaseValue(Integer key, String value) {
return new KeyValue<>(key, value.toUpperCase());
}
}
默认情况下，由它创建的StreamBuilder对象管理的流将自动启动。可以使用spring.kafka.streams.auto-startup设置这个行为。
3.4 使用嵌入式Kafka进行测试
Spring for Apache Kafka提供了一种便捷的使用嵌入式Apache Kafka broker测试项目的方式。要使用这个特性，需在spring-kafka-test模块中使用@EmbeddedKafka注释一个测试类。
为了让Spring Boot自动配置在前面提到的嵌入式Apache Kafka broker中工作，需要为嵌入式broker地址(由EmbeddedKafkaBroker填充)重新映射一个系统属性到Apache Kafka的Spring Boot配置属性中。有几种方法可以做到：
- 提供一个系统属性来映射嵌入的broker地址到测试类中的spring.kafka.bootstrap-servers
static {
System.setProperty(EmbeddedKafkaBroker.BROKER_LIST_PROPERTY, "spring.kafka.bootstrap-servers");
}
- 在@EmbeddedKafka注释上配置一个属性名
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.kafka.test.context.EmbeddedKafka;
@SpringBootTest
@EmbeddedKafka(topics = "someTopic", bootstrapServersProperty = "spring.kafka.bootstrap-servers")
class MyTest {
// ...
}
- 在配置属性中使用占位符
spring.kafka.bootstrap-servers=${spring.embedded.kafka.brokers}