RabbitMQ 高级特性

已于 2022-06-16 15:45:40 修改
阅读量828 收藏 1
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq java 分布式
于 2022-06-16 15:41:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46550964/article/details/125317106
版权

RabbitMQ 高级特性

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景;

RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式;

  • confirm 确认模式
  • return 退回模式

对于确认模式：

  • 使用 rabbitTemplate.**setConfirmCallback **设置回调函数;当消息发送到exchange后回调confirm方法;在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理;

对于退回模式

  • 使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后，则会将消息退回给producer，并执行回调函数returnedMessage;

请添加图片描述

rabbitmq 整个消息投递的路径为：

请添加图片描述

  • 消息从 product 到 exchange 是否成功可以通过 confirmCallback 来进行确认;
  • 消息从 exchange 到 queue路由是否成功可以通过 **returnCallback ** 来进行确认;

我们可以利用这两个 callback 控制消息的可靠性投递;

生产者确认 confirm & return

confirm确认模式

Maven创建 rabbitmq-confirm model

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

rabbitmq连接信息

server:
  port: 8086

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirm-type: correlated #开启confirm确认

声明队列、交换机以及绑定队列和交换机

package com.example.config;


import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * explain:消息确认 队列需要持久化 交换机需要持久化
 *
 * @author Hope
 * @date 2022/6/14
 * @see RabbitMQConfig
 */
@Configuration
public class RabbitMQConfig {

    /**
     * 声明order.A队列
     * 第一个参数：队列名称
     * 第二个参数：队列是否持久化
     * 第三个参数：是否为排外队列，如果排外队列则只能一个消费者进行访问消费
     * 第四个参数：是否自动删除
     *
     * @author Hope
     */
    @Bean
    public Queue orderQueue() {
        return new Queue("order.A", true, false, false);
    }

    /**
     * 声明交换机
     * 第二个参数：队列是否持久化
     * 第三个参数：是否自动删除
     *
     * @author Hope
     */
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("order_direct_ex", true, false);
    }

    /**
     * 将队列与交换机绑定
     *
     * @param orderQueue
     * @param directExchange
     * @author Hope
     */
    @Bean
    public Binding binding(Queue orderQueue, DirectExchange directExchange) {
        return BindingBuilder.bind(orderQueue).to(directExchange).with("order");
    }
}

发送消息

package com.example.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * explain:生产者确认测试 Controller
 *
 * @author Hope
 * @date 2022/6/14
 * @see ConfirmController
 */
@RestController
public class ConfirmController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMsgConfirm")
    public void sendMsg() {
        rabbitTemplate.convertAndSend("order_direct_ex", "order", "生产者消息");
    }
}

编写confirm回调方法

package com.example.confirm;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

@Component
@Slf4j
public class RabbitmqConfirm implements RabbitTemplate.ConfirmCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /*
        @PostConstruct在 @Autowired 后执行
     */
    @PostConstruct
    public void init() {
        rabbitTemplate.setConfirmCallback(this);
    }

    /*
        confirm 确认
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if (ack) {
            log.info("消息进入交换机成功");
        } else {
            log.info("消息进入交换机失败, cause: {}", cause);
        }
    }
}

生产者最终效果如下

请添加图片描述

消费者消费消息, 消费者这里就是mq一个基础的消费端, 只需要监听队列即可, 这里直接使用上一篇博客的消费者,

效果如下
请添加图片描述

return 退回模式

修改生产者配置文件,开启回退模式

server:
  port: 8086

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirm-type: correlated #开启confirm确认
    publisher-returns: true #开启return确认

编写return回调方法

package com.example.confirm;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * explain:生产者消息确认监控
 * confirm监控范围: 生产者->交换机
 * returned监控范围: 交换机->队列
 *
 * @author Hope
 * @date 2022/6/14
 * @see RabbitmqConfirm
 */
@Component
@Slf4j
public class RabbitmqConfirm implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /*
        @PostConstruct在 @Autowired 后执行
     */
    @PostConstruct
    public void init() {
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnCallback(this);
    }

    /*
        confirm 确认
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if (ack) {
            log.info("消息进入交换机成功");
        } else {
            log.info("消息进入交换机失败, cause: {}", cause);
        }
    }

    /*
       return 退回确认
    */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        log.info("消息从交换机路由至队列失败, replyCode: {}, replyText: {}, exchange: {}, routingKey: {}", replyCode, replyText, exchange, routingKey);
    }
}

测试: 启动生产者和消费者, 修改controller中的路由key, 让消息无法发送到队列, 观察控制台打印;

小节:

  1. 对于确认模式和回退模式都是针对于生产者确认;

  2. 生产者确认开启步骤: 配置文件开启confirm和return, 编写监控类实现确认和回退的回调函数, 交换机要声明持久化否则确认模式将毫无意义;

消费者确认(ACK)

ack指 Acknowledge，确认; 表示消费端收到消息后的确认方式;

有三种确认方式：

• 自动确认：acknowledge=“none”

• 手动确认：acknowledge=“manual”

• 根据异常情况确认：acknowledge=“auto”

如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息;

代码实现:

在配置文件中开启手动ACK, 配置最好在生产者和消费者都配置一份, ACK是必需要配置在消费者中;

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirm-type: correlated #开启confirm确认
    publisher-returns: true #开启return确认
    listener:
      simple:
        acknowledge-mode: manual #ACK

消费者代码

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Slf4j
@Component
@RabbitListener(queues = "hello_world") //监听hello_world队列
@RabbitListener(queues = "fanout.A")
@RabbitListener(queues = "direct.A")
@RabbitListener(queues = "topic.A")
@RabbitListener(queues = "order.A")
public class ConsumerService {

    @RabbitHandler
    public void receive(String message, Channel channel,
                        @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) {
        try {
            //deliveryTag 信道中每接收一条消息自增1,
            log.info("message: {}, deliveryTag: {}", message, deliveryTag);
            if (message.contains("苹果")) {
                throw new RuntimeException("不许购买苹果手机");
            }
             /*
                deliveryTag 信道中每接收一条消息自增1,
                第二个参数代表是否批量确认,我们这里只确认一条消息所以设置为false
                basicAck 代表接收消息后业务逻辑处理正常，rabbitmq可以将此消息删除掉了
             */
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            log.info("消费失败,重回队列, message: {}, deliveryTag: {}", message, deliveryTag);
            try {
                     /*
                         deliveryTag 每次接收消息+1,
                        第二个参数代表是否批量确认,我们这里只确认一条消息所以设置为false
                        第三个参数代表是否要将该消息重回队列
                    */
                channel.basicNack(deliveryTag, false, true);
            } catch (IOException e1) {
                log.error("重回队列异常： {}", e1);
            }
        }
    }

}

但是上面的方法存在一个问题, 如果消息确认失败, 失败消息不断的重新回到队列中，如果有大量的失败消息将造成队列的大量消息积压和资源的占用;

对于消费失败的消息我们不能让他无限的重新回到队列中去，mq消息中用一个布尔类型的值来标记消息是否已经重回过队列，那么我们在消费的时候增加一个消息是否已经重新回到过队列的判断就可以解决这个问题了;

代码实现:

/**
     * 消费者确认ACK
     *
     * @param message
     * @param channel
     * @param deliveryTag 信道中每接收一条消息自增1
     * @param redelivered true-代表已经重回过队列
     * @author Hope
     */
    @RabbitHandler
    public void receive(String message, Channel channel,
                        @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag,
                        @Header(AmqpHeaders.REDELIVERED) boolean redelivered) {
        try {
            // Thread.sleep(3000);
            log.info("message: {}, deliveryTag: {}, redelivered: {}", message, deliveryTag, redelivered);
            if (message.contains("苹果")) {
                throw new RuntimeException("不许购买苹果手机");
            }
             /*
                basicAck 手动确认
                deliveryTag 信道中每接收一条消息自增1
                第二个参数代表是否批量确认,我们这里只确认一条消息所以设置为false
             */
            channel.basicAck(deliveryTag, false);// 确认消息
        } catch (Exception e) {
            if (redelivered) {
                log.info("第二次消费失败,不允许重回队列, " +
                        "message: {}, deliveryTag: {}, redelivered: {}", message, deliveryTag, redelivered);

                try {
                     /*
                        basicAck 手动确认
                        deliveryTag 信道中每接收一条消息自增1
                        第二个参数代表是否批量确认,我们这里只确认一条消息所以设置为false
                        第三个参数代表是否要将该消息重回队列
                    */
                    channel.basicNack(deliveryTag, false, false);
                } catch (IOException e1) {
                    log.error("拒绝重回队列异常： {}", e1);
                }
            } else {
                log.info("消费失败,重回队列 message: {}, deliveryTag: {}, redelivered: {}"
                        , message, deliveryTag, redelivered);
                try {
                    channel.basicNack(deliveryTag, false, true);
                } catch (IOException e1) {
                    log.error("重回队列异常： {}", e1);
                }
            }
        }
    }

消费端限流

请添加图片描述

如上图所示：

假设 Consumer需要停机维护, 生产者发送5000条消息到MQ中, 此时Consumer停机消息积压在MQ中, Consumer最大处理消息数量2条, 当Consumer系统成功启动后，消费者会一次性将MQ的消息全部拉取到自己的服务，导致服务在短时间内会处理大量的业务，可能会导致系统服务的崩溃;

可以通过MQ中的 listener-container 配置属性 perfetch = 2,

表示消费端每次从mq拉去2条消息来消费，直到手动确认消费完毕后，才会继续拉去下一条消息;

  • 在rabbit:listener-container 中配置 prefetch属性设置消费端一次拉取多少消息
  • 消费端的确认模式一定为手动确认;acknowledge=“manual”

代码实现:

消费者配置开启限流, 每次读取两条消息

server:
  port: 8082

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirm-type: correlated #开启confirm确认
    publisher-returns: true #开启return确认
    listener:
      simple:
        acknowledge-mode: manual #ACK
        prefetch: 2 #消费者在未确认消息时一次拉取消息的数量

测试

请添加图片描述

TTL过期时间

TTL 全称 Time To Live（过期时间）;当消息到达存活时间后，还没有被消费，会被自动清除;

RabbitMQ可以对消息设置过期时间，也可以对整个队列设置过期时间;

  • 设置队列过期时间使用参数：x-message-ttl，单位：ms(毫秒)，会对整个队列消息统一过期;
  • 由于队列是先进先出的，所以如果设置单个消息的过期时间并没有实际意义;
  • 例如：设置消息A的过期时间为10秒，消息B的过期时间为5秒，但是先将消息A发送至队列，那么只有等消息A被消费或者到期移除后才会将消息B消费或者到期移除;

请添加图片描述

代码实现:

我们直接修改之前的生产者代码, 在声明队列是添加过期时间;


@Configuration
public class RabbitMQConfig {

    /**
     * 声明order.A队列
     * 第一个参数：队列名称
     * 第二个参数：队列是否持久化
     * 第三个参数：是否为排外队列，如果排外队列则只能一个消费者进行访问消费
     * 第四个参数：是否自动删除
     * 第五个参数: 队列过期时间, 单位ms ,key = x-message-ttl
     *
     * @author Hope
     */
    @Bean
    public Queue orderQueue() {
        HashMap<String, Object> arguments = new HashMap<>();
        arguments.put("x-message-ttl", 5000); //声明过期队列，设置过期时间为5秒

        return new Queue("order.A", true, false, false, arguments);
    }

    /**
     * 声明交换机
     * 第二个参数：队列是否持久化
     * 第三个参数：是否自动删除
     *
     * @author Hope
     */
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("order_direct_ex", true, false);
    }

    /**
     * 将队列与交换机绑定
     *
     * @param orderQueue
     * @param directExchange
     * @author Hope
     */
    @Bean
    public Binding binding(Queue orderQueue, DirectExchange directExchange) {
        return BindingBuilder.bind(orderQueue).to(directExchange).with("order");
    }
}

我们不启动消费者, 直接启动生产者, 观察rabbitmq控制台5秒后消息是否会自动移除;

这里遇到一个问题, 一旦创建了队列和交换机，就不能修改其标志了;例如，如果创建了一个non-durable的队列，然后想把它改变成durable的，唯一的办法就是删除这个队列然后重新创建;

队列一旦创建 Features(特性)不可改变, order.A队列之前已经创建过了, 所以再添加过期时间是会报错的;

死信队列

死信队列：当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是Dead Letter Exchange（死信交换机 简写：DLX）;

  1. 死信交换机和死信队列和普通的没有区别
  2. 当消息成为死信后，如果该队列绑定了死信交换机，则消息会被死信交换机重新路由到死信队列
  3. 消息成为死信的三种情况：
    • 队列消息长度到达限制;
    • 消费者拒接消费消息，并且不重回队列；
    • 原队列存在消息过期设置，消息到达超时时间未被消费；

请添加图片描述

设置死信队列绑定死信交换机：

给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key

代码实现:

初始化死信队列和死信交换机并且绑定

 /**
     * 声明死信队列
     * 第一个参数：队列名称
     * 第二个参数：队列是否持久化
     * 第三个参数：是否为排外队列，如果排外队列则只能一个消费者进行访问消费
     * 第四个参数：是否自动删除
     *
     * @author Hope
     */
    @Bean
    public Queue delQueue() {
        return new Queue("order_del_queue", true, false, false);
    }

    /**
     * 声明死信交换机
     * 第二个参数：队列是否持久化
     * 第三个参数：是否自动删除
     *
     * @author Hope
     */
    @Bean
    public DirectExchange delExchange() {
        return new DirectExchange("order_del_ex", true, false);
    }

    /**
     * 将队列与交换机绑定
     *
     * @author Hope
     */
    @Bean
    public Binding bindingDel(Queue delQueue, DirectExchange delExchange) {
        return BindingBuilder.bind(delQueue).to(delExchange).with("order_del");
    }

给order.A绑定死信队列

需要注意的是队列一旦声明就不可以变更了，所以这里记得在管控台删除一下队列;

    /**
     * 声明order.A队列
     * 第一个参数：队列名称
     * 第二个参数：队列是否持久化
     * 第三个参数：是否为排外队列，如果排外队列则只能一个消费者进行访问消费
     * 第四个参数：是否自动删除
     * 第五个参数: 声明过期队列, 设置死信队列, 设置死信交换机
     *
     * @author Hope
     */
    @Bean
    public Queue orderQueue() {
        HashMap<String, Object> arguments = new HashMap<>();
        arguments.put("x-message-ttl", 5000); //声明过期队列，设置过期时间为5秒
        arguments.put("x-dead-letter-routing-key", "order_del"); //设置死信队列
        arguments.put("x-dead-letter-exchange", "order_del_ex"); //设置死信交换机

        return new Queue("order.A", true, false, false, arguments);
    }

测试order.A的过期消息是否会路由至死信队列

延迟队列

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费;

提出需求：

  1. 下单后，30分钟未支付，取消订单，回滚库存;
  2. 新用户注册成功7天后，发送短信问好;

实现方式：

  1. 定时器

  2. 延迟队列

  3. 延迟队列 指消息进入队列后，可以被延迟一定时间，再进行消费;

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

请添加图片描述

注意：在RabbitMQ中并未提供延迟队列功能;

但是可以使用：TTL+死信队列 组合实现延迟队列的效果;

请添加图片描述

保证幂等性

幂等性例子：比如你购物只想购买一件商品，但是网络卡顿，你按了多次提交按钮后，系统将此订单生成了两次, 如上即数据库生成了两条订单记录, 即产生了幂等性的问题;

**正确的情况：**一个商品页点提交，不管如何, 只会产生一条订单信息;

解决方案: 全局唯一ID(把订单ID添加到redis, 新订单查询redis中有没有重复ID), 数据库主键 唯一索引

redis解决方案:

思路:

  1. 消费者要开启手动ACK模式, 手动确认消息;
  2. 首先消息要有全局唯一的 id;
  3. 消费者 消费时用唯一id去redis中去查;
  4. redis中没有代表消息没有被消费过, 消费后将唯一id, 存入Redis中;
  5. redis中有代表消息重复, 丢弃消息;

生产者代码实现

创建rabbitmq-idempotent-p项目

Maven依赖:

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!--JSON 数据转换支持-->
        <!--alibaba fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>

配置文件

server:
  port: 8087

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirm-type: correlated #开启confirm确认
    publisher-returns: true #开启return确认
    listener:
      simple:
        acknowledge-mode: manual #ACK

添加rabbitmq配置


@Configuration
public class RabbitMQConfig {


    /**
     * 声明order.A队列
     * 第一个参数：队列名称
     * 第二个参数：队列是否持久化
     * 第三个参数：是否为排外队列，如果排外队列则只能一个消费者进行访问消费
     * 第四个参数：是否自动删除
     * 第五个参数: 声明过期队列, 设置死信队列, 设置死信交换机
     *
     * @author Hope
     */
    @Bean
    public Queue orderQueue() {
        HashMap<String, Object> arguments = new HashMap<>();
        arguments.put("x-message-ttl", 50000); //声明过期队列，设置过期时间为50秒

        return new Queue("object.A", true, false, false, arguments);
    }

    /**
     * 声明交换机
     * 第二个参数：队列是否持久化
     * 第三个参数：是否自动删除
     *
     * @author Hope
     */
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("order_direct_ex", true, false);
    }

    /**
     * 将队列与交换机绑定
     *
     * @param orderQueue
     * @param directExchange
     * @author Hope
     */
    @Bean
    public Binding binding(Queue orderQueue, DirectExchange directExchange) {
        return BindingBuilder.bind(orderQueue).to(directExchange).with("order");
    }

}

模拟实体


@Data
@AllArgsConstructor
@NoArgsConstructor
public class MqModel implements Serializable {
    private String id;
    private String mes;
}

序列化工具


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

/**
 * explain:Json工具类
 *
 * @author Hope
 * @date 2022/3/22
 * @see com.alibaba.fastjson
 */
public class JacksonJsonUtil {

    /**
     * 对象转json
     *
     * @param obj 任意VO(页面对象) 集合
     * @return java.lang.String
     * @author Hope
     */
    public static String objToJson(Object obj) {
        String str;
        if (obj == null) {
            return null;
        }
        JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
        str = JSON.toJSONString(obj, SerializerFeature.WriteDateUseDateFormat);
        return str;

    }

    /**
     * json转对象
     *
     * @param jsonStr   json形式的对象
     * @param classType 对象类型
     * @return T
     * @author Hope
     */
    public static <T> T jsonToObj(String jsonStr, Class<T> classType) {
        if (jsonStr == null) {
            return null;
        }
        JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
        return JSON.parseObject(jsonStr, classType);
    }

}

发送消息


@RestController
public class PIdempotentController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/sendMsgConfirm")
    public void sendMsg() {
        MqModel mqModel = new MqModel();
        // 假设此id 是消息的全局唯一id
        mqModel.setId("12000");
        mqModel.setMes("生产者消息");

        //序列化对象
        String obj = JacksonJsonUtil.objToJson(mqModel);

        rabbitTemplate.convertAndSend("order_direct_ex", "order", obj);

    }
}

生产者最终效果

请添加图片描述

消费者代码实现

创建 rabbitmq-idempotent-c 项目

Maven依赖:

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

        <!--JSON 数据转换支持-->
        <!--alibaba fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>

        <!--RedisTemplate 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

配置文件

server:
  port: 8088

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirm-type: correlated #开启confirm确认
    publisher-returns: true #开启return确认
    listener:
      simple:
        acknowledge-mode: manual #ACK
  jmx:
    enabled: false
  redis:
    ## Redis数据库索引（默认为0）
    database: 0
    ## Redis服务器地址
    host: 127.0.0.1
    ## Redis服务器连接端口
    port: 6379
    ## Redis服务器连接密码（默认为空）
    password:

    lettuce:
      pool:
        ## 连接池最大连接数（使用负值表示没有限制）
        max-active: 60
        ## 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
        ## 连接池中的最大空闲连接
        max-idle: 20
        ## 连接池中的最小空闲连接
        min-idle: 8
    ## 连接超时时间（毫秒）
    timeout: 300000ms

redis配置类


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisConfig {

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        //设置序列化
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer<Object> jacksonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();

        //指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonRedisSerializer.setObjectMapper(om);

        //配置redisTemplate
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //String类的序列化方式
        RedisSerializer stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);//key序列化
        template.setValueSerializer(stringSerializer);//value序列化
        template.setHashKeySerializer(stringSerializer);//Hash key序列化
        template.setHashValueSerializer(jacksonRedisSerializer);//Hash value序列化
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    @ConditionalOnMissingBean(StringRedisTemplate.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(factory);
        return template;
    }
}



@Data
@AllArgsConstructor
@NoArgsConstructor
public class MqModel implements Serializable {
    private String id;
    private String mes;
}

序列化工具和生产者一样, 复制过来即可

消费消息


import com.rabbitmq.client.Channel;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.example.model.MqModel;
import org.example.utils.JacksonJsonUtil;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

/**
 * explain:消费者监听
 *
 * @author Hope
 * @date 2022/6/14
 * @see ConsumerService
 */
@Slf4j
@Component
@RabbitListener(queues = "object.A")
public class ConsumerService {
    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    /**
     * 消息幂等性测试方法
     *
     * @param message
     * @param channel
     * @param deliveryTag 信道中每接收一条消息自增1
     * @param redelivered true-代表已经重回过队列
     * @author Hope
     */
    @SneakyThrows
    @RabbitHandler
    public void receive(String message, Channel channel,
                        @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag,
                        @Header(AmqpHeaders.REDELIVERED) boolean redelivered) {

        try {
            // Thread.sleep(3000);

            // 获取消息内容
            MqModel model = JacksonJsonUtil.jsonToObj(message, MqModel.class);
            // 根据消息唯一id 去redis中查询
            Boolean isKey = redisTemplate.hasKey(model.getId());


            // id不存在正常消费, 存在则丢弃
            if (!isKey) {
                log.info("message: {}, deliveryTag: {}, redelivered: {}", model, deliveryTag, redelivered);
                ValueOperations<String, Object> opsForValue = redisTemplate.opsForValue();

                //将消息的唯一ID添加到redis中
                opsForValue.set(model.getId(), model.getMes());

                // 确认消息
                channel.basicAck(deliveryTag, false);
            } else {
                log.error("消息已消费, 消息丢弃: message: {}", message);

                 /*手动ack
                 * deliveryTag 信道中每接收一条消息自增1,
                   第二个参数代表是否批量确认,我们这里只确认一条消息所以设置为false
                   第三个参数代表是否要将该消息重回队列
                 * */
                channel.basicNack(deliveryTag, false, false);
            }

        } catch (Exception e) {
            //redelivered：true-代表已经重回过队列
            if (redelivered) {
                log.info("第二次消费失败,不允许重回队列, " +
                        "message: {}, deliveryTag: {}, redelivered: {}", message, deliveryTag, redelivered);
                channel.basicNack(deliveryTag, false, false);

            } else {
                log.info("消费失败,重回队列 message: {}, deliveryTag: {}, redelivered: {}"
                        , message, deliveryTag, redelivered);
                channel.basicNack(deliveryTag, false, true);

            }

        }
    }
}

消费者最终效果

请添加图片描述

测试

消息的id已经写死, 这里只测试消息幂等性, 所以没有dao层, 启动生产者和消费者, 第一次消费redis中没有消费成功然后将id添加到redis中, 再次消费时redis中存在, 丢弃消息

请添加图片描述

香辣奥利奥
关注
专栏目录
RabbitMQ高级特性
04-05
**RabbitMQ高级特性** RabbitMQ是一款广泛使用的开源消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议实现，为分布式系统提供可靠的消息传递服务。在基础功能之上，RabbitMQ还提供了丰富的高级...
rabbitmq消费端auto和manual区别；处理mq的requeue
奔跑的菜鸡
07-20 1851
rabbitmq requeue
RabbitMQ手动确认模式(项目开发常用模式)
weixin_43822632的博客
08-11 9157
RabbitMQ 手动确认模式（日常项目开发常用模式）借鉴导言架构及工作原理项目实战 借鉴导言 此文借鉴多名CSDN用户博客，并将其博文中关于MQ常用的点，进行了归纳整理 借鉴博文来源：[小目标青年][爱吃烤面筋的鱼][dreamboycs][交换机] 架构及工作原理 MQ架构图 名词解释 Producer/Consumer producer 消息生产者 consumer 消息消费者 Queue(消息队列) 消息队列，提供了FIFO的处理机制，具有缓存消息的能力。rabbitmq中，队列消
RabbitMq 消息确认机制详解
weixin_52278591的博客
02-01 5155
消息从发送，到消费者接收，会经理多个过程,其中的每一步都可能导致消息丢失，常见的丢失原因包括： 生产者发送的消未送达exchange 消息到达exchange后未到达queue 针对这些问题，RabbitMQ分别给出了解决方案： 生产者确认机制 mq持久化消费者确认机制 失败重试机制 ​
RabbitMQ 消费者确认auto 和 manual 模式对异常的处理区别（含重试、requeue的影响）
Unknownfuture的博客
08-12 4904
本文用于解答下述疑问： 消息在下面四个条件的处理方式： 两种模式 是否有异常、是否捕获异常 是否设置重试 requeue为true / false ( + default-requeue-rejected的影响) 看似是 2 4 种方案，让人头疼，但其实没那么复杂。总结中也会给出简洁的答案。 文章目录正文auto自动确认manual人工确认default-requeue-rejected 属性导致死循环的情况总结 正文 本文环境： springboot 2.1.9.RELEASE + amqp-cli
四：RabbitMQ 高级特性
Xx__WangQi的博客
04-14 857
目录 1、RabbitMQ 高级特性 1.1 消息的可靠投递 1.2 Consumer Ack 1.3 消费端限流 1.4 TTL 1.5 死信队列 1.6 延迟队列 1.7 消息幂等性保障 1.8 消息积压 1、RabbitMQ 高级特性 1.1 消息的可靠投递 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。 RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm 确认模式 return 退回模式 ..
消息队列：RabbitMQ：RabbitMQ高级特性：Exchange类型.docx
最新发布
09-02
消息队列：RabbitMQ：RabbitMQ高级特性：Exchange类型.docx
rabbitmq的高级特性
06-05
rabbitmq的高级特性
消息队列：RabbitMQ：RabbitMQ高级特性：死信队列技术教程.docx
09-02
消息队列：RabbitMQ：RabbitMQ高级特性：死信队列技术教程.docx
消息队列：RabbitMQ：RabbitMQ高级特性：Routing键与绑定.docx
09-02
消息队列：RabbitMQ：RabbitMQ高级特性：Routing键与绑定.docx
springboot整合rabbitmq高级特性配置
wei1359765074410的博客
01-29 1515
一.ack模式 ack模式 在 spring boot 中提供了三种确认模式: NONE - 使用rabbitmq的自动确认 AUTO - 使用rabbitmq的手动确认, springboot会自动发送确认回执 (默认) MANUAL - 使用rabbitmq的手动确认, 且必须手动执行确认操作 默认的 AUTO 模式中, 处理消息的方法抛出异常, 则表示消息没有被正确处理, 该消息会被重新发送. spring: rabbitmq: listener: simple:
RabbitMQ基于MANUAL机制手动确认消费模型
杨杨杨~~的博客
05-19 711
文章目录前言RabbitMq 专栏直通车干货实战演练-RabbitMQ基于MANUAL机制手动确认消费模型什么是MANUAL 手动确认消费?01::前期准备:引入相关依赖02::整合RabbitMQ02::01-加入RabbitMq相关配置03 创建确认消费模型--交换机、队列、绑定，和确认消费相关配置03::01:设置消息的确认消费模式为手动确认03::02:指定该容器监听的队列03::03:指定该容器中的消费监听器 即消费者03::04:交换机、队列持久化配置03::05:相关配置信息:04::制作消费
15.RabbitMQ 消费端手动ACK消息确认机制
自能生羽翼，何必仰云梯
07-21 4436
  ack——acknowledge（vt. 承认；答谢；报偿；告知已收到；确认的意思），在RabbitMQ中指代的是消费者收到消息后确认的一种行为，关注点在于消费者能否实际接收到MQ发送的消息。   其提供了三种确认方式：   自动确认acknowledge=“none”：当消费者接收到消息的时候，就会自动给到RabbitMQ一个回执，告诉MQ我已经收到消息了，不在乎消费者接收到消息之后业务处理的成功与否。   手动确认acknowledge=“manual”：当消费者收到消息后，不会立刻告诉Rabbit
RabbitMQ ACK 消息确认机制
tang_jian_dong的博客
12-26 3693
在消费者端的mq配置文件上添加,配置  关键代码为 acknowledeg = "manual" ，意为表示该消费者的ack方式为手动（此时的queue已经和生产者的exchange通过某个routeKey绑定了） rabbit:listener-container connection-factory="connectionFactory" acknowledge="manu
Day96.RabbitMQ：高级特性: 消息可靠投递、Ack、死信队列、SpringBoot整合、集群_队列镜像
a111042555的博客
07-03 1016
rabbitmq
springboot整合rabbitMQ系列4 消费者Consumer 手动进行ack确认---消费者做到可靠性方案
小哇
04-12 3643
ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。 有三种确认方式： 自动确认：acknowledge="none" 手动确认：acknowledge="manual" 根据异常情况确认：acknowledge="auto"，（这种方式使用麻烦，不作讲解） 其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确
RabbitMQ之高级特性
qq15035899256的博客
04-09 1144
本文是对RabbitMQ高级特性的学习，我们首先学习了消息确认机制和消费端限流的方法，又通过设置队列的参数实现了死信队列和延时队列。后面又介绍了两种方式实现消息追踪，最后也介绍了消息可靠性和消息幂等性的解决方案。
最全RabbitMQ教程4-常见问题
roykingw的专栏
02-19 301
文章目录一、RabbitMQ如何保证消息不丢失？1、哪些环节会有丢消息的可能？2、RabbitMQ消息零丢失方案：1》 生产者发送消息保证零丢失2》 RabbitMQ消息存盘不丢消息3》 RabbitMQ 主从消息同步时不丢消息4》 RabbitMQ消费者不丢失消息二、如何保证消息幂等？三、如何保证消息的顺序？ 一、RabbitMQ如何保证消息不丢失？ 这是面试时最喜欢问的问题，其实这个是所有MQ的一个共性的问题，大致的解决思路也是差不多的，但是针对不同的MQ产品会有不同的解决方案。之前针对RocketMQ
RabbitMQ详解
qq_53263107的博客
11-15 3717
说到消息中间件，估计大伙多多少少都能讲出来一些，ActiveMQ、RabbitMQ、RocketMQ、Kafka 等等各种以及 JMS、AMQP 等各种协议，然而这些消息中间件各自都有什么特点，我们在开发中又该选择哪种呢？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

香辣奥利奥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值