• Spring In Action 5 学习笔记 chapter8 JMS(ActiveMQ Artemis)要点

     本文记录Sping In Action5 第8章 发送异步消息JMS(ActiveMQ Artemis)中的踩坑情况。

    第8章的源码请自行github或gitee搜索，或参考一下。

    GitHub - habuma/spring-in-action-5-samples: Home for example code from Spring in Action 5.

    https://gitee.com/drop1et/spring-in-action-5-samples/

    操作系统及IDE环境

    win7 x64

    jdk 1.8

    idea 2018.3

    JMS(ActiveMQ Artemis)

    环境

    ActiveMQ Artemis版本号：apache-artemis-2.19.1

    下载、安装、启动步骤请网搜。可参考https://www.jianshu.com/p/b2734268aaaf

    官网https://activemq.apache.org/components/artemis/

    注意使用cmd窗口将artemis启动后，不要关闭cmd窗口，以便保留artemis。

    注意，因jms使用的并非MQTT协议，因此使用可视化图形界面时将看不到springboot JMS发送和接收的消息，可通过IDEA控制台中springboot程序的输出日志查看代码自定义日志的发送接收消息。

    消息发送

    依赖

    1.         <dependency>
    2.             <groupId>org.springframework.boot</groupId>
    3.             <artifactId>spring-boot-starter-artemis</artifactId>
    4.         </dependency>

    application.properties关键部分

    1. #ActiveMQ Artemis 配置
    2. #ActiveMQ Artemis broker主机
    3. spring.artemis.host=localhost
    4. #ActiveMQ Artemis broker端口
    5. spring.artemis.port=61616
    6. #ActiveMQ Artemis broker 访问用户名
    7. spring.artemis.user=admin
    8. #ActiveMQ Artemis broker 访问密码
    9. spring.artemis.password=admin
    10. #指定jms发送消息的目的地（主体）
    11. spring.jms.template.default-destination=wdhqueue

    关键代码JmsOrderMessagingService

    1. package com.wdh.tacocloud_jms.messaging;
    2.  
    3. import com.wdh.tacocloud_jms.domain.Order;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.jms.core.JmsTemplate;
    7. import org.springframework.jms.core.MessageCreator;
    8. import org.springframework.stereotype.Service;
    9.  
    10. import javax.jms.JMSException;
    11. import javax.jms.Message;
    12. import javax.jms.Session;
    13.  
    14. /**
    15.  * @author WangDH
    16.  * @create 2022-09-27 14:32
    17.  */
    18. @Slf4j
    19. @Service
    20. public class JmsOrderMessagingService implements OrderMessagingService {
    21.  
    22.     private JmsTemplate jmsTemplate;
    23.  
    24.     @Autowired
    25.     public JmsOrderMessagingService(JmsTemplate jmsTemplate) {
    26.         this.jmsTemplate = jmsTemplate;
    27.     }
    28.  
    29.  
    30.     @Override
    31.     public void sendOrder(Order order) {
    32.         log.info("JmsOrderMessagingService start sendOrder start.");
    33.  
    34.         //方式一
    35. //        jmsTemplate.send(
    36. //                new MessageCreator() {
    37. //                    @Override
    38. //                    public Message createMessage(Session session) throws JMSException {
    39. //                        //return session.createObjectMessage("Hello from wdhSpringBoot");
    40. //                        return session.createObjectMessage(order);
    41. //                    }
    42. //                }
    43. //        );
    44.  
    45. //        //方式2
    46. //        jmsTemplate.send("wdhqueue",
    47. //                new MessageCreator() {
    48. //                    @Override
    49. //                    public Message createMessage(Session session) throws JMSException {
    50. //                        //return session.createObjectMessage("Hello from wdhSpringBoot");
    51. //                        return session.createObjectMessage(order);
    52. //                    }
    53. //                }
    54. //        );
    55.  
    56.  
    57.  
    58. //        //方式3
    59. //        jmsTemplate.convertAndSend("wdhqueue",order);
    60.  
    61.  
    62.         //方式3
    63.         jmsTemplate.convertAndSend("wdhqueue",order,this::addOrderSource);
    64.  
    65.         log.info("JmsOrderMessagingService start sendOrder end.");
    66.     }
    67.  
    68.     private Message addOrderSource(Message message) throws JMSException{
    69.         message.setStringProperty("X_ORDER_SOURCE","WEB");
    70.         return message;
    71.     }
    72. }

    RestController部分代码

    1. package com.wdh.tacocloud_jms.api;
    2.  
    3. import com.wdh.tacocloud_jms.data.OrderRepository;
    4. import com.wdh.tacocloud_jms.domain.Order;
    5. import com.wdh.tacocloud_jms.messaging.OrderMessagingService;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.springframework.dao.EmptyResultDataAccessException;
    8. import org.springframework.http.HttpStatus;
    9. import org.springframework.web.bind.annotation.*;
    10.  
    11. import java.text.SimpleDateFormat;
    12. import java.util.Date;
    13. import java.util.Optional;
    14.  
    15. /**
    16.  * @author WangDH
    17.  * @create 2022-09-23 9:55
    18.  */
    19. @Slf4j
    20. @RestController
    21. @RequestMapping(path="/orders",produces = "application/json")
    22. @CrossOrigin(origins = "*")
    23. public class OrderApiController {
    24.  
    25.     private OrderRepository orderRepo;
    26.     private OrderMessagingService orderMessagingService;
    27.  
    28.  
    29.     public OrderApiController(OrderRepository orderRepo
    30.                               ,OrderMessagingService orderMessagingService
    31.     ) {
    32.         this.orderMessagingService=orderMessagingService;
    33.         this.orderRepo = orderRepo;
    34.     }
    35.  
    36.     @GetMapping("/")
    37.     public String getDefault(){
    38.  
    39.         log.info("######### OrderApiController enter getDefault");
    40.  
    41.  
    42.         return "ok,this is OrderApiController getDefault return";
    43.     }
    44.  
    45.     @GetMapping("/sendJMS")
    46.     public String sendJMS(){
    47.  
    48.         log.info("######### OrderApiController enter sendJMS");
    49.  
    50.         Date date=new Date();
    51.         SimpleDateFormat formatter=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    52.         String time=formatter.format(date);
    53.  
    54.  
    55.         Order order=new Order();
    56.         order.setId((long) 81);
    57.         order.setDeliveryName("jmsTestName"+time);
    58.         orderMessagingService.sendOrder(order);
    59.  
    60.         return "ok,this is OrderApiController sendJMS return。time="+time;
    61.     }
    62.  
    63.  
    64. }

    消息接收

    要点1：【推模型】OrderListener和【拉模型】JmsOrderReceiver互斥，二者代码只能选择一个

    要点2：如果同时使用【推模型】OrderListener和【拉模型】JmsOrderReceiver，则【推模型】OrderListener会优先截取队列的消息，导致【拉模型】JmsOrderReceiver接收到的数据为空。

    要点3：【拉模型】类JmsOrderReceiver的receiveOrder()方法中的jmsTemplate.receiveAndConvert()会阻塞直到发送端有数据发送。

    消息接收端程序采用SpringMVC+Thymeleaf

    依赖

    1.         <dependency>
    2.             <groupId>org.springframework.boot</groupId>
    3.             <artifactId>spring-boot-starter-artemis</artifactId>
    4.         </dependency>

    application.propertites中关键部分

    1. #ActiveMQ Artemis 配置
    2. #ActiveMQ Artemis broker主机
    3. spring.artemis.host=localhost
    4. #ActiveMQ Artemis broker端口
    5. spring.artemis.port=61616
    6. #ActiveMQ Artemis broker 访问用户名
    7. spring.artemis.user=admin
    8. #ActiveMQ Artemis broker 访问密码
    9. spring.artemis.password=admin
    10. #指定jms发送消息的目的地（主体）
    11. spring.jms.template.default-destination=wdhqueue

    消息接收代码-拉模型

    1. package com.wdh.tacocloud_kitchen.kitchen.messaging.jms;
    2.  
    3. import com.wdh.tacocloud_kitchen.OrderReceiver;
    4. import com.wdh.tacocloud_kitchen.domain.Order;
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.jms.core.JmsTemplate;
    8. import org.springframework.jms.support.converter.MessageConverter;
    9. import org.springframework.stereotype.Component;
    10. import javax.jms.JMSException;
    11. import javax.jms.Message;
    12. import java.util.Date;
    13.  
    14. /**
    15.  * @author WangDH
    16.  * @create 2022-09-27 17:21
    17.  * 注意，这种方式是[拉模型]
    18.  */
    20.  
    21. @Slf4j
    22. @Component
    23. public class JmsOrderReceiver implements OrderReceiver {
    24.  
    25. //    //方式1
    26.     private JmsTemplate jmsTemplate;
    27.     private MessageConverter messageConverter;
    28.  
    29.     @Autowired
    30.     public JmsOrderReceiver(JmsTemplate jmsTemplate, MessageConverter messageConverter) {
    31.         this.jmsTemplate = jmsTemplate;
    32.         this.messageConverter = messageConverter;
    33.     }
    34.  
    35.     @Override
    36.     public Order receiveOrder() throws JMSException {
    37.  
    38.         Message message= jmsTemplate.receive("wdhqueue");
    39.         Order order=(Order)messageConverter.fromMessage(message);
    40.  
    41.         return order;
    42.     }
    43.  
    44.  
    45.     //方式2
    46.     private JmsTemplate jmsTemplate;
    47.  
    48.     @Autowired
    49.     public JmsOrderReceiver(JmsTemplate jmsTemplate) {
    50.         this.jmsTemplate = jmsTemplate;
    51.     }
    52.  
    53.     @Override
    54.     public Order receiveOrder() {
    55.  
    56.         jmsTemplate.setReceiveTimeout(10000);//设置10000ms的等待时间，防止receiveAndConvert阻塞
    57.  
    58.         log.info("JmsOrderReceiver receiveOrder，准备接收队列消息，请在队列发送端发送消息。 receiveAndConvert start at "+(new Date()).toString());
    59.  
    60.         Order order=(Order)jmsTemplate.receiveAndConvert("wdhqueue");
    61.  
    62.         log.info("JmsOrderReceiver receiveOrder receiveAndConvert end at "+(new Date()).toString());
    63.         return order;
    64.     }
    65. }

    消息接收代码-推模型

    1. package com.wdh.tacocloud_kitchen.kitchen.messaging.jms.listener;
    2.  
    3. import com.wdh.tacocloud_kitchen.KitchenUI;
    4. import com.wdh.tacocloud_kitchen.domain.Order;
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.jms.annotation.JmsListener;
    8. import org.springframework.stereotype.Component;
    9.  
    10. /**
    11.  * @author WangDH
    12.  * @create 2022-09-27 17:33
    13.  *
    14.  * 建立监听器以配合消息队列实现【推模型】
    15.  *
    16.  * 注意，这个与JmsOrderReceiver的拉模型互斥，二者代码只能选择一个
    17.  * 如果同时使用【推模型】OrderListener和【拉模型】JmsOrderReceiver，
    18.  * 则【推模型】OrderListener会优先截取队列的消息，导致【拉模型】JmsOrderReceiver接收到的数据为空
    19.  */
    20. @Slf4j
    21. @Component
    22. public class OrderListener {
    23.  
    24.     private KitchenUI kitchenUI;
    25.  
    26.     @Autowired
    27.     public OrderListener(KitchenUI kitchenUI) {
    28.         this.kitchenUI = kitchenUI;
    29.     }
    30.  
    31.     @JmsListener(destination = "wdhqueue")
    32.     public void receiveOrder(Order order){
    33.  
    34.         kitchenUI.displayOrder(order);
    35.  
    36.     }
    37.  
    38. }

    测试消息发送与接收

    1.保证ActiveMQ artemis正在运行中

    2.启动发送端springboot程序TacocloudJmsApplication（端口8080）

    3.启动接收端springboot程序TacocloudKitchenApplication(端口8081)

    4.打开浏览器输入【http://localhost:8090/orders/sendJMS】以调用发送端程序的rest服务，回车后因spring security要求先输入用户名user,再根据idea中提示的密码复制过来再回车，登录后,网页提示消息已发送。

    5.接收端【拉模式】，在发送端已发送消息后， 打开浏览器输入【http://localhost:8081/orders/receive】回车会跳转到receiveOrder.html显示相应信息。（如果再次发送消息，则需要手动刷新浏览器以再次拉取消息）

    6.接收端【推模式】，在发送端已发送消息后，在IDEA的控制台中即可看到TacocloudKitchenApplication程序输出的日志显示OrderListener已收到消息。

  • 相关阅读:
    【JVM虚拟机】JVM常见面试题总结
    java存储数据到本地txt文件中-以及-读取txt文件的内容
    Kafka系列之：Kafka Connect错误报告设置
    如何打开pak文件-翻译pak语言包
    机器人制作开源方案 | 晾衣收纳一体机器人
    net-java-php-python-大学生互助旅游网站修改计算机毕业设计程序
    openlayer注册4490坐标系，添加4490超图服务
    mysql查看sql日志操作
    使用DIV、CSS技术设计的个人博客网页（web期末考试）
    Docker：从入门到实战过程全记录
  • 原文地址：https://blog.csdn.net/wangdonghao137/article/details/127122333