一、RabbitMQ介绍
-
**介绍:**由Rabbit公司基于Erlang语言开发的,支持多协议的、性能优秀的消息队列产品。一般消息队列,俗称 消息中间件。
-
**官网:**https://www.rabbitmq.com
-
主流消息中间件:
-
选择:
- 追求可用性:Kafka、 RocketMQ 、RabbitMQ
- 追求可靠性:RabbitMQ、RocketMQ
- 追求吞吐能力:RocketMQ、Kafka
- 追求消息低延迟:RabbitMQ、Kafka
-
结构:
1、publisher:生产者
用于生产消息的
2、consumer:消费者
用于消费消息的
3、exchange:交换机
按照指定的规则把消息路由到具体的队列
交换机只能路由信息,不能保存信息,如果路由失败则消息丢失
4、queue:队列
存储消息
5、VirtualHost:虚拟主机
对不同用户的 exchange、queue、消息 的进行隔离
- 自我理解:
RabbitMQ让消息的生产者与消费者断开联系,二者之间增加了一个Broker。
生产者只需要将通过一定的规则(交换机,路由密钥)将信息送到指定的队列。
消费者监听对应的队列,当队列有信息时,通过一定的规则判断是否可以拉取该信息。
二、RabbitMQ安装:
使用Docker在服务器安装
1,获取RabbitMQ的镜像
-
方式一:直接网上下载
docker pull rabbitmq:3-management
-
方式二:如果本地有,加载本地的tag文件(例如mq.tag)
docker load -i mq.tar
如果丢失镜像名称与版本,执行命令:
-
docker tag 自定义镜像名:自定义镜像版本 镜像ID
-
例如:docker tag rabbitmq:3-management 镜像ID
-
2,启动容器
docker run
-e RABBITMQ_DEFAULT_USER=用户名\ 【设置用户名与密码】
-e RABBITMQ_DEFAULT_PASS=密码
-v mq-plugins:/plugins \ 【数据卷】
–name mq \ 【容器名】
–hostname mq \ 【主机名】
–restart=always \ 【重启方式:跟随docker重启而重启】
-p 15672:15672 \ 【浏览器访问的ui界面端口】
-p 5672:5672 \ 【通信端口】
-d \ 【后台运行】
rabbitmq:3-management 【镜像名:镜像id】==========================================
docker run
-e RABBITMQ_DEFAULT_USER=root
-e RABBITMQ_DEFAULT_PASS=123456
-v mq-plugins:/plugins
–name mq
–hostname mq
–restart=always
-p 15672:15672
-p 5672:5672
-d
rabbitmq:3-management
三、RabbitMQ入门
1,原代码
先在服务器使用Dockers开启RabbitMQ
1.1,导入依赖
<!--AMQP依赖,包含RabbitMQ-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
1.2,发布消息
package cn.itcast.mq.helloworld;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
@SpringBootTest
public class PublisherTest {
@Test
public void testSendMessage() throws IOException, TimeoutException {
// 1.建立连接
ConnectionFactory factory = new ConnectionFactory();
// 1.1.设置连接参数,分别是:主机名、端口号、vhost、用户名、密码
factory.setHost("192.168.138.100");
factory.setPort(5672);
// 默认为你“/”
factory.setVirtualHost("/");
factory.setUsername("root");
factory.setPassword("123456");
// 1.2.建立连接
Connection connection = factory.newConnection();
// 2.创建通道Channel
Channel channel = connection.createChannel();
// 3.创建队列
String queueName = "mySimple.queue";
channel.queueDeclare(queueName, false, false, false, null);
// 4.发送消息
String message = "hello, rabbitmq!";
channel.basicPublish("", queueName, null, message.getBytes());
System.out.println("发送消息成功:【" + message + "】");
// 5.关闭通道和连接
channel.close();
connection.close();
}
}
1.3,接收消息
package cn.itcast.mq.helloworld;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class ConsumerTest {
public static void main(String[] args) throws IOException, TimeoutException {
// 1.建立连接
ConnectionFactory factory = new ConnectionFactory();
// 1.1.设置连接参数,分别是:主机名、端口号、vhost、用户名、密码
factory.setHost("192.168.138.100");
factory.setPort(5672);
factory.setVirtualHost("/");
factory.setUsername("root");
factory.setPassword("123456");
// 1.2.建立连接
Connection connection = factory.newConnection();
// 2.创建通道Channel
Channel channel = connection.createChannel();
// 3.创建队列
String queueName = "mySimple.queue";
channel.queueDeclare(queueName, false, false, false, null);
// 4.订阅消息
channel.basicConsume(queueName, true, new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body) throws IOException {
// 5.处理消息
String message = new String(body);
System.out.println("接收到消息:【" + message + "】");
System.out.println("envelope = " + envelope.getDeliveryTag());
System.out.println("envelope = " + envelope.getExchange());
System.out.println("envelope = " + envelope.getRoutingKey());
}
});
System.out.println("等待接收消息。。。。");
// 将主线程阻塞
// 因为RabbitMQ是异步的,线程结束的太快,看不到结果
System.in.read();
}
}
四、SpringAMQP
-
概述:SpringBoot整合RabbitMQ的模板,实际上就是一个起步依赖
-
网址:https://spring.io/projects/spring-amqp
-
依赖:
<!--AMQP依赖,包含RabbitMQ--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>
-
配置文件:
spring: rabbitmq: host: 192.168.138.100 # 主机名 port: 5672 # 端口 virtual-host: / # 虚拟主机 username: root # 用户名 password: 123456 # 密码
-
一些注意点:
- 交换机只能指定路由规则,不能存储消息
- 路由密钥(routingKey):在没有交换机的情况写队列名,有交换机的情况写按具体情况
1,Simple
单发。
没有交换机,或者可以说默认交换机【”空串“】
简单队列需要先创建好对应的消息队列。
1.1,图解:
1.2,生产者发送消息到队列
# 生产者向哪儿发送消息
spring:
rabbitmq:
host: 192.168.138.100 # 主机名
port: 5672 # 端口
virtual-host: / # 虚拟主机
username: root # 用户名
password: 123456 # 密码
package cn.itcast.mq.spring;
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 SpringAmqpTest {
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testSimpleQueue() {
// 队列名称
String queueName = "simple.queue";
// 消息
String message = "hello, spring amqp!";
// 发送消息
rabbitTemplate.convertAndSend(queueName, message);
}
}
1.3,消费者获取队列的消息
# 消费者从哪儿获取消息
spring:
rabbitmq:
host: 192.168.138.100 # 主机名
port: 5672 # 端口
virtual-host: / # 虚拟主机
username: root # 用户名
password: 123456 # 密码
package cn.itcast.mq.listener;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class SpringRabbitListener {
// 监听的队列名称
@RabbitListener(queues = "simple.queue")
public void listenSimpleQueueMessage(String msg) throws InterruptedException {
System.out.println("spring 消费者接收到消息:【" + msg + "】");
}
}
2,WorkQueue
可以让多个消费者绑定一个队列。
当消息开始积压的时候,就可以使用这个WorkQueue让多个消费者同时消费。
多个消费者之间时竞争的关系。
与Simple的区别就是多加了几个消费者。
1.1,图解
1.2,生产者发送信息
- 发送50条
/**
* workQueue
* 向队列中不停发送消息,模拟消息堆积。
*/
@Test
public void testWorkQueue() throws InterruptedException {
// 队列名称
String queueName = "simple.queue";
// 消息
String message = "hello, message";
for (int i = 0; i < 50; i++) {
// 发送消息
rabbitTemplate.convertAndSend(queueName, message + i);
Thread.sleep(20);
}
}
1.3,消费者获取信息
-
消费者一
@RabbitListener(queues = "simple.queue") public void listenWorkQueue1(String msg) throws InterruptedException { System.out.println("消费者1接收到消息:【" + msg + "】" + LocalTime.now()); // 模拟处理信息的时间 Thread.sleep(20); }
-
消费者二
@RabbitListener(queues = "simple.queue") public void listenWorkQueue1(String msg) throws InterruptedException { System.out.println("消费者1接收到消息:【" + msg + "】" + LocalTime.now()); // 模拟处理信息的时间 Thread.sleep(200); }
-
测试
1,通过测试,我们发现一个问题。
2,消费者一很快的处理完了25条信息,消费者二则在慢慢的处理25条信息。
3,这说明50条信息是平均分配给两个消费者的。
4,这是很不好的,因为不同服务器的性能是不一样的,我们希望性能好的处理的信息应该更多。
1.4,能者多劳
-
配置文件
spring: rabbitmq: listener: simple: prefetch: 1 # 每次只能获取一条消息,处理完成才能获取下一个消息
原本50条信息是队列平均分给两个消费者,配置上面属性后,
每个消费者一次只能获取一条信息,处理完后才能获取下一条信息。
3,Fanout
1,与上面相比,多了一个交换机。
2,消费者不在与队列直接绑定,消费者绑定交换机,并将信息发送给交换机。
3,交换机可以绑定多个队列,并将信息发送给所有的队列。
4,消费者监听队列获取信息,如果多个消费者监听一个队列,消费者之间是竞争关系。
1.1,图解
1.2,生产者发送信息
@Test
public void testFanoutExchange() {
// 交换机名称
String exchangeName = "exchange.fanout";
// 消息
String message = "hello, everyone!";
// Fanout没有路由密钥,所以使用【""】代替
rabbitTemplate.convertAndSend(exchangeName, "", message);
}
1.3,消费者接受信息(配置类方式)
-
配置类(在消费端配置)
当消费端有多个时,每个配置类声明交换机相同时只会创建一个。
package cn.itcast.mq.config; import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.FanoutExchange; import org.springframework.amqp.core.Queue; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class FanoutConfig { /** * 声明交换机 * @return Fanout类型交换机 */ @Bean public FanoutExchange fanoutExchange(){ // 交换机名称为【exchange.fanout】 return new FanoutExchange("exchange.fanout"); } // ======================================================================== /** * 第1个队列 - 消费者一 */ @Bean public Queue fanoutQueue1(){ // 队列名称【fanout.queue1】 return new Queue("fanout.queue1"); } /** * 绑定队列和交换机 */ @Bean public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){ return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange); } // ======================================================================== /** * 第2个队列 - 消费者二 */ @Bean public Queue fanoutQueue2(){ return new Queue("fanout.queue2"); } /** * 绑定队列和交换机 */ @Bean public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){ return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange); } }
-
接收信息
// 消费者一 @RabbitListener(queues = "fanout.queue1") public void listenFanoutQueue1(String msg) { System.out.println("消费者1接收到Fanout消息:【" + msg + "】"); }
// 消费者二 @RabbitListener(queues = "fanout.queue2") public void listenFanoutQueue2(String msg) { System.out.println("消费者2接收到Fanout消息:【" + msg + "】"); }
1.4 消费者接受信息(注解模式)
- 通过注解便不需要配置类
- 两个消费者交换机相同,队列不同
// 消费者一
@RabbitListener(bindings = @QueueBinding(
// 队列名称
value = @Queue(name = "fanout.queue1"),
// 交换机名称,交换机类型(加上)
exchange = @Exchange(name = "fanout.exchange", type = ExchangeTypes.FANOUT)
))
public void decr(String msg) throws InterruptedException {
System.out.println("消费者2接收到Fanout消息:【" + msg + "】");
}
// 消费者二
@RabbitListener(bindings = @QueueBinding(
// 队列名称
value = @Queue(name = "fanout.queue2"),
// 交换机名称,交换机类型(加上)
exchange = @Exchange(name = "fanout.exchange", type = ExchangeTypes.FANOUT)
))
public void decr(String msg) throws InterruptedException {
System.out.println("消费者2接收到Fanout消息:【" + msg + "】");
}
4,Direct
- 与上面基本相同,但是添加了路由密钥,交换机可以通过不同的密钥将信息发送给不同的队列,
不在将信息发送给所有队列。
- Topic交换机接收的消息RoutingKey必须是多个单词,以
**.**
分割
4.1,图解
4.2,发送信息
- 将信息发送给交换机
@Test
public void testSendDirectExchange() {
// 交换机名称
String exchangeName = "exchange.direct";
// 消息
String message = "红色警报!日本乱排核废水,导致海洋生物变异,惊现哥斯拉!";
// 发送消息, 发送的信息路由密钥是red
rabbitTemplate.convertAndSend(exchangeName, "red", message);
}
4.3,获取信息
- 消费者一
// 队列direct.queue1与交换机exchange.direct绑定
// 当交换机中信息的路由密钥是“red或者blue”时,获取信息。
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue1"),
exchange = @Exchange(name = "exchange.direct", type = ExchangeTypes.DIRECT),
key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
System.out.println("消费者接收到direct.queue1的消息:【" + msg + "】");
}
- 消费者二
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue2"),
exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
System.out.println("消费者接收到direct.queue2的消息:【" + msg + "】");
}
5,Topic
与Direct基本相同,只是添加了通配符。
#
:匹配一个或多个词
*
:匹配不多不少恰好1个词
5.1,图解
5.2,发送信息
@Test
public void testSendDirectExchange() {
// 交换机名称
String exchangeName = "exchange.direct";
// 消息
String message = "红色警报!日本乱排核废水,导致海洋生物变异,惊现哥斯拉!";
// 发送消息, 发送的信息路由密钥是red
rabbitTemplate.convertAndSend(exchangeName, "red.blue.green", message);
rabbitTemplate.convertAndSend(exchangeName, "blue.green", message);
rabbitTemplate.convertAndSend(exchangeName, "red.blue", message);
}
5.3,获取信息
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue2"),
exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
key = {"red.#", "*.blue"}
))
public void listenDirectQueue2(String msg){
System.out.println("消费者接收到direct.queue2的消息:【" + msg + "】");
}
五、消息转换器
-
在生产者与消费者都添加消息转换器,可以在发送与接受对象时统一处理,
在队列存储的消息是json字符串,不需要每次发送与接受单独处理。
依赖:
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.9.5</version>
</dependency>
配置类:
@Bean
public MessageConverter jsonMessageConverter(){
return new Jackson2JsonMessageConverter();
}