本文永久链接 – https://tonybai.com/2025/05/10/rust-dependencies-scare-me

大家好，我是Tony Bai。

在现代软件开发中，高效的包管理系统和繁荣的开源生态极大地加速了我们的开发进程。Rust语言的Cargo及其crates.io生态便是其中的佼佼者，为开发者带来了前所未有的便捷。然而，这种便捷性是否也伴随着一些潜在的“代价”？

近期，一位名叫Vincent的国外Rust开发者在其博客文章《Rust Dependencies scare Me》中，就真诚地抒发了他对Rust依赖管理的深切忧虑。这篇博文在Hacker News等社区引发了热烈讨论，其指出的问题——从依赖的维护性到惊人的代码体积——或许也值得我们每一位使用现代包管理系统的开发者深思。

今天，我们就来一起解读Vincent的这篇文章，看看他遇到了哪些具体问题，并结合社区的智慧与我们的经验，探讨这些现象背后的启示。

Cargo的魅力：作者眼中的“美好一面”

在这位开发者看来，Cargo无疑是Rust生态的巨大优势。他强调，Cargo极大地提升了生产力，开发者无需像使用CMake(多用于C++项目)那样手动管理和链接文件。这使得在不同架构和操作系统（如他的M1 MacBook和Debian桌面）之间切换变得异常顺畅。

他坦言，在大部分情况下，Cargo让他几乎可以不必过多思考包管理本身，从而能更专注于核心代码的编写。这种“无感”的便捷体验，与上世纪80年代开发者需要为节省软盘空间而精打细算地“手动挑选和集成库代码”形成了鲜明对比，无疑是现代包管理系统追求的目标，也是Rust吸引开发者的重要原因之一。

当便捷遭遇“意外”：dotenv引发的警惕

然而，文章作者也指出，正是这种“不用思考”的便捷，可能让人变得“草率”。

他在一个生产项目中使用了许多Rust开发者都用过的dotenv库（用于加载.env文件）。项目平稳运行数周后，他偶然发现一则Rust安全通告指出，他所使用的dotenv版本已无人维护，并推荐了替代方案dotenvy。

这个小插曲让他开始反思：这个依赖真的必不可少吗？他尝试后发现，仅仅35行代码便实现了他所需的核心功能。他由此提出一个普遍性的问题：当依赖项（尤其是那些看似“微不足道”的）不再维护或出现安全漏洞时，我们该如何应对？那些我们真正“需要”的复杂依赖，又隐藏着哪些风险？这不仅仅是功能问题，更关乎依赖的信任链和维护者的责任。

百万行代码的“冲击波”：一个“小项目”的真实体积

Vincent的忧虑不止于此。他以一个自认为“微不足道”的Web服务项目为例——该项目使用广受好评的异步运行时tokio和Web框架axum，主要功能是处理请求、解压文件和记录日志。

当他尝试使用cargo vendor将所有依赖项本地化时，并用代码行数统计工具tokei进行分析，结果令他大吃一惊：总代码行数高达360万行！而他自己编写的业务代码仅有约1000行。

他将此与Linux内核的2780万行代码进行对比，发现他这个“小项目”的依赖代码量已接近后者的七分之一。他不禁发问：如何审计如此庞大的代码量？我们引入的重量级依赖，其绝大部分功能是否是我们项目真正需要的？

Vincent的经历并非个案。Hacker News社区的讨论中，有开发者（如kion）指出，现代软件开发中‘库叠库’的现象十分普遍，每一层依赖可能只用到其功能的冰山一角，但最终却可能导致简单的应用膨胀到数百MB。更有甚者（如jiggawatts）通过计算发现，仅三层依赖的层层叠加，就可能导致最终应用中88%的代码是“死代码”或从未被真实业务逻辑触及的“幽灵代码”。

Rust依赖困境的“求解”：作者的困惑与社区的多元声音

面对如此庞大的依赖代码和潜在风险，该博主坦诚自己“没有答案”。他提及了社区中一些常见的讨论方向，例如扩展标准库的利弊、开发者自身的责任以及业界大厂的实践等。

Hacker News社区的讨论进一步丰富了这些思考：

• 编译时优化是否足够？ 许多评论提到了链接时优化（LTO）、Tree Shaking等技术在剔除未使用代码方面的作用。Rust基于LLVM的优化确实能在这方面做出贡献。然而，正如一些评论者指出的，这些优化并非“银弹”，对于动态分发或包含大量可选编译特性的复杂依赖，完美剥离未使用部分仍充满挑战。
• 更细粒度的依赖控制： Rust的features机制为选择性编译提供了可能，但社区也在探索更根本的解决方案。有开发者甚至提出了“超细粒度符号和依赖”的设想，即每个语言构造都声明其精确依赖，按需构建最小代码集，尽管这在实现上极具颠覆性。
• 工具链的局限与期望： Vincent指出Cargo目前难以精确追踪最终编译产物包含的代码。社区也期待更强大的工具来分析依赖树、识别冗余、评估安全风险。

最终，文章作者将问题抛给了社区：我们应该怎么办？

我们的启示：从Rust的“依赖之忧”看现代软件供应链

Vincent的博文真实地反映了现代软件开发中普遍存在的“依赖困境”——我们享受着开源生态带来的便利，但也面临着供应链安全、代码膨胀、维护性等一系列挑战。

从他的分享和社区的热烈讨论中，我们可以得到以下几点启示：

1. 审慎评估依赖，警惕“依赖膨胀”的陷阱，拥抱适度“复制”： “不要为了碟醋包饺子”。在引入任何依赖前，都应评估其必要性、维护状态、社区活跃度以及潜在的安全风险。正如Go社区所倡导的“A little copying is better than a little dependency. (一点复制代码胜过一点点依赖)”，有时为了避免引入一个庞大或不稳定的依赖，适度复制代码，或者自己实现一个轻量级的核心功能，可能是更明智的选择。Go语言设计者之一的 Rob Pike 在其著名的演讲《On Bloat》中也曾深刻地警示过软件膨胀的危害，其中就包括了因过度或不必要依赖导致的复杂性增加和性能下降。Pike强调，真正的简洁和高效往往来自于对问题本质的深刻理解和对引入外部因素的克制。

2. 理解依赖的“冰山效应”与供应链安全——真实的威胁就在身边： 一个看似简单的库，背后可能隐藏着庞大的间接依赖。我们需要关注整个依赖树的健康状况。更重要的是，正如Hacker News上一些开发者强调的，依赖的真正“恐惧”更多在于供应链安全和代码的可审查性。当我们的项目依赖数百万行来自互联网的未知代码时，如何确保没有恶意代码或严重漏洞被悄然引入？这绝非危言耸听！就在最近，Socket威胁研究团队便披露了三个恶意的Go模块 (github.com/truthfulpharm/prototransform, github.com/blankloggia/go-mcp, github.com/steelpoor/tlsproxy)。这些模块通过命名空间混淆或伪装诱导开发者引入，其内部包含高度混淆的恶意代码，在特定条件（目前主要针对Linux系统）下会下载并执行毁灭性的“磁盘擦除”脚本 (done.sh)，直接向主磁盘写入零，导致数据被完全清零且无法恢复！这个案例血淋淋地提醒我们，供应链安全是每一个开发者都必须严肃对待的现实威胁。 这需要我们对信任链和维护者责任有更清醒的认识。

3. 寻求更精细的控制与工具支持： 无论是语言特性（如Go的build tags、Rust的features）、包管理工具（如更智能的tree shaking），还是库本身的模块化设计，都应朝着让开发者能更精细控制最终产物的方向努力。同时，自动化工具在依赖分析、漏洞扫描、许可证合规等方面扮演着越来越重要的角色。

4. 标准库与生态的平衡： Go语言的“大标准库”策略在一定程度上缓解了对外部依赖的过度渴求，但也带来了标准库自身迭代和灵活性的挑战。Rust选择了更小的标准库和更繁荣的社区生态。Hacker News上的讨论也反映了这种分歧：一部分开发者期望Rust能拥有更丰富的标准库，以减少对外部“寻寻觅觅”的困扰；而另一部分则担心这会扼杀生态活力，导致标准库“僵化”。这两种模式各有其历史成因和现实取舍，值得我们持续观察和学习，或许未来会出现一种更优的“官方认证扩展库”或“元库”的形态。

讨论：你如何看待现代软件的“依赖管理”？

这篇文章所转述的思考与社区的热议无疑为我们敲响了警钟。你在日常开发中（无论是Rust、Go还是其他语言），是否也曾遇到过类似的依赖管理难题？你认为当前包管理生态面临的最大挑战是什么？又有哪些值得推广的最佳实践或工具？

非常欢迎在评论区留下你的宝贵见解和经验分享！

• 原文链接：https://vincents.dev/blog/rust-dependencies-scare-me
• Socket.dev发现恶意Go模块：https://socket.dev/blog/wget-to-wipeout-malicious-go-modules-fetch-destructive-payload

面对复杂的依赖与潜藏的风险，如何系统性提升你的Go安全意识与底层掌控力？

近期Go恶意模块的“磁盘擦除”事件，再次凸显了深入理解依赖、掌握底层机制、构建安全软件的重要性。如果你渴望系统性地学习Go语言的深层原理（包括编译、链接、运行时），提升对第三方库的辨别与审计能力，并在实践中规避类似的安全“大坑”…

那么，我的 「Go & AI 精进营」知识星球 将是你不可或缺的伙伴！这里不仅有【Go原理课】、【Go进阶课】、【Go避坑课】助你洞悉语言本质，更有针对性的安全实践讨论和案例分析。我会亲自为你解答各种疑难问题，你还可以与众多对技术安全与底层有追求的Gopher们一同交流，共同构建更安全的Go生态。

立即扫码加入，为你的技术栈装上“安全防火墙”，在复杂的软件世界中行稳致远！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

本文永久链接 – https://tonybai.com/2025/04/21/go-project-design-antipatterns

大家好，我是Tony Bai。

在软件开发这个行当里，“最佳实践”、“设计模式”、“标准规范”这些词汇总是自带光环。它们总是承诺会带来更好的代码质量、可维护性和扩展性。然而，当这些“圣经”般的原则被生搬硬套到Go语言的语境下时，有时非但不能带来预期的好处，反而可能把我们引入“歧途”，滋生出一些看似“专业”实则有害的“反模式”。

最近我也拜读了几篇国外开发者关于Go项目布局和设计哲学的文章，结合我自己这些年的实践和观察，我愈发觉得，Go社区中确实存在一些需要警惕的、流行的设计“反模式”。这些“反模式”很多人都或多或少的使用过，包括曾经的我自己。

在这篇文章中，我就总结一下我眼中的Go项目设计“七宗罪”，希望能帮助大家在实践中保持清醒，做出更符合Go精神的决策。

第一宗罪：为了结构而结构——过度分层与分组

表现： 项目伊始，不假思索地创建pkg/、internal/、cmd/、util/、model/、handler/、service/ 等层层嵌套的目录，美其名曰“组织清晰”、“符合标准”。

危害：
* 违背简洁： Go 的核心哲学是简洁。不必要的目录层级增加了认知负担和导航成本。
* 过早抽象/耦合： 在需求尚不明确时就划分 service、handler 等，可能导致错误的抽象边界和不必要的耦合。
* pkg/ 的迷思： pkg/ 是一个过时的、缺乏语义的约定，Go官方在Go 1.4时将Go项目中的pkg层次去掉了，Go官方的module布局指南中也使用了更多有意义的名字代替了pkg。
* internal/ 的滥用： 它是 Go 工具链的一个特性，用于保护内部实现不被外部导入。但如果你的项目根本不作为库被外部依赖，或者需要保护的代码很少，强制使用 internal/ 只会徒增复杂性。
* cmd/ 的误用： 除非你的仓库包含多个独立的可执行文件，否则将单一的main.go放入cmd/毫无必要。

解药： 保持扁平！从根目录开始，根据实际的功能或领域需要创建有意义的包。让结构随着项目的增长有机演化，而不是一开始就套用模板。

注：笔者当年也是pkg的“忠实粉丝”，新创建一个项目，无论规模大小，总喜欢先将pkg目录预创建出来。现在是时候根据项目的演进和规模的增长来判断是否需要”pkg”这个有点像“namespace”的目录了，即当你有多个希望公开的库时，是否用pkg/作为一个顶层分组，这个是要基于项目的实际情况进行判断的。

第二宗罪：无效的“美化运动”——无价值的重构与移动

表现： 为了让代码看起来“更干净”、“更符合某种设计模式”或“消除Linter警告”，在没有明确收益（修复 Bug、增加功能、提升性能、解决安全问题）的情况下，大规模地移动代码、修改变量名、调整文件结构。

危害：
* 浪费时间精力： 投入大量时间做无意义的表面文章。
* 引入风险： 任何修改都有引入新 Bug 的风险，没有价值的修改更是得不偿失。
* 增加 Code Review 负担： 团队成员需要花费时间理解这些非功能性的变更。
* 违背价值驱动： 软件工程的核心是交付价值，而不是追求代码的“艺术感”。

解药： 坚持价值驱动的变更！在做任何结构或代码调整前，严格拷问自己：这个改动解决了什么真实的、当前存在的问题？它的收益是否能明确衡量并大于风险？

第三宗罪：接口的“原罪”——过早、过度的抽象

表现：
* 在只有一个具体实现的情况下，就为其定义接口。
* 定义庞大、臃肿的接口，包含过多方法。
* 为了“可测试性”而无脑地给所有东西加上接口。

危害：
* 不必要的抽象： 接口是为了解耦和多态。在不需要这些时引入接口，只会增加代码量和理解成本。
* 弱化抽象能力： “接口越大，抽象越弱”（来自Go谚语）。大接口难以实现和维护，它变得模糊，难以理解哪些方法是真正必要的，也失去了其作为“契约”的精准性。
* 阻碍演化： 过早定义接口可能锁定不成熟的设计，后续修改成本更高。
* 测试的借口： Go拥有强大的测试工具（如表驱动测试），很多时候并不需要接口来实现可测试性。为测试而引入的接口可能扭曲生产代码的设计。

解药：
* 拥抱具体： 先写具体实现。
* 发现接口，而非设计接口： 只有当你确实需要多种实现（包括测试中的Mock，但要谨慎对待），或者需要打破循环依赖时，才考虑提取接口。
* 保持接口小巧、正交： 遵循接口隔离原则。

第四宗罪：“大杂烩”的诱惑——utils/common/shared 黑洞

表现： 创建一个名为 utils、common、shared 或 helpers 的包，把各种看似“通用”的函数、类型塞进去。

危害：
* 职责不清： 这些包缺乏明确的领域或功能归属，成为代码的“垃圾抽屉”。
* 依赖洼地： 随着项目增长，这些包往往会依赖越来越多的其他包，同时也被越来越多的包依赖，极易引发循环依赖或成为构建瓶颈。
* 降低内聚性： 本应属于特定领域的功能被剥离出来，破坏了原有包的内聚性。

解药：
* 就近原则： 如果一个“工具函数”只被一个包使用，就把它放在那个包里（可以是私有的）。
* 功能归类： 如果一个“工具函数”被多个包使用，思考它真正属于哪个功能领域，为其创建一个有意义的新包（例如 applog 而不是 logutil）。
* 思考依赖方向： 真正通用的基础库（如自定义的 string 处理、时间处理）应该处于依赖关系图的底层，不应依赖上层业务逻辑。

注：坦白说，其他几项“罪过”或许还只是部分开发者的“偶发行为”，但这“第四宗罪”——随手创建 utils 或 common 包——恐怕是我们绝大多数人都曾犯过，甚至习以为常的“通病”。笔者也是如此:)。

第五宗罪：对 DRY 的“迷信”——为了“不重复”而引入不当依赖

表现： 为了避免几行相似代码的重复，强行提取公共函数或类型，并为此引入新的包依赖，有时甚至导致复杂的依赖关系或循环依赖。

危害：
* 错误的抽象： 有时看似重复的代码，在不同的上下文中可能有细微的差别或独立演化的需求。强行合并可能导致错误的抽象。
* 不必要的耦合： 为了共享几行代码而引入整个包的依赖，增加了耦合度，可能比少量重复代码的维护成本更高。
* 违背 Go 谚语： “A little copying is better than a little dependency.”（一点复制代码胜过一点点依赖）。Go 社区鼓励在权衡后接受适度的代码重复，以换取更低的耦合度和更高的独立性。

解药：
* 批判性看待重复： 看到重复代码时，先思考它们是否真的是“同一件事”？它们的演化趋势是否一致？
* 权衡成本： 引入依赖的成本（耦合、潜在冲突、维护负担）是否真的低于复制代码的成本？
* 优先考虑简单： 在不确定时，保持简单，适度复制代码通常更安全。

注：这种事儿，恐怕咱们自己或者团队里都遇到过不少：就为了用里面那一两个小函数，咔嚓一下，引入了一个庞大无比的依赖库。

第六宗罪：盲目崇拜与跟风——“伪标准”与“最佳实践”的陷阱

表现：
* 不加批判地复制某个“明星项目”或所谓的“Go 标准项目布局”（如已被社区诟病的golang-standards/project-layout）。
* 将其他语言（如 Java, C#）的复杂模式生搬硬套到 Go 项目中。
* 将任何 Linter 规则或所谓的“最佳实践”奉为圭臬，不考虑具体场景。

危害：
* 脱离实际： 别人的“最佳实践”是基于他们的特定问题和上下文演化而来的，未必适合你的项目。
* 扼杀思考： 放弃了基于自己项目需求进行独立思考和决策的机会。
* 违背Go文化： Go 推崇实用主义和具体问题具体分析，而非僵化的教条。

解药：
* 保持独立思考： 理解每个模式或实践要解决的原始问题是什么，它是否在你的项目中真实存在？
* 以我为主，兼收并蓄： 学习和借鉴，但最终决策要基于你自己的项目需求、团队情况和对 Go 语言的理解。
* 质疑“最佳”： 没有万能的“最佳实践”，只有在特定上下文中的“较好实践”。

注：确实，很多Go初学者（甚至一些老手，包括我自己）都曾长期困惑甚至“抱怨”：官方为何不给出一个项目布局的指导呢？这个呼声持续多年后，Go官方终于在2023年发布了一份官方布局指南。这份指南无疑是我们理解官方思路、开始设计Go项目布局的一个重要起点。

第七宗罪：与“引力”对抗——忽视 Go 的依赖约束

表现：
* 设计出隐含循环依赖的架构（例如，某些复杂的 ORM 模式，或者 Service 层与 Repository 层相互调用具体类型）。
* 当遇到 import cycle not allowed 错误时，不从根本上调整结构，而是通过滥用接口、全局变量或 init() 函数等“技巧”来绕过编译错误。

危害：
* 与语言对抗： Go禁止循环依赖是其核心设计之一，旨在强制形成清晰的、可管理的依赖关系图 (DAG)。试图绕过它，本质上是在与语言的设计哲学对抗。
* 隐藏的复杂性： 用“技巧”解决循环依赖，只是将问题扫到地毯下，使得真实的依赖关系变得模糊不清，增加了维护难度。
* 错失优化机会： 循环依赖往往是代码职责不清、耦合过度的信号。解决循环依赖的过程，本身就是一次优化架构、厘清职责的好机会。

解药：
* 拥抱 DAG： 理解并尊重 Go 的依赖规则，将其视为架构设计的“向导”。
* 分析依赖： 当出现循环依赖时，深入分析其根源，理解是哪个环节的职责划分或耦合出了问题。
* 结构性解决： 优先使用移动代码、提取新包（向上或向下）等结构性方法来打破循环。接口解耦是可用手段，但不应是首选或唯一手段。

小结：回归常识，拥抱简洁

Go语言的设计哲学是务实和简洁。许多所谓的“最佳实践”和“复杂模式”，在Go的世界里可能水土不服。识别并避免上述这些“反模式”，需要我们：

• 保持批判性思维： 不盲从，不跟风，时刻追问“为什么”。
• 坚持价值驱动： 让每一个设计决策都服务于解决真实问题。
• 深刻理解Go： 尊重其核心约束（如无循环依赖），发挥其优势（如简洁性）。
• 拥抱演化： 从简单开始，让架构随着需求的明确而有机生长。

希望这篇“七宗罪”的总结能给大家带来一些警示和启发。你是否也曾在项目中遇到过这些“反模式”？你认为还有哪些Go设计中需要警惕的“坑”？欢迎在评论区分享你的看法和经验！

也别忘了点个【赞】和【在看】，让更多Gopher看到这篇“反模式”的总结！

避开这些设计“反模式”是迈向Go高手的关键一步。如果你渴望更深层次地理解Go语言精髓，与顶尖Gopher交流切磋，并紧跟Go+AI前沿动态…

那么，我的 「Go & AI 精进营」知识星球 正是你需要的！在这里，你可以沉浸式学习【Go原理/进阶/避坑】等独家深度专栏，随时向我提问获
得解析，并与高活跃社区成员碰撞思想火花。

扫码加入，开启你的Go深度学习与精进之旅！