栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

SpringAMQP学习二(Basic Queue 简单队列模型、Work Queue 工作队列模型、发布、订阅模型-Fanout)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

SpringAMQP学习二(Basic Queue 简单队列模型、Work Queue 工作队列模型、发布、订阅模型-Fanout)

SpringAMQP学习二(Basic Queue 简单队列模型、Work Queue 工作队列模型、发布、订阅模型-Fanout)

SpringAMQP是基于RabbitMQ封装的一套模板,并且还利用SpringBoot对其实现了自动装配,使用起来非常方便。

SpringAmqp的官方地址:https://spring.io/projects/spring-amqp

SpringAMQP提供了三个功能:
  • 自动声明队列、交换机及其绑定关系
  • 基于注解的监听器模式,异步接收消息
  • 封装了RabbitTemplate工具,用于发送消息
1、Basic Queue 简单队列模型

在上一个RabitMQ的HelloWord工程中完成队列模型的快速入门

入门案例:消息发送
  1. 在父工程mq-demo中引入依赖
    
    
        org.springframework.boot
        spring-boot-starter-amqp
    
    
  2. 在publisher模块的application.yml配置文件中配置mq的连接信息
    # 配置mq的连接信息
    spring:
      rabbitmq:
        host: 192.168.26.131 # rabbitmq的宿主ip地址
        port: 5672 # 访问端口
        username: itcast
        password: 123321
        virtual-host: / # 虚拟主机
    
  3. 在publisher模块中建立一个测试类,编写测试方法
    package cn.itcast.mq.spring;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.amqp.rabbit.core.RabbitAdmin;
    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.SpringJUnit4ClassRunner;
    
    
    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringBootTest
    public class SpringAMQPTest {
        
        @Autowired
        RabbitTemplate rabbitTemplate;
    
        
        @Test
        public void testsendMessage() {
            // 队列名称
            String queueName = "simple.queue";
            // 队列内容
            String message = "hello,Spring AMQP";
            rabbitTemplate.convertAndSend(queueName,message);
        }
    }
    
    
  4. 测试运行成功后,访问rabbitmq管理查看队列消息,再运行接收的队列消息的程序
入门案例:消息接收 在consumer中编写消费逻辑,监听Simple.queued
  1. 在publisher模块的application.yml配置文件中配置mq的连接信息

    入上面的一样

  2. 创建一个``类型进行测试

    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 listenerSimpleQueue(String msg) {
            System.out.println("接收到simple.queue队列消息:"+msg);
        }
    }
    
    
  3. 启动springboot的main函数,查看接收的队列消息
测试结果
  1. 当我有两个消费者的时候,我发送一条消息,消费者同时运行,只能一个人接收,轮流来
  2. 单我没有运行消费者时,发送的队列消息不会缓存到rabbitmq中【可能是电脑问题,目前再次测试又可以了】
  3. 队列消息被接受之后就会销毁,不会被回溯
2、Work Queue 工作队列模型

Work queues,也被称为(Task queues),任务模型。简单来说就是让多个消费者绑定到一个队列,共同消费队列中的消息。

当消息处理比较耗时的时候,可能生产消息的速度会远远大于消息的消费速度。长此以往,消息就会堆积越来越多,无法及时处理。

此时就可以使用work 模型,多个消费者共同处理消息处理,速度就能大大提高了。

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

    @Test
    public void testsendWorkQueue() throws InterruptedException {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, message___";
        for (int i = 1; i <= 50;i++) {
            // 发送消息
            rabbitTemplate.convertAndSend(queueName, message+i);
            // 线程休眠
            Thread.sleep(20);
        }
    }
    
  2. 在consumer服务中定义两个信息监听者,都监听simple.queue队列【消费者】

    @RabbitListener(queues = "simple.queue")
    public void listenerworkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收的队列消息::"+msg +"当前接收消息时间为:"+ LocalDateTime.now());
        Thread.sleep(20);
    }
    
    @RabbitListener(queues = "simple.queue")
    public void listenerworkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2__________接收的队列消息::"+msg +"当前接收消息时间为:"+ LocalDateTime.now());
        Thread.sleep(200);
    }
    
  3. 消费者1每秒处理50条消息,消费者2每秒处理10条消息

  4. 启动测试

    启动ConsumerApplication后,在执行publisher服务中刚刚编写的发送测试方法testWorkQueue。

    可以看到消费者1很快完成了自己的25条消息。消费者2却在缓慢的处理自己的25条消息。

    也就是说消息是平均分配给每个消费者,并没有考虑到消费者的处理能力。这样显然是有问题的。

  5. 能者多劳分配

    在spring中有一个简单的配置,可以解决这个问题。我们修改consumer服务的application.yml文件,添加配置:

    spring:
      rabbitmq:
        listener:
          simple:
            prefetch: 1 # 每次只能获取一条消息,处理完成才能获取下一个消息
    

    再次运行测试就会发现,消费者一获取的消息会更多了,而消费者而就会量力而行

Work模型的使用:
  • 多个消费者绑定到一个队列,同一条消息只会被一个消费者处理
  • 通过设置prefetch来控制消费者预取的消息数量
发布/订阅

发布订阅的模型如图:

可以看到,在订阅模型中,多了一个exchange角色,而且过程略有变化:

  • Publisher:生产者,也就是要发送消息的程序,但是不再发送到队列中,而是发给X(交换机)
  • Exchange:交换机,图中的X。一方面,接收生产者发送的消息。另一方面,知道如何处理消息,例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作,取决于Exchange的类型。Exchange有以下3种类型:
    • Fanout:广播,将消息交给所有绑定到交换机的队列
    • Direct:定向,把消息交给符合指定routing key 的队列
    • Topic:通配符,把消息交给符合routing pattern(路由模式) 的队列
  • Consumer:消费者,与以前一样,订阅队列,没有变化
  • Queue:消息队列也与以前一样,接收消息、缓存消息。

Exchange(交换机)只负责转发消息,不具备存储消息的能力,因此如果没有任何队列与Exchange绑定,或者没有符合路由规则的队列,那么消息会丢失!

3、发布、订阅模型-Fanout

Fanout,英文翻译是扇出,我觉得在MQ中叫广播更合适。

在广播模式下,消息发送流程是这样的:

  • 1) 可以有多个队列
  • 2) 每个队列都要绑定到Exchange(交换机)
  • 3) 生产者发送的消息,只能发送到交换机,交换机来决定要发给哪个队列,生产者无法决定
  • 4) 交换机把消息发送给绑定过的所有队列
  • 5) 订阅队列的消费者都能拿到消息

我们的计划是这样的:

  • 创建一个交换机 itcast.fanout,类型是Fanout
  • 创建两个队列fanout.queue1和fanout.queue2,绑定到交换机itcast.fanout

声明队列和交换机

Spring提供了一个接口Exchange,来表示所有不同类型的交换机:

在consumer中创建一个类,声明队列和交换机:
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 {

    
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("zcl.fanout");
    }

    
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("zcl.queue1");
    }

    
    @Bean
    public Binding fanoutBinding(FanoutExchange fanoutExchange,Queue fanoutQueue1) {
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    
    @Bean
    public Queue fanoutQueue2() {
        return new Queue("zcl.queue2");
    }

    
    @Bean
    public Binding fanoutBinding2(FanoutExchange fanoutExchange,Queue fanoutQueue2) {
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}

启动springboot引导类,就可以到rabbitmq的管理页面查看消息了
  1. 查看交换机

  2. 查看队列

  3. 点击交换机查看绑定关系

在消费者中编写接收队列消息代码
@RabbitListener(queues = "zcl.queue1")
public void listenerFanoutQueue1(String msg) throws InterruptedException {
    System.out.println("消费者接收到了zcl.queue1队列消息:"+msg);
}

@RabbitListener(queues = "zcl.queue2")
public void listenerFanoutQueue2(String msg) throws InterruptedException {
    System.out.println("消费者接收到了zcl.queue2队列消息:"+msg);
}
重启消费者服务代码 编写消息发送者代码
@Test
public void testFanoutExchange(){
    String exchangeName = "zcl.fanout";
    String message = "hello, every one!";
    rabbitTemplate.convertAndSend(exchangeName,"",message);
}

这一次发送消息,两个队列都会接收到数据

总结

交换机的作用是什么?

  • 接收publisher发送的消息
  • 将消息按照规则路由到与之绑定的队列
  • 不能缓存消息,路由失败,消息丢失
  • FanoutExchange的会将消息路由到每个绑定的队列

声明队列、交换机、绑定关系的Bean是什么?

  • Queue
  • FanoutExchange
  • Binding
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/938926.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号