Spring Boot与RabbitMQ死信队列深度整合(从原理到生产级实践)

第一章:Spring Boot与RabbitMQ死信队列概述

在现代微服务架构中,消息中间件扮演着至关重要的角色。RabbitMQ 作为一款高性能、可靠的消息代理,广泛应用于异步通信和解耦系统模块。而 Spring Boot 凭借其自动配置和快速集成能力,成为构建 RabbitMQ 应用的首选框架。两者结合可高效实现消息的发布与订阅机制。 当消息在队列中无法被正常消费时(例如消费者拒绝消息、消息过期或队列达到最大长度),RabbitMQ 提供了“死信”(Dead Letter)机制,将这些消息重新路由到指定的死信交换机(Dead Letter Exchange, DLX),进而转发至死信队列(DLQ)进行集中处理。这一机制有助于故障排查、消息重试和异常监控。

死信队列的核心组件

  • 消息TTL(Time-To-Live):设置消息过期时间,过期后自动成为死信
  • 队列长度限制:超过最大长度的消息会被移入死信队列
  • 消息拒绝:消费者使用 basic.reject 或 basic.nack 并设置 requeue=false 时触发

典型应用场景

场景说明
订单超时未支付设置消息TTL,到期后进入死信队列触发取消逻辑
消息消费失败重试多次重试失败后转入死信队列人工干预

配置示例

// 配置普通队列并绑定死信交换机
@Bean
public Queue normalQueue() {
    return QueueBuilder.durable("normal.queue")
        .withArgument("x-dead-letter-exchange", "dlx.exchange") // 指定死信交换机
        .withArgument("x-message-ttl", 10000) // 消息10秒未消费则过期
        .build();
}

@Bean
public DirectExchange dlxExchange() {
    return new DirectExchange("dlx.exchange");
}
上述代码定义了一个带有 TTL 和死信路由的队列,消息在10秒内未被消费将自动转发至死信交换机。

第二章:死信队列的核心原理与机制解析

2.1 死信消息的产生条件与触发场景

在消息队列系统中,死信消息(Dead Letter Message)是指无法被正常消费的消息,通常由特定条件触发。主要产生条件包括:消息被消费者拒绝且未重新入队、消息过期、队列达到最大长度限制。
常见触发场景
  • 消费者显式拒绝消息(如 RabbitMQ 中 basic.reject 或 basic.nack)
  • 消息 TTL(Time-To-Live)过期,未能及时处理
  • 队列堆积满,新消息无法入队
配置示例(RabbitMQ)

{
  "arguments": {
    "x-dead-letter-exchange": "dlx.exchange",
    "x-dead-letter-routing-key": "dlx.key"
  }
}
该配置定义了当消息满足死信条件时,将被路由至指定的死信交换机 dlx.exchange,并使用 dlx.key 作为路由键进行转发,便于后续排查与处理。

2.2 RabbitMQ中死信交换机与队列的绑定关系

在RabbitMQ中,死信交换机(Dead Letter Exchange, DLX)通过绑定特定的队列来接收被拒绝或过期的消息。当消息在原队列中成为“死信”时,会自动路由到DLX,并由其转发至绑定的死信队列。
绑定机制配置
通过为普通队列设置 `x-dead-letter-exchange` 参数,指定死信消息的转发目标:

const queueOptions = {
  arguments: {
    'x-dead-letter-exchange': 'dlx.exchange',     // 指定死信交换机
    'x-dead-letter-routing-key': 'dlx.routing.key' // 可选:指定死信路由键
  }
};
channel.assertQueue('normal.queue', queueOptions);
上述代码中,`x-dead-letter-exchange` 定义了死信消息应发送到的交换机名称。若未设置 `x-dead-letter-routing-key`,则使用原始消息的 routing key。
典型绑定流程
  • 消息在原队列中被拒绝(basic.reject 或 basic.nack)且不重新入队
  • 消息TTL过期
  • 队列达到最大长度限制,导致消息被丢弃
  • 消息被转移至DLX,并根据routing key投递到对应的死信队列

2.3 TTL过期机制与延迟消息的底层实现

在消息队列系统中,TTL(Time To Live)是控制消息生命周期的核心机制。每条消息可设置存活时间,超过该时限未被消费则标记为过期。
过期检测与延迟调度
系统通常借助定时任务轮询或时间轮算法来检测过期消息。以RabbitMQ为例,其内部通过dead-letter exchange机制将过期消息转发至指定交换机进行后续处理。

{
  "message": "order_timeout",
  "ttl": 60000,
  "delay_exchange": "dlx.exchange"
}
上述配置表示消息在队列中最多存活60秒,超时后自动进入死信队列,实现延迟解耦。
延迟消息的实现策略
  • 基于优先级队列的时间轮算法,适用于高精度延迟场景
  • 利用外部存储如Redis的ZSET按到期时间排序轮询
  • 消息中间件原生支持,如RocketMQ的延迟等级机制

2.4 队列长度限制与消息丢弃策略分析

在高并发系统中,队列的长度限制直接影响系统的稳定性与响应性能。当生产者速度超过消费者处理能力时,队列可能迅速积压,导致内存溢出或延迟飙升。
常见消息丢弃策略
  • Drop Newest:丢弃最新到达的消息,保障已有消息处理;
  • Drop Oldest:移除队列头部消息,适用于实时性要求高的场景;
  • Reject:拒绝新消息并抛出异常,由生产者决定后续行为。
代码示例:自定义有界队列策略
type BoundedQueue struct {
    ch chan Message
}

func (q *BoundedQueue) Push(msg Message) bool {
    select {
    case q.ch <- msg:
        return true // 入队成功
    default:
        return false // 队列满,触发丢弃
    }
}
上述实现采用非阻塞写入,当 q.ch 满时立即返回失败,可在上层结合日志或监控实现降级逻辑。
策略对比表
策略内存控制消息完整性适用场景
Drop Newest强低实时流处理
Drop Oldest强中事件聚合

2.5 死信流程的完整链路追踪与调试方法

在分布式消息系统中,死信队列(DLQ)是排查消费失败问题的核心机制。为实现全链路追踪,需在消息投递、处理、失败入队等环节注入唯一 traceId。
链路标识注入
生产者发送消息时应携带追踪上下文:
{
  "payload": {"orderId": "1001"},
  "headers": {
    "traceId": "req-50d2a8e1",
    "retryCount": 3
  }
}
该 traceId 需贯穿消费者处理逻辑及日志输出,便于通过日志系统聚合分析。
调试工具集成
使用集中式追踪平台(如 Jaeger)捕获消息流转路径。关键节点包括:
  • 原始队列消费失败
  • 进入死信队列过程
  • 人工或自动重试动作
状态流转表
阶段traceId传递日志标记
生产者注入SEND_TO_QUEUE
消费者继承CONSUME_FAIL
DLQ路由保留MOVE_TO_DLQ

第三章:Spring Boot集成RabbitMQ基础配置

3.1 项目搭建与依赖引入最佳实践

初始化项目结构
合理的项目结构有助于后期维护。建议采用标准分层模式,如 cmd/、internal/、pkg/ 和 config/。
依赖管理策略
使用 Go Modules 管理依赖,确保版本锁定与可重现构建。初始化命令如下:
go mod init myproject
go get -u github.com/sirupsen/logrus@v1.9.0
该命令初始化模块并引入日志库 logrus 的指定版本,避免因版本漂移导致兼容性问题。
  • 优先选择稳定且社区活跃的第三方库
  • 定期执行 go list -m -u all 检查过期依赖
  • 使用 replace 指令在测试私有 fork 时避免发布干扰

3.2 RabbitMQ连接工厂与模板配置详解

在Spring AMQP中,RabbitMQ的连接管理依赖于`CachingConnectionFactory`,它负责创建和缓存AMQP连接与信道。通过合理配置连接工厂,可提升系统稳定性与吞吐能力。
连接工厂基础配置
CachingConnectionFactory factory = new CachingConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
factory.setVirtualHost("/");
上述代码设置连接参数:主机、端口、认证信息及虚拟主机。连接池可通过setChannelCacheSize()控制缓存信道数量,减少重复创建开销。
RabbitTemplate核心作用
RabbitTemplate用于发送和接收消息,需绑定连接工厂:
RabbitTemplate template = new RabbitTemplate(factory);
template.setExchange("order-exchange");
template.setRoutingKey("order.route");
该模板自动处理序列化、信道获取与异常重试,是应用与Broker交互的核心组件。
关键配置参数对比
参数作用推荐值
channelCacheSize缓存信道数10-25
connectionTimeout连接超时(ms)30000
publisherConfirmType发布确认模式Correlated

3.3 声明交换机、队列与绑定关系的代码实现

在 RabbitMQ 应用开发中,正确声明交换机、队列及其绑定关系是消息通信的基础。首先需要通过客户端库建立连接,并在通道上完成资源的声明。
声明交换机
使用 AMQP 协议定义交换机类型,如 direct、topic 等,确保路由规则匹配业务需求。
err := channel.ExchangeDeclare(
    "logs",   // name
    "topic",  // type
    true,     // durable
    false,    // autoDelete
    false,    // internal
    false,    // noWait
    nil,      // args
)
参数说明:持久化(durable)保证服务器重启后交换机不丢失;autoDelete 在无绑定时自动删除。
声明队列与绑定
队列声明后需与交换机通过路由键绑定,形成完整的消息路径。
  • queue: 声明唯一队列名称,支持临时队列(name="")
  • bindingKey: 使用通配符匹配 topic 类型消息
_, err := channel.QueueDeclare("user.events", true, false, false, false, nil)
err = channel.QueueBind("user.events", "user.*", "logs", false, nil)
该绑定将路由键以 user. 开头的消息投递至 user.events 队列。

第四章:生产级死信队列设计与实战应用

4.1 订单超时关闭场景下的死信队列实现

在电商系统中,订单创建后若用户未在指定时间内支付,需自动关闭订单。借助消息队列的死信机制可高效实现该功能。
死信队列工作流程
当订单消息在延迟队列中未被消费,超时后将自动进入死信队列。监听死信队列的服务可接收该消息并执行订单关闭逻辑。
配置项说明
ttl消息存活时间,如 15 分钟
dead-letter-exchange绑定死信交换机
dead-letter-routing-key指定死信路由键
@Bean
public Queue orderTtlQueue() {
    return QueueBuilder.durable("ORDER_TTL_QUEUE")
        .withArgument("x-message-ttl", 900000) // 15分钟
        .withArgument("x-dead-letter-exchange", "DLX_EXCHANGE")
        .build();
}
上述代码定义了一个带TTL和死信转发规则的队列。消息过期后自动路由至死信交换机,由绑定的死信队列接收并触发关闭操作。

4.2 消息重试机制与死信二次处理策略

在分布式消息系统中,消息消费失败是常见场景。为保障最终一致性,需引入消息重试机制。通常采用指数退避策略进行有限次重试,避免频繁重试导致系统压力。
重试流程控制
  • 首次失败后延迟1秒重试
  • 每次重试间隔倍增,最大不超过10分钟
  • 重试次数超过阈值后进入死信队列(DLQ)
// 示例:Go中基于RabbitMQ的重试逻辑
if delivery.Headers["x-retry-count"] == nil {
    headers := amqp.Table{"x-retry-count": 1}
    // 发送回队列并设置重试次数
    channel.PublishWithContext(ctx, "", "retry_queue", false, false, amqp.Publishing{
        Headers:     headers,
        Body:        delivery.Body,
        DeliveryMode: amqp.Persistent,
    })
}
上述代码通过消息头记录重试次数,实现可控重试。参数x-retry-count用于追踪已重试次数,防止无限循环。
死信队列二次处理
字段说明
源队列原始消息所属队列
失败原因解析异常或处理超时
处理状态待人工介入或自动修复
死信消息可通过独立消费者分析原因,支持手动修正后重新投递或归档。

4.3 死信消息告警与监控体系构建

在分布式消息系统中,死信队列(DLQ)是排查异常消息的核心机制。当消息因消费失败、超时或达到最大重试次数后进入死信队列,需建立完善的告警与监控体系,及时发现潜在服务异常。
监控指标设计
关键监控指标包括:
  • 死信消息产生速率:反映消费者处理稳定性
  • 死信队列积压长度:判断故障持续时间与影响范围
  • 消息重试次数分布:识别高频失败任务
告警规则配置示例
{
  "alert": "dlq_message_threshold",
  "metric": "dlq_queue_size",
  "threshold": 100,
  "duration": "5m",
  "action": ["notify:ops-team", "trigger:autoscaling"]
}
该规则表示:若死信队列长度持续5分钟超过100条,则触发告警并通知运维团队,同时尝试启动备用消费者扩容。
可视化监控面板
监控项当前值告警状态
DLQ 消息数23正常
平均处理延迟1.2s正常
失败率0.8%警告

4.4 高可用架构下的容错与补偿方案设计

在高可用系统中,服务容错与异常补偿是保障业务连续性的核心机制。为应对网络抖动、节点宕机等故障,常采用熔断、降级与重试策略相结合的方式。
熔断机制实现
// 基于 Go 语言的熔断器示例
func NewCircuitBreaker() *CircuitBreaker {
    return &CircuitBreaker{
        threshold: 5,     // 错误阈值
        interval:  10 * time.Second, // 统计窗口
    }
}
该熔断器在连续5次失败后自动开启,阻止后续请求,避免雪崩效应。
补偿事务设计
使用Saga模式管理分布式事务,通过反向操作补偿失败步骤:
  • 订单创建 → 扣减库存 → 支付处理
  • 任一环节失败,触发逆向补偿:释放库存、取消订单
重试策略配置
策略类型重试间隔适用场景
指数退避1s, 2s, 4s...临时性故障
固定间隔1s低延迟服务

第五章:总结与生产环境建议

监控与告警机制的建立
在生产环境中,系统的可观测性至关重要。应部署完善的监控体系,涵盖应用性能、资源利用率和日志聚合。例如,使用 Prometheus 收集指标,Grafana 可视化,并通过 Alertmanager 配置关键阈值告警:

# prometheus.yml 片段
scrape_configs:
  - job_name: 'go_service'
    static_configs:
      - targets: ['localhost:8080']
配置管理的最佳实践
避免将敏感信息硬编码在代码中。推荐使用环境变量或专用配置中心(如 Consul、etcd)进行集中管理。Kubernetes 环境下可结合 ConfigMap 和 Secret 实现动态注入。
  • 数据库连接字符串应通过 Secret 注入
  • 不同环境使用独立的配置命名空间
  • 配置变更需经过版本控制与审核流程
高可用架构设计
为保障服务连续性,建议采用多副本部署并跨可用区分布。以下为某电商系统在 AWS 上的实际部署结构:
组件实例数量部署区域容灾策略
API Gateway6us-east-1a, us-east-1b自动故障转移
PostgreSQL2 (主从)us-east-1a, us-east-1c异步复制 + WAL 归档
灰度发布流程实施
新版本上线前应在小流量组验证稳定性。可通过 Istio 实现基于 Header 的路由分流:

用户请求 → 负载均衡器 → [90% 流量 → v1 | 10% 流量 → v2] → 监控对比 → 全量发布

Spring Boot整合RabbitMQ:消息队列实战指南 消息队列作为分布式系统解耦的核心组件,通过异步通信机制实现服务间松耦合。RabbitMQ作为AMQP协议的主流实现,与Spring Boot的深度整合为微服务架构提供了可靠的消息中间件解决方案。其核心原理包括交换机路由机制、消息持久化、消费者ACK确认等,能有效解决流量削峰、系统容错等分布式场景问题。在电商支付、物流跟踪等业务场景中,结合死信队列、消息幂等等特性,可构建高可用的异步处理系统。本文通过Spring Boot与RabbitMQ的工程实践,详解从基础配置到生产级优化的全链路实现方案。 阅读详情

相关推荐

RabbitMQ在高并发场景下的应用与优化实践

消息队列作为分布式系统中的关键组件,通过异步通信机制实现服务解耦和流量削峰。其核心原理是将消息生产者与消费者分离,利用队列缓冲瞬时高并发请求,保障系统稳定性。RabbitMQ作为主流消息中间件,凭借灵活的路由规则和可靠的消息传递,特别适合电商、社交等需要保证消息顺序的业务场景。本文以黑马点评系统为例,展示如何通过RabbitMQ解决高并发下的订单丢失和数据库压力问题,包括Spring Boot集成方案、消息幂等处理、顺序消息保障等关键技术实现。通过实际案例验证,系统吞吐量提升3倍以上,订单丢失率降至0.03

weixin_33924770的博客 403

SpringBoot集成RabbitMQ消息队列:延迟消息与死信队列实战

在现代分布式系统中,消息队列已成为解耦系统组件、实现异步通信的重要基础设施。RabbitMQ作为实现了高级消息队列协议(AMQP)的开源消息中间件,凭借其高吞吐量、可靠性和消息持久化等特性,在众多项目中得到广泛应用。本文将深入探讨如何在SpringBoot项目中集成RabbitMQ,并实现延迟消息与死信队列这两种高级功能。

小筱在线博客 1073

RabbitMQ实战指南带目录完整版

你看,RabbitMQ 的魅力从来不只是“发个消息”这么简单。它是一整套关于可靠性、可观测性、可扩展性的设计哲学。从一开始的环境适配,到中间的消息模型选择,再到最后的集群治理——每一步都在考验你对系统的理解深度。希望这篇文章,能帮你跳出“只会用默认配置”的舒适区,真正掌握 RabbitMQ 的核心战斗力。毕竟,一个扛得住双十一流量的消息系统,从来都不是碰运气建出来的。✨现在,轮到你动手实践了——你的第一套高可用 RabbitMQ 集群,准备什么时候上线呢?😉。

weixin_30205153的博客 964

Java代码实现RabbitMQ死信队列

死信队列的核心是给业务队列配置和,死信队列 / 交换机是普通的队列 / 交换机;死信触发的核心条件:消息过期、消费拒绝()、队列满;代码实现关键:手动 ACK + 拒绝消息时,或配置消息 / 队列 TTL。这套代码覆盖了死信队列的核心场景,你可以直接复制运行,只需确保本地 RabbitMQ 服务正常启动即可。

╮(╯_╰)╭ Don't expect me to reply to you in time 479

全网最新首发纯干货:微信数据库表结构完整分析(一)

找不到微信DB表结构说明?找不到具体字段的解释?来这里,全网最完整版!!!

killghosts的博客 4931

西门子AI面试问答(STAR法则回答实例)

通过建立良好的沟通渠道、倡导透明和积极的沟通,并建立信任和共享目标的文化,我成功地改善了团队合作的氛围和效果。对于一些存在分歧和冲突的情况,我采用了积极的解决问题的态度,促进双方的沟通和理解,寻找共同的利益点和解决方案。我的成果得到了评委和观众的认可,并为我的学术发展和进一步的科学研究奠定了基础。首先,我主动与团队成员进行一对一的沟通,倾听他们的观点和意见,了解他们在合作中遇到的问题和需求。我还参加了学校组织的科学俱乐部和研究小组,与其他热衷科学的同学一起进行讨论和实验,加深我的理解和实践技能。

kashine的博客 7252

SpringBoot2.x整合RabbitMQ(完整版)

本篇文章实现了 SpringBoot整合RabbitMQ,实现了 work模型,发布订阅模型,topic模型,confirm消息确认机制,return消息机制,TTL队列,死信队列等。整合方式有很多,比如使用 RabbitAdmin进行整合,本文介绍一个最简单的整合方式,只需要在 RabbitmqConfig.java 配置文件中进行简单配置,便可以方便的使用。相信你会喜欢这种方式的

孔明的博客 4万+

别再只当代码阅读器了!手把手教你用Understand的实体定位器和信息浏览器,5分钟精准定位代码逻辑

本文深入解析Understand代码分析工具的高级功能,重点介绍实体定位器和信息浏览器的实战应用。通过5分钟快速定位代码逻辑的技巧,帮助开发者从代码阅读者升级为逻辑侦探,提升大型代码库的分析效率。文章包含过滤搜索、调用链追踪等实用方法,是掌握Understand核心功能的必备指南。

weixin_28745821的博客 294

springboot-rabbitmq-死信队列

1、配置configuration @Configuration public class DirectRabbitConfig { /** * 死信队列 交换机标识符 */ private static final String DEAD_LETTER_QUEUE_KEY = "x-dead-letter-exchange"; /** ...

shuangyueliao的专栏 2740

SAM2与Docker的完美组合:5分钟搞定Linux环境下的图像分割部署

本文详细介绍了如何在Linux环境下通过Docker快速部署SAM2图像分割模型,解决安装过程中的常见问题。文章提供了从镜像选择、CUDA版本匹配到容器构建的全流程指南,特别针对GPU加速环境下的'cudnn_frontend: No execution plans support the graph'等报错提供了实用解决方案,帮助开发者在5分钟内完成高效部署。

fern8的博客 934

【算法】—前缀和与差分详解

前缀和指一个数组的某下标之前的所有数组元素的和(即数列的前n项求和),前缀和是一种重要的预处理,能够降低算法的时间复杂度,可以快速地求出某一段的和,对于处理区间之间的问题是往往十分高效相比较其他算法而言,前缀和更像是一种解题的技巧,一种优化方式输入一个长度为 n 的整数序列。接下来再输入 m 个询问,每个询问输入一对 l,r 对于每个询问,输出原序列中从第 l 个数到第 r 个数的和5 32 1 3 6 41 21 32 4123453610。

DAY I 的成长之路 6025

在SpringBoot 2.x中使用RabbitMQ的死信队列和延迟队列功能

在SpringBoot 2.x中使用RabbitMQ的死信队列、延迟队列功能前言延迟队列的基本原理配置测试 前言 如果你还不知道什么是死信队列、什么是延迟队列、死信队列和延迟队列有什么关系,请参考我的这篇文章:RabbitMQ学习笔记之进阶篇. 如果你还不知道怎么在SpringBoot 2.x使用RabbitMQ,请参考我的这篇文章:在SpringBoot中使用RabbitMQ客户端详解. 延迟队...

qq_35939417的博客 700

声发射传感器的工作原理是什么?

介绍声发射传感器的工作原理。

qq_39948394的博客 9247

Spring Boot整合RabbitMQ进阶实战:TTL、死信队列与延迟队列深度解析

本文详解Spring Boot整合RabbitMQ的TTL机制(队列/消息/空闲)、死信队列架构及延迟队列两种实现方案(TTL+DLX与DelayExchange),并给出配置示例与实践案例。

1287

WPS文档中心和文档中台 operate 未授权访问漏洞(CVE-2025-0717)

WPS文档中心和文档中台的/open/v6/api/etcd/operate?key=/config/storage&method=get接口存在未授权访问漏洞,攻击者可通过该漏洞获取AK/SK密钥等信息,这些密钥通常用于系统内部认证和权限控制,泄露后可能导致攻击者进一步修改K8s配置、部署恶意容器或执行远程命令,最终实现对系统的完全控制。

李同學AI安全 906

【ACP】2025-最新-疑难题解析-1

即用户手动释放时,因实例释放保护开启,不会释放该 ECS 实例(不同云厂商具体实现有差异,但题目场景下选 C )。结合题目中标记,答案为。综上,答案选 B。综上,答案选 C。综上,答案选 D。综上,答案选 A。综上,答案选 A。综上,答案选 C。综上,答案选 D。综上,答案选 A。

jundao1997的专栏 365

22、《Spring Boot消息队列:RabbitMQ延迟队列与死信队列深度解析》

在现代分布式系统中,消息队列承担着解耦、削峰填谷和异步通信的重要职责。本文将深入探讨Spring Boot与RabbitMQ的整合应用,重点解析延迟队列与死信队列的实现原理及实战应用。通过完整的代码示例和配置讲解,帮助开发者掌握构建可靠消息系统的核心技能。

朗朗的博客 1413

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

【Spring Boot RabbitMQ死信队列TTL深度解析】:掌握消息延迟处理的终极方案

掌握Spring Boot RabbitMQ死信队列的TTL,精准实现消息延迟处理。适用于订单超时、任务调度等场景,通过设置TTL和死信交换机路由过期消息,保障系统可靠性与灵活性。配置简单、易于维护,是构建高可用消息系统的理想方案,值得收藏。

CodeTrick的博客 613

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Java面试-Spring Boot 整合 RabbitMQ:消息队列使用与 ACK 机制

《Java面试指南:Spring Boot整合RabbitMQ实战》摘要 本文是《Java面试200问》系列中的RabbitMQ实战指南,通过生动比喻和代码示例,详细讲解Spring Boot如何整合RabbitMQ实现异步消息处理。文章从消息队列的核心价值(解耦、异步、削峰)切入,系统介绍RabbitMQ的Exchange、Queue等核心概念,并给出完整的Docker环境搭建和Spring Boot项目配置方案。重点解析了消息监听注解@RabbitListener、消息处理注解@RabbitHandle

千淘万漉虽辛苦,吹尽狂沙始到金 2万+

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

Spring Boot深度整合RabbitMQ:从入门到企业级实战

Component@Slf4j@Autowired// 声明Direct类型Exchange// 声明持久化队列(队列名称、持久化、独占、自动删除)// 绑定Exchange与Queue(Binding Key为"order.create")本文系统讲解了Spring Boot与RabbitMQ的整合过程,从基础概念到企业级实战,覆盖了消息确认、持久化、死信队列、延迟队列等核心功能,以及集群部署、Spring Cloud Stream集成、性能优化等高级主题。合理设计拓扑。

z1ztai的博客 1454

RabbitMQ交换机核心原理与Spring Boot实战:Direct、Fanout、Topic、Headers详解

消息队列作为现代分布式系统的核心组件,通过解耦、异步和削峰填谷等机制,极大地提升了系统的可扩展性和可靠性。其核心原理在于消息的可靠存储与路由分发。在众多实现中,AMQP协议定义了标准化的消息传递模型,而RabbitMQ作为其流行实现,其路由逻辑的精髓在于交换机机制。交换机作为消息的入口和路由决策者,根据类型和绑定规则,将消息精准投递到目标队列,从而实现了从点对点通信到复杂发布订阅模式的技术价值。在微服务架构和事件驱动系统中,这一机制被广泛应用于日志收集、订单处理、实时通知等场景。本文聚焦于RabbitMQ的

weixin_30645617的博客 315

Spring Boot 4.0 牵手RabbitMQ死信队列,解锁消息处理新姿势

死信队列(Dead Letter Queue,DLQ),其实是一种特殊的队列,主要用于存储那些因为特定原因而无法被正常消费的消息,这些消息就被称为 “死信”。简单来说,死信队列就像是一个 “消息回收站”,专门存放那些在正常消息处理流程中出现问题的消息。通过本文的介绍,我们深入了解了 Spring Boot 4.0 整合 RabbitMQ 死信队列的原理、配置和实战应用。死信队列作为消息处理中的重要机制,能够有效提高系统的可靠性和稳定性,帮助我们优雅地处理异常消息。

qq_32890771的博客 455

SpringBoot系列12:整合RabbitMQ消息队列,异步解耦、死信队列完整业务案例

本文介绍了SpringBoot整合RabbitMQ的实战指南,包含核心概念、生产级配置、四大交换机场景实现以及可靠性保障方案。主要内容包括: RabbitMQ核心价值:异步解耦、流量削峰、事件驱动、延时任务四大生产场景 核心组件详解:生产者、消费者、交换机、队列等概念 SpringBoot生产级配置:持久化、确认机制、重试策略、序列化优化 四大交换机实战:Direct直连、Topic主题、Fanout广播、Headers匹配 消息可靠性方案:确认机制、退回机制、持久化、消费者重试 生产避坑指南:重复消费、消

深耕 Java 后端与企业级软件架构设计,专注微服务、分布式系统、大模型 AI 应用架构落地。 334

RabbitMQ交换机核心原理与Spring Boot实战:Direct/Topic/Fanout/Headers详解

消息队列作为异步通信和解耦的核心组件,在现代分布式系统中扮演着关键角色。其工作原理基于生产者-消费者模型,通过可靠的消息传递机制实现服务间的松耦合。RabbitMQ作为其中广泛应用的开源实现,其核心路由机制依赖于交换机。交换机根据类型和绑定规则,将消息精准路由到目标队列,这是实现复杂消息模式的技术基础。在工程实践中,结合Spring Boot框架,开发者可以高效集成并配置RabbitMQ。本文将深入解析Direct、Topic、Fanout和Headers四种核心交换机的工作原理,并通过Spring Boo

weixin_33991418的博客 378

Spring Boot邮件发送实战:从配置到生产级优化的完整指南

邮件发送是现代业务系统中实现用户触达与系统通知的核心功能,其底层依赖于SMTP协议。Spring Boot通过`spring-boot-starter-mail`启动器,将复杂的JavaMail API进行了高度封装,开发者通过配置`JavaMailSender`即可快速集成。这项技术价值在于,它极大地简化了后端服务中通知模块的开发,提升了开发效率与系统可维护性。其应用场景广泛,涵盖用户注册验证、订单状态变更提醒、密码重置以及系统监控告警等关键环节。本文聚焦于Spring Boot邮件发送的深度实践,详细解

weixin_34059951的博客 773
上一篇: 揭秘@InitBinder神秘面纱:如何彻底掌控Spring MVC的数据绑定与类型转换
下一篇: Spring Boot Actuator高级玩法:3种场景下的自定义端点实践方案
SimTrans
博客等级 码龄1年 158粉丝 2004原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值