RabbitMQ的五种队列模式与实例

置顶 已于 2022-10-12 22:21:55 修改
阅读量677 收藏 1
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq 分布式 java
于 2022-01-17 17:04:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39519454/article/details/122504421
版权

3.1 简单模式Hello World

简单模式Hello World

功能：一个生产者P发送消息到队列Q,一个消费者C接收

生产者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel向队列中发送消息，关闭通道和连接。

生产者实现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——简单模式
*/
import org.junit.Test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Test_1_simple_provider {
@Test
public void  provider()throws Exception {
//1,建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
Connection connection = factory.newConnection();
//2.建立通道
Channel channel = connection.createChannel();
//3.定义队列
//durable true 持久化,重启服务器后，数据还有
//exclusive true,只能通过当前连接消费 false
//autoDelete true 队列中消息处理完后，自动删除队列
//arguments 参数
channel.queueDeclare("order",true,false,false,null);
//4,发送消息，routingKey必须与queue一致
String msg ="msg1";
channel.basicPublish("", "order", null, msg.getBytes());
//5.关闭
channel.close();
connection.close();
System.out.println("发送数据成功");
}
}

消费者实现思路

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue, 创建消费者并监听队列，从队列中读取消息。

消费者实现思路
 

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——简单模式
*/
import org.junit.Test;
import  com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_1_simole_consumer {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new  ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection =  factory.newConnection();
//2,创建通道
Channel channel =  connection.createChannel();
//3.声明队列
channel.queueDeclare("order",true,false,false,null);
//4.创建（排队的消费者）
QueueingConsumer consumer = new  QueueingConsumer(channel);
//1，p2:autoack 消费者取到消息, 自动确认,确认后,服务器会把消息
//2,从消息队列服务器上取order队列的数据
//3,自动确认,服务器就删除消息3,把得到消息交给第三个参数consumer处理
//basicConsume：基本消费者
channel.basicConsume("order",  true,consumer);
//5.取消息
ring);
}
}
while(true) {
//Delivery：交付
Delivery delivery =  consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者读取到："+mSt
}

3.2 工作队列模式Work Queue

工作队列模式Work Queue

功能：一个生产者，多个消费者，每个消费者获取到的消息唯一，多个消费者只有一个队列

任务队列：避免立即做一个资源密集型任务，必须等待它完成，而是把这个任务安排到稍后再做。我们将任务封装为消息并将其发送给队列。后台运行的工作进程将弹出任务并最终执行作业。当有多个worker同时运行时，任务将在它们之间共享。

生产者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel向队列中发送消息，2条消息之间间隔一定时间，关闭通道和连接。

生产者实现思路

package com.jt.rabbitmq;
import org.junit.Test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
* RabbitMQ的五种队列模式——工作队列模式——生产者
*/
public class Test_2_work_provider {
@Test
public void  provider()throws Exception {
//1,建立连接
ConnectionFactory factory = new  ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
Connection connection =  factory.newConnection();
//2.建立通道
Channel channel =  connection.createChannel();
//定义交换机
String exchangName = "E1";
//fanout:订阅模式
//direct:路由模式
//topic :主题模式
channel.exchangeDeclare(exchangName,  "fanout");
//3.定义队列
//channel.queueDeclare("order",true,false,false,null);
//4,发送消息，routingKey必须与queue一致
String msg ="msg1";
channel.basicPublish(exchangName,  "order", null, msg.getBytes());
//5.关闭
channel.close();
connection.close();
System.out.println("发送数据成功");
}
}

消费者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，创建消费者C1并监听队列，获取消息并暂停10ms，另外一个消费者C2暂停1000ms，由于消费者C1消费速度快，所以C1可以执行更多的任务。

消费者实1现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——工作队列模式——消费者1
*/
import org.junit.Test;
import  com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_2_work_consumer1 {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new  ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection =  factory.newConnection();
//2,创建通道
Channel channel =  connection.createChannel();
//3.声明队列
channel.queueDeclare("order",true,false,false,null);
//4.创建（排队的消费者）
QueueingConsumer consumer = new  QueueingConsumer(channel);
//1，p2:autoack 消费者取到消息, 自动确认,确认后,服务器会把消息
//2,从消息队列服务器上取order队列的数据
//3,自动确认,服务器就删除消息3,把得到消息交给第三个参数consumer处理
//basicConsume：基本消费者
channel.basicConsume("order",  true,consumer);
System.out.println("消费者1已启动");
//5.取消息
while(true) {
//Delivery：交付
Delivery delivery =  consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者1读取到："+mString);
}
}
}

消费者实2现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——工作队列模式——消费者2
*/
import org.junit.Test;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_2_work_consumer2 {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection = factory.newConnection();
//2,创建通道
Channel channel = connection.createChannel();
//3.声明队列
channel.queueDeclare("order",true,false,false,null);
//4.创建（排队的消费者）
QueueingConsumer consumer = new QueueingConsumer(channel);
//1，p2:autoack 消费者取到消息, 自动确认,确认后,服务器会把消息
//2,从消息队列服务器上取order队列的数据
//3,自动确认,服务器就删除消息3,把得到消息交给第三个参数consumer处理
//basicConsume：基本消费者
channel.basicConsume("order", true,consumer);
System.out.println("消费者2已启动");
//5.取消息
while(true) {
//Delivery：交付
Delivery delivery = consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者2读取到："+mString);
}
}
}

3.3发布/订阅模式 Publish/Subscribe

发布/订阅模式 Publish/Subscribe

功能：一个生产者发送的消息会被多个消费者获取。一个生产者、一个交换机、多个队列、多个消费者

生产者：可以将消息发送到队列或者是交换机。

消费者：只能从队列中获取消息。

如果消息发送到没有队列绑定的交换机上，那么消息将丢失。

交换机不能存储消息，消息存储在队列中

生产者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel创建交换机并指定交换机类型为fanout，使用通道向交换机发送消息，关闭通道和连接。

生产者实现思路

package com.jt.rabbitmq;
import org.junit.Test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
* RabbitMQ的五种队列模式——订阅模式——生产者
* @author Administrator
*
*/
public class Test_3_publish_provider {
@Test
public void  provider()throws Exception {
//1,建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
Connection connection = factory.newConnection();
//2.建立通道
Channel channel = connection.createChannel();
//3.定义交换机名称
String exchange_name="E1";
//4.fanout是定义发布订阅模式  direct是 路由模式 topic是主题模式
channel.exchangeDeclare(exchange_name, "fanout");
//4,发送消息，routingKey必须与queue一致
String msg ="msg1";
channel.basicPublish(exchange_name, "", null, msg.getBytes());
//5.关闭
channel.close();
connection.close();
}
}

消费者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，绑定队列到交换机，设置Qos=1，创建消费者并监听队列，使用手动方式返回完成。可以有多个队列绑定到交换机，多个消费者进行监听。

消费者1实现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——订阅模式——消费者1
*/
import java.util.UUID;
import org.junit.Test;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_3_publish_consumer1 {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection = factory.newConnection();
//2,创建通道
Channel channel = connection.createChannel();
//3定义交换机模式
String exchange_name="E1";
channel.exchangeDeclare(exchange_name, "fanout");
String queue_name = UUID.randomUUID().toString();
//4.声明队列
channel.queueDeclare(queue_name,true,false,false,null);
//5将队列和交换机绑定   key:表示接收数据标识
channel.queueBind(queue_name, exchange_name, "");
//6.定义消费数量
channel.basicQos(1);
//7.创建（排队的消费者）
QueueingConsumer consumer = new QueueingConsumer(channel);
//8.将消费者和队列绑定,并且需要手动返回
channel.basicConsume(queue_name, false,consumer);
System.out.println("消费者1已启动");
//9.取消息
while(true) {
//Delivery：交付
Delivery delivery = consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者1"+mString+"收到");
//false表示一个个返回值
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}

消费者2实现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——订阅模式——消费者2
*
* publish：出版
*/
import java.util.UUID;
import org.junit.Test;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_3_publish_consumer2 {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection = factory.newConnection();
//2,创建通道
Channel channel = connection.createChannel();
//3定义交换机模式
String exchange_name="E1";
channel.exchangeDeclare(exchange_name, "fanout");
String queue_name = UUID.randomUUID().toString();
//4.声明队列
channel.queueDeclare(queue_name,true,false,false,null);
//5将队列和交换机绑定   key:表示接收数据标识
channel.queueBind(queue_name, exchange_name, "");
//6.定义消费数量
channel.basicQos(1);
//7.创建（排队的消费者）
QueueingConsumer consumer = new QueueingConsumer(channel);
//8.将消费者和队列绑定,并且需要手动返回
channel.basicConsume(queue_name, false,consumer);
System.out.println("消费者2已启动");
//9.取消息
while(true) {
//Delivery：交付
Delivery delivery = consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者2"+mString+"收到");
//false表示一个个返回值
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}

3.4路由模式Routing

路由模式Routing

说明：生产者发送消息到交换机并且要指定路由key，消费者将队列绑定到交换机时需要指定路由key

生产者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel创建交换机并指定交换机类型为direct，使用通道向交换机发送消息并指定key=b，关闭通道和连接。

生产者实现思路

package com.jt.rabbitmq;
import org.junit.Test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
* RabbitMQ的五种队列模式——路由模式——生产者
*
* 使用通道向交换机发送消息并指定key="agent",
* 那么消费者将队列和交换机绑定标识符为key="agent"才能接受到消息
* @author Administrator
*
*/
public class Test_4_direct_provider {
@Test
public void  provider()throws Exception {
//1,建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
Connection connection = factory.newConnection();
//2.建立通道
Channel channel = connection.createChannel();
//3.定义交换机名称
String exchange_name="E2";
//4.fanout是定义发布订阅模式  direct是 路由模式 topic是主题模式
channel.exchangeDeclare(exchange_name, "direct");
//4,使用通道向交换机发送消息并指定key="agent"
String msg ="msg1";
channel.basicPublish(exchange_name, "agent", null, msg.getBytes());
//5.关闭
channel.close();
connection.close();
}
}

消费者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，绑定队列到交换机，设置Qos=1，创建消费者并监听队列，使用手动方式返回完成。可以有多个队列绑定到交换机,但只要绑定key=b的队列key接收到消息，多个消费者进行监听。

消费者1实现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——路由模式——消费者1
*/
import java.util.UUID;
import org.junit.Test;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_4_direct_consumer1 {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection = factory.newConnection();
//2,创建通道
Channel channel = connection.createChannel();
//3定义交换机模式
String exchange_name="E2";
channel.exchangeDeclare(exchange_name, "direct");
//4.声明队列
String queue_name = UUID.randomUUID().toString();
channel.queueDeclare(queue_name,true,false,false,null);
//5将队列和交换机绑定   key:表示接收数据标识
channel.queueBind(queue_name, exchange_name, "agent");
//6.同一时刻服务器只会发一条消息給消費者
channel.basicQos(1);
//7.定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
//8.监听队列,手动返回完成
channel.basicConsume(queue_name, false,consumer);
System.out.println("消费者1已启动");
//9.取消息
while(true) {
//Delivery：交付
Delivery delivery = consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者1"+mString+"海外代购");
//false表示一个个返回值
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}

消费者2实现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——路由模式——消费者2
*/
import java.util.UUID;
import org.junit.Test;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_4_direct_consumer2 {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection = factory.newConnection();
//2,创建通道
Channel channel = connection.createChannel();
//3定义交换机模式
String exchange_name="E2";
channel.exchangeDeclare(exchange_name, "direct");
String queue_name = UUID.randomUUID().toString();
//4.声明队列
channel.queueDeclare(queue_name,true,false,false,null);
//5将队列和交换机绑定   key:表示接收数据标识
channel.queueBind(queue_name, exchange_name, "domestic");
//6.定义消费数量
channel.basicQos(1);
//7.创建（排队的消费者）
QueueingConsumer consumer = new QueueingConsumer(channel);
//8.将消费者和队列绑定,并且需要手动返回
channel.basicConsume(queue_name, false,consumer);
System.out.println("消费者2已启动");
//9.取消息
while(true) {
//Delivery：交付
Delivery delivery = consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者2"+mString+"国内购");
//false表示一个个返回值
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}

3.5通配符模式Topic

通配符模式Topic

说明：生产者P发送消息到交换机X，type=topic，交换机根据绑定队列的routing key的值进行通配符匹配；

符号#：匹配一个或者多个词 lazy.# 可以匹配 lazy.irs或者lazy.irs.cor

符号*：只能匹配一个词 lazy.* 可以匹配 lazy.irs或者lazy.cor

生产者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel创建交换机并指定交换机类型为topic，使用通道向交换机发送消息并指定key=key.1，关闭通道和连接。

生产者实现思路

package com.jt.rabbitmq;
import org.junit.Test;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
* RabbitMQ的五种队列模式——通配符模式——生产者
* @author Administrator
* 说明：生产者P发送消息到交换机X，type=topic，交换机根据绑定队列的routing key的值进行通配符匹配；
* 符号#：匹配一个或者多个词 lazy.# 可以匹配 lazy.irs或者lazy.irs.cor
* 符号*：只能匹配一个词 lazy.* 可以匹配 lazy.irs或者lazy.cor
*
*/
public class Test_5_topic_provider {
@Test
public void  provider()throws Exception {
//1,建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
Connection connection = factory.newConnection();
//2.建立通道
Channel channel = connection.createChannel();
//3.定义交换机名称
String exchange_name="E3";
//4.fanout是定义发布订阅模式  direct是 路由模式 topic是主题模式
channel.exchangeDeclare(exchange_name, "topic");
//4,使用通道向交换机发送消息并指定key="agent"
String msg ="msg1";
channel.basicPublish(exchange_name, "agent.order", null, msg.getBytes());
//5.关闭
channel.close();
connection.close();
}
}

消费者实现思路：

创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，绑定队列到交换机，设置Qos=1，创建消费者并监听队列，使用手动方式返回完成。可以有多个队列绑定到交换机,凡是绑定规则符合通配符规则的队列均可以接收到消息，比如key.*,key.#，多个消费者进行监听。

消费者1实现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——通配符模式——消费者1
*/
import java.util.UUID;
import org.junit.Test;
import  com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_5_topic_consumer1 {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new  ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection =  factory.newConnection();
//2,创建通道
Channel channel =  connection.createChannel();
//3定义交换机模式
String exchange_name="E3";
channel.exchangeDeclare(exchange_name,  "topic");
//4.声明队列
String queue_name =  UUID.randomUUID().toString();
channel.queueDeclare(queue_name,true,false,false,null);
//5将队列和交换机绑定   key:表示接收数据标识
channel.queueBind(queue_name,  exchange_name, "agent.*");
//6.同一时刻服务器只会发一条消息給消費者
channel.basicQos(1);
//7.定义队列的消费者
QueueingConsumer consumer = new  QueueingConsumer(channel);
//8.监听队列,手动返回完成
channel.basicConsume(queue_name,  false,consumer);
System.out.println("消费者1已启动");
//9.取消息
while(true) {
//Delivery：交付
Delivery delivery =  consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者1"+mString+"海外代购");
//false表示一个个返回值
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}

消费者2实现思路

package com.jt.rabbitmq;
/**
* RabbitMQ的五种队列模式——通配符模式——消费者1
*/
import java.util.UUID;
import org.junit.Test;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
public class Test_5_topic_consumer2 {
@Test
public void sonsumer() throws  Exception{
//1、创建链接工厂
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("192.168.228.132");
factory.setPort(5672);
factory.setUsername("jtadmin");
factory.setPassword("jtadmin");
factory.setVirtualHost("/jt");
//创建连接
Connection connection = factory.newConnection();
//2,创建通道
Channel channel = connection.createChannel();
//3定义交换机模式
String exchange_name="E3";
channel.exchangeDeclare(exchange_name, "topic");
//4.声明队列
String queue_name = UUID.randomUUID().toString();
channel.queueDeclare(queue_name,true,false,false,null);
//5将队列和交换机绑定   key:表示接收数据标识
channel.queueBind(queue_name, exchange_name, "domestic.*");
//6.同一时刻服务器只会发一条消息給消費者
channel.basicQos(1);
//7.定义队列的消费者
QueueingConsumer consumer = new QueueingConsumer(channel);
//8.监听队列,手动返回完成
channel.basicConsume(queue_name, false,consumer);
System.out.println("消费者2已启动");
//9.取消息
while(true) {
//Delivery：交付
Delivery delivery = consumer.nextDelivery();
byte [] data = delivery.getBody();
String mString = new String(data);
System.out.println("消费者2"+mString+"国内购");
//false表示一个个返回值
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
}
}

4.Spring集成RabbitMQ配置

Spring提供了AMQP的一个实现，并且spring-rabbit是RabbitMQ的一个实现，下面给出订阅者模式的事例配置如下：

 Spring集成RabbitMQ配置

5.总结

RabbitMQ提供6种模式，分别是Hello，Work Queue，Publish/Subscribe，Routing，Topics，RPC Request/reply，本文详细讲述了前5种，并给出代码实现和思路。其中Publish/Subscribe，Routing，Topics三种模式可以统一归为Exchange模式，只是创建时交换机的类型不一样，分别是fanout、direct、topic。Spring提供了rabbitmq的一个实现，所以集成起来很方便，本文第4章给出了订阅者模式的一种spring配置。

本订阅号提供Java相关技术分享，从Java编程基础到Java高级技术，从JavaWeb技术基础Jsp、Servlet、>JDBC到SSH、SSM开发框架，从REST风格接口设计到分布式项目实战。剖析主流开源技术框架，用亲身

实践来谱写深度Java技术日志。

作者：Darren

QQ：603026148

以上内容归Darren所有，如果有什么错误或者不足的地方请联系我，希望我们共同进步。

从码农到码到成功
关注
专栏目录
rabbitmq队列模式
growing_duck的博客
09-06 438
1、简单队列： 生产者将消息发送到队列，消费者从队列中获取消息。 2、work模式： 队列的消息会平均分发给C1和C2 3、work模式的能者多劳： 在每个消费者的代码中加上红圈的内容，服务器同一时刻只发一条消息给消费者，待消费完成后再发下一条，  这样消费快的得到的消息就多。 4、消息的确认模式： 如果为true，则不需要最后一句代码
RabbitMQ的五种工作模式及实例使用场景
littleGreen_Hand的博客
05-06 2945
RabbitMQ的五种工作模式及实例使用场景 1. 简单模式 1）、做最简单的事情，一个生产者对应一个消费者，RabbitMQ相当于一个消息代理，负责将A的消息转发给B 应用场景：将发送的电子邮件放到消息队列，然后邮件服务在队列中获取邮件并发送给收件人 2. 工作模式 1）、一条消息只会被一个消费者接收； 2）、rabbit采用轮询的方式将消息是平均发送给消费者的； 3）、消费者在处理完某条消息后，才会收到下一条消息。 应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。 3.发布
RabbitMq 6种使用模式
qq_40776768的博客
12-15 2587
RabbitMQ的5种模式与实例 1.1 简单模式Hello World 功能：一个生产者P发送消息到队列Q,一个消费者C接收 生产者实现思路： 创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel向队列中发送消息，关闭通道和连接。 消费者实现思路 创建连接工厂Connection
【RabbitMQ】 相关概念 + 工作模式
最新发布
p_fly的博客
08-15 808
本文将介绍一些MQ中常见的概念，同时也会简单实现一下RabbitMQ的工作流程。
RabbitMQ六种队列模式-简单队列模式
weixin_30673715的博客
09-02 215
前言 RabbitMQ六种队列模式-简单队列 [本文]RabbitMQ六种队列模式-工作队列RabbitMQ六种队列模式-发布订阅RabbitMQ六种队列模式-路由模式RabbitMQ六种队列模式-主题模式 在官网的教程中，描述了如上六类工作队列模式： 简单队列模式：最简单的工作队列，其中一个消息生产者，一个消息消费者，一个队列。也称为点对点模式 工作模式：...
RabbitMQ 七种队列模式
quixotic的博客
01-23 379
RabbitMQ的七种队列模式
RabbitMQ之六种队列模式
weixin_30399055的博客
03-16 95
　　先学习一下RabbitMQ中的六种队列，只学习前五种，具体的官方文档地址是：http://next.rabbitmq.com/getstarted.html 导入maven依赖： 1 <dependency> 2 <groupId>com.rabbitmq</groupId> 3 <artifactId&g...
C# .Net RabbitMQ消息队列发送和接收实例程序
04-21
这个工厂会生成一个`IConnection`实例，它是与RabbitMQ服务器通信的基础。 ```csharp var factory = new ConnectionFactory() { HostName = "localhost" }; // 使用默认主机名 var connection = factory.Create...
RabbitMQ 5种队列
simple_start的博客
06-11 845
RabbitMQ 5种队列 1.简单队列 生产者 - > Queue -> 消费者 2.Work模式 一个生产者、2个消费者。 一个消息只能被一个消费者获取。 轮询分发模式 1、消费者1和消费者2获取到的消息内容是不同的，同一个消息只能被一个消费者获取。 2、消费者1和消费者2获取到的消息的数量是相同的，一个是消费奇数号消息，一个是偶数。 公平分发 （能者多劳） // 同一时刻服务器只...
C#实现rabbitmq 延迟队列功能实例代码
12-31
最近在研究rabbitmq,项目中有这样一个场景：在用户要支付订单的时候，如果超过30分钟未支付，会把...但如果系统的架构中本身就有RabbitMQ的话，那么选择RabbitMQ来实现类似的功能也是一种选择。 我们项目中用到了ra
8. 微服务之消息队列RabbitMQ以及五种消息队列模式
qq_46656580的博客
11-21 3700
即客户端并不是直接向服务端发起请求，而是会通过一个消息队列，客户端发起请求放入消息队列后就不会去等待服务端的执行结果，而是交给消息队列去下发请求做后台处理，客户端察觉不到。再创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息。创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息。创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息。
RabbitMQ六种队列模式
思变的博客
11-29 521
1.简单队列 1.引入maven依赖： <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.8.0</version> </dependency> 2.获取连接工具类： public class ConnectionUtil { public s.
rabbitmq入门（一）简单队列（Hello World!、Work queues）
念念不忘，必有回响
10-28 717
什么是直接模式： 我们需要将消息发给唯一一个节点时使用这种模式，这是最简单的一种形式。 特点： 这种模式下不需要将Exchange进行任何绑定(binding)操作 消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字 如果vhost中不存在RouteKey中指定的队列名，则该消息会被抛弃 一般情况可以使用rabbitMQ自带的Exchange：”"(该Exchange的名...
RabbitMQ 中的 7 种队列模式，写得太好了！
emprere的博客
05-29 260
上一篇：深夜看了张一鸣的微博，让我越想越后怕七种模式介绍与应用场景简单模式（Hello World）做最简单的事情，一个生产者对应一个消费者，RabbitMQ相当于一个消息代理，负责将A的...
【RabbitMQ】——队列模式（1）
淡泊明志，宁静致远
07-24 826
MQ：Message Queue，消息队列，是系统和系统之间的通信方法。         RabbitMQ是MQ的一种实现，较为常用的还有ActiveMQ，Kafka（分布式发布订阅消息系统）等。本篇博客是RabbitMQ的入门，简单的了解一些RabbitMQ的5中队列，分别为：简单队列、work模式、订阅模式、路由模式、通配符模式。   环境：windows上安装RabbitMQ
RabbitMQ几种模式
u014263388的专栏
05-30 9840
RabbitMQ几种模式
Rabbit Mq 五种工作模式及实例
志不强者智不达，言不信者行不果
12-10 1153
前言 在说Rabbit Mq 之前先说一下什么是MQ, MQ为Message Queue 消息队列是应用程序和应用程序之间的通信方法 Rabbit Mq是一个开源的,在AMQP(高级消息队列协议)基础上 完整的、可复用的企业消息系统 Rabbit Mq 有五种工作模式(也有人说6种),下面主要对这五种工作模式做分析以及实例 简单模式 简单模式顾名思义,就是很简单,生产者生产,消费者消费,生产者和消...
Python RabbitMQ消息队列示例与exchange模式详解
在Python中实现RabbitMQ消息队列是一种常见的分布式系统通信解决方案，它提供了可靠的消息传递机制。本篇文章将详细介绍如何通过Python的pika库来操作RabbitMQ的三种基本exchange模式：fanout、direct和topic。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

从码农到码到成功

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值