RabbitMQ系列（十五）RabbitMQ进阶-SprintBoot集成RabbitMQ使用

最新推荐文章于 2022-05-25 21:05:03 发布
最新推荐文章于 2022-05-25 21:05:03 发布
阅读量364 收藏 1
点赞数 2
分类专栏： MQ中间件 文章标签： Springboot整合MQ Rabbitmq 实战 Springboot MQ实战 Springboot集成MQ RabbitMq使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010134642/article/details/115313892
版权

RabbitMQ进阶-SprintBoot集成RabbitMQ使用

文章目录

1.构建项目
1.1 Spring Init创建项目

我们之选了RabbitMQ、Web、Lombok插件简单的几个组成
项目组成

SpringBoot 2.4.4 + RabbitMQ  AMQP版本 2.4.4

在这里插入图片描述

1.2 新建项目包

项目结构如下所示

-java
 --com.jzj.bootmqtest
   ---bean
   ---config
   --controller
   --rabbitmq
   --task

   --BootmqtestApplication
   
-resources
--static
--templates
 --application.yml

在这里插入图片描述

2.初始化RabbitMQ
2.1 项目配置Pom文件及application.yml

Pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.jzj</groupId>
    <artifactId>bootmqtest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>bootmqtest</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- hutool 工具类-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.1</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

application.yml 配置

#项目端口
server:
  port: 9672

spring:
  #应用名称
  application:
    name: jzj-sprintboot-mqtest
  #mq配置
  rabbitmq:
    addresses: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    #开启消息确认机制 confirms
    publisher-confirm-type: correlated
    publisher-returns: true
    #采用手动应答方式
    listener:
      simple:
        acknowledge-mode: manual
2.2 新建实体Bean

在com.jaj.bootmqtest.bean下新建Student实体Bean，用来作为消息体，发送Object的消息体

package com.jzj.bootmqtest.bean;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;

@Setter
@Getter
@AllArgsConstructor
public class Student {
    private Integer id;
    private String name;
    private Integer age;
}

在controller下面新建测试SiteController，用来测试消息

package com.jzj.bootmqtest.controller;

import com.jzj.bootmqtest.bean.Student;
import com.jzj.bootmqtest.config.QueueConfig;
import com.jzj.bootmqtest.rabbitmq.BaseMqProducer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@ResponseBody
@RestController
@RequestMapping("test")
public class SiteController {


    @Resource
    private BaseMqProducer mqProducer;


    @RequestMapping("ping")
    public Object ping() {
        return "pong";
    }


    @RequestMapping("sendA")
    public Object mqtestA() {
        Student student = new Student(1, "jiazijie-AAA", 18);
        mqProducer.sendMsg(student, QueueConfig.RK_QUEUE_TEST_A);
        return "AAA";
    }

    @RequestMapping("sendB")
    public Object mqtestB() {
        Student student = new Student(2, "jiazijie-BBB", 30);
        mqProducer.sendMsg(student, QueueConfig.RK_QUEUE_TEST_B);
        return "BBB";
    }
}
2.3 RabbitMQ配置
2.3.1 Exchange交换机配置

ExchangeConfig.java

package com.jzj.bootmqtest.config;

import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class ExchangeConfig {

    public static final String MAIN_EXCHANGE = "mainExchange";
    public static final String DEAD_EXCHANGE = "deadExchange";

    /**
     * 声明一个主题交换机，作为默认交换机 ，名字： mainExchange
     *
     * @return
     */
    @Bean(name = MAIN_EXCHANGE)
    public DirectExchange mainExchange() {
        return new DirectExchange(MAIN_EXCHANGE);
    }

    /**
     * 声明一个直连交换机、作为死亡交换机，名字deadExchange，为了方便接收消息，我们声明fanout类型，有消息就转发
     *
     * @return
     */
    @Bean(name = DEAD_EXCHANGE)
    public FanoutExchange deadExchange() {
        return new FanoutExchange(DEAD_EXCHANGE);
    }
}
2.3.2 Queue绑定信息

QueueConfig.java

package com.jzj.bootmqtest.config;

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

import java.util.HashMap;
import java.util.Map;

import static com.jzj.bootmqtest.config.ExchangeConfig.DEAD_EXCHANGE;
import static com.jzj.bootmqtest.config.ExchangeConfig.MAIN_EXCHANGE;

@Configuration
public class QueueConfig {

    public static final String QUEUE_TEST_A = "queue_test_AAA";
    public static final String RK_QUEUE_TEST_A = "rk.queue_test_AAA";

    public static final String QUEUE_TEST_B = "queue_test_BBB";
    public static final String RK_QUEUE_TEST_B = "rk.queue_test_BBB";

    @Autowired
    @Qualifier(MAIN_EXCHANGE)
    DirectExchange mainExchange;
    @Autowired
    @Qualifier(DEAD_EXCHANGE)
    FanoutExchange deadExchange;

    /**
     * 声明一个
     *
     * @return
     */
    @Bean
    @Qualifier("queueAAA")
    public Queue queueAAA() {
        //声明 队列名称及队列持久化
        return new Queue(QUEUE_TEST_A);
    }

    /**
     * 声明队列，绑定死信队列交换机参数
     */
    @Bean
    @Qualifier("queueBBB")
    public Queue queueBBB() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        args.put("x-dead-letter-routing-key", RK_QUEUE_TEST_B);
        return new Queue(QUEUE_TEST_B, true, false, false, args);
    }


    /**
     * 声明对立绑定的Exchange 及 Routingkey
     *
     * @return
     */
    @Bean
    public Binding bindingQueueTest1() {
        return BindingBuilder.bind(queueAAA()).to(mainExchange).with(RK_QUEUE_TEST_A);
    }


    /**
     * 声明队列绑定，绑定 mainExchange 及 RoutingKey
     */
    @Bean
    public Binding bindingQueueTest2() {
        return BindingBuilder.bind(queueBBB()).to(mainExchange).with(RK_QUEUE_TEST_B);
    }


    /**
     * 声明死信队列，用于接收 死信交换机过来的消息
     */
    @Bean
    @Qualifier("deadQueue")
    public Queue deadQueue() {
        return new Queue("dead_queue", true);
    }

    /**
     * 声明死信队列绑定，只要是rk开头的全都接收
     */
    @Bean
    public Binding bindingDeadQueue() {
        return BindingBuilder.bind(deadQueue()).to(deadExchange);
    }


}
2.3.3 生产者

在此rabbitmq包下，新建生产者，用基类生产者来定义MQ生产者，消息发送时候只需要注入 BaseMqConsumer就可以了
BaseMqProducer.java

package com.jzj.bootmqtest.rabbitmq;

import cn.hutool.json.JSONUtil;
import com.jzj.bootmqtest.task.SendMqTask;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.task.TaskRejectedException;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.UUID;

/**
 * <mq消息发送>.
 *
 * @author peng cheng
 * @date 2019/12/23
 * @since
 */
@Component
public class BaseMqProducer {

    private static final Logger LOGGER = LoggerFactory.getLogger(BaseMqProducer.class);

    /**
     * 最大线程数目
     */
    private static final Integer RETRY_TIMES = 50;

    /**
     * 消息优先级设置
     */
    private Integer msgPriority;


    @Autowired
    private AmqpTemplate amqpTemplate;

    @Autowired
    private ThreadPoolTaskExecutor mqSenderExecutor;

    @Autowired
    private DirectExchange mainExchange;


    /**
     * 发送消息  采用默认的交换机
     *
     * @param msg
     * @param routingKey
     */
    public void sendMsg(Object msg, String routingKey) {
        sendMsg(msg, mainExchange.getName(), routingKey);
    }


    /**
     * 发送消息 指定交换机和路由键
     *
     * @param exchange
     * @param routingKey
     * @param mqMsg
     */
    public void sendMsg(Object mqMsg, String exchange, String routingKey) {
        if (null == mqMsg) {
            return;
        }
        try {
            Message message = generateMessage(mqMsg);
            LOGGER.info("RabbitMQ sendMsg exchange={},routingKey={},messageId={},msgBody={}", exchange, routingKey, message.getMessageProperties().getMessageId(),
                    new String(message.getBody()));

            threadExecute(new SendMqTask(exchange, routingKey, message, amqpTemplate));
        } catch (AmqpException e) {
            LOGGER.error("booster-notify sendMsq failed exchange=" + exchange + ",routingKey=" + routingKey + ",mqMsg=" + JSONUtil.toJsonStr(mqMsg), e);
        }
    }


    /**
     * 消息处理
     *
     * @param msg
     * @return
     */
    public Message generateMessage(Object msg) {
        String msgBody = null;
        try {
            msgBody = JSONUtil.toJsonStr(msg);

            return MessageBuilder.withBody(msgBody.getBytes())
                    .setMessageId(UUID.randomUUID().toString())
                    .setTimestamp(new Date())
                    .setPriority(msgPriority)
                    .build();
        } catch (Exception e) {
            LOGGER.error("generateMessage error :" + e.getMessage(), e);
        }
        return null;
    }


    /**
     * thread execute
     *
     * @param
     */
    private void threadExecute(Runnable var) {
        for (int i = 0; i < RETRY_TIMES; i++) {
            try {
                mqSenderExecutor.execute(var);
                return;
            } catch (TaskRejectedException e) {
                LOGGER.error("RabbitMQ线程池满请等待，等待次数:" + i + " 错误信息:" + e.getMessage());

                // sleep 100 ms
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e2) {
                    LOGGER.error("sleep error! " + e2.getMessage(), e2);
                }
            }
        }

        mqSenderExecutor.execute(var);
    }


    public void setMsgPriority(Integer msgPriority) {
        this.msgPriority = msgPriority;
    }

}
2.3.4 消费者

我们模板设计模式、制定消费者抽象基类，所有的消费者都继承实现基类就可以了
BaseMqConsumer.java

package com.jzj.bootmqtest.rabbitmq;

import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * 封装消费者抽象类
 * 每个消费者只需要关注自己的Listener 及 消息的处理，其余的工作都放在抽象模板中做
 */
public abstract class BaseMqConsumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(BaseMqConsumer.class);

    /**
     * @param message
     * @return
     * @throws Exception
     */
    protected abstract boolean handlerMessage(Message message) throws Exception;

    /**
     * 获取消息消费异常后，重试的次数
     */
    protected abstract int initMaxRetryTimes();

    /**
     * 处理公共信息
     *
     * @param channel 通道
     * @param message 消息体
     */
    public void onMessage(Channel channel, Message message) throws Exception {
        String msgBody = new String(message.getBody(), StandardCharsets.UTF_8);
        // 获取重试次数
        final int maxRetryTimes = initMaxRetryTimes();

        String messageId = message.getMessageProperties().getMessageId();
        LOGGER.info(String.format("RabbitMQ receive msg, messageId:%s message:%s", messageId, msgBody));

        //先设置 处理结果为False
        boolean processResult = false;
        try {
            //开始处理消息
            processResult = handlerMessage(message);
        } catch (Exception e) {
            String errorMsg = e.getMessage() == null ? "" : e.getMessage();
            LOGGER.error(String.format("Rabbitmq Comsumer process error, messageId:%s,messageBody:%s, errorMsg:%s", messageId, msgBody, errorMsg), e);
        } finally {
            Long retryNum = getRetryCountFromMessage(message.getMessageProperties());
            if (retryNum > maxRetryTimes) {
                processResult = true;
                LOGGER.error(String.format("Rabbitmq 当前消息体重试操作超过[" + maxRetryTimes + "]次, 放弃重试!, messageId:%s retryNum:%s message:%s", messageId, retryNum, msgBody));
            }
            ackHandler(channel, message, processResult);
        }
    }

    protected void ackHandler(Channel channel, Message message, boolean processResult) throws IOException {
        if (processResult) {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } else {
            // 不成功, 丢到dead letter (second param true:requeue false:dead letter)
            channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
        }
    }

    private Long getRetryCountFromMessage(MessageProperties properties) {
        //此处最好把 Message中的消息ID放入Redis，用分布式锁获取Redis的值 来判断当前的MessageId来到过几次了，用来解决幂等性
        // 方便测试，后面我们测试时候，设置为3次,表示这是第3次到来，防止消息无线消费，导致CPU暴增
        return 0L;
    }

}

消费者A，对应A队列 QueueAListener.java

package com.jzj.bootmqtest.rabbitmq;


import cn.hutool.json.JSONUtil;
import com.jzj.bootmqtest.bean.Student;
import com.jzj.bootmqtest.config.QueueConfig;
import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class QueueAListener extends BaseMqConsumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(QueueAListener.class);


    /**
     * 绑定队列
     */
    @Override
    @RabbitHandler
    @RabbitListener(queues = QueueConfig.QUEUE_TEST_A)
    public void onMessage(Channel channel, Message message) throws Exception {
        super.onMessage(channel, message);
    }

    @Override
    protected int initMaxRetryTimes() {
        return 1;
    }


    @Override
    protected boolean handlerMessage(Message message) {
        boolean result = false;
        try {
            result = processSendResult(message);
        } catch (Exception e) {
            LOGGER.error("邮件消息 处理 异常 ", e);
        }
        return result;
    }

    /**
     * 解析邮件发送结果，且尝试计数
     * <p>
     * 此处 返回的都是 正确发送的消息，失败重试后 避免重新路由
     *
     * @param message 邮件消息
     * @return 处理结果
     */
    private boolean processSendResult(Message message) {

        // 解析MQ 邮件消息
        String msgBody = new String(message.getBody());

        Student msg = JSONUtil.toBean(msgBody, Student.class);
        if (null == msg) {
            LOGGER.error("转化失败 msg:{}", msgBody);
            throw new RuntimeException("邮件消息解析失败");
        }

        LOGGER.info("AAA处理消息:" + msgBody);
        return true;
    }


}

消费者B，对应B队列 QueueBListener.java

package com.jzj.bootmqtest.rabbitmq;


import cn.hutool.json.JSONUtil;
import com.jzj.bootmqtest.bean.Student;
import com.jzj.bootmqtest.config.QueueConfig;
import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class QueueBListener extends BaseMqConsumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(QueueBListener.class);


    /**
     * 绑定队列
     */
    @Override
    @RabbitHandler
    @RabbitListener(queues = QueueConfig.QUEUE_TEST_B)
    public void onMessage(Channel channel, Message message) throws Exception {
        super.onMessage(channel, message);
    }

    @Override
    protected int initMaxRetryTimes() {
        return 2;
    }


    @Override
    protected boolean handlerMessage(Message message) {
        boolean result = false;
        try {
            result = processSendResult(message);
        } catch (Exception e) {
            LOGGER.error("邮件消息 处理 异常 ", e);
        }
        return result;
    }

    /**
     * 解析邮件发送结果，且尝试计数
     * <p>
     * 此处 返回的都是 正确发送的消息，失败重试后 避免重新路由
     *
     * @param message 邮件消息
     * @return 处理结果
     */
    private boolean processSendResult(Message message) {

        // 解析MQ 邮件消息
        String msgBody = new String(message.getBody());

        Student msg = JSONUtil.toBean(msgBody, Student.class);
        if (null == msg) {
            LOGGER.error("转化失败 msg:{}", msgBody);
            throw new RuntimeException("邮件消息解析失败");
        }

        //测试异常信息，直接抛出异常
//        throw new RuntimeException("邮件消息BBB解析失败");

        LOGGER.info("BBB 处理消息:" + msgBody);
        return true;
    }


}
2.3.5 MQ任务

设计SendMqTask 用来接收MQ消息发送者的消息，实现消息的发送

package com.jzj.bootmqtest.task;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;

/**
 * 单独发送的线程
 */
public class SendMqTask implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(SendMqTask.class);

    /**
     * 交换机
     */
    private String exchange;
    /**
     * Routingkey
     */
    private String rk;
    /**
     * 发送的消息
     */
    private Message message;
    /**
     * amqpTemplate
     */
    private AmqpTemplate amqpTemplate;

    public SendMqTask(String exchange, String rk, Message message, AmqpTemplate amqpTemplate) {
        this.exchange = exchange;
        this.rk = rk;
        this.message = message;
        this.amqpTemplate = amqpTemplate;
    }


    @Override
    public void run() {
        amqpSend(exchange, rk, message);
    }

    /**
     * amqp发送封装逻辑
     *
     * @param rk
     * @param message
     */
    private void amqpSend(final String exchange, final String rk, final Message message) {
        try {
            amqpTemplate.convertAndSend(exchange, rk, message);
        } catch (AmqpException e) {
            LOGGER.info(String.format("send error!!! messageId:%s message:%s",
                    message.getMessageProperties().getMessageId(), new String(message.getBody())));
            LOGGER.error("send message error: " + e.getMessage(), e);
        }
    }
}
2.4 启动类

启动类BootmqtestApplication.java

package com.jzj.bootmqtest;

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

@SpringBootApplication
public class BootmqtestApplication {

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

}
3.启动测试
3.1 项目启动

项目成功启动
在这里插入图片描述

3.2 Rabbitmq界面

交换机信息如下：
在这里插入图片描述
3个队列信息
在这里插入图片描述

3.3 执行结果

执行Controller sendA 给A队列发一条消息 curl 127.0.0.1:9672/test/sendA
执行结果可以看到，先发送消息，然后Listener接收消息，然后处理消息，处理成功消费完毕，B队列也一样
在这里插入图片描述

3.4 异常测试
3.4.1 basicReject 拒绝测试

现在基类BaseMqConsumer中 逻辑是消息处理成功，就确认消息，不成功就Reject消息
在这里插入图片描述
而且Reject中的参数requeue是false，表明拒绝后到私信队列，我们制造个异常，让他处理失败，看看

修改B的Listener的processSendResult方法，因为B有死信队列配置，让他抛出异常，处理失败，走下面的else分支

    private boolean processSendResult(Message message) {

        // 解析MQ 邮件消息
        String msgBody = new String(message.getBody());

        Student msg = JSONUtil.toBean(msgBody, Student.class);
        if (null == msg) {
            LOGGER.error("转化失败 msg:{}", msgBody);
            throw new RuntimeException("邮件消息解析失败");
        }

        //测试异常信息，直接抛出异常
        throw new RuntimeException("邮件消息BBB解析失败");

//        LOGGER.info("BBB 处理消息:" + msgBody);
//        return true;
    }

重启项目，再次发送sendB消息，发送完、接收消息，处理失败，抛出异常
在这里插入图片描述
死信队列中接收到消息
在这里插入图片描述

3.4.2 basicReject 拒绝、重新路由测试

我们可以看到 channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
消息拒绝后是 requeue是false，表明不再路由，我们改为true看看，是否会重新路由
！！！！！！！ 注意，此处会有死循环，抛出异常->basicReject->重新路由->再次消费->再抛出异常…无限循环

    protected void ackHandler(Channel channel, Message message, boolean processResult) throws IOException {
        if (processResult) {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } else {
            // 不成功, 丢到dead letter (second param true:requeue false:dead letter)
            channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
        }
    }

重启项目再次发送B
在这里插入图片描述

我们现在把循环次数变为3尝试一下，重启，可以看到，消息消费了3次后，就自动丢弃了，不会再无限循环

    private Long getRetryCountFromMessage(MessageProperties properties) {
        //此处最好把 Message中的消息ID放入Redis，用分布式锁获取Redis的值 来判断当前的MessageId来到过几次了，用来解决幂等性
        // 方便测试，后面我们测试时候，设置为3次,表示这是第3次到来，防止消息无线消费，导致CPU暴增
        return 3L;
    }

重试结果，Rabbitmq 当前消息体重试操作超过[2]次, 放弃重试!
在这里插入图片描述

4.常见错误
4.1 reply-text=PRECONDITION_FAILED - unknown delivery tag 1

2021-04-06 21:46:41.708 ERROR 7560 — [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory : Shutdown Signal: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80)

该错误是因为 没有配置手动消息确认导致的，需要在配置文件application.yml中新增
publisher-confirm-type: correlated
publisher-returns: true
#采用手动应答方式
listener:
simple:
acknowledge-mode: manual

spring:
  #应用名称
  application:
    name: jzj-sprintboot-mqtest
  #mq配置
  rabbitmq:
    addresses: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    #开启消息确认机制 confirms
    publisher-confirm-type: correlated
    publisher-returns: true
    #采用手动应答方式
    listener:
      simple:
        acknowledge-mode: manual
4.2 spring.rabbitmq.publisher-confirms过时解决

该错误是因为 rabbitmq升级后，这对消息确认的方式变了，将原来的publisher-confirms 修改为 publisher-confirm-type 配置

    publisher-confirm-type: correlated

在这里插入图片描述

至此 我们的 Rabbitmq结合SpringBoot 简单完毕，下一节我们讲一下 批量发送消息

jzjie
关注
专栏目录
RabbitMQ 进阶 -- SpringBoot 集成 RabbitMQ实现生产者与消费者模式
m0_73311735的博客
10-28 3656
AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/不同产品，不同的开发语言等条件的限制。中的实现有等。AMQP 基于TCP协议之上再次封装的协议，
rabbitmq-server-generic-unix-3.6.1.tar
08-16
标题中的“rabbitmq-server-generic-unix-3.6.1.tar”是指RabbitMQ服务器的3.6.1版本的通用Unix安装包。RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中，用于处理异步任务、消息传递和负载均衡...
SprintBoot使用RabbitMQ
培根芝士的专栏
05-11 326
1、配置RabbitMQ 1.1、创建交换机 创建交换机的时候需要指定虚拟主机以及交换机的类型（direct（路由模式）、fanout（广播）、headers、topic） direct：Exchange通过消息携带的路由键来将消息分发到对应的队列中 fanout：Exchange将消息分发到所有绑定到交换机的队列中 headers：Exchange通过判断消息头的值是否与绑定的值相匹配来分发消息 x-match为any时，消息头的任意一个值匹配就可以满足条件 x-match为all时，消息头的
SpringBoot RabbitMQ 入门学习（详细）
qq_37280924的博客
05-25 1581
目录安装 RabbitMQ初始化 SpringBoot 项目导入依赖添加配置配置文件 application.yml添加配置类 RabbitMqConfig简单队列发送者消费者测试类测试的 Controller单元测试类运行路由（交换机）创建一个交换机（Exchange）交换机与队列的绑定Topic Exchange修改 `Sender` 类的 `send` 方法测试Headers Exchange 自定义规则Fanout Exchange 订阅模式创建订阅交换机消失丢失开启RabbitMQ的数据持久化参考
关于springboot在对rabbitMq队列做监听时，队列初始化的一些方式
我迷了鹿
07-16 2434
springboot rabbitMq队列初始化方法有多种方式这里列出4种 1.使用注解@Bean与类Queue单一队列初始化 如下 /** *若队列不存在创建队列第二个参数为是否持久化 * *@return */ @Bean publicQueueQueue1(){ returnnewQueue(队列名,false); } ...
springboot~rabbitmq的队列初始化和绑定
weixin_33806914的博客
10-03 3782
配置文件，在rabbit中自动建立exchange,queue和绑定它们的关系 代码里初始化exchange 代码里初始化queue 代码里绑定exchange,queue和routekey 配置文件，直接声明vhost 代码里初始化exchange /** * rabbitMq里初始化exchange. * * @return */ @Bean publ...
RabbitMQ(三) RabbitMQ高级整合应用
盲目的拾荒者的博客
06-04 1645
RabbitMQ整合Spring AMQP实战 常用组件介绍 RabbitAdmin Spring AMQP声明 通过@Bean注解进行声明 RabbitTemplate SimpleMessageListenerContainer 对消息消费进行详细配置和优化 MessageListenerAdapter 消息监听适配器，建立在监听器基础之上 MessageConverter RabbitAdmin RabbitAdmin类可以很好的操作RabbitMQ，在Sprin
RabbitMQ实战-多线程-springboot-rabbit.zip
11-07
在本项目"RabbitMQ实战-多线程-springboot-rabbit.zip"中，我们将深入探讨如何使用RabbitMQ作为消息中间件，结合Spring Boot框架和多线程技术来实现高效、可扩展的分布式系统。Spring Boot简化了RabbitMQ的集成，而...
rabbitmq-server-3.12.13-1.el8.noarch.rpm
最新发布
02-22
rabbitmq-server-3.12.13-1.el8.noarch.rpm下载，支持RPM for RHEL Linux 8.x and 9.x, CentOS Stream 8 and 9, Fedora 35+, Amazon Linux 2023, Rocky Linux, Alma Linux
rabbitmq-server-generic-unix-3.5.7.tar.rar下载，rabbitmq安装包
08-20
- 首先，您需要在Windows上使用RAR解压工具解压“rabbitmq-server-generic-unix-3.5.7.tar.gz”文件，得到解压后的tar文件。 - 接着，将解压后的文件通过FTP或SCP等工具上传到您的Linux服务器。 - 在Linux服务器...
Channel shutdown: channel error; protocol method 错误处理
热门推荐
圣人男的博客
02-28 4万+
错误信息 Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - inequivalent arg 'type' for exchange 'kxg-fanout' in vhost '/': r...
SpringBoot整合RabbitMQ——消息的发送和接收
Amos技术足迹
07-03 6811
上篇博文我们整理了RabbitMQ的交换机、队列以及路由绑定等相关知识，并且了解了RabbitMQ是如何发送消息给队列的，以及重要的RoutingKey等重要知识点，这篇博文我们来重点了解下RabbitMQ是如何发送消息，消费消息的，本片博文我们还是以代码为主，简要说明为辅，同时对消息的发送和接收功能进行简单的封装，可以作为一个jar包给第三方进行使用。 本博文是在上一篇博文《SpringBo...
spring boot集成rabbitMQ及绑定死信队列
小新-shawn的博客
04-18 2180
rabbitMQ的安装和搭建spring boot项目百度一下有很多，就不介绍了； 直接开始在spring boot项目中去集成 MQ： 这里版本号可以不填，默认使用的是spring boot的版本； 首先是pom.xml中添加： <dependency> <groupId>org.springframework.boot</groupId> ...
Rabbitmq同时处理多个消息（多线程）
lmchhh的博客
09-19 6244
Rabbitmq同时处理多个消息（多线程） 文章目录Rabbitmq同时处理多个消息（多线程）一， 失败不重试，直接确认二， 失败重试5次，再直接确认 basicQos预取方法参数解析 basicQos(int prefetchCount) basicQos(int prefetchCount, boolean global) basicQos(int prefetchSize, int prefetchCount, boolean global) 参数： prefetchSize：可接收消息的大
(转)rabbitmq.config详细配置参数
weixin_30776545的博客
05-16 681
rabbitmq.config详细配置参数 Key Documentation tcp_listeners 用于监听 AMQP连接的端口列表(无SSL). 可以包含整数 (即"监听所有接口")或者元组如{"127.0.0.1", 5672}用于监听一个或多个接口. Default:[5672] ...
RabbitMQ(四) --消费者Consumer
知识点滴
09-18 4810
一：摘要概述 经过前面三篇文章的学习，对于RabbitMQ中间件应该处于拨开云雾见青天阶段。本文将趁热打铁，完善RabbitMQ基础应用最后一个消费版块。当然文中会持续深入讲解有关消息分发、消费端确认等中阶特性 二：消息消费 MQ队列可以理解为物品寄存中心，放进去总要拿出来用，一直放着没有利息还会持久增加成本引发系列问题。MQ存储的消息使用有两种途径，RabbitMQ服务推送、消费者客户端拉取 2...
RabbitMQ之basicConsume、basicCancel、basicPublish等方法详解
OceanSky的专栏
10-19 2万+
最新版5.7.3提供了20个basicConsume消费方法，这些方法是由服务端主动PUSH消息过来，方法接收到消息后进行处理；而每个方法处理接收到的消息相差不大，下面详细介绍每个方法的参数详情； 1.String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallbac...
RabbitMQ：@RabbitListener 与 @RabbitHandler 及 消息序列化
u012794845的专栏
09-27 3905
添加 @RabbitListener 注解来指定某方法作为消息消费的方法，例如监听某 Queue 里面的消息 MessageConvert 涉及网络传输的应用序列化不可避免，发送端以某种规则将消息转成 byte 数组进行发送，接收端则以约定的规则进行 byte[] 数组的解析 RabbitMQ 的序列化是指 Message 的 body 属性，即我们真正需要传输的内容，RabbitMQ 抽象出一个 MessageConvert 接口处理消息的序列化，其实现有 SimpleMessageConverter
RocketMQ原理解析－Consumer
aikuangchou2298的博客
11-11 347
consumer 1.启动 有别于其他消息中间件由broker做负载均衡并主动向consumer投递消息，RocketMq是基于拉模式拉取消息，consumer做负载均衡并通过长轮询向broker拉消息。 Consumer消费拉取的消息的方式有两种 1. Push方式：rocketmq已经提供了很全面的实现，consumer通过长轮询拉取消息后回调MessageL...
RabbitMQ死信交换机实现定时任务：Springboot集成实例
RabbitMQ是一种开源的消息代理，它在分布式系统中广泛用于异步通信和消息传递。本文将探讨如何利用RabbitMQ的特点来...如果你对RabbitMQ集成、死信交换机或Spring Boot使用有疑问，可以参考之前的相关文章来深入了解。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值