RabbitMq系列(七)：直接交换Direct exchange

最新推荐文章于 2023-10-12 20:17:27 发布
最新推荐文章于 2023-10-12 20:17:27 发布
阅读量2.3k 收藏
点赞数
分类专栏： 消息队列 文章标签： rabbitmq MQ spring boot rabbit mq
转载请注明出处
本文链接：https://blog.csdn.net/qq_35427539/article/details/107061751
版权

系列文章

RabbitMq系列(一)：服务器搭建

RabbitMq系列(二)：最简单的例子

RabbitMq系列(三)：工作队列

RabbitMq系列(四)：消息确认和持久性

RabbitMq系列(五)：公平派遣

RabbitMq系列(六)：交换类型以及例子

RabbitMq系列(七)：直接交换Direct exchange

RabbitMq系列(八)：扇出交换Fanout Exchange

RabbitMq系列(九)：主题交换Topic Exchange

RabbitMq系列(十)：标头交换Headers exchange

RabbitMq系列(十一)：远程调用RPC

 

目录

前言

实际演示

演示1

演示2

前言

直接交换是RabbitMq主要的四种交换类型之一，其主要是针对单对单的单路由消息通信，类似于单聊。

直接交换依赖于路由键，我们可以使用 空字符串 和 自定义路由键+交换机类型 这两种方式来快速的创建我们需要的单路由通信机制。

直接交换没有通配符的说法和应用，所以其比较规则类型于 生产者routeKey == 消费者routeKey 这样的比较方式。当消息到达交换机过后，交换机将消息带来的 routing-key( 这里就是生产者定义的 routingKey ) 与 队列绑定的 binding-key( 这里就是消费者定义的 routingKey )进行比较，通过规则验证的队列会收到由交换机路由过来的消息。

实际演示

为了对直接交换有更加清楚的认识，我们采用两个消费者一个生产者的方式来演示（其中有对有错，请注意）。

演示1

  • 环境：
身份交换机队列routeKey
消费者1direct.exchangedirect.queue.onequeue.route.*
消费者2direct.exchangedirect.queue.onequeue.route.one
生产者direct.exchange无queue.route.one
  •  消费者1
/**
 * 消费者1
 *
 * @Tag 直接交换 Direct exchange
 */
public class MQConsumerOne {

    public static void main(String[] args) {
        try {
            consumerMsg("direct.exchange","direct.queue.one","queue.route.*");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void consumerMsg(String exchange,String queue,String routeKey) throws IOException, TimeoutException {
        //创建工厂连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接地址
        connectionFactory.setHost("192.168.239.128");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(exchange, BuiltinExchangeType.DIRECT,false);
        //声明队列
        channel.queueDeclare(queue,false,false,true,null);
        //绑定队列
        channel.queueBind(queue,exchange,routeKey,null);
        //创建消费者，消费消息
        channel.basicConsume(queue, true, (consumerTag, message) -> {
            //消费消息
            String msg = new String(message.getBody(), "UTF-8");
            System.out.println(msg);
        }, (consumerTag) -> {
            System.out.println(consumerTag);
        });
        //关闭连接
     /*   channel.close();
        connection.close();*/
    }
}
  • 消费者2
/**
 * 消费者2
 *
 * @Tag 直接交换 Direct exchange
 */
public class MQConsumerTwo {

    public static void main(String[] args) {
        try {
            consumerMsg("direct.exchange","direct.queue.one","queue.route.one");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void consumerMsg(String exchange,String queue,String routeKey) throws IOException, TimeoutException {
        //创建工厂连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接地址
        connectionFactory.setHost("192.168.239.128");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(exchange, BuiltinExchangeType.DIRECT,false);
        //声明队列
        channel.queueDeclare(queue,false,false,true,null);
        //绑定队列
        channel.queueBind(queue,exchange,routeKey,null);
        //创建消费者，消费消息
        channel.basicConsume(queue, true, (consumerTag, message) -> {
            //消费消息
            String msg = new String(message.getBody(), "UTF-8");
            System.out.println(msg);
        }, (consumerTag) -> {
            System.out.println(consumerTag);
        });
        //关闭连接
     /*   channel.close();
        connection.close();*/
    }
}
  • 唯一生产者 
/**
 * 生产者
 *
 *  @Tag 直接交换 Direct exchange
 */
public class MQProducer {

    public static void main(String[] args) {
        try {
            consumerMsg("direct.exchange","queue.route.one","这么耿直的人，当然是直接交换！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void consumerMsg(String exchange,String routeKey,String msg) throws IOException, TimeoutException {
        //创建工厂连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接地址
        connectionFactory.setHost("192.168.239.128");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(exchange, BuiltinExchangeType.DIRECT,false);
        //创建生产者，发送消息
        channel.basicPublish(exchange,routeKey,null,msg.getBytes());
        //关闭连接
        channel.close();
        connection.close();
    }
}
  • 全部代码编写完成后，分别启动消费者1、消费者2和生产者，观察收到消息的情况，突然发现消费者1 MQConsumerOne 竟然 收到消息了，而消费者2没收到消息。

  • 分析一下：

          1）消费者1的 routeKey：queue.route.*

          2）消费者2的 routeKey：queue.route.one

          3）生产者的 routeKey：queue.route.one

     消费者1的 routeKey  和 生产者的 routeKey 不相等，消费者2的 routeKey 和 生产者的 routeKey完全相等，理论上消费者1不该收到消息，消费者2该收到消息，但是实际结果却和我们的想象恰好相反，为什么呢？

额。。。。突然发现，妈蛋两个消费者的绑定队列竟然一模一样，都是 direct.queue.one ！！！

这个时候队列变成了 工作队列，只要有一个消费者的 routeKey 跟生产者的 routeKey 完全匹配，绑定在同一个队列的消费者都会收到消息。

各单位请注意，各单位请注意，演示1失败

演示2

  • 环境
身份交换机队列routeKey
消费者1direct.exchangedirect.queuequeue.route.*
消费者2direct.exchangedirect.queue.onequeue.route.one
生产者direct.exchange无queue.route.*
  • 消费者1
/**
 * 消费者1
 *
 * @Tag 直接交换 Direct exchange
 */
public class MQConsumerOne {

    public static void main(String[] args) {
        try {
            consumerMsg("direct.exchange","direct.queue","queue.route.*");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void consumerMsg(String exchange,String queue,String routeKey) throws IOException, TimeoutException {
        //创建工厂连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接地址
        connectionFactory.setHost("192.168.239.128");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(exchange, BuiltinExchangeType.DIRECT,false);
        //声明队列
        channel.queueDeclare(queue,false,false,true,null);
        //绑定队列
        channel.queueBind(queue,exchange,routeKey,null);
        //创建消费者，消费消息
        channel.basicConsume(queue, true, (consumerTag, message) -> {
            //消费消息
            String msg = new String(message.getBody(), "UTF-8");
            System.out.println(msg);
        }, (consumerTag) -> {
            System.out.println(consumerTag);
        });
        //关闭连接
     /*   channel.close();
        connection.close();*/
    }
}
  • 消费者2
/**
 * 消费者2
 *
 * @Tag 直接交换 Direct exchange
 */
public class MQConsumerTwo {

    public static void main(String[] args) {
        try {
            consumerMsg("direct.exchange","direct.queue.one","queue.route.one");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void consumerMsg(String exchange,String queue,String routeKey) throws IOException, TimeoutException {
        //创建工厂连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接地址
        connectionFactory.setHost("192.168.239.128");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(exchange, BuiltinExchangeType.DIRECT,false);
        //声明队列
        channel.queueDeclare(queue,false,false,true,null);
        //绑定队列
        channel.queueBind(queue,exchange,routeKey,null);
        //创建消费者，消费消息
        channel.basicConsume(queue, true, (consumerTag, message) -> {
            //消费消息
            String msg = new String(message.getBody(), "UTF-8");
            System.out.println(msg);
        }, (consumerTag) -> {
            System.out.println(consumerTag);
        });
        //关闭连接
     /*   channel.close();
        connection.close();*/
    }
}
  • 唯一生产者
/**
 * 生产者
 *
 *  @Tag 直接交换 Direct exchange
 */
public class MQProducer {

    public static void main(String[] args) {
        try {
            consumerMsg("direct.exchange","queue.route.*","这么耿直的人，当然是直接交换！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void consumerMsg(String exchange,String routeKey,String msg) throws IOException, TimeoutException {
        //创建工厂连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接地址
        connectionFactory.setHost("192.168.239.128");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(exchange, BuiltinExchangeType.DIRECT,false);
        //创建生产者，发送消息
        channel.basicPublish(exchange,routeKey,null,msg.getBytes());
        //关闭连接
        channel.close();
        connection.close();
    }
}
  • 再来确认一下，免得又出幺蛾子，分别启动消费者1、消费者2、生产者，查看下消息的收到情况，这里发现只有消费者1收到消息，消费者2未收到消息，可以多试几次，多发几次消息

  • 分析一下

          1）消费者1的 routeKey：queue.route.*

          2）消费者2的 routeKey：queue.route.one

          3）生产者的 routeKey：queue.route.*

 消费者1的 routeKey  和 生产者的 routeKey 完全相等，消费者2的 routeKey 和 生产者的 routeKey不相等，理论上消费者1应该收到消息，消费者2应该没消息。

除了上面的分析条件外，这里两个消费者的队列很明显不一样，测试结果完全完全跟我们想像的一样，演示成功

丶醉卧
关注
专栏目录
RabbitMQ系列--Direct Exchange
撸码社区的博客
08-03 517
RabbitMQ工作流程 左边是生产者，右边是消费者，中间红框内是RabbitMQ服务器，其中包括交换机以及消息队列 消费者发送消息给RabbitMQ服务器，交换机接收到消息，然后根据不同的交换机规则投递给消息队列，消费者订阅消息进行消费 RabbitMQ交换机类型 作用：接收消息，按照路由规则将消息路由到一个或者多个队列。如果路由不到，或者返回给生产者，或者直接丢弃。RabbitMQ常用的交换器常用类型有direct、topic、fanout三种，其他的由于性能不好等原因几乎用不到，后续主要介绍这
RabbitMQ核心API-Exchange之Direct、Topic、Fanout、其他关键概念
a898712940的博客
04-26 308
一：RabbitMQ核心API-Exchange之Direct【直连模式】 二：RabbitMQ核心API-Exchange之Topic【正则匹配模式】 三：RabbitMQ核心API-Exchange之Fanout【类似广播】 四：RabbitMQ核心API-其他关键概念讲解 一：RabbitMQ核心API-Exchange之Direct【直连模式】 1、Exchange 接收消息，并根据路由键(Routing key)转发消息所绑定的队列 2、Exchange 交换机的属性 Na.
RabbitMQ：交换机（direct exchange）
kaven
02-10 1853
Java初识RabbitMQ一交换机（direct exchange） 首先看看AMQP协议，对RabbitMQ的架构会更了解。 深入理解AMQP协议 创建一个Maven项目，根据自己服务器RabbitMQ的版本导入相应的包。 <dependency> <groupId>com.rabbitmq</groupId> <artifactId...
RabbitMQ之Direct exchange
lamwolf的博客
12-14 198
在这种绑定情况下，生产者发布消息到exchange上，绑定键为orange的消息会被发布到队列Q1。绑定键为black和green的消息会被发布到队列Q2,其他类型的消息将被丢弃。在上面这张图中，我们可以看到X绑定了两个队列，绑定类型是direct。队列Q1绑定键为orange,队列Q2绑定键有两个：一个绑定键为black,另一个绑定键为green.
（1）关于RabbitMq 的 Direct Exchange 直连型交换机
分享日常bug
09-27 1243
在这个界面里面我们可以做些什么？可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。以上这些管理界面的操作在这篇暂时不做扩展描述，我想着重介绍后面实例里会使用到的。根据消息携带的路由键将消息投递给对应队列。大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key。然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时交换机就会根据这个路由值X去寻找绑定值也是X的队列。
RabbitMQ之DirectExchange
gloamer的博客
09-14 881
DirectExchange，咱们看名字可以看的出来，是一种交换机，那我们首先要了解咱们的一个架构了，咱们的消息提供者发送消息根据交换机，把消息放在交换机绑定的消息队列上，然后消息的消费者，再去消费队列的消息，DirectExchange，其实交换机就是在做一个消息的分发、将提供者的消息分发到对应的队列上，DirectExchange，就可以根据对应的路由将消息放在对应的一个队列上。然后消息的消费者再去对应的队列里面去监听和消费消息。 通俗来讲就是定向的交换机，根据路由和消...
RabbitMQ安装使用（直接交换direct exchange）
08-10
**RabbitMQ安装使用——直接交换（direct exchange）** RabbitMQ是一款开源的消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议，广泛应用于分布式系统中的异步任务处理、解耦通信以及高并发场景。...
Springboot整合RabbitMQ：使用DirectExchange实现路由过滤
这里的`DirectExchange`是另一种类型的交换器，相比之前的`FanoutExchange`，它提供了更灵活的路由策略。`FanoutExchange`会将所有消息广播给所有绑定的队列，而`DirectExchange`则依赖于路由键（routingKey）进行...
rabbitmq-component:rabbitmq组件
04-20
- **Direct**：直接交换，消息根据路由键精确匹配队列。 - **Fanout**：广播交换，所有绑定到该交换器的队列都会收到消息。 - **Topic**：主题交换，路由键是模式匹配，如`news.*`匹配`news.us`和`news.uk`。 - ...
RabbitMQ系列教程（三）RabbitMQ Exchange类型之Direct Exchange
warybee
11-17 1790
Direct Exchange 一对一完全匹配，将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配
rabbitmq-direct exchange（直接交换器）
hsgao_water的博客
10-11 346
Direct exchange 直接交换器模式，其路由算法非常简单，一条消息只发送到完全匹配的队列。 我们使用以下几个实例来说明： 实例1 在这个直接交换器实例中，我们绑定了两个队列到交换器中，第一个队列使用绑定键orange，第二个队列使用black和green绑定键。 在这个实例中，路由键为“orange”的消息将被分发到队列Q1，路由键为”black”和“green”将被发到队...
交换机交换的工作方式有哪三种？
weixin_33768481的博客
11-16 2450
1.直通式（Cut Through） 　 直通方式的以太网交换机可以理解为在各端口间是纵横交叉的线路矩阵电话交换机。它在输入端口检测到一个数据包时，检查该包的包头，获取包的目的地址，启动内部的动态查找表转换成相应的输出端口，在输入与输出交叉处接通，把数据包直通到相应的端口，实现交换功能。由于不需要存储，延迟非常小、交换非常快，这是它的优点。它的缺点是，因为数据包内容并没有...
SpringAMQP--DirectExchange
Leon_Jinhai_Sun的博客
11-13 408
Direct 在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。 在Direct模型下： 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key） 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。 Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有
203、RabbitMQ 之 使用 direct 类型的 Exchange 实现 消息路由 （RoutingKey）
最新发布
Java 领域技术分享
10-12 1462
RabbitMQ 之 使用 direct 类型的 Exchange 实现 消息路由 （RoutingKey）
RabbitMQ的Exchange 模式之direct（指定模式）
浪丶荡
11-30 4788
direct模式是rabbitmq的默认模式，看懂了下图基本就明白了该模式 在这个模式中，我们可以看到两个队列在direct模式下绑定的Exchange（交换机）X. 第一个队列用binding key（绑定关键字）orange绑定，第二个队列有两个binding key，一个为black，一个是green在这种模式中，通过binding key orange发布到Exchange的消息 将被
RabbitMq中交换器（Exchange）类型详解
技术人集结地
04-04 7756
RabbitMQ是工作中经常使用的一个开源消息队列，它是通过Erlang语言来开发的，RabbitMQ中有一个非常常见且重要的概念叫交换器（Exchange），所有生产者提交的消息都是通过Exchange进行接收，然后通过特定的路由策略转发对特定的队列（Queue）中，然后消费者通过绑定特定的队列，将队列中的信息进行消费处理。我们如果是通过RabbitMQ的客户端来进行创建Exchange的话，一定需要你选择一个特定的Exchange类型的，这个时候如果不了解每一种类型的特性，就很容易选择错误，造成整
RabbitMQ之Direct（直连）Exchange解读
一个菜鸡的博客
10-07 793
在rabbitmq中，生产者发信息不会直接将信息投递到队列中，而是先将信息投递到交换机中，在交换机转发在具体的队列，队列再将信息推送或者拉取消费者进行消费路由键（Routingkey）生产者将信息发送给交换机的时候 会指定Routingkey指定路由规则绑定键（Bindingkey)通过绑定键将交换机与队列关联起来，这样rabbtamq就知道如何正确的将信息路由到队列Direct（直连）Exchange。
Direct exchange
一个菜鸡的博客
07-23 1872
routingKey来表示也可称该参数为bindingkey，创建绑定我们用代码channel.queueBind(queueName,EXCHANGE_NAME,"routingKey");绑定之后的意义由其交换类型决定。Fanout这种交换类型并不能给我们带来很大的灵活性-它只能进行无意识的广播，在这里我们将使用direct这种类型来进行替换，这种类型的工作方式是，消息只去到它绑定的routingKey队列中去。...
Direct Exchange
weixin_45012575的博客
10-30 122
6.1简介 一方面是接收生产者的消息，另一方面是向队列推送消息 匿名转发 “” Fanout(不处理路由键) Direct(处理路由键) 6.2.路由模式 生产者 package com.blj.rabbitmq.routing; import com.blj.rabbitmq.util.ConnectionUtils; import com.rabbitmq.clie...
直接交换排序
YinJianxiang的博客
03-26 1601
直接交换排序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值