RabbitMQ的五种常见模式
在练习RabbitMQ之前,请确认自己的RabbitMQ已经安装并开启。
1、简单模式
从图上可以看到只有三个角色:
p 【product】: 生产者 发生消息的
红色[queue]: 队列。 存储消息的
C [consumer]: 消费者 消费消息
创建一个maven项目,创建一个消费者和一个生产者。
生产者代码:
public class Product {
public static void main(String[] args) throws Exception{
//创建链接工厂 ---配置链接信息
ConnectionFactory factory = new ConnectionFactory();
//链接地址
factory.setHost("192.168.31.33");
//创建链接对象Connection
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//创建队列
/**
* String queue, 队列的名称
* boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
* boolean exclusive, 是否独占 false
* boolean autoDelete, 是否自动删除 如果长时间没有发生消息 则自动删除
* Map<String, Object> arguments 额外参数 先给null
*/
channel.queueDeclare("ban_queue",true,false,false,null);
//发送消息
/**
* String exchange: 交换机的名称 如果没有则使用“” 它回自动采用默认
* String routingKey, 路由key 如果没有交换机的绑定 使用队列的名称
* BasicProperties props, 消息的一些额外配置 目前先不加 null
* byte[] body 消息的内容
*/
String msg="(*Φ皿Φ*)";
channel.basicPublish("","ban_queue",null,msg.getBytes());
}
}
消费者代码:
public class Consumer {
public static void main(String[] args)throws Exception {
//创建链接工厂 ---配置链接信息
ConnectionFactory factory = new ConnectionFactory();
//链接地址
factory.setHost("192.168.31.33");
//创建链接对象Connection
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//接受消息
/**
* (String queue, 队列的名称
* boolean autoAck, 是否自动确认
* Consumer callback: 回调方法 当队列中存在信息后 会自动触发回调函数。
*/
DefaultConsumer callback = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//body接受的信息
System.out.println("消费者01"+new String(body));
}
};
channel.basicConsume("ban_queue",true,callback);
}
}
先运行生产者代码,在运行消费者,运行结果如下。
2、工作者模式
特点:
1. 一个生产者
2. 由多个消费。
3. 统一个队列。
4. 这些消费者之间存在竞争关系。
用处:
比如批量处理上. rabbitMQ里面积压了大量的消息。
项目同上:
生产者代码:
public class Product {
public static void main(String[] args) throws Exception{
//创建链接工厂 ---配置链接信息
ConnectionFactory factory = new ConnectionFactory();
//链接地址
factory.setHost("192.168.31.33");
//创建链接对象Connection
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//创建队列
channel.queueDeclare("ban_queue_work",true,false,false,null);
//发送消息
for (int i = 0; i < 10; i++) {
String msg="(*Φ皿Φ*)";
channel.basicPublish("","ban_queue_work",null,msg.getBytes());
}
}
}
如果只运行消费者,通过rabbitMQ的可视化界面发现,队列中有了十条数据,只是没有消费者需要消费。
消费者01代码:
public class Consumer01 {
public static void main(String[] args)throws Exception {
//创建链接工厂 ---配置链接信息
ConnectionFactory factory = new ConnectionFactory();
//链接地址
factory.setHost("192.168.31.33");
//创建链接对象Connection
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//接受消息
DefaultConsumer callback = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//body接受的信息
System.out.println("消费者01"+new String(body));
}
};
channel.basicConsume("ban_queue_work",true,callback);
}
}
消费者02代码:
public class Consumer02 {
public static void main(String[] args)throws Exception {
//创建链接工厂 ---配置链接信息
ConnectionFactory factory = new ConnectionFactory();
//链接地址
factory.setHost("192.168.31.33");
//创建链接对象Connection
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//接受消息
DefaultConsumer callback = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//body接受的信息
System.out.println("消费者02"+new String(body));
}
};
channel.basicConsume("ban_queue_work",true,callback);
}
}
运行后,发现消费者开始消费,同时,这里的信息是按照平均分配。
3、发布订阅模式
特点:
1.一个生产者
2.多个消费者
3.多个队列。
4.交换机 转发消息。
生产者代码:
public static void main(String[] args) throws Exception{
//创建链接工厂 ---配置链接信息
ConnectionFactory factory = new ConnectionFactory();
//链接地址
factory.setHost("192.168.31.33");
//创建链接对象Connection
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//创建队列
channel.queueDeclare("ban_queue_fanout01",true,false,false,null);
channel.queueDeclare("ban_queue_fanout02",true,false,false,null);
//创建交换机
/**
* String exchange,交换机的名称
* BuiltinExchangeType type, 交换机的类型
* boolean durable:是否持久化
*/
channel.exchangeDeclare("ban_exchange_fanout03", BuiltinExchangeType.FANOUT,true);
//绑定交换机
/**
* String queue, 队列名
* String exchange, 交换机的名称
* String routingKey:路由key 如果交换机为fanout模式则不需要路由key
*/
channel.queueBind("ban_queue_fanout01","ban_exchange_fanout03","");
channel.queueBind("ban_queue_fanout02","ban_exchange_fanout03","");
//发送消息
for (int i = 0; i < 10; i++) {
String msg="(*Φ皿Φ*)"+"第"+i+"次";
channel.basicPublish("ban_exchange_fanout03","",null,msg.getBytes());
}
//生产者这里可以管理资源 消费者不能关闭资源。
channel.close();
connection.close();
}
消费者代码01:
代码同上,只需更改队列名。
channel.basicConsume("ban_queue_fanout01",true,callback);
消费者代码02:
代码同上,只需更改队列名。
channel.basicConsume("ban_queue_fanout02",true,callback);
此时运行发布者,然后再RabbitMQ可视化管理界面发现,两个队列都已经获取到了所有信息。
注意:
如果只运行发布者,此时应该如上图两个队列都拿到信息,但是会出现意外情况,出现下面这种情况,有一个队列直接将信息消费掉了(此时没有运行消费者)
解决方法:在RabbitMQ可视化界面中将两个队列和交换机全部干掉,重新运行发布者,此时应该会恢复正常。
4、路由模式
‘’
特点:
1.一个生产者
2.多个消费者
3.多个队列。
4.交换机 转发消息。
5.routekey:路由key 只要routekey匹配的消息可以到达对应队列。
生产者代码:
public static void main(String[] args) throws Exception{
//创建链接工厂 ---配置链接信息
ConnectionFactory factory = new ConnectionFactory();
//链接地址
factory.setHost("192.168.31.33");
//创建链接对象Connection
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//创建队列
channel.queueDeclare("ban_queue_direct01",true,false,false,null);
channel.queueDeclare("ban_queue_direct02",true,false,false,null);
//创建交换机
channel.exchangeDeclare("ban_exchange_direct", BuiltinExchangeType.DIRECT,true);
//绑定交换机
channel.queueBind("ban_queue_direct01","ban_exchange_direct","error");
channel.queueBind("ban_queue_direct02","ban_exchange_direct","info");
channel.queueBind("ban_queue_direct02","ban_exchange_direct","error");
channel.queueBind("ban_queue_direct02","ban_exchange_direct","warning");
//发送消息
for (int i = 0; i < 10; i++) {
String msg="(*Φ皿Φ*)"+"第"+i+"次";
//发送info
channel.basicPublish("ban_exchange_direct","info",null,msg.getBytes());
}
//生产者这里可以管理资源 消费者不能关闭资源。
channel.close();
connection.close();
}
只运行发布者代码可以发现,只有一个队列接收到了信息。
修改发布者key,改为error,再次运行。
两个队列都获取到了信息。
消费者代码01:
代码同上,只需更改队列名。
channel.basicConsume("ban_exchange_direct",true,callback);
消费者代码02:
代码同上,只需更改队列名。
channel.basicConsume("ban_exchange_direct",true,callback);
5、主体模式
特点:
绑定按照通配符的模式。
*: 统配一个单词。
#: 统配n个单词
例如:
hello.orange.rabbit
lazy.orange
生产者代码:
public static void main(String[] args) throws Exception{
//创建链接工厂 ---配置链接信息
ConnectionFactory factory = new ConnectionFactory();
//链接地址
factory.setHost("192.168.31.33");
//创建链接对象Connection
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel();
//创建队列
channel.queueDeclare("ban_queue_topic01",true,false,false,null);
channel.queueDeclare("ban_queue_topic02",true,false,false,null);
//创建交换机
/**
* String exchange,交换机的名称
* BuiltinExchangeType type, 交换机的类型
* boolean durable:是否持久化
*/
channel.exchangeDeclare("ban_exchange_topic", BuiltinExchangeType.TOPIC,true);
//绑定交换机
/**
* String queue, 队列名
* String exchange, 交换机的名称
* String routingKey:路由key 如果交换机为fanout模式则不需要路由key
*/
channel.queueBind("ban_queue_topic01","ban_exchange_topic","*.orange.*");
channel.queueBind("ban_queue_topic02","ban_exchange_topic","*.*.rabbit");
channel.queueBind("ban_queue_topic02","ban_exchange_topic","lazy.#");
//发送消息
for (int i = 0; i < 10; i++) {
String msg="(*Φ皿Φ*)"+"第"+i+"次";
channel.basicPublish("ban_exchange_topic","lazy.orange.rabbit",null,msg.getBytes());
}
//生产者这里可以管理资源 消费者不能关闭资源。
channel.close();
connection.close();
}
只运行发布者代码可以发现,两个队列接收到了信息。
修改发布者key,改为lazy.rabbit,再次运行,发现只有队列2获取到了消息。
channel.basicPublish("ban_exchange_topic","lazy.rabbit",null,msg.getBytes());