RabbitMQ学习记录(五)-发布确认机制

置顶 已于 2022-12-06 22:47:08 修改
阅读量2.4k 收藏 9
点赞数 7
分类专栏： RabbitMQ 文章标签： rabbitmq Java
于 2022-04-12 19:25:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cuierdan/article/details/124013373
版权

为什么要确认

       队列中的消息能够成功被消费者消费的前提是消息能被生产者正确的推送到队列中，下面我们来研究RabbitMQ为保证消息被成功推送到队列中的解决方案，事务机制和发布确认机制。

如下图，解决下图部分。

事务机制

       在AMQP协议中为保障消息能够正确的被推送到RabbitMQ服务器的队列中，它提供了一种事务机制，以确保没有推送成功的消息可以进行回滚。

1. 开启事务
       我们需要在Channel(信道)中开启事务，使Channel(信道)处于transactional模式，发送者使用该模式向队列中推送消息。
2. 提交事务
       提交当前的事务。
3. 事务回滚
       发送消息出现异常后，进行事务回滚。

生产者代码

package rabbitmq.ced.confirm;

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

import java.io.IOException;

/**
 * 事务机制 创建生产者
 *
 * @author 崔二旦
 * @since now
 */
public class TransactionProducer {

    public static void main(String[] args) {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2. 设置连接属性
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;

        try {
            // 3. 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 3. 在连接中创建信道，RabbitMQ中的所有操作都是在信道中完成的
            channel = connection.createChannel();
            // 声明队列，如果队列不存在会创建队列
            channel.queueDeclare("hello", false, false, true, null);
            // 准备要被发送的消息内容
            String message = "NB 崔二旦";

            // 开启事务机制
            channel.txSelect();

            channel.basicPublish("", "hello", null, message.getBytes());

            // 提交事务
            channel.txCommit();

            System.out.println("消息发送成功");
        } catch (Exception e) {
            e.printStackTrace();
            try {
                if (null != channel) {
                    // 回滚事务
                    channel.txRollback();
                }
            } catch (IOException ioe) {
                ioe.printStackTrace();
                System.out.println("消息发送异常，回滚异常");
            }
            System.out.println("消息发送异常");
        } finally {
            // 释放关闭连接信道与连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

       查看上面代码，可以看出只是在之前的生产者代码中加了三行关于开启事务，提交事务，事务回滚的方法。

如下：

 // 开启事务机制
 channel.txSelect();
 // 提交事务
 channel.txCommit();
 // 回滚事务
 channel.txRollback();

事务机制总结
       因事务机制在每次发送消息的时候，都要在Channel中进行开启事务操作，所以会在与MQ交互时带来巨大的多余的开销，导致消息的吞吐量下降很多，据说会下降到250%。所以在RabbitMQ中还提供了另一种解决方案，那就是发布确认模式(Confirm)。

发布确认机制

       发布确认机制也就是发送方确认模式，生产者在Channel(信道)上调用confirmSelect()方法，请求将Broker的Channel(信道)设置成为confirm模式，一旦信道进入confirm模式，所有在该信道上流通的消息都会被指派一个唯一的ID(从1开始)，并将消息被推送到匹配的队列中。生产者可以在推送消息之后，通过信道调用waitForConfirms()方法，向RabbitMQ发送消息发布确认请求，RabbitMQ服务器会返回消息发布确认的状态给生产者（包括确认的消息及消息的ID信息），这样生产者就知道消息已经被正确推送到目的队列了。如果收到发布确认失败的消息，生产者可以进行后续的重新发送。

       发布确认机制有多种方式可以实现确认操作，分别是单个确认、批量确认、异步确认。

开启方法

       发布确认机制默认是不开启的，需要手动开启，开启方法是在创建Channel(信道)之后，将Channel设置成confirm模式，如下：

// 创建信道
Channel channel = connection.createChannel();
// 开启confirm模式
channel.confirmSelect();

单个确认

       单个确认是一种简单的确认方式，它是一种同步确认发布的方式，也就是发布一个消息之后，便向Broker发送确认发布请求，只有当这个消息被确认发布之后，才会继续发布后面的消息，一种串行的确认发布过程，这种方式的发布速度特别的慢，因为前面的消息没有被确认发布，就会阻塞后面所有的消息发布。这种方式的吞吐量每秒小于100条。

  1. 生产者发送一条消息给Broker。
  2. 生产者向Broker发送一次发布确认请求 。
  3. Broker向生产者返回确认发布失败(NACK)的状态，生产者重新发送这一条消息。失败可能是Broker服务端出现问题，导致消息无法被发送。
  4. Broker向生产者返回确认发布成功(ACK)的状态，生产者继续发送下一条消息。

单个确认生产者代码

      模拟了1000条消息，使用单个确认方式将消息推送到队列中。

package rabbitmq.ced.confirm;

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

/**
 * 发布确认机制  单个发布 创建生产者
 *
 * @author 崔二旦
 * @since now
 */
public class ConfirmSingleProducer {

    public static void main(String[] args) {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2. 设置连接属性
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;

        try {
            // 3. 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 3. 在连接中创建信道，RabbitMQ中的所有操作都是在信道中完成的
            channel = connection.createChannel();
            // 队列名称
            String queueName = "single_queue";
            // 声明队列，如果队列不存在会创建队列
            channel.queueDeclare(queueName, false, false, false, null);
            long begin = System.currentTimeMillis();
            // 开启发布确认模式
            channel.confirmSelect();

            for (int i = 0; i < 1000; i++) {
                // 准备要被发送的消息内容
                String message = "崔二旦" + i;
                //消息ID
                long seqNo = channel.getNextPublishSeqNo();
                // 推送消息
                channel.basicPublish("", queueName, null, message.getBytes());
                /**
                 * 发送方向Broker发送确认发布请求。
                 * 服务端返回false或超时未返回，
                 * 生产者可以获取服务器返回的相应消息的序号，
                 * 对消息进行重新发送，或者其它处理
                 */
                boolean flag = channel.waitForConfirms();
                //服务端返回true，标识消息已经正确的被发送到队列中，
                // 我们可以在这里对成功消息进行进一步处理，如保存日志等
                if (flag) {
                    //打印发送成功的消息的序列
                    System.out.println("消息发送成功,被发送成功的消息序列号为：" + seqNo);
                    /**
                     * 服务端返回false,标识消息没有被发送到指定队列中，
                     * 我们可以进行重新发送或者对失败的消息进行处理，
                     * 如记录日志，将消息重新发送到某一个失败消息的队列。
                     */
                } else {
                    System.out.println("消息发送失败,被发送失败的消息序列号为：" + seqNo);
                }
            }
            long end = System.currentTimeMillis();
            System.out.println("发布1000个消息到同一队列,耗时" + (end - begin) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("消息发送异常");
        } finally {
            // 释放关闭连接信道与连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

结果

      发布1000个消息到同一队列,耗时1863ms。

批量确认

       批量确认其实是单个确认的一个升级版，因为单个确认的方式是需要一条消息一条消息的确认，发送消息的速度比较慢，如果推送一批消息之后一起确认，这样就会大大提高吞吐量，但是在推送消息的过程中，出现了故障就会导致一些消息丢失，因为在批量确认的时候是一次性确认一批消息，Broker是没有办法返回具体确认状态里消息的信息的，所以出现失败时是不知道丢失的消息是哪个，所以我们要把整批消息记录下来，一边失败后的重新推送。这种批量确认的方式也是同步发送的，也会出现消息阻塞的情况。

  1. 生产者发送一批消息给Broker。
  2. 生产者向Broker发送一次发布确认请求 。
  3. Broker向生产者返回确认发布失败(NACK)的状态，生产者重新发送这一批消息，失败可能是Broker服务端出现问题，导致消息无法被发送。
  4. Broker向生产者返回确认发布成功(ACK)的状态，生产者继续发送下一批消息。

批量确认生产者代码

       模拟了1000条消息，使用批量确认方式将消息推送到队列中。

package rabbitmq.ced.confirm;

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

/**
 * 发布确认机制  批量发布 创建生产者
 *
 * @author 崔二旦
 * @since now
 */
public class ConfirmBatchProducer {

    public static void main(String[] args) {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2. 设置连接属性
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;
        try {
            // 3. 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4. 在连接中创建信道，RabbitMQ中的所有操作都是在信道中完成的
            channel = connection.createChannel();
            // 队列名称
            String queueName = "batch_queue";
            // 声明队列，如果队列不存在会创建队列
            channel.queueDeclare(queueName, false, false, false, null);
            long begin = System.currentTimeMillis();
            // 开启发布确认
            channel.confirmSelect();
            // 批量确认消息个数
            int batchSize = 100;
            // 未确认消息数量
            int noConfirmCount = 0;

            for (int i = 0; i < 1000; i++) {
                // 准备要被发送的消息内容
                String message = "崔二旦" + i;
                channel.basicPublish("", queueName, null, message.getBytes());
                noConfirmCount++;
                // 当发送的消息数与我们设置的批量确认的数值一致，我们就会已经一次确认操作
                if (noConfirmCount == batchSize) {
                    // 将该批消息向rabbitmq发送一个确认发布的请求，
                    // rabbitmq会返回确认发布的成功状态
                    boolean flag = channel.waitForConfirms();
                    if (flag) {
                        System.out.println("该批消息已经确认发送成功");
                    } else {
                        System.out.println("该批消息有确认失败的,需要重新发送整批失败的消息");
                    }
                    noConfirmCount = 0;
                }
            }
            // 当最后一批消息发送的数量不足批量确认的数量时，把剩余的消息在进行确认
            if (noConfirmCount > 0) {
                channel.waitForConfirms();
            }
            long end = System.currentTimeMillis();
            System.out.println("发布1000个批量消息到同一队列,耗时" + (end - begin) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("消息发送异常");
        } finally {
            // 释放关闭连接信道与连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

结果

      发布1000个批量消息到同一队列,耗时150ms。

异步确认

       Confirm模式最大的好处是可以异步确认，在生产者发送消息之前，在生产者程序中设置一个确认发布监听器，用于给Borker端调用，Broker将确认发布信息推送给生产者确认发布监听器，设置好监听器之后生产者就可以向Broker端推送消息了。确认发布监听器与消息推送是两个独立的线程，所以推送消息和监听状态是可以并行的，也就是所谓的异步操作，生产者可以一直给Broker端推送消息，Broker端会将确认状态通过监听器回调给生产者，Broker端会给确认发布监听器传递两种确认发布的状态，确认成功(Confirm Ack)和确认失败(Confirm Nack)，生产者可以获取到成功或失败的消息，做其它处理，如将失败的消息重新发送。所以异步确认是性价比最好的。

生产者在将Channel(信道)设置成Confirm模式之后，需要先将确认发布监听器准备好，以便于Broker随时可以将消息的确认状态回调给生产者。

  1. 生产者连续给Broker发送消息。
  2. Broker在接收到消息之后，随时将确认发布状态回传给生产者的监听器（调用回调函数） 。
  3. 确认发布监听器将发送失败(Nack)的消息，进行处理重新发送。
  4. 确认发布监听器将发送成功(Ack)的消息，进行后续处理，比如进度日志等。

异步确认生产者代码（一）

       从控制台输入消息

package rabbitmq.ced.confirm;

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

import java.util.Scanner;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

/**
 * 发布确认机制  异步发布 创建生产者
 * 逐条发送
 *
 * @author 崔二旦
 * @since now
 */
public class ConfirmAsyncProducer {

    public static void main(String[] args) {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2. 设置连接属性
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;

        try {
            // 3. 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4. 在连接中创建信道，RabbitMQ中的所有操作都是在信道中完成的
            channel = connection.createChannel();
            // 队列名称
            String queueName = "async_queue";
            // 声明队列，如果队列不存在会创建队列
            channel.queueDeclare(queueName, false, false, false, null);
            // 开启发布确认
            channel.confirmSelect();
            /**
             * 定义一个记录已发送消息的Map
             */
            ConcurrentSkipListMap<Long, Object> outstandingConfirms = new ConcurrentSkipListMap<>();

            /**
             * 处理发送成功的消息，消费者回传过来的两个参数
             * 1. 消息ID：当前可以确认发布的消息序号
             * 2. 是否批量发送：true:自动确认，false:手动确认
             */
            ConfirmCallback ackCallback = (sequenceNo, multiple) -> {
                //获取当前确认发布成功的消息
                Object message = outstandingConfirms.get(sequenceNo);
                // 批量发送，true:代表消费者是以自动确认的机制去接受消息的，
                // 但是自动确认机制只要消费者接收到消息，MQ就会认为消息已经发送成功，
                // 所以MQ是不会管消费者接收到消息之后的操作是否成功的，如果消费者后续失败了，消费者也是不知道的。
                // 所以生产者会将该消息之前的所有消息都认为是发送成功了。
                if (multiple) {
                    // 返回的是小于等于当前序列号的未确认消息，是一个Map
                    // headMap该方法是截取outstandingConfirms集合，将sequenceNo序号之前的都截取到confirmed 中。
                    // outstandingConfirms中sequenceNo序号之前的都会被删除。
                    ConcurrentNavigableMap<Long, Object> confirmed =
                            outstandingConfirms.headMap(sequenceNo, true);
                    // 清除该部分未确认消息，将截取出来的消息都认为是发送成功了，将截取后的集合清空。
                    confirmed.clear();
                } else {
                    // false：代表是手动确认的，也就是只有发过来的消息才是被成功处理的。
                    // 只清除当前序列号的消息
                    outstandingConfirms.remove(sequenceNo);
                }
                System.out.println("发布的消息：" + message + " 被成功确认，序列号未" + sequenceNo);
            };
            /**
             * 处理发送失败的消息
             */
            Channel finalChannel = channel;
            ConfirmCallback nackCallback = (sequenceNo, multiple) -> {
                //获取失败消息
                Object message = outstandingConfirms.get(sequenceNo);
                finalChannel.basicPublish("", queueName, null,
                        ((String) message).getBytes());
                System.out.println("发布的消息：" + message + " 未被确认，序列号未" + sequenceNo);
            };
            /**
             * 确认发布监听器
             * 1. 成功消息的处理函数
             * 2. 失败消息的处理函数
             */
            channel.addConfirmListener(ackCallback, nackCallback);
            // 通过控制台输入信息
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()) {
                String message = scanner.next();
                // 记录即将被发送的消息信息
                outstandingConfirms.put(channel.getNextPublishSeqNo(), message);
                channel.basicPublish("", queueName, null, message.getBytes());
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("消息发送异常");
        } finally {
            // 释放关闭连接信道与连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

异步确认生产者代码（二）     

       模拟了1000条消息，使用异步确认方式将消息推送到队列中。

package rabbitmq.ced.confirm;

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

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

/**
 * 发布确认机制  异步发布 创建生产者
 * 发送多条
 *
 * @author 崔二旦
 * @since now
 */
public class ConfirmAsyncMoreProducer {

    public static void main(String[] args) {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2. 设置连接属性
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

        Connection connection = null;
        Channel channel = null;

        try {
            // 3. 从连接工厂中获取连接
            connection = connectionFactory.newConnection("生产者");
            // 4. 在连接中创建信道，RabbitMQ中的所有操作都是在信道中完成的
            channel = connection.createChannel();
            // 队列名称
            String queueName = "async_queue";
            // 声明队列，如果队列不存在会创建队列
            channel.queueDeclare(queueName, false, false, false, null);
            // 开启发布确认
            channel.confirmSelect();

            ConcurrentSkipListMap<Long, String> outstandingConfirms = new ConcurrentSkipListMap<>();

            ConfirmCallback ackCallback = (sequenceNo, multiple) -> {
                String message = outstandingConfirms.get(sequenceNo);
                outstandingConfirms.put(sequenceNo, message + "-true");
                // 这里打印的成功消息不全,因为程序执行完就自动关闭了，
                // 导致Broker无法将确认状态回传，但是查看队列中已经存在1000条消息了。
                System.out.println("发布的消息：" + message + " 被成功确认，序列号未" + sequenceNo);
                if (multiple) {
                    // 返回的是小于等于当前序列号的未确认消息，是一个Map
                    ConcurrentNavigableMap<Long, String> confirmed =
                            outstandingConfirms.headMap(sequenceNo, true);
                    // 清除该部分未确认消息
                    confirmed.clear();
                } else {
                    // 只清除当前序列号的消息
                    outstandingConfirms.remove(sequenceNo);
                }
            };
            ConfirmCallback nackCallback = (sequenceNo, multiple) -> {
                String message = outstandingConfirms.get(sequenceNo);
                System.out.println("发布的消息" + message + "未被确认，序列号未" + sequenceNo);
            };
            channel.addConfirmListener(ackCallback, nackCallback);
            long begin = System.currentTimeMillis();
            for (int i = 0; i < 1000; i++) {
                // 准备要被发送的消息内容
                String message = "崔二旦" + i;
                outstandingConfirms.put(channel.getNextPublishSeqNo(), message);
                channel.basicPublish("", queueName, null, message.getBytes());
            }
            long end = System.currentTimeMillis();
            System.out.println("发布1000个异步消息到同一队列,耗时" + (end - begin) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("消息发送异常");
        } finally {
            // 释放关闭连接信道与连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

        发布1000个异步消息到同一队列,耗时99ms

速度对比

单个确认：

       发布1000个消息到同一队列,耗时1863ms。

批量确认：

       发布1000个批量消息到同一队列,耗时150ms。

异步确认：

       发布1000个异步消息到同一队列,耗时99ms

崔二旦: 崔二旦用于记录学习的代码 - Gitee.com

石图三
关注
专栏目录
RabbitMQ高级特性 - 生产者消息确认机制
CYK_byte的博客
08-04 1212
为了保证信息 从生产者 发送到 队列，因此引入了生产者的消息确认机制.通过事务机制实现.通过发送确认机制（confirm 和 return）实现.因为事务机制比较消耗性能，在实际工作中用的也不多，因此这里主要介绍confirm 和 return机制来实现发送放的确认.a）confirm 确认模式如上图，confirm 确认模式主要保障于 生产者 到 交换机 的消息可靠性.如果 Exchange成功收到消息，那么 ConfirmCallback 这个回调 ack 参数就为true。
rabbitmq-server3.10.5
01-10
RabbitMQ支持消息确认机制，允许服务器确认消息是否已被消费者成功处理，从而保证消息的可靠性。 8. **持久化** 通过配置，可以将消息和队列设置为持久化，即使服务器重启，数据也不会丢失。 9. **集群和高可用...
RabbitMQ（三）发布确认
agululu的博客
06-08 510
mq发布确认
RabbitMQ系列（10）--RabbitMQ发布确认模式的概念及实现
m0_64284147的博客
07-05 1386
已确认的消息没必要处理，而未确认的消息需要进行重新入队的处理，但由上述步骤(2)的效果图可看出程序在执行完后监听器还在监听消息是否确认成功，而要怎么做才能在程序执行完后再处理监听器监听出来未确认的消息呢？异步确认发布实现逻辑比上面两种要复杂，但性价比高，无论是可靠性还是效率都非常突出，异步确认发布通过回调函数来达到消息可靠性传递，消息的结构类似于map，都是key-value的结构，当相应的消息被消费了或消费失败了，都可以通过对应的key值来确认消费或消费失败的是哪一条消息，所以可靠性很高。
RabbitMQ 学习（七）----发布确认
rain67的博客
10-06 2024
保证生产者将信息成功的发送到 RabbitMQ的 server端了，那么broker就会回一个确认，如果没有收到或者收到拒绝信息，那么说明可能网络不好没有发送成功，server端宕机了，broker拒绝接收等情况，如果不进行后续处理，那么信息就会丢失，生产者收到失败的消息使用回调函数在进行处理。如果队列和信息是持久化的，那么确认消息会在将消息写入磁盘之后再发出，broker返回的确认包含 确认消息的序列号，还可以设置 multiple，表示此序号前的所有消息都得到了处理。2、设置队列中的消息持久化。
rabbitMq发布确认
qq_28227405的博客
01-29 494
rabbitMq存在消息丢失的风险，包括生产者消息丢失，服务器消息丢失，消费者消息丢失这3种情况。批量消息的发布确认其实和单条消息的确认方案非常像，只是在消息确认的时候是以一个批次多条消息的方式进行确认。但这种方式有一个缺点一旦消息发布确认结果是失败的，就只能知道是这个批次中有某些消息是未发送到Broker，但不知道具体是哪条消息。消息发布确认主要包括单条消息发布确认，批量消息发布确认，消息异步确认这三种方案，在工作中选择使用消息异步确认的方案是最多最常用的。
RabbitMQ--发布确认
2303_76501210的博客
09-18 215
之后，此时我们发布的信息就会被加上一个唯一ID，一旦信息被接收boker就会告诉生产者，如果消息和队列是可持久化的，那么确认消息会在将消息写入磁盘之后发出，broker 回传给生产者的确认消息中 delivery-tag 域包含了确认消息的序列号，此外 broker 也可以设置 basic.ack 的 multiple 域，表示到这个序列号之前的所有消息都已经得到了处理。，因为如果没有确认发布的消息就会阻塞所有后续消息的发布，这种方式最多提供每秒不超过数百条发布消息的吞吐量。，其中异步确认发布性能最好。
rabbitmq3.8.16-linux-centos7.x
04-05
7. **插件与扩展**：RabbitMQ有多种内置和第三方插件，例如用于监控的management插件，用于日志记录的logging插件等，学习如何启用和配置它们。 8. **消息确认机制**：理解publisher confirms和consumer ...
最新版windows rabbitmq-server-3.8.5.zip
06-22
9. **消息确认**：RabbitMQ支持消息确认机制，确保消息被正确处理，避免因消费者异常导致的消息丢失。 10. **持久化**：为了保证消息的可靠性，RabbitMQ提供了消息持久化功能，即使服务器重启，消息也不会丢失。 ...
RabbitMQ入门-实战-RabbitMQ.zip
11-07
**RabbitMQ 入门与实战** RabbitMQ 是一个基于 AMQP（Advanced Message Queuing Protocol）协议的开源消息...在 RabbitMQ-master 文件中，可能包含了示例代码和教程，可以帮助你进一步学习和掌握 RabbitMQ 的使用。
官网的rabbitmq-server-3.10.0
05-07
6. **消息确认机制**：RabbitMQ提供了消息确认机制，允许消费者确认它们已经处理了消息，这有助于防止消息丢失。在3.10.0版本中，可能会有对这一机制的优化。 7. **安全与认证**：RabbitMQ支持多种身份验证和授权...
RabbitMQ 发布确认机制
zyppxx的博客
08-09 1155
发布确认模式是避免消息由生产者到RabbitMQ消息丢失的一种手段。
RabbitMq之发布确认
chd_sun的博客
01-27 310
与单个等待确认消息相比，先发布一批消息然后一起确认可以极大地提高吞吐量，当然这种方式的缺点就是:当发生故障导致发布出现问题时，不知道是哪个消息出现问题了，我们必须将整个批处理保存在内存中，以记录重要的信息而后重新发布消息。当然这种方案仍然是同步的，也一样阻塞消息的发布。一种同步确认发布的方式，也就是发一个消息以后只有他被确认发布，后续的才能继续发布。保证消息不丢失，除了队列开启持久化，消息开启持久化之后，还要发布确认才能完全保证消息不丢失。要如何处理未发布确认的消息，简单记录代码如下。
RabbitMQ:发布确认模式
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-09 2507
生产者把信道设置成为confirm(确认)模式，一旦信道进入confirm模式，所有在这个信道上面发布的消息都会被指定唯一的一个ID(ID从1开始).一旦消息被投递到所有匹配的队列以后，broker就会发送一个确认给生产者(包含ID),这样使得生产者知道消息已经正确到底目的队列了。如果消息和队列是可持久化的，那么确认消息就会在消息被写入磁盘以后发出，broker回传给生产者的确认消息中delivery-tag包含了确认消息的序列号。
RabbitMQ的发布确认机制
qq_37129192的博客
02-16 1075
1、发布确认的原理 生产者将信道设置成confirm模式，所有在该信道上面发布的消息都将会被指派一个唯一的ID（从1开始）， 一旦消息被投送到匹配的队列之后，broker就会发送一个确认消息给生产者（包含消息唯一的ID）， 如果消息和队列是可持久化的，那么确认消息将在写入磁盘之后发送确认消息给生产者 confirm模式最大的好处就是异步的，可以一边等待消息的返回，同时可继续发布下一条消息。 当消息最终得到确认之后，生产者应用便可以通过回调方法来处理该确认消息， 如果 RabbitMQ 因为自身内部错误导致消
RabbitMQ——发布确认模式
最新发布
万里顾一程的博客
03-02 610
单条发布确认（Single Publisher Confirm）是最基本的确认模式，在发布一条消息后，等待服务器确认该消息是否成功接收。异步确认是一种更灵活的确认方式，通过回调函数处理消息的确认和未确认事件。缺点：当一批消息中有一条消息发送失败时，整个批量确认失败，可能需要重新发送整批消息且不知道是哪条消息失败。批量发布确认模式允许在一次性确认多个消息是否成功被服务器接收，这在大量消息的场景中可以提高效率。RabbitMQ 发布确认模式的三种形式：单条确认、批量确认和异步确认。
RabbitMQ之发布确认
JAVA开发区的博客
07-05 835
三种发布确认方式：单独发布消息、批量发布消息、异步处理
【RabbitMQ七】——RabbitMQ发布确认模式（Publisher Confirms）
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
02-28 754
发布确认是解决消息不丢失的重要环节，在设置队列持久化、消息持久化的基础上，设置发布确认，一旦生产者投递消息之后，如果Broker接收到消息，会给生产者一个应答。生产者进行接收应答，用来确认这条消息是否正常发送到Broker。生产者也可以根据收没有收到这条消息的应答进行相应的处理。在某些应用程序中，确保发布的消息到达代理非常重要。发布者确认RabbitMQ的特性可以帮助满足这一要求。发布者确认本质上是异步的，但也可以同步地处理它们。没有确定的方法来实现发布者确认，这通常归结于应用程序和整个系统中的约束。
RabbitMQ学习笔记：Java操作与Spring整合
"这是一份关于RabbitMQ的学习资料，涵盖了从基础的Java操作到Spring的整合使用，同时还包括了一些有价值的博客链接。" RabbitMQ是企业级的消息中间件，常用于实现分布式系统中的异步处理、应用解耦、流量削锋以及...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值