Spring Cloud ActiveMQ整合实现点对点队列

最新推荐文章于 2024-09-06 17:22:07 发布

只吃两个荞麦馒头

最新推荐文章于 2024-09-06 17:22:07 发布

阅读量1.1k

点赞数

本文链接：https://blog.csdn.net/sgdjfkbx/article/details/90240717

版权

spring cloud 同时被 3 个专栏收录

11 篇文章 0 订阅

订阅专栏

java

9 篇文章 0 订阅

订阅专栏

ActiveMQ

1 篇文章 0 订阅

订阅专栏

1、业务场景说明:

消息队列在大型电子商务类网站，如京东、淘宝、去哪儿等网站有着深入的应用，
它的主要作用是消除高并发访问高峰，加快网站的响应速度。
在不使用消息队列的情况下，用户的请求数据直接写入数据库，在高并发的情况下，会对数据库造成巨大的压力，同时也使得系统响应延迟加剧。
在使用队列后，用户的请求发给队列后立即返回,
（例如: 当然不能直接给用户提示订单提交成功，京东上提示：您“您提交了订单，请等待系统确认”），
再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库。
由于消息队列的服务处理速度远快于数据库，因此用户的响应延迟可得到有效改善。

2. 消息队列应用场景

消息队列在实际应用中常用的使用场景。异步处理，应用解耦，流量削锋和消息通讯四个场景。
场景说明：用户注册后，需要发注册邮件和注册短信。传统的做法有两种1.串行的方式；2.并行方式。

（1）串行方式：将注册信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端。
在这里插入图片描述

（2）并行方式：将注册信息写入数据库成功后，发送注册邮件的同时，发送注册短信。以上三个任务完成后，返回给客户端。与串行的差别是，并行的方式可以提高处理的时间。
在这里插入图片描述

假设三个业务节点每个使用50毫秒钟，不考虑网络等其他开销，则串行方式的时间是150毫秒，并行的时间可能是100毫秒。

因为CPU在单位时间内处理的请求数是一定的，假设CPU1秒内吞吐量是100次。

则串行方式1秒内CPU可处理的请求量是7次（1000/150）。并行方式处理的请求量是10次（1000/100）。

小结：如以上案例描述，传统的方式系统的性能（并发量，吞吐量，响应时间）会有瓶颈。如何解决这个问题呢？

引入消息队列，将不是必须的业务逻辑，异步处理。改造后的架构如下：
在这里插入图片描述

按照以上约定，用户的响应时间相当于是注册信息写入数据库的时间，也就是50毫秒。

注册邮件，发送短信写入消息队列后，直接返回，因此写入消息队列的速度很快，基本可以忽略，

因此用户的响应时间可能是50毫秒。所以基于此架构改变后，系统的吞吐量提高到每秒20 QPS。比串行提高了3倍，比并行提高了两倍。

可参考此文章：https://blog.csdn.net/qinweili751/article/details/80620104，写的很详细。

3、现在我们来具体搭建实现过程：

项目结构：

在这里插入图片描述

pom.xml文件添加依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-activemq</artifactId>
   <!--<version>1.5.6.RELEASE</version>-->
</dependency>

application.properties文件配置如下：

server.port=8888
spring.activemq.broker-url=tcp://127.0.0.1:61616
# 在考虑结束之前等待的时间
#spring.activemq.close-timeout=15s
# 默认代理URL是否应该在内存中。如果指定了显式代理，则忽略此值。
spring.activemq.in-memory=true 
# 是否在回滚回滚消息之前停止消息传递。这意味着当启用此命令时，消息顺序不会被保留。
spring.activemq.non-blocking-redelivery=false
# 用户密码
spring.activemq.user=activemq
spring.activemq.password=activemq
# 等待消息发送响应的时间。设置为0等待永远。
spring.activemq.send-timeout=0
#默认情况下activemq提供的是queue模式，若要使用topic模式需要配置spring.jms.pub-sub-domain为true
spring.activemq.pool.enabled=false

消息生产者：

package com.sinosoft.activemq.producer;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Component;

import javax.jms.Destination;

@Component
public class ActiveMQProducer {
    @Autowired
    private JmsTemplate jmsTemplate;

    public void sendMessage(Destination destination,String message){
        this.jmsTemplate.convertAndSend(destination,message);
    }

}

消息消费者：

package com.sinosoft.activemq.consumer;

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

@Component
public class ActiveMQConsumer {
    // 使用JmsListener配置消费者监听的队列，其中text是接收到的消息
    @JmsListener(destination = "mytest.queue")
    public void receiveQueue(String text) {
        System.out.println("ActiveMQConsumer收到的报文为:"+text);
    }
}

controller里写上测试接口：

package com.sinosoft.activemq.controller;

import com.sinosoft.activemq.consumer.ActiveMQConsumer;
import com.sinosoft.activemq.producer.ActiveMQProducer;
import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.jms.Destination;

@RestController
public class ActiveMQControl {
    @Autowired
    private ActiveMQProducer producer;

    private ActiveMQConsumer consumer;

    @RequestMapping("/sendMessage")
    public String sendMessage(@RequestParam String name){
        Destination destination = new ActiveMQQueue("mytest.queue");
        this.producer.sendMessage(destination,name);
        System.out.println("成功写入队列");
        return "成功写入队列...";
    }
    
}

启始类：

package com.sinosoft.activemq;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ActivemqApplication {

   public static void main(String[] args) {
      SpringApplication.run(ActivemqApplication.class, args);
   }

}

最后启动程序。

在页面输入：http://localhost:8888/sendMessage?name=Bob

控制台输出如下内容即为成功：
在这里插入图片描述

也可参考：https://www.cnblogs.com/shamo89/p/8010660.html

最后贴出ActiveMQ application.properties完整得配置：

spring.activemq.broker-url=tcp://127.0.0.1:61616
# 在考虑结束之前等待的时间
#spring.activemq.close-timeout=15s
# 默认代理URL是否应该在内存中。如果指定了显式代理，则忽略此值。
spring.activemq.in-memory=true 
# 是否在回滚回滚消息之前停止消息传递。这意味着当启用此命令时，消息顺序不会被保留。
spring.activemq.non-blocking-redelivery=false
# 用户密码
spring.activemq.user=activemq
spring.activemq.password=activemq
# 等待消息发送响应的时间。设置为0等待永远。
spring.activemq.send-timeout=0
#默认情况下activemq提供的是queue模式，若要使用topic模式需要配置spring.jms.pub-sub-domain为true
spring.activemq.pool.enabled=false

# 是否信任所有包
#spring.activemq.packages.trust-all=
# 要信任的特定包的逗号分隔列表（当不信任所有包时）
#spring.activemq.packages.trusted=
# 当连接请求和池满时是否阻塞。设置false会抛“JMSException异常”。
#spring.activemq.pool.block-if-full=true
# 如果池仍然满，则在抛出异常前阻塞时间。
#spring.activemq.pool.block-if-full-timeout=-1ms
# 是否在启动时创建连接。可以在启动时用于加热池。
#spring.activemq.pool.create-connection-on-startup=true
# 是否用Pooledconnectionfactory代替普通的ConnectionFactory。
#spring.activemq.pool.enabled=false
# 连接过期超时。
#spring.activemq.pool.expiry-timeout=0ms
# 连接空闲超时
#spring.activemq.pool.idle-timeout=30s
# 连接池最大连接数
#spring.activemq.pool.max-connections=1
# 每个连接的有效会话的最大数目。
#spring.activemq.pool.maximum-active-session-per-connection=500
# 当有"JMSException"时尝试重新连接
#spring.activemq.pool.reconnect-on-exception=true
# 在空闲连接清除线程之间运行的时间。当为负数时，没有空闲连接驱逐线程运行。
#spring.activemq.pool.time-between-expiration-check=-1ms
# 是否只使用一个MessageProducer
#spring.activemq.pool.use-anonymous-producers=true