RabbitMQ之交换器类型

最新推荐文章于 2022-04-18 18:47:18 发布
最新推荐文章于 2022-04-18 18:47:18 发布
阅读量300 收藏
点赞数
分类专栏： RabbitMQ 消息中间件 文章标签： RabbitMQ RabbitMQ 交换器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyfvsfy/article/details/84953453
版权

交换器类型

在RabbitMQ中，生产者的消息不是直接发送到队列中，而是先发送交换器，由交换器通过规则路由到对应的队列中。

  • 一个交换器可以绑定多个队列
  • 特定的交换器上，一个队列能绑定多个路由键
  • 一个队列上能绑定多个消费者，队列采用轮询的方式将消息发送给每个消费者。

RabbitMQ 一共有四种交换器类型，分别为 direct、fanout、topic、headers。其中headers类型几乎和direct功能一样，所以完全可以忽略。

Direct Exchange

 

  • 路由键完全匹配，即发送消息时指定的RoutingKey与队列绑定到交换器上的Key要完全匹配。

注意：不要错误的认为队列中绑定的Key为“#”就能收到全部消息，在Direct交换器中“#”也只是一个普通的字符。

 

  • RabbitMQ中包含一个默认的交换器，如下图。交换器的名字为空白字符串，图中显示 （AMQP default） 

Fanout Exchange

  • 不需要路由键，消息以广播形式发出，所有到绑定到交换机上的队列都会收到复制的消息。
  • Fanout交换机转发消息是最快的

 Topic Exchange

 

  • 要求路由键与队列上绑定KEY的规则相匹配。
  • 其中匹配规则中有两个特殊的标识符 "#" 和 "*"，"*" 表示匹配一个字符，"#" 表示匹配一个或多个字符。
  1. 消息 (usa.news) -> 队列 (usa.*)
  2. 消息 (usa.news) -> 队列(usa.#)
  3. 消息 (usa.news) -> 队列(#)
  4. 消息 (usa.news.it) -> 队列 (usa.*.it)
  5. 消息 (usa.news.it) -> 队列 (usa.*.*)
  6. 消息 (usa.news.it) -> 队列 (usa.#)
  7. 消息 (usa.news.it) -> 队列 (#.it)
  8. 消息 (usa.news.it) -> 队列 (#)

Java 代码实现 

需求说明

 有两种日志级别 INFO 和 ERROR 。

  1. 假设我们要做日志分析，由于日志格式的不同，需要把INFO日志存放 q_info 队列，Error日志存放到q_error队列。
  2. 假设有多个部门都要做日志分析，A部门用作日志做系统安全分析，B部门用作用户行为分析。A 部门使用 q_department_a队列，B部门使用q_department_b队列。
  3. 假设要收集多个系统的日志，其中包括订单系统、商品系统、库存系统等。只分析所有系统ERROR日志和商品系统的INFO日志。 

 针对以上几个需要我们可以分别用Direct 、Fanout 和 Topic 来实现。

Direct

 需求1使用direct类型的交换器实现

日志生产者 DirectProducer

public class DirectProducer {
	//交换器名称
	public final static String EXCHANGE_NAME = "direct_log_exchange";
	//定义日志级别
	private static String[] logLevels = {"INFO","ERROR"};
	
	public static void main(String[] args) throws Exception {
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		Connection connection = connectionFactory.newConnection();
		Channel channel = connection.createChannel();
		//声明交换器为Direct类型
		channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
		for(String logLevel : logLevels){
			for(int i=0;i<3;i++){
				TimeUnit.MILLISECONDS.sleep(100);
				String date = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS").format(new Date());
				String message = date + " " + logLevel + ": this is log message";
				System.out.println("Sent -> " + message);
				//发送消息
				channel.basicPublish(EXCHANGE_NAME, logLevel, null, message.getBytes());
			}
		}
		channel.close();
		connection.close();
	}

输出结果如下：

Sent -> 2018-12-11T11:24:21.323 INFO: this is log message
Sent -> 2018-12-11T11:24:21.427 INFO: this is log message
Sent -> 2018-12-11T11:24:21.528 INFO: this is log message
Sent -> 2018-12-11T11:24:21.628 ERROR: this is log message
Sent -> 2018-12-11T11:24:21.728 ERROR: this is log message
Sent -> 2018-12-11T11:24:21.828 ERROR: this is log messag

日志消费者 ErrorLogDirectConsumer

 public class ErrorLogDirectConsumer {
	private static final String QUEUE_NAME = "q_error";
	private static final String ROUTING_KEY = "ERROR";
	public static void main(String[] args) throws IOException, TimeoutException {
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		Connection connection = connectionFactory.newConnection();
		Channel channel = connection.createChannel();
		//声明交换器，此处需要声明Direct类型
		channel.exchangeDeclare(DirectProducer.EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		//此处需要绑定KEY为ERROR
		channel.queueBind(QUEUE_NAME, DirectProducer.EXCHANGE_NAME, ROUTING_KEY);
		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("["+envelope.getExchange()+"] ["+envelope.getRoutingKey() +"] ["+envelope.getDeliveryTag()+"] : "+  message);
	            }
		};
		channel.basicConsume(QUEUE_NAME, true, consumer);
	}
}

输出结果如下：

[direct_log_exchange] [ERROR] [7] : 2018-12-11T11:24:21.628 ERROR: this is log message
[direct_log_exchange] [ERROR] [8] : 2018-12-11T11:24:21.728 ERROR: this is log message
[direct_log_exchange] [ERROR] [9] : 2018-12-11T11:24:21.828 ERROR: this is log message

 此处仅打印出了ERROR日志，说明只有KEY绑定ERROR的队列收到了消息。

 日志消费者 InfoLogDirectConsumer

与ERROR日志消费者一样，需要修改以下部分。 

public class InfoLogDirectConsumer {	
    private static final String QUEUE_NAME = "q_info";
	private static final String ROUTING_KEY = "INFO"; 
    .......
 }

 输出结果如下：

[direct_log_exchange] [INFO] [7] : 2018-12-11T11:24:21.323 INFO: this is log message
[direct_log_exchange] [INFO] [8] : 2018-12-11T11:24:21.427 INFO: this is log message
[direct_log_exchange] [INFO] [9] : 2018-12-11T11:24:21.528 INFO: this is log message

此处仅打印出了INFO日志，说明只有KEY绑定为INFO的队列收到了消息。

 Fanout

需求2使用fanout类型的交换器实现

 生产者 FanoutProducer

public class FanoutProducer {
	//交换器名称
	public final static String EXCHANGE_NAME = "fanout_log_exchange"; 
    //定义日志级别
	private static String[] logLevels = {"INFO","ERROR"};
 
	public static void main(String[] args) throws Exception {
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		Connection connection = connectionFactory.newConnection();
		Channel channel = connection.createChannel();
		//声明交换器，此处需要声明BuiltinExchangeType.FANOUT
		channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
		for(String logLevel : logLevels){
			for(int i=0;i<3;i++){
				TimeUnit.MILLISECONDS.sleep(100);
				String date = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS").format(new Date());
				String message = date + " " + logLevel + ": this is log message";
				System.out.println("Sent -> " + message);
				channel.basicPublish(EXCHANGE_NAME, logLevel, null, message.getBytes());
			}
		}
		channel.close();
		connection.close();
	}

输出结果如下：

Sent -> 2018-12-11T11:39:11.188 INFO: this is log message
Sent -> 2018-12-11T11:39:11.292 INFO: this is log message
Sent -> 2018-12-11T11:39:11.392 INFO: this is log message
Sent -> 2018-12-11T11:39:11.493 ERROR: this is log message
Sent -> 2018-12-11T11:39:11.593 ERROR: this is log message
Sent -> 2018-12-11T11:39:11.694 ERROR: this is log message

部门A消费者 DepartmentAFanoutConsumer

public class DepartmentAFanoutConsumer {
	//定义队列名称
	private static final String QUEUE_NAME = "q_department_a";
	
	public static void main(String[] args) throws IOException, TimeoutException {
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		Connection connection = connectionFactory.newConnection();
		Channel channel = connection.createChannel();
		//声明交换器为Fanout类型
		channel.exchangeDeclare(FanoutProducer.EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		//此处绑定的key不起作用，但是参数要求必须填写，这里使用“”作为参数。
		channel.queueBind(QUEUE_NAME, FanoutProducer.EXCHANGE_NAME, "");
		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("["+envelope.getExchange()+"] ["+envelope.getRoutingKey() +"] ["+envelope.getDeliveryTag()+"] : "+  message);
	            }
		};
		//执行持续消费
		channel.basicConsume(QUEUE_NAME, true, consumer);
	}

输出结果如下：

[fanout_log_exchange] [INFO] [1] : 2018-12-11T11:39:11.188 INFO: this is log message
[fanout_log_exchange] [INFO] [2] : 2018-12-11T11:39:11.292 INFO: this is log message
[fanout_log_exchange] [INFO] [3] : 2018-12-11T11:39:11.392 INFO: this is log message
[fanout_log_exchange] [ERROR] [4] : 2018-12-11T11:39:11.493 ERROR: this is log message
[fanout_log_exchange] [ERROR] [5] : 2018-12-11T11:39:11.593 ERROR: this is log message
[fanout_log_exchange] [ERROR] [6] : 2018-12-11T11:39:11.694 ERROR: this is log message

部门B消费者 DepartmentBFanoutConsumer

public class DepartmentBFanoutConsumer {
	//定义队列名称
	private static final String QUEUE_NAME = "q_department_b";
	
	public static void main(String[] args) throws IOException, TimeoutException {
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		Connection connection = connectionFactory.newConnection();
		Channel channel = connection.createChannel();
		//声明交换器为Fanout类型
		channel.exchangeDeclare(FanoutProducer.EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		//此处绑定的key不起作用，但是参数要求必须填写，这里使用“”作为参数。
		channel.queueBind(QUEUE_NAME, FanoutProducer.EXCHANGE_NAME, "");
		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("["+envelope.getExchange()+"] ["+envelope.getRoutingKey() +"] ["+envelope.getDeliveryTag()+"] : "+  message);
	            }
		};
		//执行持续消费
		channel.basicConsume(QUEUE_NAME, true, consumer);
	}
}

输出结果如下：

[fanout_log_exchange] [INFO] [1] : 2018-12-11T11:39:11.188 INFO: this is log message
[fanout_log_exchange] [INFO] [2] : 2018-12-11T11:39:11.292 INFO: this is log message
[fanout_log_exchange] [INFO] [3] : 2018-12-11T11:39:11.392 INFO: this is log message
[fanout_log_exchange] [ERROR] [4] : 2018-12-11T11:39:11.493 ERROR: this is log message
[fanout_log_exchange] [ERROR] [5] : 2018-12-11T11:39:11.593 ERROR: this is log message
[fanout_log_exchange] [ERROR] [6] : 2018-12-11T11:39:11.694 ERROR: this is log message

从结果中可以看出部门A消费者和部门B消费者都打印出了所有消息。从而说明Fanout类型的交换器是以广播的方式发送消息。

Topic

 需求3使用topic类型的交换器实现

 生产者 TopicProducer

public class TopicProducer {
	//交换器名称
	public final static String EXCHANGE_NAME = "topic_log_exchange";
	//定义日志级别
	private static String[] logLevels = {"INFO","ERROR"};
	//定义订单、商品和库存系统
	private static String[] systems = {"ORDER","PRODUCT","INVENTORY"};
	public static void main(String[] args) throws Exception {
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		Connection connection = connectionFactory.newConnection();
		Channel channel = connection.createChannel();
		//声明交换器为Topic类型
		channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
		for(String logLevel : logLevels){
			for(String system : systems){
				TimeUnit.MILLISECONDS.sleep(100);
				String routingKey = system + "." + logLevel;
				String date = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS").format(new Date());
				String message = date + " " + routingKey + ": this is log message";
				System.out.println("Sent -> " + message);
				//发送消息
				channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
			}
		}
		channel.close();
		connection.close();
	}
}

输出结果如下：

Sent -> 2018-12-11T12:52:11.521 ORDER.INFO: this is log message
Sent -> 2018-12-11T12:52:11.623 PRODUCT.INFO: this is log message
Sent -> 2018-12-11T12:52:11.724 INVENTORY.INFO: this is log message
Sent -> 2018-12-11T12:52:11.825 ORDER.ERROR: this is log message
Sent -> 2018-12-11T12:52:11.926 PRODUCT.ERROR: this is log message
Sent -> 2018-12-11T12:52:12.027 INVENTORY.ERROR: this is log message

 商品系统INFO日志消费者 ProductInfoLogTopicConsumer

public class ProductInfoLogTopicConsumer {
	
	public static void main(String[] args) throws IOException, TimeoutException {
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		Connection connection = connectionFactory.newConnection();
		Channel channel = connection.createChannel();
		channel.exchangeDeclare(TopicProducer.EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
		// 创建一个随机队列
		String queueName = channel.queueDeclare().getQueue();
		// 此处绑定的KEY为PRODUCT.INFO
		channel.queueBind(queueName, TopicProducer.EXCHANGE_NAME, "PRODUCT.INFO");
		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("[" + envelope.getExchange() + "] [" + envelope.getRoutingKey()
						+ "] [" + envelope.getDeliveryTag() + "] : " + message);
			}
		};
		// 执行持续消费
		channel.basicConsume(queueName, true, consumer);
	}

输出结果如下：

[topic_log_exchange] [PRODUCT.INFO] [1] : 2018-12-11T13:00:50.316 PRODUCT.INFO: this is log message

从结果中可以看出只消费了商品系统中的INFO日志。

 所有系统ERROR日志消费者 SystemErrorLogTopicConsumer

public class SystemErrorLogTopicConsumer {
	public static void main(String[] args) throws IOException, TimeoutException {
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		Connection connection = connectionFactory.newConnection();
		Channel channel = connection.createChannel();
		channel.exchangeDeclare(TopicProducer.EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
		// 创建一个随机队列
		String queueName = channel.queueDeclare().getQueue();
		// 此处绑定的KEY为*.ERROR，可以设置为#.ERROR
		channel.queueBind(queueName, TopicProducer.EXCHANGE_NAME, "*.ERROR");
		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("[" + envelope.getExchange() + "] [" + envelope.getRoutingKey()
						+ "] [" + envelope.getDeliveryTag() + "] : " + message);
			}
		};
		// 执行持续消费
		channel.basicConsume(queueName, true, consumer);
	}
}

输出结果如下：

[topic_log_exchange] [ORDER.ERROR] [1] : 2018-12-11T12:52:11.825 ORDER.ERROR: this is log message
[topic_log_exchange] [PRODUCT.ERROR] [2] : 2018-12-11T12:52:11.926 PRODUCT.ERROR: this is log message
[topic_log_exchange] [INVENTORY.ERROR] [3] : 2018-12-11T12:52:12.027 INVENTORY.ERROR: this is log message

 从结果中可以看出消费了所有系统中的错误日志。

 

wyfvsfy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot+RabbitMq交换器Direct的demo
03-21
标题中的“springboot+RabbitMq交换器Direct的demo”指的是使用Spring Boot框架集成RabbitMQ，并通过Direct交换器实现消息的发送和接收。这是一个实际操作的示例，用于展示如何在Spring Boot应用中配置和使用...
RabbitMQ消息队列之fanout 多播模式
05-11
在RabbitMQ中，fanout类型交换器是最简单的，它工作原理类似于广播，将接收到的所有消息无条件地转发到与之绑定的所有队列。这种模式非常适合一对多的通信场景，例如发布/订阅模式，其中一个生产者发送消息，多个...
RabbitMq中交换器（Exchange）类型详解
技术人集结地
04-04 6969
RabbitMQ是工作中经常使用的一个开源消息队列，它是通过Erlang语言来开发的，RabbitMQ中有一个非常常见且重要的概念叫交换器（Exchange），所有生产者提交的消息都是通过Exchange进行接收，然后通过特定的路由策略转发对特定的队列（Queue）中，然后消费者通过绑定特定的队列，将队列中的信息进行消费处理。我们如果是通过RabbitMQ的客户端来进行创建Exchange的话，一定需要你选择一个特定的Exchange类型的，这个时候如果不了解每一种类型的特性，就很容易选择错误，造成整
RabbitMQ之交换器的三种模式
盛小伟的博客
05-29 2408
交换器(exchange)的最大作用一方面在于接收生产者的信息,另一方面在于发送消息到不同的队列,RabbitMQ中交换器被分为三类:fanout,topic,director 1.广播模式(fanout) 广播模式:生产的每一条消息,由所有消费者进行处理操作 图片参考自网络 消费者程序 生产者交换器核心代码 //信道绑定交换器 channel.exchangeDeclare(EXCH...
消息队列Rabbitmq的交换器类型
u011277123的博客
06-10 476
一、交换器类型 在rabbitmq中，生产者的消息都是通过交换器来接收，然后再从交换器分发到不同的队列中去，在分发的过程中交换器类型会影响分发的逻辑。 rabitmq中的交换器有4种类型，分别为fanout、direct、topic、headers四种，其中前三种较为常见，后面一种用的比较少。 二、fanout 一般情况下交换器分发会先找出绑定的队列，然后再判断routekey，来决定是否将消息分发到某一个队列中；但如果交换器的类型为fanout，那么交换器就不再判断rou...
rabbitmq交换器类型
zhaoyahui_666的博客
04-18 1882
fanout 它会把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中 direct 它会把消息路由到那些BingingKey 和RoutingKey完全匹配的队列中 topic 和direct类似，比其更灵活，支持通配符匹配
RabbitMQ的备份交换器
ITWANGBOIT的博客
04-21 229
什么时候需要备份交换器？ 备份对列中的消息什么时候取出来？
RabbitMQ入门（六）RabbitMQ交换器之fanout
jwang的博客
10-12 538
前言 本章讲解RabbitMQ常用交换器的最后一个类型——fanout 方法 1.概念 fanout（广播），顾名思义，其可以不依赖路由键，向所有绑定了的队列发送消息。 广播的含义就是将消息发送给所有订阅该频道的听众。 需求：我们的用户下订单之后，我们会做如下的两步操作：发短信、推送订单，在以前的模式上，我们下订单的业务逻辑和发短信，推送订单的逻辑是强耦合的，当我们使用Ra...
RabbitMQ交换器Exchange介绍
张姐姐聊编程
05-08 500
RabbitMQ里面的exchange（交换器）的知识
RabbitMQ 备份交换器使用
wsdfym的博客
09-30 337
生产者在发送消息时不设置mandatory 参数，那么消息达到路由器后匹配不到相应的队列后消息将会丢失。 设置了mandatory 参数，那么需要添加ReturnListener的编程逻辑。 如果既不想复杂化生产者的编程逻辑，又不想消息丢失，那么可以使用备份交换器。 顾名思义 备份交换器就是当第一个交换器未能有效匹配到队列时，路由到备份交换器，再由备份交换器区匹配队列 模型图 从模型图中可以看到...
【RabbitMQ】rabbitmq交换器topic类型
crainnogao的博客
04-25 480
生产者： package mq.topic; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import java.io.IOException; import java.util.UUID; i...
RabbitMQ交换器
寻常的博客
02-11 762
RabbitMQ交换器类型有fanout、direct、topic、headers fanout 它会把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中。 direct 类型的交换器路由规则也很简单，它会把消息路由到那些 BindingKey和RoutingKey完全匹配的队列中。 topic direct 类型的交换器路由规则是完全匹配 BindingKey和RoutingKey ,但是这种严格的匹配方式在很多情况下不能满足实际业务的需求. topic 类型的交换器在匹配规则上进行了扩展，.
rabbitmq基础+springboot集成rabbitmq
10-14
RabbitMQ预定义了几种交换器类型，如Direct（直接）、Fanout（广播）、Topic（主题）和Header（头）。 4. **队列**：队列是消息的容器，存储待处理的消息。消息被路由到队列后，等待消费者来处理。 **工作队列** ...
rabbitmq安装
02-21
RabbitMQ提供了多种类型的交换器，如Direct、Fanout、Topic和Header，每种交换器有其特定的路由策略。例如，Direct交换器根据路由键进行精确匹配，Fanout则将所有消息广播到所有绑定的队列，而Topic交换器支持模式...
RabbitMQ高级特性
04-05
常见的交换器类型有Direct、Fanout、Topic和Header，每种都有不同的分发策略。 - Direct交换器：基于精确匹配的路由键将消息发送到指定队列。 - Fanout交换器：广播模式，将所有消息分发到绑定的所有队列。 - ...
【创新未发表】Matlab实现黏菌优化算法SMA-Kmean-Transformer-LSTM负荷预测算法研究.rar
最新发布
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
PyTorch使用教程.pdf
07-29
PyTorch 是一个开源的机器学习库，广泛用于计算机视觉和自然语言处理等领域。以下是一个简化的 PyTorch 使用教程，不采用分点或Markdown格式。 首先，确保你安装了 PyTorch。你可以通过访问 PyTorch 官网获取安装指令，根据你的系统环境（如 Windows, macOS, Linux）和是否使用 GPU 支持进行安装。 安装完成后，你可以开始编写 PyTorch 代码了。 这里，我们将通过一个简单的例子来展示 PyTorch 的基本用法：创建一个简单的神经网络来识别手写数字（基于 MNIST 数据集）。
ubuntu man帮助手册
07-29
ubuntu man帮助手册
彩屏驱动开发技术资料提高篇TFT-51-11.zip
07-29
彩屏驱动开发技术资料提高篇TFT-51-11.zip
rabbitmq的交换器
09-02
RabbitMQ是一个开源的消息队列中间件，用于在应用...选择合适的交换器类型取决于你的应用程序的需求和消息传递的方式。你可以根据需要创建和配置交换器，并将其与队列进行绑定，确保消息能够正确地被分发到目标队列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值