RabbitMQ安装配置，封装工具类，发送消息及监听，延迟消息

已于 2024-07-03 02:59:12 修改
阅读量486 收藏 1
点赞数 3
分类专栏： 封装工具 springboot框架集成相关技术的步骤及配置 springboot技术的使用案例分享 文章标签： java-rabbitmq rabbitmq java
于 2024-06-12 02:37:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30166465/article/details/139612362
版权

1. Get-Started

docker安装rabbitmq

  1. 拉取镜像
[root@heima ~]# docker pull rabbitmq:3.8-management
3.8-management: Pulling from library/rabbitmq
7b1a6ab2e44d: Pull complete 
37f453d83d8f: Pull complete 
e64e769bc4fd: Pull complete 
c288a913222f: Pull complete 
13adc5da62c6: Pull complete 
bd67e639afcb: Pull complete 
9a48b5ad2519: Pull complete 
1cdfc59624be: Pull complete 
8f5ad79f0ad6: Pull complete 
Digest: sha256:543f7268600a27a39e2fdd532f8df479636fc0cf528aadde88d5fe718bed71e4
Status: Downloaded newer image for rabbitmq:3.8-management
docker.io/library/rabbitmq:3.8-management
  1. 创建目录
mkdir -p /home/apps/rabbitmq/data
  1. 运行容器
docker run \
-d \
--name rabbitmq \
--restart=always \
--privileged=true \
-p 5672:5672 \
-p 15672:15672 \
-v /home/apps/rabbitmq/data:/var/lib/rabbitmq \
-e RABBITMQ_DEFAULT_VHOST=vhost0 \
-e RABBITMQ_DEFAULT_USER=admin \
-e RABBITMQ_DEFAULT_PASS=admin123 \
rabbitmq:3.8-management
  1. 启用web界面管理插件
docker exec -it rabbitmq rabbitmq-plugins enable rabbitmq_management
或
-- 进入容器
docker exec -it rabbitmq /bin/bash
-- 安装插件
rabbitmq-plugins enable rabbitmq_management
  1. 浏览器访问 http://虚拟机ip:15672/出现以下界面说明安装成功。

在这里插入图片描述
输入上面在初始化Rabbitmq容器时我们自己指定了默认账号和密码：admin/admin123，如果没有指定的话那么rabbitmq的默认账号密码是:guest/guest

2. 生产者模块

2.1 项目引入依赖：

rabbitmq依赖包，使用RabbitMq这2个依赖就够了。

<dependency>
    <groupId>org.springframework.amqp</groupId>
    <artifactId>spring-amqp</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework.amqp</groupId>
    <artifactId>spring-rabbit</artifactId>
    <scope>provided</scope>
</dependency>

封装工具类用到的包

<!--hutool工具包-->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.7.17</version>
</dependency>

2.2 工具类

  • RabbitMqHelper
import cn.hutool.core.lang.UUID;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;
@Slf4j
public class RabbitMqHelper {

    public static final String REQUEST_ID_HEADER = "requestId";
    private final RabbitTemplate rabbitTemplate;
    private final MessagePostProcessor processor = new BasicIdMessageProcessor();
    private final ThreadPoolTaskExecutor executor;

    public RabbitMqHelper(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
        executor = new ThreadPoolTaskExecutor();
        //配置核心线程数
        executor.setCorePoolSize(10);
        //配置最大线程数
        executor.setMaxPoolSize(15);
        //配置队列大小
        executor.setQueueCapacity(99999);
        //配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("mq-async-send-handler");

        // 设置拒绝策略：当pool已经达到max size的时候，如何处理新任务
        // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //执行初始化
        executor.initialize();
    }

    /**
     * 根据exchange和routingKey发送消息
     */
    public <T> void send(String exchange, String routingKey, T t) {
        log.debug("准备发送消息，exchange：{}， RoutingKey：{}， message：{}", exchange, routingKey, t);
        // 1.设置消息标示，用于消息确认，消息发送失败直接抛出异常，交给调用者处理
        String id = UUID.randomUUID().toString(true);
        CorrelationData correlationData = new CorrelationData(id);
        // 2.设置发送超时时间为500毫秒
        rabbitTemplate.setReplyTimeout(500);
        // 3.发送消息，同时设置消息id
        rabbitTemplate.convertAndSend(exchange, routingKey, t, processor, correlationData);
    }

    /**
     * 根据exchange和routingKey发送消息，并且可以设置延迟时间
     */
    public <T> void sendDelayMessage(String exchange, String routingKey, T t, Duration delay) {
        // 1.设置消息标示，用于消息确认，消息发送失败直接抛出异常，交给调用者处理
        String id = UUID.randomUUID().toString(true);
        CorrelationData correlationData = new CorrelationData(id);
        // 2.设置发送超时时间为500毫秒
        rabbitTemplate.setReplyTimeout(500);
        // 3.发送消息，同时设置消息id
        rabbitTemplate.convertAndSend(exchange, routingKey, t, new DelayedMessageProcessor(delay), correlationData);
    }


    /**
     * 根据exchange和routingKey 异步发送消息，并指定一个延迟时间
     *
     * @param exchange   交换机
     * @param routingKey 路由KEY
     * @param t          数据
     * @param <T>        数据类型
     */
    public <T> void sendAsync(String exchange, String routingKey, T t, Long time) {
        String requestId = MDC.get(REQUEST_ID_HEADER);
        CompletableFuture.runAsync(() -> {
            try {
                MDC.put(REQUEST_ID_HEADER, requestId);
                // 发送延迟消息
                if (time != null && time > 0) {
                    sendDelayMessage(exchange, routingKey, t, Duration.ofMillis(time));
                } else {
                    send(exchange, routingKey, t);
                }
            } catch (Exception e) {
                log.error("推送消息异常，t:{},", t, e);
            }
        }, executor);
    }

    /**
     * 根据exchange和routingKey 异步发送消息
     *
     * @param exchange   交换机
     * @param routingKey 路由KEY
     * @param t          数据
     * @param <T>        数据类型
     */
    public <T> void sendAsync(String exchange, String routingKey, T t) {
        sendAsync(exchange, routingKey, t, null);
    }
}
  • MqConfig
import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.MDC;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.config.ContainerCustomizer;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.amqp.rabbit.retry.RepublishMessageRecoverer;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;


@Configuration
@ConditionalOnClass(value = {MessageConverter.class, AmqpTemplate.class})
public class MqConfig implements EnvironmentAware{

    public static final String REQUEST_ID_HEADER = "requestId";
    public static final String ERROR_EXCHANGE = "error.topic";
    public static final String ERROR_KEY_PREFIX = "error.";
    public static final String ERROR_QUEUE_TEMPLATE = "error.{}.queue";
    private String defaultErrorRoutingKey;
    private String defaultErrorQueue;

    @Bean(name = "rabbitListenerContainerFactory")
    @ConditionalOnProperty(prefix = "spring.rabbitmq.listener", name = "type", havingValue = "simple",
            matchIfMissing = true)
    SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer, ConnectionFactory connectionFactory,
            ObjectProvider<ContainerCustomizer<SimpleMessageListenerContainer>> simpleContainerCustomizer) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        configurer.configure(factory, connectionFactory);
        simpleContainerCustomizer.ifUnique(factory::setContainerCustomizer);
        factory.setAfterReceivePostProcessors(message -> {
            Object header = message.getMessageProperties().getHeader(REQUEST_ID_HEADER);
            if(header != null) {
                MDC.put(REQUEST_ID_HEADER, header.toString());
            }
            return message;
        });
        return factory;
    }

    @Bean
    public MessageConverter messageConverter(ObjectMapper mapper){
        // 1.定义消息转换器
        Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter(mapper);
        // 2.配置自动创建消息id，用于识别不同消息
        jackson2JsonMessageConverter.setCreateMessageIds(true);
        return jackson2JsonMessageConverter;
    }

    /**
     * <h1>消息处理失败的重试策略</h1>
     * 本地重试失败后，消息投递到专门的失败交换机和失败消息队列：error.queue
     */
    @Bean
    @ConditionalOnClass(MessageRecoverer.class)
    @ConditionalOnMissingBean
    public MessageRecoverer republishMessageRecoverer(RabbitTemplate rabbitTemplate){
        // 消息处理失败后，发送到错误交换机：error.direct，RoutingKey默认是error.微服务名称
        return new RepublishMessageRecoverer(
                rabbitTemplate, ERROR_EXCHANGE, defaultErrorRoutingKey);
    }

    /**
     * rabbitmq发送工具
     *
     */
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnClass(RabbitTemplate.class)
    public RabbitMqHelper rabbitMqHelper(RabbitTemplate rabbitTemplate){
        return new RabbitMqHelper(rabbitTemplate);
    }

    /**
     * 专门接收处理失败的消息
     */
    @Bean
    public DirectExchange errorMessageExchange(){
        return new DirectExchange(ERROR_EXCHANGE);
    }

    @Bean
    public Queue errorQueue(){
        return new Queue(defaultErrorQueue, true);
    }

    @Bean
    public Binding errorBinding(Queue errorQueue, DirectExchange errorMessageExchange){
        return BindingBuilder.bind(errorQueue).to(errorMessageExchange).with(defaultErrorRoutingKey);
    }

    @Override
    public void setEnvironment(Environment environment) {
        String appName = environment.getProperty("spring.application.name");
        this.defaultErrorRoutingKey = ERROR_KEY_PREFIX + appName;
        this.defaultErrorQueue = StrUtil.format(ERROR_QUEUE_TEMPLATE, appName);
    }
}
  • Processor
import cn.hutool.core.lang.UUID;
import org.slf4j.MDC;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;

public class BasicIdMessageProcessor implements MessagePostProcessor {
    public static final String REQUEST_ID_HEADER = "requestId";
    @Override
    public Message postProcessMessage(Message message) throws AmqpException {
        String requestId = MDC.get(REQUEST_ID_HEADER);
        if (requestId == null) {
            requestId = UUID.randomUUID().toString(true);
        }
        // 写入RequestID标示
        message.getMessageProperties().setHeader(REQUEST_ID_HEADER, requestId);
        return message;
    }
}

----------------------------------------------------------------------

import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import java.time.Duration;

public class DelayedMessageProcessor extends BasicIdMessageProcessor {

    private final long delay;

    public DelayedMessageProcessor(Duration delay) {
        this.delay = delay.toMillis();
    }

    @Override
    public Message postProcessMessage(Message message) throws AmqpException {
        // 1.添加消息id
        super.postProcessMessage(message);
        // 2.添加延迟时间
        message.getMessageProperties().setHeader("x-delay", delay);
        return message;
    }
}

2.3 配置

通常mq是放在common模块中，别的模块需要mq时就引入该模块，因此需要把MqConfig放在IOC容器里加载。

  • resources/META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 com.tianji.common.autoconfigure.mq.MqConfig

配置rabbitmq的地址等信息

  • boostrap.yml
spring:
  rabbitmq:
    host: ${mydemo.mq.host:192.168.150.101}
    port: ${mydemo.mq.port:5672}
    virtual-host: ${mydemo.mq.vhost:/vhost0}
    username: ${mydemo.mq.username:admin}
    password: ${mydemo.mq.password:admin123}
    listener:
      simple:
        retry:
          enabled: ${mydemo.mq.listener.retry.enable:true} # 开启消费者失败重试
          initial-interval: ${mydemo.mq.listener.retry.interval:1000ms} # 初始的失败等待时长为1秒
          multiplier: ${mydemo.mq.listener.retry.multiplier:2} # 失败的等待时长倍数，下次等待时长 = multiplier * last-interval
          max-attempts: ${mydemo.mq.listener.retry.max-attempts:3} # 最大重试次数
          stateless: ${mydemo.mq.listener.retry.stateless:true} # true无状态；false有状态。如果业务中包含事务，这里改为false

2.4 测试文件

TestController

@RestController
public class TestController {

    @Autowired
    RabbitMqHelper rabbitMqHelper;

    @GetMapping("/hello")
    public String hello(){
        return "hello";
    }

    @GetMapping("/sendMsg")
    public String sendMsg(){
        rabbitMqHelper.send(
                "order.topic", // "order.topic"
                "order.pay", // "order.pay"
                UserDto.builder()
                        .id(10001)
                        .name("gz")
                        .age(23)
                        .phone("15500000001")
                        .email("123@qq.com")
                        .build()
        );
        return "success";
    }
}

UserDto

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class UserDto {
    private Integer id;
    private String name;
    private String phone;
    private Integer age;
    private String email;
}

2.5 生产者测试

生产者模块目录结构
在这里插入图片描述

启动生产者服务，访问http://127.0.0.1:8080/sendMsg
在这里插入图片描述报错了，原因是没有消费者消费消息
但是发现创建了新的错误消息exchange和queue
在这里插入图片描述
因此，接下来创建消费者监听消息。

3. 消费者

3.1 引入通用模块

由于消费者也需要使用刚刚的工具类和UserDto用来接收消息。
在这里插入图片描述
而这些工具类和UserDto都在模块rabbitmq-demo中。因此，在消费者模块中引入该生产者模块（如果这些通用的配置和实体类dto都在一个通用的模块common中，哪些模块需要发送消息，哪些模块需要监听消息，就都引入common模块就行了）

    <groupId>com.gzdemo</groupId>
    <artifactId>rabbitmq-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

因为rabbitmq-demo模块中已经引入了RabbitMq相关依赖，因此消费者模块不需要重复引入RabbitMq相关的依赖。只需要把依赖包添加到classpath下,再import就行了
在这里插入图片描述
在这里插入图片描述

3.2 配置yml

与生产者的配置相同，通常只有消费者才需要配置listener，生产者不需要。
在这里插入图片描述

3.3 编写listener

import com.gzdemo.rabbitmq.pojos.UserDto;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class UserListener {
    /**
     * 监听消息
     */
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "learning.lesson.pay.queue", durable = "true"),
            exchange = @Exchange(name = "order.topic", type = ExchangeTypes.TOPIC),
            key = "order.pay"
    ))
    public void listenLessonPay(UserDto userDto){
        System.out.println(userDto);
    }
}

3.4 消费者目录结构

这里是随便找了个同工程中的子模块作为消费者测试，在UserListener类中监听消息
在这里插入图片描述

4 测试消息发送、监听

启动这两个服务，浏览器访问http://127.0.0.1:8080/sendMsg，多访问几次后发现消费者接收到了消息
在这里插入图片描述生产者console

2024-06-14 05:46:39.187  INFO 106168 --- [nio-8080-exec-1] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [192.168.150.101:5672]
2024-06-14 05:46:39.210  INFO 106168 --- [nio-8080-exec-1] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory#399d82:0/SimpleConnection@1673b17 [delegate=amqp://admin@192.168.150.101:5672/vhost0, localPort= 61317]

5 延迟消息

5.1 rabbitmq容器里安装延迟消息插件

  • 去官网下载插件（v3.8.17）
  • 地址：https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases
# 将下载好的插件复制到mq容器内部 注意插件版本与rabbitmq匹配
docker cp rabbitmq_delayed_message_exchange-3.8.0.ez rabbitmq:/plugins

# 进入mq容器
docker exec -it rabbitmq /bin/bash

# 开启插件支持 
rabbitmq-plugins enable rabbitmq_delayed_message_exchange

# 查看插件列表
rabbitmq-plugins list

# 重启mq
exit
docker restart rabbitmq

我的步骤

[root@heima my-file]# ls
rabbitmq_delayed_message_exchange-3.8.0.ez
[root@heima my-file]# docker cp rabbitmq_delayed_message_exchange-3.8.0.ez rabbitmq:/plugins
[root@heima my-file]# docker exec -it rabbitmq /bin/bash
root@27007a2f1356:/# rabbitmq-plugins enable rabbitmq_delayed_message_exchange
Enabling plugins on node rabbit@27007a2f1356:
rabbitmq_delayed_message_exchange
The following plugins have been configured:
  rabbitmq_delayed_message_exchange
  rabbitmq_management
  rabbitmq_management_agent
  rabbitmq_prometheus
  rabbitmq_web_dispatch
Applying plugin configuration to rabbit@27007a2f1356...
The following plugins have been enabled:
  rabbitmq_delayed_message_exchange

started 1 plugins.
root@27007a2f1356:/# rabbitmq-plugins list
Listing plugins with pattern ".*" ...
 Configured: E = explicitly enabled; e = implicitly enabled
 | Status: * = running on rabbit@27007a2f1356
 |/
......省略
[E*] rabbitmq_delayed_message_exchange 3.8.0
......省略
root@27007a2f1356:/# exit
exit
[root@heima my-file]# docker restart rabbitmq
rabbitmq

5.2 配置延迟交换机、延迟队列

将下面的配置，加入到MqConfig文件里

    @Bean
    public DirectExchange delayExchange(){
        return ExchangeBuilder
                .directExchange("delay.direct")
                .delayed()
                .durable(true)
                .build();
    }

    @Bean
    public Queue delayedQueue(){
        return new Queue("delay.queue");
    }

    @Bean
    public Binding delayedQueueBinding(){
        return BindingBuilder.bind(delayedQueue()).to(delayExchange()).with(DMP_ROUTEKEY);
    }

5.3 发送延迟消息

    @GetMapping("/sendDelayMsg")
    public String sendDelayMsg(){
        rabbitMqHelper.sendDelayMessage(
                "delay.direct",
                "delay",
                UserDto.builder()
                        .id(10001)
                        .name("gz")
                        .age(23)
                        .phone("15500000001")
                        .email("123@qq.com")
                        .build(),
                Duration.ofSeconds(10) //延迟10s
        );
        System.out.println("sendDelayMsg:"+LocalTime.now());
        return "success";
    }

5.4 接收延迟消息

    /**
     * 监听延迟消息
     */
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "delay.queue", durable = "true"),
            exchange = @Exchange(name = "delay.direct",delayed = "true"),
            key = "delay"
    ))
    public void listenDelayedMsg(UserDto userDto){
        System.out.println("收到消息:"+ LocalTime.now());
        System.out.println(userDto);
    }

5.5 测试

在这里插入图片描述

康提扭狗兔
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
Rabbitmq工具类，java工具类RabbitmqUtil
10-29
1、java工具类RabbitmqUtil是本人封装好的直接使用 2、常用的方法都在里面 3、改一下初始化配置参数就行
较完善的rabbitmq消息队列工具类
zhiqiang_zhao
05-13 1464
包含： 1 生产者补单队列 2 生产者重试机制 3 消费者重试机制 4 可靠性投递，最终事务一致原则 5 消费端限流 （服务端限流内存和磁盘配置此处不涉及） rabbitConfig全局配置 package org.jeecg.boot.starter.rabbitmq.config; import lombok.extern.slf4j.Slf4j; import org.springframework.amqp.core.Message; import org.springframe
消息中间件之RabbitMQ的安装及消息发送接收
共勉
08-04 552
安装erlang 官网地址：https://www.erlang.org/downloads 选择对应本机的版本
java rabbitmq 工具类_RabbitMq工具类(springboot)
weixin_39939993的博客
02-13 775
1、pom.xml配置:xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">4.0.0org.springframework.bootspring-boot-starter-parent2.1.4.RELEASEcom.yfjava-spring-...
RabbitMQ工具类封装实现
10-26
本篇文章将重点讲解如何进行RabbitMQ的工具类封装，以及在Android环境下的使用。 首先，`MQSubscribeService.java`代表的是订阅者服务，它是接收和处理来自RabbitMQ的消息的组件。在封装订阅者线程时，通常会包括...
common-io监听文件夹并发送rabbitmq
03-01
在这个案例中，Spring Boot被用来创建一个能够自动配置RabbitMQ连接的应用，并且利用Commons IO来实现文件系统的监听功能，一旦检测到文件夹变化，就将文件内容解析并封装成消息，然后通过RabbitMQ发送出去。...
rabbitMq.zip
10-27
消费者则需要设置监听器，当有新消息到达时，RabbitMQ会通知消费者。 在实际应用中，你可以利用RabbitMQ实现以下功能： - **解耦**：通过消息队列，可以将不同的系统模块解耦，即使它们运行在不同的时间或速度上。...
tp6使用rabbitmq
09-22
5. **创建生产者**：在TP6应用中，你需要创建一个生产者类来发送消息到队列。这通常涉及到创建一个服务容器绑定，定义一个方法来构建AMQP连接和通道，并使用`basic_publish`方法发布消息。 6. **创建消费者**：消费...
php整合rabbitmq进行消息中间件系统开发-php-rabbitmq.zip
01-30
在项目实践中，建议将这些操作封装为类或服务，以提高代码的可读性和可维护性。同时，对异常处理和错误恢复机制进行充分设计，确保系统的健壮性。通过不断学习和实践，你将能够熟练地运用PHP和RabbitMQ构建高效的...
Prometheus 云原生 - 监控 Linux、MySQL、Redis、RabbitMQ、Docker、SpringBoot 3.x
CYK_byte的博客
07-14 1475
docker restart 重启 Prometheus，接着在 Prometheus 的 Targets 就可以观察到。docker restart 重启 Prometheus，接着在 Prometheus 的 Targets 就可以观察到。docker restart 重启 Prometheus，接着在 Prometheus 的 Targets 就可以观察到。docker restart 重启 Prometheus，接着在 Prometheus 的 Targets 就可以观察到。Ps：这里有点问题。
消息队列-RabbitMQ
Roc的博客
07-16 294
延迟队列是一种消息队列，它允许消息在被发送后延迟一定时间才被消费者处理。这意味着消息可以设定一个未来的时间点进行投递，直到达到指定的延迟时间后，消息才会被转移到另一个队列中供消费者消费。延迟队列常用于实现需要延时处理的任务，如定时任务、延迟通知等。优先级队列是一种支持按元素优先级顺序处理消息的队列。在这种队列中，每个消息被赋予一个优先级，高优先级的消息会先于低优先级的消息被消费处理，无论它们的到达顺序如何。优先级队列用于实现重要任务的优先处理等场景。
RabbitMQ - 延迟消息 - 死信交换机
LYJbao的博客
07-14 818
当一个队列中的消息满足下列情况之一时，就会成为死信（Dead Letter）：消费者使用basic.reject或basic.nack声明消费失败，并且消息的Requeue参数设置为false消息是一个过期消息（达到了队列或消息本身设置的过期时间），超时无人消费要投递的队列消息堆积满了（可以给队列设置一个消息上限），最早的消息可能成为死信如果队列通过dead-letter-exchange属性指定了一个交换机，那么该队列中的死信就会投递到这个交换机中。
【雷丰阳-谷粒商城 】【分布式高级篇-微服务架构篇】【22】【RabbitMQ】
Keep Reading Keep Writing Keep Thinking
07-15 1303
【雷丰阳-谷粒商城 】【分布式高级篇-微服务架构篇】【22】【RabbitMQ】 延时队列，可靠消息 Message Queue 消息队列 异步处理 应用解耦 流量控制 消息中间件概念 RabbitMQ概念 Message Publisher Exchange Queue Binding Connection Channel Consumer Virtual Host Broker RabbitMQ运行机制 AMQP 中的消息路由 Exchange类型 RabbitMQ整合
RabbitMq
最新发布
qq_44288171的博客
07-18 659
消息传递模式：RabbitMQ支持多种消息传递模式，包括发布/订阅、点对点和工作队列等，使其更灵活适用于各种消息通信场景。消息路由和交换机：RabbitMQ引入交换机的概念，用于将消息路由到一个或多个队列。允许根据消息的内容、标签或路由键进行灵活的消息路由，从而实现更复杂的消息传递逻辑。消息确认机制：RabbitMQ支持消息确认机制，消费者可以确定已成功处理消息。确保了消息不会再传递后被重复消费，增加了消息的可靠性。消息持久性。
RabbitMQ 如何保证消息的可靠性
weixin_65837469的博客
07-18 345
在分布式系统中，消息队列（如 RabbitMQ）扮演着至关重要的角色，它们作为中间件，帮助系统解耦、异步处理任务、提升系统性能和可靠性。然而，在使用消息队列时，确保消息的可靠性是一个不可忽视的问题。本文将详细探讨 RabbitMQ 如何通过一系列机制来保证消息的可靠性。
rabbitmq生产与消费
qq_30064799的博客
07-18 466
一个生产者，多个消费者，消费者之间负载均衡生产者把消息给交换机，交换机把消息推送给与它绑定的所有队列，消费者监听自己的队列交换机与队列由routing key绑定，生产者发送消息时指定交换机和routing key，则对应的队列便会收到消息交换机与队列由routing key绑定，但routing key由通配符和具体的字符组成，生产者输入具体的字符，交换机根据routing key的规则模糊匹配到对应的队列，则对应的队列会收到消息消费者可以主动拉取队列里的消息通过发布订阅模式，订阅队列里的消息。
rockemq 发送延迟消息_利用rabbitmq 实现消息的延迟发送
05-17
在 RabbitMQ 中实现消息延迟发送的方法是使用 RabbitMQ 的插件 rabbitmq_delayed_message_exchange。这个插件可以让你定义一个 Exchange，然后在发送消息到这个 Exchange 时指定消息的延迟时间。当消息到达指定的延迟时间后，RabbitMQ 会将这个消息转发到真正的 Exchange。 步骤如下： 1. 安装 RabbitMQ 插件 rabbitmq_delayed_message_exchange 可以使用 RabbitMQ 自带的插件管理工具 rabbitmq-plugins 命令来安装插件： ``` rabbitmq-plugins enable rabbitmq_delayed_message_exchange ``` 2. 定义 delayed exchange 创建一个类型为 x-delayed-message 的 exchange，其中 x-delayed-type 属性指定了 exchange 的类型： ``` channel.ExchangeDeclare( "my-delayed-exchange", "x-delayed-message", durable: true, arguments: new Dictionary<string, object> { { "x-delayed-type", "direct" } }); ``` 3. 发送延迟消息 发送消息时需要指定消息的延迟时间和目标 exchange： ``` var headers = new Dictionary<string, object> { { "x-delay", 5000 } // 延迟 5 秒 }; var properties = channel.CreateBasicProperties(); properties.Headers = headers; channel.BasicPublish( exchange: "my-delayed-exchange", routingKey: "", basicProperties: properties, body: Encoding.UTF8.GetBytes("Hello, delayed message!")); ``` 需要注意的是，延迟时间单位是毫秒，需要将延迟时间转换成毫秒后再设置到消息的 header 中。 4. 接收延迟消息 接收延迟消息的方式和普通的消息一样，只需要订阅指定的 exchange 和 routing key 即可。 参考资料： - [RabbitMQ delayed messages with .NET Core](https://www.c-sharpcorner.com/article/rabbitmq-delayed-messages-with-net-core/) - [rabbitmq_delayed_message_exchange plugin](https://github.com/rabbitmq/rabbitmq-delayed-message-exchange)

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值