- RabbitMQ提供了6种工作模式,我们学习5种。这是今天的重点。
- AMQP 是协议,类比HTTP。
- JMS 是 API 规范接口,类比 JDBC。
二、RabbitMQ学习
1、五种工作模式
简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式
1.1 简单模式
上述的入门案例中其实使用的是如下的简单模式:
在上图的模型中,有以下概念:
- P:生产者,也就是要发送消息的程序
- C:消费者:消息的接收者,会一直等待消息到来
- queue:消息队列,图中红色部分。类似一个邮箱,可以缓存消息;生产者向其中投递消息,消费者从其中取出消息
代码示例:
依赖
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.6.0</version>
</dependency>
生产者:
package com.zwb.producer;
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\_HelloWorld {
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.创建队列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("hello\_world",true,false,false,null);
//6.发送消息
/\*
String exchange, String routingKey, boolean mandatory, byte[] body
参数:
1. exchange:交换机名称,简单模式下交换机会使用默认的 ""
2. routingKey: 路由名称
3. props: 配置信息
4. body: 发送消息数据
\*/
String body="hello rabbitmq----测试内容222";
channel.basicPublish("","hello\_world",null,body.getBytes());
//7、释放资源
/\*
channel.close();
connection.close();
\*/
}
}
消费者:
package com.zwb.consumer;
import com.rabbitmq.client.\*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer\_HelloWorld {
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、创建队列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("hello\_world",true,false,false,null);
//6、接收消息
/\*
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: 数据
\*/
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("hello\_world",true,consumer);
//关闭资源?不要,因为消费者要监听
}
}
1.2 work queues模式
(1)模式说明
- Work Queues:与入门程序的简单模式相比,多了一个或一些消费端,多个消费端共同消费同一个队列中的消息。(队列存在竞争关系,可以理解为抢红包)
- 应用场景:对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
(2)代码编写
Work Queues 与入门程序的简单模式的代码几乎是一样的。可以完全复制,并多复制一个消费者进行多个消费者同时对消费消息的测试。
Producer_WorkQueues
package com.itheima.producer;
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\_WorkQueues {
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.创建队列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.发送消息
/\*
String exchange, String routingKey, boolean mandatory, byte[] body
参数:
1. exchange:交换机名称,简单模式下交换机会使用默认的 ""
2. routingKey: 路由名称
3. props: 配置信息
4. body: 发送消息数据
\*/
for (int i = 1; i <=10; i++) {
String body=i+"hello rabbitmq----";
channel.basicPublish("","work\_queues",null,body.getBytes());
}
//7.释放资源
/\*channel.close();
connection.close();\*/
}
}
Consumer_WorkQueues1
package com.itheima.consumer;
import com.rabbitmq.client.\*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer\_WorkQueues1 {
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.创建队列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)
参数:
1. queue:队列名称
2. autoAck: 是否自动确认
3. 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);
//关闭资源?不要,因为消费者要监听
}
}
Consumer_WorkQueues2
package com.itheima.consumer;
import com.rabbitmq.client.\*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer\_WorkQueues2 {
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.创建队列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)
参数:
1. queue:队列名称
2. autoAck: 是否自动确认
3. 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
(4) 小结
- 在一个队列中如果有多个消费者,那么消费者之间对于同一个消息的关系是竞争的关系。
- Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如:短信服务部署多个,只需要有一个节点成功发送即可。
1.3 Pub/Sub 订阅模式
(1)模式说明
在订阅模型中,多了一个 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)
参数:
1. queue:队列名称
2. autoAck: 是否自动确认
3. 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)
参数:
1. queue:队列名称
2. autoAck: 是否自动确认
3. 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);
//关闭资源?不要,因为消费者要监听
}
}
运行结果:
(3)小结
- 交换机需要与队列进行绑定,绑定之后;一个消息可以被多个消费者都收到。
- 发布订阅模式与工作队列模式的区别:
工作队列模式不用定义交换机,而发布/订阅模式需要定义交换机
发布/订阅模式的生产方是面向交换机发送消息,工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)
发布/订阅模式需要设置队列和交换机的绑定,工作队列模式不需要设置,实际上工作队列模式会将队列绑 定到默认的交换机
1.4 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)代码编写
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)
参数:
1. queue:队列名称
2. autoAck: 是否自动确认
3. 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)
参数:
1. queue:队列名称
2. autoAck: 是否自动确认
3. 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) 运行结果
小结
- 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
图解:
- 红色 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)
参数:
1. queue:队列名称
2. autoAck: 是否自动确认
3. 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)
参数:
1. queue:队列名称
2. autoAck: 是否自动确认
3. 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);
//关闭资源?不要,因为消费者要监听
}
}
结果
小结
- Topic 主题模式可以实现 Pub/Sub 发布与订阅模式和 Routing 路由模式的功能,只是 Topic 在配置routing key 的时候可以使用通配符,显得更加灵活。
2、工作模式总结
3、SpringBoot 整合RabbitMQ
3.1 生产者
- 创建生产者SpringBoot工程
- 引入start,依赖坐标
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
- 编写yml配置,基本信息配置
- 定义交换机,队列以及绑定关系的配置类
- 注入RabbitTemplate,调用方法,完成消息发送
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);
}
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数大数据工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年大数据全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上大数据开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加VX:vip204888 (备注大数据获取)
lder.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);
}
}
**自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。**
**深知大多数大数据工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!**
**因此收集整理了一份《2024年大数据全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。**
[外链图片转存中...(img-wP9gWW95-1712858630560)]
[外链图片转存中...(img-0HidaGKf-1712858630561)]
[外链图片转存中...(img-5GLq3DO5-1712858630561)]
[外链图片转存中...(img-mM4cDhY5-1712858630561)]
[外链图片转存中...(img-Bjp8kj4k-1712858630562)]
**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上大数据开发知识点,真正体系化!**
**由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新**
**如果你觉得这些内容对你有帮助,可以添加VX:vip204888 (备注大数据获取)**
[外链图片转存中...(img-KzhZPj9U-1712858630562)]