一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第6天，点击查看活动详情。

1. RabbitMQ的概念

1.1 什么是RabbitMQ

RabbitMQ是一个消息中间件：它接收并转发消息。你可以把它当作一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑RabbitMQ是一个快递站，一个快递员帮你快递快件。RabbitMQ与快递站的主要区别在于，它不处理快件而是接收，存储和转发消息数据。

1.2 四大核心概念

生产者

产生数据发送消息的程序

交换机

交换机是RabbitMQ非常重要的一个部件，一方面它接收来自生产者的消息，另一方面它将消息推送到队列中。交换机必须确切知道如何处理它接收到的消息，是将这些消息送到特定队列还是推送到多个队列，亦或者是把消息丢弃，这个得有交互及类型决定。

队列

队列是 RabbitMQ 内部使用的一种数据结构，尽管消息流经 RabbitMQ 和应用程序，但它们只能存储在队列中。队列仅受主机的内存和磁盘限制的约束，本质上是一个大的消息缓冲区。许多生产者可以将消息发送到一个队列，许多消费者可以尝试从一个队列接收数据。这就是我们使用队列的方式

消费者

消费与接收具有相似的含义。消费者大多时候是一个等待接收消息的程序。请注意生产者，消费者和消息中间件很多时候并不在同一机器上。同一个应用程序既可以是生产者又是可以是消费者。

2. RabbitMQ工作原理

Broker：接收和分发消息的应用，RabbitMQ Server 就是 Message Broker
Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个 vhost，每个用户在自己的 vhost 创建 exchange／queue 等
Connection：publisher／consumer 和 broker 之间的 TCP 连接
Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection 的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个 thread 创建单独的 channel 进行通讯，AMQP method 包含了 channel id 帮助客户端和 message broker 识别 channel，所以 channel 之间是完全隔离的。 l Channel 作为轻量级的Connection 极大减少了操作系统建立 TCP connection 的开销
Exchange ： message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到 queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout(multicast)
Queue ：消息最终被送到这里等待 consumer 取走
Binding ： exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key，Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据

3. RabbitMQ的使用

导入依赖

<dependencies>
<!--rabbitmq 依赖客户端 -->
	<dependency>
		<groupId>com.rabbitmq</groupId>
		<artifactId>amqp-client</artifactId>
		<version>5.8.0</version>
	</dependency>
<!-- 操作文件流的一个依赖 -->
	<dependency>
		<groupId>commons-io</groupId>
		<artifactId>commons-io</artifactId>
		<version>2.6</version>
	</dependency>
</dependencies>

生产者代码

public class Producer {
	//队列名称
	private final static String QUEUE_NAME = "hello";
	
	public static void main(String[] args) throws Exception {
		// 创建一个连接工厂
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("101.201.72.216");
		factory.setUsername("admin");
		factory.setPassword("123");
		//channel 实现了自动 close 接口 自动关闭 不需要显示关闭
		try(Connection connection = factory.newConnection();Channel channel = connection.createChannel()) {
			/**
			* 生成一个队列
			* 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 {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("101.201.72.216");
		factory.setUsername("admin");
		factory.setPassword("123");
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		System.out.println(" 等待接收消息....");
		// 推送的消息如何进行消费的接口回调
		DeliverCallback deliverCallback=(consumerTag,delivery)->{
			String message= new String(delivery.getBody());
			System.out.println(message);
		};
		// 取消消费的一个回调接口 如在消费的时候队列被删除掉了
		CancelCallback cancelCallback=(consumerTag)->{
			System.out.println(" 消息消费被中断");
		};
		/**
		* 消费者消费消息
		* 1. 消费哪个队列
		* 2. 消费成功之后是否要自动应答 true 代表自动应答 false 手动应答
		* 3. 消费者未成功消费的回调
		* 4. 消费者取消消费的回调
		*/
		channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
	}
}

4. 工作队列

原理：一个生产者大量发消息，多个消费者消费。利用轮训的方式实现，一个一个执行消息。

连接工厂工具类抽取

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

创建一个工作线程（消费者）

public class Worker01 {
	private static final String QUEUE_NAME="hello";
	public static void main(String[] args) throws Exception {
		Channel channel = RabbitMqUtils.getChannel();
		DeliverCallback deliverCallback=(consumerTag,delivery)->{
		String receivedMessage = new String(delivery.getBody());
			System.out.println(" 接收到消息:"+receivedMessage);
		};
		CancelCallback cancelCallback=(consumerTag)->{
			System.out.println(consumerTag+" 消费者取消消费接口回调逻辑");
		};
		System.out.println("C2 消费者启动等待消费......");
		channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
	}
}

创建发送线程（生产者）

public class Task01 {
	private static final 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);
			}
		}
	}
}

5. 消息应答

为了保证消息在发送过程中不丢失，rabbitmq 引入消息应答机制，消息应答就是: 消费者在接收到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了，rabbitmq 可以把该消息删除了。

5.1 消息应答方法

Channel.basicAck(用于肯定确认),RabbitMQ 已知道该消息并且成功的处理消息；可以将其丢弃了
Channel.basicNack(用于否定确认)
Channel.basicReject(用于否定确认),与 Channel.basicNack 相比少一个参数；不处理该消息了直接拒绝，可以将其丢弃了

5.2 消息手动应答实现

生产者

public class Task02 {
	private static final String TASK_QUEUE_NAME = "ack_queue";
	public static void main(String[] argv) throws Exception {
		try (Channel channel = RabbitMqUtils.getChannel()) {
			channel.queueDeclare(TASK_QUEUE_NAME, false, false, false, null);
			Scanner sc = new Scanner(System.in);
			System.out.println(" 请输入信息");
			while (sc.hasNext()) {
				String message = sc.nextLine();
				channel.basicPublish("", TASK_QUEUE_NAME, null, message.getBytes("UTF-8"));
				System.out.println(" 生产者发出消息" + message);
			}
		}
	}
}

消费者

public class Work03 {
	private static final String ACK_QUEUE_NAME="ack_queue";
	public static void main(String[] args) throws Exception {
		Channel channel = RabbitMqUtils.getChannel();
		System.out.println("C1 等待接收消息处理时间较短");
		// 消息消费的时候如何处理消息
		DeliverCallback deliverCallback=(consumerTag,delivery)->{
			String message= new String(delivery.getBody());
			SleepUtils.sleep(1);
			System.out.println(" 接收到消息:"+message);
			/**
			* 1. 消息标记 tag
			* 2. 是否批量应答未应答消息
			*/
			channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
		};
		// 采用手动应答
		boolean autoAck=false;
		channel.basicConsume(ACK_QUEUE_NAME,autoAck,deliverCallback,(consumerTag)->{
			System.out.println(consumerTag+" 消费者取消消费接口回调逻辑");
		});
	}
}

睡眠工具类

public class SleepUtils {
	public static void sleep(int second){
		try {
			Thread.sleep(1000*second);
		} catch (InterruptedException _ignored) {
			Thread.currentThread().interrupt();
		}
	}
}

6. RabbitMQ持久化

刚刚我们已经看到了如何处理任务不丢失的情况，但是如何保障当 RabbitMQ 服务停掉以后消息生产者发送过来的消息不丢失。默认情况下 RabbitMQ 退出或由于某种原因崩溃时，它忽视队列和消息，除非告知它不要这样做。确保消息不会丢失需要做两件事：我们需要将队列和消息都标记为持久化。

队列持久化：定义队列的时候将druable参数设置为true

boolean durable = true;
channel.queueDeclare(ACK_QUEUE_NAME, durable, false, false, null);

消息持久化

channel.basicPublish("", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes("UTF-8"));

发布确认

//开启发布确认
channel.confirmSelect();

3.1 单个发布确认

public static void publishMessageIndividually() throws Exception {
	try (Channel channel = RabbitMqUtils.getChannel()) {
		String queueName = UUID.randomUUID().toString();
		channel.queueDeclare(queueName, false, false, false, null);
		// 开启发布确认
		channel.confirmSelect();
		long begin = System.currentTimeMillis();
		for (int i = 0; i < MESSAGE_COUNT; i++) {
			String message = i + "";
			channel.basicPublish("", queueName, 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");
	}
}

 3.2 批量确认发布

public static void publishMessageBatch() throws Exception {
	try (Channel channel = RabbitMqUtils.getChannel()) {
			String queueName = UUID.randomUUID().toString();
			channel.queueDeclare(queueName, 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("", queueName, 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");
	}
}

3.3 异常确认发布

public static void publishMessageAsync() throws Exception {
	try (Channel channel = RabbitMqUtils.getChannel()) {
		String queueName = UUID.randomUUID().toString();
		channel.queueDeclare(queueName, 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, null);
		long begin = System.currentTimeMillis();
		for (int i = 0; i < MESSAGE_COUNT; i++) {
			String message = " 消息" + i;
			/**
			* channel.getNextPublishSeqNo() 获取下一个消息的序列号
			* 通过序列号与消息体进行一个关联
			* 全部都是未确认的消息体
			*/
			outstandingConfirms.put(channel.getNextPublishSeqNo(), message);
			channel.basicPublish("", queueName, null, message.getBytes());
		}
		long end = System.currentTimeMillis();
		System.out.println(" 发布" + MESSAGE_COUNT + " 个异步确认消息, 耗时" + (end - begin) + "ms");
	}
}

7. RabbitMQ的不公平分发和预取值

不公平分发：能者多劳

int prefetchCount = 1;  // 只有1是不公平分发，如果是大于1的则是预取值，等于0就是轮训分发
channel.basicQos(prefetchCount);

预取值本身消息的发送就是异步发送的，所以在任何时候，channel 上肯定不止只有一个消息另外来自消费者的手动确认本质上也是异步的。因此这里就存在一个未确认的消息缓冲区，因此希望开发人员能限制此缓冲区的大小，以避免缓冲区里面无限制的未确认消息问题。这个时候就可以通过使用 basic.qos 方法设置“预取计数”值来完成的。该值定义通道上允许的未确认消息的最大数量。

int prefetchCount = 5;
channel.basicQos(prefetchCount);

8. 交换机

8.1 交换机的概念

RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。

8.2 交换机类型

直接（direct），主题（topic），标题（headers），扇出（fanout）

无名exchange

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

临时队列

String queueName = channel.queueDeclare().getQueue();

fanout交换机它是将接收到的所有消息广播到它知道的所有队列中。发送者

public class EmitLog {
	private static final String EXCHANGE_NAME = "logs";
	public static void main(String[] argv) throws Exception {
		try (Channel channel = RabbitUtils.getChannel()) {
			/**
			* 声明一个 exchange
			* 1.exchange 的名称
			* 2.exchange 的类型
			*/
			channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
			Scanner sc = new Scanner(System.in);
			System.out.println(" 请输入信息");
			while (sc.hasNext()) {
				String message = sc.nextLine();
				channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
				System.out.println(" 生产者发出消息" + message);
			}
		}
	}
}

消费者1

public class ReceiveLogs01 {
	private static final String EXCHANGE_NAME = "logs";
	public static void main(String[] argv) throws Exception {
		Channel channel = RabbitUtils.getChannel();
		channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
		/**
		* 生成一个临时的队列 队列的名称是随机的
		* 当消费者断开和该队列的连接时 队列自动删除
		*/
		String queueName = channel.queueDeclare().getQueue();
		// 把该临时队列绑定我们的 exchange 其中 routingkey( 也称之为 binding key) 为空字符串
		channel.queueBind(queueName, EXCHANGE_NAME, "");
		System.out.println(" 等待接收消息, 把接收到的消息打印在屏幕.....");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), "UTF-8");
			System.out.println(" 控制台打印接收到的消息"+message);
		};
		channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
	}
}

消费者2

public class ReceiveLogs02 {
	private static final String EXCHANGE_NAME = "logs";
	public static void main(String[] argv) throws Exception {
		Channel channel = RabbitUtils.getChannel();
		channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
		/**
		* 生成一个临时的队列 队列的名称是随机的
		* 当消费者断开和该队列的连接时 队列自动删除
		*/
		String queueName = channel.queueDeclare().getQueue();
		// 把该临时队列绑定我们的 exchange 其中 routingkey( 也称之为 binding key) 为空字符串
		channel.queueBind(queueName, EXCHANGE_NAME, "");
		System.out.println(" 等待接收消息, 把接收到的消息写到文件.....");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), "UTF-8");
			File file = new File("C:\\work\\rabbitmq_info.txt");
			FileUtils.writeStringToFile(file,message,"UTF-8");
			System.out.println(" 数据写入文件成功");
		};
		channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
	}
}

direct交换机日志系统将所有消息广播给所有消费者，对此我们想做一些改变，例如我们希望将日志消息写入磁盘的程序仅接收严重错误(errros)，而不存储哪些警告(warning)或信息(info)日志消息避免浪费磁盘空间。Fanout 这种交换类型并不能给我们带来很大的灵活性-它只能进行无意识的广播，在这里我们将使用 direct 这种类型来进行替换，这种类型的工作方式是，消息只去到它绑定的routingKey 队列中去。

发送者

public class EmitLogDirect {
	private static final String EXCHANGE_NAME = "direct_logs";
	public static void main(String[] argv) throws Exception {
		try (Channel channel = RabbitUtils.getChannel()) {
			channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
			// 创建多个 bindingKey
			Map<String, String> bindingKeyMap = new HashMap<>();
			bindingKeyMap.put("info"," 普通 info 信息");
			bindingKeyMap.put("warning"," 警告 warning 信息");
			bindingKeyMap.put("error"," 错误 error 信息");
			//debug 没有消费这接收这个消息 所有就丢失了
			bindingKeyMap.put("debug"," 调试 debug 信息");
			for (Map.Entry<String, String> bindingKeyEntry: bindingKeyMap.entrySet()){
				String bindingKey = bindingKeyEntry.getKey();
				String message = bindingKeyEntry.getValue();
				channel.basicPublish(EXCHANGE_NAME,bindingKey, null, message.getBytes("UTF-8"));
				System.out.println(" 生产者发出消息:" + message);
			}
		}
	}
}

消费者1

public class ReceiveLogsDirect01 {
	private static final String EXCHANGE_NAME = "direct_logs";
	public static void main(String[] argv) throws Exception {
		Channel channel = RabbitUtils.getChannel();
		channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
		String queueName = "disk";
		channel.queueDeclare(queueName, false, false, false, null);
		channel.queueBind(queueName, EXCHANGE_NAME, "error");
		System.out.println(" 等待接收消息.....");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), "UTF-8");
			message=" 接收绑定键:"+delivery.getEnvelope().getRoutingKey()+", 消息:"+message;
			File file = new File("C:\\work\\rabbitmq_info.txt");
			FileUtils.writeStringToFile(file,message,"UTF-8");
			System.out.println(" 错误日志已经接收");
		};
		channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
	}
}

消费者2

public class ReceiveLogsDirect02 {
	private static final String EXCHANGE_NAME = "direct_logs";
	public static void main(String[] argv) throws Exception {
		Channel channel = RabbitUtils.getChannel();
		channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
		String queueName = "console";
		channel.queueDeclare(queueName, false, false, false, null);
		channel.queueBind(queueName, EXCHANGE_NAME, "info");
		channel.queueBind(queueName, EXCHANGE_NAME, "warning");
		System.out.println(" 等待接收消息.....");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), "UTF-8");
			System.out.println(" 接 收 绑 定 键 :"+delivery.getEnvelope().getRoutingKey()+", 消
			息:"+message);
		};
		channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
	}
}

topic交换机我们想接收的日志类型有info.base 和 info.advantage，某个队列只想 info.base 的消息，那这个时候 direct 就办不到了。这个时候就只能使用 topic 类型。发送到类型是 topic 交换机的消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如说："stock.usd.nyse", "nyse.vmw","quick.orange.rabbit".这种类型的。当然这个单词列表最多不能超过 255 个字节。 *(星号)可以代替一个单词 #(井号)可以替代零个或多个单词

生产者

public class EmitLogTopic {
	private static final String EXCHANGE_NAME = "topic_logs";
	public static void main(String[] argv) throws Exception {
		try (Channel channel = RabbitUtils.getChannel()) {
			channel.exchangeDeclare(EXCHANGE_NAME, "topic");
			/**
			* Q1--> 绑定的是
			* 中间带 orange 带 3 个单词的字符串 (*.orange.*)
			* Q2--> 绑定的是
			* 最后一个单词是 rabbit 的 3 个单词 (*.*.rabbit)
			* 第一个单词是 lazy 的多个单词 (lazy.#)
			*
			*/
			Map<String, String> bindingKeyMap = new HashMap<>();
			bindingKeyMap.put("quick.orange.rabbit"," 被队列 Q1Q2 接收到");
			bindingKeyMap.put("lazy.orange.elephant"," 被队列 Q1Q2 接收到");
			bindingKeyMap.put("quick.orange.fox"," 被队列 Q1 接收到");
			bindingKeyMap.put("lazy.brown.fox"," 被队列 Q2 接收到");
			bindingKeyMap.put("lazy.pink.rabbit"," 虽然满足两个绑定但只被队列 Q2 接收一次");
			bindingKeyMap.put("quick.brown.fox"," 不匹配任何绑定不会被任何队列接收到会被丢弃");
			bindingKeyMap.put("quick.orange.male.rabbit"," 是四个单词不匹配任何绑定会被丢弃");
			bindingKeyMap.put("lazy.orange.male.rabbit"," 是四个单词但匹配 Q2");
			for (Map.Entry<String, String> bindingKeyEntry: bindingKeyMap.entrySet()){
				String bindingKey = bindingKeyEntry.getKey();
				String message = bindingKeyEntry.getValue();
				channel.basicPublish(EXCHANGE_NAME,bindingKey, null,
				message.getBytes("UTF-8"));
				System.out.println(" 生产者发出消息" + message);
			}
		}
	}
}

消费者1

public class ReceiveLogsTopic01 {
	private static final String EXCHANGE_NAME = "topic_logs";
	public static void main(String[] argv) throws Exception {
		Channel channel = RabbitUtils.getChannel();
		channel.exchangeDeclare(EXCHANGE_NAME, "topic");
		// 声明 Q1 队列与绑定关系
		String queueName="Q1";
		channel.queueDeclare(queueName, false, false, false, null);
		channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.*");
		System.out.println(" 等待接收消息.....");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), "UTF-8");
			System.out.println(" 接 收 队 列 :"+queueName+" 绑定键:"+delivery.getEnvelope().getRoutingKey()+", 消息:"+message);
		};
		channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
	}
}

消费者2

public class ReceiveLogsTopic02 {
	private static final String EXCHANGE_NAME = "topic_logs";
	public static void main(String[] argv) throws Exception {
		Channel channel = RabbitUtils.getChannel();
		channel.exchangeDeclare(EXCHANGE_NAME, "topic");
		// 声明 Q2 队列与绑定关系
		String queueName="Q2";
		channel.queueDeclare(queueName, false, false, false, null);
		channel.queueBind(queueName, EXCHANGE_NAME, "*.*.rabbit");
		channel.queueBind(queueName, EXCHANGE_NAME, "lazy.#");
		System.out.println(" 等待接收消息.....");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), "UTF-8");
			System.out.println(" 接 收 队 列 :"+queueName+" 绑定键:"+delivery.getEnvelope().getRoutingKey()+", 消息:"+message);
		};
		channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
	}
}

9. 死信队列

死信的概念先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说: 用户在商城下单成功并点击去支付后在指定时间未支付时自动失效。
死信的来源消息 TTL 过期队列达到最大长度(队列满了，无法再添加数据到 mq 中) 消息被拒绝(basic.reject 或 basic.nack)并且 requeue=false.
代码架构图

生产者

public class Producer {
	private static final String NORMAL_EXCHANGE = "normal_exchange";
	public static void main(String[] argv) throws Exception {
		try (Channel channel = RabbitMqUtils.getChannel()) {
			channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
			// 设置消息的 TTL 时间
			AMQP.BasicProperties properties = new
			AMQP.BasicProperties().builder().expiration("10000").build();
			// 该信息是用作演示队列个数限制
			for (int i = 1; i <11 ; i++) {
				String message="info"+i;
				channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", properties,message.getBytes());
				System.out.println(" 生产者发送消息:"+message);
			}
		}
	}
}

消费者1

public class Consumer01 {
	// 普通交换机名称
	private static final String NORMAL_EXCHANGE = "normal_exchange";
	// 死信交换机名称
	private static final String DEAD_EXCHANGE = "dead_exchange";
	public static void main(String[] argv) throws Exception {
		Channel channel = RabbitUtils.getChannel();
		// 声明死信和普通交换机 类型为 direct
		channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
		channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
		// 声明死信队列
		String deadQueue = "dead-queue";
		channel.queueDeclare(deadQueue, false, false, false, null);
		// 死信队列绑定死信交换机与 routingkey
		channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");
		// 正常队列绑定死信队列信息
		Map<String, Object> params = new HashMap<>();
		// 正常队列设置死信交换机 参数 key 是固定值
		params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
		// 正常队列设置死信 routing-key 参数 key 是固定值
		params.put("x-dead-letter-routing-key", "lisi");
		String normalQueue = "normal-queue";
		channel.queueDeclare(normalQueue, false, false, false, params);
		channel.queueBind(normalQueue, NORMAL_EXCHANGE, "zhangsan");
		System.out.println(" 等待接收消息.....");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), "UTF-8");
			System.out.println("Consumer01 接收到消息"+message);
		};
		channel.basicConsume(normalQueue, true, deliverCallback, consumerTag -> {});
	}
}

消费者2

public class Consumer02 {
	private static final String DEAD_EXCHANGE = "dead_exchange";
	public static void main(String[] argv) throws Exception {
		Channel channel = RabbitUtils.getChannel();
		channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
		String deadQueue = "dead-queue";
		channel.queueDeclare(deadQueue, false, false, false, null);
		channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");
		System.out.println(" 等待接收死信队列消息.....");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), "UTF-8");
			System.out.println("Consumer02 接收死信队列的消息" + message);
		};
		channel.basicConsume(deadQueue, true, deliverCallback, consumerTag -> {});
	}
}

RabbitMQ学习之旅

1. RabbitMQ的概念

1.1 什么是RabbitMQ

1.2 四大核心概念

2. RabbitMQ工作原理

3. RabbitMQ的使用

4. 工作队列

5. 消息应答

5.1 消息应答方法

5.2 消息手动应答实现

6. RabbitMQ持久化

7. RabbitMQ的不公平分发和预取值

8. 交换机

8.1 交换机的概念

8.2 交换机类型

9. 死信队列