一、Work queues 工作队列模式
1. 模式说明
⚫ P：生产者，也就是要发送消息的程序
⚫ C：消费者，消息的接收者，会一直等待消息到来
⚫ Work Queues：与RabbitMQ 入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。
⚫ 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
2. 代码编写
Work Queues 与入门程序的简单模式的代码几乎是一样的。可以完全复制，并多复制一个消费者进行多个消费者同时对消费消息的测试。
2.1 发送消息的程序： WorkQueueProducer.java
package com.nanfeng;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 10:53
*/
public class WorkQueueProducer {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
//5. 创建队列Queue
/*
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
参数：
1. queue：队列名称
2. durable:是否持久化，当mq重启之后，还在
3. exclusive：
* 是否独占。只能有一个消费者监听这队列
* 当Connection关闭时，是否删除队列
*
4. autoDelete:是否自动删除。当没有Consumer时，自动删除掉
5. arguments：参数。
*/
//如果没有一个名字叫hello_world的队列，则会创建该队列，如果有则不会创建
channel.queueDeclare("work_queues",true,false,false,null);
//6. 发送消息
/*
basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
参数：
1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
2. routingKey：路由名称
3. props：配置信息
4. body：发送消息数据
*/
for (int i = 1; i <= 10; i++) {
String body = i+"hello rabbitmq~~~";
//6. 发送消息
channel.basicPublish("","work_queues",null,body.getBytes());
}
//7.释放资源
channel.close();
connection.close();
}
}
2.2 接收消息的程序： WorkQueueConsumerOne.java
注：WorkQueueConsumerTwo.java 代码相同
package com.nanfeng;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxx
* @DateTime: 2023/8/31 14:45
*/
public class WorkQueueConsumerOne {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
//5. 创建队列Queue
/*
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
参数：
1. queue：队列名称
2. durable:是否持久化，当mq重启之后，还在
3. exclusive：
* 是否独占。只能有一个消费者监听这队列
* 当Connection关闭时，是否删除队列
*
4. autoDelete:是否自动删除。当没有Consumer时，自动删除掉
5. arguments：参数。
*/
//如果没有一个名字叫hello_world的队列，则会创建该队列，如果有则不会创建
channel.queueDeclare("work_queues",true,false,false,null);
//接收消息
Consumer consumer = new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1. consumerTag：标识
2. envelope：获取一些信息，交换机，路由key...
3. properties:配置信息
4. body：数据
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("body："+new String(body));
}
};
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck：是否自动确认
3. callback：回调对象
*/
channel.basicConsume("work_queues",true,consumer);
//关闭资源？不要
}
}
测试结果：
3. 小结
（1） 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。
（2）Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。
二、 Pub/Sub 订阅模式
在订阅模型中，多了一个 Exchange 角色，而且过程略有变化
生产者把消息发给交换机（X），交换机把消息路由分发给不同的队列，消费者监听队列获取消息
⚫ P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
⚫ C：消费者，消息的接收者，会一直等待消息到来
⚫ Queue：消息队列，接收消息、缓存消息
⚫ Exchange：交换机（X）。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、
种类型：
➢ Fanout：广播，将消息交给所有绑定到交换机的队列
➢ Direct：定向，把消息交给符合指定routing key 的队列
➢ Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列
Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息会丢失
2. 代码编写
2.1 发送信息的程序 PubSubConsumerTwo.java
package com.nanfeng;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 10:53
*/
public class PubSubProducer {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
/*
exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
参数：
1. exchange:交换机名称
2. type:交换机类型
DIRECT("direct"),：定向
FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
TOPIC("topic"),通配符的方式
HEADERS("headers");参数匹配
3. durable:是否持久化
4. autoDelete:自动删除
5. internal：内部使用。 一般false
6. arguments：参数
*/
String exchangeName = "rabbitMQ_fanout";
//5. 创建交换机
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
//6. 创建队列
String queue1Name = "rabbitMQ_fanout_queue_one";
String queue2Name = "rabbitMQ_fanout_queue_two";
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1. queue：队列名称
2. exchange：交换机名称
3. routingKey：路由键，绑定规则
如果交换机的类型为fanout ，routingKey设置为""
*/
//7. 绑定队列和交换机
channel.queueBind(queue1Name,exchangeName,"");
channel.queueBind(queue2Name,exchangeName,"");
//8. 发送消息
String body = "日志信息：xxx用户调用selectList()方法...日志级别：info...";
channel.basicPublish(exchangeName,"",null,body.getBytes());
//9. 释放资源
channel.close();
connection.close();
}
}
2.2 接收消息的程序 PubSubConsumerOne.java
package com.nanfeng;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 14:45
*/
public class PubSubConsumerOne {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
String queue1Name = "rabbitMQ_fanout_queue_one";
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck：是否自动确认
3. callback：回调对象
*/
// 接收消息
Consumer consumer = new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1. consumerTag：标识
2. envelope：获取一些信息，交换机，路由key...
3. properties:配置信息
4. body：数据
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("body："+new String(body));
System.out.println("将日志信息打印到控制台.....");
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要
}
}
2.3 接收消息的程序 PubSubConsumerTwo.java
package com.nanfeng;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 14:45
*/
public class PubSubConsumerTwo {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
String queue2Name = "rabbitMQ_fanout_queue_two";
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck：是否自动确认
3. callback：回调对象
*/
// 接收消息
Consumer consumer = new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1. consumerTag：标识
2. envelope：获取一些信息，交换机，路由key...
3. properties:配置信息
4. body：数据
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("body："+new String(body));
System.out.println("将日志信息保存到数据库.....");
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要
}
}
测试结果：
3. 小结
（1）交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。
（2）发布订阅模式与工作队列模式的区别：
⚫ 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机
⚫ 发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)
⚫ 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑 定到默认的交换机
三、 Routing 路由模式
1. 模式说明
⚫ 队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey（路由key）
⚫ 消息的发送方在向 Exchange 发送消息时，也必须指定消息的 RoutingKey
⚫ Exchange 不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的Routingkey 与消息的 Routing key 完全一致，才会接收到消息
图解：
⚫ P：生产者向 Exchange 发送消息，发送消息时，会指定一个routing key
⚫ X：Exchange（交换机），接收生产者的消息，然后把消息递交给与 routing key 完全匹配的队列
⚫ C1：消费者，其所在队列指定了需要 routing key 为 error 的消息
⚫ C2：消费者，其所在队列指定了需要 routing key 为 info、error、warning 的消息
2. 代码编写
2.1 发送消息的程序 RoutingProducer.java
package com.nanfeng;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 10:53
*/
public class RoutingProducer {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
/*
exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
参数：
1. exchange:交换机名称
2. type:交换机类型
DIRECT("direct"),：定向
FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
TOPIC("topic"),通配符的方式
HEADERS("headers");参数匹配
3. durable:是否持久化
4. autoDelete:自动删除
5. internal：内部使用。 一般false
6. arguments：参数
*/
String exchangeName = "rabbitMQ_direct";
//5. 创建交换机
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,false,null);
//6. 创建队列
String queue1Name = "rabbitMQ_direct_queue_one";
String queue2Name = "rabbitMQ_direct_queue_two";
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1. queue：队列名称
2. exchange：交换机名称
3. routingKey：路由键，绑定规则
如果交换机的类型为direct ，需要设置routingKey
*/
//7. 绑定队列和交换机
//队列1绑定 info error warning,需要打印控制台
channel.queueBind(queue1Name,exchangeName,"info");
channel.queueBind(queue1Name,exchangeName,"error");
channel.queueBind(queue1Name,exchangeName,"warning");
//队列2绑定 error，需要保存数据库
channel.queueBind(queue2Name,exchangeName,"error");
//8. 发送消息
String body = "日志信息：xxx用户调用selectList()方法...日志级别：info...";
channel.basicPublish(exchangeName,"info",null,body.getBytes());
String bodyError = "日志信息：xxx用户调用delete()方法...,不允许物理删除,日志级别：error...";
channel.basicPublish(exchangeName,"error",null,bodyError.getBytes());
//9. 释放资源
channel.close();
connection.close();
}
}
2.2 接收消息的程序 RoutingConsumerOne.java
package com.nanfeng;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 14:45
*/
public class RoutingConsumerOne {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
String queue1Name = "rabbitMQ_direct_queue_one";
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck：是否自动确认
3. callback：回调对象
*/
// 接收消息
Consumer consumer = new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1. consumerTag：标识
2. envelope：获取一些信息，交换机，路由key...
3. properties:配置信息
4. body：数据
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("body："+new String(body));
System.out.println("将日志信息打印到控制台.....");
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要
}
}
2.3 接收消息的程序 RoutingConsumerTwo.java
package com.nanfeng;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 14:45
*/
public class RoutingConsumerTwo {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
String queue2Name = "rabbitMQ_direct_queue_two";
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck：是否自动确认
3. callback：回调对象
*/
// 接收消息
Consumer consumer = new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1. consumerTag：标识
2. envelope：获取一些信息，交换机，路由key...
3. properties:配置信息
4. body：数据
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("body："+new String(body));
System.out.println("将日志信息打印到控制台.....");
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要
}
}
测试结果：
3. 小结
Routing 模式要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列。
四、Topics 通配符模式
1. 模式说明
⚫ Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型Exchange 可以让队列在绑定 Routing key 的时候使用通配符！
⚫ Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
⚫ 通配符规则：# 匹配一个或多个词，* 匹配不多不少恰好1个词，例如：item.# 能够匹配 item.insert.abc 或者 item.insert，item.* 只能匹配 item.insert
图解：
⚫ 红色 Queue：绑定的是 usa.# ，因此凡是以 usa. 开头的 routing key 都会被匹配到
⚫ 黄色 Queue：绑定的是 #.news ，因此凡是以 .news 结尾的 routing key 都会被匹配
2. 代码编写
2.1 发送消息的程序 TopicProducer.java
package com.nanfeng;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 10:53
*/
public class TopicProducer {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
/*
exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
参数：
1. exchange:交换机名称
2. type:交换机类型
DIRECT("direct"),：定向
FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
TOPIC("topic"),通配符的方式
HEADERS("headers");参数匹配
3. durable:是否持久化
4. autoDelete:自动删除
5. internal：内部使用。 一般false
6. arguments：参数
*/
String exchangeName = "rabbitMQ_topic";
//5. 创建交换机
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
//6. 创建队列
String queue1Name = "rabbitMQ_topic_queue_one";
String queue2Name = "rabbitMQ_topic_queue_two";
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1. queue：队列名称
2. exchange：交换机名称
3. routingKey：路由键，绑定规则
如果交换机的类型为direct ，需要设置routingKey
*/
//7. 绑定队列和交换机
// routing key 系统的名称.日志的级别。
//需求：不论什么类型的信息都需要打印在控制台
channel.queueBind(queue1Name,exchangeName,"*.*");
//需求： 所有error级别的日志存入数据库，所有order系统的日志存入数据库
channel.queueBind(queue2Name,exchangeName,"#.error");
channel.queueBind(queue2Name,exchangeName,"order.*");
//8. 发送消息
String body = "日志信息：xxx用户调用selectList()方法...日志级别：info...";
channel.basicPublish(exchangeName,"order.info",null,body.getBytes());
String bodyError = "日志信息：xxx用户调用selectGoodsById()方法...,日志级别：info...";
channel.basicPublish(exchangeName,"good.info",null,bodyError.getBytes());
//9. 释放资源
channel.close();
connection.close();
}
}
2.2 接收消息的程序 TopicConsumerOne.java
package com.nanfeng;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 14:45
*/
public class TopicConsumerOne {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("i");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
String queue1Name = "rabbitMQ_topic_queue_one";
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck：是否自动确认
3. callback：回调对象
*/
// 接收消息
Consumer consumer = new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1. consumerTag：标识
2. envelope：获取一些信息，交换机，路由key...
3. properties:配置信息
4. body：数据
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("body："+new String(body));
System.out.println("将日志信息打印到控制台.....");
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要
}
}
2.3 接收消息的程序 TopicConsumerTwo.java
package com.nanfeng;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author: xxxx
* @DateTime: 2023/8/31 14:45
*/
public class TopicConsumerTwo {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2.设置参数：ip,端口,虚拟机,用户名,密码
factory.setHost("ip");//ip 默认值 localhost
factory.setPort(5672);//端口 默认值 5672
factory.setVirtualHost("studyRabbitMQ");//虚拟机 默认值/
factory.setUsername("用户名");//用户名 默认 guest
factory.setPassword("密码");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
String queue2Name = "rabbitMQ_topic_queue_two";
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck：是否自动确认
3. callback：回调对象
*/
// 接收消息
Consumer consumer = new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1. consumerTag：标识
2. envelope：获取一些信息，交换机，路由key...
3. properties:配置信息
4. body：数据
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("body："+new String(body));
System.out.println("将日志信息保存到数据库.....");
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要
}
}
测试结果：
3. 小结
Topic 主题模式可以实现 Pub/Sub 发布与订阅模式和 Routing 路由模式的功能，只是 Topic 在配置routing key 的时候可以使用通配符，显得更加灵活。
五、工作模式总结
1. 简单模式 HelloWorld：一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。
2. 工作队列模式 Work Queue：一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。
3. 发布订阅模式 Publish/subscribe：需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列。
4. 路由模式 Routing：需要设置类型为 direct 的交换机，交换机和队列进行绑定，并且指定 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。
5. 通配符模式 Topic：需要设置类型为 topic 的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
