RabbitMQ消息队列---模式规则以及测试
在最新的RabbitMQ中，消息的处理模式一共有7种，分别是简单模式（Hello Word），工作模式（Work queues），发布订阅模式（Publish/Subscribe），路由模式（Routing），主题模式（Topics），异步调用模式（RPC）和最新的发布确认模式（Publisher Confirms） ,每种模式都有其相对应的应用场景，并且这些场景是比较常见的。
1 简单模式（HelloWorld）
1.1 概述
简单模式是RabbitMQ最简单的模式，当生产者发送消息到交换机,交换机根据消息属性发送到队列，消费者监听绑定队列实现消息的接收和消费逻辑编写。简单模式下,强调的一个队列queue只被一个消费者监听消费。
在简单模式的结构图中，虽然没有出现交换机，但要注意的是它是有一个交换机的，当我们在使用RabbitMQ没有指定交换机时，它会使用默认的交换机来负责消息的发送和接受。
简单模式的应用场景常见为短信发送，单封邮件发送，比如说：当你登录一个系统时，它会发一条短信给你，短信内容是你的账号的登录时间，登录地点等等。
1.2 Web界面测试
1.登录RabbitMQ界面： 进入队列界面创建消息队列
2.发布消息： 在Web界面的操作中，如果我们想要发送消息，可以使用交换机发送或者直接在队列发送
3.消费消息： 在队列详情页面中，我们可以测试消息的消费
1.3 Java代码测试
1.创建工程： 创建maven项目，并导入Java原生的RabbitMQ的依赖
<dependency>
<groupId>com.rabbitmqgroupId>
<artifactId>amqp-clientartifactId>
<version>5.14.2version>
dependency>
2.创建生产者生产消息： 创建provider类，生产消息发送到RabbitMQ
package Simple;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Provider {
public static void main(String[] args) {
//1.创建连接工程，声明RabbitMQ的连接信息
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost"); //RabbitMQ连接地址
connectionFactory.setPort(5672); //RabbitMQ连接端口，注意，这里不是web访问界面的端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
connectionFactory.setVirtualHost("/");
//2.声明连接和通道
Connection connection = null;
Channel channel = null;
try {
//2.创建连接，连接到RabbitMQ
connection = connectionFactory.newConnection("消息生产者");
//3.从连接中获取通道
channel = connection.createChannel();
//4.通过通道创建消息交换机，消息队列等信息(简单模式中使用默认的交换机，它会自己定义)
/**
* @Params1 队列名
* @Params2 是否持久化
* @Params3 排他性
* @Params4 是否自动删除
* @Params5 参数，主要用来做主题模式的
*/
String queues = "queue01";
channel.queueDeclare(queues,false,false,false,null);
//5.创建消息载体，并发送消息到队列中
String message = "我是用Java代码来测试简单模式的";
channel.basicPublish("",queues,null,message.getBytes());
System.out.println("消息已发送");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (channel != null && channel.isOpen()) {
try {
channel.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (connection != null && connection.isOpen()) {
try {
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
3.执行方法： 查看消息是否发送到RabbitMQ
4.创建消费者消费消息： 创建consumer类，消费RabbitMQ里的消息
package Simple;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Consumer {
public static void main(String[] args) {
//1.创建连接工程，声明RabbitMQ的连接信息
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost"); //RabbitMQ连接地址
connectionFactory.setPort(5672); //RabbitMQ连接端口，注意，这里不是web访问界面的端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
connectionFactory.setVirtualHost("/");
//2.声明连接和通道
Connection connection = null;
Channel channel = null;
try {
//2.创建连接，连接到RabbitMQ
connection = connectionFactory.newConnection("消息生产者");
//3.从连接中获取通道
channel = connection.createChannel();
//4.通过通道消费消息
/**
* @Params1 队列名
* @Params2 是否是真消费
* @Params3 获取消费消息，对消息进行转换为string类型
* @Params4 获取消息失败处理方式
*/
channel.basicConsume("queue01", true, new DeliverCallback() {
public void handle(String consumerTag, Delivery message) throws IOException {
System.out.println("消费的消息是:" + new String(message.getBody(), "UTF-8"));
}
}, new CancelCallback() {
public void handle(String consumerTag) throws IOException {
System.out.println("消费消息失败");
}
});
} catch (Exception e) {
e.printStackTrace();
} finally {
if (channel != null && channel.isOpen()) {
try {
channel.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if (connection != null && connection.isOpen()) {
try {
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
5.测试： 执行方法，看消息是否被消费掉了
1.4 整合SpringBoot测试
1.新建测试项目： 建立消息提供者和消费者，并导入相关依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-amqpartifactId>
dependency>
<dependency>
<groupId>org.springframework.amqpgroupId>
<artifactId>spring-rabbit-testartifactId>
<scope>testscope>
dependency>
2.搭建生产者模块： 编写配置文件和消息提供者代码
#yaml配置文件
server:
port: 8085
spring:
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
virtual-host: /
//RabbitConfig配置文件，主要用来建立队列（因为是简单模式，所以可以不声明交换机和绑定关系，它会绑定默认的交换机）
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfig {
//声明队列
@Bean
public Queue HelloWorldQueue(){
return new Queue("queue01",true);
}
}
//编写消息发送类，这里主要是模仿订单下单消息，只要订单生成成功，他就会向RabbitMQ发送消息
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.UUID;
@Service
public class orderService {
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* 模拟下单逻辑
*/
public void MakeOrder(String userId,String productID,int num){
//使用UUID来代替订单信息
String orderId = UUID.randomUUID().toString();
//订单生成成功,发送消息到消息队列
String queueName = "queue01";
rabbitTemplate.convertAndSend(queueName,orderId);
}
}
//在springboot的测试类中模拟订单下单操作
@SpringBootTest
class RabbitmqProviderApplicationTests {
@Autowired
private orderService orderService;
@Test
void contextLoads() {
orderService.MakeOrder("1","1",1);
}
}
3.测试： 启动测试类，看看消息队列中是否有消息
4.搭建消费者模块： 编写相关配置和代码
#yaml配置文件
server:
port: 8086
spring:
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
virtual-host: /
//编写消费类，这里监听了队列queue01，只要queue01有消息，他就会去消费
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
@Service
//绑定队列
@RabbitListener(queues = "queue01")
public class consumerService {
@RabbitHandler
public void receiveMessage(String message) {
System.out.println("接收到了订单信息，他的ID是：" + message);
}
}
5.测试： 启动消息消费服务，监听队列
2 工作模式（work queue）
2.1 概述
工作队列模式主要是多个消费者绑定一个消息队列，当消息生产者生产消息标签发送到队列时，RabbitMQ就会将这些消息分别分发到和队列绑定的消费者中去，这种分发有两种模式，分别是轮询分发和公平分发。
- 轮询分发：轮询分发则是将这些消息逐一发送到消费者中去，就是说发一个给A，然后发一个给B，然后再发一个给A。
- 公平分发：公平分发则是按照消费者的能力去分发消息，如果A的性能高，消费的快，那就会分发多一点给A，让A来消费执行。
注意：虽然上面的结构图没有出现交换机，但是它还是绑定了默认的交换机的
常用的应用场景为：抢红包，资源分配系统等等
2.2 Java代码测试
2.2.1 轮询模式
1.创建消息提供者： 编写provider类
package Work.Lunxun;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Provider {
public static void main(String[] args) {
//1.创建连接工程，声明RabbitMQ的连接信息
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost"); //RabbitMQ连接地址
connectionFactory.setPort(5672); //RabbitMQ连接端口，注意，这里不是web访问界面的端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
connectionFactory.setVirtualHost("/");
//2.声明连接和通道
Connection connection = null;
Channel channel = null;
try {
//2.创建连接，连接到RabbitMQ
connection = connectionFactory.newConnection("消息生产者");
//3.从连接中获取通道
channel = connection.createChannel();
//4.通过通道创建消息交换机，消息队列等信息(简单模式中使用默认的交换机，它会自己定义)
/**
* @Params1 队列名
* @Params2 是否持久化
* @Params3 排他性
* @Params4 是否自动删除
* @Params5 参数，主要用来做主题模式的
*/
String queues = "queue01";
channel.queueDeclare(queues, true, false, false, null);
//5.创建消息载体，并发送消息到队列中
for (int i = 0; i <= 20; i++) {
String message = "我是轮询模式发送过来的第"+i+"条消息";
channel.basicPublish("", "queue01", null, message.getBytes());
}
System.out.println("消息已发送");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (channel != null && channel.isOpen()) {
try {
channel.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if