springBoot使用rabbitmq并保证消息可靠性

已于 2023-04-06 15:30:26 修改
阅读量2.6k 收藏 31
点赞数 8
分类专栏： 零零散散 MQ 文章标签： java-rabbitmq rabbitmq spring boot
于 2023-01-04 09:42:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38263083/article/details/128530631
版权

一、理论说明

1.1、数据的丢失问题，可能出现在生产者、MQ、消费者中

1、如下图
在这里插入图片描述

1.2、生产者弄丢了数据

1、生产者将数据发送到 RabbitMQ 的时候，可能数据就在半路给搞丢了，因为网络问题啥的，都有可能。此时可以选择用RabbitMQ 提供的事务功能，就是生产者发送数据之前开启 RabbitMQ 事务channel.txSelect ，然后发送消息，如果消息没有成功RabbitMQ 接收到，那么生产者会收到异常报错，此时就可以回滚事务 channel.txRollback ，然后重试发送消息；如果收到了消息，那么可以提交事务 channel.txCommit
在这里插入图片描述
2、但是问题是，RabbitMQ 事务机制（同步）一搞，基本上吞吐量会下来，因为太耗性能。所以一般来说，如果你要确保说 RabbitMQ 的消息别丢，可以开启 confirm 模式，在生产者那里设置开启 confirm 模式之后，你每次写的消息都会分配一个唯一的 id，然后如果写入了 RabbitMQ 中，RabbitMQ 会给你回传一个 ack 消息，告诉你说这个消息 ok 了。

3、如果RabbitMQ 没能处理这个消息，会回调你的一个 nack 接口，告诉你这个消息接收失败，你可以重试。而且你可以结合这个机制自己在内存里维护每个消息 id 的状态，如果超过一定时间还没接收到这个消息的回调，那么你可以重发。

4、事务机制和 confirm 机制最大的不同在于，事务机制是同步的，你提交一个事务之后会阻塞在那儿，但是 confirm 机制是异步的，你发送个消息之后就可以发送下一个消息，然后那个消息 RabbitMQ 接收了之后会异步回调你的一个接口通知你这个消息接收到了。所以一般在生产者这块避免数据丢失，都是用 confirm 机制的。

1.3、RabbitMQ 弄丢了数据

1、就是 RabbitMQ 自己弄丢了数据，这个你必须开启 RabbitMQ 的持久化，就是消息写入之后会持久化到磁盘，哪怕RabbitMQ 自己挂了，恢复之后会自动读取之前存储的数据，一般数据不会丢。除非极其罕见的是，RabbitMQ 还没持久化，自己就挂了，可能导致少量数据丢失，但是这个概率较小。

设置持久化有两个步骤：

  • 创建 queue 的时候将其设置为持久化

这样就可以保证 RabbitMQ 持久化 queue 的元数据，但是它是不会持久化 queue 里的数据的。

  • 第二个是发送消息的时候将消息的 deliveryMode 设置为 2

就是将消息设置为持久化，此时 RabbitMQ 就会将消息持久化到磁盘上去。

2、必须要同时设置这两个持久化才行，RabbitMQ 哪怕是挂了，再次重启，也会从磁盘上重启恢复queue，恢复这个 queue 里的数据。注意，哪怕是你给 RabbitMQ 开启了持久化机制，也有一种可能，就是这个消息写到了RabbitMQ 中，但是还没来得及持久化到磁盘上，结果不巧，此时 RabbitMQ 挂了，就会导致内存里的一点点数据丢失。所以，持久化可以跟生产者那边的 confirm 机制配合起来，只有消息被持久化到磁盘之后，才会通知生产者 ack 了，所以哪怕是在持久化到磁盘之前，RabbitMQ 挂了，数据丢了，生产者收不到 ack ，你也是可以自己重发的

1.4、消费端弄丢了数据

RabbitMQ 如果丢失了数据，主要是因为你消费的时候，刚消费到，自己还没处理，结果自己的进程挂了，比如重启了，那么就尴尬了，RabbitMQ 认为你都消费了，这数据就丢了。这个时候得用 RabbitMQ 提供的 ack 机制，简单来说，就是你必须关闭 RabbitMQ 的自动 ack ，可以通过一个 api 来调用就行，然后每次你自己代码里确保处理完的时候，再在程序里 ack 一把。这样的话，如果你还没处理完，不就没有 ack 了？那 RabbitMQ 就认为你还没处理完，这个时候 RabbitMQ 会把这个消费分配给别的 consumer 去处理，消息是不会丢的。

1.5、总结

在这里插入图片描述

二、结合springBoot并保证消息可靠性

1、模拟业务，我们希望会员服务在多个实例的情况下，每个实例只需要收到一次消息

在这里插入图片描述

2、项目结构
在这里插入图片描述

3、生产者和消费者引入pom依赖

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

4、生产者和消费者配置rabbitmq信息

spring:
  # rabbitmq 配置信息
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest

2.1、保证生产者到rabbitmq阶段消息投递的安全

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

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

2、我们先来了解一下 rabbitmq 整个消息投递的路径，如下：

producer—>rabbitmq broker—>exchange—>queue—>consumer

3、消息从 producer 到 exchange 则会返回一个 confirmCallback 。

4、消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。

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

2.1.1、【生产者】开启confirm和return 配置

1、在配置文件中直接开启即可

spring:
  # rabbitmq 配置信息
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    #1、确保消息从发送端到服务端投递可靠（分为以下两个步骤）
    #1.1、确认消息已发送到交换机(Exchange) 可以把publisher-confirms: true 替换为  publisher-confirm-type: correlate
    publisher-confirm-type: correlated
    #1.2、确认消息从交换机中到队列中
    publisher-returns: true

在这里插入图片描述

2.1.2、【生产者】配置交换器，队列，以及routingKey三件套

1、生产者项目结构

在这里插入图片描述

2、DirectRabbitConfig 这里根据前面的需求，我们创建Direct类型的交换器即可，至于其他类型的交换器以及区别，后面有说明

package cn.gxm.producer.config;

import lombok.extern.slf4j.Slf4j;
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;

/**
 * @author GXM
 * @version 1.0.0
 * @Description 创建direct类型的交换机
 * @createTime 2023年01月03日
 */
@Slf4j
@Configuration
public class DirectRabbitConfig {


    private static final String QUEUE = "TestDirectQueue";
    private static final String EXCHANGE = "TestDirectExchange";
    private static final String ROUTING_KEY = "TestDirectRouting";

    /**
     * 创建一个名为TestDirectQueue的队列
     *
     * @return
     */
    @Bean
    public Queue testDirectQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，有消息者订阅本队列，然后所有消费者都解除订阅此队列，会自动删除。
        // arguments：队列携带的参数，比如设置队列的死信队列，消息的过期时间等等。
        return new Queue(QUEUE, true);
    }

    /**
     * 创建一个名为TestDirectExchange的Direct类型的交换机
     *
     * @return
     */
    @Bean
    public DirectExchange testDirectExchange() {
        // durable:是否持久化,默认是false,持久化交换机。
        // autoDelete:是否自动删除，交换机先有队列或者其他交换机绑定的时候，然后当该交换机没有队列或其他交换机绑定的时候，会自动删除。
        // arguments：交换机设置的参数，比如设置交换机的备用交换机（Alternate Exchange），当消息不能被路由到该交换机绑定的队列上时，会自动路由到备用交换机
        return new DirectExchange(EXCHANGE, true, false);
    }

    /**
     * 绑定交换机和队列
     *
     * @return
     */
    @Bean
    public Binding bindingDirect() {
        //bind队列to交换机中with路由key（routing key）
        return BindingBuilder.bind(testDirectQueue()).to(testDirectExchange()).with(ROUTING_KEY);
    }
}

3、RabbitTemplate配置配置，这里有一个点非常重要，

  • rabbitTemplate.setMandatory(true);必须得设置成true，否则无法回调ReturnsCallback。
  • Mandatory：为true时,消息通过交换器无法匹配到队列会返回给生产者 并触发MessageReturn，而为false时,匹配不到会直接被丢弃
  • 如果配置了发送回调ReturnCallback，插件延迟队列则会回调该方法，因为发送方确实没有投递到队列上，只是在交换器上暂存，等过期时间到了 才会发往队列。并非是BUG，而是有原因的，建议利用if 去拦截这个异常，判断延迟队列交换机名称，然后break;
package cn.gxm.producer.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@Configuration
public class RabbitConfig {

    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);

        //设置消息投递失败的策略，有两种策略：自动删除或返回到客户端。
        //我们既然要做可靠性，当然是设置为返回到客户端(true是返回客户端，false是自动删除)
        rabbitTemplate.setMandatory(true);

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack) {
                    log.info("ConfirmCallback 关联数据：{},投递成功,确认情况：{}", correlationData, ack);
                } else {
                    log.info("ConfirmCallback 关联数据：{},投递失败,确认情况：{}，原因：{}", correlationData, ack, cause);
                }
            }
        });

        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returnedMessage) {
                // 请注意!如果你使用了延迟队列插件，那么一定会调用该callback方法，因为数据并没有提交上去，
                // 而是提交在交换器中，过期时间到了才提交上去，并非是bug！你可以用if进行判断交换机名称来捕捉该报错
                if (exchange.equals("你声明的延迟队列的交换机")) {
                    return;
                }
                log.info("ReturnsCallback 消息：{},回应码：{},回应信息：{},交换机：{},路由键：{}"
                        , returnedMessage.getMessage(), returnedMessage.getReplyCode()
                        , returnedMessage.getReplyText(), returnedMessage.getExchange()
                        , returnedMessage.getRoutingKey());
            }
        });

        return rabbitTemplate;
    }
}

4、写一个TestController，用作消息发送，一共发送5条消息，其中一条触发confirmCallback的失败，一条触发returnCallback，但是五条都会触发confirmCallback，他们的关系是并行的.

package cn.gxm.producer.controller;

import cn.gxm.producer.vo.User;
import com.alibaba.fastjson.JSON;
import org.springframework.amqp.rabbit.connection.CorrelationData;
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;

import java.util.UUID;

/**
 * @author GXM
 * @version 1.0.0
 * @Description TODO
 * @createTime 2023年01月03日
 */
@RestController
public class TestController {

    @Autowired
    RabbitTemplate rabbitTemplate;


    @GetMapping("/test")
    public String test() {
        return "producer ok";
    }

    @GetMapping("/push")
    public String push() {
        for (int i = 1; i <= 5; i++) {
            //这个参数是用来做消息的唯一标识
            //发布消息时使用，存储在消息的headers中
            User user = new User(i, "汪涵");
            // 关联的数据，可以用在消息投递失败的时候，作为一个线索，比如我把当前用户的id放进去，如果user消息投递失败
            // 我后面可以根据id再找到user，再次投递数据
            CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString().concat("-") + i);
            if (i == 2) {
                //故意把交换机写错，演示 confirmCallback
                rabbitTemplate.convertAndSend("TestDirectExchange_111", "TestDirectRouting",
                        JSON.toJSONString(user), correlationData);
            } else if (i == 3) {
                //故意把路由键写错，演示 returnCallback
                rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting_111",
                        JSON.toJSONString(user), correlationData);
            } else {
                //正常发送
                rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting",
                        JSON.toJSONString(user), correlationData);
            }
        }
        return "producer push ok";
    }
}

5、开始请求测试，打印日志如下，你会发现，和测试controller的注释写的一样，这里就不再多说了。

2023-01-03 16:34:14.912  INFO 27080 --- [nio-6072-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2023-01-03 16:34:14.912  INFO 27080 --- [nio-6072-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2023-01-03 16:34:14.913  INFO 27080 --- [nio-6072-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
2023-01-03 16:34:14.975  INFO 27080 --- [nio-6072-exec-1] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [127.0.0.1:5672]
2023-01-03 16:34:14.992  INFO 27080 --- [nio-6072-exec-1] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory#5f95f1e1:0/SimpleConnection@12b7544d [delegate=amqp://guest@127.0.0.1:5672/, localPort= 63178]
2023-01-03 16:34:15.020 ERROR 27080 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory       : Shutdown Signal: channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'TestDirectExchange_111' in vhost '/', class-id=60, method-id=40)
2023-01-03 16:34:15.022  INFO 27080 --- [nectionFactory2] cn.gxm.producer.config.RabbitConfig      : ConfirmCallback 关联数据：CorrelationData [id=0ba3b21e-e4fc-44cf-84d7-17461c8c9c18-1],投递成功,确认情况：true
2023-01-03 16:34:15.022  INFO 27080 --- [nectionFactory3] cn.gxm.producer.config.RabbitConfig      : ConfirmCallback 关联数据：CorrelationData [id=54c62476-6847-4193-8f11-2a3efd90c284-2],投递失败,确认情况：false，原因：channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'TestDirectExchange_111' in vhost '/', class-id=60, method-id=40)
2023-01-03 16:34:15.023  INFO 27080 --- [nectionFactory3] cn.gxm.producer.config.RabbitConfig      : ReturnsCallback 消息：(Body:'{"id":3,"name":"汪涵"}' MessageProperties [headers={spring_returned_message_correlation=d91bb792-b6b0-4bea-a909-6eb8d0997b74-3}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0]),回应码：312,回应信息：NO_ROUTE,交换机：TestDirectExchange,路由键：TestDirectRouting_111
2023-01-03 16:34:15.024  INFO 27080 --- [nectionFactory2] cn.gxm.producer.config.RabbitConfig      : ConfirmCallback 关联数据：CorrelationData [id=d91bb792-b6b0-4bea-a909-6eb8d0997b74-3],投递成功,确认情况：true
2023-01-03 16:34:15.025  INFO 27080 --- [nectionFactory2] cn.gxm.producer.config.RabbitConfig      : ConfirmCallback 关联数据：CorrelationData [id=70852973-9d21-49a4-aa07-67ca8f11aed8-4],投递成功,确认情况：true
2023-01-03 16:34:15.026  INFO 27080 --- [nectionFactory2] cn.gxm.producer.config.RabbitConfig      : ConfirmCallback 关联数据：CorrelationData [id=9dc23013-5b97-47b4-8ebf-3f842615c2f7-5],投递成功,确认情况：true

6、因为我们此刻是没有启动消费者的，所以，在控制台是能看到三条数据的，id为2和id为3的数据是有问题的，都分别通过confirmCallback和returnCallback来进行回调了，则具体的补偿措施，可以根据自身的业务来处理。

在这里插入图片描述

2.2、保证rabbitmq阶段消息存储的安全

1、这个阶段我们只要保证队列，交换机，以及发送数据的持久化就🆗。

  • 队列持久化，第二个持久化的参数为true即可，即使rabbitmq重启，这个队列还是存在的
/**
     * 创建一个名为TestDirectQueue的队列
     *
     * @return
     */
    @Bean
    public Queue testDirectQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，有消息者订阅本队列，然后所有消费者都解除订阅此队列，会自动删除。
        // arguments：队列携带的参数，比如设置队列的死信队列，消息的过期时间等等。
        return new Queue(QUEUE, true);
    }
  • 交换机持久化，第二个持久化的参数为true即可，即使rabbitmq重启，这个交换机还是存在的
/**
     * 创建一个名为TestDirectExchange的Direct类型的交换机
     *
     * @return
     */
    @Bean
    public DirectExchange testDirectExchange() {
        // durable:是否持久化,默认是false,持久化交换机。
        // autoDelete:是否自动删除，交换机先有队列或者其他交换机绑定的时候，然后当该交换机没有队列或其他交换机绑定的时候，会自动删除。
        // arguments：交换机设置的参数，比如设置交换机的备用交换机（Alternate Exchange），当消息不能被路由到该交换机绑定的队列上时，会自动路由到备用交换机
        return new DirectExchange(EXCHANGE, true, false);
    }
  • 数据持久化，如果你使用原生方式，设置deliveryMode参数为2即可
//消息持久化测试
Builder builder = new Builder();
builder.deliveryMode(2);
BasicProperties properties = builder.build();
channel.basicPublish("", queue_name, properties, string.getBytes());

其中针对BasicProperties中的源码信息为：

public static class BasicProperties extends
com.rabbitmq.client.impl.AMQBasicProperties {
        private String contentType;//消息类型如：text/plain
        private String contentEncoding;//编码
        private Map<String,Object> headers;
        private Integer deliveryMode;//1:nonpersistent 不持久 2:persistent 持久
        private Integer priority;//优先级
        private String correlationId;
        private String replyTo;//反馈队列
        private String expiration;//expiration到期时间
        private String messageId;
        private Date timestamp;
        private String type;
        private String userId;
        private String appId;
        private String clusterId;
...

而我们如果使用springBoot的RabbitTemplate，则默认会进行数据持久化，具体springBoot的持久化封装，可以查看文章 Springboot 2.x ——RabbitTemplate为什么会默认消息持久化？ 所以，如下发送数据，会默认执行数据持久化

rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting",
                        JSON.toJSONString(user), correlationData);

2.3、保证消费端消费数据

1、根据前面的分析，我们在消费端，只需要手动ACK即可，这样就能保证消费端的数据可靠性了

2、消息确认模式有：

  • AcknowledgeMode.NONE：自动确认
  • AcknowledgeMode.AUTO：根据情况确认
  • AcknowledgeMode.MANUAL：手动确认

2.3.1、【消费者】开启手动ack模式

  • 默认情况下消息消费者是自动 ack （确认）消息的，如果要手动 ack（确认）则需要修改确认模式为 manual

如果设置了自动应答，又进行手动应答，会出现 double ack，那么程序会报错。
注意这里使用的是simplet的，其实还有direct的，simple主要包括两种工作模式，direct主要包括四种，根据你的使用模式来选择配置即可

在这里插入图片描述

spring:
  rabbitmq:
    listener:
      simple:
        acknowledge-mode: manual
  • 或在 RabbitListenerContainerFactory 中进行开启手动 ack
@Bean
public RabbitListenerContainerFactory<?> rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory);
    factory.setMessageConverter(new Jackson2JsonMessageConverter());
    factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);             //开启手动 ack
    return factory;
}
  • 最后可以手动确认消息，以下两种方式都可以
@RabbitHandler
public void processMessage2(String message,Channel channel,@Header(AmqpHeaders.DELIVERY_TAG) long tag) {
    System.out.println(message);
    try {
        channel.basicAck(tag,false);            // 确认消息
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@RabbitListener(queues = "TestDirectQueue")
@Component
@Slf4j
public class DirectConsumer {

    @RabbitHandler
    public void process(Object data, Channel channel, Message message) throws IOException {
        log.info("消费者接受到的消息是：{},消息体为：{}", data, message);
        //由于配置设置了手动应答，所以这里要进行一个手动应答。注意：如果设置了自动应答，这里又进行手动应答，会出现double ack，那么程序会报错。
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

  • 需要注意的 basicAck 方法需要传递两个参数

    • deliveryTag（唯一标识 ID）：当一个消费者向 RabbitMQ 注册后，会建立起一个 Channel ，RabbitMQ 会用 basic.deliver 方法向消费者推送消息，这个方法携带了一个 delivery tag， 它代表了 RabbitMQ 向该 Channel 投递的这条消息的唯一标识 ID，是一个单调递增的正整数，delivery tag 的范围仅限于 Channel

    • multiple：为了减少网络流量，手动确认可以被批处理，当该参数为 true 时，则可以一次性确认 delivery_tag 小于等于传入值的所有消息

2.3.2、【消费者】开启ack后拒绝消息 nack

1、以下示例表示了，如果header中没有error字段，我们则否认消息，不接受消息，而一旦该消息被 nack 后，则该消息会一直重新入队列然后一直重新消费，所以这个很重要，我们最好设置重试的次数，不然消息一直nack，一直重复消费，如果消息一直在累加，则会越来越多的无法消费的数据，最终会拖垮rabbitmq。

也可以拒绝该消息，消息会被丢弃，不会重回队列,这样就会避免上述拖垮rabbitmq的情况出现
channel.basicReject((Long)map.get(AmqpHeaders.DELIVERY_TAG),false); //拒绝消息

@RabbitHandler
public void processMessage2(String message, Channel channel,@Headers Map<String,Object> map) {
    System.out.println(message);
    if (map.get("error")!= null){
        System.out.println("错误的消息");
        try {
            channel.basicNack((Long)map.get(AmqpHeaders.DELIVERY_TAG),false,true);      //否认消息
            return;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    try {
        channel.basicAck((Long)map.get(AmqpHeaders.DELIVERY_TAG),false);            //确认消息
    } catch (IOException e) {
        e.printStackTrace();
    }
}

在这里插入图片描述

在这里插入图片描述

三、Exchange的三种模式：Direct，Fanout，Topic。

1、可以参考 Springboot+RabbitMq整合使用（含配置详解等）

总结：

在Exchange中，有三种模式：Direct，Fanout，Topic。

  • Direct模式只会将消息转发到符合绑定routing key的队列中，如果没有符合routing key的队列，那么消息会丢失。而且Direct发送的消息是唯一的，也就是说再Direct中的一个消息，最后只会发送到一个队列中被消费。

  • Fanout模式会无视routing key，会把消息转发到所有绑定到该交换机上的队列中。所以Fanout中的一个消息，会转发到所有的队列中，也就是如果绑定了多个队列，那么一个相同的消息会在多个队列中。

  • Topic模式有一套转发的routing key规则，只会把消息转发到符合routing key 的队列中。所以在Topic中的一个消息有可能也会被转发到多个队列中进行消费。

四、注意消息模式是广播还是工作队列

1、消息广播，和我们平时说的“广播”意思差不多，就是希望同一条消息，不同消费者都能分别消费；而队列模式，就是不同消费者共享消费同一个队列的数据，相同消息只能被某一个消费者消费一次。

2、比如，同一个用户的注册消息，会员服务需要监听以发送欢迎短信，营销服务同样需要监听以发送新用户小礼物。但是，会员服务、营销服务都可能有多个实例，我们期望的是同一个用户的消息，可以同时广播给不同的服务（广播模式），但对于同一个服务的不同实例（比如会员服务 1 和会员服务 2），不管哪个实例来处理，处理一次即可（工作队列模式）：

在这里插入图片描述

3、可以参考文章 异步处理好用，但非常容易用错

灵泽~
关注
  • 8
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
RabbitMQ笔记(五)-RabbitTemplate
yingziisme的博客
01-13 3万+
使用RabbitTemplate进行收发消息将十分的方便 首先配置bean @Bean public RabbitTemplate rabbitTemplate(CachingConnectionFactory factory){ log.info(&quot;caching factory: {}&quot;, factory.getChannelCacheSize()); ...
「中间件」你会确保rabbitmq 的消息不丢失以及不重复吗
2301_79528833的博客
09-05 175
通过上述的步骤，我们可以确保RabbitMQ和Spring Boot之间的消息传递是可靠、安全和高效的。虽然这些步骤会增加我们的开发成本，但是它们是实现分布式系统的必要手段。在实际生产环境中，我们应该根据实际需求进行选择和调整，以达到最优的性能和可靠性。
RabbitTemplate的创建与配置
qq_37436172的博客
04-05 3679
RabbitTemplate是我们在与SpringAMQP整合的时候进行发送消息的关键类该类提供了丰富的发送消息的方法，包括可靠性消息投递、回调监听消息接口ConfirmCallback、返回值确认接口ReturnCallback等等同样我们需要注入到Spring容器中，然后直接使用。在与spring整合时需要实例化，但是在与Springboot整合时，只需要添加配置文件即可首先将其注入到bean里面：如果自己不注入。
RabbitMQ三、springboot整合rabbitmq（消息可靠性、高级特性）
最新发布
学习笔记
06-01 1100
主要对rabbitmq的消息可靠性、高级特性进行阐述说了，理解rabbitmq的用法
Spring Boot 中的 RabbitTemplate 是什么，原理，如何使用
it_xushixiong的博客
07-01 2773
本文介绍了 RabbitTemplate 的原理、使用方法和常见应用场景。RabbitTemplate 是 Spring Boot 应用程序中与 RabbitMQ 集成的关键组件，它封装了 AMQP 协议的细节，提供了简单的 API 来进行消息发送和接收。通过本文的介绍，读者可以了解 RabbitTemplate 的基本原理和使用方法，并在实际项目中使用 RabbitTemplate 实现异步任务处理和发布订阅模式等应用场景。
转载----消息模板-RabbitTemplate
Jjw的博客
04-10 4151
消息模板-RabbitTemplate RabbitTemplate是我们在与SpringAMQP整合的时候进行发送消息的关键类 该类提供了丰富的发送消息的方法，包括可靠性消息投递、回调监听消息接口ConfirmCallback、返回值确认接口 ReturnCallback等等同样我们需要注入到Spring容器中，然后直接使用。 在与spring整合时需要实例化，但是在与Springboot整合时，只需要添加配置文件即可 首先将其注入到bean里面： @Bean public RabbitTemp
Rabbittemplate所有方法.简介.
LLL778888的博客
04-28 2743
csdn的chatgpt
Springboot实战16 消息驱动：如何使用 RabbitTemplate 集成 RabbitMQ？
sucaiwa的博客
04-09 1605
15 讲我们介绍了基于 ActiveMQ 和 JmsTemplate 实现消息发送和消费，并重构了 SpringCSS 案例系统中的 account-service 和 customer-service 服务。今天，我们将介绍另一款主流的消息中间件 RabbitMQ，并基于 RabbitTemplate 模板工具类为 SpringCSS 案例添加对应的消息通信机制。
springboot整合stream使用rabbitmq作为消息中间件
12-13
在实际开发中，使用Spring Boot Stream和RabbitMQ的组合可以极大地提升微服务架构的灵活性和可靠性，通过解耦各个服务，使得系统能够更好地扩展和维护。文件名"stream"可能包含的就是关于这个整合过程的代码示例或者...
springboot整合rabbitmq，开启手工确认。保证消息100%投递
09-16
下面将详细解释如何在Spring Boot中配置RabbitMQ，并启用手动确认机制来增强消息的可靠性。 首先，我们需要在Spring Boot项目中引入RabbitMQ的相关依赖。这通常通过在`pom.xml`或`build.gradle`文件中添加Spring ...
Springboot+RabbitMQ 消息中间件
04-16
在IT行业中，消息中间件是实现系统间异步通信、...结合Redis的消息补偿机制，能够进一步增强消息的可靠性，确保数据的完整传输。在实际开发中，我们需要根据业务需求灵活运用这些技术，构建出稳定、高效的分布式系统。
springboot+rabbitmq
03-21
本项目结合了这两个技术，提供了队列（Queue）、主题（Topic）和广播（Fanout）模式的示例，帮助学习者理解如何在Spring Boot应用中集成并使用RabbitMQ进行消息传递。 首先，让我们深入了解一下Spring Boot。Spring...
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它...通过理解并熟练运用上述知识点，可以有效地提升系统的可扩展性和可靠性。在实际开发中，根据具体需求灵活配置和设计消息模型，能够更好地发挥RabbitMQ的优势。
消息驱动：如何使用 Rabbit Template 集成 RabbitMQ？
我乐了的博客
02-04 1392
上图中，不同的路由算法存在不同的 Exchange 类型，而 AMQP 规范中指定了直接式交换器（Direct Exchange）、广播式交换器（Fanout Exchange）、主题式交换器（Topic Exchange）和消息头式交换器（Header Exchange）这几种 Exchange 类型，不过这一讲我们将重点介绍直接式交换器。消息中包含一个路由键（Routing Key），它由消息发送者产生，并提供给 Exchange 路由这条消息的标准。
SpringBoot实践RabbitMQ小结：RabbitTemplate消息可靠性投递、死信队列使用
qq_39198749的博客
06-25 2057
1. 引入依赖 <!--rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2. RabbitMQ配置 Spring
SpringBoot学习之路---使用RabbitTemplate操作RabbitMq
热门推荐
LeslieLau的博客
04-28 2万+
在学习了RabbitMq之后，我们知道当打开RabbitMq服务时，访问15672端口可以进入web管理界面，并且可以在里面操作，如发送消息，从某个队列中接受消息。但是我们平时在程序实际运行中，不可能一直手动地来完成这些操作(因为我们不知道什么时候需要发送接受消息，而且这样效率很低)。在基于消息队列的程序中，我们需要编写程序来完成从消息队列自动收发消息的操作，这一篇就来记录怎么使用java来完成这...
RabbitTemplate ：简化与 RabbitMQ 消息代理的交互
wddblog的博客
03-22 998
是 Spring AMQP 提供的一个高级消息模板，它封装了与 RabbitMQ 服务器交互的底层细节，使得开发者能够以一种更加声明式的方式发送和接收消息。通过，我们可以发送消息到指定的交换机和队列，也可以从队列中接收消息。是 Spring AMQP 中一个非常重要的类，它简化了与 RabbitMQ 消息代理的交互过程，使得开发者能够更加方便地发送和接收消息。通过合理配置和使用，我们可以构建高效、可靠的消息传递系统，以满足各种业务场景的需求。
rabbitmq的发布确认和事务
weixin_34409741的博客
05-06 411
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringBoot集成RabbitMQ---保证消息可靠性
xiaoping__的博客
04-29 2344
SpringBoot集成RabbitMQ—保证消息可靠性 在我们使用RabbitMQ消息队列时，使用生产者发送消息，可能出现发送失败，rabbitMQ宕机，一个消息重复发送等问题，一旦出现这种问题，如果不进行相应处理，就可能导致消息丢失，消费者重复消费一条信息等问题，消息就变得不可靠了，进而影响我们的业务逻辑。所以我们要对可能出现的问题进行相应的操作，来保证消息的可靠性。下面我们来介绍在生产端实现消息可靠性投递，消费端幂等性操作两种实现方式。 本篇文章是springboot集成RabbitMQ中保证消息可靠
springboot rabbitmq可靠性
08-15
在Spring Boot中使用RabbitMQ，可以通过几种方式来提高消息传递的可靠性。 首先，可以配置发送确认模式来确保生产者到RabbitMQ阶段的消息投递的安全。可以通过修改配置文件开启发送确认模式，设置`spring.rabbitmq.publisher-returns=true`。然后，可以自定义RabbitTemplate并实现ConfirmCallback接口，设置一个确认回调来接收发送确认的结果。通过这种方式，可以获取到消息是否成功发送到RabbitMQ的信息。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [springBoot使用rabbitmq并保证消息可靠性](https://blog.csdn.net/qq_38263083/article/details/128530631)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [SpringBoot整合RabbitMq(消息可靠投递)](https://blog.csdn.net/qq_39140300/article/details/118756008)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值