首页 > 软件编程 > Java > SpringBoot 整合RabbitMq 自定义消息监听容器来实现消息批量处理

SpringBoot 整合RabbitMq 自定义消息监听容器来实现消息批量处理

福牛 4月 04, 2023 40 0

SpringBoot 整合RabbitMq 自定义消息监听容器来实现消息批量处理

前言

RabbitMQ是一种常用的消息队列，Spring Boot对其进行了深度的整合，可以快速地实现消息的发送和接收。在RabbitMQ中，消息的发送和接收都是异步的，因此需要使用监听器来监听消息的到来。Spring Boot中提供了默认的监听器容器，但是有时候我们需要自定义监听器容器，来满足一些特殊的需求，比如批量获取数据。

-1

在本文中，我们将使用Spring Boot来整合RabbitMQ，并自定义一个监听器容器，实现批量获取数据的功能。
前置条件：
在开始之前，您需要具备以下条件：

  • 已经安装好RabbitMQ服务器并启动。
  • 已经创建好要使用的队列。
  • 已经熟悉了Spring Boot和RabbitMQ的基本知识。

环境准备：
在开始之前，我们需要准备好以下环境：

  • JDK 1.8或以上版本
  • Spring Boot 2.5.0或以上版本
  • RabbitMQ 3.8.0或以上版本

添加依赖

首先，在pom.XML文件中添加以下依赖：

  1. <dependency>
  2.      <groupId>org.springframework.boot</groupId>
  3.      <artifactId>spring-boot-starter-amqp</artifactId>
  4. </dependency>

配置文件

接下来，在application.properties文件中添加以下配置：

  1. spring.rabbitmq.host=localhost
  2. spring.rabbitmq.port=5672
  3. spring.rabbitmq.username=guest
  4. spring.rabbitmq.password=guest
  5. spring.rabbitmq.virtual–host=/
  6.  
  7. # 队列名称
  8. spring.rabbitmq.listener.simple.queue–name=myQueue
  9.  
  10. # 最大并发消费者数量
  11. spring.rabbitmq.listener.simple.concurrency=5
  12.  
  13. # 最小数量
  14. spring.rabbitmq.listener.simple.min–concurrency=1
  15.  
  16. # 最大数量
  17. spring.rabbitmq.listener.simple.max–concurrency=10
  18.  
  19. # 批量处理消息的大小
  20. spring.rabbitmq.listener.simple.BATch–size=50

或

  1. spring:
  2.      rabbitmq:
  3.      host: localhost
  4.      listener:
  5.          simple:
  6.          batch–size: 50
  7.          concurrency: 5
  8.          max–concurrency: 10
  9.          min–concurrency: 1
  10.          queue–name: myQueue
  11.      password: guest
  12.      port: 5672
  13.      username: guest
  14.      virtual–host: /

编写监听器

然后，我们需要创建一个监听器类，以便处理从队列中接收到的消息。以下是一个简单的示例：

  1. @Component
  2. public class MyListener {
  4.      @RabbitListener(queues = “myQueue”, containerFactory = “myFactory”)
  5.      public void handleMessage(List<MyMessage> messages, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag)
  6.              throws IOException {
  7.          try {
  8.              // 处理消息
  9.              System.out.println(“Received “ + messages.size() + ” messages”);
  10.              for (Message message : messages) {
  11.              // 处理消息
  12.              System.out.println(“Received message: “ + new String(message.getBody()));
  13.          }
  14.          channel.basicAck(messages.get(messages.size() – 1).getMessageProperties().getDeliveryTag(), true);
  15.          } finally {
  16.              // 手动确认消息
  17.              channel.basicAck(deliveryTag, true);
  18.          }
  19.      }
  20. }

在上面的代码中，我们使用了@RabbitListener注解来指定要监听的队列名称，同时也指定了使用myFactory工厂来创建监听容器。在这个监听器中，我们简单地打印了接收到的消息。

创建SimpleRabbitListenerContainerFactory

接下来，我们需要创建一个SimpleRabbitListenerContainerFactory工厂，以便能够自定义监听容器的行为。以下是一个简单的示例：

  1. @Configuration
  2. public class RabbitMQConfig {
  3.  
  4. // @Bean
  5. // public SimpleRabbitListenerContainerFactory myFactory(ConnectionFactory connectionFactory) {
  6. // SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
  7. // factory.setConnectionFactory(connectionFactory);
  8. // factory.setConcurrentConsumers(1);
  9. // factory.setMaxConcurrentConsumers(10);
  10. // factory.setBatchListener(true);
  11. // factory.setBatchSize(50);
  12. // return factory;
  13. // }
  14.  
  15.      @Bean
  16.      public SimpleRabbitListenerContainerFactory myFactory(
  17.              ConnectionFactory connectionFactory,
  18.              PlatformTransactionManager transactionManager,
  19.              MessageConverter messageConverter) {
  21.          SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
  23.          // 并发消费者数，默认为 1
  24.          factory.setConcurrentConsumers(5);
  26.          // 最大并发消费者数，默认为 1
  27.          factory.setMaxConcurrentConsumers(10);
  29.          // 拒绝未确认的消息并重新将它们放回队列，默认为 true
  30.          factory.setDefaultRequeueRejected(false);
  32.          // 容器启动时是否自动启动，默认为 true
  33.          factory.setAutoStartup(true);
  35.          // 消息确认模式，默认为 AUTO
  36.          factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
  38.          // 每个消费者在一次请求中预获取的消息数，默认为 1
  39.          factory.setPrefetchCount(5);
  41.          // 从队列中接收消息的超时时间，默认为 0，表示没有超时限制
  42.          factory.setReceiveTimeout(1000);
  44.          // 与容器一起使用的事务管理器。默认情况下，容器不会使用事务
  45.          factory.setTransactionManager(transactionManager);
  47.          // 消息转换器，用于将接收到的消息转换为 Java 对象或将 Java 对象转换为消息
  48.          factory.setMessageConverter(messageConverter);
  50.          // 用于异步消息处理的线程池。默认情况下，容器使用一个简单的 SimpleAsyncTaskExecutor
  51.          factory.setTaskExecutor(new SimpleAsyncTaskExecutor());
  53.          // 在关闭容器时等待活动线程终止的时间，默认为 5000 毫秒
  54.          factory.setShutdownTimeout(10000);
  56.          // 重试失败的消息之前等待的时间，默认为 5000 毫秒
  57.          factory.setRecoveryInterval(5000);
  59.          // 如果消息处理器尝试监听不存在的队列，是否抛出异常。默认为 true
  60.          factory.setMissingQueuesFatal(false);
  62.          // 监听器容器连接工厂
  63.          factory.setConnectionFactory(connectionFactory);
  64.  
  65.          return factory;
  66.      }
  67. }

这些属性中的大多数都是可选的，可以根据需要进行设置。根据应用程序的需求，我们可以自由地调整这些属性，以提高应用程序的性能和可靠性。

发送消息

最后，我们可以编写一个简单的发送消息的代码来向队列中发送一些消息。以下是一个简单的示例：

  1. @Component
  2. public class MySender {
  3.  
  4.      @Autowired
  5.      private RabbitTemplate rabbitTemplate;
  6.  
  7.      public void sendMessage(String message) {
  8.          for (int i = 0; i < 100; i++) {
  9.              rabbitTemplate.convertAndSend(“myQueue”, “message：” + i);
  10.          }
  11.      }
  12. }

总之， SimpleRabbitListenerContainerFactory 提供了一个灵活而强大的机制，用于自定义和配置 RabbitMQ 消息监听容器。

到此这篇关于SpringBoot 整合RabbitMq 自定义消息监听容器来实现消息批量处理的文章就介绍到这了,更多相关SpringBoot RabbitMq消息批量处理内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论