Spring Boot整合一之Spring Boot整合RabbitMQ

本是古典何须时尚 2022-04-17 20:55 201阅读 0赞

## 1.首先我们简单了解一下消息中间件的应用场景 ##

异步处理  
场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种1.串行的方式;2.并行的方式   
(1)串行方式:将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西.

![20181107144440655.png][]

(2)并行方式:将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70][]

假设三个业务节点分别使用50ms,串行方式使用时间150ms,并行使用时间100ms。虽然并性已经提高的处理时间,但是,前面说过,邮件和短信对我正常的使用网站没有任何影响，客户端没有必要等着其发送完成才显示注册成功,英爱是写入数据库后就返回.   
(3)消息队列   
引入消息队列后，把发送邮件,短信不是必须的业务逻辑异步处理   
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70 1][]

由此可以看出,引入消息队列后，用户的响应时间就等于写入数据库的时间+写入消息队列的时间(可以忽略不计),引入消息队列后处理后,响应时间是串行的3倍,是并行的2倍。

应用解耦

场景：双11是购物狂节,用户下单后,订单系统需要通知库存系统,传统的做法就是订单系统调用库存系统的接口.

![20181107144625870.png][]

这种做法有一个缺点:

*  当库存系统出现故障时,订单就会失败。
 *  订单系统和库存系统高耦合.   
    引入消息队列

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70 2][]

订单系统:用户下单后,订单系统完成持久化处理,将消息写入消息队列,返回用户订单下单成功。

库存系统:订阅下单的消息,获取下单消息,进行库操作。   
就算库存系统出现故障,消息队列也能保证消息的可靠投递,不会导致消息丢失。  
流量削峰  
流量削峰一般在秒杀活动中应用广泛   
场景:秒杀活动，一般会因为流量过大，导致应用挂掉,为了解决这个问题，一般在应用前端加入消息队列。   
作用:   
1.可以控制活动人数，超过此一定阀值的订单直接丢弃(我为什么秒杀一次都没有成功过呢^^)   
2.可以缓解短时间的高流量压垮应用(应用程序按自己的最大处理能力获取订单)   
![2018110714473836.png][]

1.用户的请求,服务器收到之后,首先写入消息队列,加入消息队列长度超过最大值,则直接抛弃用户请求或跳转到错误页面.

2.秒杀业务根据消息队列中的请求信息，再做后续处理.

以上内容的来源是：https://blog.csdn.net/whoamiyang/article/details/54954780，在此感谢

## 2.各种消息中间件性能的比较： ##

**TPS比较** 一ZeroMq 最好，RabbitMq 次之， ActiveMq 最差。

**持久化消息比较**—zeroMq不支持，activeMq和rabbitMq都支持。持久化消息主要是指：MQ down或者MQ所在的服务器down了，消息不会丢失的机制。

**可靠性、灵活的路由、集群、事务、高可用的队列、消息排序、问题追踪、可视化管理工具、插件系统、社区**—RabbitMq最好，ActiveMq次之，ZeroMq最差。

**高并发**—从实现语言来看，RabbitMQ最高，原因是它的实现语言是天生具备高并发高可用的erlang语言。

综上所述：RabbitMQ的性能相对来说更好更全面，是消息中间件的首选。

## 3.接下来我们在springboot当中整合使用RabbitMQ ##

**需要提前安装RabbitMQ 可参考：[https://blog.csdn.net/Keith003/article/details/82386210][https_blog.csdn.net_Keith003_article_details_82386210]**

第一步：导入maven依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>

第二步：在application.yml文件中进行RabbitMQ的相关配置

spring:
      rabbitmq:
        host: 127.0.0.1
        port: 5672
        username: guest    # guest 3.0以后默认只能本地登陆
        password: guest
        publisher-confirms: true  #  消息发送到交换机确认机制,是否确认回调
        publisher-returns: true
        virtual-host: /
        connection-timeout: 6000
    server:
      port: 8080

注：使用场景：

*  如果消息没有到exchange,则confirm回调,ack=false
 *  如果消息到达exchange,则confirm回调,ack=true
 *  exchange到queue成功,则不回调return
 *  exchange到queue失败,则回调return(需设置mandatory=true,否则不回回调,消息就丢了)

第三步：进行相关配置

ExchangeConfig    ***消息交换机配置***

package com.space.rabbitmq.config;
     
    import org.springframework.amqp.core.DirectExchange;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
     
    /**
     * 消息交换机配置  可以配置多个
     */
    @Configuration
    public class ExchangeConfig {
     
        /**
         *   1.定义direct exchange，绑定queueTest
         *   2.durable="true" rabbitmq重启的时候不需要创建新的交换机
         *   3.direct交换器相对来说比较简单，匹配规则为：如果路由键匹配，消息就被投送到相关的队列
         *     fanout交换器中没有路由键的概念，他会把消息发送到所有绑定在此交换器上面的队列中。
         *     topic交换器你采用模糊匹配路由键的原则进行转发消息到队列中
         *   key: queue在该direct-exchange中的key值，当消息发送给direct-exchange中指定key为设置值时，
         *   消息将会转发给queue参数指定的消息队列
         */
        @Bean
        public DirectExchange directExchange(){
            DirectExchange directExchange = new DirectExchange(RabbitMqConfig.EXCHANGE,true,false);
            return directExchange;
        }
    }

*** QueueConfig  队列配置***

package com.space.rabbitmq.config;
     
    import org.springframework.amqp.core.Queue;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
     
    /**
     * 队列配置  可以配置多个队列
     */
    @Configuration
    public class QueueConfig {
     
        @Bean
        public Queue firstQueue() {
            /**
             durable="true" 持久化 rabbitmq重启的时候不需要创建新的队列
             auto-delete 表示消息队列没有在使用时将被自动删除 默认是false
             exclusive  表示该消息队列是否只在当前connection生效,默认是false
             */
            return new Queue("first-queue",true,false,false);
        }
     
        @Bean
        public Queue secondQueue() {
            return new Queue("second-queue",true,false,false);
        }
    }

*** RabbitMqConfig RabbitMq配置***

package com.space.rabbitmq.config;
    
    import com.space.rabbitmq.mqcallback.MsgSendConfirmCallBack;
    import com.space.rabbitmq.mqcallback.MsgSendReturnCallback;
    import org.springframework.amqp.core.Binding;
    import org.springframework.amqp.core.BindingBuilder;
    import org.springframework.amqp.rabbit.connection.ConnectionFactory;
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * RabbitMq配置
     */
    @Configuration
    public class RabbitMqConfig {
    
        /** 消息交换机的名字*/
        public static final String EXCHANGE = "exchangeTest";
        /*对列名称*/
        public static final String QUEUE_NAME1 = "first-queue";
        public static final String QUEUE_NAME2 = "second-queue";
    
        /*
        *
        * key: queue在该direct-exchange中的key值，当消息发送给direct-exchange中指定key为设置值时，
        *   消息将会转发给queue参数指定的消息队列
        */
        /** 队列key1*/
        public static final String ROUTINGKEY1 = "queue_one_key1";
        /** 队列key2*/
        public static final String ROUTINGKEY2 = "queue_one_key2";
    
        @Autowired
        private QueueConfig queueConfig;
        @Autowired
        private ExchangeConfig exchangeConfig;
    
        /**
         * 连接工厂
         */
        @Autowired
        private ConnectionFactory connectionFactory;
    
        /**
         * 将消息队列1和交换机进行绑定,指定队列key1
         */
        @Bean
        public Binding binding_one() {
            return BindingBuilder.bind(queueConfig.firstQueue()).to(exchangeConfig.directExchange()).with(RabbitMqConfig.ROUTINGKEY1);
        }
    
        /**
         * 将消息队列2和交换机进行绑定,指定队列key2
         */
        @Bean
        public Binding binding_two() {
            return BindingBuilder.bind(queueConfig.secondQueue()).to(exchangeConfig.directExchange()).with(RabbitMqConfig.ROUTINGKEY2);
        }
    
        /**
         * queue listener  观察 监听模式
         * 当有消息到达时会通知监听在对应的队列上的监听对象
         * @return
         */
        /*@Bean
        public SimpleMessageListenerContainer simpleMessageListenerContainer_one(){
            SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
            simpleMessageListenerContainer.addQueues(queueConfig.firstQueue());
            simpleMessageListenerContainer.setExposeListenerChannel(true);
            simpleMessageListenerContainer.setMaxConcurrentConsumers(5);
            simpleMessageListenerContainer.setConcurrentConsumers(1);
            simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认
            return simpleMessageListenerContainer;
        }*/
    
        /**
         * 自定义rabbit template用于数据的接收和发送
         * 可以设置消息确认机制和回调
         * @return
         */
        @Bean
        public RabbitTemplate rabbitTemplate() {
            RabbitTemplate template = new RabbitTemplate(connectionFactory);
            // template.setMessageConverter(); 可以自定义消息转换器  默认使用的JDK的，所以消息对象需要实现Serializable
    
            /**若使用confirm-callback或return-callback，
             * 必须要配置publisherConfirms或publisherReturns为true
             * 每个rabbitTemplate只能有一个confirm-callback和return-callback
             */
            template.setConfirmCallback(msgSendConfirmCallBack());
    
            /**
             * 使用return-callback时必须设置mandatory为true，或者在配置中设置mandatory-expression的值为true，
             * 可针对每次请求的消息去确定’mandatory’的boolean值，
             * 只能在提供’return -callback’时使用，与mandatory互斥
             */
            template.setReturnCallback(msgSendReturnCallback());
            template.setMandatory(true);
            return template;
        }
    
        /*  关于 msgSendConfirmCallBack 和 msgSendReturnCallback 的回调说明：
            1.如果消息没有到exchange,则confirm回调,ack=false
            2.如果消息到达exchange,则confirm回调,ack=true
            3.exchange到queue成功,则不回调return
            4.exchange到queue失败,则回调return(需设置mandatory=true,否则不回回调,消息就丢了)
        */
    
        /**
         * 消息确认机制
         * Confirms给客户端一种轻量级的方式，能够跟踪哪些消息被broker处理，
         * 哪些可能因为broker宕掉或者网络失败的情况而重新发布。
         * 确认并且保证消息被送达，提供了两种方式：发布确认和事务。(两者不可同时使用)
         * 在channel为事务时，不可引入确认模式；同样channel为确认模式下，不可使用事务。
         * @return
         */
        @Bean
        public MsgSendConfirmCallBack msgSendConfirmCallBack(){
            return new MsgSendConfirmCallBack();
        }
    
        @Bean
        public MsgSendReturnCallback msgSendReturnCallback(){
            return new MsgSendReturnCallback();
        }
    }

***消息回调***

package com.space.rabbitmq.mqcallback;
     
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.amqp.rabbit.support.CorrelationData;
     
    /**
     * 消息发送到交换机确认机制
     */
    public class MsgSendConfirmCallBack implements RabbitTemplate.ConfirmCallback {
     
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            System.out.println("MsgSendConfirmCallBack  , 回调id:" + correlationData);
            if (ack) {
                System.out.println("消息消费成功");
            } else {
                System.out.println("消息消费失败:" + cause+"\n重新发送");
            }
        }
    }

package com.space.rabbitmq.mqcallback;
    
    import org.springframework.amqp.core.Message;
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    
    public class MsgSendReturnCallback implements RabbitTemplate.ReturnCallback {
        @Override
        public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
            System.out.println("回馈消息："+message);
        }
    }

***生产者/消息发送者***

package com.space.rabbitmq.sender;
     
    import com.space.rabbitmq.config.RabbitMqConfig;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.amqp.rabbit.support.CorrelationData;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
     
    import java.util.UUID;
     
    /**
     * 消息发送  生产者1
     */
    @Slf4j
    @Component
    public class FirstSender {
     
        @Autowired
        private RabbitTemplate rabbitTemplate;
     
        /**
         * 发送消息
         * @param uuid
         * @param message  消息
         */
        public void send(String uuid,Object message) {
            CorrelationData correlationId = new CorrelationData(uuid);
            rabbitTemplate.convertAndSend(RabbitMqConfig.EXCHANGE, RabbitMqConfig.ROUTINGKEY2,
                    message, correlationId);
        }
    }

***消费者***

package com.space.rabbitmq.receiver;
     
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
     
    /**
     * 消息消费者1
     */
    @Component
    public class FirstConsumer {
     
        @RabbitListener(queues = {"first-queue","second-queue"}, containerFactory = "rabbitListenerContainerFactory")
        public void handleMessage(String message) throws Exception {
            // 处理消息
            System.out.println("FirstConsumer {} handleMessage :"+message);
        }
    }

***测试***

package com.space.rabbitmq.controller;
     
    import com.space.rabbitmq.sender.FirstSender;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
     
    import java.util.UUID;
     
    
    @RestController
    public class SendController {
     
        @Autowired
        private FirstSender firstSender;
     
        @GetMapping("/send")
        public String send(String message){
            String uuid = UUID.randomUUID().toString();
            firstSender.send(uuid,message);
            return uuid;
        }
    }

***此时，我们就可以启动项目，进行测试了***

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70 4][]

转载：[https://blog.csdn.net/zhuzhezhuzhe1/article/details/80454956][https_blog.csdn.net_zhuzhezhuzhe1_article_details_80454956]

[https://blog.csdn.net/qq\_38455201/article/details/80308771][https_blog.csdn.net_qq_38455201_article_details_80308771]

[20181107144440655.png]: /images/20220418/6ee4c85db84641c4b5af978ae2678258.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70]: /images/20220418/70bc5d48d4e64fd3a2476c73beed36f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70 1]: /images/20220418/249bdd97e1604941ae6c98e61f01f5e2.png
[20181107144625870.png]: /images/20220418/3bb2b8f82f1142cbb15226342a747c47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70 2]: /images/20220418/f6d87ed88c4b4b66a4bb309c15deaa93.png
[2018110714473836.png]: /images/20220418/569fe1488bb449e1998d49f88b8c078a.png
[https_blog.csdn.net_Keith003_article_details_82386210]: https://blog.csdn.net/Keith003/article/details/82386210
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70 3]: /images/20220418/fdec8b9242b441d5982e675b39e054bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0tlaXRoMDAz_size_16_color_FFFFFF_t_70 4]: /images/20220418/e98ee7d510c5486fb81777f148c0f4f1.png
[https_blog.csdn.net_zhuzhezhuzhe1_article_details_80454956]: https://blog.csdn.net/zhuzhezhuzhe1/article/details/80454956
[https_blog.csdn.net_qq_38455201_article_details_80308771]: https://blog.csdn.net/qq_38455201/article/details/80308771