RabbitMQ实现六类工作模式

😊 @ 作者： 一恍过去

💖 @ 主页： https://blog.csdn.net/zhuocailing3390

🎊 @ 社区： Java技术栈交流

🎉 @ 主题： RabbitMQ实现六类工作模式

⏱️ @ 创作时间： 2023年07月20日

1、概述

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

2、工具类封装

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

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

public class Producer {/*** 设置队列名称*/private final static String QUEUE_NAME = "hello";public static void main(String[] args) throws Exception {// 获取ChannelChannel 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("消息发送完毕");}
}

消费者：

public class Consumer {/*** 设置队列名称*/private final static String QUEUE_NAME = "hello";public static void main(String[] args) throws Exception {// 获取ChannelChannel 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

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 代码为例：

// Consumer01与Consumer02代码一致
public class Consumer01 {/*** 设置队列名称*/private final static String QUEUE_NAME = "hello";public static void main(String[] args) throws Exception {// 获取ChannelChannel 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

public class Producer {/*** 定义交换机和队列名称*/private static final String EXCHANGE_NAME = "fanout_exchange";public static void main(String[] args) throws Exception {// 获取ChannelChannel 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 代码为例：

/**
*两个消费者逻辑代码一样，只是绑定的队列不同，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 {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();//消费者关联队列channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKeychannel.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

生产者：

public class Producer {/*** 定义交换机和队列名称*/private static final String EXCHANGE_NAME = "direct_exchange";public static void main(String[] args) throws Exception {// 获取ChannelChannel 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 代码为例：

/**
* 两个消费者逻辑代码一样，只是绑定的队列不同和不同的路由键
* 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 {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();//消费者关联队列channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKeychannel.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

生产者：

public class Producer {/*** 定义交换机和队列名称*/private static final String EXCHANGE_NAME = "topic";public static void main(String[] args) throws Exception {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();/*绑定的交换机 参数1交互机名称 参数2 exchange类型 */channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);// 定义路由keyString 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("消息发送完毕");}
}

消费者：

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 {// 获取ChannelChannel channel = RabbitMqUtils.getChannel();//消费者关联队列channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 消费者绑定交换机 参数1 队列 参数2 交换机 参数3 routingKeychannel.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

public class Consumer {//设置队列名称private final static String QUEUE_NAME = "confirm_queue";public static void main(String[] args) throws Exception {// 获取ChannelChannel 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、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

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、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

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、消费者实现》；
步骤： 启动消费者，发送消息，然后观察耗时即可；

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) {//返回的是小于等于当前序列号的未确认消息    是一个  mapConcurrentNavigableMap<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