视频地址:https://www.bilibili.com/video/BV1pa4y1x7Kc?p=7&spm_id_from=pageDriver
1、介绍 1.1RabbitMQMQ全称为Message Queus,即消息队列,RabbitMQ是由erlang语言开发,基于AMQP(Advanced Message Queue 高级消息队列协议)协议实现的消息队列,他是一种应用程序之间的通信方法,消息队列在分布式系统开发中应用非常广泛。
开发消息队列通常有如下应用场景:
1、任务异步处理将不需要同步 处理的并且耗时长的操作由消息队列通知消息接受方进行异步处理。提高了应用程序的响应时间。
2、应用程序解耦合MQ相当于一个中介,生产方通过MQ与消费者交互,它将应用程序进行解耦合。
市场上还有哪些消息队列?
ActiceMQ、RabbitMQ、ZeroMQ、Kafka、MetaMQ、RocketMQ、Redis
为什么要使用RabbitMQ呢?
1、使用简单,功能强大。
2、基于AMQP协议。
3、社区活跃,文档完善。
4、高并发性能好,这主要的益于Erlang语言。
5、Spring Boot默认已集成RabbitMQ。
2、快速入门 2.1 RabbitMQ的工作原理下图是RabbitMQ的基本结构:
==我的理解:==生产者(Producer)发送消息给中介(RabbitMQ)里的Excahnge(交换机),由交换机转发给指定的队列(Queue),消费者监听消息队列之后消息队列将消息转发给消费者,如果消费者还没监听,消息就存储在消息队列中。
组成部分说明如下:
- Broker :消息队列服务进程,此进程包括两个部分: Exchange和Queue。
- Exchange :消息队列交换机,按-定的规则将消息路由转发到某个队列,对消息进行过虑。
- Queue :消息队列,存储消息的队列,消息到达队列并转发给指定的消费方。
- Producer :消息生产者,即生产方客户端,生产方客户端将消费发送到MQ。
- Consumer :消息消费者,即消费方客户端,接收MQ转发的消息。
消息发布接收流程:
———发送消息———
1、生产者和Broker建立TCP连接。
2、生产者和Broker建 立通道。
3、生产者通过通道消息发送Broker ,由Exchange将消息进行转发。
4、Exchange将消息转发到指定的Queue (队列)
———接收消息———
1、消费者和Broker建立TCP连接
2、消费者和Broker建立通道
3、消费者监听指定的Queue (队列)
4、当有消息到达Queue时Broker默认将消息推送给消费者。
5、消费者接收到消息。
2.2 hello rabbitMQ一个生产者给一个队列发消息,一个消费者从这个队列取消息!
依赖
com.rabbitmq
amqp-client
5.14.2
org.springframework.boot
spring-boot-starter-logging
2.7.0
Producer01—生产者
package com.rabbitmq;
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 Producer01 {
//队列
private static final String QUEUE = "helloword2";
public static void main(String[] args) {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = connection.createChannel();
//声明队列,如果队列在mq中没有,则要创建
//String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments
channel.queueDeclare(QUEUE,true,false,false,null);
//发送消息
//参数:String exchange, String routingKey, BasicProperties props, byte[] body
//消息内容
String message = "hello world 小伙子";
channel.basicPublish("",QUEUE,null,message.getBytes());
System.out.println("send to mq" + message);
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭连接,先关闭通道
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
try {
connection.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Consumer01——消费者
package com.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer01 {
//队列
private static final String QUEUE = "helloword2";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE,true,false,false,null);
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String message = new String(body, "utf-8");
System.out.println("receive message" + message);
}
};
//监听队列
//参数:String queue, boolean autoAck, Consumer callback
channel.basicConsume(QUEUE,true,defaultConsumer);
}
}
2.3 总结
一、发送端执行流程
- 创建连接
- 创建通道
- 声明队列
- 发送消息
二、接收端
- 创建连接
- 创建通道
- 创建队列
- 监听队列
- 接收消息
- ack回复
RabbitMQ 有一下几种工作模式:
- Work queues 工作队列
- pubish/Subscribe 发布订阅
- Routing 路由
- Topics 通配符
- Header Header转发器
- RPC 远程过程调用
work queues与入门程序相比,多了一个消费者,两个消费者痛一个队列中的消息,它的特点如下:
一个生产者将消息发给一个队列
多个消费者共同监听一个队列的消息
消息不能被重复消费
rabbit采用轮询的方式将消息是平均的发给消费者
测试运行多个消费者,运行一个生产者会给一个消费者发送消息,再次运行会给另一个发消息,不会重复给一个消费者发送。
3.2 Publish/subscribe 工作模式: 发布订阅模式:1、一个生产者将消息发送给交换机
2、与交换机绑定的有多个队列,每个消费者监听自己的队列。
3、生产者将消息发给交换机,由交换机将消息转发到绑定此交换机的每个队列,每个绑定的队列都将接收到消息。
4、如果消息发给没有绑定队列的交换机上消息将丢失。
publish/subscribe与work queues有什么区别?1、publish/subcribe可以定义一个交换机绑定多个队列,一个消息可以发送个多个队列。
2、work queues无需定义交换机,一个消息一次只能发送给一个队列。
3、publish/subscribe比work queues的功能更强大,publish/subcribe也可以将多个消费者监听同一个队列实现work queues的功能。
代码 消费者——Producer02_publishpackage com.rabbitmq;
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 Producer02_publish {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";
public static void main(String[] args) {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = connection.createChannel();
//声明队列,如果队列在mq中没有,则要创建
//String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数:String exchange,String type
channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
//进行交换机和队列绑定
//参数:String queue.String exchange, String routingkey
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");
for (int i = 0; i < 5; i++) {
//消息内容
String message = "send inform message user" + i;
channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,message.getBytes());
System.out.println("send to mq" + message);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭连接,先关闭通道
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
try {
connection.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
生产者——Consumer02_subscribe_email
package com.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer02_subscribe_email {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
//进行交换机和队列绑定
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String message = new String(body, "utf-8");
System.out.println("receive message" + message);
}
};
//监听队列
//参数:String queue, boolean autoAck, Consumer callback
channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
}
}
生产者——Consumer02_subscribe_sms
package com.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer02_subscribe_sms {
//队列名称
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
//进行交换机和队列绑定
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String message = new String(body, "utf-8");
System.out.println("receive message" + message);
}
};
//监听队列
//参数:String queue, boolean autoAck, Consumer callback
channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
}
}
3.3 Routing
工作模式:
路由模式:
1、一个交换机绑定多个队列,每个队列设置routingkey,并且一个队列可以设置多个routingkey
2、每个消费者监听自己的队列
3、生产者将教习发给交换机,发送消息时需要指定routingKey的值,交换机来判断改routingKey的值和哪个队列的routingKey相等,如果相等则将消息转发给该队列。
Routing模式和Publish/subscibe的区别?
Publish/subscibe模式在绑定交换机时不需要指定routingkey,消息会发送到每个绑定交换机的队列
Routing模式要求队列在绑定交换机时需要指定routingkey(这就是队列routingkey),发送消息将消息发送到和routingkey的值相等的队列中。正如上图所示,每个队列可以指定多个routingkey,如果发送消息时指定routingkey为 “error‘ ,由于C1和C2的routingkey都是error,所有消息会给它俩都发送。
如果发送消息时指定routingkey为"info",则只有C2可以接收到消息。
所以,Routing模式更加强大,它可以实现Publish/subscibe的功能。
代码 生产者——Producer03_routingpackage com.rabbitmq;
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 Producer03_routing {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
private static final String ROUTINGKEY_EMAIL = "inform_email";
private static final String ROUTINGKEY_SMS = "inform_sms";
public static void main(String[] args) {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = connection.createChannel();
//声明队列,如果队列在mq中没有,则要创建
//String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数:String exchange,String type
channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
//进行交换机和队列绑定
//参数:String queue.String exchange, String routingkey
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,"inform");
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,"inform");
for (int i = 0; i < 3; i++) {
//发送消息的时候指定
String message = "send inform message user" + i;
channel.basicPublish(EXCHANGE_ROUTING_INFORM,"inform",null,message.getBytes());
System.out.println("send to mq" + message);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭连接,先关闭通道
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
try {
connection.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
消费者——Consumer03_routing_sms
package com.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer03_routing_sms {
//队列名称
private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String ROUTINGKEY_SMS = "inform_sms";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
//进行交换机和队列绑定
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String message = new String(body, "utf-8");
System.out.println("receive message" + message);
}
};
//监听队列
//参数:String queue, boolean autoAck, Consumer callback
channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
}
}
消费者——Consumer03_routing_email
package com.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer03_routing_email {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";
private static final String ROUTINGKEY_EMAIL = "inform_email";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
//进行交换机和队列绑定
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String message = new String(body, "utf-8");
System.out.println("receive message" + message);
}
};
//监听队列
//参数:String queue, boolean autoAck, Consumer callback
channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
}
}
3.4 Topics
工作模式:
路由模式:
1、一个交换可以绑定多个队列,每个队列可以设置一个或多个带统配符的routingkey。
2、生产者将消息发给交换机,交换机根据routingkey的值来匹配队列,匹配时采用统配符方式,匹配成功的 将消息转发到指定的队列。
Topocs与Routing的区别?
Topics和Routing的基本原理相同,即:生产者将消息给交换机根据routingkey将消息转发给与routingkey匹配的队列。
不同之处是:routingkey的匹配方式,Routing模式是相等匹配,topics模式是统配符匹配。
符号#:匹配一个或者多个词(每个词中间以.分隔,后面不论点多少都可以匹配),比如inform.#可以匹配inform.sms、inform.email、inform.email.sms 符号*:只能匹配一个词,比如inform.*可以匹配inform.sms、inform.email代码 生产者——Producer04_topics
package com.rabbitmq;
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 Producer04_topics {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
private static final String ROUTINGKEY_SMS = "inform.#.sms.#";
public static void main(String[] args) {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = connection.createChannel();
//声明队列,如果队列在mq中没有,则要创建
//String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
//参数:String exchange,String type
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//进行交换机和队列绑定
//参数:String queue.String exchange, String routingkey
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);
for (int i = 0; i < 5; i++) {
//发送消息的时候指定
String message = "send email inform message user" + i;
channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.email",null,message.getBytes());
System.out.println("send to mq" + message);
}
for (int i = 0; i < 3; i++) {
//发送消息的时候指定
String message = "send sms and email inform message user" + i;
channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms",null,message.getBytes());
System.out.println("send to mq" + message);
}
for (int i = 0; i < 3; i++) {
//发送消息的时候指定
String message = "send sms and email inform message user" + i;
channel.basicPublish(EXCHANGE_TOPICS_INFORM,"inform.sms.email",null,message.getBytes());
System.out.println("send to mq" + message);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//关闭连接,先关闭通道
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
try {
connection.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
消费者——Consumer04_topics_email
package com.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer04_topics_email {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//进行交换机和队列绑定
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_EMAIL);
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String message = new String(body, "utf-8");
System.out.println("receive message" + message);
}
};
//监听队列
//参数:String queue, boolean autoAck, Consumer callback
channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);
}
}
消费者——Consumer04_topics_sms
package com.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer04_topics_sms {
//队列名称
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
private static final String ROUTINGKEY_SMS = "inform.#.sms.#";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);//端口
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//设置虚拟机,一个mq服务可以设置多个虚拟机,每个虚拟机就相当于一个独立的mq
connectionFactory.setVirtualHost("/");
Connection connection = null;
//建立连接
connection = connectionFactory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
//声明一个交换机
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//进行交换机和队列绑定
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,ROUTINGKEY_SMS);
//实现消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id,mq在channel中永安里标识消息的id,可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String message = new String(body, "utf-8");
System.out.println("receive message" + message);
}
};
//监听队列
//参数:String queue, boolean autoAck, Consumer callback
channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
}
}
3.5 Header 模式
header模式与routing不同的地方在于,header模式取消routingkey,使用中的key/value(键值对)匹配队列。
案例:
根据用户的通知设置去通知用户,设置接收Email的用户只接收Email,设置sms的用户只接收sms,设置两种通知类型都接收的则两种通知都有效。
3.6 RPCRPC即客户端远程调用服务端的方法,使用MQ可以实现RPC的异步调用,基于Direct交换机实现,流程如下:
1、客户端即是生产者就是消费者,向RPC调用消息,同时监听RPC响应队列。
2、服务端监听RPC请求队列的消息,收到消息后执行服务端的方法,得到方法返回的结果
3、服务端将RPC 方法的结果发送到RPC响应队列
4、Spring整合RabbitMQ 4.1 环境搭建依赖:
org.springframework.boot spring-boot-starter-amqp org.springframework.boot spring-boot-starter-test org.springframework.boot spring-boot-starter-logging
配置:
server:
port: 44000
spring:
application:
name: test-tabbitmq-producer
rabbitmq:
host: 127.0.0.1
port: 5672
username: guest
password: guest
virtual-host: /
日志:
%d %-5level [%thread] %logger{0}: %msg%n %n ]]> 192.168.1.100:5672 admin admin / 36 false dataquality logstash true UTF-8 true NON_PERSISTENT true rabbit.logs queue true
注意:此注解@RunWith用不了导入以下两个依赖
代码 RabbitmqConfigjunit junit 4.12 test org.junit.jupiter junit-jupiter-api 5.6.3 test
package rabbitmq.config;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.Exchanger;
@Configuration
public class RabbitmqConfig {
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
public static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";
private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
private static final String ROUTINGKEY_SMS = "inform.#.sms.#";
//声明交换机
@Bean(EXCHANGE_TOPICS_INFORM)
public Exchanger EXCHANGER_TOPICS_INFORM(){
//durable(true)持久化,mq重启之后交换机还在
return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
}
//声明 QUEUE_INFORM_EMAIL 队列
@Bean(QUEUE_INFORM_EMAIL)
public Queue QUEUE_INFORM_EMAIL(){
return new Queue(QUEUE_INFORM_EMAIL);
}
// ROUTINGKEY_EMAIL 绑定交换机和队列,指定routingkey
@Bean
public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL)Queue queue,
@Qualifier(EXCHANGE_TOPICS_INFORM)Exchanger exchanger){
return BindingBuilder.bind((Exchange) queue).to((Exchange) exchanger).with(ROUTINGKEY_EMAIL).noargs();
}
// ROUTINGKEY_SMS 绑定交换机和队列,指定routingkey
@Bean
public Binding BINDING_ROUTINGKEY_SMS(@Qualifier(QUEUE_INFORM_SMS)Queue queue,
@Qualifier(EXCHANGE_TOPICS_INFORM)Exchanger exchanger){
return BindingBuilder.bind((Exchange) queue).to((Exchange) exchanger).with(ROUTINGKEY_SMS).noargs();
}
}
Producer05_topics_springboot
package com.rabbitmq;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import rabbitmq.config.RabbitmqConfig;
@SpringBootTest
@RunWith(SpringRunner.class)
public class Producer05_topics_springboot {
@Autowired(required = false)
RabbitTemplate rabbitTemplate;
// 使用rabbitTemplate
@Test
public void testSenEmail(){
String message = "send email message to user";
rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.email",message);
}
}
ReceiveHandler
@Component
public class ReceiveHandler {
@RabbitListener(queues = "#{rabbitmqConfig.QUEUE_INFORM_EMAIL}")
public void send_email(String msg, Message message, Channel channel){
System.out.println("receive message is:"+msg);
}
}



