rabbitMQ第三篇：采用不同的交换机规则

最新推荐文章于 2023-06-07 11:22:08 发布
最新推荐文章于 2023-06-07 11:22:08 发布
阅读量276 收藏
点赞数
分类专栏： RabbitMQ

在上一篇我们都是采用发送信息到队列然后队列把信息在发送到消费者，其实实际情况并非如此，rabbitMQ其实真正的思想是生产者不发送任何信息到队列，甚至不知道信息将发送到哪个队列。相反生产者只能发送信息到交换机，交换机接收到生产者的信息，然后按照规则把它推送到对列中，交换机是如何做处理他接收到的信息，并怎么样发送到特定的队列，那么这一篇主要是讲解交换机的规则。

一：发布/订阅

在上一篇说到的队列都指定了名称，但是现在我们不需要这么做，我们需要所有的日志信息，而不只是其中的一个。如果要做这样的队列，我们需要2件事，一个就是获取一个新的空的队列，这样我就需要创建一个随机名称的队列，最好让服务器帮我们做出选择，第一个就是我们断开用户的队列，应该自动进行删除。ok下面是一副工作图。

信息发送端代码

复制代码
复制代码 
public class EmitLog {
    private static final String EXCHANGE_NAME = "logs"; public static void main(String[] args) throws IOException, TimeoutException { ConnectionFactory factory=new ConnectionFactory(); factory.setHost("localhost"); Connection connection=factory.newConnection(); Channel channel=connection.createChannel(); channel.exchangeDeclare(EXCHANGE_NAME,"fanout");//fanout表示分发，所有的消费者得到同样的队列信息 //分发信息 for (int i=0;i<5;i++){ String message="Hello World"+i; channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes()); System.out.println("EmitLog Sent '" + message + "'"); } channel.close(); connection.close(); }
复制代码
复制代码

消费者代码

复制代码
复制代码 
public class ReceiveLogs1 {
    private static final String EXCHANGE_NAME = "logs"; public static void main(String[] args) throws IOException, TimeoutException { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); channel.exchangeDeclare(EXCHANGE_NAME, "fanout"); //产生一个随机的队列名称 String queueName = channel.queueDeclare().getQueue(); channel.queueBind(queueName, EXCHANGE_NAME, "");//对队列进行绑定  System.out.println("ReceiveLogs1 Waiting for messages"); Consumer consumer = new DefaultConsumer(channel) { @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { String message = new String(body, "UTF-8"); System.out.println("ReceiveLogs1 Received '" + message + "'"); } }; channel.basicConsume(queueName, true, consumer);//队列会自动删除  } }
复制代码
复制代码

上面就完成了一个发布/订阅模式的消息队列 看看结果

 二：Routing

上面我用采用了广播的模式进行消息的发送，现在我们采用路由的方式对不同的消息进行过滤

发送端代码

复制代码
复制代码 
public class RoutingSendDirect {
    private static final String EXCHANGE_NAME = "direct_logs"; // 路由关键字 private static final String[] routingKeys = new String[]{"info" ,"warning", "error"}; public static void main(String[] args) throws IOException, TimeoutException { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); //声明交换机 channel.exchangeDeclare(EXCHANGE_NAME,"direct");//注意是direct //发送信息 for (String routingKey:routingKeys){ String message = "RoutingSendDirect Send the message level:" + routingKey; channel.basicPublish(EXCHANGE_NAME,routingKey,null,message.getBytes()); System.out.println("RoutingSendDirect Send"+routingKey +"':'" + message); } channel.close(); connection.close(); } }
复制代码
复制代码 
ReceiveLogsDirect1 消费者代码
复制代码
复制代码 
public class ReceiveLogsDirect1 {
    // 交换器名称
    private static final String EXCHANGE_NAME = "direct_logs"; // 路由关键字 private static final String[] routingKeys = new String[]{"info" ,"warning"}; public static void main(String[] args) throws IOException, TimeoutException { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); //声明交换器 channel.exchangeDeclare(EXCHANGE_NAME, "direct"); //获取匿名队列名称 String queueName=channel.queueDeclare().getQueue(); //根据路由关键字进行绑定 for (String routingKey:routingKeys){ channel.queueBind(queueName,EXCHANGE_NAME,routingKey); System.out.println("ReceiveLogsDirect1 exchange:"+EXCHANGE_NAME+"," + " queue:"+queueName+", BindRoutingKey:" + routingKey); } System.out.println("ReceiveLogsDirect1 Waiting for messages"); Consumer consumer = new DefaultConsumer(channel) { @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { String message = new String(body, "UTF-8"); System.out.println("ReceiveLogsDirect1 Received '" + envelope.getRoutingKey() + "':'" + message + "'"); } }; channel.basicConsume(queueName, true, consumer); }
复制代码
复制代码 
ReceiveLogsDirect2消费者代码
复制代码
复制代码 
public class ReceiveLogsDirect2 {
    // 交换器名称
    private static final String EXCHANGE_NAME = "direct_logs"; // 路由关键字 private static final String[] routingKeys = new String[]{"error"}; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); //声明交换器 channel.exchangeDeclare(EXCHANGE_NAME, "direct"); //获取匿名队列名称 String queueName = channel.queueDeclare().getQueue(); //根据路由关键字进行多重绑定 for (String severity : routingKeys) { channel.queueBind(queueName, EXCHANGE_NAME, severity); System.out.println("ReceiveLogsDirect2 exchange:"+EXCHANGE_NAME+", queue:"+queueName+", BindRoutingKey:" + severity); } System.out.println("ReceiveLogsDirect2 Waiting for messages"); Consumer consumer = new DefaultConsumer(channel) { @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws UnsupportedEncodingException { String message = new String(body, "UTF-8"); System.out.println("ReceiveLogsDirect2 Received '" + envelope.getRoutingKey() + "':'" + message + "'"); } }; channel.basicConsume(queueName, true, consumer); } }
复制代码
复制代码

上面代码可以看出这里是通过路由来找个这个对列的。我们看下结果

三：Topics

这种应该属于模糊匹配

* ：可以替代一个词

#：可以替代0或者更多的词

现在我们继续看看代码来理解

发送端

复制代码
复制代码 
public class TopicSend {
    private static final String EXCHANGE_NAME = "topic_logs"; public static void main(String[] args) throws IOException, TimeoutException { Connection connection = null; Channel channel = null; try{ ConnectionFactory factory=new ConnectionFactory(); factory.setHost("localhost"); connection=factory.newConnection(); channel=connection.createChannel(); //声明一个匹配模式的交换机 channel.exchangeDeclare(EXCHANGE_NAME,"topic"); //待发送的消息 String[] routingKeys=new String[]{ "quick.orange.rabbit", "lazy.orange.elephant", "quick.orange.fox", "lazy.brown.fox", "quick.brown.fox", "quick.orange.male.rabbit", "lazy.orange.male.rabbit" }; //发送消息 for(String severity :routingKeys){ String message = "From "+severity+" routingKey' s message!"; channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes()); System.out.println("TopicSend Sent '" + severity + "':'" + message + "'"); } }catch (Exception e){ e.printStackTrace(); if (connection!=null){ channel.close(); connection.close(); } }finally { if (connection!=null){ channel.close(); connection.close(); } } } }
复制代码
复制代码

消费者1：

复制代码
复制代码 
public class ReceiveLogsTopic1 {
    private static final String EXCHANGE_NAME = "topic_logs"; public static void main(String[] args) throws IOException, TimeoutException { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); //声明一个匹配模式的交换机 channel.exchangeDeclare(EXCHANGE_NAME, "topic"); String queueName = channel.queueDeclare().getQueue(); //路由关键字 String[] routingKeys = new String[]{"*.orange.*"}; //绑定路由 for (String routingKey : routingKeys) { channel.queueBind(queueName, EXCHANGE_NAME, routingKey); System.out.println("ReceiveLogsTopic1 exchange:" + EXCHANGE_NAME + ", queue:" + queueName + ", BindRoutingKey:" + routingKey); } System.out.println("ReceiveLogsTopic1 Waiting for messages"); Consumer consumer = new DefaultConsumer(channel) { @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { String message = new String(body, "UTF-8"); System.out.println("ReceiveLogsTopic1 Received '" + envelope.getRoutingKey() + "':'" + message + "'"); } }; channel.basicConsume(queueName, true, consumer); } }
复制代码
复制代码

消费者2：

复制代码
复制代码 
ublic class ReceiveLogsTopic2 {
    private static final String EXCHANGE_NAME = "topic_logs"; public static void main(String[] argv) throws IOException, TimeoutException { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); // 声明一个匹配模式的交换器 channel.exchangeDeclare(EXCHANGE_NAME, "topic"); String queueName = channel.queueDeclare().getQueue(); // 路由关键字 String[] routingKeys = new String[]{"*.*.rabbit", "lazy.#"}; // 绑定路由关键字 for (String bindingKey : routingKeys) { channel.queueBind(queueName, EXCHANGE_NAME, bindingKey); System.out.println("ReceiveLogsTopic2 exchange:"+EXCHANGE_NAME+", queue:"+queueName+", BindRoutingKey:" + bindingKey); } System.out.println("ReceiveLogsTopic2 Waiting for messages"); Consumer consumer = new DefaultConsumer(channel) { @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws UnsupportedEncodingException { String message = new String(body, "UTF-8"); System.out.println("ReceiveLogsTopic2 Received '" + envelope.getRoutingKey() + "':'" + message + "'"); } }; channel.basicConsume(queueName, true, consumer); } }
复制代码
复制代码

运行后结果

http://www.cnblogs.com/LipeiNet/p/5978276.html

馥钰
关注
专栏目录
rabbitmq安装包
09-22
2. **交换机（Exchange）**: 负责根据路由规则将消息分发到不同的队列。 3. **绑定（Binding）**: 定义了交换机如何将消息路由到特定队列的规则。 4. **生产者（Producer）**: 发送消息到交换机的客户端。 5. **...
RabbitMQ基本概念——Channel、RoutingKey、Exchange
李正浩的博客
02-19 3099
RabbitMQ基本概念——Channel、RoutingKey、Exchange 博客原地址链接： http://www.lizhenghao.site/blog/2022/02/07/191 先上一张RabbitMQ的结构图： rabbitMQ工作流 Channel（信道） Channel是生产者消费者和RabbitMQ通信的方式，它是建立在TCP连接之上的一个虚拟连接，也就是类似于生产者A要和RabbitMQ通信，那么A在程序运行的时候先起一个TCP连接连上RabbitMQ，后面每次需要发消息的时候就
RabbitMQ-直连模型
Anoraker的小屋
12-01 7220
AMQP的架构模型 其中虚拟主机的意思类似于数据库中库的概念，设计者更希望，每一个项目独立使用一个虚拟主机。 入门案例 引入依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.7.2</version> </dependency> 先去创建虚拟主
RabbitMQ的学习(三)：RabbitMQ不同的交换机配合路由键发送消息
热门推荐
shenhaiyushitiaoyu的博客
11-20 5万+
前言：前面两章我们已经开始了从安装到编写简单的demo的过程： RabbitMQ的学习(一)：Windows下安装及配置RabbitMQ，erlang环境变量 RabbitMQ的学习(二)：简单的java demo实现RabbitMQ的发送与接收 ...
rabbitmq 同一个topic交换机下不同的routingkey指向同一个queue
top_explore的博客
08-17 5512
使用rabbitmq时，如果在同一个交换机下绑定了不同的routingkey A和B，指向同一个queue。 那么在监听的时候，routingkey为B的消息也会被A监听到。
rabbitmq下载安装
最新发布
11-03
在不同的操作系统上，RabbitMQ的安装过程会有所不同。这里以常用的Ubuntu和Windows为例简述安装步骤： **Ubuntu** 1. 更新系统包列表：`sudo apt-get update` 2. 安装Erlang：`sudo apt-get install erlang` 3. ...
RabbitMQ客户端资源
03-18
7. **监控与日志**：监控RabbitMQ的状态和性能，可以通过管理控制台、第三方工具或者日志文件。日志文件一般位于`C:\Program Files\RabbitMQ Server\rabbitmq_server-3.9.13\logs`。 在Windows环境中，RabbitMQ...
rabbitmq.zip
07-06
- 可以利用RabbitMQ提供的API或者第三方工具如Prometheus和Grafana进行更深入的监控。 7. **RabbitMQ的扩展**： - 插件系统：RabbitMQ有许多官方和社区开发的插件，如用于监控的rabbitmq_management，以及与其他...
RabbitMQ工具类实现配置文件动态创建队列和绑定
02-21
3. **读取配置文件**：可以使用Java的`java.util.Properties`或者第三方库如Apache Commons Configurations来读取配置文件。配置文件中应包含队列和绑定的信息，例如队列名称、交换机类型、路由键等。 ```java ...
学习RabbitMQ的一些个人总结
Paracosm的博客
10-30 193
RabbitMQ是流行的开源消息队列系统，用erlang语言开发，RabbitMQ是AMQP(高级消息队列协议)的标准实现。采用该技术，我们可以实现异步处理、流量削峰、系统解耦； 消息 Message 是指在应用件传送的数据,消息可以非常简单,比如只包含文本字符串.也可能包含嵌入对象. 消息队列(Message Queue)是一种应用间的通信方式,消息发送后可以立即返回,由消息系统来确保消息的科可靠传递. //异步协作机制 RabbitMQ 消息队列 基于Erlang语言开发的AMQP的开源实现. AM
RabbitMQ可以不使用交换机，直连队列吗？
weixin_43933456的博客
02-06 2582
可以的！ 消费者和生产者使用相同的参数声明队列就可以，重复声明不会改变队列，谁先生效就用谁。 channel.queueDeclare(QUEUE_NAME, false, false, false, null);
rabbitMQ 中三种常用交换机：direct、topic、fanout的使用以及区别
z69183787的专栏
10-29 1671
在rabbitmq中有许多交换机，不同的交换机适用于不同的场景。如下： 这么多交换机中，最常用的交换机有三种：direct、topic、fanout。我分别叫他们：“直接连接交换机”，“主题路由匹配交换机”，“无路由交换机”。以下是详细的介绍： Direct 交换机 这个交换机就是一个直接连接交换机，什么叫做直接连接交换机呢？ 所谓“直接连接交换机”就是：Producer(生产者)投递的消息被DirectExchange (交换机)转发到通过routingkey绑定到具体的某个Queue(队列)，把消
RabbitMQ教程直连交换器和路由Routing
Keep learing, and stay fast
08-03 426
前言：上一篇我们的程序实现了广播消息给所有的消费者，本章中我们将要增加一个特性，我们将实现只订阅消息的某个子集，例如我们将ERROR错误等级的消息保存到磁盘上，而INFO.WARNING 等级的日志直接打印出来 RabitMQ安装 如何安装： https://blog.csdn.net/Beijing_L/article/details/119042261 图例 P（生产者）： 生产者属于数据的发送方 ,发送的消息被放入队列里 C（消费者）： 消费者属于数据的接收方，发现队列里的消息，将
rabbitMQ(三) 不同的交换机规则
CHENJINGBIN的博客
01-04 730
在上一篇的内容中，讲到rabbitMQ的发布和订阅，也就是使用了交换机里面的其中一个机制。 现在继续接着讲其他的 4）路由 之前的发布和订阅那是全部发过去的，现在需要做的是给他需要的消息，其他不需要的就不接受。 绑定是交换和队列之间的关系。这可以简单地理解为：队列对来自这个交换的消息感兴趣。 绑定可以采用额外的routingKey参数。为了避免混淆basic_publish参数，我们将其称
「RabbitMQ」使用Direct交换机实现消息的路由与投递
技术路上的探险家
06-07 273
使用Direct 交换机实现消息的路由与投递，实现方法有：Bean配置和注解配置
RabbitMQ详解
qq_33791517的博客
07-28 746
可以开启消费消息的手动确认模式（有三种自动确认，手动确认，异常重发），当消息消费完成后确认消息消费，消息队列才会剔除消息，如果消费失败，可以选择重发指定次数后还是失败在存在库中或日志中以做进一步处理，这时设置消息丢弃。延迟队列（TTL+死信交换机）给消息队列设置过期时间，不设置消费者来消费，当达到过期时间后，过期消息绑定到指定的死信交换机再次分发给消息队列，从而达到延迟队列的目的。如何防止消息的重复消费消费消息的方法最好能达到幂等性（多次消费相同消息不会对结果有影响），一般可以通过乐观锁来实现。...
关于RabbitMQ 的默认交换机 的问题
王小明的专栏
10-16 4123
关于RabbitMQ 的默认交换机 的问题 有4个默认的交换机 Name Default pre-declared names Direct exchange (Empty string) and amq.direct Fanout exchange ...
RabbitMq四种交换机模式
chenxiaokang的博客
07-22 1365
RabbitMq的四种交换机模式 package cn.chen.miaosha.rabbitmq; import org.springframework.amqp.core.*; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configura...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值