目录
Spirng AMQP-----Fanout Exchange
Spirng AMQP-----Direct Exchange
Spirng AMQP-----Topic Exchange
RabbitMQ官网：Messaging that just works — RabbitMQ
MQ(MessageQueue)，中文是消息队列，字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。
RabbitMQ的基本结构：
RabbitMQ中的几个概念
- channel:操作MQ的工具
- exchange:路由消息到队列中
- queue:缓存消息
- virtual host:虚拟主机，是对queue、exchange等资源的逻辑分组
RabbitMQ的基本模型：
官网：https://www.rabbitmq.com/getstarted.html
直接发送到队列:
- 基本消息队列( BasicQueue)
- 工作消息队列( workQueue)
发布订阅(Publish、Subscribe)，发送到交换机，又根据交换机类型不同分为三种:
- Fanout Exchange:广播
- Direct Exchange:路由
- Topic Exchange:主题
注意:消息一旦消费就会从队列删除，RabbitMQ没有消息回溯功能(阅后即焚）
AMQP的基本概念
是用于在应用程序或之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中独立性的要求。
Spirng AMQP
是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。包含两部分，其中spring-amqp是基础抽象，spring-rabbit是底层的默认实现。
特征：
- 用于异步处理入站消息的侦听器容器
- RabbitTamplate发送和接收消息的模板
- RabbitAdmin，用于自动声明队列、交换和绑定
Spirng AMQP-----基本消息队列
消息发送者和消息消费者都需要导依赖
<!--AMQP依赖，包含RabbitMQ-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>消息发送者和消息消费者都需要在服务中编写mq的连接信息：
spring:
rabbitmq:
addresses: 192.168.80.128 #rabbitmq的ip地址
port: 5672 #端口
username: root
password: 147979
virtual-host: / #虚拟主机消息发送者
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void rabbittest() {
String queueName = "simple.queue";//队列的名称
Object message = "hello, spring amqp!";//消息
rabbitTemplate.convertAndSend(queueName,message);
}消息消费者
@Component
public class SpringRabbitmqListener {
@RabbitListener(queues = "simple.queue")//队列名称
public void listenerSimpleQueuer1(String msg) {
System.out.println("SimpleQueuer接受到的消息："+msg+"-----"+LocalTime.now());
}
}Spirng AMQP-----工作消息队列
工作队列，可以提高消息处理速度，避免队列消息堆积
消息发送者：模拟一秒发送50条消息
@Test
public void rabbittesttuo() throws InterruptedException {
String queueName = "simple.queue";//队列的名称
Object message = "hello, spring amqp!";//消息
for (int i = 0; i < 50; i++) {//模拟一秒发送50条消息
rabbitTemplate.convertAndSend(queueName,message+"------"+i);
Thread.sleep(20);
}
}消息消费者：通过睡眠来模拟每个消费者的性能
@RabbitListener(queues = "simple.queue")
public void listenerSimpleQueuer(String msg) throws InterruptedException {
System.out.println("SimpleQueuer接受到的消息："+msg+" "+LocalTime.now());
Thread.sleep(20);
}
@RabbitListener(queues = "simple.queue")
public void listenerWorkQueuer(String msg) throws InterruptedException {
System.err.println("WorkQueuer接受到的消息："+msg+" "+LocalTime.now());
Thread.sleep(100);
}结果：
结果并没有达到预期的能者多劳的效果，我们希望能力好的处理多的消息，但是却两个消费者平均分配了消息。
原因：RabiitMQ的消息预期机制，当有大量的消息进入队列是，队列会把消息进行投递，然后消费者不管能不能及时处理都会提前取走消息，因此两个消费者便平均分配了50条消息
解决方案：
消费者预取限制
修改application.yml文件，设置prefetch这个值，可以控制预取消息的上限
spring:
rabbitmq:
addresses: 192.168.80.128 #rabbitmq的ip地址
port: 5672 #端口
username: root
password: 147979
virtual-host: / #虚拟主机
listener:
simple:
prefetch: 5 #每次只能预取5条消息，处理完成才能接着预取SpringAMQP提供了声明交换机、队列、绑定关系的API，例如:
Spirng AMQP-----Fanout Exchange
Fanout Exchange会将接收到的消息路由到每一个跟其绑定的queue
消息发送者：向test.fanout 交换机发送消息
@Test
public void testSendFanoutExchange() {
String exchangeName = "test.fanout";//较好机名称
String queueName = "";//队列的名称
Object message = "hello, every one!";//消息
rabbitTemplate.convertAndSend(exchangeName,queueName,message);
}消费者利用代码声明队列、交换机，并将两者绑定
package cn.itcast.mq.config;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Map;
@Configuration
public class FanoutConfig {
//交换机 test.fanout
@Bean
public FanoutExchange fanoutExchange() {
return new FanoutExchange("test.fanout");
}
//队列 fanout.queue1
@Bean
public Queue fanoutQueue1() {
return new Queue("fanout.queue1");
}
//队列 fanout.queue1
@Bean
public Queue fanoutQueue2() {
return new Queue("fanout.queue2");
}
//绑定fanout.queue1队列到交换机
@Bean
public Binding fanoutbinding1(Queue fanoutQueue1,FanoutExchange fanoutExchange) {
//将fanoutQueue1绑定到fanoutExchange
return BindingBuilder
.bind(fanoutQueue1)
.to(fanoutExchange);
}
//绑定fanout.queue2队列到交换机
@Bean
public Binding fanoutbinding2(Queue fanoutQueue2,FanoutExchange fanoutExchange) {
//将fanoutQueue2绑定到fanoutExchange
return BindingBuilder
.bind(fanoutQueue2)
.to(fanoutExchange);
}
@Bean
public Queue ObjectQueue() {
return new Queue("Object.queue");
}
}
编写两个消费者方法，分别监听fanout.queue1和fanout.queue2
@RabbitListener(queues = "fanout.queue1")//队列名称
public void listenerfanoutQueuer1(String msg) throws InterruptedException {
System.err.println("fanoutQueuer1。。。接受到的消息："+msg+" "+LocalTime.now());
}
@RabbitListener(queues = "fanout.queue2")//队列名称
public void listenerfanoutQueuer2(String msg) throws InterruptedException {
System.err.println("fanoutQueuer2。。。接受到的消息："+msg+" "+LocalTime.now());
}结果：两个都能接收到消息
Spirng AMQP-----Direct Exchange
Direct比Fanout更加的灵活
- Direct交换机根据RoutingKey判断路由给哪个队列
- 如果多个队列具有相同的RoutingKey，则与Fanout功能类似
消息发送者
@Test
public void testSendDirectExchange() {
String exchangeName = "test.direct";//交换机机名称
String queueName = "yellow";//key名称
Object message = "hello, yellow!";//消息
rabbitTemplate.convertAndSend(exchangeName,queueName,message);
}消息消费者：利用@RabbitListener声明Exchange、Queue、RoutingKey
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "directQueue1"),//队列名称
//交换机类型,可以是字符串，也可以是ExchangeTypes枚举
exchange = @Exchange(name = "test.direct",type = "direct"),
key = {"red","blue"}
))
public void listenDirectQueue1(String msg) throws InterruptedException {
System.err.println("directQueue1。。。接受到的消息："+msg+" "+LocalTime.now());
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "directQueue2"),//队列名称
//交换机类型,可以是字符串，也可以是ExchangeTypes枚举
exchange = @Exchange(name = "test.direct",type = ExchangeTypes.DIRECT),
key = {"red","yellow"}
))
public void listenDirectQueue2(String msg) throws InterruptedException {
System.err.println("directQueue2。。。接受到的消息："+msg+" "+LocalTime.now());
}
Spirng AMQP-----Topic Exchange
TopicExchange与DirectExchange类似，区别在于routingKey必须是多个单词的列表，并且以“.”分割。Queue与Exchange指定BindingKey时可以使用通配符
消息发送者
@Test
public void testSendTopicExchange() {
String exchangeName = "test.topic";//交换机机名称
String queueName = "China.news";//key名称
Object message = "长得像小女孩的小女孩实际上就是个小女孩!";//消息
rabbitTemplate.convertAndSend(exchangeName,queueName,message);
}消息消费者：利用@RabbitListener声明Exchange、Queue、RoutingKey
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topicQueue1"),//队列名称
//交换机类型,可以是字符串，也可以是ExchangeTypes枚举
exchange = @Exchange(name = "test.topic",type = ExchangeTypes.TOPIC),
key = {"China.#"}
))
public void listenTopicQueue1(String msg) throws InterruptedException {
System.err.println("topicQueue1。。。接受到的消息："+msg+" "+LocalTime.now());
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topicQueue2"),//队列名称
//交换机类型,可以是字符串，也可以是ExchangeTypes枚举
exchange = @Exchange(name = "test.topic",type = ExchangeTypes.TOPIC),
key = {"#.news"}
))
public void listenTopicQueue2(String msg) throws InterruptedException {
System.err.println("topicQueue2。。。接受到的消息："+msg+" "+LocalTime.now());
}
消息转换器
在SpringAMQP的发送方法中，接收消息的类型是Object，也就是说我们可以发送任意对象类型的消息，SpringAMQP会帮我们序列化为字节后发送。
以发送一个map对象为例
@Test
public void testSendObjectQueue() {
Map<String,Object> map = new HashMap<>();
map.put("name","张三");
map.put("age",18);
rabbitTemplate.convertAndSend("Object.queue",map);
}springAMQP会使用jdk的序列化，但这种序列化性能比较差，安全性也比较差（如意出现注入的问题），消息体很大占用较大的内存空间
Spring的对消息对象的处理是由org.springframework.amqp.support.converter.MessageConverter来处理的。而默认实现是SimpleMessageConverter，基于JDK的ObjectOutputStream完成序列化。
如果要修改只需要定义一个MessageConverter类型的Bean即可。推荐用JSON方式序列化，步骤如下：
消费者和发送一样都需要引入依赖和修改序列化（保证数据编码一样）
引入json的依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
</dependencies>修改序列化
@Configuration
public class JsonSerializationConfig {
@Bean
public MessageConverter messageConverter() {
return new Jackson2JsonMessageConverter();
}
}现在就是json序列化的消息体了
这里以接收刚才的map对象为例
@RabbitListener(queues = "Object.queue")
public void ObjectQueue(Map<String,Object> map) {
System.err.println("Object.queue接受到的消息："+map);
}
923
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
