复制代码

😊 @ 作者：一恍过去
💖 @ 主页： https://blog.csdn.net/zhuocailing3390
🎊 @ 社区： Java技术栈交流
🎉 @ 主题： RabbitMQ实现六类工作模式
⏱️ @ 创作时间： 2023年07月20日

1、概述

六模式：简单模式、工作模式、发布订阅模式、路由模式、主题模式、发布确认模式
参考代码： https://gitee.com/lhzlx/rabbit-simple-demo.git

2、工具类封装

在下面每种模式的笔记中，会进行代码演示，为了方便，进行工具类的封装，代码如下：

java 复制代码

public class RabbitMqUtils {
    /**
     * 得到一个连接的  channel
     *
     * @return
     * @throws Exception
     */
    public static Channel getChannel() throws Exception {
        //创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("admin");
        factory.setPassword("admin");
        Connection connection = factory.newConnection();
        return connection.createChannel();
    }
}

3、简单列队模式

由生产者通过直接将消息发送到消费者

代码包路径： lhz.simple

java 复制代码

public class Producer {
    /**
     * 设置队列名称
     */
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();
        /*
         * 生成一个队列
         * 1.队列名称
         * 2.队列里面的消息是否持久化   默认消息存储在内存中
         * 3.该队列是否只供一个消费者进行消费   是否进行共享   true可以多个消费者消费
         * 4.是否自动删除   最后一个消费者端开连接以后   该队列是否自动删除   true 自动删除
         * 5.其他参数
         */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "hello world";
        /*
         * 发送一个消息
         * 1.发送到那个交换机(可以没有)
         * 2.路由的  key是哪个
         * 3.其他的参数信息
         * 4.发送消息的消息体
         */
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println("消息发送完毕");
    }
}

消费者：

java 复制代码

public class Consumer {
    /**
     * 设置队列名称
     */
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();

        // 消费队列消息的一个回调接口
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println("消息消费成功,内容:");
            System.out.println(message);
        };
        // 取消消费的一个回调接口   如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println("消息消费被中断");
        };
        /*
         * 消费者消费消息
         * 1.消费哪个队列
         * 2.消费成功之后是否要自动应答   true代表自动应答   false手动应答
         * 3.消费者未成功消费的回调
         * 3.消费者取消消费的的回调
         */
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
        System.out.println("等待接收消息....");
    }
}

4、工作列队模式

工作队列： 用来将耗时的任务分发给多个消费者，并且一个消息只能被消费一次，默认情况下RabbitMQ 将按顺序将每条消息发送给下一个消费者==(即轮询分发)==。

主要解决问题： 处理资源密集型任务，并且还要等他完成。有了工作队列，我们就可以将具体的工作放到后面去做，将工作封装为一个消息，发送到队列中，一个工作进程就可以取出消息并完成工作。如果启动了多个工作进程，那么工作就可以在多个进程间共享。

代码包路径： lhz.work

java 复制代码

public class Producer {
    /**
     * 设置队列名称
     */
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        try (Channel channel = RabbitMqUtils.getChannel();) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 从控制台当中接受信息
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()) {
                String message = scanner.next();
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                System.out.println("发送消息完成:" + message);
            }
        }
    }
}

消费者：

消费者需要两个，分别为：Consumer01 、Consumer02两者代码一致，只是名称不同，下面以Consumer01 代码为例：

java 复制代码

// Consumer01与Consumer02代码一致
public class Consumer01 {
    /**
     * 设置队列名称
     */
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();
        // 消费队列消息的一个回调接口
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println("Consumer01消息消费成功,内容:");
            System.out.println(message);
        };
        // 取消消费的一个回调接口   如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println("Consumer01消息消费被中断");
        };
        
        //采用自动应答
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
        System.out.println("Consumer01等待接收消息....");
    }
}

结果：

为了演示工作队列的轮询分发，需要启动两个Consumer实例，然后再启动Producer并且在控制台多次输入内容，可以看到两个Consumer会依次接收消息，结果如下：

5、发布/订阅模式

发布/订阅模式是：

生产者将消息发送到交换机中，由交换机发送给不同类型的消费者，做到发布一次，消费多个，如果消费者绑定的队列名称一样，将按照轮询进行消费，所以保证了：同一个队列的中的消息不会被重复消费；

比如：

它包含一个生产者、多个消费者、两个队列和一个交换机。两个消费者同时绑定到不同的队列上去，两个队列绑定到交换机上去，生产者通过发送消息到交换机，所有消费者接收并消费消息。

代码包路径： lhz.fanout

java 复制代码

public class Producer {

    /**
     * 定义交换机和队列名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();

        /*绑定的交换机 参数1交互机名称 参数2 exchange类型 */
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        for (int i = 0; i < 10; i++) {
            String message = "消息：" + i;
            // 发送一个消息,1.发送到那个交换机,2.路由的  key是哪个,3.其他的参数信息,4.发送消息的消息体
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
        }
        System.out.println("消息发送完毕");
    }
}

消费者：

消费者需要两个，分别为：Consumer01 、Consumer02两者代码一致，只是名称不同，下面以Consumer01 代码为例：

java 复制代码

/**
*两个消费者逻辑代码一样，只是绑定的队列不同，Consumer01：consumerFanout_sms；Consumer02：consumerFanout_email
*/
public class Consumer01(02) {
    /**
     * 设置队列及交换机名称
     */
    private static final String QUEUE_NAME = "consumerFanout_sms";
    private static final String QUEUE_NAME = "consumerFanout_email";
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();

        //消费者关联队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKey
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        // 消费队列消息的一个回调接口
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println("Consumer01(02)消息消费成功,内容:");
            System.out.println(message);
        };
        // 取消消费的一个回调接口   如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println("Consumer01(02)消息消费被中断");
        };

        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
        System.out.println("Consumer01(02)等待接收消息....");
    }
}

结果：

先启动一次生产者，再启动两个消费者，绑定到交换机A，以及两个不同的队列、然后再重新启动生产者，绑定到交换机A；

在生产者发生消息以后，两个不同名称的消费者队列都可以接收到消息相同的内容，这些因为不同的消费者绑定了同一个交换机
注意：如果消费者绑定的队列名称一样，将按照轮询进行消费，所以保证了：同一个队列的中的消息不会被重复消费；**

6、路由模式

路由模式：

跟发布订阅模式类似，在订阅模式的基础上修改了exchange类型以及加上了路由键，如果消费者的路由键一样，其效果和发布/订阅模式一致，订阅模式是分发到所有绑定到交换机的所有队列，路由模式只分发到绑定在交换机上面指定路由键的队列 ，一个队列可以绑定多个不同的路由

注意： 消息可能匹配多个消费者，但是同一个队列的中的消息不会被重复消费；；

我们可以看一下下面这张图：

在上面这张图中，我们可以看到 X 绑定了两个队列，绑定类型是 direct。队列 Q1 绑定键为 orange，队列 Q2 绑定键有两个:一个绑定键为 black，另一个绑定键为 green。

在这种绑定情况下，生产者发布消息到 exchange 上，绑定键为 orange 的消息会被发布到队列 Q1。绑定键为 black、green的消息会被发布到队列 Q2，其他消息类型的消息将被丢弃。

说明： 生产者发送消息到交换机，同时定义了一个路由 routingKey，多个消费者声明多个队列，与交换机进行绑定，同时定义路由 routingKey，只有和生产者发送消息时的路由 routingKey相同的消费者才能消费数据；

注意： 如果交换机和路由绑定后，需要修改路由就要修改交换机名称

代码包路径： lhz.route

生产者：

java 复制代码

public class Producer {

    /**
     * 定义交换机和队列名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();

        /*绑定的交换机 参数1交互机名称 参数2 exchange类型 */
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 发送消息
        String message = "", sendType = "";
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                sendType = "info";
                message = "我是 info 级别的消息类型：" + i;
            } else {
                sendType = "error";
                message = "我是 error 级别的消息类型：" + i;
            }
            System.out.println("[send]：" + message + "  " + sendType);

            // 第二个参数就是路由键
            channel.basicPublish(EXCHANGE_NAME, sendType, null, message.getBytes());
        }
        System.out.println("消息发送完毕");
    }
}

消费者：

消费者需要两个，分别为：Consumer01 、Consumer02两者代码一致，只是名称不同，下面以Consumer01 代码为例：

java 复制代码

/**
* 两个消费者逻辑代码一样，只是绑定的队列不同和不同的路由键
* Consumer01:"info"、"consumer_info"；Consumer02:"error"、"consumer_error"；
*/
public class Consumer01(02) {
    /**
     * 设置队列及交换机名称
     */
    private static final String ROUTING_KEY = "info";
    private static final String ROUTING_KEY = "error";
    private static final String QUEUE_NAME = "consumer_info";
    private static final String QUEUE_NAME = "consumer_error";
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();

        //消费者关联队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKey
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTING_KEY);

        // 消费队列消息的一个回调接口
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println("Consumer01(02)消息消费成功,内容:");
            System.out.println(message);
        };
        // 取消消费的一个回调接口   如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println("Consumer01(02)消息消费被中断");
        };

        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
        System.out.println("Consumer01(02)等待接收消息....");
    }
}

结果：

先启动一次生产者，再启动两个消费者，绑定到交换机A，以及两个不同的队列和不同的路由键；最后重新启动生产者，绑定到交换机A；

7、主题模式

主题模式：

跟 routing 路由模式类似，只不过路由模式是指定固定的路由键 routingKey，而主题模式是可以模糊匹配路由routingKey，类似于SQL中 = 和 like 的关系

注意：消息可能匹配多个消费者，但是同一个队列的中的消息不会被重复消费；
要求：

要求

Topic 模式消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单词列表，以 "." 或者 "#" 分隔开。这些单词可以是任意单词，这个单词列表最多不能超过 255 个字节。

分隔符

"*(星号)"：可以代替一个单词

"#(井号)"：可以替代零个或多个单词

比如

中间带 orange 带3个单词： *.orange.*

最后一个词是 rabbit 的3 个单词：*.*.rabbit

以 lazy开头的多个单词lazy.#

图示：

注意： 如果交换机和路由绑定后，需要修改路由就要修改交换机名称

代码包路径： lhz.toptic

生产者：

java 复制代码

public class Producer {

    /**
     * 定义交换机和队列名称
     */
    private static final String EXCHANGE_NAME = "topic";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();

        /*绑定的交换机 参数1交互机名称 参数2 exchange类型 */
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 定义路由key
        String routingKey = "mq.info.log";
        String message = "topic_exchange_msg：" + routingKey;
        System.out.println("[send] = " + message);
        // 发送消息

        // 第二个参数就是路由键
        channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
        System.out.println("消息发送完毕");
    }
}

消费者：

java 复制代码

public class Consumer {

    /**
     * 设置路由匹配规则
     */
    private static final String ROUTING_KEY = "#.log";
    /**
     * 设置队列及交换机名称
     */
    private static final String QUEUE_NAME = "topic_consumer";
    private static final String EXCHANGE_NAME = "topic";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();

        //消费者关联队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKey
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTING_KEY);

        // 消费队列消息的一个回调接口
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println("消息消费成功,内容:");
            System.out.println(message);
        };
        // 取消消费的一个回调接口   如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println("消息消费被中断");
        };

        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
        System.out.println("等待接收消息....");
    }
}

结果：

先启动消费者，绑定到交换机A，通过通配符模糊匹配路由；再启动生产者，绑定到交换机A，设置具体的路由键；

8、交换机说明

在没有交换机的情况，生产者直接往队列发送消息，消费者绑定队列消费相消息，但是同一个队列中一个消息只会被消费一次，所以无法满足一个消息同时被多个消费者使用；

交换机的作用就可以解决这个问题，一个交换机可以绑定多个不同的队列，一个队列绑定多个消费者；生产者将消息发送到交换机中，所有绑定了该交换机的队列都可以收到消息；所以生产者发送一次消息，可以被不同的队列**(消费者)**进行消费；当同一个队列中存在多个消费者时，消息不会被重复消费；

9、发布确认模式(消息确认机制)

概念： 生产者将信道设置成 确认(confirm) 模式，一旦信道进入 confirm 模式，所有在该信道上面发布的消息都将会被指派一个唯一的 ID(从 1 开始)，一旦消息被投递到所有匹配的队列之后，broker就会发送一个确认给生产者(包含消息的唯一 ID)，这就使得生产者知道消息已经正确到达目的队列了，如果消息和队列是可持久化的，那么确认消息会在将消息写入磁盘之后发出，broker 回传给生产者的确认消息中 delivery-tag 域包含了确认消息的序列号。

优点： confirm 模式最大的好处在于他是异步的 ，一旦发布一条消息，生产者就可以在等待信道返回确认的同时继续发送下一条消息 ，当消息最终得到ack之后 ，生产者可以通过回调方法来处理该ack消息；如果 RabbitMQ 因为自身内部错误导致消息丢失，就会发送一条 nack 消息，生产者应用程序同样可以在回调方法中处理该 nack 消息；

使用： 发布确认模式默认是没有开启的，生产者通过调用方法 confirmSelect实现开启

9.1、消费者实现

代码包路径： lhz.confirm

java 复制代码

public class Consumer {
    
    //设置队列名称
    private final static String QUEUE_NAME = "confirm_queue";

    public static void main(String[] args) throws Exception {
        // 获取Channel
        Channel channel = RabbitMqUtils.getChannel();
        
        // 消费队列消息的一个回调接口
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println("消息消费成功,内容:");
            System.out.println(message);
        };
        // 取消消费的一个回调接口   如在消费的时候队列被删除掉了
        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println("消息消费被中断");
        };
        
        // 消费者消费消息
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, cancelCallback);
        System.out.println("等待接收消息....");
    }
}

9.2、单个确认发布(生产者实现)

单个确认发布：

是一种简单的确认方式，它是一种**同步确认发布** 的方式，也就是发布的消息只有被确认发布之后，后续的消息才能继续发布,通过waitForConfirmsOrDie(long outTime)方法，指定时间范围内(单位:毫秒 )这个消息没有被确认那么它将抛出异常；通过waitForConfirms()对broker响应的消息进行确认；

这种确认方式有一个最大的缺点就是：发布速度特别的慢 ，因为如果没有确认发布的消息就会阻塞所有后续消息的发布 ，这种方式最多提供每秒不超过数百条发布消息的吞吐量，当然对于某些应用程序来说这可能已经足够了。

代码包路径： lhz.confirm
类： SingleProducer
说明： 确认发布的实现只是对生产者代码做修改，所以消费者代码不变，参考：《9.1、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

java 复制代码

public class SingleProducer {

    // 设置队列名称
    private final static String QUEUE_NAME = "confirm_queue";
    // 发送消息数量
    private final static Integer MESSAGE_COUNT = 100;

    public static void main(String[] args) throws Exception {
        try (Channel channel = RabbitMqUtils.getChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            //开启发布确认
            channel.confirmSelect();
            long begin = System.currentTimeMillis();
            for (int i = 0; i < MESSAGE_COUNT; i++) {
                String message = i + "";
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                //服务端返回确认状态，如果 false或超时时间内未返回，生产者可以消息重发
                boolean flag = channel.waitForConfirms();
                if (flag) {
                    System.out.println("消息发送成功");
                }
            }
            long end = System.currentTimeMillis();
            System.out.println("发布" + MESSAGE_COUNT + "个单独确认消息,耗时" + (end - begin) + "ms");
        }
    }
}

9.3、批量确认发布(生产者实现)

批量确认发布：

与单个等待确认消息相比，会先发布一批消息然后一起确认 可以极大地提高吞吐量，它也是一种**同步确认发布** 的方式。

这种方式的缺点就是： 当消息发布出现问题时，不知道是哪个消息出现问题了；

代码包路径： lhz.confirm
类： BatchProducer

**说明：**确认发布的实现只是对生产者代码做修改，所以消费者代码不变，参考：《9.1、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

java 复制代码

public class BatchProducer {

    // 设置队列名称
    private final static String QUEUE_NAME = "confirm_queue";
    // 发送消息数量
    private final static Integer MESSAGE_COUNT = 100;

    public static void main(String[] args) throws Exception {
        try (Channel channel = RabbitMqUtils.getChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 开启发布确认
            channel.confirmSelect();
            // 批量确认消息大小
            int batchSize = 100;
            // 未确认消息个数
            int outstandingMessageCount = 0;
            long begin = System.currentTimeMillis();
            for (int i = 0; i < MESSAGE_COUNT; i++) {
                String message = i + "";
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                outstandingMessageCount++;
                // 达到设置的批处理大小时，进行确认
                if (outstandingMessageCount == batchSize) {
                    channel.waitForConfirms();
                    outstandingMessageCount = 0;
                }
            }
            // 为了确保还有剩余没有确认消息，进行再次确认
            if (outstandingMessageCount > 0) {
                channel.waitForConfirms();
            }
            long end = System.currentTimeMillis();
            System.out.println("发布" + MESSAGE_COUNT + "个批量确认消息,耗时" + (end - begin) + "ms");
        }
    }
}

9.4、异步确认发布(生产者实现)

异步确认发布：

虽然编程逻辑比上两个要复杂，但是可靠性和效率更高；他是利用回调函数来保证是否投递成功。逻辑图如下：

代码包路径： lhz.confirm
类： AsynProducer

**说明：**确认发布的实现只是对生产者代码做修改，所以消费者代码不变，参考：《9.1、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

java 复制代码

public class AsynProducer {
    /**
     * 设置队列名称
     */
    private final static String QUEUE_NAME = "confirm_queue";

    /**
     * 发送消息数量
     */
    private final static Integer MESSAGE_COUNT = 500;

    public static void main(String[] args) throws Exception {
        try (Channel channel = RabbitMqUtils.getChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            //开启发布确认
            channel.confirmSelect();
            /*
             * 线程安全有序的一个哈希表，适用于高并发的情况
             * 1.轻松的将序号与消息进行关联
             * 2.轻松批量删除条目    只要给到序列号
             * 3.支持并发访问
             */
            ConcurrentSkipListMap<Long, String> outstandingConfirms = new ConcurrentSkipListMap();

            /*
             * 确认收到消息的一个回调
             * 1.消息序列号
             * 2.true可以确认小于等于当前序列号的消息
             *   false确认当前序列号消息
             */
            ConfirmCallback ackCallback = (sequenceNumber, multiple) -> {
                if (multiple) {
                    //返回的是小于等于当前序列号的未确认消息    是一个  map
                    ConcurrentNavigableMap<Long, String> confirmed = outstandingConfirms.headMap(sequenceNumber, true);
                    //清除该部分未确认消息
                    confirmed.clear();
                } else {
                    //只清除当前序列号的消息
                    outstandingConfirms.remove(sequenceNumber);
                }
            };
            // 未被确认消息回调
            ConfirmCallback nackCallback = (sequenceNumber, multiple) -> {
                String message = outstandingConfirms.get(sequenceNumber);
                System.out.println("未被确认消息：" + message + "，序列号" + sequenceNumber);
            };
            /*
             * 添加一个异步确认的监听器
             * 1.确认收到消息的回调
             * 2.未收到消息的回调
             */
            channel.addConfirmListener(ackCallback, nackCallback);
            long begin = System.currentTimeMillis();
            for (int i = 0; i < MESSAGE_COUNT; i++) {
                String message = "消息" + i;
                /*
                 * channel.getNextPublishSeqNo()获取下一个消息的序列号
                 * 通过序列号与消息体进行一个关联
                 * 全部都是未确认的消息体
                 */
                outstandingConfirms.put(channel.getNextPublishSeqNo(), message);
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            }
            long end = System.currentTimeMillis();
            System.out.println("发布" + MESSAGE_COUNT + "个异步确认消息,耗时" + (end - begin) + "ms");
        }
    }
}

9.5、三类确认发布区别对比

单独发布消息

同步等待确认，简单，但吞吐量非常有限，较耗时。
批量发布消息

批量同步等待确认，简单，合理的吞吐量，一旦出现问题但很难推断出是那条消息出现了问题，效率较高。
异步处理：

最佳性能和资源使用，在出现错误的情况下可以很好地控制，但是实现起来稍微难些，效率高。

10、源码地址

源码地址：https://gitee.com/lhzlx/rabbit-simple-demo.git

复制代码

RabbitMQ实现六类工作模式

目录

1、概述

2、工具类封装

3、简单列队模式

4、工作列队模式

5、发布/订阅模式

6、路由模式

7、主题模式

8、交换机说明

9、发布确认模式(消息确认机制)

9.1、消费者实现

9.2、单个确认发布(生产者实现)

9.3、批量确认发布(生产者实现)

9.4、异步确认发布(生产者实现)

9.5、三类确认发布区别对比

10、源码地址