RabbitMQ之交换机

最新推荐文章于 2024-10-06 19:15:22 发布
最新推荐文章于 2024-10-06 19:15:22 发布
阅读量341 收藏 7
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45174759/article/details/103682692
版权

前言：

根据我们在RabbitMQ入门里面所了解到的，我们知道了生产端和消费端是通过队列来进行消息互通的，但其实在生产端加入队列的时候还要进行一步操作，也就是我们今天所讲的交换机。

交换机

在这里插入图片描述

交换机属性：
Name：交换机名称
Type：交换机类型 direct、topic、fanout、headers
Durability：是否需要持久化，true为持久化
Auto Delete：当最后一个绑定到Exchange上的队列删除后，自动删除该Exchange
Internal：当前Exchange是否用于RabbitMQ内部使用，默认为False
Arguments：扩展参数，用于扩展AMQP协议，定制化使用

直流交换机

直连交换机Direct Exchange（完全匹配路由key）

所有发送到Direct Exchange的消息会被转发到RouteKey中指定的Queue

注意：Direct模式可以使用RabbitMQ自带的Exchange：default Exchange，所以不需要将Exchange进行任何绑定（binding）操作，消息传递时，RouteKey必须完全匹配才会被队列接收，否则该消息会被抛弃；

消费端代码

package com.dengrenli.rabbitmqapi.exchange.direct;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

/**
 * @author小科比
 * @site www.dengrenli.com
 * @company 科比公司
 * @create  2019-12-24 14:55
 */
public class Consumer4DirectExchange {
    public static void main(String[] args) throws Exception {


        ConnectionFactory connectionFactory = new ConnectionFactory() ;

        connectionFactory.setHost("192.168.149.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        connectionFactory.setAutomaticRecoveryEnabled(true);
        connectionFactory.setNetworkRecoveryInterval(3000);
        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();
        //4 声明
        String exchangeName = "test_direct_exchange";
        String exchangeType = "direct";
        String queueName = "test_direct_queue";
        String routingKey = "test.direct";

        //表示声明了一个交换机
        channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
        //表示声明了一个队列
        channel.queueDeclare(queueName, false, false, false, null);
        //建立一个绑定关系:
        channel.queueBind(queueName, exchangeName, routingKey);

        //durable 是否持久化消息
        QueueingConsumer consumer = new QueueingConsumer(channel);
        //参数：队列名称、是否自动ACK、Consumer
        channel.basicConsume(queueName, true, consumer);
        //循环获取消息
        while(true){
            //获取消息，如果没有消息，这一步将会一直阻塞
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println("收到消息：" + msg);
        }
    }
}

生产端代码

package com.dengrenli.rabbitmqapi.exchange.direct;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @author小科比
 * @site www.dengrenli.com
 * @company 科比公司
 * @create  2019-12-24 14:55
 */
public class Producer4DirectExchange {
    public static void main(String[] args) throws Exception {

        //1 创建ConnectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.149.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2 创建Connection
        Connection connection = connectionFactory.newConnection();
        //3 创建Channel
        Channel channel = connection.createChannel();
        //4 声明
        String exchangeName = "test_direct_exchange";
        String routingKey = "test.direct";
//        String routingKey = "test.direct111"; //收不到
        //5 发送

        String msg = "Hello World RabbitMQ 4  Direct Exchange Message 111 ... ";
        channel.basicPublish(exchangeName, routingKey , null , msg.getBytes());

    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

主题交换机

主题交换机Topic Exchange（匹配路由规则的交换机）

所有发送到Topic Exchange的消息被转发到所有关系RouteKey中指定Topic的Queue上；

Exchange将RouteKey和某Topic进行模糊匹配，此时队列需要绑定一个Topic；

注意：可以使用通配符进行模糊匹配

符号：“#” 匹配一个或者多个词
符号：“*” 匹配不多不少一个词
列如：
“log.#” 能够匹配到 “log.info.oa”
“log.*” 能够匹配到 “log.err”

消费端代码

package com.dengrenli.rabbitmqapi.exchange.fanout;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

/**
 * @author小科比
 * @site www.dengrenli.com
 * @company 科比公司
 * @create  2019-12-24 14:55
 */
public class Consumer4TopicExchange {
    public static void main(String[] args) throws Exception {


        ConnectionFactory connectionFactory = new ConnectionFactory() ;

        connectionFactory.setHost("192.168.149.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        connectionFactory.setAutomaticRecoveryEnabled(true);
        connectionFactory.setNetworkRecoveryInterval(3000);
        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();
        //4 声明
        String exchangeName = "test_topic_exchange";
        String exchangeType = "topic";
        String queueName = "test_topic_queue";
        String routingKey = "user.#";
//        String routingKey = "user.*";
        // 1 声明交换机
        channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
        // 2 声明队列
        channel.queueDeclare(queueName, false, false, false, null);
        // 3 建立交换机和队列的绑定关系:
        channel.queueBind(queueName, exchangeName, routingKey);

        //durable 是否持久化消息
        QueueingConsumer consumer = new QueueingConsumer(channel);
        //参数：队列名称、是否自动ACK、Consumer
        channel.basicConsume(queueName, true, consumer);
        //循环获取消息
        while(true){
            //获取消息，如果没有消息，这一步将会一直阻塞
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println("收到消息：" + msg);
        }
    }
}

生产端代码

package com.dengrenli.rabbitmqapi.exchange.fanout;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @author小科比
 * @site www.dengrenli.com
 * @company 科比公司
 * @create  2019-12-24 14:55
 */
public class Producer4TopicExchange {
    public static void main(String[] args) throws Exception {

        //1 创建ConnectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.149.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2 创建Connection
        Connection connection = connectionFactory.newConnection();
        //3 创建Channel
        Channel channel = connection.createChannel();
        //4 声明
        String exchangeName = "test_topic_exchange";
        String routingKey1 = "user.save";
        String routingKey2 = "user.update";
        String routingKey3 = "user.delete.abc";
        //5 发送

        String msg = "Hello World RabbitMQ 4 Topic Exchange Message ...";
        channel.basicPublish(exchangeName, routingKey1 , null , msg.getBytes());
        channel.basicPublish(exchangeName, routingKey2 , null , msg.getBytes());
        channel.basicPublish(exchangeName, routingKey3 , null , msg.getBytes());
        channel.close();
        connection.close();
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

输出交换机

输出交换机Fanout Exchange（不做路由）
不处理路由键，只需要简单的将队列绑定到交换机上；
发送到交换机的消息都会被转发到与该交换机绑定的所有队列上；
Fanout交换机转发消息是最快的

消费端代码

package com.dengrenli.rabbitmqapi.exchange.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

/**
 * @author小科比
 * @site www.dengrenli.com
 * @company 科比公司
 * @create  2019-12-24 14:55
 */
public class Consumer4FanoutExchange {
    public static void main(String[] args) throws Exception {

        ConnectionFactory connectionFactory = new ConnectionFactory() ;

        connectionFactory.setHost("192.168.149.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        connectionFactory.setAutomaticRecoveryEnabled(true);
        connectionFactory.setNetworkRecoveryInterval(3000);
        Connection connection = connectionFactory.newConnection();

        Channel channel = connection.createChannel();
        //4 声明
        String exchangeName = "test_fanout_exchange";
        String exchangeType = "fanout";
        String queueName = "test_fanout_queue";
        String routingKey = "";    //不设置路由键
        channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
        channel.queueDeclare(queueName, false, false, false, null);
        channel.queueBind(queueName, exchangeName, routingKey);

        //durable 是否持久化消息
        QueueingConsumer consumer = new QueueingConsumer(channel);
        //参数：队列名称、是否自动ACK、Consumer
        channel.basicConsume(queueName, true, consumer);
        //循环获取消息
        while(true){
            //获取消息，如果没有消息，这一步将会一直阻塞
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println("收到消息：" + msg);
        }
    }
}

生产端代码

package com.dengrenli.rabbitmqapi.exchange.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @author小科比
 * @site www.dengrenli.com
 * @company 科比公司
 * @create  2019-12-24 14:55
 */
public class Producer4FanoutExchange {
    public static void main(String[] args) throws Exception {

        //1 创建ConnectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.149.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2 创建Connection
        Connection connection = connectionFactory.newConnection();
        //3 创建Channel
        Channel channel = connection.createChannel();
        //4 声明
        String exchangeName = "test_fanout_exchange";
        //5 发送
        for(int i = 0; i < 10; i ++) {
            String msg = "Hello World RabbitMQ 4 FANOUT Exchange Message ...";
            channel.basicPublish(exchangeName, "", null , msg.getBytes());
        }
        channel.close();
        connection.close();
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Binding-绑定
Exchange和Exchange、Queue之间的连接关系；
Binding中可以包含RoutingKey或者参数

Queue-消息队列
消息队列，实际存储消息数据
Durability：是否持久化
Durable：是，Transient：否
Auto delete：如选yes，代表当最后一个监听被移除之后，该Queue会自动被删除

Message-消息
服务器和应用程序之间传递的数据
本质上就是一段数据，由Properties和Payload（Body）组成
常用属性：delivery model、headers（自定义属性）

Message-其他属性
content_type、content_encoding、priority
correlation_id、reply_to、expiration、message_id
Timestamp、type、user_id、app_id、cluster_id

Virtual host-虚拟主机
虚拟地址，用于进行逻辑隔离，最上层的消息路由
一个Virtual Host里面可以有若干个Exchange和Queue
同一个Virtual Host里面不能有相同名称的Exchange或Queue

谢谢大家，多多指教！！！
在这里插入图片描述

冬.
关注
Rabbitmq之交换机
u013129606的博客
09-16 169
生产者将消息发送到消息系统的时候，不是直接发送到队列，而是发送到交换机，由交换机路由到相应的队列 交换机有三种路由模式 1.direct 交换机通过一个routing key和队列绑定，当生产者生产消息的时候指定一个routing key，当绑定队列的routing key和生产者发送的routing key一致，那么交换机就会把消息发送到这个队列 public class Co...
RabbitMQ交换机
xieminglu的博客
12-22 484
RabbitMQ交换机 交换机属性： Name：交换机名称 Type：交换机类型 direct、topic、fanout、headers Durability：是否需要持久化，true为持久化 Auto Delete：当最后一个绑定到Exchange上的队列删除后，自动删除该Exchange Internal：当前Exchange是否用于RabbitMQ内部使用，默认为False Argumen...
rabbitMQ 交换机
TonyWu的博客
09-30 483
rabbitMq有四种类型的交换机fanout、direct、topic、headers 实际在RabbitMQ中，生产者将消息发送到Exchange（交换器，下图中的X），由Exchange将消息路由到一个或多个Queue中（或者丢弃）。 Exchange是按照什么逻辑将消息路由到Queue的？。 RabbitMQ中的Exchange有四种类型，不同的类型有着不同的路由策略，。有四种类型的...
RabbitMQ入门5—exchange参数之durability
最新发布
小诸葛的博客
10-06 487
在 RabbitMQ 中，durability参数不仅可以应用于队列，也可以应用于交换机（Exchange）。durability参数决定了在 RabbitMQ 服务器重启后是否仍然存在。durability。
RabbitMQ（三）------routing 路由选择/通配符模式
qq_42727102的博客
02-14 669
1.Excahnge(交换机/转发器)： ​ 一方面接收生产者的消息，另一方面是向队列推送消息 2.匿名转发 ： “”； 3.fanout（不处理路由键） direct（处理路由键） 路由模式： 4.Send.java public class Send { private static final String EXCHANGE_NAME = "test_exchange_direc...
RabbitMQ - 4种交换机详解
Dragon1993vsLong的博客
09-01 1690
RabbitMQ 路由 1、 Direct Exchange 把Exchange 路由 和 Queue 绑定 ———— queue 中保存了一个 路由 key 路由将指定 key 的消息发送给相应的消费者 创建信道，声明路由，插入消息 using (var connection = factory.CreateConnection()) { using (IModel channel = conn.................
02、RabbitMQ之交换机
qq_43469718的博客
12-24 359
一、 Exchange(交换机)的作用 在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列， 队列再将消息以推送或者拉取方式给消费者进行消费 创建消息 路由键 pull/push 生产者------------>交换机------------>队列------------...
批量删除rabbitmq的队列或交换机
06-29
采用python编写的批量删除rabbitmq的队列或交换机。 1.修改rabbitmq_delete.py中rabbitmq的配置； 2.执行以下命令： 删除队列: python3 rabbitmq_delete.py -k ‘udata.climb’ -d 1 删除交换机: python3 rabbitmq_...
RabbitMQ（02章）：RabbitMQ之交换机（直联、主题、扇形）
weixin_61024320的博客
12-12 701
在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列， 队列再将消息以推送或者拉取方式给消费者进行消费 创建消息 路由键 pull/push 生产者------------>交换机------------>队列------------>消费者
RabbitMQ与交换机
weixin_66202611的博客
12-18 797
直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定，除此之外再绑定一个routing_key，当消息被发送的时候，需要指定一个binding_key，这个消息被送达交换机的时候，就会被这个交换机送到指定的队列里面去。主题交换机的routing_key需要有一定的规则，交换机和队列的binding_key需要采用*.#.*.....的格式，每个部分用.分开，其中。因此，当携带着名为”hello”的路由键的消息被发送到默认交换机的时候，此消息会被默认交换机路由至名为”hello”的队列中。
总结几点Quartz的经验
Foxswily的专栏
06-03 216
总结一下经典的定时处理框架quartz的使用经验。基于 Ver. 1.8.0   1.配置方式         最常用的方式properties + xml定义 org.quartz.scheduler.instanceName = CMS_Batch org.quartz.scheduler.instanceId = AUTO org.quartz.threadPool.class...
quartz 参数说明
热门推荐
lzj0470的专栏
01-03 2万+
JobDetail JobDetail 用来保存我们作业的详细信息。一个JobDetail可以有多个Trigger，但是一个Trigger只能对应一个JobDetail。下面是JobDetail的一些常用的属性和含义 参数名 类型 备注 name String 任务的名称，必须 group
事务的4个特性——ACID（原子性、一致性、隔离性和持久性）、更新丢失问题...
coco3600的博客
07-02 686
事务的4个特性——ACID（原子性、一致性、隔离性和持久性） 事务是一个操作序列。这些操作要么都做，要么都不做，是一个不可分割的工作单位。事务通常以BEGIN TRANSACTION开...
RabbitMQ.交换机
Cat_Jay_Fish的博客
02-26 1427
交换机（Exchange） 交换机的属性 Name：交换机名称 Type：交换机类型，direct,topic,fanout,headers Durability:是否需要持久化，如果持久性，则RabbitMQ重启后，交换机还存在 Auto Delet：当最后一个绑定到Exchange的队列删除后，自动删除改Exchange Internal：当前Exchange是否用于RabbitMQ内部使用，默认为False Arguments：扩展参数，用于...
RabbitMQ三种交换机的实现方式
weixin_42454678的博客
12-02 432
1.使用direct交换机 消费者： spring.rabbitmq.host=192.168.56.122 spring.rabbitmq.port=5672 spring.rabbitmq.username=admin spring.rabbitmq.password=111111 #交换机名称 mq.rabbit.direct.exchange=log.direct #info队列名称 mq...
RabbitMq中的durable
Lvlht的博客
04-18 1万+
RabbitMq对交换器，队列，消息都可以声明持久化属性，交换器和队列持久化属性为durable（其属性值为false代表不持久化，属性值为true代表持久化），消息持久化属性为deliveryMode（其属性值为1代表不持久化，属性值为2代表持久化）。 在说明durable之前，需要指出的是： 1，RabbitMq实例以broker表示，当broker重启时，所有未申明durable的交换器和队...
rabbitmq之交换机fanout（c#）
weixin_43906877的博客
08-15 1325
rabbitmq之交换机fanout（c#） fanout的主要功能是广播，他会将他收到的消息广播到它已知的所有队列当中 这个特性我们可以适用于群发的情况，像官方例子当中的简单日志广播，也可以用于接受数据源（如硬件采集到的数据）提供的数据，将其转发给数据库用于保存，转发给程序用于显示等等 其过程如下 publish的实现代码如下 var factory = new C...
rabbitmq默认交换机
08-14
- *1* *2* [RabbitMQ学习之交换机](https://blog.csdn.net/u010517268/article/details/104423712)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值