RabbitMQ基本使用

最新推荐文章于 2023-12-09 22:10:28 发布

qq1205183806

最新推荐文章于 2023-12-09 22:10:28 发布

阅读量88

点赞数 1

分类专栏： java 文章标签： java rabbitmq 队列

本文链接：https://blog.csdn.net/qq1205183806/article/details/109805479

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. 消息中间件

为什么使用MQ

在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。

开发中消息队列通常有如下应用场景：

1、任务异步处理

将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。

2、应用程序解耦合

MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。

3、削峰填谷

如订单系统，在下单的时候就会往数据库写数据。但是数据库只能支撑每秒1000左右的并发写入，并发量再高就容易宕机。低峰期的时候并发也就100多个，但是在高峰期时候，并发量会突然激增到5000以上，这个时候数据库肯定卡死了。

消息被MQ保存起来了，然后系统就可以按照自己的消费能力来消费，比如每秒1000个数据，这样慢慢写入数据库，这样就不会卡死数据库了。

但是使用了MQ之后，限制消费消息的速度为1000，但是这样一来，高峰期产生的数据势必会被积压在MQ中，高峰就被“削”掉了。但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000QPS，直到消费完积压的消息,这就叫做“填谷”

实现MQ的大致有两种主流方式：AMQP、JMS。

AMQP 与 JMS 区别

JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式
JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。
JMS规定了两种消息模式；而AMQP的消息模式更加丰富

1.2 RabbitMQ

RabbitMQ提供了6种模式：简单模式，work模式，Publish/Subscribe发布与订阅模式，Routing路由模式，Topics主题模式，RPC远程调用模式（远程调用，不太算MQ）；

官网：http://www.rabbitmq.com/

2.安装及配置RabbitMQ（略）

3.Spring Boot整合RabbitMQ

生产者工程：

application.yml文件配置RabbitMQ相关信息；

      <-- pom文件依赖 -->
   	 <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-amqp</artifactId>
      </dependency>
      
    #配置文件
   	spring.rabbitmq.host=192.168.200.128

在生产者工程中编写配置类，用于创建交换机和队列，并进行绑定

package com.hskj.consumer.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    public static final String hs_queue = "HS_QUEUE";
    public static final String hs_exchange = "HS_EXCHANGE";

    @Bean("hs_queueBean")
    public Queue queue(){
        return QueueBuilder.durable(hs_queue).build();
    }

    @Bean("hs_exchangeBean")
    public Exchange exchange(){
        return ExchangeBuilder.topicExchange(hs_exchange).durable(true).build();
    }

    @Bean
    public Binding binding(@Qualifier("hs_queueBean") Queue queue,@Qualifier("hs_exchangeBean") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("kk.#").noargs();
    }

}

注入RabbitTemplate对象，通过RabbitTemplate对象发送消息到交换机

@Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads() {
       /**
         * 参数1：交换机名称
         * 参数2：路由key
         * 参数3：发送的内容
         */
        rabbitTemplate.convertAndSend("HS_EXCHANGE", "kk.ll", "你在放什么");
    }

消费者工程：

application.yml文件配置RabbitMQ相关信息
创建消息处理类，用于接收队列中的消息并进行处理

@Component
public class MqListen {

	//queues要监听的队列名称(数组可多个)
    @RabbitListener(queues = {"HS_QUEUE"})
    public void getMessage(Message message){
        System.out.println("mq消费端获取消息："+new String(message.getBody()));
    }
}

4.消息可靠投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 提供了两种方式用来控制消息的投递可靠性模式。

confirm 确认模式
return 退回模式

rabbitmq 整个消息投递的路径为：
producer—>rabbitmq broker（略）—>exchange—>queue—>consumer

消息从 producer 到 exchange 则会返回一个 confirmCallback 。
消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。

spring.rabbitmq.publisher-confirm-type=correlated #开启 确认模式
spring.rabbitmq.publisher-returns=true 开启 退回模式

@Test
    void contextLoads() {
    //使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String s) {
                if (!ack) {
                    System.out.println("交换机失败原因：" + s);
                } else {
                    System.out.println("发送成功" + s);
                }
            }
        });

//使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。并执行回调函数returnedMessage。
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returnedMessage) {
                System.out.println(returnedMessage.getReplyCode());
                System.out.println(returnedMessage.getReplyText());
            }
        });
     
        rabbitTemplate.convertAndSend("HS_EXCHANGE", "kk.ll", "你在放什么");
    }

4.1 Consumer Ack

ack指Acknowledge,确认。表示消费端收到消息后的确认方式。有三种确认方式：
自动确认：acknowledge=“none”
手动确认：acknowledge=“manual”
根据异常情况确认：acknowledge=“auto”

其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。

spring.rabbitmq.listener.simple.acknowledge-mode=manual #设置手动确认
spring.rabbitmq.listener.direct.prefetch=2 #设置消费方每次拉取多少信息

如果在消费端没有出现异常，则调用channel.basicAck(deliveryTag,false);方法确认签收消息。

如果出现异常，则在catch中调用 basicNack或 basicReject，拒绝消息，让MQ重新发送消息。

4.2TTL

设置消息过期时间

rabbitTemplate.convertAndSend("HS_EXCHANGE", "kk.ll", "你在放什么", new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setExpiration("5000");
                return message;
            }
        });

4.3 死信队列

在这里插入图片描述

消息成为死信的三种情况：

队列消息长度到达限制；
消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；
原队列存在消息过期设置，消息到达超时时间未被消费；

@Configuration
public class RabbitMQConfig {

    public static final String hs_queue = "HS_QUEUE";
    public static final String hs_exchange = "HS_EXCHANGE";
    public static final String hs_queue_dlx = "HS_QUEUE_DLX";
    public static final String hs_exchange_dlx = "HS_EXCHANGE_DLX";

    @Bean("hs_queueBean")
    public Queue queue() {
        Map<String, Object> args = new HashMap<>(2);
//       x-dead-letter-exchange    这里声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", hs_exchange_dlx);
//       x-dead-letter-routing-key  这里声明当前队列的死信路由key
        args.put("x-dead-letter-routing-key", "dlx.haha");
//       x-max-length 这里声明当前队列最多可以存多少消息
        arg.put("x-max-length",2);
        return QueueBuilder.durable(hs_queue).withArguments(args).build();
    }

    @Bean("hs_exchangeBean")
    public Exchange exchange() {
        return ExchangeBuilder.topicExchange(hs_exchange).durable(true).build();
    }

    @Bean("hs_queue_dlx")
    public Queue queueDlx() {
        return QueueBuilder.durable(hs_queue_dlx).build();
    }

    @Bean("hs_exchange_dlx")
    public Exchange exchangeDlx() {
        return ExchangeBuilder.topicExchange(hs_exchange_dlx).durable(true).build();
    }

    @Bean
    public Binding binding(@Qualifier("hs_queueBean") Queue queue, @Qualifier("hs_exchangeBean") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("kk.#").noargs();
    }

    @Bean
    public Binding bindingDlx(@Qualifier("hs_queue_dlx") Queue queue, @Qualifier("hs_exchange_dlx") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("dlx.#").noargs();
    }
}

4.4 延迟队列

在这里插入图片描述

RabbitMQ没有提供延迟队列功能，但是可以使用： TTL + DLX 来实现延迟队列效果

qq1205183806

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ基本使用

1. 消息中间件为什么使用MQ在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。开发中消息队列通常有如下应用场景：1、任务异步处理将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。2、应用程序解耦合MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。3、削峰填谷如订单系统，在下单的时候就会往数据库写数据。但是数据库只能支撑
复制链接

扫一扫