代码编织梦想

1、常见消息模型

  • 基本消息队列(BasicQueue)
  • 工作消息队列(WorkQueue)

发布订阅( Publish、Subscribe)

  • Fanout Exchange: 广播
  • Direct Exchange:路由
  • Topic Exchange:主题

2、快速入门

HelloWorld案例
官方的HelloWorld是基于最基础的消息队列模型来实现的,只包括三个角色:

  • publisher:消息发布者,将消息发送到队列queue
  • queue:消息队列,负责接受并缓存消息
  • consumer:订阅队列,处理队列中的消息

基本消息队列的消息发送流程:

1.建立connection
2.创建channel
3.利用channel声明队列
4.利用channel向队列发送消息

基本消息队列的消息接收流程:

1.建立connection
2.创建channel
3.利用channel声明队列
4.定义consumer的消费行为handle Delivery()

5.利用channel将消费者与队列绑定

3、SpringAMQP

3.1 什么是SpringAMQP

Advanced Message Queuing Protocol,是用于在应用程序或之间传递业务消息的开放标准。该协议与语言和平台无关,更符合微服务中独立性的要求。

Spring AMQP是基于AMQP协议定义的一套API规范,提供了模板来发送和接收消息。包含两部分,其中spring-amqp是基础抽象,spring-rabbit是底层的默认实现。

特征

  • 侦听器容器,用于星步处理入站消息
  • ·用于发送和接收消息的RabbitTemplate
  • · RabbitAdmin用于自动声明队列,交换和绑定

3.2 Basic Queue简单队列模型

案例

利用SpringAMQP实现HelloWorld中的基础消息队列功能
流程如下:
1.在父工程中引入spring-amqp的依赖

<! --AMQP依赖,包含RabbitMQ-->
<dependency>
	<groupId>org.springframework. boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2.在publisher服务中利用RabbitTemplate发送消息到simple.queue这个队列

1.在publisher服务中编写application.yml添加mq连接信息:

spring:
  rabbitmq:
    host: 192.168.44.128
    port: 5672
    username: beiyihang
    password: beiyihang
    virtual-host: /

2.在publisher服务中新建一个测试类,编写测试方法:

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void  testSendMessage2SimpleQueue(){
        String queueName = "simple.queue";
        String message = "hello,spring amqp";
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

SpringAMQP如何发送消息?

  • 引入amqp的starter依赖
  • 配置RabbitMQ地址
  • 利用RabbitTemplate的convertAndSend方法

3:在consumer中编写消费逻辑,监听simple.queue

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue" )
    public void listenSimpleQueue(String msg){
        System.out.println("消费者收到simple.queue的信息:【 " + msg + " 】");
    }
}

springAMQP如何接收消息?

  • 引入amqp的starter依赖
  • 配置RabbitMQ地址
  • 定义类,添加@Component注解
  • 类中声明方法,添加@RabbitListener注解,方法参数就时消息

注意:消息一旦消费就会从队列删除,RabbitMQ没有消息回溯功能

3.3 Work Queue工作队列模型

案例

模拟WorkQueue,实现一个队列绑定多个消费者
基本思路如下:
1.在publisher服务中定义测试方法,每秒产生50条消息,发送到simple.queue

@Test
    public void  testSendMessage2WorkSimpleQueue() throws InterruptedException {
        String queueName = "simple.queue";
        String message = "hello,beiyihang--";
        for (int i = 1; i <= 50; i++) {
            rabbitTemplate.convertAndSend(queueName, message + i);
            Thread.sleep(20);
        }
        rabbitTemplate.convertAndSend(queueName, message);
    }

2.在consumer服务中定义两个消息监听者,都监听simple.queue队列

 @RabbitListener(queues = "simple.queue" )
    public void listenWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1收到simple.queue的信息:【 " + msg + " 】" + LocalTime.now());
        Thread.sleep(20);
    }


    @RabbitListener(queues = "simple.queue" )
    public void listenWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2..........收到simple.queue的信息:【 " + msg + " 】" + LocalTime.now());
        Thread.sleep(200);
    }

3.4 发布、订阅模型-Fanout

发布订阅模式与之前案例的区别就是允许将同一消息发送给多个消费者。实现方式是加入了exchange(交换机)。

常见exchange类型包括:

  • Fanout:广播
  • Direct:路由
  • Topic:话题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RwFWUXFV-1679065071495)(C:\Users\27995\AppData\Roaming\Typora\typora-user-images\image-20230317151805896.png)]

注意:exchange负责消息路由,而不是存储,路由失败则消息丢失

案例

利用SpringAMQP演示Fanout Exchange的使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wfL1dK1j-1679065071497)(C:\Users\27995\AppData\Roaming\Typora\typora-user-images\image-20230317152049182.png)]

实现思路如下:
1.在consumer服务中,利用代码声明队列、交换机,并将两者绑定

@Configuration
public class FanoutConfig {
    // 声明交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("beiyihang.fanout");
    }

    // 声明队列1
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    // 绑定 交换机与队列1
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
   // 队列 2
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }
  // 绑定 队列2 与 交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder
                .bind(fanoutQueue2)
                .to(fanoutExchange);
    }

}

2。在consumer服务中,编写两个消费者方法,分别监听fanout.queue1和fanout.queue2

 @RabbitListener(queues = "fanout.queue1" )
    public void listenFanoutQueue1(String msg){
        System.out.println("消费者收到fanout.queue1的信息:【 " + msg + " 】");
    }

    @RabbitListener(queues = "fanout.queue2" )
    public void listenFanoutQueue2(String msg){
        System.out.println("消费者收到fanout.queue2的信息:【 " + msg + " 】");
    }

3.在publisher中编写测试方法,向itcast.fanout发送消息

@Test
    public void testSendFanoutExchange(){

        String exchangeName = "beiyihang.fanout";
        String message = " hallo ,every one";
        rabbitTemplate.convertAndSend(exchangeName, "" , message );
    }

3.5 发布、订阅模型-Direct

DirectExchange 会将接收到的消息根据规则路由到指定的Queue,因此称为路由模式( routes)

  • 每一个Queue都与Exchange设置一个BindingKey
  • 发布者发送消息时,指定消息的RoutingKey
  • Exchange将消息路由到BindingKey与消息RoutingKey一致的队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P4rEoEG0-1679065071498)(C:\Users\27995\AppData\Roaming\Typora\typora-user-images\image-20230317155537604.png)]

1.利用@RabbitListener声明Exchange、Queue、RoutingKey

@RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "beiyihang.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 = "beiyihang.direct", type = ExchangeTypes.DIRECT),
            key = { "red" , "yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者收到direct.queue2的信息:【 " + msg + " 】");
    }

2.在consumer服务中,编写两个消费者方法,分别监听direct.queue1和direct.queue2

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "beiyihang.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 = "beiyihang.direct", type = ExchangeTypes.DIRECT),
            key = { "red" , "yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者收到direct.queue2的信息:【 " + msg + " 】");
    }

3.在publisher中编写测试方法,向itcast. direct发送消息

    @Test
    public void testSendDirectExchange(){

        String exchangeName = "beiyihang.direct";
        String message = " hallo ,yellow!";
        rabbitTemplate.convertAndSend(exchangeName, "yellow" , message );
    }

描述下Direct交换机与Fanout交换机的差异?

  • Fanout交换机将消息路由给每一个与之绑定的队列.
  • Direct交换机根据RoutingKey判断路由给哪个队列
  • ·如果多个队列具有相同的RoutingKey,则与Fanout功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解?

  • @Queue
  • @Exchange

3.6 发布、订阅模型-Topic

TopicExchange与DirectExchange类似,区别在于routingKey必须是多个单词的列表,并且以**.**分割。

Queue与Exchange指定BindingKey时可以使用通配符:

  • #∶代指0个或多个单词
  • *∶代指一个单词

在这里插入图片描述

利用SpringAMQP演示TopicExchange的使用
实现思路如下:
1.并利用@RabbitListener声明Exchange、Queue、RoutingKey

@RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "beiyihang.topic", type = ExchangeTypes.TOPIC),
            key = { "china.#"}
    ))
    public void listenTopicQueue1(String msg){
        System.out.println("消费者收到topic.queue1的信息:【 " + msg + " 】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "beiyihang.topic", type = ExchangeTypes.TOPIC),
            key = { "#.news"}
    ))
    public void listenTopicQueue2(String msg){
        System.out.println("消费者收到topic.queue2的信息:【 " + msg + " 】");
    }

2.在consumer服务中,编写两个消费者方法,分别监听topic.queue1和topic.queue2

@RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "beiyihang.topic", type = ExchangeTypes.TOPIC),
            key = { "china.#"}
    ))
    public void listenTopicQueue1(String msg){
        System.out.println("消费者收到topic.queue1的信息:【 " + msg + " 】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "beiyihang.topic", type = ExchangeTypes.TOPIC),
            key = { "#.news"}
    ))
    public void listenTopicQueue2(String msg){
        System.out.println("消费者收到topic.queue2的信息:【 " + msg + " 】");
    }

3.在publisher中编写测试方法,向itcast. topic发送消息

@Test
public void testSendTopicExchange(){

    String exchangeName = "beiyihang.topic";
    String message = " 你好,北易航!";
    rabbitTemplate.convertAndSend(exchangeName, "china.news" , message );
}

3.7 消息转换器

测试发送Object类型消息

说明:

在SpringAMQP的发送方法中,接收消息的类型是Object,也就是说我们可以发送任意对象类型的消息,SpringAMQP会帮我们序列化为字节后发送。

Spring的对消息对象的处理是由org.springframework.amqp.support.converter.MessageConverter来处理的。而默认实现是SimpleMessageConverter,基于JDK的ObjectOutputStream完成序列化。
如果要修改只需要定义一个MessageConverter类型的Bean即可。推荐用JSON方式序列化,步骤如下:

<dependency>
	<groupId>com.fasterxml.jackson.dataformat</groupId>
	<artifactId>jackson-dataformat-xml</artifactId>
	<version>2.9.10</version>
</ dependency>

我们在publisher服务声明MessageConverter:

 @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
@Test
    public void testSendObjectQueue(){
        Map<String ,Object> msg = new HashMap<>();
        msg.put("name","北易航");
        msg.put("age","20");
        rabbitTemplate.convertAndSend("object.queue",msg);

    }
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_52889347/article/details/129629944