RabbitMQ实战学习

2401_84183628

于 2024-04-30 03:49:44 发布

阅读量606

点赞数 7

分类专栏：程序员文章标签： rabbitmq 学习分布式

本文链接：https://blog.csdn.net/2401_84183628/article/details/138331758

版权

程序员专栏收录该内容

120 篇文章 0 订阅

订阅专栏

    factory.setHost("192.168.101.22");//ip地址 默认localhost
    factory.setPort(5672);//端口 默认值5672
    factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
    factory.setUsername("heima");//用户名 默认guest
    factory.setPassword("heima");//密码 默认guest
    //3.创建连接 connection
    Connection connection = factory.newConnection();
    //4.创建channel
    Channel channel = connection.createChannel();
    //5.创建队列Queue 暂时不用交换机
    /\*

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.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：

queue：队列名称
autoAck: 是否自动确认
callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key…
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println(“consumerTag:”+consumerTag);
System.out.println(“exchange:”+envelope.getExchange());
System.out.println(“RoutingKey:”+envelope.getRoutingKey());
System.out.println(“properties:”+properties);*/
System.out.println(“body:”+new String(body));//byte数组转string字符串
}
};
channel.basicConsume(“work_queues”,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}


**（3）测试**


注意：先运行消费者1和消费者2，再运行生产者


结果如下：消费者1消费消息序号 1,3,5,7,9  
 消费者2消费消息序号 2,4,6,8,10


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/4b87fcf7d2c84f9687c99ba1ddbc291f.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/f6137611705a4dadaa8e6d0d88dc3094.png)


**（4） 小结**


1. 在一个队列中**如果有多个消费者**，那么消费者之间对于同一个消息的关系是**竞争**的关系。
2. Work Queues 对于**任务过重**或**任务较多**情况使用**工作队列**可以**提高任务处理的速度**。例如：**短信服务部署多个，只需要有一个节点成功发送即可**。


##### 1.3 Pub/Sub 订阅模式


**（1）模式说明**


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/aa4463e3152e4dce8f3651150a3a176f.png)


在订阅模型中，**多了一个 Exchange 角色**，而且过程略有变化：


* P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
* C：消费者，消息的接收者，会一直等待消息到来
* Queue：消息队列，接收消息、缓存消息
* Exchange：交换机（X）。一方面，

 接收生产者发送的消息

 。另一方面，

 知道如何处理消息

 ，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：


	1. Fanout：**广播**，将消息交给**所有绑定到交换机的队列**
	2. Direct：**定向**，把消息交给**符合指定routing key 的队列**
	3. Topic：**通配符**，把消息交给**符合routing pattern（路由模式） 的队列**


**Exchange**（交换机）**只负责转发消息**，**不具备存储消息的能力**，因此如果没有任何队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息会丢失！


**（2）代码编写**


**生产者Producer\_PubSub**

package com.itheima.producer;
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;

//发布订阅模式
//发送消息
public class Producer_PubSub {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost(“192.168.101.22”);//ip地址默认localhost
factory.setPort(5672);//端口默认值5672
factory.setVirtualHost(“/itcast”);//虚拟机默认值 /虚拟机
factory.setUsername(“heima”);//用户名默认guest
factory.setPassword(“heima”);//密码默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建交换机
/*
exchangeDeclare
(String exchange, 交换机名称
BuiltinExchangeType type, 交换机类型枚举类型
DIRECT(“direct”), ：定向
FANOUT(“fanout”), ：扇形（广播），发送消息到每一个与之绑定的队列
TOPIC(“topic”),：通配符方式
HEADERS(“headers”);参数匹配
boolean durable, 是否持久化
boolean autoDelete, 是否自动删除
boolean internal, 内部使用一般false
Map<String, Object> arguments) 参数列表
*/
String exchangeName=“test_fanout”;
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
//6.创建两个队列
String queue1Name=“test_fanout_queue1”;
String queue2Name=“test_fanout_queue2”;
/*
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: 参数
*/
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7，绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1.queue: 队列名称
2.exchange：交换机
3.routingKey：路由键：绑定规则
如果交换机的类型为fanout，routingKey设置为""
*/
channel.queueBind(queue1Name,exchangeName,“”);
channel.queueBind(queue2Name,exchangeName,“”);
//8.发送消息
String body=“日志信息：张三调用了findAll方法…日志级别：info”;
channel.basicPublish(exchangeName,“”,null,body.getBytes());
//9.释放资源
channel.close();
connection.close();
}
}

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576


**Consumer\_PubSub1**

package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_PubSub1 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost(“192.168.101.22”);//ip地址默认localhost
factory.setPort(5672);//端口默认值5672
factory.setVirtualHost(“/itcast”);//虚拟机默认值 /虚拟机
factory.setUsername(“heima”);//用户名默认guest
factory.setPassword(“heima”);//密码默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.队列已经声明一次了，这里不用再声明队列
String queue1Name=“test_fanout_queue1”;
String queue2Name=“test_fanout_queue2”;
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：

queue：队列名称
autoAck: 是否自动确认
callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key…
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println(“consumerTag:”+consumerTag);
System.out.println(“exchange:”+envelope.getExchange());
System.out.println(“RoutingKey:”+envelope.getRoutingKey());
System.out.println(“properties:”+properties);*/
System.out.println(“body:”+new String(body));//byte数组转string字符串
System.out.println(“将日志信息打印到控制台”);
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}


**Consumer\_PubSub2**

package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_PubSub2 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost(“192.168.101.22”);//ip地址默认localhost
factory.setPort(5672);//端口默认值5672
factory.setVirtualHost(“/itcast”);//虚拟机默认值 /虚拟机
factory.setUsername(“heima”);//用户名默认guest
factory.setPassword(“heima”);//密码默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.队列已经声明一次了，这里不用再声明队列
String queue1Name=“test_fanout_queue1”;
String queue2Name=“test_fanout_queue2”;
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：

queue：队列名称
autoAck: 是否自动确认
callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key…
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println(“consumerTag:”+consumerTag);
System.out.println(“exchange:”+envelope.getExchange());
System.out.println(“RoutingKey:”+envelope.getRoutingKey());
System.out.println(“properties:”+properties);*/
System.out.println(“body:”+new String(body));//byte数组转string字符串
System.out.println(“将日志信息保存数据库”);
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}


运行结果：


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/0cd46a942946495d96c439c33b64cc2a.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/331e0d18e4b84dd0a2bff93cb5d6b56d.png)


**（3）小结**


1. **交换机需要与队列进行绑定**，绑定之后；**一个消息可以被多个消费者都收到**。
2. 发布订阅模式与工作队列模式的区别：

 **工作队列模式不用定义交换机**，**而发布/订阅模式需要定义交换机**

 发布/订阅模式的生产方是**面向交换机发送消息**，工作队列模式的生产方是**面向队列发送消息**(**底层使用默认交换机**)

 发布/订阅模式**需要设置队列和交换机的绑定**，**工作队列模式不需要设置**，实际上**工作队列模式会将队列绑 定到默认的交换机**


##### 1.4 Routing 路由模式


**（1）模式说明**


* 队列与交换机的绑定，不能是任意绑定了，而是要指定一个 **RoutingKey**（路由key）
* 消息的发送方在向 Exchange 发送消息时，也必须**指定消息的 RoutingKey**
* Exchange 不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的Routingkey 与消息的 Routing key 完全一致，才会接收到消息


图解：


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/43159a3a33934670b299e80f4f2508f9.png)


* P：生产者，向 Exchange 发送消息，发送消息时，会指定一个routing key
* X：Exchange（交换机），接收生产者的消息，然后把消息递交给与 routing key 完全匹配的队列
* C1：消费者，其所在队列指定了需要 routing key 为 error 的消息
* C2：消费者，其所在队列指定了需要 routing key 为 info、error、warning 的消息


**（2）代码编写**


Producer\_Routing

package com.zwb.producer.routing;

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;

public class Producer_Routing {

public static void main(String[] args) throws IOException, TimeoutException {
    //1、创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2、设置参数
    //factory.setHost("192.168.1.100"); //默认localhost
    factory.setPort(5672);     //默认5672
    factory.setVirtualHost("/itcast"); //设置RabbitMQ服务器中的虚拟机，类似mysql数据库中的某一个库
    factory.setUsername("heima");
    factory.setPassword("heima");
    //3、创建连接Connection
    Connection connection = factory.newConnection();
    //4、创建Channel
    Channel channel = connection.createChannel();
    //5、创建交换机
       /\*

exchangeDeclare
(String exchange, 交换机名称
BuiltinExchangeType type, 交换机类型枚举类型
DIRECT(“direct”), ：定向
FANOUT(“fanout”), ：扇形（广播），发送消息到每一个与之绑定的队列
TOPIC(“topic”),：通配符方式
HEADERS(“headers”);参数匹配
boolean durable, 是否持久化
boolean autoDelete, 是否自动删除
boolean internal, 内部使用一般false
Map<String, Object> arguments) 参数列表
*/
String exchangeName = “test_direct”;
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,null);
//6、创建两个队列
String queue1Name=“test_direct_queue1”;
String queue2Name=“test_direct_queue2”;
/*
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: 参数
*/
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7、绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1.queue: 队列名称
2.exchange：交换机
3.routingKey：路由键：绑定规则
如果交换机的类型为fanout，routingKey设置为""
*/
//队列1
channel.queueBind(queue1Name,exchangeName,“error”);
//队列2
channel.queueBind(queue2Name,exchangeName,“info”);
channel.queueBind(queue2Name,exchangeName,“warning”);
channel.queueBind(queue2Name,exchangeName,“error”);
//8.发送消息
String body=“日志信息：张三调用了delete方法出错误了…日志级别：error”;
channel.basicPublish(exchangeName,“error”,null,body.getBytes());
//9.释放资源
channel.close();
connection.close();
}
}


Consumer\_Routing1

package com.zwb.consumer.routing;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Routing1 {

public static void main(String[] args) throws IOException, TimeoutException {
    //1、创建工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2、设置参数
    //factory.setHost("192.168.1.100"); //默认localhost
    factory.setPort(5672);//默认5672
    factory.setVirtualHost("/itcast");// 默认/
    factory.setUsername("heima");// heima
    factory.setPassword("heima");// heima
    //3、创建连接Connection
    Connection connection = factory.newConnection();
    //4、创建Channel
    Channel channel = connection.createChannel();
    //5.队列已经声明一次了，这里不用再声明队列
    String queue1Name="test\_direct\_queue1";
    String queue2Name="test\_direct\_queue2";
    //6.接收消息
    /\*

basicConsume(String queue, boolean autoAck, Consumer callback)
参数：

queue：队列名称
autoAck: 是否自动确认
callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key…
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println(“consumerTag:”+consumerTag);
System.out.println(“exchange:”+envelope.getExchange());
System.out.println(“RoutingKey:”+envelope.getRoutingKey());
System.out.println(“properties:”+properties);*/
System.out.println(“body:”+new String(body));//byte数组转string字符串
System.out.println(“将日志信息打印到控制台”);
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}


Consumer\_Routing2

package com.zwb.consumer.routing;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Routing2 {

public static void main(String[] args) throws IOException, TimeoutException {
    //1、创建工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2、设置参数
    //factory.setHost("192.168.1.100"); //默认localhost
    factory.setPort(5672);//默认5672
    factory.setVirtualHost("/itcast");// 默认/
    factory.setUsername("heima");// heima
    factory.setPassword("heima");// heima
    //3、创建连接Connection
    Connection connection = factory.newConnection();
    //4、创建Channel
    Channel channel = connection.createChannel();
    //5.队列已经声明一次了，这里不用再声明队列
    String queue1Name="test\_direct\_queue1";
    String queue2Name="test\_direct\_queue2";
    //6.接收消息
    /\*

basicConsume(String queue, boolean autoAck, Consumer callback)
参数：

queue：队列名称
autoAck: 是否自动确认
callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key…
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println(“consumerTag:”+consumerTag);
System.out.println(“exchange:”+envelope.getExchange());
System.out.println(“RoutingKey:”+envelope.getRoutingKey());
System.out.println(“properties:”+properties);*/
System.out.println(“body:”+new String(body));//byte数组转string字符串
System.out.println(“将日志信息打印到控制台”);
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}

}


**(3) 运行结果**


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/f20daae548eb4ffba4f5f131d11b8f96.png)


![  ](https://img-blog.csdnimg.cn/direct/7ca7176bc2c24ca3b61b96b49afcb52c.png)


**小结**


* **Routing 模式**：要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列


##### 1.5 Topics 通配符模式


**（1）模式说明**


* Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic  
 类型Exchange 可以让队列在绑定 Routing key 的时候使用通配符！
* Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
* 通配符规则：# 匹配一个或多个词，\* 匹配不多不少恰好1个词，例如：item.# 能够匹配 item.insert.abc 或者item.insert，item.\* 只能匹配 item.insert


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/b4d4197710ac4eb4a5c0bf63a0f7f546.png)


**图解：**


* 红色 Queue：绑定的是 usa.# ，因此凡是以 usa. 开头的 routing key 都会被匹配到
* 黄色 Queue：绑定的是 #.news ，因此凡是以 .news 结尾的 routing key 都会被匹配
* \***代表一个单词，#代表0个或者多个单词**


**（2）代码实现**


Producer\_Topics

package com.zwb.producer.topics;

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;

public class Producer_Topics {

public static void main(String[] args) throws IOException, TimeoutException {
    //1、创建连接工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2、设置参数
    //factory.setHost("192.168.1.100"); //默认localhost
    factory.setPort(5672);     //默认5672
    factory.setVirtualHost("/itcast"); //设置RabbitMQ服务器中的虚拟机，类似mysql数据库中的某一个库
    factory.setUsername("heima");
    factory.setPassword("heima");
    //3、创建连接Connection
    Connection connection = factory.newConnection();
    //4、创建Channel
    Channel channel = connection.createChannel();
    //5、创建交换机
       /\*

exchangeDeclare
(String exchange, 交换机名称
BuiltinExchangeType type, 交换机类型枚举类型
DIRECT(“direct”), ：定向
FANOUT(“fanout”), ：扇形（广播），发送消息到每一个与之绑定的队列
TOPIC(“topic”),：通配符方式
HEADERS(“headers”);参数匹配
boolean durable, 是否持久化
boolean autoDelete, 是否自动删除
boolean internal, 内部使用一般false
Map<String, Object> arguments) 参数列表
*/
String exchangeName = “test_topic”;
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,null);
//6、创建两个队列
String queue1Name=“test_topic_queue1”;
String queue2Name=“test_topic_queue2”;
/*
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: 参数
*/
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7、绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1.queue: 队列名称
2.exchange：交换机
3.routingKey：路由键：绑定规则
如果交换机的类型为fanout，routingKey设置为""
*/
//routing key：系统的名称，日志级别
//–需求：所有error级别的日志存入数据库，所有order系统的日志存入数据库
channel.queueBind(queue1Name,exchangeName,“#.error”);
channel.queueBind(queue1Name,exchangeName,“order.*”);
channel.queueBind(queue2Name,exchangeName,“*.*”);
//8.发送消息
String body=“日志信息：张三调用了findAll方法…日志级别：info”;
channel.basicPublish(exchangeName,“order.info”,null,body.getBytes());
//9.释放资源
channel.close();
connection.close();
}
}


Consumer\_Topic1

package com.zwb.consumer.topics;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Topic1 {

public static void main(String[] args) throws IOException, TimeoutException {
    //1、创建工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2、设置参数
    //factory.setHost("192.168.1.100"); //默认localhost
    factory.setPort(5672);//默认5672
    factory.setVirtualHost("/itcast");// 默认/
    factory.setUsername("heima");// heima
    factory.setPassword("heima");// heima
    //3、创建连接Connection
    Connection connection = factory.newConnection();
    //4、创建Channel
    Channel channel = connection.createChannel();
    //5.队列已经声明一次了，这里不用再声明队列
    String queue1Name="test\_topic\_queue1";
    String queue2Name="test\_topic\_queue2";
    //6.接收消息
    /\*

basicConsume(String queue, boolean autoAck, Consumer callback)
参数：

queue：队列名称
autoAck: 是否自动确认
callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key…
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println(“consumerTag:”+consumerTag);
System.out.println(“exchange:”+envelope.getExchange());
System.out.println(“RoutingKey:”+envelope.getRoutingKey());
System.out.println(“properties:”+properties);*/
System.out.println(“body:”+new String(body));//byte数组转string字符串
System.out.println(“将日志信息打印到控制台”);
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}

}


Consumer\_Topic2

package com.zwb.consumer.topics;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Topic2 {

public static void main(String[] args) throws IOException, TimeoutException {
    //1、创建工厂
    ConnectionFactory factory = new ConnectionFactory();
    //2、设置参数
    //factory.setHost("192.168.1.100"); //默认localhost
    factory.setPort(5672);//默认5672
    factory.setVirtualHost("/itcast");// 默认/
    factory.setUsername("heima");// heima
    factory.setPassword("heima");// heima
    //3、创建连接Connection
    Connection connection = factory.newConnection();
    //4、创建Channel
    Channel channel = connection.createChannel();
    //5.队列已经声明一次了，这里不用再声明队列
    String queue1Name="test\_topic\_queue1";
    String queue2Name="test\_topic\_queue2";
    //6.接收消息
    /\*

basicConsume(String queue, boolean autoAck, Consumer callback)
参数：

queue：队列名称
autoAck: 是否自动确认
callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key…
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println(“consumerTag:”+consumerTag);
System.out.println(“exchange:”+envelope.getExchange());
System.out.println(“RoutingKey:”+envelope.getRoutingKey());
System.out.println(“properties:”+properties);*/
System.out.println(“body:”+new String(body));//byte数组转string字符串
System.out.println(“将日志信息打印到控制台”);
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}


结果


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/5124400817944a0ba6b566e760698e3e.png)


**小结**


* Topic 主题模式可以实现 Pub/Sub 发布与订阅模式和 Routing 路由模式的功能，只是 Topic 在配置routing key 的时候可以使用通配符，显得更加灵活。


#### 2、工作模式总结


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/7fdddf6c99914f6292dac9a55a9e6a81.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/73aa2885063042a0bc9aee2a7698567f.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/faaae60798b24809b7760fc30d4e1f4c.png)


#### 3、SpringBoot 整合RabbitMQ


##### 3.1 生产者


1. 创建生产者SpringBoot工程
2. 引入start，依赖坐标

org.springframework.boot spring-boot-starter-amqp

3. 编写yml配置，基本信息配置
4. 定义交换机，队列以及绑定关系的配置类
5. 注入RabbitTemplate，调用方法，完成消息发送

 ![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/dddb03d9fb99427eae21d2495bcf74e8.png)

 **pom.xml**

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.15</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.rabiitmq</groupId>
<artifactId>producer-springboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>producer-springboot</name>
<description>producer-springboot</description>
<properties>
    <java.version>8</java.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

 **RabbitMQConfig.java**

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

public static final String EXCHANGE\_NAME="boot\_topic\_exchange";
public static final String QUEUE\_NAME="boot\_quque";

/\*

* 参数说明：
* id: bean的名称
* name：quque名称
* auto-declare:自动创建
* auto-delete: 自动删除，最后一个消费者和该队列断开连接后，自动删除队列
* durable:是否持久化
* exclusive:是否独占
*/

//1.交换机
@Bean("bootExchange")
public Exchange bootExchange(){
    return ExchangeBuilder.topicExchange(EXCHANGE\_NAME).durable(true).build();
}

//2.队列
@Bean("bootQueue")
public Queue bootQueue(){
    return QueueBuilder.durable(QUEUE\_NAME).build();
}

//3.队列和交换机的绑定关系
@Bean
public Binding binQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange){
    return  BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
}

}



 **ProducerSpringbootApplication**

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProducerSpringbootApplication {

public static void main(String[] args) {
    SpringApplication.run(ProducerSpringbootApplication.class, args);
}

}


**application.yml**

配置rabbitmq的基本信息 IP端口 username passwordspring:

spring:
rabbitmq:
host: localhost
port: 5672
virtual-host: /itcast
username: heima
password: heima


**ProducerTest**

import com.rabiitmq.config.RabbitMQConfig;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class ProducerSpringbootApplicationTests {

//1.注入rabbitTemplate
@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testSend(){
    rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE\_NAME,"boot.haha","这是springboot-rabbitmq的测试消息22");
}

}


测试：运行Junit Test


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/ab70cff753814c08af8f2cba8f53ab80.png)


##### 3.2 消费者


1. 创建消费者SpringBoot工程
2. 引入start，依赖坐标

org.springframework.boot spring-boot-starter-amqp

3. 编写yml配置，基本信息配置
4. 定义监听类，使用@RabbitListener注解完成队列监听。


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/1746f7deb19b474d8ba893d363eab71c.png)


**ConsumerSpringbootApplication**

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerSpringbootApplication {

public static void main(String[] args) {
    SpringApplication.run(ConsumerSpringbootApplication.class, args);
}

}


**RabbitMQListener.java**

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class RabbitMQListener {

@RabbitListener(queues = "boot\_quque")
public void ListenerQueue(Message message){
    System.out.println(new String(message.getBody()));
}

}


**application.yml**

配置rabbitmq的基本信息 IP端口 username passwordspring:

spring:
rabbitmq:
host: localhost
port: 5672
virtual-host: /itcast
username: heima
password: heima


**pom.xml**

org.springframework.boot spring-boot-starter-parent 2.5.15 com.rabbitmq consumer-springboot 0.0.1-SNAPSHOT consumer-springboot consumer-springboot

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

pringboot
0.0.1-SNAPSHOT
consumer-springboot
consumer-springboot

<java.version>8</java.version>

org.springframework.boot
spring-boot-starter-web

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>

[外链图片转存中…(img-vxMhPM8u-1714420139953)]
[外链图片转存中…(img-8024GqCK-1714420139954)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

2401_84183628

关注

7
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ实战学习

1.queue 队列名称2.durable 是否持久化，当mq重启之后，还在*是否独占：只能有一个消费者监听队列*当connection关闭时，是否删除队列4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉5.arguments: 参数*///如果没有一个名字为hello_world的队列，则会创建队列，如果有则不会创建//6.接收消息/*//发布订阅模式//发送消息//1.创建连接工厂。
复制链接

扫一扫