• docker安装RabbitMQ和延时插件

    RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）

    使用 docker安装 RabbitMQ和延时插件，实现消息延时消费

    目录

    1、docker 安装 RabbitMQ

    2、安装延时插件 

    3、测试延时消息

    1、docker 安装 RabbitMQ

    docker拉取镜像

    docker pull rabbitmq:3.10-management

    开启容器

    docker run -it --name rabbitmq -p 5672:5672 -p 15672:15672 -d rabbitmq:3.10-management

    开启容器后，浏览器访问宿主机器 ip+15672端口，访问RabbitMQ管理页面

    笔者的宿主机器 ip 是 192.168.5.25

    初始账号密码都是guest 

    2、安装延时插件 

    下载插件地址：https://www.rabbitmq.com/community-plugins.html

    找到 rabbitmq_delayed_message_exchange

    点击进入下载页面

    找到对应的版本进行下载

    下载插件后，将插件上传到服务器

    使用 docker 命令将插件复制到容器内部 plugins目录下

    docker cp rabbitmq_delayed_message_exchange-3.10.0.ez  rabbitmq:/plugins

    进入容器内部进行查看

    docker exec -it rabbitmq bash

     进入 plugins 目录查看

    cd plugins

    执行命令安装插件

    rabbitmq-plugins enable rabbitmq_delayed_message_exchange

    通过命令查看已安装的插件

    rabbitmq-plugins list

     

    退出容器后，重启 rabbitmq 容器

    docker restart rabbitmq

     

    重启完成后，进入管理页面，点击交换机 Exchange，点开 Add a new exchange，查看交换机类型 Type，发现里面新增了 x-delayed-message 类型，则延时插件安装成功

    3、测试延时消息

    新建 SpringBoot 项目

    pom.xml内容

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     <modelVersion>4.0.0modelVersion>
    5.     <groupId>com.wsjzzcbqgroupId>
    6.     <artifactId>rabbitmq-demoartifactId>
    7.     <version>0.0.1-SNAPSHOTversion>
    8.     <name>rabbitmq-demoname>
    9.     <description>Demo project for Spring Bootdescription>
    10.  
    11.     <properties>
    12.         <java.version>1.8java.version>
    13.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    14.         <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    15.         <spring-boot.version>2.3.7.RELEASEspring-boot.version>
    16.     properties>
    17.  
    18.     <dependencies>
    19.         <dependency>
    20.             <groupId>org.springframework.bootgroupId>
    21.             <artifactId>spring-boot-starter-amqpartifactId>
    22.         dependency>
    23.         <dependency>
    24.             <groupId>org.springframework.bootgroupId>
    25.             <artifactId>spring-boot-starter-webartifactId>
    26.         dependency>
    27.  
    28.         <dependency>
    29.             <groupId>org.projectlombokgroupId>
    30.             <artifactId>lombokartifactId>
    31.             <optional>trueoptional>
    32.         dependency>
    33.         <dependency>
    34.             <groupId>org.springframework.bootgroupId>
    35.             <artifactId>spring-boot-starter-testartifactId>
    36.             <scope>testscope>
    37.             <exclusions>
    38.                 <exclusion>
    39.                     <groupId>org.junit.vintagegroupId>
    40.                     <artifactId>junit-vintage-engineartifactId>
    41.                 exclusion>
    42.             exclusions>
    43.         dependency>
    44.         <dependency>
    45.             <groupId>org.springframework.amqpgroupId>
    46.             <artifactId>spring-rabbit-testartifactId>
    47.             <scope>testscope>
    48.         dependency>
    49.     dependencies>
    50.  
    51.     <dependencyManagement>
    52.         <dependencies>
    53.             <dependency>
    54.                 <groupId>org.springframework.bootgroupId>
    55.                 <artifactId>spring-boot-dependenciesartifactId>
    56.                 <version>${spring-boot.version}version>
    57.                 <type>pomtype>
    58.                 <scope>importscope>
    59.             dependency>
    60.         dependencies>
    61.     dependencyManagement>
    62.  
    63.     <build>
    64.         <plugins>
    65.             <plugin>
    66.                 <groupId>org.apache.maven.pluginsgroupId>
    67.                 <artifactId>maven-compiler-pluginartifactId>
    68.                 <version>3.8.1version>
    69.                 <configuration>
    70.                     <source>1.8source>
    71.                     <target>1.8target>
    72.                     <encoding>UTF-8encoding>
    73.                 configuration>
    74.             plugin>
    75.             <plugin>
    76.                 <groupId>org.springframework.bootgroupId>
    77.                 <artifactId>spring-boot-maven-pluginartifactId>
    78.                 <version>2.3.7.RELEASEversion>
    79.                 <configuration>
    80.                     <mainClass>com.wsjzzcbq.RabbitmqDemoApplicationmainClass>
    81.                 configuration>
    82.                 <executions>
    83.                     <execution>
    84.                         <id>repackageid>
    85.                         <goals>
    86.                             <goal>repackagegoal>
    87.                         goals>
    88.                     execution>
    89.                 executions>
    90.             plugin>
    91.         plugins>
    92.     build>
    93.  
    94. project>

    application.properties内容

    1. # 应用名称
    2. spring.application.name=rabbitmq-demo
    3. # 应用服务 WEB 访问端口
    4. server.port=8080
    5.  
    6. spring.rabbitmq.addresses=192.168.5.25
    7. spring.rabbitmq.username=guest
    8. spring.rabbitmq.password=guest
    9. spring.rabbitmq.virtual-host=/
    10. spring.rabbitmq.publisher-confirm-type=correlated
    11. spring.rabbitmq.publisher-returns=true
    12. spring.rabbitmq.template.mandatory=true
    13. spring.rabbitmq.connection-timeout=5000
    14.  
    15. spring.rabbitmq.listener.simple.acknowledge-mode=manual
    16. spring.rabbitmq.listener.simple.concurrency=1
    17. spring.rabbitmq.listener.simple.max-concurrency=5

    启动类 RabbitmqDemoApplication 内容

    1. package com.wsjzzcbq;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5.  
    6. @SpringBootApplication
    7. public class RabbitmqDemoApplication {
    8.  
    9.     public static void main(String[] args) {
    10.         SpringApplication.run(RabbitmqDemoApplication.class, args);
    11.     }
    12.  
    13. }

    RabbitConsumer 消费者内容

    1. package com.wsjzzcbq.rabbit;
    2.  
    3. import com.rabbitmq.client.Channel;
    4. import org.springframework.amqp.rabbit.annotation.*;
    5. import org.springframework.amqp.support.AmqpHeaders;
    6. import org.springframework.messaging.Message;
    7. import org.springframework.stereotype.Component;
    8. import java.io.IOException;
    9. import java.time.LocalDateTime;
    10. import java.time.format.DateTimeFormatter;
    11.  
    12. /**
    13.  * RabbitConsumer
    14.  *
    15.  * @author wsjz
    16.  * @date 2022/10/26
    17.  */
    18. @Component
    19. public class RabbitConsumer {
    20.  
    21.     /**
    22.      * 注解会自动创建交换机队列及其绑定
    23.      * @param message
    24.      * @param channel
    25.      * @throws IOException
    26.      */
    27.     @RabbitListener(bindings = @QueueBinding(
    28.             value=@Queue(value="queue-poetry",durable="true"),
    29.             exchange=@Exchange(
    30.                     value="exchange-delayed",
    31.                     arguments = {@Argument(name="x-delayed-type", value = "direct")},
    32.                     type = "x-delayed-message",
    33.                     ignoreDeclarationExceptions="true"),
    34.             key="poetry"
    35.     ))
    36.     public void onMessage(Message message, Channel channel) throws IOException {
    37.         String name = (String) message.getHeaders().get("name");
    38.         System.out.println(name);
    39.         Long deliveryTag = (Long) message.getHeaders().get(AmqpHeaders.DELIVERY_TAG);
    40.         //手工签收
    41.         channel.basicAck(deliveryTag, false);
    42.  
    43.         String now = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    44.         System.out.println("消息已接收" + now + ":" + message.getPayload());
    45.     }
    46. }

    RabbitProducer 生产者内容

    1. package com.wsjzzcbq.rabbit;
    2.  
    3. import org.springframework.amqp.rabbit.core.RabbitTemplate;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.messaging.Message;
    6. import org.springframework.messaging.MessageHeaders;
    7. import org.springframework.messaging.support.MessageBuilder;
    8. import org.springframework.stereotype.Component;
    9. import java.time.LocalDateTime;
    10. import java.time.format.DateTimeFormatter;
    11. import java.util.Map;
    12.  
    13. /**
    14.  * RabbitProducer
    15.  *
    16.  * @author wsjz
    17.  * @date 2022/10/26
    18.  */
    19. @Component
    20. public class RabbitProducer {
    21.  
    22.     @Autowired
    23.     private RabbitTemplate rabbitTemplate;
    24.  
    25.     /**
    26.      * 发送消息
    27.      * @param msg
    28.      * @param properties
    29.      * @param millisecond
    30.      */
    31.     public void sendMessage(Object msg, Map properties, int millisecond) {
    32.         MessageHeaders messageHeaders = new MessageHeaders(properties);
    33.         Message content = MessageBuilder.createMessage(msg, messageHeaders);
    34.  
    35.         rabbitTemplate.convertAndSend("exchange-delayed", "poetry", content, (message)->{
    36.             message.getMessageProperties().setHeader("x-delay", millisecond);
    37.             return message;
    38.         });
    39.  
    40.         String now = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    41.         System.out.println("消息已发送" + now + ":" + msg);
    42.     }
    43.  
    44. }

    DemoController 内容

    1. package com.wsjzzcbq.controller;
    2.  
    3. import com.wsjzzcbq.rabbit.RabbitProducer;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RestController;
    7. import java.util.HashMap;
    8. import java.util.Map;
    9.  
    10. /**
    11.  * DemoController
    12.  *
    13.  * @author wsjz
    14.  * @date 2022/10/26
    15.  */
    16. @RestController
    17. public class DemoController {
    18.  
    19.     @Autowired
    20.     private RabbitProducer producer;
    21.  
    22.     @RequestMapping("/send")
    23.     public String send() {
    24.         Map map = new HashMap<>();
    25.         map.put("name", "花月吟.唐伯虎");
    26.         //消息发送，延时5秒钟
    27.         producer.sendMessage("如此好花如此月， 莫将花月作寻常", map, 5 * 1000);
    28.         return "ok";
    29.     }
    30. }

    启动项目，会自动创建交换机和队列，进入管理页面查看交换机 exchange-delayed

    运行测试

    浏览器访问：http://localhost:8080/send

    看控制台打印时间间隔

    消费者端延时5秒钟收到消息

    至此完

  • 相关阅读:
    Python按照拼音顺序给数组排序
    CAP项目集成带身份和证书验证的MongoDB
    【附源码】计算机毕业设计SSM甜心驿站饮品信息管理
    python 里面对于字典进行key或value排序输出
    基于一个多分类问题比较bert单任务训练和多任务训练
    Unity Shader Graph 节点入门
    JVM调优前置知识-深堆Retained Heap和浅堆Shallow Heap
    [附源码]java毕业设计st音乐网站论文
    tensorrt: pycuda, onnx, onnxruntime, tensorrt,torch-tensorrt 安装
    Map.Entry理解和应用
  • 原文地址：https://blog.csdn.net/wsjzzcbq/article/details/127558183