原文： https://howtodoinjava.com/spring-boot/spring-boot-jmstemplate-activemq/

了解如何使用嵌入式 ActiveMQ 配置 Spring Boot 应用程序，以便借助 JMSTemplate 发送和接收 JMS 消息。

项目结构

请在 Eclipse 中创建一个 Maven 应用程序，然后在给定的文件夹结构下创建。

带有嵌入式 ActiveMQ 的 Spring Boot `JMSTemplate` - 图1

Spring Boot JMSTemplate – 项目结构

要运行该示例，您将需要在运行时中使用 Java 1.8.

Maven 配置

使用 Spring Boot 和 ActiveMQ 依赖项更新pom.xml文件。 此外，对于对象到 JSON 转换，我们需要 Jackson。

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd;
  3.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.howtodoinjava.demo</groupId>
  6.     <artifactId>SpringJMSTemplate</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <packaging>jar</packaging>
  10.     <name>SpringJMSTemplate</name>
  11.     <url>http://maven.apache.org</url>
  13.     <parent>
  14.         <groupId>org.springframework.boot</groupId>
  15.         <artifactId>spring-boot-starter-parent</artifactId>
  16.         <version>1.5.2.RELEASE</version>
  17.     </parent>
  19.     <properties>
  20.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  21.         <java.version>1.8</java.version>
  22.     </properties>
  24.     <dependencies>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-activemq</artifactId>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.apache.activemq</groupId>
  31.             <artifactId>activemq-broker</artifactId>
  32.         </dependency>
  34.         <dependency>
  35.             <groupId>com.fasterxml.jackson.core</groupId>
  36.             <artifactId>jackson-databind</artifactId>
  37.         </dependency>
  38.     </dependencies>
  39. </project>

@EnableJms和JmsListenerContainerFactory配置

通过使用@SpringBootApplication注解对其进行注解来创建 Spring Boot 应用程序类。 将此代码添加到类中。

  1. package com.howtodoinjava.demo;
  3. import javax.jms.ConnectionFactory;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.boot.autoconfigure.jms.DefaultJmsListenerContainerFactoryConfigurer;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.jms.annotation.EnableJms;
  9. import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
  10. import org.springframework.jms.config.JmsListenerContainerFactory;
  11. import org.springframework.jms.support.converter.MappingJackson2MessageConverter;
  12. import org.springframework.jms.support.converter.MessageConverter;
  13. import org.springframework.jms.support.converter.MessageType;
  15. @SpringBootApplication
  16. @EnableJms
  17. public class JMSApplication 
  18. {
  19.     @Bean
  20.     public JmsListenerContainerFactory<?> myFactory(
  21.                             ConnectionFactory connectionFactory,
  22.                             DefaultJmsListenerContainerFactoryConfigurer configurer) 
  23.     {
  24.         DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
  25.         // This provides all boot's default to this factory, including the message converter
  26.         configurer.configure(factory, connectionFactory);
  27.         // You could still override some of Boot's default if necessary.
  28.         return factory;
  29.     }
  31.     @Bean
  32.     public MessageConverter jacksonJmsMessageConverter() 
  33.     {
  34.         MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
  35.         converter.setTargetType(MessageType.TEXT);
  36.         converter.setTypeIdPropertyName("_type");
  37.         return converter;
  38.     }
  39. }
  • @SpringBootApplication注解等效于使用@Configuration，@EnableAutoConfiguration和@ComponentScan及其默认属性。 这是使用注解配置轻松配置 spring 应用程序的快捷方式。
  • @EnableJms启用由JmsListenerContainerFactory在封面下创建的@JmsListener带注解的端点。
  • JmsListenerContainerFactory负责创建负责特定端点的监听器容器。 作为DefaultJmsListenerContainerFactory的典型实现提供了基础MessageListenerContainer支持的必要配置选项。
  • MappingJackson2MessageConverter用于将Message的有效载荷从序列化形式转换为类型化对象，反之亦然。
  • 我们已经配置了MessageType.TEXT。 此消息类型可用于传输基于文本的消息。 客户端收到TextMessage时，处于只读模式。 如果客户端此时尝试写入消息，则会抛出MessageNotWriteableException。

使用@JmsListener的 JMS 消息接收器

消息接收器类是带有注解@JmsListener的单一方法的非常简单的类。 @JmsListener允许您将托管 Bean 的方法公开为 JMS 监听器端点。

因此，只要在配置的队列上有任何消息可用（在此示例中，队列名称为jms.message.endpoint），就会调用带注解的方法（即receiveMessage）。

@JmsListener是一个可重复的注释，因此您可以在同一方法上多次使用它，以将多个 JMS 目标注册到同一方法。

  1. package com.howtodoinjava.demo;
  3. import org.springframework.jms.annotation.JmsListener;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. public class MessageReceiver {
  9.     @JmsListener(destination = "jms.message.endpoint")
  10.     public void receiveMessage(Message msg) 
  11.     {
  12.         System.out.println("Received " + msg );
  13.     }
  14. }

Message类是简单的 POJO 类。

  1. package com.howtodoinjava.demo;
  3. import java.io.Serializable;
  4. import java.util.Date;
  6. public class Message implements Serializable {
  8.     private static final long serialVersionUID = 1L;
  10.     private Long id;
  11.     private String content;
  12.     private Date date;
  14.     public Message() {
  15.     }
  17.     public Message(Long id, String content, Date date) {
  18.         super();
  19.         this.id = id;
  20.         this.content = content;
  21.         this.date = date;
  22.     }
  24.     public Long getId() {
  25.         return id;
  26.     }
  28.     public void setId(Long id) {
  29.         this.id = id;
  30.     }
  32.     public String getContent() {
  33.         return content;
  34.     }
  36.     public void setContent(String content) {
  37.         this.content = content;
  38.     }
  40.     public Date getDate() {
  41.         return date;
  42.     }
  44.     public void setDate(Date date) {
  45.         this.date = date;
  46.     }
  48.     @Override
  49.     public String toString() {
  50.         return "Message [id=" + id + ", content=" + content + ", date=" + date + "]";
  51.     }
  52. }

使用JmsTemplate发送消息

要发送 JMS 消息，您将需要来自 spring 容器的 bean 类JmsTemplate的引用。 调用它的convertAndSend()方法发送消息。

  1. package com.howtodoinjava.demo;
  3. import java.util.Date;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.context.ConfigurableApplicationContext;
  7. import org.springframework.jms.core.JmsTemplate;
  9. public class Main 
  10. {
  11.     public static void main(String[] args) 
  12.     {
  13.         // Launch the application
  14.         ConfigurableApplicationContext context = SpringApplication.run(JMSApplication.class, args);
  16.         //Get JMS template bean reference
  17.         JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
  19.         // Send a message
  20.         System.out.println("Sending a message.");
  21.         jmsTemplate.convertAndSend("jms.message.endpoint", new Message(1001L, "test body", new Date()));
  22.     }
  23. }

示例

执行上述Main类的main()方法。 这将启动 Spring Boot 应用程序，然后将消息发送到队列jms.message.endpoint。

MessageReceiver.receiveMessage()已经在监听此队列地址。 因此此方法将接收到消息，可以通过将消息打印到控制台进行验证。

在控制台中，输出将如下所示：

  1. Sending a message.
  2. Received Message [id=1001, content=test body, date=Fri Jul 07 14:19:19 IST 2017]

显然，邮件已成功发送和接收。 这就是使用嵌入式 ActiveMQ 的 Spring JMSTemplate的快速示例。

将我的问题放在评论部分。

学习愉快！