消息队列（一）-- RabbitMQ入门（3）

news2024/9/30 5:40:34

延迟队列

延迟队列是用来存放需要在指定时间被处理的元素的队列。队列内部是有序的，最重要的特性就体现在它的延时属性上。
使用场景：订单在十分钟之内未支付则自动取消。

整合SpringBoot

新建一个SpringBoot的Module
在这里插入图片描述
添加依赖

        <!--RabbitMQ依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.19</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--RabbitMQ测试依赖-->
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>

修改配置文件
在这里插入图片描述
添加Swagger配置类

package com.ql.springbootrabbitmq.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket webApiConfig(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select()
                .build();
    }
    private ApiInfo webApiInfo(){
        return new ApiInfoBuilder()
                .title("rabbitmq接口文档")
                .description("本文档描述了rabbitmq微服务接口定义")
                .version("1.0")
                .contact(new Contact("admin123", "http://www.ql.com", "123123123@qq.com"))
                .build();
    }
}

队列TTL

创建两个队列QA和QB，两者队列TTL分别设置为10S和40S，然后在创建一个交换机X和死信交换机Y，它们类型都是direct，创建一个死信队列QD，绑定关系如下图
在这里插入图片描述
配置文件类

package com.ql.springbootrabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * TTL队列 配置文件类代码
 */
@Configuration
public class TtlQueueConfig {
    //普通交换机名称
    public static final String X_EXCHANGE = "X";
    //死信交换机名称
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    //普通队列名称
    public static final String QUEUE_A = "QA";
    public static final String QUEUE_B = "QB";
    //死信队列名称
    public static final String DEAD_LETTER_QUEUE = "QD";

    //声明xExchange
    @Bean("xExchange")
    public DirectExchange xExchange(){
        return new DirectExchange(X_EXCHANGE);
    }
    //声明yExchange
    @Bean("yExchange")
    public DirectExchange yExchange(){
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }

    //声明普通队列TTL为10s
    @Bean("queueA")
    public Queue queueA(){
        Map<String, Object> arguments = new HashMap<>(3);
        //设置死信交换机
        arguments.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //设置死信RoutingKey
        arguments.put("x-dead-letter-routing-key", "YD");
        //设置TTL 单位ms
        arguments.put("x-message-ttl", 10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(arguments).build();
    }
    //声明普通队列TTL为40s
    @Bean("queueB")
    public Queue queueB(){
        Map<String, Object> arguments = new HashMap<>(3);
        //设置死信交换机
        arguments.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //设置死信RoutingKey
        arguments.put("x-dead-letter-routing-key", "YD");
        //设置TTL 单位ms
        arguments.put("x-message-ttl", 40000);
        return QueueBuilder.durable(QUEUE_B).withArguments(arguments).build();
    }
    //声明死信队列
    @Bean("queueD")
    public Queue queueD(){
        return QueueBuilder.durable(DEAD_LETTER_QUEUE).build();
    }
    //绑定
    @Bean
    public Binding queueABindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }
    @Bean
    public Binding queueBBindingX(@Qualifier("queueB") Queue queueB,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueB).to(xExchange).with("XB");
    }
    @Bean
    public Binding queueDBindingY(@Qualifier("queueD") Queue queueD,
                                  @Qualifier("yExchange") DirectExchange yExchange){
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }
}

生产者

package com.ql.springbootrabbitmq.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * 发送延迟消息
 */
@Slf4j
@RestController
@RequestMapping("/ttl")
public class SendMsgController {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    //开始发消息
    @GetMapping("/sendMsg/{message}")
    public void sendMsg(@PathVariable String message){
        log.info("当前时间：{}，发送一条消息给两个TTL队列：{}",new Date().toString(), message);
        rabbitTemplate.convertAndSend("X", "XA", "消息来自ttl为10s的队列："+message);
        rabbitTemplate.convertAndSend("X", "XB", "消息来自ttl为40s的队列："+message);
    }
}

消费者

package com.ql.springbootrabbitmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 队列TTL 消费者
 */
@Slf4j
@Component
public class DeadLetterQueueConsumer {
    //接收消息
    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel ){
        String msg = new String(message.getBody());
        log.info("当前时间：{}，收到死信队列的消息：{}", new Date().toString(), msg);
    }
}

运行项目，浏览器输入http://localhost:8080/ttl/sendMsg/哈哈哈 测试
在这里插入图片描述
在这里插入图片描述

延迟队列优化

新增一个队列QC，绑定关系如下，该队列不设置TTL时间
在这里插入图片描述
配置类添加代码如下

    //普通队列名称
    public static final String QUEUE_C = "QC";

    //声明普通队列 不设TTL
    @Bean("queueC")
    public Queue queueC(){
        Map<String, Object> arguments = new HashMap<>(2);
        //设置死信交换机
        arguments.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //设置死信RoutingKey
        arguments.put("x-dead-letter-routing-key", "YD");
        return QueueBuilder.durable(QUEUE_C).withArguments(arguments).build();
    }
    @Bean
    public Binding queueCBindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueC).to(xExchange).with("XC");
    }

生产者增加发有延迟时间的消息的接口代码

    //开始发消息 发TTL
    @GetMapping("/sendExpirationMsg/{message}/{ttlTime}")
    public void sendExpirationMsg(@PathVariable("message") String message,
                        @PathVariable("ttlTime") String ttlTime){
        log.info("当前时间:{},发送一条时长是{}毫秒TTL信息给队列QC：{}",
                new Date().toString(),ttlTime,message);
        rabbitTemplate.convertAndSend("X","XC",message,msg -> {
            //发送消息的时候的延迟时长
            msg.getMessageProperties().setExpiration(ttlTime);
            return msg;
        });
    }

运行测试，浏览器依次访问如下连接
http://localhost:8080/ttl/sendExpirationMsg/延迟二十秒消息/20000
http://localhost:8080/ttl/sendExpirationMsg/延迟两秒信息/2000
在这里插入图片描述
结果2秒的未被先收到，说明RabbitMQ只会检查第一个消息是否过期，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

RabbitMQ 插件实现延迟队列

从官网https://www.rabbitmq.com/community-plugins.html
下载rabbitmq_delayed_message_exchange插件（注意下载跟RabbitMQ一致的版本），然后放到 RabbitMQ 的安装目录下的 plugins 目录 /usr/lib/rabbitmq/lib/rabbitmq_server-3.10.0/plugins 下，然后执行
rabbitmq-plugins enable rabbitmq_delayed_message_exchange
在这里插入图片描述
在这里插入图片描述
然后重启 RabbitMQ ，浏览器访问管理界面
http://192.168.1.130:15672/ 在新增交换机时，多了一个 x-delayed-message 类型
在这里插入图片描述
之前是基于死信队列的延迟属性实现延迟队列，存在多个延迟消息时只会检查第一个消息是否过期的问题。
在这里插入图片描述
那么现在基于插件，使得交换机延迟发给队列。
在这里插入图片描述
编写配置类

package com.ql.springbootrabbitmq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class DelayedQueueConfig {
    //队列
    public static final String DELAYED_QUEUE_NAME = "delayed.queue";
    //交换机
    public static final String DELAYED_EXCHANGE_NAME = "delayed.queue";
    //routingKey
    public static final String DELAYED_ROUTING_KEY = "delayed.routingKey";

    //声明交换机 基于插件的
    @Bean
    public CustomExchange delayedExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type","direct");
        /**
         * 1.交换机的名称
         * 2.交换机的类型
         * 3.是否需要持久化
         * 4.是否需要自动删除
         * 5.其他的参数
         */
        return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message",
                true, false, arguments);
    }
    //声明队列
    @Bean
    public Queue delayedQueue(){
        return new Queue(DELAYED_QUEUE_NAME);
    }
    //绑定
    @Bean
    public Binding delayedQueueBindingDelayedExchange(
            @Qualifier("delayedQueue") Queue delayedQueue,
            @Qualifier("delayedExchange") CustomExchange delayedExchange
    ){
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
    }

}

编写生产者

    //开始发消息 基于插件的 消息 及 延迟的时间
    @GetMapping("/sendDelayMsg/{message}/{delayTime}")
    public void sendDelayMsg(@PathVariable String message,
                                  @PathVariable Integer delayTime){
        log.info("当前时间:{},发送一条时长是{}毫秒信息给延迟队列：{}",
                new Date().toString(),delayTime,message);
        rabbitTemplate.convertAndSend(DelayedQueueConfig.DELAYED_EXCHANGE_NAME,
                DelayedQueueConfig.DELAYED_ROUTING_KEY,message, msg -> {
            //发送消息的时候的延迟时长 单位ms
            msg.getMessageProperties().setDelay(delayTime);
            return msg;
        });
    }

编写消费者

package com.ql.springbootrabbitmq.consumer;

import com.ql.springbootrabbitmq.config.DelayedQueueConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 消费者 基于插件的延迟消息
 */
@Slf4j
@Component
public class DelayQueueConsumer {
    //接收消息
    @RabbitListener(queues = DelayedQueueConfig.DELAYED_QUEUE_NAME)
    public void receiveDelayQueue(Message message){
        String msg = new String(message.getBody());
        log.info("当前时间：{}，收到死信队列的消息：{}", new Date().toString(), msg);
    }
}

运行测试，浏览器依次访问如下连接
http://localhost:8080/ttl/sendDelayMsg/延迟二十秒消息/20000
http://localhost:8080/ttl/sendDelayMsg/延迟两秒信息/2000
在这里插入图片描述
这次符合预期。

发布确认高级

在生产环境中由于一些不明原因，导致RabbitMQ 重启，在 RabbitMQ 重启期间生产者消息投递失败，导致消息丢失，需要手动处理和恢复。那么，如何才能进行 RabbitMQ 的消息可靠投递呢？

发布确认 SpringBoot 版本

确认机制方案
在这里插入图片描述
配置类

package com.ql.springbootrabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置类 发布确认（高级）
 */
@Configuration
public class ConfirmConfig {
    //交换机
    public static final String CONFIRM_EXCHANGE_NAME = "confirm_exchange";
    //队列
    public static final String CONFIRM_QUEUE_NAME = "confirm_queue";
    //RoutingKey
    public static final String CONFIRM_ROUTING_KEY = "key1";

    //声明交换机
    @Bean
    public DirectExchange confirmExchange(){
        return new DirectExchange(CONFIRM_EXCHANGE_NAME);
    }

    @Bean
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build();
    }

    //绑定
    @Bean
    public Binding queueBindingExchange(@Qualifier("confirmQueue") Queue confirmQueue,
                                        @Qualifier("confirmExchange")DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROUTING_KEY);
    }

}

生产者

package com.ql.springbootrabbitmq.controller;

import com.ql.springbootrabbitmq.config.ConfirmConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 开始发消息 测试确认
 */
@Slf4j
@RestController
@RequestMapping("/confirm")
public class ProducerController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //发消息
    @GetMapping("/sendMessage/{message}")
    public void sendMessage(@PathVariable String message){
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE_NAME,
                ConfirmConfig.CONFIRM_ROUTING_KEY, message);
        log.info("发送消息内容：{}",message);
    }
}

消费者

package com.ql.springbootrabbitmq.consumer;

import com.ql.springbootrabbitmq.config.ConfirmConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 接收消息
 */
@Slf4j
@Component
public class Consumer {
    @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE_NAME)
    public void receiveConfirmMessage(Message message){
        String msg = new String(message.getBody());
        log.info("接收到的队列confirm.queue消息：{}",msg);
    }
}

运行测试，浏览器访问http://localhost:8080/confirm/sendMessage/哈哈哈
在这里插入图片描述
回调接口
需要在配置文件添加
spring.rabbitmq.publisher-confirm-type=correlated
该配置有以下几个参数值
none 默认值，禁用发布确认模式
correlated 发布消息成功到交换机会触发回调方法
simple 经测试有两种效果，其一效果和 correlated 值一样会触发回调方法；其二在发布消息成功后使用 rabbitTemplate 调用 waitForConfirms 或 waitForConfirmsOrDie 方法，等待 broker 节点返回发送结果，根据返回结果判定下一步的逻辑，要注意的点是 waitForConfirmsOrDie 方法如果返回 false 则会关闭 channel ，则接下来无法发送消息到 broker。
在这里插入图片描述
编写回调方法

package com.ql.springbootrabbitmq.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 回调接口
 */
@Slf4j
@Component
public class MyCallBack implements RabbitTemplate.ConfirmCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        //注入
        rabbitTemplate.setConfirmCallback(this);
    }
    /**
     * 交换机确认回调方法
     * @param correlationData 回调消息的ID及相关信息
     * @param b 是否接收到消息
     * @param s 失败原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        String id = correlationData != null ? correlationData.getId() : "";
        if(b){
            log.info("交换机已经收到Id为：{}的消息", id);
        }else{
            log.info("交换机还未收到Id为：{}的消息,原因为：{}", id, s);
        }
    }
}

运行测试，浏览器访问http://localhost:8080/confirm/sendMessage/呵呵呵
在这里插入图片描述
把生产者交换机名称故意改错，重启再测试

在这里插入图片描述
在这里插入图片描述
但是交换机名称改回来，队列名称故意改错会不会调回调方法呢？
在这里插入图片描述
在这里插入图片描述
显然没有回调。

回退消息

在仅开启了生产者确认机制下，交换机接收到消息后，会直接给消息生产者发送确认消息，如果发现消息不可路由，那么消息会被直接丢弃，此时生产者是不知道消息被丢弃的。可以通过mandatory 参数可以在消息传递过程中不可达目的时将消息返回给生产者。

先给在配置文件添加spring.rabbitmq.publisher-returns=true配置
在这里插入图片描述
编写回退接口

package com.ql.springbootrabbitmq.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 回调接口
 */
@Slf4j
@Component
public class MyCallBack implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback{

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        //注入
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }
    /**
     * 交换机确认回调方法
     * @param correlationData 回调消息的ID及相关信息
     * @param b 是否接收到消息
     * @param s 失败原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        String id = correlationData != null ? correlationData.getId() : "";
        if(b){
            log.info("交换机已经收到Id为：{}的消息", id);
        }else{
            log.info("交换机还未收到Id为：{}的消息,原因为：{}", id, s);
        }
    }


    /**
     * Returned message callback.
     *
     * @param returned the returned message and metadata.
     * 可以在消息传递过程中不可达目的时将消息返回给生产者
     * 只有不可达目的时，才进行回退
     */
    @Override
    public void returnedMessage(ReturnedMessage returned) {
        log.error("消息{}，被交换机{}退回，退回原因：{}，路由Key:{}",
                new String(returned.getMessage().getBody()),
                returned.getExchange(),returned.getReplyText(),returned.getRoutingKey());
    }
}

运行测试
在这里插入图片描述

备份交换机

当交换机接收一条不可路由消息时，可以把这条消息转发到备份交换机中，由备份交换机来进行转发和处理。通常备份交换机的类型为 Fanout ，这样就能把所有消息都投递到与其绑定的队列中。我们还可以建立一个报警队列，用独立的消费者进行监测和报警。
在这里插入图片描述
在ConfirmConfig.java 配置类里声明备份交换机、备份队列和报警队列，并且修改确认交换声明

    //备份交换机
    public static final String BACKUP_EXCHANGE_NAME = "backup_exchange";
    //备份队列
    public static final String BACKUP_QUEUE_NAME = "backup_queue";
    //报警队列
    public static final String WARNING_QUEUE_NAME = "warning_queue";

    @Bean
    public FanoutExchange backupExchange(){
        return new FanoutExchange(BACKUP_EXCHANGE_NAME);
    }
    @Bean
    public Queue backupQueue(){
        return QueueBuilder.durable(BACKUP_QUEUE_NAME).build();
    }
    @Bean
    public Queue warningQueue(){
        return QueueBuilder.durable(WARNING_QUEUE_NAME).build();
    }
    @Bean
    public Binding backupQueueBindingBackupExchange(@Qualifier("backupQueue") Queue backupQueue,
                                        @Qualifier("backupExchange")FanoutExchange backupExchange){
        return BindingBuilder.bind(backupQueue).to(backupExchange);
    }
    @Bean
    public Binding warningQueueBindingBackupExchange(@Qualifier("warningQueue") Queue warningQueue,
                                                    @Qualifier("backupExchange")FanoutExchange backupExchange){
        return BindingBuilder.bind(warningQueue).to(backupExchange);
    }

    //声明交换机
    @Bean
    public DirectExchange confirmExchange(){
        return ExchangeBuilder.directExchange(CONFIRM_EXCHANGE_NAME).durable(true)
                .withArgument("alternate-exchage", BACKUP_EXCHANGE_NAME).build();
    }

报警消费者

package com.ql.springbootrabbitmq.consumer;

import com.ql.springbootrabbitmq.config.ConfirmConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 报警消费者
 */
@Component
@Slf4j
public class WarningConsumer {

    //接收报警消息
    @RabbitListener(queues = ConfirmConfig.WARNING_QUEUE_NAME)
    public void receiveWarningMsg(Message message){
        String msg = new String(message.getBody());
        log.error("报警：发现不可路由消息：{}", msg);
    }
}

先通过管理页面删除原来的确认交换机，然后运行测试
在这里插入图片描述
注意：mandatory 参数与备份交换机在一起使用时，备份交换机优先级高。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/789081.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Kafka集群——（区别于Master/Slave架构的的分布式集群）

Kafka集群——（区别于Master/Slave架构的的分布式集群）

Kafka角色介绍&#xff1a; 1. Producer:消息生产者&#xff1a; 2. Broker: kafka实例&#xff0c;可以理解为一台kafka服务器&#xff0c;kafka cluster 是由多个broker构成的集群。 3. Topic: 消息主题&#xff0c;理解为消息队列&#xff0c;kafka数据就保存在topic里。…
阅读更多...
vue+Element-ui实现树形组件、表格树

vue+Element-ui实现树形组件、表格树

需求 要做出如下图所示的 树形表格&#xff0c;也就是数据之间有父子类关系的这种&#xff0c;可以点击展开、收缩 像上图这样的表格树 实现 1.使用树形组件 在学习树形表格之前&#xff0c;肯定得先搞懂普通的树形组件是怎么搞的&#xff0c;然后将其套到表格中就好了&…
阅读更多...
基于JavaSE的手机库存管理系统

基于JavaSE的手机库存管理系统

1、项目背景 基于JavaSE完成如下需求&#xff1a; 功能需求&#xff1a; 1、查询库存量 2、可以修改库存中不同品牌手机的个数 3、退出系统 实现步骤&#xff1a; 1、把List当做库房 2、把手机存放在库房中 3、使用封装的方法区操作仓库中的手机 2、项目知识点 面向对象 集合…
阅读更多...
存储过程——case函数、while函数、repeat函数的应用、loop函数

存储过程——case函数、while函数、repeat函数的应用、loop函数

1.case循环 存储过程中&#xff0c;几种循环格式的语法讲解。 create procedure p6(in month int) begindeclare result varchar(10);casewhen month > 1 and month < 3 thenset result : 第一季度;when month > 4 and month < 6 thenset result : 第二季度;whe…
阅读更多...
spring cloud sentinel

spring cloud sentinel

初始时 并不能将sentinel实例显示出来的 需要修改加配置clent-ip spring:cloud:sentinel:transport:#本机ipclient-ip: 192.168.10.108#dashboard服务端的grp端口 监听心跳的port: 8719#dashboard服务端地址dashboard: 192.168.12.14:8080
阅读更多...
数据结构【栈和队列】

数据结构【栈和队列】

第三章 栈与队列 一、栈 1.定义&#xff1a;只允许一端进行插入和删除的线性表&#xff0c;结构与手枪的弹夹差不多&#xff0c;可以作为实现递归函数&#xff08;调用和返回都是后进先出&#xff09;调用的一种数据结构&#xff1b; 栈顶&#xff1a;允许插入删除的那端&…
阅读更多...
了解Unity编辑器之组件篇Physics（四）

了解Unity编辑器之组件篇Physics（四）

Physics&#xff1a;用于处理物理仿真和碰撞检测。它提供了一组功能强大的工具和算法&#xff0c;用于模拟真实世界中的物理行为&#xff0c;使游戏或应用程序更加真实和可信。 主要用途包括&#xff1a; 碰撞检测&#xff1a;Unity Physics 提供了高效的碰撞检测算法&#x…
阅读更多...
【Unity实战篇 】| 游戏中实现镂空遮罩效果【矩形、圆形镂空遮罩】

【Unity实战篇 】| 游戏中实现镂空遮罩效果【矩形、圆形镂空遮罩】

前言【Unity实战篇 】 | 游戏中实现镂空遮罩效果【矩形、圆形镂空遮罩】一、制作原理二、矩形中间镂空遮罩效果2.1 实现镂空显示2.2 镂空区域内事件穿透三、圆形中间镂空遮罩效果总结前言 本文来写一下怎样在Unity中完成一个 镂空遮罩 的效果。镂空遮罩 比较常用的有两种：矩形…
阅读更多...
力扣题库刷题笔记73--矩阵置零

力扣题库刷题笔记73--矩阵置零

1、题目如下&#xff1a; 2、个人Python代码实现 3、个人Python代码思路 a、声明2个空数组p、q&#xff0c;用于存放值为0的元素matrix[i][j]的下标 b、首先遍历二维数组matrix&#xff0c;找到值为0的元素matrix[i][j]&#xff0c;将下标i加入数组p&#xff0c;将下标j加入数…
阅读更多...
【【51单片机直流电机调速】】

【【51单片机直流电机调速】】

学会电机调速&#xff0c;掌握中国速度 PWM的生成方法 先用户设定一个比较值&#xff0c;然后计数器定时自增。 当计数器<比较值&#xff0c;输出0 当计数器>比较值&#xff0c;输出1 main.c #include <REGX52.H> #include"delay.h" #include"…
阅读更多...
vue 学习笔记 【ElementPlus】el-menu 折叠后图标不见了

vue 学习笔记 【ElementPlus】el-menu 折叠后图标不见了

项目当前版本 {"dependencies": {"element-plus/icons-vue": "^2.1.0","types/js-cookie": "^3.0.3","types/nprogress": "^0.2.0","axios": "^1.4.0","core-js": &quo…
阅读更多...
PHP 药店管理系统mysql数据库web结构apache计算机软件工程网页wamp

PHP 药店管理系统mysql数据库web结构apache计算机软件工程网页wamp

一、源码特点 PHP 药品管理系统 是一套完善的web设计系统,系统采用smarty框架进行开发设计&#xff0c;对理解php编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。 PHP 药店管理系统mysql数据库web结构apache计 下载地址…
阅读更多...
TSN -促进IT/OT 融合的网络技术

TSN -促进IT/OT 融合的网络技术

时间敏感网络&#xff08;tsn&#xff09;技术是IT/OT 融合的一项关键的基础网络技术&#xff0c;它实现了在一个异构网络中&#xff0c;实现OT的实时数据和IT系统的交互数据的带宽共享。 TSN允许将经典的高确定性现场总线系统和IT应用&#xff08;如大数据传输&#xff09;的功…
阅读更多...
第1章 获取数据库中的数据

第1章 获取数据库中的数据

CoreShop源程序是以数据库优先进行定义的&#xff0c;所以其本身不包含代码优先的定义&#xff0c;但本从更习惯于代码优先&#xff0c;所以为其定义了代码优先的定义。 1 CoreCms.Net.Model.Entities.SysRole using SqlSugar; using System.ComponentModel.DataAnnotations…
阅读更多...
力扣 56. 合并区间

力扣 56. 合并区间

题目来源&#xff1a;https://leetcode.cn/problems/merge-intervals/description/ C题解&#xff1a;根据左区间排序&#xff0c;更新每一段的右区间最大值&#xff0c;直到间断。 class Solution { public:static bool cmp(vector<int> & a, vector<int> &a…
阅读更多...
小学期笔记——天天酷跑5

小学期笔记——天天酷跑5

效果&#xff1a; -------------------------- 效果&#xff1a; ------------------ 让人物跑起来 效果&#xff1a;&#xff08;此时的人物是运动的&#xff09; ---------------------- 通过键盘控制角色 效果&#xff1a; 人物可以上左右动&#xff0c;自由落体
阅读更多...
K8S初级入门系列之二-集群搭建

K8S初级入门系列之二-集群搭建

一、前言 为了更好学习K8S&#xff0c;建议自行搭建一套K8S的环境&#xff0c;目前比较流行的有两种搭建工具&#xff0c;一种是单机版的minkube&#xff0c;一种是集群版的kubeadm。minkube更多是用于实验环境&#xff0c;且单机版隐藏了很多细节&#xff0c;而kubeadm更贴近实…
阅读更多...
Vue 3.3 + Vite 4.3 + TypeScript 5+ Element-Plus：从零到一构建企业级后台管理系统（前后端开源）

Vue 3.3 + Vite 4.3 + TypeScript 5+ Element-Plus：从零到一构建企业级后台管理系统（前后端开源）

vue3-element-admin 是基于 vue-element-admin 升级的 Vue3 Element Plus 版本的后台管理前端解决方案&#xff0c;技术栈为 Vue3 Vite4 TypeScript Element Plus Pinia Vue Router 等当前主流框架。 相较于其他管理前端框架&#xff0c;vue3-element-admin 的优势在于一…
阅读更多...
红队打靶：Nullbyte打靶思路详解（vulnhub）

红队打靶：Nullbyte打靶思路详解（vulnhub）

目录 写在开头 第一步&#xff1a;主机发现与端口扫描 第二步&#xff1a;Web渗透 第三步&#xff1a;hydra密码爆破 第四步&#xff1a;SQL注入大赏 方法一&#xff1a;手工SQL注入之联合查询 方法二&#xff1a;SQL注入写入一句话木马 方法三&#xff1a;SQL注入写入…
阅读更多...
快速了解新一轮Moonbeam Grants申请提案

快速了解新一轮Moonbeam Grants申请提案

随着Moonbeam Grant第二期计划的发布&#xff0c;超过12个项目同时提交了生态Grant申请的提案。任何大于25万枚GLMR Grant的申请都将会要求项目在Moonbeam社区治理论坛上发布Grant提案&#xff0c;内容包含项目概览、申请金额、Grant使用方案以及背后的原因等等。 Grant的发放…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023