本文深入探讨RabbitMQ中的四种交换机类型：Direct、Topic、Header和Fanout。Direct交换机按routingKey精确匹配队列；Topic允许使用通配符进行更灵活的路由；Header交换机根据消息headers键值对匹配；Fanout则将消息广播到所有绑定队列。文中通过实例代码展示了每种交换机的工作原理及其在实际应用中的配置和使用。
RabbitMQ交换机（Exchanges）
- RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中
- 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来
自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定
RabbitMQ的类型
- 直接(direct), 主题(topic) ,标题(headers) , 扇出(fanout)
Binding绑定
- binding 其实是 exchange 和 queue 之间的桥梁，它告诉我们 exchange 和那个队列进行了绑定关系。
扇出(Fanout)类型
- 它是将接收到的所有消息广播到它知道的所有队列中，具体代码实现如下，
消费者
- 设置两个消费者，除了名字外其他全部相等，此处演示的为其中一个
public class ReceiveLog01 {
// 交换机名称
public static final String EXHANGE_NAME = "logs";
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 工厂IP，连接RabbitMQ队列(安装RabbitMQ机器的IP地址)
factory.setHost("xxx.xxx.xxx.xxx");
//用户名
factory.setUsername("username");
//密码
factory.setPassword("password");
// 创建连接
Connection connection = factory.newConnection();
// 获取信道
Channel channel = connection.createChannel();
// 声明交换机,扇出类型
channel.exchangeDeclare(EXHANGE_NAME,"fanout");
// 声明一个队列 临时队列
/**
* 声明一个临时队列
* 队列名称是随机的
* 当消费者与生产者断开的时候，队列自动删除
*/
String queue = channel.queueDeclare().getQueue();
/**
* 绑定交换机与队列
*/
channel.queueBind(queue,EXHANGE_NAME,"");
System.out.println("等待接收消息，打印消息。。。。");
DeliverCallback deliverCallback = (consumerTag,message)->{
System.out.println("接收到消息："+new String(message.getBody(),"UTF-8"));
};
/**
* 接收消息
* 1。 队列名称
* 2。 是否自动确认
* 3。 接收到消息回调
* 4。 取消消息时回调
*/
channel.basicConsume(queue,true,deliverCallback,consumerTag->{});
}
}
生产者
public class EmitLog {
// 交换机名称
public static final String EXCHANGE_NAME = "logs";
public static void main(String[] args) throws IOException, TimeoutException {
=========按照上述的方式获取信道==========
channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()){
String message = scanner.next();
channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes("UTF-8"));
System.out.println("生产者发出消息："+message);
}
}
}
实验结果
生产者发出消息后，与交换机绑定的队列全部都收到消息
直接交换机(Direct)
消息只去到它绑定的routingKey 队列中去,具体代码如下：
消费者
第一个消费者队列consile绑定交换机，对应的routingkey分别为info，warning，第二个队列disk绑定交换机，对应的routingkey为error
public class ReceiveLogsDirect01 {
// 交换机名称
public static final String EXHANGE_NAME = "direct_logs";
public static void main(String[] args) throws IOException, TimeoutException {
=========按照上述的方式获取信道==========
// 声明交换机，直接交换机
channel.exchangeDeclare(EXHANGE_NAME, BuiltinExchangeType.DIRECT);
// 声明一个队列
channel.queueDeclare("console",false,false,false,null);
// 队列捆绑
channel.queueBind("console",EXHANGE_NAME,"info");
channel.queueBind("console",EXHANGE_NAME,"warning");
System.out.println("队列一开始接收消息。。。。");
DeliverCallback deliverCallback = (consumerTag, message)->{
System.out.println("队列一接收到消息："+new String(message.getBody(),"UTF-8"));
};
channel.basicConsume("console",deliverCallback,consumerTag->{});
}
}
public class ReceiveLogsDirect02 {
// 交换机名称
public static final String EXHANGE_NAME = "direct_logs";
public static void main(String[] args) throws IOException, TimeoutException {
============上述的方式获取信道===============
// 声明交换机，直接交换机
channel.exchangeDeclare(EXHANGE_NAME, BuiltinExchangeType.DIRECT);
// 声明一个队列
channel.queueDeclare("disk",false,false,false,null);
// 队列捆绑
channel.queueBind("disk",EXHANGE_NAME,"error");
System.out.println("队列二开始接收消息。。。。");
DeliverCallback deliverCallback = (consumerTag, message)->{
System.out.println("队列二接收到消息："+new String(message.getBody(),"UTF-8"));
};
channel.basicConsume("disk",deliverCallback,consumerTag->{});
}
}
生产者
通过Map来发送不同的消息
public class DeceiveLogs {
// 交换机名称
public static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] args) throws IOException, TimeoutException {
Channel channel = RabbitMQUtils.getChannel();
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
Scanner scanner = new Scanner(System.in);
//创建多个 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);
}
}
}
测试结果
发送了四个不同的Routingkey的消息，由于debug没有对应的队列接收，所以消息丢失，队列一接收到info与warning消息，队列二姐收到error消息
Topic交换机(主题交换机)
尽管使用 direct 交换机改进了我们的系统，但是它仍然存在局限性-比方说我们想接收的日志类型有info.base 和 info.advantage，某个队列只想 info.base 的消息，那这个时候 direct 就办不到了。这个时候就只能使用 topic 类型，发送到类型是 topic 交换机的消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如说：“stock.usd.nyse”, “nyse.vmw”,“quick.orange.rabbit”.这种类型的。当然这个单词列表最多不能超过 255 个字节。重要的是两个替换符规则为 *(星号)可以代替一个单词， #(井号)可以替代零个或多个单词
当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像 fanout 了
如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是 direct 了
消费者代码
消费者01接收*.orange.* 的消息，即前面和后面各只有一个单词的消息，而消费者2接受*.*.rabbit，以及lazy.#，即rabbit前面有两个单词以及lazy后面有任意单词的消息
public class ReceiveLogsTopic01 {
// 交换机名称
public static final String EXHANGE_NAME = "topic_logs";
public static void main(String[] args) throws IOException, TimeoutException {
=============上述的方式获取信道=============
// 获取信道，主题模式
channel.exchangeDeclare(EXHANGE_NAME, BuiltinExchangeType.TOPIC);
// 声明队列
channel.queueDeclare("Q1", false, false, false, null);
channel.queueBind("Q1", EXHANGE_NAME, "*.orange.*");
System.out.println("Q1等待接收消息。。。");
DeliverCallback deliverCallback = (consumerTag, message) -> {
System.out.println("Q1接收到消息：" + new String(message.getBody(), "UTF-8") + "绑定键："
+ message.getEnvelope().getRoutingKey());
};
channel.basicConsume("Q1", true, deliverCallback, consumerTag -> {
});
}
}
public class ReceiveLogsTopic02 {
// 交换机名称
public static final String EXHANGE_NAME = "topic_logs";
public static void main(String[] args) throws IOException, TimeoutException {
===========上述的方式获取信道============
// 获取信道，主题模式
channel.exchangeDeclare(EXHANGE_NAME, BuiltinExchangeType.TOPIC);
// 声明队列
channel.queueDeclare("Q2", false, false, false, null);
channel.queueBind("Q2", EXHANGE_NAME, "*.*.rabbit");
channel.queueBind("Q2", EXHANGE_NAME, "lazy.#");
System.out.println("Q2等待接收消息。。。");
DeliverCallback deliverCallback = (consumerTag, message) -> {
System.out.println("Q2接收到消息：" + new String(message.getBody(), "UTF-8") + "绑定键："
+ message.getEnvelope().getRoutingKey());
};
channel.basicConsume("Q2", true, deliverCallback, consumerTag -> {
});
}
}
生产者
在生产者中发送不同方式的routingkey，发送不同的消息，看看是否能被两个不同的队列接收
public class EmitLogTopic {
// 交换机名称
public static final String EXHANGE_NAME = "topic_logs";
public static void main(String[] args) throws IOException, TimeoutException {
============上述方式获取信道============
channel.exchangeDeclare(EXHANGE_NAME, BuiltinExchangeType.TOPIC);
Map<String,String> bindingMap = new HashMap<>();
bindingMap.put("quick.orange.rabbit","被队列 Q1Q2 接收到");
bindingMap.put("lazy.orange.elephant ","被队列 Q1Q2 接收到");
bindingMap.put("quick.orange.fox","被队列 Q1 接收到");
bindingMap.put("lazy.brown.fox","被队列 Q2 接收到");
bindingMap.put("lazy.pink.rabbit","虽然满足两个绑定但只被队列 Q2 接收一次");
bindingMap.put("quick.brown.fox ","虽然满足两个绑定但只被队列 Q2 接收一次");
bindingMap.put("quick.orange.male.rabbit","是四个单词不匹配任何绑定会被丢弃");
bindingMap.put("lazy.orange.male.rabbit","是四个单词但匹配 Q2");
for (Map.Entry<String, String > stringObjectEntry : bindingMap.entrySet()) {
channel.basicPublish(EXHANGE_NAME,stringObjectEntry.getKey(),null,stringObjectEntry.getValue().getBytes());
System.out.println("生产者发出消息："+stringObjectEntry.getValue());
}
}
}
结果
预期结果为上述生产者中描述的结果，结果如图所示
header交换机（头部交换机）
headers与交换机其他的模式不同，不是使用routingkey去做绑定。而是通过消息headers的键值对匹配。发布者 – > 头部交换机 --> (id: 001) binding --> queue，id：001取代了上述的routingkey来进行匹配队列
匹配有两种方式all和any。这两种方式是在接收端必须要用键值"x-mactch"来定义。all代表定义的多个键值对都要满足，而any则代码只要满足一个就可以了。
代码演示
生产者
由于header模式使用较少，这里不做过多的介绍
========上述方式获取信道========
//声明转发器和类型headers
channel.exchangeDeclare(EXCHANGE_NAME, ExchangeTypes.HEADERS,false,true,null);
Map<String,Object> headers = new Hashtable<String, Object>();
headers.put("aaa", "01234");
Builder properties = new BasicProperties.Builder();
properties.headers(headers);
// 指定消息发送到的转发器,绑定键值对headers键值对
channel.basicPublish(EXCHANGE_NAME, "",properties.build(),message.getBytes());
消费者
===========上述方式获取信道=============
//声明转发器和类型headers
channel.exchangeDeclare(EXCHANGE_NAME, ExchangeTypes.HEADERS,false,true,null);
channel.queueDeclare(QUEUE_NAME,false, false, true,null);
Map<String, Object> headers = new Hashtable<String, Object>();
headers.put("x-match", "any");//all any
headers.put("aaa", "01234");
DeliverCallback deliverCallback = (consumerTag, message) -> {
System.out.println("接收到消息：" + new String(message.getBody(), "UTF-8") + "绑定键："
+ message.getEnvelope().getRoutingKey());
};
// 为转发器指定队列，设置binding 绑定header键值对
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME,"", headers);
channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
扫一扫
470
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
