MQ全称为Message Queue,消息队列是应用程序和应用程序之间的通信方法。
为什么使用MQ?
在项目中,可将一些无需即时返回且耗时的操作提取出来,进行异步处理,而这种异步处理的方式大大的节省 了服务器的请求响应时间,从而提高了系统的吞吐量。
列通常有如下应用场景:
任务异步处理
将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。
应用程序解耦合
MQ相当于一个中介,生产方通过MQ与消费方交互,它将应用程序进行解耦合。
MQ是消息通信的模型;实现MQ的大致有两种主流方式:AMQP、JMS。
AMQP是一种协议,更准确的说是一种binary wire-level protocol(链接协议)。这是其和JMS的本质差别,AMQP 不从API层进行限定,而是直接定义网络交换的数据格式。
JMS即Java消息服务(JavaMessage Service)应用程序接口,是一个Java平台中关于面向消息中间件(MOM)的 API,用于在两个应用程序之间,或分布式系统中发送消息,进行异步通信。
AMQP 与 JMS 区别
市场上常见的消息队列有如下:
学习目标:能够说出什么是消息队列;为什么使用消息队列;常见产品有哪些
总结:
消息队列是应用程序之间的通信方法;无需即时返回的且耗时的操作进行异步处理从而提高系统的吞吐量;可以实现程序之间的解耦合。
RabbitMQ是由erlang语言开发,基于AMQP(Advanced Message Queue 高级消息队列协议)协议实现的消息队列,它是一种应用程序之间的通信方法,消息队列在分布式系统开发中应用非常广泛。
RabbitMQ官方地址:http://www.rabbitmq.com/
RabbitMQ提供了6种模式:简单模式,work模式,Publish/Subscribe发布与订阅模式,Routing路由模式,Topics 主题模式,RPC远程调用模式(远程调用,不太算MQ;不作介绍);
官网对应模式介绍:https://www.rabbitmq.com/getstarted.html
简单模式
work模式
Publish/Subscribe发布与订阅模式
Routing路由模式
Topics 主题模式
RPC远程调用模式(远程调用,不太算MQ;不作介绍)
学习目标:按照文档在本机安装windows版本RabbitMQ,并配置其用户和Virtual Hosts
解析:
总结:
安装上述的组件时候都需要使用以管理员身份运行。
学习目标:搭建RabbitMQ入门工程并配置对应的maven依赖
解析:
创建heima-rabbitmq的工程;用于测试RabbitMQ的消息收发。添加用于操作RabbitMQ的依赖。
<dependency>
<groupId>com.rabbitmqgroupId>
<artifactId>amqp-clientartifactId>
<version>5.6.0version>
dependency>
总结:
使用IDEA创建maven工程;使用了jdk1.8。在工程中的pom.xml文件中添加了上述的依赖。
学习目标:编写消息生产者代码,发送消息到队列
解析:
入门工程:生产者发送消息到RabbitMQ的队列(simple_queue);消费者可以从队列中获取消息。可以使用RabbitMQ的简单模式(simple)。
生产者实现发送消息的步骤:
总结:
package com.itheima.rabbitmq.simple;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
* 简单模式:发送消息
*/
public class Producer {
static final String QUEUE_NAME = "simple_queue";
public static void main(String[] args) throws Exception {
//1. 创建连接工厂(设置RabbitMQ的连接参数);
ConnectionFactory connectionFactory = new ConnectionFactory();
//主机;默认localhost
connectionFactory.setHost("localhost");
//连接端口;默认5672
connectionFactory.setPort(5672);
//虚拟主机;默认/
connectionFactory.setVirtualHost("/itcast");
//用户名;默认guest
connectionFactory.setUsername("heima");
//密码;默认guest
connectionFactory.setPassword("heima");
//2. 创建连接;
Connection connection = connectionFactory.newConnection();
//3. 创建频道;
Channel channel = connection.createChannel();
//4. 声明队列;
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否在不使用的时候队列自动删除
* 参数5:其它参数
*/
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//5. 发送消息;
String message = "你好!小兔纸。";
/**
* 参数1:交换机名称;如果没有则指定空字符串(表示使用默认的交换机)
* 参数2:路由key,简单模式中可以使用队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("已发送消息:" + message);
//6. 关闭资源
channel.close();
connection.close();
}
}
在设置连接工厂的时候;如果没有指定连接的参数则会有默认值;可以去设置虚拟主机。
学习目标:编写消息消费者代码,从队列中接收消息并消费
解析:
从RabbitMQ中队列(与生产者发送消息时的队列一致;simple_queue)接收消息;
实现消费者步骤:
总结:
package com.itheima.rabbitmq.simple;
import com.itheima.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
/**
* 简单模式;消费者接收消息
*/
public class Consumer {
public static void main(String[] args) throws Exception {
//1. 创建连接工厂;
//2. 创建连接;(抽取一个获取连接的工具类)
Connection connection = ConnectionUtil.getConnection();
//3. 创建频道;
Channel channel = connection.createChannel();
//4. 声明队列;
/**
* 参数1:队列名称
* 参数2:是否定义持久化队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否在不使用的时候队列自动删除
* 参数5:其它参数
*/
channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);
//5. 创建消费者(接收消息并处理消息);
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//接收到的消息
System.out.println("接收到的消息为:" + new String(body, "utf-8"));
}
};
//6. 监听队列
/**
* 参数1:队列名
* 参数2:是否要自动确认;设置为true表示消息接收到自动向MQ回复接收到了,MQ则会将消息从队列中删除;
* 如果设置为false则需要手动确认
* 参数3:消费者
*/
channel.basicConsume(Producer.QUEUE_NAME, true, defaultConsumer);
}
}
需要持续监听队列消息,所以不要关闭资源
上述的入门案例中中其实使用的是如下的简单模式:
在上图的模型中,有以下概念:
在rabbitMQ中消息者是一定要到某个消息队列中去获取消息的
学习目标:启动消费者和生产者,到RabbitMQ中查询队列并在消费者端IDEA控制台查看接收到的消息
解析:
生产者:发送消息到RabbitMQ队列(simple_queue)
消费者:接收RabbitMQ队列消息
总结:
简单模式:生产者发送消息到队列中,一个消费者从队列中接收消息。
在RabbitMQ中消费者只能从队列接收消息。
如果接收消息的消费者在同一个队列中有两个或多个时;
消息是如何分配的
?
Work Queues 与入门程序的 简单模式 相比,多了一个或一些消费端,多个消费端共同消费同一个队列中的消息。
应用场景:对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
学习目标:编写生产者、消费者代码并测试了解Work queues工作队列模式的特点
解析:
工作队列模式:在同一个队列中可以有多个消费者,消费者之间对于消息的接收是竞争关系。
生产者:发送30个消息
package com.itheima.rabbitmq.work;
import com.itheima.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author 嘿嘿嘿1212
* @version 1.0
* @date 2019/11/4 20:47
*/
public class Producer {
static final String QUEUE_NAME = "simple_queue";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
//创建频道
Channel channel = connection.createChannel();
//声明队列
/**
* 参数1:队列名称
* 参数2:是否定义持久队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否不使用的时候队列自动删除
* 参数5:其他参数
*/
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
//发送消息
for (int i = 1; i <= 30; i++) {
String message = "work模式 你好!大兔纸"+i;
//发送消息
/**
* 参数1:交换机名称;如果没有则指定空字符串(表示使用默认的交换机)
* 参数2:路由key,简单模式中可以使用队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("已发送消息:" + message);
}
//关闭资源
channel.close();
connection.close();
}
}
消费者:创建两个消费者监听同一个队列,查看两个消费者的接收消息是否存在重复。
package com.itheima.rabbitmq.work;
import com.itheima.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @author 嘿嘿嘿1212
* @version 1.0
* @date 2019/11/4 21:14
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
//2.创建连接:(抽取一个获取连接的工具类)
Connection connection = ConnectionUtil.getConnection();
//3.创建频道
final Channel channel = connection.createChannel();
//声明队列
/**
* 参数1:队列名称
* 参数2:是否定义持久队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否不使用的时候队列自动删除
* 参数5:其他参数
*/
channel.queueDeclare(ConnectionUtil.QUEUE_NAME, true, false, false, null);
channel.basicQos(1);
//创建消费者
DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
try {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//接收到的消息
System.out.println("1------接收到消息为" + new String(body, "utf-8"));
Thread.sleep(1000);
//确认消息
/**
* 参数1:消息id
* 参数2:false表示只有当前这条被处理
*/
channel.basicAck(envelope.getDeliveryTag(),false);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
/**
* 参数1:队列名
* 参数2:是否要自动确认:设置为true表示消息接收到自动向MQ回复收到了,MQ则会将消息从队列中删除;
* 如果设置为false则需要手动确认
* 参数3:消费者
*/
channel.basicConsume(Producer.QUEUE_NAME, true, defaultConsumer);
}
}
消费者2于消费者1无多大区别,仅仅是打印不同
总结:
在一个队列中如果有多个消费者,那么消费者之间对于同一个消息的关系是竞争的关系
工作队列模式:一个消息只能被一个消费者接收,其它消费者是不能接收到同一条消息的。
应用场景:可以在消费者端处理任务比较耗时的时候;添加对同一个队列的消费者来提高任务处理能力。
Exchange(交换机)只负责转发消息,不具备存储消息的能力,因此如果没有任何队列与Exchange绑定,或者没有符合路由规则的队列,那么消息会丢失
学习目标:说出订阅模式中的Exchange交换机作用以及交换机的三种类型
总结:
订阅模式与前面的两种模式比较:多了一个角色Exchange交换机,接收生产者发送的消息并决定如何投递消息到其绑定的队列;消息的投递决定于交换机的类型。
交换机类型:广播(fanout)、定向(direct)、通配符(topic)
交换机只做消息转发,自身不存储数据。
学习目标:编写生产者、消费者代码并测试了解Publish/Subscribe发布与订阅模式的特点
解析:
发布与订阅模式特点:一个消息可以被多个消费者接收;其实是使用了订阅模式,交换机类型为:fanout广播
生产者(发送10个消息)
package com.itheima.rabbitmq.ps;
import com.itheima.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 分布与订阅模式:发送消息
*
* @author 嘿嘿嘿1212
* @version 1.0
* @date 2019/11/4 20:47
*/
public class Producer {
/**
* 交换机名称
*/
static final String FANOUT_EXCHANGE = "fanout_exchange";
/**
* 队列名称
*/
static final String FANOUT_QUEUE_1 = "fanout_queue_1";
/**
* 队列名称
*/
static final String FANOUT_QUEUE_2 = "fanout_queue_2";
public static void main(String[] args) throws IOException, TimeoutException {
//获取链接
Connection connection = ConnectionUtil.getConnection();
//创建频道
Channel channel = connection.createChannel();
//声明交换机:参数1:交换机名称,参数2:交换机类型(fanout,direct,topic)
channel.exchangeDeclare(FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);
//声明队列
/**
* 参数1:队列名称
* 参数2:是否定义持久队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否不使用的时候队列自动删除
* 参数5:其他参数
*/
channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null);
channel.queueDeclare(FANOUT_QUEUE_2, true, false, false, null);
//5.队列绑定到交换机:参数1:队列名称,参数2:交换机名称,参数3:路由key
channel.queueBind(FANOUT_QUEUE_1, FANOUT_EXCHANGE, "");
channel.queueBind(FANOUT_QUEUE_2, FANOUT_EXCHANGE, "");
//发送消息
for (int i = 1; i <= 10; i++) {
String message = "你好!大兔纸,发布订阅模式---" + i;
/**
* 参数1:交换机名称;如果没有则指定空字符串(表示使用默认的交换机)
* 参数2:路由key,简单模式中可以使用队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(FANOUT_EXCHANGE, "", null, message.getBytes());
System.out.println("已发送消息:" + message);
}
//关闭资源
channel.close();
connection.close();
}
}
消费者(至少两个消费者)
package com.itheima.rabbitmq.ps;
import com.itheima.rabbitmq.util.ConnectionUtil;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* 发布于订阅模式:消费者接收消息
*
* @author 嘿嘿嘿1212
* @version 1.0
* @date 2019/11/4 21:14
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
//获取连接:(抽取一个获取连接的工具类)
Connection connection = ConnectionUtil.getConnection();
//创建频道
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);
//声明队列
/**
* 参数1:队列名称
* 参数2:是否定义持久队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否不使用的时候队列自动删除
* 参数5:其他参数
*/
channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null);
//将队列绑定到交换机上
channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHANGE, "");
//创建消费者(接收消息并处理消息)
DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//接收到的消息
System.out.println("接收到消息为" + new String(body, "utf-8"));
}
};
//监听队列
/**
* 参数1:队列名
* 参数2:是否要自动确认:设置为true表示消息接收到自动向MQ回复收到了,MQ则会将消息从队列中删除;
* 如果设置为false则需要手动确认
* 参数3:消费者
*/
channel.basicConsume(Producer.FANOUT_QUEUE_1, true, defaultConsumer);
}
}
消费者2与消费者1的区别为消息队列名不同
总结:
发布与订阅模式:一个消息可以被多个消费者接收;一个消费者对于的队列,该队列只能被一个消费者监听。使用了订阅模式中交换机类型为:广播。
绑定同一交换机,并且每个队列只有一个消费者的不同消费者与生产者组成发布订阅模式
路由模式特点:
学习目标:编写生产者、消费者代码并测试了解Routing路由模式的特点
解析:
生产者:发送两条消息(路由key分别为:insert、update)
/**
* 路由模式:发送消息
*
* @author 嘿嘿嘿1212
* @version 1.0
* @date 2019/11/4 20:47
*/
public class Producer {
/**
* 交换机名称
*/
static final String DIRECT_EXCHANGE = "direct_exchange";
/**
* 队列名称
*/
static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
/**
* 队列名称
*/
static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";
public static void main(String[] args) throws IOException, TimeoutException {
//获取链接
Connection connection = ConnectionUtil.getConnection();
//创建频道
Channel channel = connection.createChannel();
//声明交换机:参数1:交换机名称,参数2:交换机类型(fanout,direct,topic)
channel.exchangeDeclare(DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);
//声明队列
/**
* 参数1:队列名称
* 参数2:是否定义持久队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否不使用的时候队列自动删除
* 参数5:其他参数
*/
channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);
//5.队列绑定到交换机:参数1:队列名称,参数2:交换机名称,参数3:路由key
channel.queueBind(DIRECT_QUEUE_INSERT, DIRECT_EXCHANGE, "insert");
channel.queueBind(DIRECT_QUEUE_UPDATE, DIRECT_EXCHANGE, "update");
//发送消息
String message = "你好!大兔纸,路由模式:routing key为insert";
/**
* 参数1:交换机名称;如果没有则指定空字符串(表示使用默认的交换机)
* 参数2:路由key,简单模式中可以使用队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(DIRECT_EXCHANGE, "insert", null, message.getBytes());
System.out.println("已发送消息:" + message);
//发送消息
message = "你好!大兔纸,路由模式:routing key 为update";
/**
* 参数1:交换机名称;如果没有则指定空字符串(表示使用默认的交换机)
* 参数2:路由key,简单模式中可以使用队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(DIRECT_EXCHANGE, "update", null, message.getBytes());
System.out.println("已发送消息:" + message);
//关闭资源
channel.close();
connection.close();
}
}
注意消息路由key值,绑定到交换机上的key值与交换器的类型
消费者:创建两个消费者,监听的队列分别绑定路由key为:insert
、update
消息中路由key为insert的会被绑定路由key为insert的队列接收并被其监听的消费者接收、处理;
/**
* 路由模式:消费者接收消息
*
* @author 嘿嘿嘿1212
* @version 1.0
* @date 2019/11/4 21:14
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
//获取连接:(抽取一个获取连接的工具类)
Connection connection = ConnectionUtil.getConnection();
//创建频道
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);
//声明队列
/**
* 参数1:队列名称
* 参数2:是否定义持久队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否不使用的时候队列自动删除
* 参数5:其他参数
*/
channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);
//将队列绑定到交换机上
channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHANGE, "insert");
//创建消费者(接收消息并处理消息)
DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//接收到的消息
System.out.println("接收到消息为" + new String(body, "utf-8"));
}
};
//监听队列
/**
* 参数1:队列名
* 参数2:是否要自动确认:设置为true表示消息接收到自动向MQ回复收到了,MQ则会将消息从队列中删除;
* 如果设置为false则需要手动确认
* 参数3:消费者
*/
channel.basicConsume(Producer.DIRECT_QUEUE_INSERT, true, defaultConsumer);
}
}
注意声明的交换机类型,队列绑定交换机的key值
消息中路由key为update的会被绑定路由key为update的队列接收并被其监听的消费者接收、处理;
与消费者1,只有队列名与key值不同
总结:
Routing 路面模式要求队列绑定到交换机的时候指定路由key;消费发送时候需要携带路由key;只有消息的路由key与队列路由key完全一致才能让该队列接收到消息。
Topic 类型与 Direct 相比,都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型 Exchange 可以让队列在绑定 Routing key 的时候使用通配符!
Routingkey 一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如: item.insert
通配符规则:
# :匹配一个或多个词
* :匹配不多不少恰好1个词
举例:
item.# :能够匹配 item.insert.abc 或者 item.insert
item.* :只能匹配 item.insert
学习目标:编写生产者、消费者代码并测试了解Topics通配符模式的特点
解析:
生产者:发送包含有item.insert、item.update,item.delete的3中路由key消息
/**
* 通配符模式:发送消息
*
* @author 嘿嘿嘿1212
* @version 1.0
* @date 2019/11/4 20:47
*/
public class Producer {
/**
* 交换机名称
*/
static final String TOPIC_EXCHANGE = "topic_exchange";
/**
* 队列名称
*/
static final String TOPIC_QUEUE_1 = "topic_queue_1";
/**
* 队列名称
*/
static final String TOPIC_QUEUE_2 = "topic_queue_2";
public static void main(String[] args) throws IOException, TimeoutException {
//获取链接
Connection connection = ConnectionUtil.getConnection();
//创建频道
Channel channel = connection.createChannel();
//声明交换机:参数1:交换机名称,参数2:交换机类型(fanout,direct,topic)
channel.exchangeDeclare(TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);
//发送消息
String message = "商品新增。通配符模式 ;routing key 为 item.insert ";
/**
* 参数1:交换机名称;如果没有则指定空字符串(表示使用默认的交换机)
* 参数2:路由key,简单模式中可以使用队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE, "item.insert", null, message.getBytes());
System.out.println("已发送消息:" + message);
//发送消息
message = "商品修改。通配符模式 ;routing key 为 item.update ";
/**
* 参数1:交换机名称;如果没有则指定空字符串(表示使用默认的交换机)
* 参数2:路由key,简单模式中可以使用队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE, "item.update", null, message.getBytes());
System.out.println("已发送消息:" + message);
//发送消息
message = "商品删除。通配符模式 ;routing key 为 item.delete ";
/**
* 参数1:交换机名称;如果没有则指定空字符串(表示使用默认的交换机)
* 参数2:路由key,简单模式中可以使用队列名称
* 参数3:消息其它属性
* 参数4:消息内容
*/
channel.basicPublish(TOPIC_EXCHANGE, "item.delete", null, message.getBytes());
System.out.println("已发送消息:" + message);
//关闭资源
channel.close();
connection.close();
}
}
注意没有绑定队列,而是直接发送消息并给消息绑定了消息key值
,注意交换机的类型
消费者1:监听的队列绑定到交换机的路由key为:item.update,item.delete
/**
* 通配符模式:消费者接收消息
*
* @author 嘿嘿嘿1212
* @version 1.0
* @date 2019/11/4 21:14
*/
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
//获取连接:(抽取一个获取连接的工具类)
Connection connection = ConnectionUtil.getConnection();
//创建频道
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);
//声明队列
/**
* 参数1:队列名称
* 参数2:是否定义持久队列(消息会持久化保存在服务器上)
* 参数3:是否独占本连接
* 参数4:是否不使用的时候队列自动删除
* 参数5:其他参数
*/
channel.queueDeclare(Producer.TOPIC_QUEUE_1, true, false, false, null);
//将队列绑定到交换机上
channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHANGE, "item.insert");
channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHANGE, "item.update");
//创建消费者(接收消息并处理消息)
DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//接收到的消息
System.out.println("接收到消息为" + new String(body, "utf-8"));
}
};
//监听队列
/**
* 参数1:队列名
* 参数2:是否要自动确认:设置为true表示消息接收到自动向MQ回复收到了,MQ则会将消息从队列中删除;
* 如果设置为false则需要手动确认
* 参数3:消费者
*/
channel.basicConsume(Producer.TOPIC_QUEUE_1, true, defaultConsumer);
}
}
区别:交换机的类型为TOPIC,队列绑定交换机时,指定的路由key为对应信息key值进行通配
,多条绑定路由key可以实现,一个队列绑定多个路由key.
消费者2:监听的队列绑定到交换机的路由key为:item.*
//将队列绑定到交换机上
channel.queueBind(Producer.TOPIC_QUEUE_2, Producer.TOPIC_EXCHANGE, "item.*");
与消费者1的主要区别:队列绑定交换机时,指定的队列路由key为使用了通配符
,减少多次绑定,避免了不必要的重复代码
总结:
Topics通配符模式:可以根据路由key将消息传递到对应路由key的队列;队列绑定到交换机的路由key可以有多个;通配符模式中路由key可以使用 *
和 #
;使用了通配符模式之后对于路由Key的配置更加灵活。
学习目标:对比总结RabbitMQ的5种模式特征
总结:
多个
消费者监听该队列;一个消息只能被一个消费者接收,消费者之间是竞争关系绑定
了该交换机的队列一致
的话那么该队列可以接收到消息匹配
的话那么该队列可以接收到消息学习目标:创建springboot-rabbitmq-producer工程用于生产消息;创建springboot-rabbitmq-consumer工程用于接收消息
解析:
Spring Boot提供了对于AMQP的整合;可以使用RabbitTemplate发送消息;可以使用@RabbitListener注解接收消息。
生产者工程springboot-rabbitmq-producer:发送消息
消费者工程springboot-rabbitmq-consumer:接收消息
总结:
可以使用插件自动生产Spring Boot工程的启动引导类Application.java和配置文件application.yml
学习目标:配置springboot-rabbitmq-producer工程的RabbitMQ,一个交换机、队列并绑定
解析:
使用通配符模式:将队列绑定到交换机(topic)时需要指定路由key(item.#)
总结:
配置application.yml文件
spring:
rabbitmq:
host: localhost
port: 5672
virtual-host: /itcast
username: heima
password: heima
配置交换机、队列和绑定,创建一个配置类
@Configuration
public class RabbitMQConfig {
//交换机名称
public static final String ITEM_TOPIC_EXCHANGE = "item_topic_exchange";
//队列名称
public static final String ITEM_QUEUE = "item_queue";
//声明交换机
@Bean("itemTopicExchange")
public Exchange topicExchange(){
return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).durable(true).build();
}
//声明队列
@Bean("itemQueue")
public Queue itemQueue(){
return QueueBuilder.durable(ITEM_QUEUE).build();
}
//将队列绑定到交换机
@Bean
public Binding itemQueueExchange(@Qualifier("itemQueue") Queue queue,
@Qualifier("itemTopicExchange")Exchange exchange){
return BindingBuilder.bind(queue).to(exchange).with("item.#").noargs();
}
}
学习目标:配置springboot-rabbitmq-consumer工程的RabbitMQ,编写消息监听器接收消息
解析:
总结:
配置application.yml文件;与生产者工程一致
编写监听器类
@Component
public class MyListener {
/**
* 接收队列消息
* @param message 接收到的消息
*/
@RabbitListener(queues = "item_queue")
public void myListener1(String message){
System.out.println("消费者接收到消息:" + message);
}
}
接收消息的队列名称要与生产者发送消息时的队列名称一致
学习目标:生产者编写测试类RabbitMQTest发送消息到交换机和特定的路由(item.insert,item.update,item.delete)
解析:
生产者:编写测试类RabbitMQTest,利用RabbitTemplate发送3条消息,这3条消息的路由key分别是item.insert,item.update,item.delete
消费者:在IDEA控制台查看是否能接收到符合路由key的消息
总结:
编写测试类如下:
package com.itheima.rabbitmq;
import com.itheima.rabbitmq.config.RabbitMQConfig;
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;
@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitMQTest {
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void test(){
rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,
"item.insert", "商品新增,路由Key为item.insert");
rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,
"item.update", "商品新增,路由Key为item.update");
rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,
"item.delete", "商品新增,路由Key为item.delete");
rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,
"a.item.delete", "商品新增,路由Key为a.item.delete");
}
}
先启动测试类进行声明交换机、队列和绑定;之后再启动消费者工程接收消息。