消息可靠投递

最新推荐文章于 2024-11-12 23:14:56 发布
最新推荐文章于 2024-11-12 23:14:56 发布
阅读量1.3k 收藏 7
点赞数 11
分类专栏： RabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wen_J_Q/article/details/141931623
版权

消息可靠投递

  • 生产者消息投递到 Broker 时，万一网络断了，生产者以为自己投递成功了，消息队列以为没有生产者投递
  • RabbitMQ 提供了两种方式控制可靠投递，confirm 确认模式，return 退回模式
  • RabbitMQ 提供事务机制，但是性能较差，不做讲解，可自行研究

image-20210816144827884

ConfrmCallBack

消息从生产者投递交换机，交换机给生产者一个响应，生产者收到肯定应答，才能保证消息成功投递到交换机，但是如果没有设置持久化，这时候交换机断电重启，仍然丢失，需要做到以下3个方法才能保证可靠投递到交换机

  1. 队列设置持久化
  2. 消息设置持久化
  3. ConfirmCallBack回调

单个同步确认

生产者投递一个消息，交换机回应，生产者确认之后再发布下一个，吞吐量很低

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

//单条同步确认
public class SingleSyncConfirm {
    /**
     * 生产者 → 交换机
     * 生产者投递 1条 消息给交换机
     * 交换机持久化,保存本地之后,给生产者一个应答
     * 生产者接收到成功应答之后,再投递下一条消息
     * 10000条,每条都回执一次 总耗时: 1958 毫秒
     * @param args
     */
    private static final String SINGLE_SYNC_CONFIRM_EXCHANGE = "singleSyncConfirmExchange";
    private static final String SINGLE_SYNC_CONFIRM_QUEUE = "singleSyncConfirmQueue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        ConnectionFactory factory = new ConnectionFactory();
        if (true) {
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
        }
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //交换机声明,队列声明，交换机绑定队列
        channel.exchangeDeclare(SINGLE_SYNC_CONFIRM_EXCHANGE, BuiltinExchangeType.DIRECT, true);
        channel.queueDeclare(SINGLE_SYNC_CONFIRM_QUEUE,true,false,false,null);
        channel.queueBind(SINGLE_SYNC_CONFIRM_QUEUE,SINGLE_SYNC_CONFIRM_EXCHANGE,SINGLE_SYNC_CONFIRM_QUEUE);
        /**
         * 开启 confirm 确认
         */
        channel.confirmSelect();

        long begin = System.currentTimeMillis();//开始时间

        for (int i = 0; i < 1000; i++) {
            String str = i + "";
            channel.basicPublish(SINGLE_SYNC_CONFIRM_EXCHANGE,SINGLE_SYNC_CONFIRM_QUEUE,null,str.getBytes());
            //生产者等待确认
            boolean b = channel.waitForConfirms();
            if (b) {
                System.out.println("第 " + i + " 条发送成功");
            } else {
                System.out.println("第 " + i + " 条发送失败================");
            }
        }

        long end = System.currentTimeMillis();//结束时间
        System.out.println("总耗时: " + (end - begin) + " 毫秒");
    }
}

批量同步确认

发布批量消息之后，等待，当有某一个故障的时候，不知道是哪个消息出问题

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

//多条同步确认
public class MultipleSyncConfirm {

    private static final String MULTIPLE_SYNC_CONFIRM_EXCHANGE = "multipleSyncConfirmExchange";
    private static final String MULTIPLE_SYNC_CONFIRM_QUEUE = "multipleSyncConfirmQueue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        ConnectionFactory factory = new ConnectionFactory();
        if (true) {
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
        }
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //交换机声明
        channel.exchangeDeclare(MULTIPLE_SYNC_CONFIRM_EXCHANGE, BuiltinExchangeType.DIRECT, true);
        channel.queueDeclare(MULTIPLE_SYNC_CONFIRM_QUEUE,true,false,false,null);
        channel.queueBind(MULTIPLE_SYNC_CONFIRM_QUEUE,MULTIPLE_SYNC_CONFIRM_EXCHANGE,MULTIPLE_SYNC_CONFIRM_QUEUE);

        /**
         * 开启 confirm 确认
         */
        channel.confirmSelect();

        long begin = System.currentTimeMillis();//开始时间

        for (int i = 1; i <= 1000; i++) {
            String str = i + "";
            channel.basicPublish(MULTIPLE_SYNC_CONFIRM_EXCHANGE, MULTIPLE_SYNC_CONFIRM_QUEUE, null, str.getBytes());

            if (i % 100 == 0) {
                //生产者等待确认
                boolean b = channel.waitForConfirms();
                if (b) {
                    System.out.println("第 " + i + " 条发送成功");
                } else {
                    System.out.println("第 " + i + " 条发送失败================");
                }
            }
        }

        long end = System.currentTimeMillis();//结束时间
        System.out.println("总耗时: " + (end - begin) + " 毫秒");
    }
}

异步批量确认

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.Date;
import java.util.concurrent.TimeoutException;

//多条异步确认
public class MultipleAsyncConfirm {

    private static final String MULTIPLE_ASYNC_CONFIRM_EXCHANGE = "multipleAsyncConfirmExchange";
    private static final String MULTIPLE_ASYNC_CONFIRM_QUEUE = "multipleAsyncConfirmQueue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        ConnectionFactory factory = new ConnectionFactory();
        if (true) {
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("guest");
            factory.setPassword("guest");
            factory.setVirtualHost("/");
        }
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //交换机声明
        channel.exchangeDeclare(MULTIPLE_ASYNC_CONFIRM_EXCHANGE, BuiltinExchangeType.DIRECT, true);
        channel.queueDeclare(MULTIPLE_ASYNC_CONFIRM_QUEUE, true, false, false, null);
        channel.queueBind(MULTIPLE_ASYNC_CONFIRM_QUEUE, MULTIPLE_ASYNC_CONFIRM_EXCHANGE, MULTIPLE_ASYNC_CONFIRM_QUEUE);

        /**
         * 开启 confirm 确认
         */
        channel.confirmSelect();

        long begin = System.currentTimeMillis();//开始时间


        /**
         * 开启 confirm 回调函数
         */
        ConfirmCallback ackCallBack = new ConfirmCallback() {
            /**
             * 成功回调
             * @param deliveryTag
             * @param multiple      true表示已确认多条,false表示已确认单条
             * @throws IOException
             */
            @Override
            public void handle(long deliveryTag, boolean multiple) throws IOException {
                if (multiple) {
                    System.out.println("已确认多条: " + deliveryTag);
                } else {
                    System.out.println("已确认单条: " + deliveryTag);
                }
            }
        };
        ConfirmCallback nackCallBack = new ConfirmCallback() {
            /**
             * 失败回调
             * @param deliveryTag
             * @param multiple      true表示未确认多条,false表示未确认单条
             * @throws IOException
             */
            @Override
            public void handle(long deliveryTag, boolean multiple) throws IOException {
                if (multiple) {
                    System.out.println("未确认多条: " + deliveryTag);
                } else {
                    System.out.println("未确认多条: " + deliveryTag);
                }
            }
        };
        channel.addConfirmListener(ackCallBack, nackCallBack);

        for (int i = 1; i <= 1000; i++) {
            String str = i + "\t" + new Date().getTime();
            channel.basicPublish(MULTIPLE_ASYNC_CONFIRM_EXCHANGE, MULTIPLE_ASYNC_CONFIRM_QUEUE, null, str.getBytes());
        }

        long end = System.currentTimeMillis();//结束时间
        System.out.println("总耗时: " + (end - begin) + " 毫秒==========================");
    }
}

对比

单条确认：简单，吞吐量低

批量确认：简单，吞吐量比单条确认高，当一批消息中有一个出问题，不知道是哪一个

异步批量确认：代码复杂，吞吐量高

ReturnCallBack

交换机投递到队列

SpringBoot 整合

ConfirmCallback

引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
配置文件中开启
spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirm-type: correlated

  • 较低版本中配置是

    publisher-confirms: true

  • publisher-confirm-type：取值有3种

    • none 禁用发布确认模式，默认
    • correlated 消息从生产者投递到交换机成功后触发回调
    • simple 类似 correlated ，支持 waitForConfirms() 和 waitForConfirmsOrDie() 方法
配置类

在 Publish/Subscribe 基础之上整合

import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

@Component
public class ConfirmCallBackImpl implements RabbitTemplate.ConfirmCallback {

    /**
     * @param correlationData 相关数据,一般存储一个id,用来辨识唯一性
     * @param ack             确认,如果成功返回 true,如果失败返回 false
     * @param cause           原因,失败原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        System.out.println("correlationData = " + correlationData);
        System.out.println("ack = " + ack);
        System.out.println("cause = " + cause);

        if (ack) {
            System.out.println("投递到交换机成功");
        } else {
            System.out.println("投递失败,原因是:\t" + cause);
            System.out.println("将失败的消息 " + correlationData.getId() + " 保存到数据库");
        }
    }
}

//设置确认回调
rabbitTemplate.setConfirmCallback(confirmCallBackI);

image-20210816182706901

因为是和之前的一起整合，所以设置 ConfirmCallBack 在注入 RabbitTemplate 时一起设置
也可以使用匿内部类或者Lambda表达式
测试
  • http://localhost:8080/confirm/test/abc 正常投递
  • http://localhost:8080/confirm/test-fail/abc 失败投递
import com.example.constants.Constants;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("confirm")
public class ConfirmController {
    /**
     * 注入 RabbitTemplate 模板对象
     */
    @Resource
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("test/{name}")
    public String send(@PathVariable("name") String name) {

        /**
         * 发送消息
         */
        String str = name + "\t" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss_SSS").format(new Date());

        CorrelationData correlationData = new CorrelationData();
        correlationData.setId(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend(Constants.MY_FANOUT_EXCHANGE, "", str, correlationData);

        try {
            /**
             * 睡眠,程序还没运行结束
             * 确认回调已经执行,说明是异步的
             */
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消息发送成功!\t" + str);
        return "success";
    }

    /**
     * 测试失败
     *
     * @param name
     * @return
     */
    @RequestMapping("test-fail/{name}")
    public String sendFail(@PathVariable("name") String name) {
        String str = name + "\t" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss_SSS").format(new Date());

        CorrelationData correlationData = new CorrelationData();
        correlationData.setId(UUID.randomUUID().toString());
        /**
        * 创建一个不存在的交换机名称,用来测试投递失败
        */
        String errorExchangeName = Constants.MY_FANOUT_EXCHANGE + "abc";
        rabbitTemplate.convertAndSend(errorExchangeName, "", str, correlationData);

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消息发送成功!\t" + str);
        return "success";
    }
}

ReturnCallBack

引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
配置文件中开启
spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-returns: true
配置类
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

@Component
public class ReturnsCallBackImpl implements RabbitTemplate.ReturnsCallback {
    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
        System.out.println("returnedMessage = " + returnedMessage);
        System.out.println("returnedMessage.getMessage() = " + returnedMessage.getMessage());
        System.out.println("returnedMessage.getReplyCode() = " + returnedMessage.getReplyCode());
        System.out.println("returnedMessage.getReplyText() = " + returnedMessage.getReplyText());
        System.out.println("returnedMessage.getExchange() = " + returnedMessage.getExchange());
        System.out.println("returnedMessage.getRoutingKey() = " + returnedMessage.getRoutingKey());
    }
}

//设置确认回调
rabbitTemplate.setMandatory(true);
rabbitTemplate.setReturnsCallback(returnsCallBackImpl);

image-20210817032048020

测试
  • 在 Direct 模式下，修改路由为一个不存在的路由
import com.example.constants.Constants;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("return")
public class ReturnController {
    /**
     * 注入 RabbitTemplate 模板对象
     */
    @Resource
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("test/{name}")
    public String send(@PathVariable("name") String name) {

        /**
         * 发送消息
         */
        String str = name + "\t" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss_SSS").format(new Date());

        CorrelationData correlationData = new CorrelationData();
        correlationData.setId(UUID.randomUUID().toString());

        rabbitTemplate.convertAndSend(Constants.MY_DIRECT_EXCHANGE, "sms", str, correlationData);
        rabbitTemplate.convertAndSend(Constants.MY_DIRECT_EXCHANGE, "email", str, correlationData);

        try {
            /**
             * 睡眠,程序还没运行结束
             * 确认回调已经执行,说明是异步的
             */
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消息发送成功!\t" + str);
        return "success";
    }

    /**
     * 测试失败
     *
     * @param name
     * @return
     */
    @RequestMapping("test-fail/{name}")
    public String sendFail(@PathVariable("name") String name) {
        String str = name + "\t" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss_SSS").format(new Date());

        CorrelationData correlationData = new CorrelationData();
        correlationData.setId(UUID.randomUUID().toString());
        /**
         * 使用错误的路由键,用来测试交换机不能达到队列
         */
        String routingKey = "abc";
        rabbitTemplate.convertAndSend(Constants.MY_DIRECT_EXCHANGE, routingKey, str, correlationData);

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消息发送成功!\t" + str);
        return "success";
    }
}
架构小闻闻
关注
专栏目录
RabbitMQ实现消息可靠投递
baobao的博客
07-08 1244
本文从本人博客搬运，原文格式更加美观，可以移步原文阅读：RabbitMQ实现消息可靠投递 实际开发中，我们经常需要保证消息由生产者发送到消费者接收并消费的整个过程中，消息不丢失，这就需要在RabbitMQ中实现消息的可靠投递。主要包含以下两部分： 发送端可靠性：指生产者发送消息到RabbitMQ Broker这个过程中保证消息不丢失 接收端可靠性：指RabbitMQ Broker将消息发送给消费者并且消费者正确处理消息的这个过程中保证消息不丢失 发送端可靠性 发送端可靠性主要包含3个方面： 消息抵达交
消息可靠性投递
skystep的博客
07-24 682
如图，该方案对消息进行落库处理，每次操作之后修改消息的状态。启动定时任务对消息库中的获取投递失败的消息，请求发送者重新投递消息。数据库中核心存储消息的唯一id，消息状态，重试次数，重试时间，主要的步骤如下step1发送消息前，存储消息至消息库；step2发送消息至MQBroker；step3生产者监听到MQ的确认消息；step4如果ack=true，更改数据库中消息的状态；step5定时任务（定时去获取数据库中消息状态为投递中状态，并且重试时间小于当前时间的消息）......
rabbitmq+springboot实现消息可靠投递
zwjzone的博客
05-08 1181
最详细，最全面，无bug版消息可靠投递策略演示
MQ如何保证消息可靠投递
Best_Lynn的博客
06-13 889
producer : 发送消息给Broker, 服务器将消息写入磁盘, 并发送确认请求后, 才算消息发送成功 consumer : 定时轮询Broker的消息, 抽取消息, 并返回确认请求 Broker : 接收生产者发送的消息, 消息本地存储; 消费者抽取消息返回确认请求后, 删除该消息 注意点: 生产消息, 消费消息 都是异步的...
RabbitMQ的消息可靠投递 --上篇
weixin_30947631的博客
01-13 508
前言 上一节介绍了有关rabbitmq里面常用了几种命令，以及交换机的路由规则等，生产端以及消费端之间的伪代码来介绍了各种路由规则下的消费情况，从管控台的设置，数据分析，了解到如何手动设置vhost下的交换机以及用户，队列等。这节开始就rabbitmq的高级特性进行详细的介绍，比如TTL，死信队列，限流，ACK以及失败转移等生产中常用到的特性。 消息如何保障100%的投递成功? 这里投递成功的意思...
RabbitMQ消息的可靠投递
Knight
03-28 722
其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。如果出现异常，则在catch中调用 basicNack，拒绝消息，让MQ重新发送消息。4.队列和交互机绑定。
消息可靠投递实践：如何保证 RabbitMQ 的消息可靠投递
pengyi123的博客
04-03 1483
死信队列”其实就是一个普通的 RabbitMQ 队列，我们可以在创建一个队列的时候为它指定 x-dead-letter-exchange 和 x-dead-letter-routing-key 参数，这样当这个队列中的消息因为各种原因被拒绝，并且设置的是不重新入队，那么 RabbitMQ 就会自动地将这个消息重新发布到我们指定的 exchange，并且用我们指定的 routing key 进行路由，从而实现消息的“死信”处理。在每次消费者准备处理消息的时候，我们都检查 "retry_count" 的值。
SpringBoot整合RabbitMq(消息可靠投递)
one
07-18 1214
文章目录前言一、RabbitMq简介1、为何用RabbitMq，RabbitMq特点，场景应用2、RabbitMq工作流程3、AMQP协议二、创建工程1.spring-boot-starter-amqp注解2.rabbitTemplate使用3.rabbitListener&rabbitHandler接收消息4.消息队列-可靠投递-发送端确认5.消息队列-可靠投递-消费端确认总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开
RabbitMQ消息可靠投递
jing956899449的博客
07-01 149
RabbitMQ 可靠投递
SpringBoot-RabbitMQ篇-消息可靠投递
ITGENIUS1的博客
07-23 556
一、发送者异常监控 1.1 发送者异常种类 1.基本处理流程 补偿(兜底)方案 2.模拟broker宕机：修改发送者端口如5673，然后启动，发送消息，端口不对无法连接主机 错误信息：java.net.ConnectException: Connection timed out: connect 补偿方案：加入异常处理，如果不可达则返回错误 这种错误在发送的时候就已经可以发现，直接将错误返回给调用方即可 @RequestMapping("/direct") public Object sendEma
rabbitMQ 消息可靠投递
05-13
RabbitMQ 是一个开源的消息队列，它采用了 AMQP 协议来实现消息的可靠传输。AMQP 协议提供了消息确认...综上所述，RabbitMQ 提供了多种机制来保证消息的可靠投递，可以根据实际情况选择合适的机制来保证消息的可靠性。
消息队列专题(高级特性篇)：RabbitMQ 如何保证消息的可靠性投递、传输和消费
盛夏温暖流年
12-04 1349
我们使用 RabbitMQ 进行消息处理一般都需要保证消息的可靠性，而消息的可靠性又可以根据消息的不同处理阶段分为可靠性投递、传输和消费。 本篇博客将针对这三种情况介绍相应的设计方案，首先来看一下消息的可靠性投递。 消息的可靠性投递 1. 消息投递模式 消息可靠性投递，是指保证生产者能够把消息 100% 发送到消息队列中，生产者 Producer 为我们提供了两种消息投递模式：Confirm 确认模式 和 Return 退回模式 ，这两种模式是保障消息可靠性投递的核心，先来了解下这两种模式。 Confir
goframe开发一个企业网站 rabbitmq队例15
hzether的博客
11-10 1025
本文介绍了在GoFrame框架中实现RabbitMQ消息队列的完整解决方案。通过YAML配置文件管理RabbitMQ的连接信息，支持普通消息、延迟消息和死信队列功能。在pkg层封装了RabbitMQ的基础操作，包括连接初始化、交换机和队列声明、消息发布和消费等核心功能。业务逻辑层实现了消息的发送、消费、批量处理等功能，并提供了队列管理和状态查询接口。控制器层提供了HTTP接口，支持消息发送、延迟发送、批量发送、队列查询和消息消费等操作，采用统一的响应格式和错误处理机制。整个实现采用分层架构，代码结构清晰.
RabbitMQ 与 PHP Swoole 实现
最新发布
学习,分享一直在路上
11-12 581
RabbitMQ 是一个开源的消息队列中间件，允许通过异步消息传递来解耦应用程序的各个部分。Swoole 是一个高性能的 PHP 扩展，支持异步编程和协程，适用于构建高并发的网络服务。将 RabbitMQ 与 Swoole 结合使用，可以构建高效、可扩展的应用程序。本文将介绍如何使用 RabbitMQ 和 PHP Swoole 实现一个简单的消息队列示例。使用 Docker 快速启动 RabbitMQ 实例
【RabbitMQ】06-消费者的可靠性
Infinity的博客
11-11 331
没有ack，mq就会一直保留消息。
接收nVisual中rabbitmq数据不成功问题排查
NWVDI的博客
11-08 470
rabbitmq服务部署成功的情况下，消息对接不成功一般原因为消息发送失败，发送失败大多数可能为global_settings表配置错误。下面从两个方面解决消息对接不成功问题。
RabbitMQ高效的消息队列中间件原理及实践
学习,分享一直在路上
11-12 666
RabbitMQ 是一个功能强大的消息队列中间件，提供了高效的消息传递机制和灵活的路由策略。通过使用 PHP 的库，开发者可以轻松地与 RabbitMQ 进行交互，实现生产者和消费者的功能。
RabbitMQ — 异步调用
cyt涛的博客
11-08 1004
RabbitMQ 是一个开源的消息代理中间件，它使用高级消息队列协议（AMQP, Advanced Message Queuing Protocol）来实现不同系统之间的消息传递。它以 Erlang 语言编写，具有高可靠性、灵活性和易于扩展的特点，被广泛应用于异步通信、数据流处理等场景。
【RabbitMQ】04-发送者可靠性
Infinity的博客
11-07 432
每个RabbitTemplate只能配置一个ReturnCallback，因此我们可以在配置类中统一设置。@Slf4j@Overridelog.error("触发return callback,");});由于每个消息发送时的处理逻辑不一定相同，因此ConfirmCallback需要在每次发消息时定义。@Test// 1.创建CorrelationData// 2.给Future添加ConfirmCallback@Override。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值