RabbitMq交换机
Exchanges
Exchange 概念
RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。
相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。
Exchange 类型
总共有以下类型：
直接(direct), 主题(topic) ,标题(headers) , 扇出(fanout)
无名Exchange
如果不填写交换机的话，使用的就是默认交换，我们通过空字符串("")进行标识。
/*
发送一个消费
1.发送到哪个交换机
2.队列名称
3.其他的参数信息
4.发送消息的消息体
*/
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
临时队列
每当我们连接到 Rabbit 时，我们都需要一个全新的空队列，为此我们可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称那就更好了。其次一旦我们断开了消费者的连接，队列将被自动删除。
创建临时队列的方式如下:
/*
生成一个临时队列 队列名称是随机的
当消费者断开与队列连接的时候 队列自动删除
*/
String queueName = channel.queueDeclare().getQueue();
创建出来之后长成这样:
绑定(bindings)
binding 是 exchange 和 queue 之间的桥梁，它告诉我们 exchange 和哪个 queue 进行了绑定关系。比如说下面这张图告诉我们的就是 交换机 与 队列A 和 队列B 进行了绑定
Fanout
Fanout 介绍
Fanout 这种类型非常简单。正如从名称中猜到的那样，它是将接收到的所有消息广播到它知道的所有队列中。系统中默认有些 exchange 类型，和路由key没关系。
Fanout 实战
Logs 和临时队列的绑定关系如下图
下方代码均已上方实战图有关对照图完成
ReceiveLogsOne代码
/**
* @author zjh
*/
public class ReceiveLogsOne {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 声明一个交换机
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
/*
生成一个临时队列 队列名称是随机的
当消费者断开与队列连接的时候 队列自动删除
*/
String queueName = channel.queueDeclare().getQueue();
// 绑定交换机与队列
channel.queueBind(queueName, EXCHANGE_NAME, "");
System.out.println("ReceiveLogsOne等待接收消息，把接收的消息打印在控制台...");
// 消费
channel.basicConsume(queueName, true, (consumerTag, message) -> System.out.println("ReceiveLogsOne接收消息：" + new String(message.getBody(), StandardCharsets.UTF_8)),
consumerTag -> {});
}
}
ReceiveLogsTwo代码
/**
* @author zjh
*/
public class ReceiveLogsTwo {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 声明一个交换机
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
/*
生成一个临时队列 队列名称是随机的
当消费者断开与队列连接的时候 队列自动删除
*/
String queueName = channel.queueDeclare().getQueue();
// 绑定交换机与队列
channel.queueBind(queueName, EXCHANGE_NAME, "");
System.out.println("ReceiveLogsTwo等待接收消息，把接收的消息打印在控制台...");
// 消费
channel.basicConsume(queueName, true, (consumerTag, message) -> System.out.println("ReceiveLogsTwo接收消息：" + new String(message.getBody(), StandardCharsets.UTF_8)),
consumerTag -> {});
}
}
EmitLog代码
/**
* @author zjh
*
* 发消息给交换机
*/
public class EmitLog {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 声明一个交换机
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String message = scanner.next();
// 发布消息
channel.basicPublish(EXCHANGE_NAME, message, null, message.getBytes(StandardCharsets.UTF_8));
System.out.println("生产者发出消息：" + message);
}
}
}
运行结果
可以看到 两个消费者全都消费了, 说明交换机路由到了两个队列上
Direct exchange
Direct exchange 介绍
使用 fanout类型交换机 我们的日志系统将所有消息广播给所有消费者，对此我们想做一些改变，例如我们希望将日志消息写入磁盘的程序仅接收严重错误(errros)，而不存储哪些警告(warning)或信息(info)日志消息避免浪费磁盘空间。Fanout 这种交换类型并不能给我们带来很大的灵活性-它只能进行无意识的广播，在这里我们将使用 direct 这种类型来进行替换，这种类型的工作方式是，消息只去到它绑定的routingKey 队列中去。
在上面这张图中，我们可以看到 exchange 绑定了两个队列，绑定类型是 direct。队列A 绑定键为 orange，队列B 绑定键有两个:一个绑定键为 black，另一个绑定键为 green.
在这种绑定情况下，生产者发布消息到 exchange 上，绑定键为 orange 的消息会被发布到队列A。绑定键为 black、green 和的消息会被发布到队列B，其他消息类型的消息将被丢弃。
多重绑定
当然如果 exchange 的绑定类型是 direct，但是它绑定的多个队列的 key 如果都相同，在这种情况下虽然绑定类型是 direct 但是它表现的就和 fanout 有点类似了，就跟广播差不多，如上图所示。
实战
绑定关系图：
ReceiveLogsDirectOne代码 消费者
/**
* @author zjh
*/
public class ReceiveLogsDirectOne {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 声明一个交换机
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
// 声明一个队列
channel.queueDeclare("console", false, false, false, null);
// 绑定交换机与队列
channel.queueBind("console", EXCHANGE_NAME, "info");
channel.queueBind("console", EXCHANGE_NAME, "warning");
// 消费
channel.basicConsume("console", true, (consumerTag, message) -> System.out.println("ReceiveLogsDirectOne接收的消息打印在控制台：" + new String(message.getBody(), StandardCharsets.UTF_8)),
consumerTag -> {});
}
}
ReceiveLogsDirectTwo代码 消费者
/**
* @author zjh
*/
public class ReceiveLogsDirectTwo {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 声明一个交换机
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
// 声明一个队列
channel.queueDeclare("disk", false, false, false, null);
// 绑定交换机与队列
channel.queueBind("disk", EXCHANGE_NAME, "error");
// 消费
channel.basicConsume("disk", true, (consumerTag, message) -> System.out.println("ReceiveLogsDirectTwo接收的消息打印在控制台：" + new String(message.getBody(), StandardCharsets.UTF_8)),
consumerTag -> {});
}
}
EmitDirectLogs代码 生产者
/**
* @author zjh
*/
public class EmitDirectLogs {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String message = scanner.next();
// 发布消息
channel.basicPublish(EXCHANGE_NAME, "error", null, message.getBytes(StandardCharsets.UTF_8));
System.out.println("生产者发出消息：" + message);
}
}
}
routingkey为error结果
routingkey为info结果
可以看到结果 如果指定了routingkey 只能路由到指定的队列，由指定的消费者消费。
Topics
之前类型的问题
日志记录系统。我们没有使用只能进行随意广播的 fanout 交换机，而是使用了 direct 交换机，从而有能实现有选择性地接收日志。
尽管使用 direct 交换机改进了我们的系统，但是它仍然存在局限性-比方说我们想接收的日志类型有info.base 和 info.advantage，某个队列只想 info.base 的消息，那这个时候direct 就办不到了。这个时候就只能使用 topic 类型
Topic 的要求
发送到类型是 topic 交换机的消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如说："stock.usd.nyse", "nyse.vmw","quick.orange.rabbit".这种类型的。当然这个单词列表最多不能超过 255 个字节。
在这个规则列表中，其中有两个替换符是大家需要注意的
*(星号)可以代替一个单词
#(井号)可以替代零个或多个单词
Topic 匹配案例
Topic 匹配案例
queueOne --> 绑定的是
中间带 orange 带 3 个单词的字符串(.orange.)
queueTwo --> 绑定的是
最后一个单词是 rabbit 的 3 个单词(..rabbit)
第一个单词是 lazy 的多个单词(lazy.#)
上图是一个队列绑定关系图，我们来看看他们之间数据接收情况是怎么样的
quick.orange.rabbit 被队列 queueOne、queueTwo 接收到
lazy.orange.elephant 被队列 queueOne、queueTwo 接收到
quick.orange.fox 被队列 queueOne 接收到
lazy.brown.fox 被队列 queueTwo 接收到
lazy.pink.rabbit 虽然满足两个绑定但只被队列 queueTwo 接收一次
quick.brown.fox 不匹配任何绑定不会被任何队列接收到会被丢弃
quick.orange.male.rabbit 是四个单词不匹配任何绑定会被丢弃
lazy.orange.male.rabbit 是四个单词但匹配 queueTwo
当队列绑定关系是下列这种情况时需要引起注意
- 当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像 fanout 了
- 如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是 direct 了
实战
绑定关系图：
EmitTopicLogs代码 生产者
/**
* @author zjh
*/
public class EmitTopicLogs {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "topic_logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 设置发送消息
Map<String, String> bindingKeyMap = new HashMap<>(8);
bindingKeyMap.put("quick.orange.rabbit","被队列queueOne、queueTwo接收到");
bindingKeyMap.put("lazy.orange.elephant","被队列queueOne、queueTwo接收到");
bindingKeyMap.put("quick.orange.fox","被队列queueOne接收到");
bindingKeyMap.put("lazy.brown.fox","被队列queueTwo接收到");
bindingKeyMap.put("lazy.pink.rabbit","虽然满足两个绑定条件但只被队列queueTwo接收到");
bindingKeyMap.put("quick.brown.fox","不匹配任何绑定不会被任何队列接收到会被丢弃");
bindingKeyMap.put("quick.orange.male.rabbit","是四个单词不匹配任何绑定会被吊丢弃");
bindingKeyMap.put("lazy.orange.male.rabbit","是四个单词匹配队列queueTwo接收到");
for (Map.Entry<String, String> bindingKeyEntry : bindingKeyMap.entrySet()) {
// 路由key
String routeingKey = bindingKeyEntry.getKey();
// 消息
String message = bindingKeyEntry.getValue();
channel.basicPublish(EXCHANGE_NAME, routeingKey, null, message.getBytes(StandardCharsets.UTF_8));
}
}
}
ReceiveLogsTopicOne 消费者
/**
* @author zjh
*
* 声明主题交换机以及队列
*/
public class ReceiveLogsTopicOne {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "topic_logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 声明交换机
channel.exchangeDeclare(EXCHANGE_NAME, "topic");
// 声明一个队列
channel.queueDeclare("queueOne", false, false, false, null);
// 绑定交换机和队列
channel.queueBind("queueOne", EXCHANGE_NAME, "*.orange.*");
// 接收消息
channel.basicConsume("queueOne", true, (consumerTag, message) -> System.out.println("ReceiveLogsTopicOne接收的消息打印在控制台：" + new String(message.getBody(), StandardCharsets.UTF_8)),
consumerTag -> {});
}
}
ReceiveLogsTopicTwo 消费者
/**
* @author zjh
*
* 声明主题交换机以及队列
*/
public class ReceiveLogsTopicTwo {
/**
* 交换机名称
*/
private static final String EXCHANGE_NAME = "topic_logs";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
// 声明交换机
channel.exchangeDeclare(EXCHANGE_NAME, "topic");
// 声明一个队列
channel.queueDeclare("queueTwo", false, false, false, null);
// 绑定交换机和队列
channel.queueBind("queueTwo", EXCHANGE_NAME, "*.*.rabbit");
channel.queueBind("queueTwo", EXCHANGE_NAME, "lazy.#");
// 接收消息
channel.basicConsume("queueTwo", true, (consumerTag, message) -> System.out.println("ReceiveLogsTopicTwo接收的消息打印在控制台：" + new String(message.getBody(), StandardCharsets.UTF_8)),
consumerTag -> {});
}
}
结果
