RabbitMQ五种模式

最新推荐文章于 2021-05-06 19:27:08 发布
最新推荐文章于 2021-05-06 19:27:08 发布
阅读量632 收藏 1
点赞数
分类专栏： rabbitmq 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42325823/article/details/88574508
版权

1. 简单模式

在这里插入图片描述
说明:
P:生产者 C:消费者
工作的流程:

  1. 当生产者生产消息后,将消息发往队列.
  2. 当队列中有消息时,消费者会实时的监听队列中的消息.如果有消息则会执行消息

public class TestRabbitMQ_1_simple {

private Connection connection = null;

//定义公共连接
/**
 * 1.定义rabbmq地址 ip:端口
 * 2.定义虚拟主机
 * 3.定义用户名和密码
 * @throws IOException 
 */
@Before
public void init() throws IOException{
	ConnectionFactory connectionFactory = new ConnectionFactory();
	connectionFactory.setHost("192.168.126.146");
	connectionFactory.setPort(5672);
	connectionFactory.setVirtualHost("/jt");
	connectionFactory.setUsername("jtadmin");
	connectionFactory.setPassword("jtadmin");
	
	//获取链接
	connection = connectionFactory.newConnection();
}


//定义生产者
@Test
public void proverder() throws IOException{
	//定义通道Chneel接口
	Channel channel = connection.createChannel();
	
	//定义队列
	/**
	 * queue:队列名称
	 * durable:是否持久化  true 和false
	 * exclusive: 如果为true 表示为生产者独有
	 * autoDelete:当消息消费完成后是否自动删除
	 * arguments:是否传递参数 一般为空
	 */
	channel.queueDeclare("queue_1", false, false, false, null);
	
	//定义发送的消息
	String msg = "我是单工模式";
	
	
	//发送消息
	/**
	 * exchange:交换机名称   如果没有交换机 添加""串
	 * routingKey:路由KEy 信息标识符,没有添加队列名称
	 * props 携带的参数
	 * body.传递信息的字节码文件
	 */
	channel.basicPublish("", "queue_1",null, msg.getBytes());
	
	channel.close();
	connection.close();
}

//定义消费者
@Test
public void consumer() throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
	//获取通道
	Channel channel = connection.createChannel();
	//定义队列
	channel.queueDeclare("queue_1", false, false, false, null);
	//定义消费者对象
	QueueingConsumer consumer = new QueueingConsumer(channel);
	//将消费者与队列绑定
	channel.basicConsume("queue_1", true, consumer);
	//循环获取信息
	while(true){
		QueueingConsumer.Delivery delivery = consumer.nextDelivery();
		
		String msg = new String(delivery.getBody());
		
		System.out.println("获取信息:"+msg);	
	}
	
}

2.工作模式

在这里插入图片描述
说明:
当生产者生产消息时,将消息写入队列中,多个消费者争抢执行,并且实现轮询执行方式.
业务场景:
抢红包的机制/秒杀业务

 public class TestRabbitMQ_2_work {

//工作模式:多个人一起消费一个队列消息.内部轮询机制


/**
 * 1.定义rabbmq地址 ip:端口
 * 2.定义虚拟主机
 * 3.定义用户名和密码
 * @throws IOException 
 */
private Connection connection = null;
@Before
public void init() throws IOException{
	ConnectionFactory connectionFactory = new ConnectionFactory();
	connectionFactory.setHost("192.168.126.146");
	connectionFactory.setPort(5672);
	connectionFactory.setVirtualHost("/jt");
	connectionFactory.setUsername("jtadmin");
	connectionFactory.setPassword("jtadmin");
	
	//获取链接
	connection = connectionFactory.newConnection();
}

@Test
public void provider() throws IOException{
	//定义通道对象
	Channel channel = connection.createChannel();
	
	//定义队列
	channel.queueDeclare("queue_work", false, false, false, null);
	
	//定义广播的消息
	String msg = "我是工作模式";
	
	//发送消息
	channel.basicPublish("", "queue_work", null, msg.getBytes());
	
	//关闭流文件
	channel.close();
	connection.close();
}


//定义消费者
@Test
public void consumer1() throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
	//定义通道
	Channel channel = connection.createChannel();
	
	//定义队列
	channel.queueDeclare("queue_work", false, false, false, null);
	
	//定义消费数  每次只能消费一条记录.当消息执行后需要返回ack确认消息 才能执行下一条
	channel.basicQos(1);
	
	//定义消费者
	QueueingConsumer consumer = new QueueingConsumer(channel);
	
	//将队列和消费者绑定  false表示手动返回ack
	channel.basicConsume("queue_work", false, consumer);
	
	while(true){
		QueueingConsumer.Delivery delivery = consumer.nextDelivery();
		String msg = new String(delivery.getBody());
		System.out.println("队列A获取消息:"+msg);
		//deliveryTag 队列下标位置
		//multiple是否批量返回
		channel.basicAck(delivery.getEnvelope().getDeliveryTag(), true);
	}
}


//定义消费者
	@Test
	public void consumer2() throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
		//定义通道
		Channel channel = connection.createChannel();
		
		//定义队列
		channel.queueDeclare("queue_work", false, false, false, null);
		
		//定义消费数  每次只能消费一条记录.当消息执行后需要返回ack确认消息 才能执行下一条
		channel.basicQos(1);
		
		//定义消费者
		QueueingConsumer consumer = new QueueingConsumer(channel);
		
		//将队列和消费者绑定  false表示手动返回ack
		channel.basicConsume("queue_work", false, consumer);
		
		while(true){
			QueueingConsumer.Delivery delivery = consumer.nextDelivery();
			String msg = new String(delivery.getBody());
			System.out.println("队列B获取消息:"+msg);
			//deliveryTag 队列下标位置
			//multiple是否批量返回
			channel.basicAck(delivery.getEnvelope().getDeliveryTag(), true);
		}
	}


	//定义消费者
			@Test
			public void consumer3() throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
				//定义通道
				Channel channel = connection.createChannel();
				
				//定义队列
				channel.queueDeclare("queue_work", false, false, false, null);
				
				//定义消费数  每次只能消费一条记录.当消息执行后需要返回ack确认消息 才能执行下一条
				channel.basicQos(1);
				
				//定义消费者
				QueueingConsumer consumer = new QueueingConsumer(channel);
				
				//将队列和消费者绑定  false表示手动返回ack
				channel.basicConsume("queue_work", false, consumer);
				
				while(true){
					QueueingConsumer.Delivery delivery = consumer.nextDelivery();
					String msg = new String(delivery.getBody());
					System.out.println("队列C获取消息:"+msg);
					//deliveryTag 队列下标位置
					//multiple是否批量返回
					channel.basicAck(delivery.getEnvelope().getDeliveryTag(), true);
				}
			}
}

3.发布订阅模式

在这里插入图片描述
说明:
P:生产者
C:消费者
X:交换机
模式:
当采用了发布订阅模式时,当生产者发布了消息,经过交换机发往不同的队列.
这时不同的队列中有相同的消息.一个消息被执行多次
使用场景: 群发 微信公众号订阅

public class TestRabbitMQ_3_publish {

 //发布订阅模式
  private Connection connection = null;

//定义rabbit连接池
@Before
public void initConnection() throws IOException{
	//定义工厂对象
	ConnectionFactory connectionFactory = new ConnectionFactory();
	//设定参数
	connectionFactory.setHost("192.168.126.146");
	connectionFactory.setPort(5672);
	connectionFactory.setVirtualHost("/jt");
	connectionFactory.setUsername("jtadmin");
	connectionFactory.setPassword("jtadmin");
	
	//创建连接
	connection = connectionFactory.newConnection();	
}



//定义生产者
@Test
public void  proverder() throws IOException{
	//定义通道
	Channel channel = connection.createChannel();
	
	//定义交换机名称
	String exchange_name = "E1";
	
	
	//定义发布订阅模式    fanout    redirect 路由模式    topic 主题模式
	channel.exchangeDeclare(exchange_name, "fanout");
	
	for(int i=0;i<10; i++){
		String msg = "发布订阅模式"+i;
		channel.basicPublish(exchange_name, "", null, msg.getBytes());
	}
	
	channel.close();
	connection.close();
}


/**
 * 消费者需要定义队列名称  并且与交换机绑定
 * @throws IOException
 * @throws InterruptedException 
 * @throws ConsumerCancelledException 
 * @throws ShutdownSignalException 
 */
@Test
public void consumer1() throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
	Channel channel = connection.createChannel();
	
	String exchange_name = "E1";
	String queue_name = "c_1";
	
	//定义交换机模式
	channel.exchangeDeclare(exchange_name, "fanout");
	
	//定义队列
	channel.queueDeclare(queue_name, false, false, false, null);
	
	//将队列和交换机绑定
	channel.queueBind(queue_name, exchange_name, "");
	
	//定义消费数量 
	channel.basicQos(1);
	
	//定义消费者
	QueueingConsumer consumer = new QueueingConsumer(channel);
	
	//将消费者和队列绑定,并且需要手动返回
	channel.basicConsume(queue_name, false, consumer);
	
	while(true){
		QueueingConsumer.Delivery delivery = consumer.nextDelivery();
		
		String msg = "发布订阅模式-消费者1"+new String(delivery.getBody());
		System.out.println(msg);
		
		//false表示一个一个返回
		channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
	}
}


/**
 * 消费者需要定义队列名称  并且与交换机绑定
 * @throws IOException
 * @throws InterruptedException 
 * @throws ConsumerCancelledException 
 * @throws ShutdownSignalException 
 */
@Test
public void consumer2() throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
	Channel channel = connection.createChannel();
	
	String exchange_name = "E1";
	String queue_name = "c_2";
	
	//定义交换机模式
	channel.exchangeDeclare(exchange_name, "fanout");
	
	//定义队列
	channel.queueDeclare(queue_name, false, false, false, null);
	
	//将队列和交换机绑定
	channel.queueBind(queue_name, exchange_name, "");
	
	channel.basicQos(1);
	
	//定义消费者
	QueueingConsumer consumer = new QueueingConsumer(channel);
	
	//定义回复方式
	channel.basicConsume(queue_name, false, consumer);
	
	while(true){
		QueueingConsumer.Delivery delivery = consumer.nextDelivery();
		
		String msg = "发布订阅模式-消费者2"+new String(delivery.getBody());
		System.out.println(msg);
		
		channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
	}

}

}

路由模式

在这里插入图片描述
说明:路由模式是发布订阅模式的升级版.根据不同的路由key实现消息的发送.
作用:
可以根据功能模块的业务不同,发往不同的队列中.

代码:
public class TestRabbitMQ_4_redirect {
//发布订阅模式
private Connection connection = null;

//定义rabbit连接池
@Before
public void initConnection() throws IOException{
	//定义工厂对象
	ConnectionFactory connectionFactory = new ConnectionFactory();
	//设定参数
	connectionFactory.setHost("192.168.126.146");
	connectionFactory.setPort(5672);
	connectionFactory.setVirtualHost("/jt");
	connectionFactory.setUsername("jtadmin");
	connectionFactory.setPassword("jtadmin");
	//创建连接
	connection = connectionFactory.newConnection();	
}



//定义生产者
@Test
public void  proverder() throws IOException{
	Channel channel = connection.createChannel();
	
	//定义交换机名称
	String exchange_name = "redirect";
	
	
	//定义发布订阅模式    fanout    direct 路由模式    topic 主题模式
	channel.exchangeDeclare(exchange_name, "direct");
	
	for(int i=0;i<10; i++){
		String msg = "生产者发送消息"+i;
		String rontKey = "1707B";
		
		/**
		 * exchange:交换机名称
		 * routingKey:路由key
		 * props:参数
		 * body:发送消息
		 */
		channel.basicPublish(exchange_name, rontKey, null, msg.getBytes());
	}
	
	channel.close();
	connection.close();
}

/**
 * 消费者需要定义队列名称  并且与交换机绑定
 * @throws IOException
 * @throws InterruptedException 
 * @throws ConsumerCancelledException 
 * @throws ShutdownSignalException 
 */
@Test
public void consumer1() throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
	
	//定义通道
	Channel channel = connection.createChannel();
	
	//定义交换机名称
	String exchange_name = "redirect";
	
	//定义队列名称
	String queue_name = "c_r_1";
	
	//定义交换机模式
	channel.exchangeDeclare(exchange_name, "direct");
	
	//定义队列
	channel.queueDeclare(queue_name, false, false, false, null);
	
	//将队列和交换机绑定
	/**
	 * 参数介绍:
	 * 	queue:队列名称
	 *  exchange:交换机名称
	 *  routingKey:路由key
	 */
	//channel.queueBind(queue, exchange, routingKey)
	channel.queueBind(queue_name, exchange_name, "1707A");
	
	//定义消费个数
	channel.basicQos(1);
	
	//定义消费者
	QueueingConsumer consumer = new QueueingConsumer(channel);
	
	//绑定消息与消费者
	channel.basicConsume(queue_name, false, consumer);
	
	while(true){
		QueueingConsumer.Delivery delivery = consumer.nextDelivery();
		
		String msg = "路由模式-消费者1"+new String(delivery.getBody());
		System.out.println(msg);
		
		//手动回复 一个一个回复
		channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
	}

}


/**
 * 消费者需要定义队列名称  并且与交换机绑定
 * @throws IOException
 * @throws InterruptedException 
 * @throws ConsumerCancelledException 
 * @throws ShutdownSignalException 
 */
@Test
public void consumer2() throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
	Channel channel = connection.createChannel();
	
	String exchange_name = "redirect";
	String queue_name = "c_r_2";
	
	//定义交换机模式
	channel.exchangeDeclare(exchange_name, "direct");
	
	//定义队列
	channel.queueDeclare(queue_name, false, false, false, null);
	
	//将队列和交换机绑定
	channel.queueBind(queue_name, exchange_name, "1707B");
	
	channel.basicQos(1);
	
	//定义消费者
	QueueingConsumer consumer = new QueueingConsumer(channel);
	
	//定义回复方式
	channel.basicConsume(queue_name, false, consumer);
	
	while(true){
		QueueingConsumer.Delivery delivery = consumer.nextDelivery();
		
		String msg = "路由模式-消费者2"+new String(delivery.getBody());
		System.out.println(msg);
		
		channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
	}
}

}

主题模式

在这里插入图片描述
说明:
主题模式是路由模式的升级版,只要满足条件的路由key,都可以接收消息.
通配符的格式:
号:匹配一个或一组字符(以.分割)
#号.能够匹配任意的字符.
例子:
Item.update.aabb item.# 可以匹配
Item.update item.# item. 都可以匹配
代码:
//主题模式
public class TestRabbitMQ_5_topic {

private Connection connection = null;

@Before
public void initConnection() throws IOException{
	//1.定义ConnectionFactory对象
	ConnectionFactory connectionFactory = new ConnectionFactory();
	connectionFactory.setHost("192.168.126.146");
	connectionFactory.setPort(5672);
	connectionFactory.setVirtualHost("/jt");
	connectionFactory.setUsername("jtadmin");
	connectionFactory.setPassword("jtadmin");	
	//获取连接
	connection = connectionFactory.newConnection();	
}

//定义生产者
@Test
public void proverder() throws Exception{
	//获取通道
	Channel channel = connection.createChannel();
	
	//定义交换机的名称
	String exchange_name = "TOP";
	
	//创建交换机队列   
	//exchange  交换机名称
	//type 定义类型 fanout 发布订阅模式   direct-路由模式    topic-主题模式
	channel.exchangeDeclare(exchange_name, "topic");  //主题模式
	
	for (int i = 0; i < 100; i++) {
		
		String msg = "主题模式"+i;
		
		/**
		 * 参数说明:
		 * 	exchange:交换机名称
		 *  routingKey:路由key
		 *  props:参数
		 *  body:数据字节码
		 */
		//channel.basicPublish(exchange, routingKey, props, body);
		channel.basicPublish(exchange_name,"item.update", null, msg.getBytes());
	}
	channel.close();
	connection.close();
}

@Test
public  void consumer1() throws Exception{
	
	//定义通道
	Channel channel = connection.createChannel();
	
	//定义交换机名称
	String exchange_name = "TOP";
	
	//定义队列名称
	String queue_name = "TOP1";
	
	//声明交换机名称以及主题模式
	channel.exchangeDeclare(exchange_name, "topic");
	
	//定义队列
	channel.queueDeclare(queue_name, false, false, false, null);
	
	//将交换机和队列进行绑定   
	//参数1.队列名称     参数2交换机名称   参数3 路由key  #号匹配多个字符
	channel.queueBind(queue_name, exchange_name, "item.#");
	
	channel.basicQos(1);  //定义消费数量  1
	
	//定义消费者
	QueueingConsumer consumer = new QueueingConsumer(channel);
	
	//将队列和消费者绑定
	channel.basicConsume(queue_name, false, consumer);  //定义手动回复
	
	while(true){
		QueueingConsumer.Delivery delivery = consumer.nextDelivery();
		//获取消息队列中的数据
		String msg = new String(delivery.getBody());
		System.out.println("item.#消费者1:"+msg);
		
		//手动回复
		channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);	
	}
}


@Test
public  void consumer2() throws Exception{
	Channel channel = connection.createChannel();
	String exchange_name = "TOP";
	String queue_name = "TOP2";
	//生命交换机模式
	channel.exchangeDeclare(exchange_name, "topic");
	//定义队列
	channel.queueDeclare(queue_name, false, false, false, null);
	//将交换机和队列进行绑定   
	//参数1.队列名称     参数2交换机名称     参数3定义路由key
	channel.queueBind(queue_name, exchange_name, "item.*");
	
	channel.basicQos(1);  //定义消费数量  1
	
	//定义消费者
	QueueingConsumer consumer = new QueueingConsumer(channel);
	channel.basicConsume(queue_name, false, consumer);  //定义手动回复
	
	while(true){
		QueueingConsumer.Delivery delivery = consumer.nextDelivery();
		//获取消息队列中的数据
		String msg = new String(delivery.getBody());
		System.out.println("item.*消费者2:"+msg);
		//定义回执
		channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);	
	}
}

}

无中生友
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ五大模式轻松理解
风影浪子
06-13 7256
简要概括RabbitMQ工作模式：1、简单模式 HelloWorld 2、工作队列模式 Work Queue 3、发布订阅模式 Publish/subscribe 4、路由模式 Routing 5、通配符模式 Topic
【青龙面板Ck工具】RabbitPro—快捷扫码或短信获取ck
最新发布
weixin_42565036的博客
02-27 1288
打开FinalShell，进入/etc/docker，创建一个daemon.json文件，内容如下,然后重启Docker。（无错误可忽略）如果重启Docker失败，如下图情况，将daemon.json，改成daemon.conf重启即可。等待安装，安装完成后到浏览器打开 ip:5702/admin 账号和密码都是admin。保存好你的Token。应用ID和秘钥，到青龙里面创建一个，权限全选就行。按照页面要求，把Token写上，其他的随便写，登录人数和回收时间按我的就行。然后到容器管理页面，添加容器。
RabbitMQ的五种模式
weixin_39389888的博客
07-10 778
首先先了解RabbitMQ是什么： 　　RabbitMQ是消息中间件的一种,消息中间件即分布式系统中完成消息的发送和接收的基础软件.这些软件有很多,包括ActiveMQ(apache公司的),RocketMQ(阿里巴巴公司的,现已经转让给apache). 　　消息中间件的工作过程可以用生产者消费者模型来表示.即,生产者不断的向消息队列发送信息,而消费者从消息队列中消费信息.具体过程如下: ...
rabbitmq五种模式
weixin_49307896的博客
12-21 7337
rabbitmq五种模式 1.简单模式 2.争抢模式（工作模式，工作争抢模式） 3.路由模式 route 4.发布订阅模式 fanout 5.主题模式 topic 6. RPC异步调用模式（不常用） 1.简单模式 当生产端发送消息到交换机,交换机根据消息属性发送到队列,消费者监听绑定队列实现消息的接收和消费逻辑编写.简单模式下,强调的一个队列queue只被一个消费者监听消费. 1.1 结构 生产者：生成消息,发送到交换机 交换机：根据消息属性,将消息发送给队列 消费者：监听这个队列,发现消息后,
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
基于RabbitMQ几种Exchange 模式详解
08-28
下面小编就为大家带来一篇基于RabbitMQ几种Exchange 模式详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
rabbitmq常用三种模式的配置
03-16
rabbitmq包含多种模式，主要是fanout，direct，topic，本代码主要针对这三种模式进行相关的配置，配置文件单独放置在不同的文件夹里，以便学习。
springboot+RabbitMQ三种模式demo
07-03
springboot+RabbitMQ的direct，topic，fanout三种模式demo
RabbitMQ 5种工作模式
guohewei123的博客
03-02 741
1. Simple模式 最简单常用的模式
RabbitMQ的五种模式源码+纯手工打的代码
03-12
RabbitMQ的五种模式源码+纯手工打的代码
RabbitMQ的五种工作模式
weixin_51683936的博客
05-06 223
RabbitMQ的五种工作模式 RabbitMQ的作用 1、服务解藕：降低服务之间耦合度 2、流量削峰：当高峰情况下，出现大量的请求时，将请求发送到消息队列服务器上，排队等待被处理 3、异步调用：将数据发送到消息队列服务器中，系统可以得到立即响应，整条链路的响应时间只有200毫秒左右 一：简单模式（点对点模式） 原理：生产者将消息交给默认的交换机，交换机获取消息后交给绑定这个生产者的队列（投递规则为队列名称和routing key 相同的队列），监听当前队列的消费者获取信息并执行消费逻辑。 使用场景：用户通
RabbitMQ五种工作模式
学习交流，答疑解惑，可以查看博客主页左侧我的推广哦！
10-26 2518
1.简介 最近，在看一些消息中间件的内容，之前都没有好好学习一下消息中间件。本文将对RabbitMQ中五种常用的工作模式做一个简单的介绍和总结。RabbitMQ常用的工作模式有：简单队列模式、工作队列模式、发布订阅模式、路由模式、主题模式。本文参照RabbitMQ官网示例总结，详细可以到官网查看：https://www.rabbitmq.com/getstarted.html。 2.简单队列模式（...
Rabbitmq的五种模式和案例
热门推荐
KHOST的博客
04-28 1万+
 消息生产者p将消息放入队列消费者监听队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列删除(隐患,消息可能没有被消费者正确处理,已经消失了,无法恢复)应用场景:聊天室 案例：1&gt;.首先准备依赖&lt;dependency&gt;       &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;       &lt;artif...
（一）rabbitMQ 5种模式与实例
小码哥222的博客
11-27 349
众所周知，RabbitMq的交换机和队列的绑定方式有3种 Fanout Exchange– 不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。 Direct Exchange– 处理路由键。需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键 “dog”，则只有被标记为“dog
rabbitmq的五种工作模式
06-09
RabbitMQ支持以下五种工作模式： 1. 简单模式（Simple Mode）：一个生产者向一个队列发送消息，一个消费者从队列中接收消息。 2. 工作模式（Work Mode）：一个生产者向一个队列发送消息，多个消费者从队列中接收...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值