rabbitmq学习

一文带你彻底搞懂SpringBoot-RabbitMQ(1) 一、环境搭建 采用maven多module模式,共计创建三个子module common:通用实体信息 rabbitmq-publisher:消息发布者,基于SpringBoot rabbitmq-subscriber:消息订阅者,基于SpringBoot 在消息发布者和订阅者两个项目中加入rabbitmq maven依赖 <dependency> <groupId>org.springframework.boot</groupId> 阅读详情

基础

direct模式

请添加图片描述
生產端創建並綁定交換機和隊列,其中重點關注queue的名字,exchange的名字,routingKey的名字

    @Bean
    public Queue rabbitmqDemoDirectQueue() {
        /**
         * 1、name:    队列名称
         * 2、durable: 是否持久化
         * 3、exclusive: 是否独享、排外的。如果设置为true,定义为排他队列。则只有创建者可以使用此队列。也就是private私有的。
         * 4、autoDelete: 是否自动删除。也就是临时队列。当最后一个消费者断开连接后,会自动删除。
         * */
        return new Queue(RabbitMQConfig.RABBITMQ_DEMO_TOPIC, true, false, false);
    }
    
    @Bean
    public DirectExchange rabbitmqDemoDirectExchange() {
        //Direct交换机
        return new DirectExchange(RabbitMQConfig.RABBITMQ_DEMO_DIRECT_EXCHANGE, true, false);
    }
    @Bean
    public Binding bindDirect() {
        //链式写法,绑定交换机和队列,并设置匹配键
        return BindingBuilder
                //绑定队列
                .bind(rabbitmqDemoDirectQueue())
                //到交换机
                .to(rabbitmqDemoDirectExchange())
                //并设置匹配键
                .with(RabbitMQConfig.RABBITMQ_DEMO_DIRECT_ROUTING);
    }

生產端發送消息,填寫exchange的名字,routingKey的名字和需要發送的msg

rabbitTemplate.convertAndSend(RabbitMQConfig.RABBITMQ_DEMO_DIRECT_EXCHANGE, RabbitMQConfig.RABBITMQ_DEMO_DIRECT_ROUTING, map);

消費端監聽queue的名字獲取msg

    @RabbitHandler
    @RabbitListener(queuesToDeclare = @Queue(RabbitMQConfig.RABBITMQ_DEMO_TOPIC))
    public void process(String msg, Message message, Channel channel) {}

fanout

相當於廣播
请添加图片描述
生產端綁定exchange到兩個queue,不需要設置routingKey

    @Bean
    public Queue fanoutExchangeQueueA() {
        //队列A
        return new Queue(RabbitMQConfig.FANOUT_EXCHANGE_QUEUE_TOPIC_A, true, false, false);
    }

    @Bean
    public Queue fanoutExchangeQueueB() {
        //队列B
        return new Queue(RabbitMQConfig.FANOUT_EXCHANGE_QUEUE_TOPIC_B, true, false, false);
    }

    @Bean
    public FanoutExchange rabbitmqDemoFanoutExchange() {
        //创建FanoutExchange类型交换机
        return new FanoutExchange(RabbitMQConfig.FANOUT_EXCHANGE_DEMO_NAME, true, false);
    }

    @Bean
    public Binding bindFanoutA() {
        //队列A绑定到FanoutExchange交换机
        return BindingBuilder.bind(fanoutExchangeQueueA()).to(rabbitmqDemoFanoutExchange());
    }

    @Bean
    public Binding bindFanoutB() {
        //队列B绑定到FanoutExchange交换机
        return BindingBuilder.bind(fanoutExchangeQueueB()).to(rabbitmqDemoFanoutExchange());
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //启动项目即创建交换机和队列
        rabbitAdmin.declareExchange(rabbitmqDemoFanoutExchange());
        rabbitAdmin.declareQueue(fanoutExchangeQueueB());
        rabbitAdmin.declareQueue(fanoutExchangeQueueA());
        return null;
    }

因爲是廣播,所以生產端發送msg只需要填寫exchange和msg

rabbitTemplate.convertAndSend(RabbitMQConfig.FANOUT_EXCHANGE_DEMO_NAME, "", message);

消費端監聽queue

@Component
@RabbitListener(queuesToDeclare = @Queue(RabbitMQConfig.FANOUT_EXCHANGE_QUEUE_TOPIC_A))
public class FanoutExchangeConsumerA {

    @RabbitHandler
    public void process(Map<String, Object> map) {
        System.out.println("队列A收到消息:" + map.toString());
    }
}

@Component
@RabbitListener(queuesToDeclare = @Queue(RabbitMQConfig.FANOUT_EXCHANGE_QUEUE_TOPIC_B))
public class FanoutExchangeConsumerB {

    @RabbitHandler
    public void process(Map<String, Object> map) {
        System.out.println("队列B收到消息:" + map.toString());
    }
}

topic

通過設置routingKey的匹配模式,匹配到相應的queue,根據routingKey,可以發給多個queue,也可以發給單個queue
请添加图片描述

@Bean
    public TopicExchange rabbitmqDemoTopicExchange() {
        //配置TopicExchange交换机
        return new TopicExchange(RabbitMQConfig.TOPIC_EXCHANGE_DEMO_NAME, true, false);
    }

    @Bean
    public Queue topicExchangeQueueA() {
        //创建队列1
        return new Queue(RabbitMQConfig.TOPIC_EXCHANGE_QUEUE_A, true, false, false);
    }

    @Bean
    public Queue topicExchangeQueueB() {
        //创建队列2
        return new Queue(RabbitMQConfig.TOPIC_EXCHANGE_QUEUE_B, true, false, false);
    }

    @Bean
    public Queue topicExchangeQueueC() {
        //创建队列3
        return new Queue(RabbitMQConfig.TOPIC_EXCHANGE_QUEUE_C, true, false, false);
    }

    @Bean
    public Binding bindTopicA() {
        //队列A绑定到FanoutExchange交换机
        return BindingBuilder.bind(topicExchangeQueueB())
                .to(rabbitmqDemoTopicExchange())
                .with("a.*");
    }

    @Bean
    public Binding bindTopicB() {
        //队列A绑定到FanoutExchange交换机
        return BindingBuilder.bind(topicExchangeQueueC())
                .to(rabbitmqDemoTopicExchange())
                .with("a.*");
    }

    @Bean
    public Binding bindTopicC() {
        //队列A绑定到FanoutExchange交换机
        return BindingBuilder.bind(topicExchangeQueueA())
                .to(rabbitmqDemoTopicExchange())
                .with("rabbit.#");
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        rabbitAdmin.declareExchange(rabbitmqDemoTopicExchange());
        rabbitAdmin.declareQueue(topicExchangeQueueA());
        rabbitAdmin.declareQueue(topicExchangeQueueB());
        rabbitAdmin.declareQueue(topicExchangeQueueC());
        return null;
    }
}

生產端填寫exchange,routingKey,msg

rabbitTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE_DEMO_NAME, routingKey, message);

消費端監聽queue

@Component
@RabbitListener(queuesToDeclare = @Queue(RabbitMQConfig.FANOUT_EXCHANGE_QUEUE_TOPIC_A))
public class FanoutExchangeConsumerA {

    @RabbitHandler
    public void process(Map<String, Object> map) {
        System.out.println("队列A收到消息:" + map.toString());
    }
}

@Component
@RabbitListener(queuesToDeclare = @Queue(RabbitMQConfig.FANOUT_EXCHANGE_QUEUE_TOPIC_B))
public class FanoutExchangeConsumerB {

    @RabbitHandler
    public void process(Map<String, Object> map) {
        System.out.println("队列B收到消息:" + map.toString());
    }
}

@Component
@RabbitListener(queuesToDeclare = @Queue(RabbitMQConfig.FANOUT_EXCHANGE_QUEUE_TOPIC_C))
public class FanoutExchangeConsumerC {

    @RabbitHandler
    public void process(Map<String, Object> map) {
        System.out.println("队列C收到消息:" + map.toString());
    }
}

這時如果routingKey為rabbit.abcd則匹配到C
如果routingKey為a.b則匹配到A和B

header

header模式會根據msg的類型自動路由
生產端綁定

    @Bean
    public Binding bindHeadersA() {
        Map<String, Object> map = new HashMap<>();
        map.put("key_one", "java");
        map.put("key_two", "rabbit");
        //全匹配
        return BindingBuilder.bind(headersQueueA())
                .to(rabbitmqDemoHeadersExchange())
                //全匹配
                .whereAll(map).match();
				//或者任意匹配
				//.whereAny(map).match();
    }

生产端发送消息

rabbitTemplate.convertAndSend(RabbitMQConfig.HEADERS_EXCHANGE_DEMO_NAME, null, message);
消息主体{"key_one":"java", "key_two":"rabbit"}

会被消费端匹配

容易产生的问题

1消息堆积

当生产者生产的速度大于消费者的时候就会产生堆积的问题,这个时候如果不是生产者的问题,就需要扩大消费者的规模,或者将新的消息转移到别的队列中

消费者配置线程数量和最大线程数量

@Configuration
public class RabbitMQConfig {
    public static final String QUEUE_WORK_AI_TASK = "queue_work_ai_task";
    // 声明交换机
    // 声明队列
	@Bean("AIContainerFactory")
	public SimpleRabbitListenerContainerFactory containerFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer, 
		ConnectionFactory connectionFactory) {
   		SimpleRabbitListenerContainerFactory container= new SimpleRabbitListenerContainerFactory();
   		container.setConcurrentConsumers(5);
   		container.setMaxConcurrentConsumers(10);
  		configurer.configure(factory, connectionFactory);
  		// 是否重回队列
        container.setDefaultRequeueRejected(true);
        // 手动确认
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
   		return factory;
 	}
 	
}

2消息丢失

由于宕机或者其他某些原因

1.消息在生产端丢失
2.消息在队列中丢失
3.消息在消费端丢失

1.解决办法:事务和confirm模式
事务很好理解,生产端失败可以回滚。
confirm模式是生产端给消息加上唯一的编号,queue收到数据后返回ack确认。
这样创建confirm模式

ConnectionFactory factory = new ConnectionFactory();
Connection connection = null;
// 创建信道
Channel channel = null;
// 创建连接
connection = factory.newConnection();
// 创建信道
channel = connection.createChannel();
channel.confirmSelect();

或者这样配置
在这里插入图片描述

2.解决办法:持久化队列
参数1队列名称,参数2是否持久化,参数3是否独占模式,参数4是否自动删除

Queue(RabbitMQConfig.RABBITMQ_DEMO_TOPIC, true, false, false);

3.解决办法:消费端宕机后数据无法恢复,是没有设置手动确认导致的,使用如下方法设置:

    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        //此处也设置为手动ack
        factory.setConnectionFactory(connectionFactory);
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        return factory;
    }
    
	public enum AcknowledgeMode {
    	NONE,
    	MANUAL,
    	AUTO;
	}

消费端手动确认代码如下

 @RabbitListener(queues = RabbitExChangeConfig.DEAD_LETTER_QUEUE, containerFactory = "simpleRabbitListenerContainerFactory")
    public void reciveDeadLetter(Message message, Channel channel, @Headers Map<String, Object> headers) throws IOException {
        long deliveryTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
        try {
 
            System.out.println("死信队列消费者收到消息 : " + new String(message.getBody(), "UTF-8"));
            /**
             * 手动ack
             * deliveryTag:该消息的index
             * multiple:是否批量.true:将一次性ack所有小于deliveryTag的消息。
             */
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            //消息退回 (可以在可视化界面看到)
            //批量退回 退回之后重回消息队列 true  false的话就是丢弃这条信息,如果配置了死信队列,那这条消息会进入死信队列
            channel.basicNack(deliveryTag, false, true);
            //单条退回 channel.basicReject();
        }
    }

如果想使用数据库记录生产者生产失败的记录,消费者消费失败的记录,配置文件按照如下配置

	@PostConstruct
    public void initRabbitTemplate(){
        /**
         * @param correlationData  当前消息的唯一关联数据  ,这个是消息的唯一id
         * @param ack 消息是否成功收到
         * @param cause 失败原因
         */
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (!ack){
                    //修改数据库
                    aiTaskService.update(new UpdateWrapper<AiTask>()
                            .eq("id",correlationData.getId())
                            .set("cause",cause)
                            .set("state", AiTask.AI_WORK_FAILURE));
                }
            }
        });
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             * 只要消息没有投递给指定的队列,就会触发这个失败回调
             * @param message   投递失败的消息
             * @param replyCode  回复的状态码
             * @param replyText  回复的文本内容
             * @param exchange  消息发送的交换机
             * @param routingKey  消息走的路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                //修改数据库
                String s = new String(message.getBody());
                AiMqMessageVo aiMqMessageVo = JSONObject.parseObject(s, AiMqMessageVo.class);
                aiTaskService.update(new UpdateWrapper<AiTask>()
                        .eq("id",aiMqMessageVo.getId())
                        .set("cause","未成功投递给指定队列。信息 - > 状态码:"+replyCode + " 文本内容:"+replyText  + "  交换机:"+exchange  + "  路由:"+routingKey)
                        .set("state", AiTask.AI_WORK_FAILURE));
            }
        });
    }
 }

3重复消费

一般情况下消费端消费过后需要发送确认消息给队列,如果由于某些意外原因比如网络故障,队列没有收到消息。就会导致队列将消息重新发送给其他消费者,就会导致重复消费。或者,消费之后还没来得及返回确认消息就重启了等等情况。

既然mq端我们无法解决,那就在消息上下功夫。
解决办法:

1.消息设置唯一的ID作为数据库主键id,这样在insert的时候如果重复消费就会报错。

2.Redis 设置全局唯一id
每次生产者发送消息前设置一个全局唯一id放在消息体重,并存放的 redis 里,在消费端接口上先找在redis 查看是否存在全局id,如果存在,调用消费接口并删除全局id,如果不存在,不做后续操作。

生产端在redis中添加id的值到集合当中,并把id添加到消息中。

private static int id;
jedis.sadd("id", id);
Map<String, String> map = new HashMap<>();
map.add("id", id++);
//其他逻辑
//发送消息

消费端

    @RabbitHandler
    @RabbitListener(queuesToDeclare = @Queue("topicDemo1"))
    public void process(Map<String, String> msg, Message message, Channel channel) {
        long tag = message.getMessageProperties().getDeliveryTag();
        Action action = Action.SUCCESS;
        try {
            //操作redis, 解决重复消费问题
            String id = msg.get("id");
            Set<Integer> allId;
            if(!(allId = jedis.get("id")).contains(id){
                System.out.println("重复消费");
                return;
            }else{
            	//从集合中删除
            	allId.srem(id);
            }
            //其他逻辑
        }
    }

4死信队列

队列中已经死亡的信息,顾名思义,这些信息已经不会被消费者消费
有几种可能
1消息被拒绝(basic.reject / basic.nack),并且requeue = false
2消息TTL过期
3队列达到最大长度

如何解决呢
1.丢弃,如果不是很重要,可以选择丢弃
2.记录死信入库,然后做后续的业务分析或处理
3.通过死信队列,由负责监听死信的应用程序进行处理

这里采用的是配置死信队列的方式
详见:https://blog.youkuaiyun.com/doupengzp/article/details/106929216

rabbitmq实现分布式事务

场景如下,用户在订单中心生成订单修改数据库,同时订单要同步到运单中心。
在这里插入图片描述
如果只在订单中心写事务的逻辑,当回滚操作时,运单中心就无法保障了
在这里插入图片描述
于是我们使用rabbitmq中间件,对于消息进行异步暂存
在这里插入图片描述

  1. 在订单系统数据库中增加消息状态表
    在这里插入图片描述

  2. 生产端开启confirm机制,当消息确实送到queue中返回ack,并修改本地消息状态表。如果发送失败,定期查询数据库消息状态表,重新发送。
    在这里插入图片描述

  3. queue开启持久化,防止宕机消息丢失。
    防止重复消费,数据库中使用唯一id进行鉴别。

  4. 消费者开启手动ack,当消息处理失败的时候,queue可以重新发送。消费端处理成功时再从queue中移除

  5. 消费者重复消费多次仍然失败,则运维人员处理,或者移交到死信队列,对订单中心进行回滚操作。

其他

負載均衡

CAP理论

一致性
可用性
分区容错性

RabbitMQ:实现消息确认与消息返回 不了解RabbitMQ的消息确认与消息返回可以参考下面两篇博客: RabbitMQ:消息确认机制 RabbitMQ:Return消息机制 pom.xml: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoca 阅读详情

相关推荐

RabbitMQ 学习路线与知识总结

以下是 RabbitMQ 学习路线与知识总结,结合 Mermaid 生成的脑图,帮助你系统掌握核心概念和实战技巧。

专注后端开发 1318

SpringBoot RabbitMQ 入门学习(详细)

目录安装 RabbitMQ初始化 SpringBoot 项目导入依赖添加配置配置文件 application.yml添加配置类 RabbitMqConfig简单队列发送者消费者测试类测试的 Controller单元测试类运行路由(交换机)创建一个交换机(Exchange)交换机与队列的绑定Topic Exchange修改 `Sender` 类的 `send` 方法测试Headers Exchange 自定义规则Fanout Exchange 订阅模式创建订阅交换机消失丢失开启RabbitMQ的数据持久化参考

qq_37280924的博客 1918

RabbitMQ超详细学习笔记(章节清晰+通俗易懂)

RabbitMQ超详细学习笔记,章节清晰,通俗易懂

欢迎来到 Baret-H 的博客 8万+

Binding与BindingBuilder源码解读

Binding在Spring-AMQP下core中,生产者创建消息发送至exchange,消费者从队列中消费消息,队列与交换器的绑定关系便是由Binding来表示的,类中的说明原文:Simple container collecting information to describe a binding. Takes String destination and exchange names as...

8843

PC网站实现微信扫码登录功能(二)

上篇我们介绍了怎么申请账号以及最后拿到appId和appSecret,如果有不清楚的可以看一下 PC网站实现微信扫码登录功能(一) 下面我就来说一下怎样在PC端怎么实现扫码登录功能。 一、进入官方文档网站 https://developers.weixin.qq.com/doc/oplatform/Website_App/WeChat_Login/Wechat_Login.html 其实官网对过程描述的已经非常细致了。并且提供了两种扫码方式。一种是跳转二维码扫描页面,另一种是内嵌式二维码。大家可以

qq_35771266的博客 3万+

利用李雅普诺夫函数开发航天器姿态控制系统

本文基于李雅普诺夫函数控制方法,采用修正罗德里格斯参数(MRP)描述航天器姿态,设计了姿态控制律。通过构造能量型李雅普诺夫函数,推导出保证系统稳定的控制闭环方程,实现了航天器从初始状态到目标状态的稳定转换。针对MRP参数可能出现的奇异性问题,采用影子集进行规避。仿真实验包含两种模式:非追踪模式(目标状态为0)和追踪模式(目标为三角函数轨迹)。结果表明,该控制方法能够有效实现姿态稳定和轨迹跟踪,在短暂调整后即可精确跟随目标轨迹。控制律设计考虑了不同参考系间的转换,通过DCM矩阵处理目标角速度的坐标变换问题。

weixin_50227659的博客 1224

2021-09-28

Spring Boot 消息队列 RabbitMQ 入门 1.概述 RabbitMQ 是 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现,由以高性能、健壮以及可伸缩性出名的 Erlang 写成,因此也是继承了这些优点。 AMQP 里主要要说两个组件:Exchange 和 Queue (在 AMQP 1.0 里还会有变动),如下图所示,绿色的 X 就是 Exchange ,红色的是 Queue ,这两者都在 Server 端,又称作 B

zhaoyanjun008的博客 418

Unity开源游戏源码精选:17个亲测可运行教学项目

Unity游戏开发中,掌握真实项目结构与工程实践远比熟记API更重要。本文围绕‘Unity开源项目’和‘游戏源码’两大核心概念,解析高质量开源资源的本质特征——结构清晰、逻辑可溯、修改即时反馈。从基础的MonoBehaviour生命周期组织,到进阶的ScriptableObject数据驱动、事件总线解耦,再到架构级的DOTS ECS设计与网络同步模式,技术价值在于将抽象原理落地为可调试、可验证、可迁移的代码范式。适用于新手建立开发直觉、中级开发者突破系统设计瓶颈,以及团队构建可维护框架。所有项目均基于Uni

weixin_31528001的博客 725

RabbitMQ学习

rabbitmq学习

qq_47660541的博客 346

电影票购票小程序搭建(源码部署)

答:为用户提供便捷的购票方式,包括授权登录、个性化推荐、在线选座、订单管理等功能,同时在界面设计上注重用户友好性,简化用户的购票流程。答:通过展示电影院的优惠活动和票价信息,同时提供电影推荐功能,根据用户的历史购票记录和电影评分推荐个性化的电影列表,吸引用户购票。编写页面逻辑代码:使用JavaScript编写小程序页面的逻辑代码,实现电影列表的获取、电影详情的展示、座位选择的逻辑等。设计小程序界面:使用WXML和WXSS编写小程序的界面代码,实现电影列表的展示、电影详情的样式、座位选择页面的布局等。

2301_79072569的博客 2068

【openwrt-21.02】T750 openwrt 双系统说明及切换方法

高度集成的 T750 平台大幅减少组件数量,为产品设计者提供更小的尺寸和更低的功耗。T750 采用先进的 7nm 制程,高度集成 5G 调制解调器和四核 Arm CPU,提供较强的功能和配置,设备制造商得以打造精巧的高性能 CPE 产品,如固定无线接入(FWA)路由器和移动热点。3. preloader 加载并启动 A 系统,若 A 系统的任一启动阶段加载失败,preloader 将重新加载并启动 A 系统 3 次,若 3 次均失败,则自动切换至 B 系统,加载并启动 B 系统。A/B 系统切换流程如下。

wgl307293845的博客 1419

RabbitMQ深入学习指导

本文收集了一些关于RabitMQ学习参考的资料,以备学习之用。最初对RabbitMQ学习基于一次愉快的尝试,但是学习怎可不深入之?每一种MQ都解决了不同的问题,各有所长,所以深入学习和研究就是很有必要的了。最近在研究阿里巴巴的RocketMQ,发现之前的RabbitMQ学习止于环境搭建和基本的测试连通性,离真正的应用自如还有一定的差距,于是迫不及待想写一篇关于如何深入学习Rabbit的文章(因为时...

纸上得来终觉浅,绝知此事要躬行 3822

27930-2015+充电协议解析

对2015+充电与2015充电进行硬件电路对比、通信协议对比和2015+通信协议解析。

manjixingkong1234的专栏 242

RabbitMQ实战学习

RabbitMQ是一个广泛使用的开源消息中间件,它实现了高级消息队列协议(AMQP)标准。该系统允许不同应用程序之间进行可靠且高效的通信,通过提供消息传递、队列、交换机和绑定等功能。RabbitMQ的架构灵活且模块化,使得它适用于各种不同的场景,包括分布式系统、微服务架构和异步任务处理。 本文章通过黑马程序员学习,整理了一些常用RabbitMQ的学习资料,冲冲冲!!!

qq_45830276的博客 1709

Microsemi Libero使用技巧1——查看芯片资源占用情况

Microsemi Libero使用技巧——查看芯片资源占用情况 前言 与MCU不同,FPGA的资源主要包括:逻辑资源,IO资源,Flash大小,PLL资源,SoC硬核处理器资源等,其中逻辑资源和IO资源是我们主要关心的,本篇文章将介绍,如何通过Microsemi Libero IDE来查看工程的详细资源占用情况。 A2F200M3F的资源 以Microsemi SmartFusion系列A2F2...

whik1194的博客 5700

YOLOv13改进策略【多YAML融合】| HWD + DSC3k2_PConv + Detect_MBConv

本文记录的是利用HWD + DSC3k2_PConv + Detect_MBConv改进YOLOv13,分别涉及骨干、颈部和检测头部分的改进。一方面按照此配置,其工作量及创新程度能够满足论文发表的需求,另一方面是一些难以融合多个YAML的举例,以帮助大家理解如何将多个YAML整合到一个YAML中。小波下采样:一个简单但有效的语义分割下采样模块。块由两个主要块组成:无损特征编码块和特征表示学习块。HWD模块与其他下采样模块对比:保留信息能力:传统的下采样方法(如最大池化、平均池化和步幅卷积等)会导致信息丢失,

Limiiiing的博客 499

Rabbitmq学习

rabbitmq

weixin_51751186的博客 2301

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

RabbitMQ入门——学习笔记

(1)Exchanges交换机没有存储数据的能力,它收到数据就马上转发,不会存下来,所以接收数据失败了数据就丢失了(2)交换机必须要和queue进行绑定,只会把消息给和它绑定的queue点进指定交换机,选择bindings在Add binding from this exchange填入交换机的名字,然后点击bind就行这时候发信息就可以成功!!

2501_90975132的博客 947

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

【RabbitMQ】RabbitMQ学习

根据routing key ,会发送给 binding Key 符合的对列。一个交换机,将消息转发到于其绑定的所有对列,每个消费者都能享有这些消息。将消息转发给 和带有通配符的 binding key 的对列。根据消息内容进行匹配,消息内容中有headers内容进行匹配,这个模式中,多了一个 exchange host 角色。发送消息的时候,使用的是 Routing Key。传到对列的时候,使用的是 Binding Key。一个消费者一个生产者,直接进行通信。

这个人很勤快,但还是什么也没有。 1067

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

运维RabbitMQ 系统 & 学习计划

以上链接均来源于作者博客的原创专栏,涵盖了 RabbitMQ 的核心运行参数、配置与存储布局、常用 CLI 命令、Management 插件功能、Exchange/Queue/VHost 核心概念及整体架构图等关键主题,适合作为入门与运维参考。

喝醉酒的小白 1063

RabbitMQ学习总结

转载: https://blog.youkuaiyun.com/qq_40298902/article/details/108499885

qq_36854073的博客 182

黑马rabbitmq学习

黑马rabbitmq学习

flamesfather的博客 99

RabbitMq学习(第一天)

rabbitmq入门,搭建环境,熟悉使用,配置消息转换器、配置类和配置注解使用

su_xu_chao的博客 1008

RabbitMQ 学习笔记

https://www.yuque.com/docs/share/873fc642-77b9-4156-97f6-184462c8d3b1

284
上一篇: zookeeper学习
下一篇: netty源码分析channel初始msg
小健健健
博客等级 码龄8年 101粉丝 68原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值