[{"content":"我是 Hyman，一个把编程当作艺术的码农。编程是艺术，极致是信仰，分享是连接世界的方式。\n这里是「艺术码农的小栈」，一个从 2009 年写到现在的技术博客。早年写 Java 与 Eclipse 插件，后来主要写 Go 的并发与源码，这两年多在写 AI 工程化和 Ease Ops。\n写些什么 实践总结 项目里的经验、踩坑与解法 笔记 源码阅读、工具使用与学习摘录 探索 新技术的尝试与想法 K8S 容器与云原生相关 转载 值得收藏的好文章 ","permalink":"/about.html","summary":"\u003cp\u003e我是 \u003cstrong\u003eHyman\u003c/strong\u003e，一个把编程当作艺术的码农。编程是艺术，极致是信仰，分享是连接世界的方式。\u003c/p\u003e\n\u003cp\u003e这里是「艺术码农的小栈」，一个从 2009 年写到现在的技术博客。早年写 Java 与 Eclipse 插件，后来主要写 Go 的并发与源码，这两年多在写 AI 工程化和 Ease Ops。\u003c/p\u003e","title":"关于"},{"content":"前言 从复制粘贴，到一句话落进目录\n上周想让 AI 把手里这篇方案改一版。方案在我的笔记本里。\n于是我打开笔记软件，找到它，全选，复制，切回对话框，粘贴，说要改什么，等它写完，再全选复制，切回去，覆盖原文。\n改完算了一下中间那几步：和 AI 的能力一点关系都没有。它只是在做一件它做不到的事，读我硬盘上的一份笔记。\n现在这件事变了。我可以直接说「把上周那篇方案按这个思路改一版」，它自己搜到、读完、把改好的版本盖回去。查资料也一样：它在我的笔记里翻，答完顺手把结论整理成一页放进目录，下周用关键词就能找回来。\n这背后是 MCP（Model Context Protocol），一个让 AI 助手调用外部工具的协议。协议本身没什么可讲的，值得讲的是接上之后，笔记这件事多了哪几种用法，以及为此付出了什么。\n三件以前要手工搬的事 第一件，查完就记。\n你让 AI 查一个东西、回答一个问题，然后说「整理成一页，放进技术 / 技术笔记，标签加上同步和 CRDT」。它自己搜、读、归纳、写、打标签。\n以前要六七步：结论在对话框里，你不想让它烂在那儿，于是打开笔记软件、想标题、找目录、粘进去、再补几个标签。这些动作都不难，但得挤进你当时正忙的那件事里。于是大多数时候，它就这么消失了。记一下越贵，笔记越稀。\n第二件，基于旧笔记写新版。\n以前是找到、打开、全选、复制、粘贴进对话框、描述要求、等它写完、再复制回去覆盖。八步，中间任何一步走神都要重来。\n现在一句话。它自己搜到那篇、读完、改完、盖回去。\n第三件，回答「我以前关于这件事写过什么」。\n以前得自己搜，逐篇打开，全选复制，还得分好几次粘。现在它自己找、自己读，决定读哪几篇，答完把出处带上。\n三件事的共同点：以前每一步都要人动手，现在只有「我想要什么」需要人说。\n记录：一句话落进目录 这条链现在短到一句：\n把这五篇里关于离线同步的做法整理成一页，放进「技术 / 技术笔记」，标签加上同步和 CRDT。\n几个细节让它真的能天天用。\n目录不用你先建。你说「技术 / 技术笔记」，路径不存在，它逐级补建，然后告诉你实际落在了哪。不会悄悄扔进「未分类」让你以后去翻。\n同名同目录不会写两遍。重复问同一个问题，它把已有的那篇还给你，而不是攒出一堆「xxx 副本」。\n标签按名字自动建。你不用先去标签管理里创建，再回来赋值。\n写完立刻能搜到。这一条最容易坏，单说。\nAI 写进笔记的数据，和搜索用的数据不是同一份。搜索为了快，会把正文另存一份到索引里。AI 改的是前者，后者不会自己更新。所以「写进去了」和「搜得到」中间还差一步：把新正文回填给搜索。少这一步，笔记打开看得见，搜索框里就是搜不到，列表里的摘要还是空白。\n有个限制要说清楚：这样整理出来的笔记带不了图。AI 没有上传附件的能力，图得你自己补进去。\n搜索：以前其实只搜了标题 很多人以为笔记软件的搜索是全文搜索。不是。正文通常进不了索引，能搜的只有标题和摘要。所以你明明记得写过某个词，搜出来是空的。\n这次把正文放进了全文索引。变化很直接：一个只出现在正文里的词，以前一条都返不回来，现在能命中。\n搜索结果的形态也变了。以前返回一堆标题，模型和人一样，只能靠标题猜哪篇是要找的。现在每条结果带目录、修改时间，还有正文里命中的那一段。看到片段就知道是不是它，不用一篇篇点开。\n多个词按「同时满足」理解。以前输入「离线 同步」，得原文里有这一整串，包括中间那个空格，才算命中，这几乎不是人的搜索习惯。现在拆成两个词求交集。这个改动人和 AI 都受益，软件自己的搜索框也走同一套逻辑。\n一个诚实的边界：两个字的词搜不到正文。中文没有词边界，不需要词典就能工作的分词方案只有三字符滑窗，代价是查询词不能少于三个字。「架构」「周报」这类两字词切不出可查片段，只能退回标题和摘要。宁可少返结果，也不能让原本搜得到的东西凭空消失。\n索引是有成本的：一万篇、约 40MB 正文的库，索引本身 89.7MB，是正文的 2.2 倍。但换来的是覆盖率，不是速度。查一次二三十毫秒，和原来的子串匹配差不多，差别在于能不能搜到。\n整理：整篇替换，不是往后接 让 AI 润色一篇笔记，最直觉的做法是追加：新版本接在原文末尾，你自己对比。\n这是错的。追加出来是一篇既有旧版又有新版的笔记，越改越乱，而没人会去手动删旧的那段。\n正确的做法是整篇替换：读旧全文，模型产出新全文，一次盖掉。改写发生在 AI 助手自己的模型里，不在笔记软件里调一个「AI 润色」接口，所以你可以换模型、能看到改了什么，也不依赖软件配了哪家的密钥。\n覆盖是破坏性动作，所以顺序有讲究：读旧正文，校验新正文，逐字比对（一样就什么都不做），存一份旧内容当回滚点，探测有没有人在中途改过，最后才写入。回滚点必须在写入之前，这类写入本身不产生历史版本，没有这一步，覆盖就不可撤销。\n发现中途有人改过，只提醒不重试。笔记软件会把两边的修改合并起来，但用户正在编辑器里打的字可能被盖掉，AI 不知道该保留谁的，让人来定。\n带图的笔记一开始不允许改写，理由是「图片的某些属性没法从 Markdown 还原」。跑了一遍真实读写之后这个说法站不住：图片地址、替代文本、宽度都是无损往返的。危险的地方在于模型看不见图，它把地址改一个字符、或者润色时把图删了，自己不知道。\n所以限制换成一条能机器校验的规则：替换前后，图片地址的集合必须完全相等，不计顺序，一处不能少也不能凭空多；标题、说明、位置、宽度随便改，违反就报错。\n这条规则比图片本身更通用：能用可校验的不变式，就别用类型黑名单，黑名单会一路往严格的方向滑，直到把本来能安全做的事也禁掉。只有内联密钥仍然禁止整篇替换，模型看到的是占位符，它把两个占位符对调，谁也检查不出来。\n一句话背后是七步 上面说的都是「一句话」。但一句话落进去，服务器要做这些事：\n解析 Markdown，校验里面有没有 AI 写不出来的东西 → 按「目录 + 标题」查重，已存在就不建，把已有 id 还回去 → 创建笔记（只能带标题和目录） → 把 Markdown 编码成协同文档格式的二进制增量，上传 → 目录不存在就逐级补建，标签按名字自动建 → 重新拉一次数据，解码出正文 → 回写搜索用的正文与摘要 顺序和检查都由服务器保证，不交给模型。模型只需要表达意图。\n这些步骤不是凑数的。有一部分失败了也返回成功，只是没做成该做的事：\n漏掉的那一步 坏成了什么样 什么时候才发现 编码成协同文档，而不是直接写文本 笔记建出来了但正文是空的，或者旧内容复活 打开编辑器的那一刻 回写搜索用的正文与摘要 这篇笔记再也搜不到，列表里摘要是空白 下次想找它的时候 先查重再建 同名笔记建了两篇 翻目录的时候 接口返回成功，模型就认为自己成功了，接着往下做。用户要过好几天才发现那些笔记根本搜不到。把编排收进服务器，这些坑就从「模型要记住」变成了「服务器保证」。\n对外一共七个动作：查状态、列目录、搜索、读取、新建、追加、整篇替换。没有删除，没有权限管理，没有一个动作叫「更新正文」。\n为什么这件事不好做 笔记正文在这个软件里不是一段文本，它是一份协同文档。同一篇笔记在手机上改一段、电脑上改一段，两份副本放一起能自动合并，不丢内容。代价是它不再可读，在数据库里是一堆二进制增量。\n三处设计把「直接写正文」这条路堵死了：创建笔记的接口拒收正文，更新笔记的接口只允许改标题和目录，服务端不解析那份二进制，它只负责把字节存下来。\n这是设计上对的选择。把 Markdown 变成协同文档，需要知道编辑器的文档结构：哪些算标题、表格单元格归属哪行、图片带哪些属性。这份定义只存在于前端。服务端再实现一遍，两边就会开始漂移，今天是图片少一个属性，明天是嵌套列表算错一层。\n于是知道怎么写入正文的代码只有一处：编辑器本身。结论听起来很荒唐，要让 AI 能写笔记，就得让 AI 跑起一个浏览器里的编辑器。工具服务器跑在 Node 里，没有浏览器，最后靠一个模拟浏览器环境的库把编辑器挂了起来。\n代价是这个包 71MB。它把一个编辑器塞进了 app 里，用户不用装任何依赖。我们试过三次想把它压成单个文件，全部失败，就停在这了。\n它不能做什么 先说最硬的一条：它只能连本机。AI 读的是你这台机器上正在运行的那个桌面端，云端和跨设备完全没做。令牌只在本地，别人拿不到，也调不了。\n删不了任何东西。令牌按路径白名单放行，只允许读状态、列目录、搜索、读正文、写正文、建目录、打标签，其余一律拒绝。加密目录根本不会列出来，AI 不知道它存在。这个软件没有回收站，所以在有回收站之前，不提供不可逆动作。\n带不了图。新建和追加的内容里不允许带图片，因为 AI 没有上传附件的能力，带进去就是一张永远坏掉的图。\n接入的成本倒是压到了最低：设置页里有一个「复制 MCP 配置」，粘进客户端就能连上。\n最后 这三件事以前都不算「做不到」，只是太费手：查完的资料懒得搬、旧笔记不敢让 AI 改、想找的东西翻了半天。费手到一定程度，人就不做了。\n现在的区别是，这些动作变得比不做还省事。顺手记一下，然后它真的在库里，而且搜得到。\n而那篇设计文档，就是这个链路写进我的笔记本的。\n","permalink":"/blogs/2026/ai/devmate---mcp.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e\u003cem\u003e从复制粘贴，到一句话落进目录\u003c/em\u003e\u003c/p\u003e\n\u003cp\u003e上周想让 AI 把手里这篇方案改一版。方案在我的笔记本里。\u003c/p\u003e\n\u003cp\u003e于是我打开笔记软件，找到它，全选，复制，切回对话框，粘贴，说要改什么，等它写完，再全选复制，切回去，覆盖原文。\u003c/p\u003e","title":"DevMate - MCP 让AI看到我笔记"},{"content":"引言 端到端测试的难点，从来不是启动一个浏览器，而是让「用例从哪来、凭什么可信、何时执行、跑在哪里」这四个问题有同一个答案。ease-ops 的 E2E 能力线给出的答案是：一条版本契约，串起四个角色。\n做 E2E 的团队通常卡在三个地方：用例散落在代码仓库、文档和个人脚本里，没人说得清哪份是准的；AI 能批量写用例，但产物没人把关，直接上线又不敢信；执行依赖某台机器上的临时脚本，跑多了就互相污染、难以复现。\nease E2E 是 ease-ops 平台内的一条端到端测试能力线，不造新引擎，也不做低代码。它把用例变成平台里的版本化资产，把 AI 变成受约束的写作者，把执行变成流水线里的一个标准阶段，把算力交给一组可扩展的执行 Agent。本文从宏观层面讲清这套设计的思路与优势，不展开接口与实现细节；文中的流程图由笔记自动渲染，涉及真实产品界面的配图暂以占位块标注。\n一、整体思路：四个角色，一条版本契约 图 1　端到端闭环：AI 生成、平台落库、流水线调度、分布式执行\n角色 职责 AI 客户端 生成用例文本，离代码与页面最近 MCP 写入接口 把产物安全落库，只到草稿为止 流水线 选已发布版本，决定执行时机与失败策略 分布式执行 Agent 提供算力、运行隔离与结果回传 平台自己只维护两样东西：版本化的用例资产，以及贯穿全链路的版本契约。既不做生成模型，也不做测试引擎——生成交给离上下文最近的客户端，执行交给成熟的测试生态。\n二、用例从哪来：AI 写，接口收，人来放行 生成在客户端，约束在服务端。AI 编程助手手上有仓库代码、页面组件和用户意图，平台没必要复制一份上下文；平台的职责是让 AI 的产物可控、可审、可复现。 MCP 是标准写入通道。AI 通过用例写入接口保存草稿，这条通道与人工控制台共用同一套业务规则与权限，不是给 AI 另开的后门。写作规范、幂等写入、逻辑名引用、危险等级标注、密钥边界，都写在模型一定会看到的地方。 草稿与发布两态分离。任何编辑先落草稿；人工审阅版本差异后发布，冻结为不可变版本；流水线只执行已发布版本。此后 AI 再改草稿，也不会污染正在跑的版本。 资产化带来复现能力。用例不随被部署的代码一起签出，独立演进；每次运行记录当时使用的版本快照，结果可复现、可回溯、可回滚；凭据由平台在执行时注入，不进入用例内容或对话。 界面\n三、何时执行：把 E2E 做成流水线的一等阶段 位置明确：放在部署之后，作为流水线里的标准阶段，而不是挂在外部的一段脚本；用例资产与执行细节彻底解耦。 配置面收敛：步骤只关心选哪个用例集、哪些标签、哪个运行时、被测地址与失败策略；临时工程、登录态准备、报告路径等一律由执行端按模板生成。 触发灵活：可手动触发，也可由平台接口或 AI 客户端经 MCP 发起；代码推送自动触发与定时全量属于后续演进。 软硬门禁渐进：初期用例失败只记录报告与产物、不阻断流水线；稳定后关闭软失败开关即升级为硬阻断，无需改动引擎。重试统一放在测试框架侧，避免两层重试叠加放大噪声。 界面\n四、跑在哪里：分布式 Agent 提供算力与隔离 可横向扩展：执行 Agent 通过长连接注册到平台，心跳上报在线状态与资源状况，新节点需审批后接入。 按策略选机：结合环境归属、能力标签与健康状态挑选节点，让同类任务尽量稳定落在同一节点以复用缓存；专用测试节点优先，缺失时平滑回退到通用节点。 定向派发、类型路由：任务由平台推送到指定节点，而不是节点轮询领取；执行端按任务类型路由到不同处理器，天然具备插件化扩展能力。 运行隔离：每次运行使用独立、干净的工作空间，容器资源设上限，支持容器与宿主机两种方式；登录态与凭据由平台注入，用例里只保留业务断言。 刻意轻量：不引入消息队列与额外中间件，分布式协调压在长连接、心跳与调度策略上，运维面最小。 五、结果到哪去：报告与产物闭环 复用既有体系：结果以标准化报告回传，平台沿用既有报告模型与统计口径，不新增一套报表体系；通过率、用例明细与耗时直接呈现在流水线详情里。 失败可排查：失败时保留截图、追踪与录屏等产物，归档失败不影响测试判定；运行版本快照让「当时跑了什么」可追溯，历史数据也能用于识别不稳定用例。 六、优势亮点 亮点 价值 AI 生成与安全落库分离 生成贴近代码上下文，服务端零模型成本，产物天然可审 版本化资产 + 人工发布闸门 AI 产出不会直接进生产验证，只有冻结版本可跑 面向 AI 的接口契约 写入幂等、引用不易幻觉、密钥不过对话，协作可控 流水线一等阶段 + 软硬门禁演进 从「先观察」到「硬阻断」只改一个策略，不改引擎 分布式执行与运行隔离 算力可横向扩展，多任务互不污染，专用节点可灰度接入 复用成熟测试生态与既有报告体系 直接享受生态红利，建设与维护成本最低 凭据与权限统一收口 安全边界清晰，用例内容与日志都不接触敏感信息 七、落地路径 为 AI 客户端接入平台的 MCP 通道并配置访问凭证。 让 AI 按规范生成用例并写入草稿；人工在用例库审阅版本差异后发布。 在流水线部署阶段之后加入端到端测试步骤，选用例集与标签，保持软失败。 在项目里配置被测地址与测试账号等环境变量。 触发一次完整流水线，查看测试报告与失败产物。 稳定运行一段时间后关闭软失败，升级为硬门禁。 八、边界与演进 平台当前不内置 AI 生成用例与失败用例自愈；生成能力来自客户端 AI，资产模型已为 AI 来源预留位置。 用例是可执行的标准测试脚本，不是低代码或自然语言用例。 目前以手动与接口触发为主；代码推送自动触发、定时全量、不稳定用例自动隔离均在后续规划。 软失败阶段目前是「流程继续、报告标失败、产物保留」，告警与人工放行链路尚未完全落地。 分布式执行不依赖消息队列与任务租约，靠长连接与调度策略实现。 结语 把「生成」交给离代码最近的 AI 客户端，把「可信」交给版本化资产与人工发布闸门，把「调度」交给流水线，把「算力」交给分布式 Agent；平台只用一条标准接口与一份版本契约把四者粘起来。这样 AI 写得再快，也越不过「已发布版本」这条线——这大概是这套设计里最值得复用的一条原则。\n","permalink":"/blogs/2026/ease-ops/ease-ops-e2e.html","summary":"\u003ch2 id=\"引言\"\u003e引言\u003c/h2\u003e\n\u003cblockquote\u003e\n\u003cp\u003e端到端测试的难点，从来不是启动一个浏览器，而是让「用例从哪来、凭什么可信、何时执行、跑在哪里」这四个问题有同一个答案。ease-ops 的 E2E 能力线给出的答案是：一条版本契约，串起四个角色。\u003c/p\u003e\n\u003c/blockquote\u003e","title":"Ease Ops - E2E 让 AI 写用例、流水线调度与分布式执行连成闭环"},{"content":"前言 流水线失败的红灯只在 EaseOps 网页上亮，而人一天里眼睛都在 DevMate 上。 这个功能的目标只有一句话：让「有事发生」主动送上门，但不制造第二份真相。\n一、为什么放在 DevMate 里 消息系统最难的部分从来不是\u0026quot;怎么推\u0026quot;，而是\u0026quot;推了有没有人看见\u0026quot;。\nEaseOps 消息天然落在它自己的网页里：流水线失败的红灯会在控制台亮，但控制台是被动打开的——你只有想起去看的时候才会看。而 DevMate 是日常里一直开着的那个窗口：写方案、记会议、剪藏、随手记，一天里眼睛大部分时间停在它上面，桌面端还常驻托盘与贴边圆钮。\n把消息送到这里，等于把送达位置从\u0026quot;需要主动访问的系统\u0026quot;换成\u0026quot;人已经在的地方\u0026quot;。这个位置变化带来的收益，比任何推送技术的选择都大：\n不用多开一个入口。 不用为这件事多留一个浏览器标签、多装一个客户端、多记一套登录态。消息和正在写的东西在同一个窗口旁边。 常驻即到达。 网页关掉就什么都不知道；桌面应用跟着系统起来，贴边圆钮、托盘、Dock 至少有一处亮着。 时效敏感的消息才有时效。 流水线失败、部署中止这类消息的价值以分钟计，晚半小时看见和没看见差不多。 消息能直接接上下一步。 点开看详情与链接；看完把结论记进当天的笔记，消息与工作记录落在同一处——这是 DevMate 独有的便利，换成 IM 得再搬一次。 也正因为如此，它不该长成第二个 IM。这里只做\u0026quot;送上门 + 点进去看\u0026quot;：不落库、不做搜索与归档；已读也只是转手调对端接口，本地不维护状态。要长期归档与协作，EaseOps 自己的通知中心才是对的地方。DevMate 是门铃，不是第二个信箱。\n二、先想清楚：问题不是\u0026quot;怎么推送\u0026quot; 接到需求时的原始描述是三条：右上角一个带未读数的图标、点开是列表和详情、消息走 WebSocket 且支持多来源。\n如果按这个描述直接写，很容易落进三个陷阱：\n建一张本地消息表。既然要列表、要已读、要未读角标，顺手就存了。存下去之后你要面对：去重（同一条推两遍）、裁剪（保留多少条）、已读状态与对端不一致、断网时的空态、以及最烦的——用户在两台设备上都点过已读。 自己做未读加减。收到一条 +1，标记已读 -1。看起来天经地义，实际要求\u0026quot;每一帧都是新消息且不重推\u0026quot;，漏一帧、重放一帧，角标就长期偏了，而且偏了没人能修回来。 跨来源合并列表。多来源看起来应该是一张统一收件箱，但一合并，来源的字段语义就打架（一个系统的 id 是 itemId，另一个是 messageId），排序也无法解释，点击定位更没有落点。 最后落下来的原则是三条，后面所有设计都是从这三条推出来的：\n消息不是笔记，所有权在对端。 桌面端是视口，不是仓库。列表、详情、标记已读全部实时调对端接口，本地零存储。 未读数只有一个来源。 只认对端的 inbox-unread-count 接口；事件到达后回查，不做任何本地加减。 事件只是信号，不是数据。 帧告诉你有事发生、可能是哪一条；内容一律回查，因为帧里的字段不可信。 代价写在明面上：断网即空、没有搜索、没有\u0026quot;全部已读\u0026quot;（对端没这个接口）。换来的是整个\u0026quot;缓存一致性\u0026quot;问题域直接消失。\n三、边界：凭据不出壳层，渲染只在壳层 前端（Wails 里的 webview）不直接发请求，全部走 Go 侧代理方法：\nListMessages(sourceKey string, page int) (MessagePageDTO, error) GetMessageDetail(sourceKey, id string) (MessageDTO, error) MarkMessageRead(sourceKey, id string) error GetMessageUnread() ([]SourceUnreadDTO, error) OpenExternalURL(url string) error 三个直接收益：\n没有 CORS。Wails 的前端是 wails:// 源，直连对端必然撞预检；Go 侧发请求没这问题。 token 停在壳层。配置文件在 ~/.smart-note/messages.yaml（0600），前端永远看不到凭据。 统一结构。不管对端字段怎么起名，跨过绑定边界的已经是 {title, level, ts, read, attrs, links}。 链接打开也是壳层的事：仅 http / https 交给系统浏览器，其余 scheme 直接拒。正文里的 \u0026lt;a\u0026gt; 全被拦截改写，webview 自己不会跳走——这条不做，点一个相对链接就会把整个应用页面替换掉。\n四、适配层：配置驱动，而不是\u0026quot;接一个系统写一套代码\u0026quot; EaseOps 的字段长这样：列表项 itemId / createdAt / message.title / projectName，详情在 data.message.body，未读数分 projectCount + platformCount。\n如果把这些名字写进 Go 代码，第二个系统（比如 GitLab 或内部工单）进来就要复制一遍结构体、一遍分页、一遍错误处理。所以做成一层声明式的适配规则：取值用 gjson，变换用表达式。\n- key: devops basic_auth: { username: \u0026lt;AK id\u0026gt;, password: \u0026lt;AK secret\u0026gt; } ws: url: \u0026#34;wss://devops.itart.cn/ws/v1/user-notify\u0026#34; type_field: event # 注意不是 type：type 恒为 \u0026#34;event\u0026#34; events: inbox_message: { action: notify, id: { from: data.messageId } } inbox_read: { action: refresh } api: list: path: /api/v1/inbox-items items: data.items map: id: { from: itemId, required: true } title: expr: \u0026#39;join(\u0026#34; \u0026#34;, bracket(json.projectName), json.message.title)\u0026#39; read: { from: readAt, expr: \u0026#39;value != nil\u0026#39; } count: path: /api/v1/inbox-unread-count unread: - { from: data.projectCount, expr: \u0026#39;int(value)\u0026#39; } - { from: data.platformCount, expr: \u0026#39;int(value)\u0026#39; } 这层配置解决三件事：\n字段名不进代码。 换一个系统只换 YAML：路径、字段、分页参数、鉴权方式都写在配置里。 变换不进代码。 拼项目名前缀、判空、类型转换、枚举映射都由一条取值 + 一个表达式表达，不用为每个系统写一遍 DTO 转换。 一个来源写坏不拖累别的。 配置按来源隔离加载与告警：某个来源的表达式或路径写错，它自己在诊断面板里亮红灯，其余来源照常收发。 配置的语义要小 —— 取值 + 一个表达式就够，不要再往上长出模板语言和循环。\n五、代价与边界 做了 没做（以及原因） 配置驱动多来源，一条 YAML 接一个新系统 配置的图形化编辑与热加载（改完重启，够用） 应用内提示卡 + 角标 + 托盘 / 圆钮 / Dock 可点击的系统通知（需 UserNotifications + 签名打包） HTML 正文经 DOMPurify 白名单渲染 Markdown 渲染、消息搜索 按源隔离失败，坏源不拖累好源 本地缓存、离线可读、跨源统一视图 单条已读 \u0026ldquo;全部已读\u0026rdquo;（对端没有 readAll 接口） 规模上大概 2.5k 行 Go（配置加载 / 映射引擎 / HTTP 代理 / WS 集线器）+ 1.3k 行 Go 测试（25 个消息相关单测：gjson 路径、表达式拼标题、判空、int 强转、业务码判定、帧路由、分页推导）+ 约 3k 行前端（抽屉、列表、详情、提示卡与提示条）。\n六、可以搬走的五条 一份真相。 只要有权威接口，就别在前端做加减。宁可多打两次请求，也不要一个长期慢慢偏的数字。 事件是信号，不是数据。 帧里只信 id，内容回查。这让你换后端字段时不会连带改提示逻辑。 配置而非代码。 字段名和路径写进 YAML，加一个系统从\u0026quot;复制一遍代码\u0026quot;变成\u0026quot;抄一段配置\u0026quot;。但配置的语义要小——取值 + 一个表达式，不要再长出模板语言。 可观测性先写。 \u0026ldquo;没有反应\u0026quot;是这类集成最贵的故障态；每帧一条日志的成本，比上线后隔着屏幕猜低一个数量级。 先验证协议，再设计路径。 绕路通常不是因为难，而是因为假设没验证。二十行探针能问清的事，不要用一周的实现去猜。 最后一句是本项目反复验证过的：每一个看起来很\u0026quot;设计\u0026quot;的决定，背后都有一次具体的、能复述给用户的故障。 反过来也成立——没有具体故障支撑的设计，多半是为了好看。\n","permalink":"/blogs/2026/ease-ops/smart-note-ease-ops.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cblockquote\u003e\n\u003cp\u003e流水线失败的红灯只在 EaseOps 网页上亮，而人一天里眼睛都在 DevMate 上。\n这个功能的目标只有一句话：让「有事发生」主动送上门，但不制造第二份真相。\u003c/p\u003e\n\u003c/blockquote\u003e\n\u003ch2 id=\"一为什么放在-devmate-里\"\u003e一、为什么放在 DevMate 里\u003c/h2\u003e\n\u003cp\u003e消息系统最难的部分从来不是\u0026quot;怎么推\u0026quot;，而是\u0026quot;推了有没有人看见\u0026quot;。\u003c/p\u003e","title":"DevMate - 把 EaseOps 消息送进DevMate"},{"content":"前言 给 AI 一双操作 CI/CD 的手 —— ease-ops MCP 介绍\n上一篇讲了 ease ops - 自动化接入Skill 设计：AI 怎么\u0026quot;照着规程\u0026quot;把仓库接进平台。 这一篇讲规程底下的那双\u0026quot;手\u0026quot;——MCP 服务：26 个工具长什么样、怎么连怎么用、 以及它和 Skill 是怎么分工、怎么互相锁死的。\nMCP 是什么：USB-C 的比喻，和它没说的部分 MCP（Model Context Protocol）是 2024 年底 Anthropic 开源的一个协议，管一件事：AI 客户端（Cursor、Claude Code 等）怎么标准化地发现并调用外部系统的能力。你可以把它理解成 USB-C——以前每个 AI 工具要各家写各家插件，现在只要双方都\u0026quot;长这个口\u0026quot;，插上就能用。\n一个常见的误解是：接上之后 AI 就\u0026quot;什么都会了\u0026quot;。不是的。MCP 只解决通道问题，它规定了三件很窄的事：\n发现：客户端问服务器\u0026quot;你有哪些工具？\u0026quot;（tools/list），服务器回一份清单，每个工具带名字、参数 schema、一段给模型看的描述； 调用：客户端发 tools/call，带上工具名和参数，服务器返回结果或错误； 元信息：工具可以带注解（是不是只读、是不是破坏性、能不能重复调），服务器可以带一段全局说明。 至于\u0026quot;AI 该怎么用这些工具把事情做对\u0026quot;，协议一概不管。这正是留给我们要设计的东西——也是这篇后半段 Skill 存在的原因。\nease-ops 的 MCP 长什么样 先看最小的事实。服务端用 Go + mark3labs/mcp-go 实现，挂在主服务的 HTTP 上（默认路径 /mcp，配置里 mcp.enabled 开关），传输方式是 Streamable HTTP：\nCursor / Claude Code ──POST /mcp──▶ ease-ops-api ──▶ 26 个工具 ──▶ 复用 biz 层用例 值得注意最后一节：MCP 没有自己的业务层。internal/mcp/deps.go 里注入的全是现成的 Usecase（Projects / Envs / Flows / Onboard……），和 web 控制台走的是同一套校验与权限。AI 调 ease_ops_apply_onboarding 和人点向导按钮，落到的是同一个函数——不存在\u0026quot;给 AI 开的后门接口\u0026quot;。\n鉴权是一把 eops_ 前缀的 API Key，放在 HTTP 头里：\nKey 与用户身份绑定，服务端只存哈希，明文只在创建时返回一次； 每个工具调用先过中间件：ctx 里没有用户身份直接拒绝（authentication required）； 权限是项目级的：工具内部先解析项目、把该用户在该项目上的权限码写回 ctx，再 requirePerm。你在 web 上看不到某个项目，通过 MCP 一样看不到——AI 不获得任何额外权限。 26 个工具按\u0026quot;旅程\u0026quot;排序注册——身份 → 工作空间 → 项目 → 环境 → 流水线 → 构建 → 接入 → 凭证 → 密钥。tools/list 的顺序就是这条旅程，模型从上往下读，读到的一半是流程。\n六个接口面设计，以及各自防的事故 MCP 服务器做得好坏，全在\u0026quot;接口面\u0026quot;上：模型看到的每个字节。下面六个决定，每个都对应一种真实会发生的事故。\n1. 一段全局说明书，让 26 条工具描述各自只说一句话 server.go 里有一段 serverInstructions，随协议初始化下发给模型，把跨工具的共识集中讲一次：工作空间怎么定、引用怎么给、两种非失败返回、密钥边界。注释写得很直白：\n它把跨工具的共识……集中讲一次，避免在 26 个工具描述里重复。\n于是每条工具描述只写\u0026quot;做什么 + 用哪个工具接着做\u0026quot;，测试里锁了上限——普通工具 120 字符（plan/apply 两个安全语义重的放宽到 400）。不这么做的话，每条描述都会膨胀成小作文，26 份重复的\u0026quot;先调 whoami\u0026quot;最后会把真正有用的 token 挤掉。\n2. 返回形状只有三种，其中一种不是失败 envelopes.go 把工具返回值收敛成一个很反直觉的约定：\n形状 含义 模型该做什么 正常 JSON，其中 status=need_input 缺上下文，不是失败 从 candidates 里挑一个，重试 {\u0026quot;error\u0026quot;:{code,message,field,hint,fixable}} 结构化失败 fixable:false 就停下问人 普通 isError 消息 权限不足 / 参数非法 / 下游故障 绝不猜测式重试 need_input 是给 AI 专门设计的对话钩子。比如你只说\u0026quot;给项目加个环境变量\u0026quot;，但你的 Key 能访问三个项目——服务器不猜，返回：\n{ \u0026#34;status\u0026#34;: \u0026#34;need_input\u0026#34;, \u0026#34;need\u0026#34;: \u0026#34;project\u0026#34;, \u0026#34;hint\u0026#34;: \u0026#34;these repos match several accessible projects; pass project to pick one.\u0026#34;, \u0026#34;candidates\u0026#34;: [ { \u0026#34;code\u0026#34;: \u0026#34;shop\u0026#34;, \u0026#34;name\u0026#34;: \u0026#34;商城\u0026#34; }, { \u0026#34;code\u0026#34;: \u0026#34;payment\u0026#34;, \u0026#34;name\u0026#34;: \u0026#34;支付\u0026#34; } ] } 歧义被原样上抛给模型裁决，而不是在服务端做静默选择。AI 最怕的不是报错，是\u0026quot;看起来成功了但其实选错了\u0026quot;——need_input 让每一步选择都显式。\n3. 只收逻辑名，几乎不收 ID 全局说明里一句话：pass names or codes, never numeric ids。唯一的例外是 build_id，而且规则是\u0026quot;原样传回\u0026quot;（工具还专门容忍了模型把字符串 ID 回传成数字的情况）。\n这条是防\u0026quot;AI 幻觉编 ID\u0026quot;的：模型想不起某个 ID 时，它会造一个看着合理的数字——如果接口收 ID，这个错误会一路穿透到数据层；如果接口只收名字，解析不过就返回 need_input，错误被拦在入口。ID 是平台内部的事，模型连犯错的语言都不具备。\n4. 工作空间：服务器看不见你的终端，就让你钉一次 MCP over HTTP 有个先天缺陷：服务器不知道客户端的工作目录，\u0026ldquo;当前仓库\u0026quot;这个问题无解。ease_ops_use_workspace 的处理是让客户端自己上报：\n你: git remote get-url origin → git@github.com:acme/shop.git AI: use_workspace { repo: \u0026#34;git@github.com:acme/shop.git\u0026#34; } → { status: \u0026#34;ready\u0026#34;, project: {code:\u0026#34;shop\u0026#34;}, components:[...] } （之后所有工具的 project 参数都可以省略） 绑定按用户记在服务端内存里（一人同时只\u0026quot;站在\u0026quot;一个仓库里，语义接近 shell 的 cwd），同时 AI 会把结果写进本地的 .ease-ops/workspace.json——下次会话直接读文件，连这个工具都能跳过。绑定失效（项目被删、权限被收回）时自动走 rebindWorkspace：只剩一个可访问项目就无缝接上，否则回 need_input。\n5. 注解四件套：让客户端知道哪个工具危险 mcplib.NewTool 的默认注解是\u0026quot;破坏性、开放世界\u0026rdquo;——不显式覆盖的话，26 个工具在客户端看来个个都是危险操作，要么全弹确认框，要么用户学会了一路回车（后者更糟）。所以每个工具注册时必须显式声明四类工具身份（read / write / upsert / delete），漏写直接注册期 panic，测试 TestToolAnnotationValues 还锁了每个工具的具体取值。防的是一次手滑把\u0026quot;get_build 改成 writeTool\u0026quot;这种静默回归。\n6. 密钥不过对话 协议层的约定只有一句：secret 永不经过对话。落到接口上是两个工具接力：\nAI: create_secret_request { project:\u0026#34;shop\u0026#34;, name:\u0026#34;prod/DB_PASSWORD\u0026#34;, purpose:\u0026#34;env_variable\u0026#34; } → { url: \u0026#34;https://console.../intake/xxxx\u0026#34; } ← 一次性填写页 你: （在浏览器里填，填完说\u0026#34;好了\u0026#34;） AI: get_secret_request { request_id } → status: filled → 拿到 credential_ref 继续 AI 全程只知道\u0026quot;缺哪把密钥\u0026quot;，从不知道值是什么——不是加密做得好，而是值的通道本来就不在 AI 的可达空间里。\n怎么用：从一行配置到一段对话 第一步，拿 Key、配 MCP。 在 ease-ops 控制台创建 MCP API Key（只显示一次），然后写进客户端配置，以 Cursor 为例（.cursor/mcp.json）：\n{ \u0026#34;mcpServers\u0026#34;: { \u0026#34;ease-ops\u0026#34;: { \u0026#34;url\u0026#34;: \u0026#34;https://console.ease-ops.example.com/mcp\u0026#34;, \u0026#34;headers\u0026#34;: { \u0026#34;Authorization\u0026#34;: \u0026#34;Bearer ${env:EASE_OPS_TOKEN}\u0026#34; } } } } 推荐用环境变量插值（Cursor、VS Code 支持），Key 不进文件、配置可以放心提交；不支持插值的客户端只能写明文，那就要把文件权限收到 600 并加进 .gitignore。\n第二步，直接说人话。 配好之后不需要学任何命令，工具清单和全局说明会自动进入模型的上下文。两类典型场景：\n随手查询——不需要 Skill 教，模型顺着 instructions 里的推荐顺序就能走：\n你：shop 项目 test 环境最近一次构建挂了，帮我看下为什么\nAI：（whoami 确认身份 → use_workspace 钉项目 → list_builds 找到最近一次 → get_build {build_id, include:[\u0026quot;steps\u0026quot;,\u0026quot;diagnosis\u0026quot;]}） 构建 #37 失败在 shop-api 的构建步骤，诊断显示 go.mod 里依赖版本冲突……点这里看流水线详情：links.pipeline_detail\n注意最后那个链接：每个响应都内嵌 links 深链映射，AI 直接把 URL 给你，不许自己拼——对话里\u0026quot;AI 编出一个 404 链接\u0026quot;这类事就是这么防掉的。\n接入仓库——这是唯一被 Skill 接管的重写链路（下一节讲为什么）：\n你：把这个仓库接进 ease-ops\nAI：check_repo → 读本地文件 → 写计划 → plan_onboarding → 摘要给你确认 → apply_onboarding → 交接\n排障三件事：连不上或 401，先查 Key 是否有效、配置里变量是否注入成功；工具列表为空，多半是服务器没开 mcp.enabled；AI 说\u0026quot;skill 版本过旧\u0026quot;，那是下一节的版本门禁拦下了你，重跑安装器即可。\nMCP 与 Skill：能力和规程的关系 先给结论式的分工表：\nMCP Skill 本体 服务端进程，26 个带 schema 的工具 一组 markdown 文件，装在客户端 回答的问题 \u0026ldquo;能调什么、怎么调\u0026rdquo; \u0026ldquo;该在什么时候调、调之前谁点头\u0026rdquo; 生效层 协议层：鉴权、校验、need_input 对话层：阶段、硬规则、话术 消费者 任何支持 MCP 的客户端 支持 skill 机制的客户端 为什么光有 MCP 不够 理论上，不装 Skill 模型也能看着 26 个工具自己编排——查询类场景确实没问题。但接入链路不一样：apply_onboarding 会建项目、改流水线，模型\u0026quot;发挥\u0026quot;的代价是真实的。缺了 Skill，会发生三件事：\n模型可能跳过确认直接 apply——协议层没有任何机制禁止它这样做； 模型可能把密钥明文写进 payload——虽然服务端会以 secret_in_payload 硬错误拒绝，但它要多试错几轮才知道； 模型遇到 pre_build_blockers 可能自动重试 apply——而 apply 的部分失败恰恰最需要人来裁决。 所以 Skill 把这三件事写成了硬规则（没 plan_id 不 apply / secret 不进对话 / 确认必须显式）。反过来，Skill 也不只是\u0026quot;更详细的说明书\u0026quot;——看下一小节。\n规则的两层实现：话说在前面，闸门在后面 Skill 和 MCP 对同一条安全约定的执行是两层的，这是整个设计里最值得展开的一点：\n安全约定 Skill 层（提示词） MCP/服务端层（机制） 不许未确认就执行 \u0026ldquo;确认必须是显式的\u0026rdquo; apply 必须携带有效 plan_id，payload 指纹不匹配直接拒绝 不许带风险执行 逐条向用户过 acknowledge_required acknowledge 未回填 → ack_missing 不许碰密钥 \u0026ldquo;不写入文件、不复述\u0026rdquo; payload 里出现 values → secret_in_payload 硬错误 不许用内部 ID \u0026ldquo;对外只出现逻辑名\u0026rdquo; schema 只收名字/编码，未知字段严格报错 Skill 的价值是让模型根本不发起错误的调用（省一轮试错、少一分漂移）；服务端的价值是即使模型没听劝，也做错不了。提示词不可靠是正常的，所以每一条规矩都必须有一个服务端闸门做后盾——只有提示词的规则是许愿，只有服务端规则的体验是灾难，两层都在才成立。\n版本握手：skill 和 MCP 谁也不许跑在对方前面 whoami 返回 min_skill_version: 2.0.0，而 SKILL.md 头部写着 version: 2.0.0。Skill 的阶段 0 就是比对这两个值：服务端把工具面从 55 个重写成 26 个时，把下限抬到 2.0.0，所有装旧版 skill 的用户会在第一个工具调用就被拦下并提示\u0026quot;重跑安装器\u0026quot;，而不是带着对旧工具名的理解一路猜下去。\n一起演进：文档不许引用不存在的工具 最后一道保险在 CI 里。registry_test.go 有两个不显眼的测试：\nTestToolSurface：工具面锁死为 26 个具体名字，多一个少一个都红——工具面对模型就是承诺，不能悄悄变； TestSkillDocsOnlyReferenceRegisteredTools：扫描 skills/ease-ops-onboard/ 下全部 markdown（外加设计文档），凡是写了 ease_ops_* 的地方，都必须对应一个已注册的工具，否则测试失败。 也就是说：SKILL.md 里写了一个不存在的工具名，是编译不过去的。文档和代码不是靠人肉同步，是靠测试焊死。这就是\u0026quot;skill 是 MCP 的说明书\u0026quot;这类说法的升级版——说明书被钉在了服务器身上，撕一页都留痕迹。\n结语：双层的 Agent 接口 把两篇合起来看，ease-ops 给 AI 暴露的其实是一个双层结构：\nSkill（对话层） 五阶段 · 三条硬规则 · references 按需加载 ← 规程 MCP（协议层） 26 工具 · need_input · 逻辑名 · 密钥绕行 ← 能力 + 闸门 biz（业务层） 与 web 向导共用的同一套用例与权限 ← 事实 查询类轻量场景，模型沿 MCP 的全局说明自由发挥就够了；接入这种重写场景，才值得上 Skill。判断标准就一条：AI 自由发挥出错的代价，你付得起吗？\n而不管轻还是重，MCP 这一侧的纪律是共通的：把歧义上抛（need_input）、把幻觉堵死（只收逻辑名）、把密钥绕出对话（intake 页面）、把危险显式标注（注解四件套）——不是让 AI 更强，而是让它能犯的错误更少。\n","permalink":"/blogs/2026/ease-ops/ease-ops-mcp.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e给 AI 一双操作 CI/CD 的手 —— ease-ops MCP 介绍\u003c/p\u003e\n\u003cblockquote\u003e\n\u003cp\u003e上一篇讲了 \u003ca href=\"https://itart.cn/blogs/2026/explore/ease-ops-onboard.html\"\u003eease ops - 自动化接入Skill 设计\u003c/a\u003e：AI 怎么\u0026quot;照着规程\u0026quot;把仓库接进平台。\n这一篇讲规程底下的那双\u0026quot;手\u0026quot;——MCP 服务：26 个工具长什么样、怎么连怎么用、\n以及它和 Skill 是怎么分工、怎么互相锁死的。\u003c/p\u003e\n\u003c/blockquote\u003e","title":"Ease Ops - MCP 给 AI 一双操作 CI/CD 的手"},{"content":"前言 让 Cursor / Claude Code / CodeBuddy 里的 AI，通过一句话把\u0026quot;当前仓库\u0026quot;接进 ease-ops： 建项目、识别组件、插流水线、接配置和密钥。 这篇讲的核心是 Skill 本身怎么设计，以及它带来了什么收益。\n起点：接入这件事，值不值得做一个 Skill？ 对没接入过 DevOps 平台的人来说，\u0026ldquo;把仓库接进 ease-ops\u0026quot;是一条又长又碎的链路：项目、环境、仓库、组件、构建规格、配置模板、流水线插入，一环扣一环。熟练工在 web 向导里点半小时，中间填错任何一步都要回退重来。\n而这件事的消费者恰恰是 AI 编码工具——它们最擅长处理\u0026quot;有明确流程的复杂任务\u0026rdquo;。问题只有一个：你敢不敢让 AI 碰生产平台的写接口？\nease-ops-onboard 的回答是：敢，但前提是 Skill 设计得当。Skill 不是\u0026quot;给 AI 的一段提示词\u0026quot;，而是一份把权限、流程、安全全部写死的作业规程。下面看这份规程的四个设计支柱。\n支柱一：五阶段工作流 —— 每阶段有\u0026quot;退出条件\u0026quot;，不许跳步 Skill 把整个接入组织成五个阶段，每个阶段定义了动作和退出条件，没达标就不能进下一阶段：\n阶段 AI 在做什么 人在做什么 退出条件 0 自检 whoami 版本比对、resolve_repo 判定模式 命中多项目时选一个 模式已定 1 探测 probe_repo + 本地读 go.mod / package.json 交叉验证 — 组件候选与配置清单生成 2 规划 写计划文件 → plan → 渲染四块摘要 显式确认 用户点头 + 风险逐条回填 3 执行 apply → 缺密钥引导去 intake 页面 → 轮询续跑 在浏览器里填密钥 applied 或有明确下一步 4 交接 写状态文件、给深链、列待复核清单 知道下一步找谁 无悬空 blocker 这个结构带来三个直接收益：\n可预期：无论用户的对话怎么绕，AI 永远沿同一状态机走，同一个仓库今天接、明天接，产出的拓扑一致； 可恢复：阶段间通过计划文件（.ease-ops/onboarding.yaml）和状态文件（onboarding.json）衔接，对话中断、密钥没填、执行部分失败，回来都能从断点续跑，而不是从头再来； 可审计：每个阶段的输入输出都是平台侧有记录的对象（plan_id、apply 结果、intake 状态），出了问题能回放。 值得强调的是阶段 0 的\u0026quot;数据路由\u0026quot;设计：不支持 slash command 的客户端（Trae、Windsurf 等），靠 Skill description + resolve_repo 的返回数据也能自动路由到正确场景（新接入 / 加项目 / 加组件）。入口可以有高有低，流程只有一条。\n落到实际对话里，前两个阶段是这样的（真实走查的浓缩版）：\n你：把这个仓库接进 ease-ops\nAI [阶段 0] 你是 hyman，skill 版本校验通过 ✔；git@github.com:acme/shop.git 未被任何项目使用 → new_project\nAI [阶段 1] 平台探测：monorepo，2 个可独立构建单元 —— web/（Next.js → 建议 shop-web）、api/（Go 1.23 → 建议 shop-api）；.env.example 发现 7 个 key，其中 2 个疑似密钥\nAI [阶段 2] 计划已写入 .ease-ops/onboarding.yaml，四块摘要（仓库与项目 / 组件与构建 / 配置与密钥 / 流程插入）。缺 1 项密钥：prod/DB_PASSWORD。确认执行？\n你：执行\nAI [阶段 3] apply 完成 10/10 → 打开 intake 页面补密钥，轮询到 filled 后续跑\nAI [阶段 4] 已写 .ease-ops/onboarding.json；项目与流水线深链、待复核清单就绪，下一步 /ease-ops:verify 触发一次构建并自动诊断\n全程用户只说了三句话：一个请求、一次\u0026quot;执行\u0026quot;、一句\u0026quot;填好了\u0026quot;。\n支柱二：三条硬规则 —— 把安全写成协议，而不是靠自觉 Skill 正文里最醒目的是三条任何阶段不得违反的硬规则：\n没有 plan_id 不执行；blockers 非空不执行；风险项未逐条确认不执行； secret 永不进入 payload / 文件 / 对话，只走独立的 intake 页面； 用户确认必须是显式肯定，\u0026ldquo;看起来可以\u0026quot;\u0026ldquo;嗯\u0026quot;不算。 三条规则落到形态上，各是这样一小段：\n规则 1——plan 返回的风险项，必须逐条回填才许执行：\n// plan_onboarding 返回 \u0026#34;acknowledge_required\u0026#34;: [ {\u0026#34;code\u0026#34;: \u0026#34;shared_repo\u0026#34;, \u0026#34;summary\u0026#34;: \u0026#34;该 git 已被项目 payment 使用；共用会导致凭证、分支策略、产物互相牵连\u0026#34;} ] // apply 前 payload 必须回填，否则 ack_missing 拒绝 \u0026#34;acknowledge\u0026#34;: [\u0026#34;shared_repo\u0026#34;] 规则 2——secret 在 payload 里只许出现名字：\nconfigs: - key: DB_PASSWORD scope: project secret: true # 出现 values 即服务端硬错误 secret_in_payload required: [prod] 规则 3——确认必须是显式指令：\nAI: 确认执行？ 你: 看起来可以 → 不算，AI 停下来再次请求明确指令 你: 执行 → 算，进入 apply 这三条规则的巧妙之处在于：它们约束的不是平台，而是 AI 自己。平台侧本来就有校验兜底，但 Skill 把\u0026quot;什么情况下根本不该发起调用\u0026quot;前置到了对话层，效果是：\nAI 拿不到密钥，也不需要拿到。整个对话里密钥只以\u0026quot;缺 1 项：prod/DB_PASSWORD\u0026quot;的形态出现——AI 知道缺什么，从不知道值是什么。用户填完回来说\u0026quot;填好了\u0026rdquo;，AI 轮询状态继续。零暴露不是因为加密做得好，而是因为值的通道在 AI 的可达空间之外； 人审过的计划就是被执行的计划。apply 时服务端按 payload 重算指纹，AI\u0026quot;顺手改一个字段\u0026quot;直接被打回重新走确认。防 AI 漂移不靠祈祷模型听话，靠机制； 确认是可审计的动作。跨项目共用 git 这类风险，plan 会返回 acknowledge_required，用户不逐条点头就 apply 不了——把\u0026quot;知道风险\u0026quot;从口头承诺变成落库记录。 对用户的体感收益是：你不需要懂这个平台的所有细节，也敢让它替你做。这是 AI 操作生产系统和\u0026quot;玩具 demo\u0026quot;的分水岭。\n支柱三：渐进披露的文档结构 —— 250 行正文 + 四件套按需读取 Skill 的交付物不是一段长提示词，而是一个分层的信息结构：\nSKILL.md（≤250 行） → 只放\u0026#34;路由与阶段\u0026#34;：何时用、硬规则、五阶段表、各阶段判定逻辑 references/payload.md → 字段铁律 + 完整 JSON Schema + 正反例 + 易错判断 references/errors.md → 错误码表 + 逐码话术 + 处置总则 + 禁止行为 references/clients.md → 5 客户端能力矩阵 + 配置片段 + 排障表 references/verify.md → 触发方式 + 轮询节奏 + 失败自动诊断对照表 这是按\u0026quot;AI 怎么读文档\u0026quot;设计的：正文是给所有对话的常驻路由层，细节在真正需要时才加载（阶段 1 读 payload、失败时读 errors、阶段 0 读 clients、阶段 4 读 verify）。\n收益 说明 Token 经济 常驻上下文只有 250 行，而不是把 60+ tool 的参数细节全塞进去 单一真相 SKILL.md 正文与设计文档一一对应，改错误话术只动 errors.md，不用重新对齐提示词 行为一致 AI 对未知错误的第一反应是查表（errors.md 逐码话术），而不是现场编一个处置方案 人类可读 新人想了解这个 Skill 能干什么，读 250 行正文就够，不用啃全量 schema 250 行正文里装的是什么，章节骨架一目了然（与 SKILL.md 文件一一对应）：\n## 何时用 / 何时不用 ## 三条硬规则 ## 五阶段与退出条件（表格） ## 阶段 0 的判定逻辑（resolve_repo 分支：0/1/≥2 命中） ## 阶段 1 的组件切分规则 ## 阶段 2 的四块摘要模板 ## 阶段 3 的 intake 与 resume ## 阶段 4 的交接四件套 ## 失败处置（指向 references/errors.md） 注意最后几行：正文对 references 的引用点恰好落在四个阶段上——阶段 1 读 payload、失败时读 errors、阶段 0 读 clients、阶段 4 读 verify。正文负责\u0026quot;什么时候去查\u0026rdquo;，references 负责\u0026quot;查什么\u0026quot;。\n配套还有一条接口纪律贯穿始终：对外只出现逻辑名，永不出现平台资源 ID；未知字段严格报错。看一小段 payload 就能感受到这份\u0026quot;词汇表\u0026quot;有多窄：\nrepos: - key: shop credential_ref: platform:git-acme-ro # 引用凭证，不是用户名密码 components: - code: shop-api repo_refs: [shop] # 按 key 指仓库，不重复贴 URL build: runtime: go-1.23 # 逻辑名，不是 image_version_id 这让 AI 无法引用自己不认识的东西——它连犯错的语言都不具备。\n支柱四：安装器即产品 —— npx @ease-ops/onboard init 十分钟上手 Skill 再好，接入成本高就没人用。所以 skill 目录本身同时是一个零依赖的 npm 包：\nnpx @ease-ops/onboard init → 选客户端 → 粘贴 MCP Key（或浏览器设备码） → 写 skill + references → 合并 MCP 配置 → whoami 连通性验证 跑起来是这样（示意）：\n$ npx @ease-ops/onboard init ? 选择客户端: Cursor ? 粘贴 MCP Key（隐藏输入）: ******** ✔ 写入 .cursor/skills/ease-ops-onboard/（SKILL.md + 4 个 references） ✔ 合并 .cursor/mcp.json（只动 ease-ops 条目，原有 server 与 4 空格缩进不变） ✔ 连通性验证: hyman / 可见 2 个项目 $ npx @ease-ops/onboard init # 重跑 ✔ unchanged # 幂等，不产生重复条目 设计上有几处克制值得学：\n多客户端差异被适配器吸收：Cursor / Claude Code / CodeBuddy / VS Code / Trae 五家的 skill 落位、MCP 配置格式、Key 注入能力（环境变量插值 / 输入框占位 / 只能明文）全部收敛在 5 个客户端适配器里，用户只回答一个问题：\u0026ldquo;你用什么编辑器\u0026rdquo;；\n安全分级：不同客户端的 Key 注入能力分三档，安装器按档处理——\n// A 档（如 Cursor）：写变量引用，Key 不进文件，配置可放心提交 { \u0026#34;url\u0026#34;: \u0026#34;https://console.../mcp\u0026#34;, \u0026#34;headers\u0026#34;: { \u0026#34;Authorization\u0026#34;: \u0026#34;Bearer ${env:EASE_OPS_TOKEN}\u0026#34; } } // B 档（如 CodeBuddy）：无插值能力，只能写明文 // → 安装器强制 chmod 600 + 自动补 gitignore 并用 git check-ignore 复查 { \u0026#34;url\u0026#34;: \u0026#34;https://console.../mcp\u0026#34;, \u0026#34;headers\u0026#34;: { \u0026#34;Authorization\u0026#34;: \u0026#34;Bearer eops_xxxx\u0026#34; } } 能写引用的（A/C 档）不含 secret，可放心提交；只能写明文的（B 档）被机制保证不会进版本库；\n工具宁可少做，不可做错：合并 JSON 配置只改自己的那一项、保留用户缩进和顶层键序；文件含注释就拒写并打印片段供手改；init 幂等（重跑输出 unchanged）；remove 按客户端定向清理，不碰用户的工作目录状态；\n版本漂移有告警：whoami 返回 min_skill_version，服务端升级了 payload 格式，旧版 skill 会在阶段 0 被礼貌拦下并提示更新，而不是带着过期的理解去执行。\n收益很直接：使用者从\u0026quot;读文档 + 手工配 5 个文件\u0026quot;变成\u0026quot;跑一条命令\u0026quot;；维护者从\u0026quot;逐个用户排查 MCP 配置错误\u0026quot;变成\u0026quot;让用户跑一遍 doctor\u0026quot;。\n抽几行 SKILL.md 原文：规则是怎么\u0026quot;驯\u0026quot;AI 的 上面四个支柱不是 PPT 上的架构词，它们最终都落在 SKILL.md 一行行的祈使句里。全文只有 198 行，抽几句最能体现设计功力的原文：\n开篇先定权责：\n你负责探测与推断，平台负责校验与执行，人负责选择、确认与填密钥。\n违反任意一条（硬规则）视为本次任务失败。\n一句话把三边界写进 AI 的角色认知，而\u0026quot;任务失败\u0026quot;四个字给硬规则上了刑罚——不是建议，是红线。\n不让 AI 做\u0026quot;好心的加工\u0026quot;：\n把原样输出传给工具，不要自己改写 URL（归一化由服务端负责）。\n连不上 / 401 / 工具列表为空：查排障表，不要自行改 MCP 配置后重试。\nAI 的\u0026quot;顺手加工\u0026quot;恰恰是漂移的主要来源：自己规范化一下 URL、自己改改配置试试——每一步都是不可控分岔。这两行的哲学是：AI 只负责搬运事实，不负责修饰事实。\n人说的话和代码冲突时，以代码为准：\n用户说\u0026quot;它只是一个服务\u0026quot;但仓库里明显有前后端两份 → 以代码为准，列出两个候选并说明理由。\n不是无条件听话，也不是无条件自作主张——冲突时把两边都摆上桌，把裁决权交还给人，并附上理由。\n默认值取最保守的那一档：\n密钥判定：key 命中 *_PASSWORD|*_TOKEN|*_SECRET|*_KEY|*_DSN|*_PRIVATE\ntest 只自动填非密默认值；prod 一律不填。\n宁可漏填一个变量让人回来补，不可多填一个值碰了不该碰的密钥——不对称风险的不对称处理。\n把含糊也当作信号处理：\n逐条处理 acknowledge_required：每条都要用户明确回答；即使说\u0026quot;不用管\u0026quot;也要记为明确否定。\n沉默不等于同意，\u0026ldquo;不用管\u0026quot;也不是同意——含糊回答被当作一种信号落库，而不是被 AI 乐观地解释成默许。\n给 AI 的自愈能力设上限：\n可修正的错误只允许在阶段 2 重跑 plan，最多一次。\n连续两次 plan 失败 → 停下来向用户说明卡点，不要继续猜。\n没有这一条，AI 会陷入\u0026quot;猜-报错-再猜\u0026quot;的循环把用户刷屏。允许失败，但不允许无限失败。\n最后一道保险是否定式的清单：\n不要做：不创建定制镜像；不创建环境（平台自动初始化）；不修改既有流程拓扑；不在用户未提及部署时启用部署；不在 payload 里写平台内部 ID。\n把能力边界写成\u0026quot;禁止清单\u0026quot;而不只是\u0026quot;允许清单\u0026rdquo;，是因为 AI 对否定指令的遵循远好于对模糊授权的理解——说清楚\u0026quot;哪些能碰\u0026quot;不够，还要说清楚\u0026quot;哪些永远别碰\u0026quot;。\n这些句子没有一个在描述平台功能，全部在约束 AI 自己的行为——这才是 Skill 的真正精华：它不是说明书，是一个写满了护栏的作业现场。\n收益盘点 把整件事放在一起看，这个 Skill 换来的东西：\n视角 之前 之后 开发者 web 向导点半小时，填错回退重来 一句话，AI 全程代办，人只做三次\u0026quot;点头\u0026quot; 平台 每次接入留下明文密钥的执行记录 协议层杜绝 secret 入 payload / 文件 / 对话 运维 \u0026ldquo;AI 把我流水线改坏了\u0026quot;无法追责 plan_id + 指纹 + acknowledge 回填，每一步可回放 维护者 提示词越长越失控，改一处崩全身 250 行正文 + 四件套 references，分层演进 推广 每个用户手工配置 MCP + skill npx init 一条命令，幂等可卸载 还有一个容易被忽略的复利：Skill 与 web 向导共用同一套 plan/apply 校验。向导服务不写代码的人，Skill 服务写代码的人，两条入口一套规则——平台不用维护两套语义，规则演进一次两边生效。\n设计原则的取舍：不做什么 v1 的\u0026quot;明确不做清单\u0026quot;和正文一样长，几条代表性的：\n不做完整拓扑编辑——只承诺\u0026quot;追加一条并行分支 + 检出复用\u0026rdquo;，精细编排回平台 orchestrator。Skill 的职责边界是\u0026quot;接入\u0026quot;，不是\u0026quot;替代整个流水线编辑器\u0026quot;； 不做 Connector 统一抽象——目前只有 git/ssh 两个真实用例，没有第二个实现的抽象不做； 不动现有向导——skill 只做新链路，旧向导的明文脱敏另立专项。范围收敛让 P0–P5 在几个迭代内全部落地； 不自动创建定制镜像——会触发镜像构建，破坏 apply 的同步语义。宁可少一个功能，不坏一个契约。 这些\u0026quot;不做\u0026quot;共同指向一条原则：Skill 的能力边界要小于平台的真实能力。AI 只在被验证过的窄路上跑，宽路留给人。\n结语：Agent 时代，Skill 是\u0026quot;作业规程\u0026quot;，不是\u0026quot;说明书\u0026quot; 回顾 ease-ops-onboard 的设计，它没有把 Skill 当作\u0026quot;教 AI 怎么用 API 的文档\u0026quot;，而是当作一份作业规程：\n用五阶段状态机规定动作顺序； 用三条硬规则划出安全红线； 用渐进披露控制 AI 的注意力预算； 用安装器和版本握手保证规程能被执行、能被更新。 最终的收益不是\u0026quot;AI 很聪明\u0026quot;，而是\u0026quot;AI 可以不那么聪明\u0026quot;——漂移有指纹拦着，越权有 plan_id 拦着，泄密有 intake 通道绕着。当规程把犯错的空间压到足够小，一句话接入一个仓库才敢从演示视频走进生产环境。\n","permalink":"/blogs/2026/ease-ops/ease-ops-onboard.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cblockquote\u003e\n\u003cp\u003e让 Cursor / Claude Code / CodeBuddy 里的 AI，通过一句话把\u0026quot;当前仓库\u0026quot;接进 ease-ops：\n建项目、识别组件、插流水线、接配置和密钥。\n这篇讲的核心是 \u003cstrong\u003eSkill 本身怎么设计\u003c/strong\u003e，以及它带来了什么收益。\u003c/p\u003e\n\u003c/blockquote\u003e","title":"Ease Ops - 自动化接入Skill 设计"},{"content":" 本文转载自掘金技术社区，原文链接：https://juejin.cn/post/7565516607302074419\n前言 MVCC，全称 Multi-Version Concurrency Control，即多版本并发控制。它是一种为了提高数据库并发性能而提出的技术，使得在并发读写数据库时，读操作不会阻塞写操作，写操作也不会阻塞读操作，解决了传统锁机制带来的性能瓶颈问题。\n在 MySQL 中，InnoDB 存储引擎实现了 MVCC。\n一、MVCC 要解决的核心问题 在没有 MVCC 的情况下，如果要保证事务的隔离性（例如可重复读级别），通常会用锁来实现：\n当一个事务正在读取某些数据时，其他事务不能修改这些数据（共享锁），会导致读 - 写冲突； 当一个事务在修改数据时（排他锁），其他事务不能读取，会导致写 - 读冲突。 MVCC 通过创建数据的历史版本来优雅地解决这个问题。\n核心思想：为每行数据维护多个历史版本。当一个事务需要读取数据时，它会看到在它开始之前就已经提交的某个一致性数据快照，而不管当前这些数据被其他事务修改成了什么样子。\n二、MVCC 的实现基石 MVCC 的实现依赖于三个核心组件：\n隐藏字段 Undo Log（回滚日志） Read View（读视图） 1. 隐藏字段 InnoDB 为每一行数据（记录）都添加了三个系统隐藏字段，此外还有一个删除标记字段，用于标记该行是否被删除。\n表格\n隐藏字段 字节数 作用说明 DB_TRX_ID 6 字节 事务 ID。表示最后一次插入或更新该行的事务 ID；删除操作在内部也被视为更新，会设置特殊的删除标记。 DB_ROLL_PTR 7 字节 回滚指针。指向该行数据的上一个历史版本，存储在 Undo Log 中。 DB_ROW_ID 6 字节 行 ID。随着新行插入而单调递增的行 ID；如果表没有定义主键，InnoDB 会基于这个字段生成聚簇索引。 2. Undo Log Undo Log（回滚日志）主要有两个作用：\n事务回滚时，用于恢复数据； 实现 MVCC 的核心载体，存储数据行的历史版本。 工作原理 当一个事务对某行数据进行修改（INSERT、UPDATE、DELETE）时：\nUPDATE / DELETE：会先将该行数据的当前版本（修改前）复制到 Undo Log 中，副本保留原有的 DB_TRX_ID 和 DB_ROLL_PTR；随后将新的 DB_ROLL_PTR 指向这个刚存入 Undo Log 的旧版本，最后在表中修改该行数据，写入新的 DB_TRX_ID 和新的 DB_ROLL_PTR。 INSERT：新插入的数据对之前的事务不可见，它的 Undo Log 仅在事务回滚时生效，在 MVCC 中作用不大。 通过 DB_ROLL_PTR 指针，一行数据的所有历史版本（快照）被串联成一个链表，这个链表就存放在 Undo Log 中，称为版本链。链表的头节点是当前的最新记录，尾节点是最早的历史版本。\n3. Read View（读视图） Read View 是事务在进行快照读操作时产生的，它定义了当前事务在执行期间，能看到哪些版本的数据。\nRead View 主要包含以下几个关键属性：\nm_ids：生成 Read View 时，系统中活跃的（未提交的）读写事务的事务 ID 列表。 min_trx_id：m_ids 中的最小值。 max_trx_id：生成 Read View 时，系统应该分配给下一个事务的 ID（注意：不是 m_ids 的最大值，而是已创建的最大事务 ID + 1）。 creator_trx_id：创建该 Read View 的事务 ID。 三、可见性算法：如何判断一个版本是否可见 当一个事务执行一条 SELECT 语句（快照读）时，它需要遍历数据行的版本链，并利用自己的 Read View，通过一套算法来决定哪个版本对它来说是可见的。\n对于版本链中的某个版本，假设其对应的事务 ID 为 trx_id，判断规则如下：\n如果 trx_id == creator_trx_id：说明当前事务自己修改了这行数据，这个版本是可见的。\n如果 trx_id \u0026lt; min_trx_id：说明这个版本是在当前 Read View 创建之前就已经提交的，这个版本是可见的。\n如果 trx_id \u0026gt;= max_trx_id：说明这个版本是在当前 Read View 创建之后才开启的事务修改的，这个版本不可见。\n如果 min_trx_id \u0026lt;= trx_id \u0026lt; max_trx_id\n：需要检查\ntrx_id 是否在\nm_ids （活跃事务列表）中：\n如果在，说明创建 Read View 时，修改这个版本的事务还未提交，该版本不可见； 如果不在，说明创建 Read View 时，修改这个版本的事务已经提交了，该版本可见。 如果当前版本不可见，就顺着版本链找下一个旧版本，重复上述判断，直到找到可见的版本；如果遍历完所有版本都不可见，则返回空。\n四、在不同隔离级别下的表现 MVCC 主要在 READ COMMITTED（读已提交） 和 REPEATABLE READ（可重复读） 这两个隔离级别下工作，二者的核心差异在于 Read View 的生成时机不同。\n1. REPEATABLE READ（可重复读 - MySQL 默认级别） 核心特性：在同一个事务中，第一次执行快照读时会创建一个 Read View，之后在这个事务中的所有快照读都复用这个相同的 Read View。 效果：因为 Read View 是静态的，所以无论之后其他事务如何提交修改，这个事务看到的数据快照始终和它第一次看到的一样，完美实现了 “可重复读”。 2. READ COMMITTED（读已提交） 核心特性：在同一个事务中，每次执行快照读都会生成一个新的、独立的 Read View。 效果：因为每次读都会重新获取一次当前系统的活跃事务列表，所以每次都能看到在本次查询开始之前已经提交的所有事务的修改，实现了 “读已提交”，即能读到其他事务最新提交的内容。 五、工作流程总结 MVCC 的完整工作流程可以总结为：\n每个数据行都带有隐藏的 DB_TRX_ID 和 DB_ROLL_PTR 字段； 数据的修改操作会在 Undo Log 中创建历史版本，形成版本链； 事务执行快照读时生成 Read View（RC 级别每次生成，RR 级别仅第一次生成）； 通过可见性算法遍历版本链，找到对当前事务可见的那个数据版本。 六、补充说明 快照读 vs 当前读 快照读：普通的 SELECT 语句，基于 MVCC 和 Read View 读取历史版本，不加锁。 当前读：特殊的 SELECT 语句（如 SELECT ... FOR UPDATE、SELECT ... LOCK IN SHARE MODE）以及 INSERT、UPDATE、DELETE 操作。当前读读取的是记录的最新版本，并且会通过加锁（Next-Key Lock）来保证数据一致性。 Purge 操作 随着时间推移，Undo Log 中旧版本数据会越来越多。系统会有一个后台的 Purge 线程，来清理那些不再被任何事务的 Read View 需要的旧版本数据，从而释放存储空间。\n","permalink":"/blogs/2026/db/mysql-mvcc.html","summary":"\u003cblockquote\u003e\n\u003cp\u003e本文转载自掘金技术社区，原文链接：https://juejin.cn/post/7565516607302074419\u003c/p\u003e\n\u003c/blockquote\u003e\n\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003eMVCC，全称 \u003cstrong\u003eMulti-Version Concurrency Control\u003c/strong\u003e，即多版本并发控制。它是一种为了提高数据库并发性能而提出的技术，使得在并发读写数据库时，读操作不会阻塞写操作，写操作也不会阻塞读操作，解决了传统锁机制带来的性能瓶颈问题。\u003c/p\u003e","title":"[转] MySQL InnoDB MVCC 实现原理详解"},{"content":"前言 Skill 不只是一个 Prompt 文件，而是一套可以被 Agent 自动发现、按需加载、重复执行、持续验证和版本化管理的“工作流能力”。\n随着 Cursor、Claude Code、Codex、ChatGPT 等 AI 编程和 Agent 工具不断成熟，一个非常明显的趋势正在出现：\nAI Agent 的竞争正在从“模型知道多少”，逐渐转向“Agent 能否稳定执行一套专业流程”。\n例如：\n写 Go 代码时必须遵循项目 DDD 分层规范\n做数据库迁移时必须先备份、迁移、校验，再允许删除旧结构\n做 Code Review 时必须按照固定维度检查\n写技术文章时必须先分析资料、再组织结构、最后自检\n发布服务时必须经过测试、构建、灰度、监控和回滚\n开发前端页面时必须使用公司统一组件和设计规范\n这些事情的问题并不是模型“不会”，而是：\n每一次都重新告诉 AI 怎么做，成本高，而且容易漂移。\nSkill 的价值，就是把这些反复出现的工作方式沉淀成一种可以复用的 Agent 能力。\nAnthropic 当前的官方文档将 Skill 定义为可复用的、基于文件系统的专业知识、工作流和最佳实践；Claude 会根据 Skill 的 name/description 判断相关性，在需要时进一步读取 SKILL.md 和配套资源。\nOpenAI 的官方介绍也将 Skill 描述为一种可复用、可共享的工作流，用于减少重复解释，让模型按照稳定的流程完成任务。\nCursor 则把 Skill 定义为一种便携、可版本控制、可渐进加载的 Agent 能力包。\n所以，真正值得讨论的问题已经不是：\n“Skill 是什么？”\n而是：\n怎样设计一个工程化、高可靠、可维护、跨 Agent 复用的 Skill？\n1. Skill 到底是什么？ 可以把 Skill 抽象成：\nSkill = Trigger + Instructions + Resources + Tools + Validation\n也就是：\n触发条件 ↓ 执行规则 ↓ 标准流程 ↓ 参考资料 / 脚本 / 模板 ↓ 结果校验 与传统 Prompt 最大的区别在于，Skill 不是一次性的对话指令，而是一个可以长期复用的能力模块。\n例如一个：code-review Skill，可以规定：\n什么时候使用 ↓ 先分析整体结构 ↓ 再检查正确性 ↓ 再检查并发 ↓ 再检查性能 ↓ 再检查安全 ↓ 最后输出问题等级和修改建议 Agent 每次遇到 Code Review 场景，都可以复用这个流程。\n因此可以把：\nPrompt\n理解成：\n“这一次怎么做”\n而：\nSkill\n更像：\n“以后遇到这类事情，一律按照这套方法做”。\n2. Skill 与 Prompt、Rule、Agent、MCP 的区别 实际工程中最容易混淆的是这几个概念。\n2.1 Prompt Prompt 主要解决：\n一次任务\n例如：\n帮我 review 这个 Go 文件。\n它通常只对当前请求有效。\n2.2 Rule Rule 更偏向：\n长期约束\n例如：\n项目统一使用 Go 1.24 禁止使用 panic 所有 Repository 必须通过 interface 注入\nRule 更像：\n“这个项目永远遵守什么规则”。\n2.3 Skill Skill 解决的是：一类任务怎么完成\n例如：\nCode Review 数据库迁移 发布服务 生成技术文章 分析生产事故 它描述的不只是规则，而是：\nInput ↓ Process ↓ Output ↓ Validation 2.4 Agent Agent 更高一层。\n可以理解成： 可以理解成：\nAgent ├── Model ├── Tools ├── Rules ├── Skills ├── Memory └── Context Skill 是 Agent 的专业能力模块之一。\n2.5 MCP MCP 解决的是：Agent 能做什么 例如：\n查询 GitHub 访问数据库 读取 Jira 操作 Kubernetes 调用内部 API Skill 解决的是：\nAgent 应该怎么做 因此两者可以组合：\nSkill + MCP Tools ↓ 完整业务工作流 例如：\nproduction-incident-response Skill: 定义故障处理流程 MCP: 查询 Prometheus 查询 Kubernetes 查询日志 查询 GitHub 这才是企业 Agent 真正有价值的形态。\n3. 官方标准实际上在强调什么？ 目前 Agent Skills 生态正在形成比较一致的设计原则。\nAnthropic 官方要求每个 Skill 至少包含一个 SKILL.md，其中通过 YAML frontmatter 定义：\n--- name: your-skill-name description: What this Skill does and when to use it --- 其中：\nname 必须明确 description 必须同时说明“做什么”和“什么时候使用” Skill 目录可以进一步包含脚本、参考资料等资源。 Cursor 同样采用：\nskill-name/ └── SKILL.md 并支持：\nscripts/ references/ assets/ 等配套资源。\nOpenAI 的官方 Skill 指南也强调：\nName Description Workflow Instructions Resources Required Output Final Checks 这实际上和你给出的 Superpowers 规范高度一致。\n4. 为什么 SKILL.md 不应该写成一本书？ 这是 Skill 最重要的设计原则之一。\n很多人第一次写 Skill，会犯一个错误：\n把所有自己知道的东西全部写进去。\n例如：\n## 什么是 Go Go 是 Google 开发的一门编程语言…… ## 什么是 Goroutine Goroutine 是 Go 提供的轻量级并发执行单元…… ## 什么是 Channel Channel…… 这通常是错误的。\n因为 Agent 本身已经具备大量基础知识。\n官方文档明确强调：\nContext Window 是共享资源。\nSkill 一旦被加载，其内容会和系统指令、历史对话、其他 Skill、用户任务共同竞争上下文空间。因此 Skill 应该只提供模型缺失的、真正有价值的上下文。\n正确方式应该是：\n## Go Project Rules - Use Go 1.24. - Repository implementations must be injected through interfaces. - HTTP handlers must not directly access GORM. - Domain layer must not import infrastructure packages. 而不是：\n什么是 Go？ 什么是 interface？ 什么是 GORM？ 什么是 DDD？ 核心原则就是：\nSkill 写规范，不写百科。\n5. Skill 最重要的设计：描述必须帮助 Agent 发现它 很多 Skill 写得很好，但 Agent 根本不会使用。\n问题往往不在 Instructions，而在：\ndescription:\n例如：\ndescription: Code review helper.\n太模糊。\nAgent 很难判断什么时候应该调用。\n更好的形式：\ndescription: Reviews Go code for correctness, concurrency safety, performance, error handling, API design, and project conventions. Use this skill when reviewing Go pull requests, commits, or source files. 也就是：\nWhat + When Anthropic 官方明确要求 description 同时描述 Skill 做什么以及什么时候使用，并建议使用第三人称描述。\n例如：\ndescription: Reviews Go services for correctness, concurrency safety, performance, maintainability, and project conventions. Use when reviewing Go code, pull requests, commits, or architecture changes. 这个描述明显比：\ndescription: Go review.\n更容易被正确发现。\n6. Skill 的目录设计 一个成熟 Skill 不应该只有一个巨大 Markdown。\n推荐：\nskills/ └── code-review/ ├── SKILL.md ├── scripts/ │ ├── check.sh │ └── analyze.go ├── references/ │ ├── go-style.md │ ├── security.md │ └── concurrency.md ├── examples/ │ └── review-example.md └── tests/ ├── basic.md └── concurrency.md 其中：\nSKILL.md\n负责：\n核心流程\n而：\nreferences/\n负责：\n详细知识\nscripts/\n负责：\n机械执行\nexamples/\n负责：\n帮助模型理解正确结果\ntests/\n负责：\n验证 Skill 是否真的有效\nAnthropic 的开源 Skills 仓库本身也采用了这种 Skill 目录化设计，并将不同 Skill 作为独立目录维护。\n7. 最佳实践一：核心流程必须写在 SKILL.md 你提供的 Superpowers 规范中有一个非常重要的设计：\nTRIGGERS CORE RULE STANDARD PROCESS SELF-CHECK LIST COMMON EXCUSES ANTI-PATTERNS 这是非常适合工程实践的一种 Skill 结构。\n推荐：\n# Go Code Review ## TRIGGERS This skill activates when: - Reviewing Go source code - Reviewing Go pull requests - Reviewing Go commits - Reviewing concurrency-sensitive changes ## CORE RULE - NON-NEGOTIABLE Every review MUST evaluate correctness before optimization. ## STANDARD PROCESS 1. Understand architecture 2. Check correctness 3. Check concurrency 4. Check performance 5. Check security 6. Check maintainability 7. Produce prioritized findings ## SELF-CHECK LIST [ ] Correctness checked [ ] Concurrency checked [ ] Performance checked [ ] Security checked [ ] Findings prioritized 这种结构非常适合 Agent。\n因为 Agent 最擅长的不是读取一堆散文，而是执行：\n状态 ↓ 步骤 ↓ 条件 ↓ 动作 ↓ 验证 8. 最佳实践二：不要所有地方都使用绝对规则 这里需要对 Superpowers 的“绝对化语气”做一个工程化修正。\n在真正的 Skill 设计中：\nNO EXCEPTIONS\n并不是所有地方都适合。\nAnthropic 官方实际上强调：\nSkill 指令应该根据任务的不确定性设置不同程度的自由度。\n可以分为三种。\n高自由度 适合：\n代码 Review 架构分析 技术方案设计 故障分析 例如：\nAnalyze the architecture and identify the most important risks. Choose the most appropriate review strategy based on the codebase. 不要规定每一步都必须使用固定命令。\n中自由度 适合：\n生成报告 构建代码 生成 API 例如：\nUse the project template and adapt it to the current service.\n低自由度 适合：\n数据库迁移 生产发布 安全操作 证书轮换 数据删除 例如：\nRun: ./scripts/migrate.sh --verify Do not modify the command. Do not skip verification. 官方文档给出的原则非常清晰：\n任务越危险、越脆弱、越要求一致性，指令自由度就越低。\n所以真正好的 Skill 不是：\n一律绝对化\n而是：\n根据风险决定自由度\n9. 最佳实践三：渐进式加载 这是现代 Skill 非常重要的设计思想。\n不要：\nSKILL.md ↓ 5000 行 而应该：\nSKILL.md ↓ 判断需要什么 ↓ references/ scripts/ examples/ ↓ 按需读取 例如：\nSKILL.md\n只有：\n## Migration 1. Read references/migration.md 2. Execute scripts/backup.sh 3. Execute scripts/migrate.sh 4. Run verification 真正复杂的内容放：\nreferences/migration.md 这就是：\nProgressive Disclosure\nAnthropic 官方明确说明，Skill 的 metadata 会优先用于发现，而完整 SKILL.md 在 Skill 相关时再读取，其他资源也应该按需读取，从而控制上下文成本。\nCursor 也明确把 Progressive Loading 作为 Skills 的核心特性之一。\n10. 最佳实践四：不要把“业务决策”全部塞进脚本 例如：\nscripts/ └── deploy.sh 非常适合：\n机械执行\n例如：\ndocker build kubectl apply go test go vet 但是不应该把：\n到底部署哪个环境？ 为什么部署？ 什么时候允许灰度？ 是否应该回滚？ 完全写死在脚本中。\n更合理的职责划分：\nSKILL.md ↓ 业务决策 ↓ 调用脚本 ↓ 机械执行 即：\n模型负责决策，脚本负责确定性执行。\n这样 Skill 才容易维护。\n11. 最佳实践五：Skill 必须有验收机制 Skill 和普通 Prompt 最大的一个区别就是：\n它应该知道什么叫“完成”。\n例如：\n## SELF-CHECK LIST [ ] All tests pass [ ] No TODO remains [ ] API compatibility verified [ ] Error handling reviewed [ ] Output matches required format 这一步非常重要。\n因为：\n执行完成\n和：\n任务正确完成\n不是一个概念。\n一个成熟 Skill 应该形成：\nInput ↓ Plan ↓ Execute ↓ Verify ↓ Output 而不是：\nInput ↓ Generate ↓ Done 12. 最佳实践六：把错误经验写成 Anti-Patterns Superpowers 规范非常值得保留的一部分。\n例如：\n## ANTI-PATTERNS - Writing production code before tests - Querying the database directly from HTTP handlers - Ignoring existing project abstractions - Adding unrelated refactoring - Optimizing before correctness is verified 这样做比单纯写：\n请写高质量代码 有效得多。\n因为模型不仅需要知道：\n应该做什么\n还需要知道：\n不能做什么\n最终形成：\nPositive Rules + Negative Rules = Behavior Boundary 13. 最佳实践七：不要把 Skill 写成“万能 Skill” 这是非常常见的失败模式。\n例如：\nsoftware-engineering/ 里面包含：\nGo Java React Kubernetes Docker MySQL Kafka ES DDD AI Code Review DevOps ... 最后变成几万字。\n这种设计的问题是：\n边界不清 触发不准 上下文巨大 维护困难 版本难管理 更好的方式是：\ngo-backend-development/ java-backend-development/ react-development/ kubernetes-deployment/ database-migration/ code-review/ architecture-design/ technical-writing/ 一个 Skill：\n只解决一种相对稳定的任务类型。\n14. Skill 的组织模型 在真实研发组织中，Skill 不适合简单划分成“四层”，更准确的方式是从 任务类型、专业领域和配套资源 三个方面组织。\n1. Workflow Skill：一类事情怎么做 描述完整工作流程，例如：\ncode-review database-migration release-service incident-response technical-writing 核心是：\nInput → Process → Output → Validation 2. Domain Skill：某个领域怎么做 描述专业领域的规则和最佳实践，例如：\ngo-development kubernetes mysql react ddd Workflow 和 Domain 可以组合：\ncode-review + go-development ↓ Go Code Review 3. References / Tools：Skill 的配套能力 它们不是独立的“层”，而是 Skill 的支撑资源：\nSkill ├── SKILL.md # 流程、规则、决策 ├── references/ # 专业知识、规范、文档 ├── scripts/ # 确定性的脚本执行 ├── examples/ # 示例 └── tests/ # 验证 Skill 是否有效 可以简单理解为：\nWorkflow 定义怎么做，Domain 定义应该遵循什么，References 提供知识，Tools 负责执行，Tests 负责验证。\n因此，Skill 更适合被理解为一个可复用的 AI 能力单元，而不是严格的“四层架构”。\n15. 一个生产级 Skill 示例 下面给出一个比较完整的 Go Code Review Skill。\ngo-code-review/ ├── SKILL.md ├── references/ │ ├── concurrency.md │ ├── performance.md │ └── security.md ├── scripts/ │ ├── test.sh │ └── staticcheck.sh └── examples/ └── review-example.md SKILL.md：\n--- name: go-code-review description: Reviews Go code for correctness, concurrency safety, performance, security, maintainability, and project conventions. Use when reviewing Go source files, commits, pull requests, or architecture changes. --- # Go Code Review ## TRIGGERS Activate when: - Reviewing Go source code - Reviewing Go pull requests - Reviewing Go commits - Reviewing concurrency-sensitive changes ## CORE RULE - NON-NEGOTIABLE Correctness MUST be verified before optimization. ## STANDARD PROCESS 1. Read the changed code and surrounding abstractions. 2. Identify the intended behavior. 3. Check correctness and error handling. 4. Check concurrency safety. 5. Check performance and resource usage. 6. Check security-sensitive behavior. 7. Check maintainability and project conventions. 8. Run available automated checks. 9. Rank findings by severity. ### Concurrency Read `references/concurrency.md` when the change contains: - goroutines - channels - mutexes - atomics - worker pools - context cancellation ### Verification Run: ./scripts/test.sh ./scripts/staticcheck.sh Do not claim verification if the commands were not executed. ## OUTPUT Each finding MUST contain: - Severity - Location - Problem - Why it matters - Recommended fix Prioritize: - Critical - High - Medium - Low ## SELF-CHECK LIST [ ] Intended behavior is understood [ ] Correctness is checked [ ] Concurrency is checked [ ] Performance is checked [ ] Security is checked [ ] Automated checks are executed when available [ ] Findings are prioritized [ ] No unsupported claims are made ## ANTI-PATTERNS - Reviewing only the changed lines without surrounding context - Optimizing before correctness analysis - Reporting stylistic preferences as bugs - Claiming tests passed without running them - Rewriting unrelated code 这个版本有几个关键特点：\n触发条件明确 + 核心原则明确 + 流程明确 + 按需加载参考资料 + 使用脚本进行确定性验证 + 输出结构固定 + 最终自检 这基本就是一个可以进入真实团队使用的 Skill。\n16. Skill 的测试，比 Skill 本身更重要 很多人写 Skill 的过程是：\n写 SKILL.md ↓ 感觉很好 ↓ 结束 这是不够的。\n真正工程化的方法应该是：\nSkill ↓ Test Cases ↓ Agent Execution ↓ Compare Result ↓ Modify Skill ↓ Regression Test 例如：\ntests/ ├── should-detect-concurrency.md ├── should-run-tests.md ├── should-not-overreview-style.md └── should-prioritize-critical.md 测试：\n输入： 这个 Go worker pool 有 data race。 期望： 必须识别并发问题 必须将其判定为高优先级问题 不能只提出代码风格建议 然后不断加入真实失败案例。\n这就是：\nSkill Regression Testing\nAnthropic 官方同样强调 Skill 应该通过真实使用进行测试，而且不同模型可能需要不同程度的指导，因此实际使用哪些模型，就应该用哪些模型进行验证。\n17. Skill 应该像代码一样管理 成熟团队不应该把 Skill 当成：\n某个人电脑里的一个 Markdown\n而应该放入 Git。\n例如：\nai-skills/ ├── skills/ │ ├── go-code-review/ │ ├── database-migration/ │ ├── kubernetes-deployment/ │ └── technical-writing/ ├── shared/ ├── tests/ └── README.md 每次变更：\nPR ↓ Review ↓ Regression Tests ↓ Merge ↓ Release 例如：\ngo-code-review v1.3.0 这样 Skill 才真正具备：\n版本 历史 Review 回滚 复用 Anthropic 的 Skills API 本身也已经将 Skill 与版本管理结合起来，API 提供 Skill 的创建、查询、删除以及 Skill Version 管理能力。\n18. 跨平台兼容：不要过度绑定某一个 Agent 现在比较值得关注的一点是：\nAgent Skills 正在形成一种跨 Agent 的目录与文件约定。\nCursor 官方已经直接将 Agent Skills 描述为开放标准，并兼容 .claude/skills/、.codex/skills/ 等目录。\n因此推荐项目采用：\n.agents/ └── skills/ 作为通用目录，同时根据具体 Agent 做兼容：\n.claude/skills/ .codex/skills/ .cursor/skills/ .agents/skills/ 一个核心 Skill 尽量保持：\n纯 Markdown + Shell/Python/Go 脚本 + 参考文件 避免：\n强绑定某个 Agent 的特殊语法 这样可以最大化复用。\n19. Skill 安全问题不能忽视 Skill 本质上是：\nAgent 可执行的指令。\n因此它实际上属于 Agent 的信任边界。\n尤其当 Skill 能访问：\nfilesystem shell web database cloud production 风险会明显增加。\nAnthropic 官方明确提醒，Skills 应当像安装软件一样被信任；恶意或被篡改的 Skill 可能通过工具调用造成数据泄露或其他危险操作。对于来自 GitHub 的 Repository Skills，也必须信任相应代码仓库，因为提交者可能修改 Skill 的行为。\n所以生产环境至少应该做到：\nSkill Source ↓ Code Review ↓ Security Review ↓ Version Pinning ↓ Least Privilege ↓ Runtime Sandbox 尤其不要默认给所有 Skill：\n生产数据库 + 云账号 + 全部文件系统 + Shell root 权限。\n20. Skill 与 MCP 的最佳组合 未来真正强大的 Agent，应该是：\nAgent │ ┌─────┴─────┐ │ │ Skill MCP │ │ Workflow Tools │ │ └─────┬─────┘ ↓ Business Result 例如：\nproduction-incident-response Skill：\n1. 收集故障信息 2. 判断影响范围 3. 查询指标 4. 查询日志 5. 检查最近部署 6. 建立假设 7. 验证假设 8. 输出修复方案 9. 判断是否回滚 10. 输出事故报告 MCP：\nPrometheus Grafana Kubernetes Loki GitHub Jira 最终 Agent 就不只是：\n“回答问题”\n而是：\n按照企业规定的流程，使用企业工具完成工作。\n这也是 Skill 真正的价值所在。\n21. Superpowers 规范应该如何落地？ 你给出的 Superpowers 规范：\nTRIGGERS CORE RULE STANDARD PROCESS SELF-CHECK LIST COMMON EXCUSES ANTI-PATTERNS PLATFORM NOTES SEE ALSO 我认为非常适合作为一套：\n企业 Skill Authoring Convention\n但可以进一步演进成下面这个标准。\n# Skill Name ## TRIGGERS 明确什么时候触发。 ## CORE RULE 最重要的不可违背规则。 ## STANDARD PROCESS 标准工作流。 ## DECISION RULES 描述什么情况下选择什么策略。 ## RESOURCES 说明什么时候读取哪些 references。 ## TOOLS 说明什么时候调用哪些 scripts / tools。 ## OUTPUT 规定最终输出结构。 ## SELF-CHECK LIST 完成前验证。 ## COMMON EXCUSES 防止 Agent 绕过关键流程。 ## ANTI-PATTERNS 禁止行为。 ## PLATFORM NOTES 平台兼容说明。 ## SEE ALSO 关联 Skill。 这里增加了两个非常重要的部分：\nDECISION RULES RESOURCES 它们可以明显提高 Skill 的工程化程度。\n22. 一个非常重要的原则：Skill ≠ 越详细越好 最终可以总结为：\nBad Skill ↓ Everything is written ↓ Huge Context ↓ Low Signal ↓ Poor Execution 而好的 Skill：\nSkill Metadata ↓ Fast Discovery ↓ Minimal Core Instructions ↓ Progressive Loading ↓ Deterministic Tools ↓ Verification ↓ Stable Output 所以真正好的 Skill 应该满足：\n短、准、可执行、可验证。\n这和传统文档完全不同。\n23. 我推荐的一套企业级 Skill 标准 如果团队准备真正建立自己的 AI Engineering Skill Repository，可以直接采用下面这套规范。\nskills/ ├── engineering/ │ ├── go-development/ │ ├── java-development/ │ ├── react-development/ │ └── architecture-design/ │ ├── quality/ │ ├── code-review/ │ ├── security-review/ │ └── performance-review/ │ ├── devops/ │ ├── kubernetes-deployment/ │ ├── database-migration/ │ └── incident-response/ │ ├── documentation/ │ ├── technical-writing/ │ ├── api-documentation/ │ └── architecture-documentation/ │ └── ai/ ├── rag-development/ ├── agent-development/ └── mcp-development/ 每个 Skill：\nSKILL.md scripts/ references/ examples/ tests/ 整个仓库：\nGit ↓ PR ↓ Skill Review ↓ Automated Tests ↓ Version ↓ Distribution 这样 Skill 才从：\nPrompt 技巧 真正升级为：\nAI Engineering Infrastructure 24. 最终结论 Skill 最值得理解的，并不是：\n“又多了一个 Markdown 文件” 而是：\nSkill 正在成为 Agent 的“专业工作流层”。\n传统软件：\n代码 ↓ 函数 ↓ 模块 ↓ 服务 Agent Software：\nModel ↓ Tool ↓ Skill ↓ Workflow ↓ Business Result 未来真正有价值的企业 AI 能力，很可能不是简单地给员工一个“大模型”，而是把企业中大量隐性的专家经验沉淀成：\nSkills 例如：\n一个优秀架构师怎么设计系统 一个优秀 DBA 怎么执行迁移 一个优秀 SRE 怎么处理事故 一个优秀工程师怎么做 Code Review 一个优秀产品经理怎么分析需求 一个优秀技术作者怎么写文章 这些经验过去存在于：\n人的脑子 + Wiki + 代码规范 + 口头经验 而 Skill 的目标，是把它们转换成：\n机器可以发现 + 机器可以执行 + 机器可以验证 + 机器可以版本化 + 团队可以共享 这才是 Skill 真正的工程价值。\n一句话总结 Prompt 是“告诉 AI 做什么”，Rule 是“限制 AI 不能做什么”，Tool/MCP 是“给 AI 什么能力”，而 Skill 是“告诉 AI 面对一类任务，应该按照什么专业流程把事情做对”。\n从这个角度看，SKILL.md 并不是 Prompt 的升级版，而是 Agent Workflow 的声明式工程载体。\n参考资料 Anthropic Agent Skills Overview：Skill 的定义、目录结构、发现机制和生命周期。 Anthropic Skill Authoring Best Practices：上下文成本、Skill 简洁性、自由度、命名、描述和模型测试。 Anthropic Skills API：Skill 与版本管理能力。 Anthropic 官方 Skills Repository：生产级 Skill 的目录与实现参考。 OpenAI Academy — Using Skills：Skill、SKILL.md、工作流与复用理念。 Cursor Agent Skills：开放标准、目录结构、渐进式加载和跨 Agent 兼容。 ","permalink":"/blogs/2026/ai/llm/engineering-agent-skill-skill.md-to-reusable-ai-workflows.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cblockquote\u003e\n\u003cp\u003eSkill 不只是一个 Prompt 文件，而是一套可以被 Agent 自动发现、按需加载、重复执行、持续验证和版本化管理的“工作流能力”。\u003c/p\u003e\n\u003c/blockquote\u003e\n\u003cp\u003e随着 Cursor、Claude Code、Codex、ChatGPT 等 AI 编程和 Agent 工具不断成熟，一个非常明显的趋势正在出现：\u003c/p\u003e","title":"Agent Skill 工程化实践：从 SKILL.md 到可复用的 AI 工作流"},{"content":"一、对账系统：交易体系的资金安全基石 在支付、电商等交易类业务中，对账系统是保障资金安全、校验业务一致性的核心环节。当交易规模从百万级增长到千万、亿级时，基于数据库直连 + SQL 关联的传统对账方案会迅速遇到性能瓶颈与准确性问题：\n直接查询生产库执行对账任务，会占用大量数据库资源，拖慢线上交易响应速度，严重时会引发数据库雪崩\n单表 SQL 关联在大数据量下复杂度高，任务执行时长指数级上升，甚至无法在约定的日终窗口内完成\n不同渠道的日切时间存在差异，叠加网络延迟、系统处理耗时，会导致跨日交易出现大量 “伪差异”，大幅增加人工排查成本\n对账差异缺乏标准化处理流程，长短款处理混乱，容易引发资金风险与用户投诉\n本文从工程落地视角，分享一套可支撑亿级交易量的对账系统架构方案，覆盖数据采集、比对引擎、跨日容错、差错闭环四大核心环节，兼顾性能、准确性与可运维性。\n二、整体设计理念 对账系统的核心目标是保证交易资金与业务记录的一致性，设计的核心矛盾在于：既要保证对账准确率，不漏掉任何一笔异常；又要控制任务耗时与运维成本，避免大量伪异常消耗人力。\n整套方案以日终全量批量对账为基础主体，保障全量交易的一致性校验；同时通过边界场景缓冲容错机制处理跨日、延迟等特殊场景，在准确率与效率之间取得平衡。系统自上而下分为四层核心能力：数据采集层、并行比对引擎、跨日异常容错、差错闭环处理。\n三、数据采集层：离线隔离 + 口径标准化 3.1 核心痛点 传统对账方案常直接对接生产业务库执行查询，这是典型的反模式。一方面大数据量的批量查询会拖垮数据库性能，影响线上交易；另一方面不同渠道的金额统计口径不一致（如优惠券、补贴、手续费的计算规则差异），会从源头产生大量无效差异。\n3.2 设计方案 数据源物理隔离，离线计算\n渠道侧账单：采用流式读取方式处理渠道对账文件或接口数据，避免全量加载导致的内存溢出，支持大文件逐行处理\n业务侧数据：统一从离线数仓（如 Hive）拉取日终快照数据，全程不访问生产事务库，对线上业务零侵入、零影响\n统一统计口径，数据预处理 在正式对账前，对两边数据做标准化清洗，统一以用户实付金额为对账基准，剔除优惠券抵扣、积分抵现、平台补贴、渠道手续费等口径差异项，从源头减少无效对账差异。\n四、比对引擎：基于分片归并的高性能流式比对 4.1 核心痛点 基于 SQL JOIN 的传统对账方式，时间复杂度高，在数据量突破千万级后，执行耗时会急剧增长，同时内存占用高，很容易出现任务超时、内存溢出等问题，无法支撑大规模交易场景。\n4.2 核心算法：哈希分片 + 排序归并 我们采用分治思想，通过「哈希分片 - 分片内排序 - 双指针归并比对」三步实现高性能对账，整体时间复杂度为 O (N log N)，且运行时内存仅需保留当前行数据，可平滑支撑千万至亿级的交易体量。\n第一步：哈希分片拆分数据集 将渠道与业务侧的交易数据，均按照交易订单 ID 进行哈希取模，拆分为多个独立的小文件（例如拆分为 10 个分片）。 由于同一笔订单的 ID 哈希值固定，因此它在渠道侧和业务侧必然会落入同一个分片中，保证了对账的正确性，同时将大任务拆分为多个可并行处理的子任务。\n第二步：分片内有序化 对每个分片内的交易数据，按照订单 ID 进行升序排序，得到两个有序的数据集。 排序的复杂度为 O (N log N)，但相较于 SQL 关联的 O (N²) 复杂度，性能有数量级的提升。\n第三步：双指针流式归并比对 借鉴归并排序中合并有序数组的思路，使用两个指针分别遍历两个有序分片，逐行完成比对。整个过程采用流式读取，内存中仅保留当前正在比对的两条记录，内存占用极低。\n核心逻辑示例：\n// 双指针对账核心逻辑 while (bizRecord != null \u0026amp;\u0026amp; channelRecord != null) { if (bizRecord.getOrderId().equals(channelRecord.getOrderId())) { // 订单匹配，校验金额一致性 if (bizRecord.getAmount().compareTo(channelRecord.getAmount()) != 0) { saveDifference(\u0026#34;金额不一致\u0026#34;, bizRecord, channelRecord); } // 双指针同时后移 bizRecord = nextBizRecord(); channelRecord = nextChannelRecord(); } else if (bizRecord.getOrderId().compareTo(channelRecord.getOrderId()) \u0026lt; 0) { // 业务侧有记录、渠道侧无记录 → 短款异常 saveDifference(\u0026#34;业务单边账\u0026#34;, bizRecord, null); bizRecord = nextBizRecord(); } else { // 渠道侧有记录、业务侧无记录 → 长款异常/跨日延迟 handleLongAccountOrDelay(null, channelRecord); channelRecord = nextChannelRecord(); } } 4.3 方案优势 高性能：整体 O (N log N) 的时间复杂度，配合分片并行处理，亿级数据可在日终窗口内完成\n低内存：流式读取 + 双指针遍历，运行时内存仅占用单条记录大小，不会出现内存溢出\n易扩展：分片数量可根据数据量灵活调整，支持分布式多节点并行执行，横向扩展能力强\n五、跨日容错：解决日切差异的两层机制 5.1 经典问题场景 这是对账系统中最常见的边界问题：第三方支付渠道通常以自然日 00:00 作为日切点，而用户在临近日切时（如 23:59:59）完成的支付，可能因为网络传输、系统处理延迟，在业务侧的落库时间为次日 00:00:01。 如果仅按自然日拉取数据对账，这笔交易会在两边分属不同日期，导致对账出现伪差异。\n5.2 两层容错机制 我们通过「扩展时间窗口 + 边界缓冲队列」的两层方案，覆盖绝大多数跨日延迟场景，同时避免误报。\n第一层：扩展时间窗口拉取（覆盖绝大多数场景） 拉取对账数据时，不严格限制在当日 00:00~23:59，而是将时间窗口向前后各延伸一段时间（通常 5 分钟）。 例如核对 2 月 1 日的账单时，实际拉取 1 月 31 日 23:55 至 2 月 2 日 00:05 时间范围内的所有交易。 通过窗口扩容，绝大多数跨日延迟交易都会被包含在对账数据中，在比对阶段即可正常匹配，从源头杜绝了大量伪差异。\n第二层：边界交易缓冲队列（极端场景兜底） 对于超出扩展窗口的极端情况，通过边界缓冲机制做差异化处理，避免直接报警：\n交易发生时段 风险判定 处理策略 日切前后短时间内（如 23:55~00:05） 大概率为跨日网络 / 系统延迟 移入缓冲队列，次日对账时优先进行匹配校验 非日切时段（如日间交易时段） 大概率为真实掉单或系统异常 直接触发告警，启动人工排查流程 这种分级处理的思路，既不会因为过度敏感产生大量无效告警，增加运维负担；也不会放过真实的交易异常，兼顾了对账的准确性与运维效率。\n六、差错闭环：长短款的标准化处理流程 对账的最终目的不是发现差异，而是解决差异。针对对账出的两类核心异常，我们设计了标准化的自动 + 人工处理闭环，保障资金安全与用户体验。\n6.1 长款异常（渠道有、业务无） 即用户支付成功，但业务系统未生成对应订单或未标记到账。\n优先自动补单：校验对应商品 / 服务的可用性，若库存或服务能力充足，自动触发补单流程，完成业务侧的订单落地与发货\n人工退款兜底：若库存不足或不支持补单，则触发人工审核退款流程，将资金原路退回用户，避免资金沉淀与用户投诉\n6.2 短款异常（业务有、渠道无） 即业务系统显示订单已支付，但渠道侧无对应收款记录，属于高风险资金异常。\n直接触发告警，强制进入人工核查流程\n不设置自动处理逻辑，防止出现支付漏洞、恶意刷单等风险扩大\n七、方案总结 这套对账系统架构，从工程实践出发，解决了大规模交易场景下的四大核心问题：\n业务零影响：基于离线数仓进行计算，全程不触碰生产事务库，对线上交易无任何影响\n高性能支撑：分片归并比对算法，支撑亿级交易体量的日终对账，任务耗时可控\n高准确率：扩展窗口 + 缓冲队列的跨日容错机制，大幅降低伪差异比例，提升对账准确率\n流程闭环：长短款标准化处理流程，实现从差异发现到问题解决的完整闭环\n整体方案兼顾了技术性能与业务价值，既可以作为系统设计的参考，也可以根据实际业务体量灵活裁剪落地。\n","permalink":"/blogs/2026/performance/design-and-practice-of-billionscale-transaction-reconciliation-system.html","summary":"\u003ch2 id=\"一对账系统交易体系的资金安全基石\"\u003e一、对账系统：交易体系的资金安全基石\u003c/h2\u003e\n\u003cp\u003e在支付、电商等交易类业务中，对账系统是保障资金安全、校验业务一致性的核心环节。当交易规模从百万级增长到千万、亿级时，基于数据库直连 + SQL 关联的传统对账方案会迅速遇到性能瓶颈与准确性问题：\u003c/p\u003e","title":"亿级交易对账系统架构设计与实践"},{"content":"前言 Ease-Ops 是新一代轻量化 DevOps CICD 持续交付平台，依托 DAG 拓扑并行调度、结构化日志管控、AI 智能故障诊断三大核心能力，解决传统 CI/CD 工具发布低效、排错繁琐、运维复杂、扩展困难等行业痛点。平台支持零代码拖拽编排流水线、多组件并行交付、全流程可追溯、AI秒级排错，大幅降低研发运维成本，适配中小企业各类前后端分离、混合部署架构项目，可轻量化替代传统 Jenkins 工具。\n本手册面向平台日常使用人员，通俗易懂讲解核心功能、操作流程、配置规范及优势特性，适配日常项目管理、环境配置、任务搭建、流水线编排、MCP智能接口、权限管控、节点运维等全场景操作。\n一、项目管理 在Ease Ops平台中，项目是研发交付全生命周期的核心管控容器，用于统一归集和隔离代码仓库、组件、主机、凭证、流水线、环境配置等所有研发资源，实现单项目全流程独立管控、权限隔离与链路追溯。\n1.1 项目创建 1.1.1 新建项目 在平台右上角项目下拉菜单中选择「新建项目」，跟随智能化引导流程完成创建，核心填写信息如下：\n项目名称：自定义项目展示名称，便于日常识别管理；\n项目编码：平台唯一标识，作为后续资源路径隔离、变量识别、组件绑定的核心依据，创建后不可修改。\n项目创建后自动初始化基础环境与默认流水线，无需手动从零搭建，快速落地DevOps流程。\n编辑项目\n1.1.2 项目核心资源说明 所有项目资源统一归属当前项目，相互独立，核心包含五大类资源：\n凭证：统一管理仓库拉取、服务器登录的鉴权信息； 代码仓库：关联项目Git代码源，支撑代码检出、构建、持续集成流程； 组件：最小独立部署单元，涵盖前端Web、后端API、分布式Runner代理等可独立发布的业务实体，支持按业务模块拆分管理； 主机：归集项目所有部署服务器信息，按环境分类隔离； 流水线：承载项目构建、测试、部署全流程工作流。 1.2 凭证管理 凭证用于统一托管代码仓库、远程主机的登录鉴权信息，支持多资源共享复用，避免明文泄露、重复配置，保障资源访问安全。\n1.2.1 新建凭证 进入「资源管理」-\u0026gt;「凭证管理」界面，点击「新建凭证」；\n凭证信息\n自定义凭证名称，便于快速识别用途；\n选择凭证类型，支持用户名密码、SSH秘钥两种主流类型；\n按类型填写对应信息：密码类型填写账号密码，秘钥类型上传秘钥文件；\n可选填写备注，标注适用仓库、主机或环境，完成创建。\n1.2.2 凭证使用规则 支持多仓库、多主机共享同一凭证，统一维护、修改一次全局生效；\n创建/编辑代码仓库、主机资源时，直接选择已有凭证关联，无需重复录入鉴权信息；\n凭证仅当前项目可见，实现跨项目权限隔离。\n1.3 代码仓库管理 用于绑定项目Git代码源，支撑流水线代码检出、自动触发构建等核心能力，兼容各类标准Git仓库地址格式。\n1.3.1 新增仓库 进入项目「代码仓库」模块，点击右侧「新增」；\n新增界面 填写完整Git仓库地址、默认构建分支；\n私有仓库必须关联已有凭证或新建凭证，保障代码拉取权限；\n确认保存，完成仓库绑定。\n1.3.2 仓库日常管理 流水线详情可以查看仓库提交记录、分支列表、代码变更日志；\n支持编辑仓库配置、更新关联凭证、删除无效仓库；\n可配置Webhook钩子，实现代码提交自动触发流水线构建。\n1.4 主机管理 统一管理项目所有部署服务器资源，按环境分类隔离，为流水线部署节点提供目标机器支撑。\n1.4.1 新建主机 进入项目「主机管理」界面，点击「新建主机」；\n新增界面 填写主机名称、IP地址、SSH登录端口；\n关联所属环境（开发、测试、生产等），实现环境资源隔离；\n选择已有SSH登录凭证或新建凭证，完成主机绑定。\n1.4.2 主机日常管理 可视化查看主机硬件配置、在线状态、心跳信息、部署记录；\n支持主机信息编辑、状态刷新、无效主机删除；\n部署任务仅可调用当前环境绑定的主机，杜绝跨环境误部署。\n1.5 组件管理 组件是平台可独立部署、独立迭代的最小业务单元，是流水线任务编排、构建部署的核心绑定对象。 1.5.1 组件定义规范 按业务架构拆分，支持前端Web、后端API、分布式Runner、数据服务等各类组件定义； 大仓库模式下，同一代码仓库内的多业务模块，需按独立部署规则拆分多个组件，适配单独构建、部署需求。 1.5.2 新建组件 进入项目详情，点击组件框旁边的“新增组件”，弹出新增引导，功能和创建项目的引导类似，参考「快速入门」\n1.5.3 组件日常管理 查看组件关联的代码仓库、构建配置、环境变量、部署历史、版本记录；\n支持组件配置编辑、手动触发构建、指定环境部署、版本回滚等操作；\n所有流水线任务均围绕组件配置，实现单组件独立管控、多组件自由编排。\n二、环境管理 Ease Ops 环境配置模块依托树形继承架构、模板变量拆分、全链路追溯核心能力，解决传统研发多环境配置重复、易错、难追溯、不一致的行业痛点，实现多环境配置高效复用、差异化适配、风险可控，是流水线构建、部署的核心环境依托。\n2.1 核心特性与架构优势 2.1.1 树形继承，配置高效复用 平台采用「根节点通用模板+子环境差异化变量」的树形架构，彻底摒弃全环境重复配置模式：\n缺省环境（根节点）统一维护全环境通用配置、公共默认变量；\n测试、生产、自定义子环境自动继承父级所有配置与资源；\n差异化参数（数据库地址、账号、端口、密钥等）通过变量单独配置，无需重写完整配置文件，大幅降低维护成本与人工失误率。\n2.1.2 快速拓容，适配多样研发场景 支持一键新建多级子环境，自动完整继承父环境所有配置、变量、主机、Runner资源，仅需微调少量差异化参数，即可快速搭建调试、测试、预发等专属环境，适配功能迭代、问题复现、版本验证等全场景需求。\n2.1.3 全程追溯，变更风险可控 系统每次构建、配置更新自动生成配置快照，支持新旧配置差异对比、变更记录溯源，精准定位配置修改节点与内容，有效规避漏改、错改、配置不一致等问题，大幅降低线上变更故障风险。\n2.2 默认基础环境架构 项目创建后，平台自动初始化三套隔离式基础环境，树形层级固定，资源相互独立，用户可按需新增多级自定义子环境：\n缺省环境（根节点·全局通用） └── 测试环境（研发调试） └── 生产环境（正式上线） 所有子环境默认继承父级全部配置、变量、主机、Runner资源；\n各环境流水线、部署资源、配置数据完全隔离，互不干扰。\n2.3 配置文件管理规范 2.3.1 新增配置规则 为保障全局配置统一规范，仅支持在缺省环境新增配置文件，填写配置文件相对路径及文件内容即可，相对路径用于配置分组，支持部署时单文件、目录批量拷贝。\n默认子环境继承\n2.3.2 变量引用规范 通用配置文件固定模板化，差异化参数通过 “大括号+ 变量名”引用变量，系统自动识别提取变量并支持统一设置默认值。\n标准配置示例（相对路径：config/app.yaml）：\nserver: http: addr: {{http_addr}} timeout: 300s data: database: driver: mysql source: {{mysql_username}}:{{mysql_password}}@tcp({{mysql_host}}:3306)/ease_ops?parseTime=True\u0026amp;loc=Local 变量会自动被提前：\n2.3.3 继承与覆盖规则 子环境默认完整继承缺省环境的所有配置文件与变量；\n支持子环境按需修改变量值、重写配置文件，实现个性化覆盖适配；\n核心规则：变量依托配置存在，若子环境重写配置并移除变量引用，当前及下级子环境将不再继承该变量。\n2.3.4 配置状态标识 平台自动标注配置/变量来源，快速区分配置状态，便于运维核查：\n继承「xx环境」：当前配置无自定义修改，完全继承自父级环境；\n覆盖「xx环境」：当前配置已自定义修改，覆盖父级原有内容；\n本地定义：当前配置/变量由本环境独立创建，无上级继承关系。\n2.3.5 部署引用方式 部署脚本通过 “大括号 + conf:配置路径” 精准引用配置，系统自动适配当前生效环境生成最终配置，支持修改后差异预览，规避误操作。两种常用引用方式：\n单文件精准拷贝：\nrsync -avc {{conf/config/app.yaml}} /usr/local/my_app/conf/app.yaml 目录批量同步：\nrsync -avc {{conf:config}}/ /usr/local/my_app/conf/ 2.4 环境变量与资源绑定管理 2.4.1 环境变量分类 环境变量支持继承、覆盖，全局统一引用格式：var:环境类型.变量名，分为两类：\next 自定义变量：用户按需在对应环境手动维护，适配项目个性化配置；\nsys 系统内置变量：平台原生自带（组件编码、版本号等），无需手动配置，可直接全局引用。\n2.4.2 主机资源绑定 各环境可独立绑定专属主机资源，流水线部署仅可调用当前环境绑定主机，实现跨环境资源隔离；子环境未绑定主机时，自动继承父级环境主机资源。\n2.4.3 Runner资源绑定 Runner节点区分构建、部署双场景独立绑定，适配环境继承规则，资源调度优先级：环境专属Runner \u0026gt; 平台公共Runner，保障任务执行稳定、资源高效利用。\n2.5 环境管理价值与规范 2.5.1 核心落地收益 提效降错：一套通用模板多环境复用，减少80%重复配置，规避人工配置失误；\n提速迭代：快速搭建个性化子环境，大幅缩短环境部署、调试周期；\n风险可控：配置变更全程可追溯、可对比，精准管控线上变更风险。\n2.5.2 基础环境定位规范 缺省环境：全局根节点，统一维护全项目通用配置、默认变量、公共资源模板；\n测试环境：用于日常研发调试、问题复现、版本迭代验证，支持个性化配置修改；\n生产环境：线上正式业务环境，配置、资源严格管控，仅允许合规变更，保障业务高可用。\n2.5.3 标准化配置流程 模板搭建：在缺省环境创建通用配置文件模板，固定通用内容，差异化参数用变量占位；\n变量配置：为所有自定义变量设置默认值，保障基础流程可正常运行；\n环境适配：子环境按需覆盖变量值、绑定专属主机/Runner资源，完成环境差异化适配；\n变更校验：配置修改后预览差异，构建自动生成快照，留存变更记录。\n三、任务管理配置（流水线基础单元） 所有流水线节点均依赖前置任务配置，任务统一在「任务管理」模块创建维护，默认关联「缺省环境」，仅部署任务支持单独指定所属环境。核心包含代码检出、单元测试、构建、部署四大类任务。\n3.1 代码检出任务 用于拉取代码仓库源码，是所有流程的起始节点，支持单组件、多组件批量检出（大仓库模式适配）。\n配置规范 任务名称：单个组件仅1个检出任务时，使用默认名称即可，无需额外添加组件名，流水线界面自动展示对应组件信息。\n关联组件：绑定当前检出任务对应的业务组件，支持一对一、一对多（大仓库）绑定。\n检出分支：填写需拉取的代码分支（如main、dev、test）。\n检出目录：默认跟随Git克隆目录，支持自定义子目录路径。\n3.2 单元测试任务 用于代码质量校验，拦截不合格代码，从源头降低线上故障率，支持自定义脚本模式，Java/Go/Python/Node.js 等主流开发语言均可适配，内置主流语言的最佳示例\n配置规范 任务名称：单个组件仅1个单测任务时，使用默认名称，流水线自动关联展示组件信息。\n关联组件：绑定需进行单元测试的业务组件。\n执行环境：选择对应组件适配的Go版本环境。\n执行环境：选择和项目语言、运行版本匹配的单测环境。\n工作目录：填写组件代码根目录（示例：ease-ops-api）。\n执行脚本 支持自定义测试执行命令，可根据项目技术栈编写测试脚本；脚本内支持内置变量占位符：junitReportPath、coverageReportPath，变量与下方填写的文件路径一一对应。Go 项目参考模板：\ngotestsum \\ --no-color \\ --junitfile {{junitReportPath}} \\ --junitfile-testsuite-name=relative \\ --junitfile-testcase-classname=relative \\ --rerun-fails=2 \\ --packages ./... -- \\ -race \\ -timeout=300s \\ -coverprofile=coverage.out gocover-cobertura \u0026lt; coverage.out \u0026gt; {{coverageReportPath}} JUnit XML：填写测试结果报告文件路径（示例：report.xml），平台将按该路径采集报告数据，用于页面展示单元测试用例执行情况。 覆盖率 左侧下拉选择覆盖率报告格式，平台支持多种标准覆盖率格式（Cobertura XML / Jacoco XML 等）； 右侧输入框填写覆盖率报表文件路径（示例：cobertura.xml），平台按该路径采集覆盖率数据，用于页面可视化展示代码覆盖率。 核心价值：单测失败自动阻断后续构建部署流程；依托自定义脚本实现全主流语言兼容，统一产出标准测试报告与覆盖率文件；平台根据配置路径自动采集报表数据并可视化展示，配合 AI 智能诊断，秒级定位用例失败、报表缺失、路径配置异常等问题。\n3.3 静态检查 用于代码安全与代码规范校验，拦截漏洞、不规范代码，从研发源头规避线上安全风险与代码缺陷，基于 Semgrep 实现标准化扫描，支持自定义规则扩展，Java/Go/Python/Node.js/ 前端等主流开发语言均可适配，内置官方 CI 安全规则集覆盖 OWASP、代码规范、高危漏洞检测场景。\n配置规范 任务名称*：自定义静态扫描节点展示名称，建议统一命名为「静态扫描」，流水线可视化页面统一识别展示。 组件*：固定选择「执行器 runner」，依托容器执行 Semgrep 扫描任务。 镜像*：固定镜像地址 docker.io/returntocorp/semgrep:latest，提供完整 Semgrep 运行环境，无需自行搭建依赖。 自定义规则：可选配置，在对应环境和组件下增加相对路径前缀为semgrep/rules/ 配置，自定义扫描规则， （示例：semgrep/rules/my_rule），目录下 YAML 规则文件会叠加官方规则同步扫描；无私有规则时留空仅使用官方规则集。 质量门槛 - 错误*：严重缺陷阻断阈值，扫描检出的错误类问题最大允许数量，超出阈值流水线直接阻断。 质量门槛 - 警告*：风险警告阻断阈值，扫描检出的警告类问题最大允许数量，超出阈值流水线直接阻断。 质量门槛 - 提示*：代码优化提示阻断阈值，扫描检出的规范提示类问题最大允许数量，超出阈值流水线直接阻断。 核心价值：扫描缺陷超标自动阻断后续构建部署流程；支持官方规则 + 团队自定义规则叠加扫描，适配全主流开发语言；统一产出 SARIF、JSON 双标准报告，平台自动采集扫描结果可视化展示缺陷清单；通过可配置化质量门槛灵活管控代码准入标准，提前拦截安全漏洞、代码不规范问题，降低线上故障与安全事件概率。\n3.4 构建任务 用于代码编译、打包生成可部署工件，支持常规构建、Docker镜像构建两种模式，支持工件本地归档、阿里云云效仓库远程上传，适配各类部署场景。\n通用配置规范 任务名称：单个组件仅1个构建任务时，使用默认名称即可。\n关联组件：绑定需构建的业务组件。\n3.4.1 常规构建（二进制/安装包构建） 适用于传统代码编译打包，生成二进制文件、压缩包等部署工件，核心配置如下：\n运行环境：下拉选择适配项目的构建镜像环境。\n工作目录：默认使用代码检出根目录，支持自定义子目录。\n构建脚本：填写编译打包命令（如mvn clean package、go build），编辑器内置智能变量补全功能： 变量自动胶囊高亮，无效变量实时提示，支持快捷键快速唤起变量面板、常用构建命令模板。 自定义变量：格式 var:ext.xx，读取缺省环境自定义环境变量；\n系统变量：格式 var:sys.xx，内置版本号、组件编码等系统通用变量；\n配置变量：格式 conf:xx，读取缺省环境配置文件/目录路径；\n工件提取：定义构建产物的提取规则，供后续部署使用：\n工件名：仅支持字母、数字、下划线、连字符、点，作为部署流程变量占位符；\n提取路径：默认检出目录，支持自定义子路径；\n匹配过滤：基于Glob语法匹配产物文件，支持正则排除、规则测试，可配置多路径、多工件提取。\n3.4.2 Docker构建 支持自定义Dockerfile，一站式完成代码编译、镜像制作，平台管控基础镜像来源，仅支持平台内置镜像列表。\n镜像推送仓库信息通过项目级别内置变量配置：\nALI_IMAGE_REGISTRY：镜像仓库地址\nALI_IMAGE_NS：镜像命名空间\nALI_IMAGE_USERNAME：仓库用户名\nALI_IMAGE_PASSWORD：仓库密码\n3.4.3 工件归档配置 默认工件归档至构建机本地目录，支持自动上传至阿里云云效制品仓库，只需在项目级别配置变量 ARTIFACT_ARCHIVE\n配置示例：\nmethod: aliyun aliyun: upload_api_root: https://packages.aliyun.com/api/protocol/6248ee889491f3d1689b80d7/generic/repo-ifvee/files username: xxx password: yyy 3.5 部署任务 用于将构建完成的工件、配置文件分发至目标服务器，完成服务启动、更新，支持SSH远程部署、全流程日志留痕。\n基础配置规范 任务名称：单个组件仅1个部署任务时，使用默认名称。\n关联组件：绑定待部署的业务组件。\n所属环境：默认缺省环境，流水线编排时可自定义调整。\n公共配置：服务启动、停止、状态检查命令统一配置在对应组件的环境变量中，与环境绑定，无需单个任务重复配置。\n部署脚本示例（标准通用模板） #!/bin/bash set -euo pipefail # 创建组件运行目录 mkdir -p /opt/{{var:sys.COMPONENT_CODE}}/bin/ # 赋予二进制文件执行权限 chmod +x {{artifact:devops-runner}}/{{var:sys.COMPONENT_CODE}} # 同步程序二进制文件 rsync -avc {{artifact:devops-runner}}/{{var:sys.COMPONENT_CODE}} /opt/{{var:sys.COMPONENT_CODE}}/bin/ # 同步业务配置文件 rsync -avc {{conf:conf}}/ /opt/{{var:sys.COMPONENT_CODE}}/conf/ # 注册系统服务 rsync -c {{conf:ease-ops-runner.service}} /etc/systemd/system/ 变量说明：\nvar:sys.COMPONENT_CODE：系统变量，自动读取当前组件编码；\nartifact:devops-runner：关联构建任务输出的工件包；\nconf:xxx：读取项目配置文件/目录，支持精准文件、目录批量同步。\n四、流水线 4.1 流水线核心概述 4.1.1 流水线定义 流水线是平台核心工作流，用于实现代码检出、单元测试、构建打包、自动化部署全流程持续集成与持续交付，支持多组件并行执行、流程自由编排、任务灵活组合，实现研发交付全自动化闭环。\n4.1.2 环境分类与流水线权限规则 平台以环境继承树的二级环境为核心分类，展示在流水线页面顶部导航，所有流水线均归属固定环境，不同环境流水线权限、数量规则独立：\n生产环境（特殊环境）：仅允许创建1条正式发布流水线，仅支持编辑操作，禁止新增、删除、替换流程，作为项目唯一正式上线通道，保障生产发布稳定性。\n测试环境/自定义环境：无流程数量限制，支持自由新增、编辑、删除多条流水线，适配多版本测试、多场景迭代需求。\n补充规则：部署任务为特殊流程节点，可在环境基础上，按主备环境、业务模块等架构维度二次分类，适配差异化部署场景。\n4.1.3 双维度管理模式（任务+流程） 平台采用任务定义 + 流程编排解耦式管理，灵活性远超传统流水线脚本模式，核心逻辑：\n任务层（基础单元）：在「任务管理」模块独立维护，提前配置好各组件的检出、单测、构建、部署规则，可复用、可单独修改，一次配置多次使用。\n流程层（组合编排）：创建流水线时，仅关联已配置的任务，自定义任务执行顺序、串行/并行规则，无需重复编写基础配置。\n核心优势：修改单一任务参数不影响整体流程，调整流程顺序无需改动任务配置，彻底规避传统脚本“一处修改、全流程报错”的问题。\n4.1.4 默认初始化规则 新建项目后，平台自动初始化测试环境、生产环境两大分类，且每个环境默认生成1条基础流水线，用户可直接使用，也可手动新增、自定义流水线，快速落地研发流程。\n4.2 流水线编排与配置 完成所有任务创建后，即可通过可视化拖拽编排搭建流水线，零代码实现多组件、多节点流程组合，支持并行/串行自定义。\n4.2.1 新增/编辑流水线 仅测试环境、自定义环境支持新增流水线，生产环境仅可编辑已有流程；\n选择所需组件及对应任务，默认规则：组件间检出、单测、构建全程并行执行，部署环节可自主选择串行/并行模式；\n确认后进入可视化编排界面，支持拖拽调整节点顺序、左右新增串行步骤、上下插入并行分支，像搭积木一样搭建流程。\n4.2.2 流水线核心配置项 流水线标题：鼠标悬浮标题可编辑，自定义流程名称，便于场景区分；\n所属环境：支持调整至当前大类下的子环境（如测试环境下的QA环境），精准归类流程；\n复用空间：开启后构建不清理本地代码，通过Pull拉取增量更新，大幅提升构建效率；生产环境禁止开启，避免目录污染导致发布异常；\n触发钩子（自动构建）：平台提供专属Webhook地址，配置至代码仓库即可实现代码提交自动触发构建，支持两种防抖策略：\n延迟合并：触发后重置倒计时，避免频繁提交重复构建；\n防抖延迟：默认300秒，窗口内多次提交合并为一次构建； Cron定时触发：支持配置定时执行规则，仅检测到代码变更时构建，无变更自动跳过，适配夜间迭代、定时更新场景，输入框内\nCron 表达式：填写标准的Cron表达式，内置常用Cron示例。 4.2.3 流程快速编辑能力 右侧面板展示当前流程所有组件、任务信息，支持批量新增缺失组件及对应任务； 点击任意节点可查看关联组件、任务详情，支持单点编辑、删除； 部署节点专属能力：支持绑定多套环境配置、指定机器/标签批量部署，适配集群、多环境差异化发布。\n4.3 流水线构建与详情查看 流水线支持手动构建、自动触发构建两种方式，全流程可视化、日志结构化、结果可追溯、故障可智能诊断。\n4.3.1 构建触发方式 手动构建：点击页面「构建」按钮，选择待构建组件、填写流程版本/组件版本；若开启工作空间复用，可自主选择是否清理缓存，确认后启动构建。\n自动构建：配置仓库Webhook且开启流程触发开关后，代码提交自动触发构建；触发前置闹钟图标闪动，悬浮可查看待触发组件及倒计时，全程可视化提示。\n4.3.2 构建详情与日志能力 构建发起后，可进入详情页查看全流程状态、执行进度、最终结果：\n核心能力如下：\n双视图展示：上方DAG流程图直观展示节点状态、耗时、用例覆盖率，下方结构化日志面板精准留存全流程记录；\n日志精准过滤：支持按组件、节点筛选日志，关键词检索、错误日志标红高亮，支持日志下载、锁定禁止自动滚动；\n各节点详情追溯\n配置打包：展示配置/变量新增、修改、删除数量，支持查看详细变更记录；\n代码检出：记录当前及上一次成功构建的Commit版本，精准追溯代码变更；\n单元测试：展示用例成功/失败数、测试覆盖率，支持查看详细测试报告；\n构建打包：展示工件名称、大小，支持在线下载产物；\n部署节点：展示部署机器数量、执行结果，支持单独重试失败机器，无需全量重跑。\n构建历史审计：右上角统一归档所有构建记录，支持随时回溯查询，满足研发运维审计需求。\n4.3.3 AI智能故障诊断（核心优势） 构建、单测、部署任意节点异常时，平台自动唤起AI诊断助手，无需人工逐行排查日志：\n自动抓取全量异常日志，凝练故障核心问题； 分层解析直接原因、间接根因，精准定位代码缺失、路径错误、权限不足、用例失败等问题； 同步输出标准化整改方案，将传统小时级排错压缩至秒级，排错效率提升90%。 五、MCP AI接口能力 Ease Ops 平台内置MCP开放接口能力，作为独立智能化能力模块，支持外部AI工具、自动化系统对接调用平台全量DevOps能力，实现流水线智能调度、自动化运维、故障智能处置，赋能研发流程智能化升级。\n5.1 能力概述 MCP接口为平台标准化对外交互接口，打通AI智能工具与DevOps流水线的联动能力，可远程调用项目管理、环境配置、任务构建、流水线执行、日志查询、故障诊断等核心功能，适配智能化持续交付、无人值守运维、批量自动化发布等场景。\n5.2 密钥创建与鉴权规范 所有MCP接口请求需通过专属密钥鉴权，保障接口访问安全，配置流程如下：\n进入平台「系统管理」-「MCP API Key」模块；\n点击「新增密钥」，自定义密钥备注、适配场景，生成专属鉴权密钥；\n妥善保存密钥，密钥仅生成一次，丢失无法找回；\n支持密钥启用、禁用、删除管理，可按需回收接口访问权限。\n鉴权报错说明：未携带密钥、密钥过期或密钥无效时，接口将返回 invalid or missing token 401无权限报错，需核对密钥有效性或重新生成密钥配置。\n5.3 接口标准配置示例 标准MCP接口对接配置格式如下，将配置中xxx替换为平台生成的专属MCP密钥即可完成对接：\n{ \u0026#34;mcpServers\u0026#34;: { \u0026#34;cicd-mcp\u0026#34;: { \u0026#34;url\u0026#34;: \u0026#34;https://devops.itart.cn/mcp\u0026#34;, \u0026#34;headers\u0026#34;: { \u0026#34;Authorization\u0026#34;: \u0026#34;Bearer xxx\u0026#34; } } } } 5.4 核心应用场景 智能流水线调度：通过AI工具远程触发构建、启停流水线、查询构建状态，实现无人值守自动化发布；\n批量运维管控：对接外部运维系统，批量查询项目、环境、主机资源状态，实现规模化DevOps运维；\n故障智能联动：结合平台AI诊断能力，通过接口推送故障日志、根因分析、整改方案，实现故障自动预警与处置；\n流程智能化扩展：支持自定义AI场景联动，拓展平台原生能力，适配个性化智能化研发运维需求。\n六、权限管理 平台采用角色化分级授权模式，区分平台级、项目级权限，权限隔离清晰、管控精准，适配多用户协作场景。\n6.1 权限资源分类 平台资源：平台全局配置、权限管理、Runner管理等跨项目通用资源，仅平台管理员可操作；\n项目资源：组件、流水线、机器、凭证等项目专属资源，由项目角色独立管控。\n6.2 角色分类 平台角色：管控平台级资源，负责全局配置、用户管理、Runner审核分配；\n项目角色：管控单项目资源，每个项目可独立定义、单独授权，互不干扰。\n6.3 用户管理规则 单个用户可绑定多个角色，兼顾多场景权限需求；\n新用户加入项目后，默认授予项目管理员基础权限；\n仅项目管理员拥有「邀请用户、修改项目角色权限」的能力，保障项目权限安全。\n七、Runner 管理 Runner 为平台分布式执行代理，承担代码构建、远程部署两大核心职能，支持集群扩容、智能调度，解决单节点性能瓶颈，仅平台管理员可管理配置。\n7.1 Runner 核心能力 构建职能：拉取代码、执行编译打包、完成工件归档/上传至本地或阿里云云效制品仓库；\n部署职能：远程连接目标服务器、分发工件与配置、执行部署脚本、启停服务。\n7.2 新增 Runner 节点 下载平台专属Runner程序，部署至目标服务器并启动；\n程序自动注册至平台，管理员在「系统管理-Runner管理」列表查看节点信息；\n管理员完成节点审核（通过/拒绝）、工作空间配置、项目分配；\n支持标签配置：内置「构建、部署」系统标签，精准区分节点用途。\n7.3 Runner 调度策略 平台采用精准匹配+一致性哈希调度机制，保障流程运行稳定：\n优先匹配流水线所属环境绑定的、对应标签的Runner节点；\n无专属节点时，自动使用平台内置公共Runner；\n多节点匹配时，通过一致性哈希将同一流水线ID固定调度至同一节点，保证执行环境一致性。\n八、平台核心优势（核心亮点） 效率大幅提升：DAG多组件并行调度，整体发布耗时缩短60%+，分钟级完成全流程交付，告别人工通宵发布；\n故障精准可控：单测卡点拦截缺陷，线上故障率下降82%；AI秒级智能排错，无需人工日志排查；\n运维成本极低：零代码拖拽编排，无需编写复杂脚本，运维人力减负70%，专注架构优化而非重复发布；\n架构灵活稳定：任务与流程解耦、三层架构隔离，支持插件化扩展，新增业务无需重构底层；\n全流程可追溯：结构化日志分组件隔离，所有操作、变更、部署记录全程留痕，审计溯源有据可依；\n轻量化易落地：无需复杂环境搭建，开箱即用，低成本替代传统Jenkins，适配各类中小企业研发场景。\n九、适配场景 前后端分离多组件分布式项目；\n物理机、容器混合部署的研发环境；\n需要标准化、规范化研发交付流程的团队；\n希望简化CI/CD运维、降低落地成本的中小企业。\n","permalink":"/blogs/2026/ease-ops/ease-ops-use-guide.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003eEase-Ops 是新一代轻量化 DevOps CICD 持续交付平台，依托 DAG 拓扑并行调度、结构化日志管控、AI 智能故障诊断三大核心能力，解决传统 CI/CD 工具发布低效、排错繁琐、运维复杂、扩展困难等行业痛点。平台支持零代码拖拽编排流水线、多组件并行交付、全流程可追溯、AI秒级排错，大幅降低研发运维成本，适配中小企业各类前后端分离、混合部署架构项目，可轻量化替代传统 Jenkins 工具。\u003c/p\u003e","title":"Ease Ops - 用户手册"},{"content":"背景 在传统研发管理模式中，“项目”大多指代有明确起止时间的阶段性业务任务，比如“双十一大促项目”“版本迭代专项项目”。但在 DevOps 与 CI/CD 持续交付体系中，“项目”的定义发生了本质变化。\n很多新手初次使用 DevOps 平台时，往往因为对“项目”边界界定模糊、划分方式不合理，导致后续出现权限混乱、流水线冗余臃肿、多环境配置互相干扰、版本追溯困难等一系列问题。\n本文结合主流 DevOps 平台的行业最佳实践，用通俗易懂的语言搭配实战案例，全面拆解 DevOps 中“项目”的核心定义、科学划分原则、落地操作规范，帮大家彻底避开项目搭建的架构陷阱。\n一、什么是 DevOps 中的 “项目”？ 1.1 专业定义 在 DevOps \u0026amp; CICD 平台中，项目（Project）是一套具备统一管控边界的研发交付全生命周期容器。\n它的核心作用是归集同一套业务、产品或版本对应的代码仓库、流水线、运行环境、配置参数、制品文件、工单、看板、权限体系、研发指标与文档资料，是打通“需求 → 开发 → 构建 → 测试 → 部署”全流程的一体化管控载体。\n1.2 通俗理解 如果将研发流程具象化：代码仓库是“设计图纸”，流水线是“生产车间”，服务器是“仓储库房”，那么 DevOps 项目就是一整套独立运转的超级工厂。\n这个工厂拥有专属的权限门禁、独立的审计度量台账、定制化的生产流水线，完全独立于其他工厂运转，互不干扰。\n1.3 常见误区澄清 很多团队的项目乱象，本质都是认知误区导致的，以下两个核心错误一定要规避：\n❌ 误区1：DevOps 项目 = 单个代码仓库\n一个标准 DevOps 项目可容纳多个微服务代码仓库，包含前端、后端、基础设施 IaC、脚本工具类仓库等，无需一个仓库对应一个项目。\n❌ 误区2：DevOps 项目 = 版本 / 迭代\nSprint 迭代、v1.0/v2.0 版本只是项目内部的短期周期管理单元，仅用于阶段性迭代管控。而 DevOps 项目是长期存续的载体，不会随迭代结束、版本更新而销毁。\n1.4 项目核心承载与约束规范 一个合规、标准的 DevOps 项目，需要完整承载研发全流程资产，同时满足三大核心边界约束，具体如下：\n核心承载内容 代码资产：关联 Git 仓库、分支管理策略、代码合并规则、代码扫描与质检规则等研发代码规范体系。\n交付流水线：涵盖 CI 构建、代码检查、单元测试、镜像构建、CD 自动化部署、全流程自动化测试等交付能力。\n环境与资源：包含 Dev 开发环境、Test 测试环境、Prod 生产环境、K8s 命名空间、数据库实例、IaC 基础设施脚本等资源。\n配置与密钥：配置中心参数、系统密钥、登录凭证、全局环境变量、标准化部署模板等核心配置资源。\n过程与度量：需求工单、Bug 管理台账、部署频次、变更前置时间、故障恢复时长等 DORA 研发效能指标数据。\n核心约束（边界三要素） 生命周期对齐：与业务产品生命周期保持一致，支持长期持续迭代，不针对短期临时业务任务创建项目。\n独立权限与审计：拥有专属独立角色权限模型，代码变更、流水线调整、配置修改等所有操作均可全程追溯、审计留痕。\n成本与计量边界：支持按项目独立统计资源消耗、构建时长、制品存储容量等数据，实现成本精准计量。\n二、如何科学地划分项目？6大维度与选型指南 搭建 DevOps 平台的核心关键，是确定顶层项目的划分维度。合理的顶层设计，能从根源避免后续管控混乱。以下是行业通用的 6 种划分维度，附适用场景、实战案例、优缺点及选型建议。\n维度1：按业务产品/产品线划分（⭐ 最推荐主维度） 适用场景：独立完整的业务产品、垂直产品线、企业通用中台服务。\n实战案例：电商主站项目、会员系统项目、支付中台项目、用户中心项目。\n结构规则：1 个 DevOps 主项目对应 1 条独立业务产品线，项目内部归集该产品线所有微服务仓库，统一使用一套权限体系、一套发布管控规范。\n核心优点：以业务视角为核心，贴合产品持续迭代模式，端到端交付周期、研发效能数据统计最精准，便于业务整体管控与复盘。\n存在缺点：若产品线微服务数量极多，项目内部资源会相对臃肿，需要通过文件夹、组件细分等方式做精细化管理。\n维度2：按独立微服务/组件划分（微服务架构专用） 适用场景：团队独立自治、可单独发布、可独立扩缩容、耦合度极低的微服务。\n实战案例：电商体系下的订单服务、商品服务、网关服务、消息队列服务。\n结构规则：1 个 DevOps 项目对应 1 个独立微服务，每个服务拥有专属独立的流水线、运行环境、密钥配置，完全自主管控。\n核心优点：服务发布完全解耦，单个服务更新、故障、迭代不会影响其他服务，团队自治度、研发灵活性极高。\n存在缺点：无法便捷实现跨服务整体发布编排，全局业务视图、整体数据统计的管理成本较高。可通过搭建上层聚合看板弥补该短板。\n维度3：按团队/研发组织划分（辅助管控维度） 适用场景：固定职能研发团队、外包交付团队，贴合康威定律做组织级管控。\n实战案例：基础架构团队项目、业务一线研发组项目、外包专项交付组项目。\n核心优点：权限治理简单高效，能从组织层面杜绝跨团队误操作、越权操作，保障研发安全。\n存在缺点：极易与业务边界错位（单个团队往往负责多个产品线）。不建议作为顶层核心划分维度，仅建议叠加在产品维度之上，用于辅助权限管控。\n维度4：按部署环境/集群划分（⛔ 严禁用于业务应用） 适用场景：仅适用于基础底座、K8s 集群、网络设施、数据库集群等基础设施 IaC 工程。\n实战案例：K8s 生产集群底座项目、公司级 MySQL 集群运维项目、网络安全策略配置项目。\n核心优点：将基础设施变更与业务变更完全隔离，可设置严格的审批流程，避免基础设施操作干扰业务迭代，提升底座稳定性。\n严禁错误做法：绝对不要将同一业务应用按环境拆分为多个项目，例如 order-service-dev、order-service-prod。这种操作会彻底破坏版本追溯链路与分支一致性，导致配置混乱、迭代失控。\n正确做法：同一业务仅创建一个顶层项目，通过项目内环境变量、配置分组区分 Dev/Test/Prod 环境。\n维度5：按版本/主线分支划分（版本专项管控） 适用场景：需要长期维护的稳定版本（LTS）、产品重大版本迭代、新旧版本并行运营场景。\n实战案例：产品 v3.0 长期维护版项目、产品 v4.0 全新迭代版项目（新旧版本并行运营）。\n核心优点：老版本补丁迭代、故障修复不会干扰主线新版本开发，版本边界清晰，维护成本更低。\n存在缺点：不适用于短期月度迭代、小版本更新场景，容易产生大量重复配置，造成资源冗余。\n维度6：按客户/租户划分（SaaS 多租户专用） 适用场景：SaaS 多租户模式、私有化部署项目、政企定制化交付项目。\n实战案例：SaaS 标准版母项目、某银行私有化定制衍生项目、某政企专属定制项目。\n核心优点：定制化代码、专属配置与主干版本完全隔离，既能复用基础能力，又能满足私有化交付、合规审计、版本追溯的专属需求。\n顶层项目创建核心原则总结 ✅ 单体应用：1 套产品对应 1 个 DevOps 主项目，统一管控全流程。\n✅ 微服务架构：产品线搭建顶层主项目做整体规划，各微服务单独创建子项目实现独立发布。\n✅ 平台底座：基础设施 IaC 单独建项，与业务项目完全物理隔离。\n❌ 高频避坑：禁止以月度迭代、冲刺周期、临时任务创建顶层项目；禁止按 Dev/UAT/Prod 环境拆分业务顶层项目。\n三、实战操作：平台项目创建与标准化管理流程 掌握理论划分原则后，下面为大家拆解 DevOps 平台项目的落地实操步骤，全程遵循行业最佳实践，适配绝大多数主流平台。\nStep 1：新增项目（核心信息配置） 在平台右上角项目下拉菜单中，点击「新建项目」，跟随平台智能化引导完成配置，核心两项信息需重点关注：\n项目编码（Code）：必须保证平台全局唯一。该编码是后续资源隔离的核心标识，将用于 URL 路径、K8s Namespace 前缀、资源标签等场景，创建后不可修改，需提前规范命名。\n项目名称（Name）：支持自定义修改，建议统一遵循「产品线-服务名-场景」的命名规范，便于团队统一识别、归档管理。\n[此处预留截图：新建项目引导页及编码、名称填写配置界面]\nStep 2：配置凭证管理（统一权限管控） 凭证主要用于授权代码仓库拉取、服务器登录部署等操作，平台普遍支持「账号密码」和「SSH 秘钥」两种验证方式。\n最佳实践：支持凭证多仓库、多主机共享复用，不建议单资源单独创建凭证。推荐按「业务线」「运行环境」创建公共凭证（如 prod-deploy-key、test-business-key），方便统一权限管控、定期轮换更新，降低安全风险。\n[此处预留截图：凭证管理列表及新增凭证弹窗界面]\nStep 3：关联代码仓库与部署主机 代码仓库关联：可在新建项目流程中同步创建关联，也可在项目首页「代码仓库」模块独立新增。填写仓库官方 URL 与默认主干分支，私有仓库需绑定上一步配置的专属凭证，确保拉取、提交权限正常。\n部署主机关联：录入部署目标服务器的 IP 地址、SSH 端口（默认 22），并匹配对应环境的登录凭证，完成部署资源绑定。\n[此处预留截图：代码仓库添加、主机配置界面]\n四、核心概念深度解析：什么是 DevOps 组件？ 完成项目、仓库、主机基础配置后，想要实现精细化 CI/CD 发布，必须掌握「组件」核心概念，这是 DevOps 精细化部署的关键。\n4.1 组件专业定义 组件（Component）是软件部署的最小独立单元，是软件系统在交付部署过程中，可单独完成开发、测试、构建、部署的最小实体。\n4.2 通俗理解 延续前文的工厂比喻：项目是整体超级工厂，代码仓库是全套设计图纸，组件就是工厂最终生产出来、可独立打包、独立发货的标准集装箱，是直接落地部署的核心载体。\n4.3 组件拆分的核心意义（解决 Monorepo 痛点） 目前很多团队采用 Monorepo 大仓库模式，将前端、后端、各类工具代码统一放在一个 Git 仓库中，这种模式本身无问题，但绝大多数团队都存在部署误区。\n❌ 错误部署方式：将整个大仓库直接作为一个组件部署。\n弊端：仅修改前端代码，也会触发后端代码重新编译、整体重新部署，不仅浪费构建资源、延长发布耗时，还会无端增加部署故障风险。\n✅ 正确部署方式：代码可统一存放于同一个仓库，但需根据实际部署载体、业务模块，在 DevOps 平台中拆分多个独立组件，实现按需发布。\n4.4 实战拆分案例 假设团队存在一个统一电商大仓库 my-ecommerce-repo，仓库目录分为两大模块：/frontend（Vue 前端代码）、/backend（Java 后端代码）。\n对应 DevOps 项目内需拆分两个独立组件：\n组件A：ecommerce-web 前端组件\n构建路径：/frontend\n部署目标：Nginx 服务器 / CDN 静态资源节点\n组件B：ecommerce-api 后端组件\n构建路径：/backend\n部署目标：K8s 集群 / Tomcat 服务器\n通过组件拆分，可对前后端配置独立的 CI/CD 流水线，实现改前端只发布前端、改后端只发布后端的精细化交付，大幅提升发布效率、降低变更风险。\n[此处预留截图：项目内组件列表、组件构建路径配置界面]\n五、总结 DevOps 中的项目绝非简单的文件归集文件夹，而是支撑产品持续迭代、全流程可管控、可追溯的研发交付生命周期容器。其核心价值是搭建统一的权限、资源、流水线、成本计量边界，打通研发全流程工具链，实现标准化交付。\n核心划分原则：以「业务产品/产品线」为核心顶层维度，微服务架构叠加二级微服务细分；基础设施底座独立建项、完全隔离；坚决杜绝按环境、短期迭代拆分顶层项目。\n落地关键动作：合理拆分定义组件，将统一仓库的代码资产，拆解为最小可独立部署单元，实现精细化、轻量化、低风险的持续交付。\n合理的 DevOps 项目架构设计，是研发体系高效、稳定、可迭代的基础。希望本文的指南，能帮助团队从平台搭建初期避开架构陷阱，搭建出标准化、规范化、高效化的研发交付体系！\n","permalink":"/blogs/2026/ease-ops/ease-ops-project-component.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003e在传统研发管理模式中，“项目”大多指代有明确起止时间的阶段性业务任务，比如“双十一大促项目”“版本迭代专项项目”。但在 DevOps 与 CI/CD 持续交付体系中，“项目”的定义发生了本质变化。\u003c/p\u003e","title":"Ease Ops - 如何科学划分“项目”定义“组件”"},{"content":"一、前言 在DevOps研发落地流程中，环境管理是支撑研发、测试、上线全流程的核心基础环节。但传统的环境配置管理模式存在诸多短板，操作繁琐、容错率低，长期以来成为困扰研发团队的核心痛点，严重制约研发效率与业务稳定性提升。\n二、传统环境管理的核心痛点 传统环境配置管理模式下，研发团队需要为开发、测试、预发布、生产等多套独立环境逐一分配资源、维护配置文件，同时保障各环境配置、变量的同步一致性，整体管控难度极高。\n传统模式下每套环境均拥有独立配置文件，任意配置参数的微调修改，都需要运维或研发人员逐环境手动操作。对于中大型项目而言，多环境重复配置操作不仅工作量大、效率低下，还极易出现漏改、错改、配置不同步等问题。一旦数据库连接信息、API接口地址等核心配置出现偏差，极易引发线上功能异常、系统崩溃、数据丢失等严重故障，直接造成企业经济损失，同时损害产品口碑与品牌声誉。\n随着项目迭代升级、研发环境数量增多，环境架构复杂度持续攀升，人工管控的局限性被进一步放大，配置管理难度、人工失误率大幅上升，多环境数据不一致问题频发，成为制约DevOps流程高效落地的关键瓶颈。\n三、Ease Ops 创新环境配置管理解决方案 针对传统环境管理的各类痛点，Ease Ops打造了轻量化、高效率、可追溯的环境配置管理方案，通过创新的架构设计与功能机制，彻底解决多环境配置冗余、易出错、难追溯等问题，全方位优化DevOps环境管控流程。\n3.1 树形继承模式，实现配置高效复用 Ease Ops 突破性采用环境树形继承架构，重构传统配置管理逻辑。平台将单一完整配置文件拆解为「通用配置模板」与「差异化环境变量」两大独立模块，通过变量引用替代重复配置，从根源上减少冗余操作。\n具体实现逻辑为：提炼所有环境的通用配置，在默认缺省环境中搭建统一配置模板；将各环境的差异化参数（数据库地址、账号密码、接口地址等）定义为独立变量。后续所有子环境可直接继承默认环境的通用配置，仅需根据自身场景单独修改差异化变量值，无需重复搭建完整配置。\n以电商项目多环境管理为例，传统模式下，开发、测试、生产三套环境需独立配置数据库连接参数，一旦数据库地址变更，需逐套环境手动修改，操作繁琐且出错率极高。依托Ease Ops树形继承模式，只需在默认环境配置通用模板，将数据库地址、用户名、密码等设为可变变量，各环境自动继承模板配置，仅按需修改变量值即可，大幅提升配置效率，彻底规避重复修改引发的故障问题。\n3.2 快速搭建个性化环境，适配多样化研发需求 在日常研发测试工作中，研发人员常需要搭建专属个性化测试环境，用于功能调试、问题复现、版本验证等场景。传统模式下，全新环境搭建、配置复刻、参数调试流程繁琐、耗时较长，严重影响研发进度。\nEase Ops 支持一键新增子环境+父级配置继承能力，大幅简化个性化环境搭建流程。用户可基于已有测试环境快速新建个人专属环境，系统自动完整继承父级环境的全部配置与变量，仅需针对个性化需求微调部分变量参数，即可快速完成专属测试环境搭建，极大缩短环境部署周期，有效提升开发、测试整体效率。\n3.3 全局配置统一管控，变更全程可追溯 针对传统配置变更无记录、差异难对比、风险不可控的问题，Ease Ops 提供全局配置统一管理能力，实现配置变更可视化、可追溯、可校验。\n平台在每次流程构建时，会自动对当前配置、环境变量、自定义变量生成快照，用户可随时对比当前最新配置与历史成功构建配置的差异，直观清晰掌握每一项配置的变更内容。该功能可有效规避人工操作失误、配置漏改、数据不一致等问题，精准把控配置变更风险，从流程上杜绝因配置变更引发的线上故障，保障系统运行稳定。\n3.4 环境配置标准化操作指南 项目创建完成后，Ease Ops 会自动初始化三套基础环境：缺省环境、测试环境、生产环境，各环境可独立管控配置文件、环境变量、绑定主机及Runner资源，权限与资源隔离清晰。\n3.4.1 配置文件管理规范 为保障全环境配置一致性，平台统一规范：所有新增配置仅可在根节点「缺省环境」中创建。用户选中环境树根节点缺省环境，点击新增配置，设置对应相对路径并填写配置内容即可。相对路径主要用于配置分组，部署时可通过简易命令批量拷贝同路径配置文件至目标服务器。\n以下为标准配置示例（相对路径：config/app.yaml）：\nserver: http: addr: {{http_addr}} timeout: 300s data: database: driver: mysql source: {{mysql_username}}:{{mysql_password}}@tcp({{mysql_host}}:3306)/ease_ops?parseTime=True\u0026amp;amp;loc=Local 配置内容中采用双大括号的格式引用自定义变量，配置保存后，系统将自动识别并提取所有变量，用户可统一设置变量默认值。测试、生产等子环境默认完整继承缺省环境的配置与变量，同时支持子环境独立修改变量值，或重写配置文件内容，实现按需覆盖。\n需要注意的是，配置继承与变量引用为两个独立维度，变量必须依托配置存在。若子环境重写配置、移除部分变量引用，该部分变量将不再在当前环境展示，其下级子环境也将同步不再继承该配置变量。\n为清晰区分配置、变量的来源与状态，平台会统一标识三类继承类型：\n继承「xx」：当前配置/变量从指定父级环境继承而来，无自定义修改； 覆盖「yy」：当前配置/变量已重新自定义赋值，覆盖父级环境原有配置； 本地定义：当前配置/变量由本环境独立创建，无上级继承关系。 部署阶段，用户可通过简易脚本完成配置文件部署，支持单文件拷贝与目录批量拷贝两种方式，示例脚本如下：\n# 单文件拷贝 cp {{conf/config/app.yaml}} /usr/local/my_app/conf/app.yaml # 目录批量拷贝 rsync -avc {{conf:config}}/ /usr/local/my_app/conf/ 平台会根据部署流程选定的环境，自动生成对应环境的最终配置。同时支持配置预览功能，配置修改保存后，系统自动弹出差异对比弹窗，支持二次确认，规避误操作风险。\n预览\n修改保存二次确认\n3.4.2 环境变量与资源绑定管理 环境变量的管理逻辑与配置文件一致，全面支持继承、覆盖机制。变量引用标准格式为 var:ext.StopCommand，其中var:为固定前缀，ext代表自定义变量，sys代表平台系统内置变量，无需手动定义即可直接使用。\n除配置与变量外，平台支持为各环境绑定主机与Runner工作节点，同样适配继承机制。部署任务仅可选用当前环境绑定的主机资源；Runner节点优先使用环境绑定资源，未单独绑定时，自动调用平台公共级别Runner资源，保障部署资源规范可控。\n四、Ease Ops 落地核心收益 Ease Ops 通过树形继承架构、可视化变更追溯、快速环境搭建、标准化资源管控四大核心能力，彻底解决传统DevOps环境配置管理的痛点，为企业研发流程带来全方位提升。\n在配置管理层面，大幅减少多环境重复配置工作，降低人工操作失误概率，有效保障全环境配置的准确性、一致性；在环境搭建层面，轻量化的个性化环境搭建能力，极大缩短环境部署周期，提速整体研发迭代流程；在风险管控层面，全流程配置快照与差异追溯能力，实现配置变更可查、可溯、可校验，有效降低变更风险，保障业务系统稳定运行。\n整体而言，Ease Ops 为DevOps环境隔离与配置管理提供了一套高效、规范、可靠的一体化解决方案，能够有效助力企业优化研发管理流程、提升研发效率、夯实业务稳定性，是企业数字化研发迭代的重要助力。\n","permalink":"/blogs/2026/ease-ops/ease-ops-env-conf.html","summary":"\u003ch2 id=\"一前言\"\u003e一、前言\u003c/h2\u003e\n\u003cp\u003e在DevOps研发落地流程中，环境管理是支撑研发、测试、上线全流程的核心基础环节。但传统的环境配置管理模式存在诸多短板，操作繁琐、容错率低，长期以来成为困扰研发团队的核心痛点，严重制约研发效率与业务稳定性提升。\u003c/p\u003e","title":"Ease Ops - 优雅解决环境配置管理难题"},{"content":"欢迎开启自动化运维与规范化交付之旅，仅需3步即可快速上手，解锁平台全能力，轻松实现自动化构建与部署。\n第一步：注册账户 使用个人邮箱即可完成安全加密的快速注册，两步即可完成账号创建：\n访问注册页面：Ease Ops 账户注册 按照引导流程，先验证邮箱，再完善基础账户信息，即刻解锁平台全部能力。 第二步：初识平台 成功登录平台后，系统已提前为您预置好 PetClinic 参考示例项目，您可以直接进入该项目参考完整流程，快速直观地理解平台的构建、部署全链路运转逻辑，快速掌握核心使用思路。\n第三步：5分钟搭建第一个项目 点击页面右上角的项目切换下拉按钮，选择「新增项目」即可进入引导式项目创建流程，全程采用可视化分步配置，操作零门槛：\n基础信息填报\n第一步填写项目的名称与唯一编码，即可完成项目的基础身份配置。\n关联代码仓库\n进入代码仓库配置页面，输入您的代码仓库地址：\n若仓库开启了权限认证，可按需选择密码或秘钥两种认证方式完成授权 平台支持同时添加多个代码仓库，满足多源码关联需求 确认提交信息后，平台将自动拉取仓库全部内容，智能解析仓库特征，为您预填充组件构建相关信息，接下来可从两种主流构建模式中按需选择其一完成配置：\n构建流程配置\n平台提供两类开箱即用的主流构建模式，您可根据业务需求自由选择：\n模式一：常规构建\n选择匹配项目需求的构建环境镜像，填写对应的构建执行脚本即可完成基础构建配置 配置工件提取规则：该功能可从构建产物中自动提取后续部署环节所需的程序包、文件等工件资源，保障部署流程与构建环节自动无缝衔接。\n模式二：Docker镜像构建\n填写分阶段构建的Dockerfile：第一阶段完成业务产物的编译构建，第二阶段直接生成可部署的轻量化运行时镜像 配置目标镜像仓库信息，构建生成的镜像将自动推送至该仓库完成持久化存储，方便后续部署直接调用 配置部署\n填写部署目标主机信息，支持同时添加多台主机作为部署目标，一键实现批量发布\n配置组件的部署执行规则，您可以自定义启动、停止脚本，同时支持通过的变量格式动态关联已提取的工件名，实现配置与产物自动绑定，无需手动修改适配\n完成项目创建\n核对页面上展示的所有项目配置信息，确认无误后点击提交，即可一键完成整个项目的创建流程 项目创建完成后，系统将自动跳转至该项目的详情页面，您可以直接启动首次构建，一键触发完整自动化部署流程，验证全链路运转效果。\n流水线实现全流程可观测与进度可视化，支持执行过程中实时流式输出全量操作日志，还可随时一键中止流程，每一步节点的执行细节都清晰留存，让交付全链路透明可控。\n探索更多进阶能力 除了基础的项目创建能力，平台还提供丰富的高阶功能，满足各类复杂业务场景的发布需求：\n自定义流程编排（详情：https://itart.cn/blogs/2026/practice/ease-ops-flows.html）\n如果您需要定制完整的CI/CD流水线逻辑，只需进入编排页面，即可通过可视化拖拽调整任务节点，自由搭建完全符合您业务需求的专属发布流程。\n任务调整与规则优化\n当需要灵活调整流水线中的任务执行逻辑时，进入任务配置页即可快速修改任务参数、新增或删减任务步骤，轻松适配不同的发布场景需求。 环境差异化配置 （详细：https://itart.cn/blogs/2026/explore/ease-ops-env-conf.html）\n点击页面中的「环境配置」入口，即可快速新增、修改不同环境下的专属配置，包括环境变量、自定义配置文件等内容，轻松实现开发、测试、生产等多环境的配置隔离与统一管理。 层级自动继承\n默认包含顶层缺省父环境default，以及两个同级子环境test、prod，子环境自动继承父环境的配置文件件、环境变量、绑定主机等全部配置。\n本地覆盖规则\n在当前子环境增改配置，仅作用于本环境，不会影响上级父环境和其他同级环境：在default配置变量DB_HOST，test和prod会自动同步获取该变量子环境继承的配置文件中，会自动按当前环境的变量值解析，仅需修改生产环境配置时，直接在prod中调整即可，不会干扰其他环境\n","permalink":"/blogs/2026/ease-ops/ease-ops-quick-start.html","summary":"\u003cp\u003e欢迎开启自动化运维与规范化交付之旅，仅需3步即可快速上手，解锁平台全能力，轻松实现自动化构建与部署。\u003c/p\u003e\n\u003ch2 id=\"第一步注册账户\"\u003e第一步：注册账户\u003c/h2\u003e\n\u003cp\u003e使用个人邮箱即可完成安全加密的快速注册，两步即可完成账号创建：\u003c/p\u003e","title":"Ease Ops - 平台快速入门指南"},{"content":"从代码提交到生产发布：ease-ops 如何把 CI/CD 做成「看得懂、管得住、扩得开」 摘要：ease-ops 是专为50–200人中小研发团队打造的企业级DevOps平台。它摒弃了传统CI/CD工具的碎片化弊端，以可视化DAG编排、轻量化MySQL任务队列、CI/CD与配置中心一体化为核心，打通开发、测试、部署、配置全流程，构建出可观测、可审计、可迭代的研发交付生产线。本文结合真实落地场景与架构设计，拆解平台轻量可靠、灵活易扩的核心优势。\n一、中小团队CI/CD普遍面临的三大痛点 对于50人以上的研发团队而言，传统CI/CD工具链落地后，极易陷入效率低、门槛高、管控弱的困境，核心问题集中在三点：\n1. 工具链碎片化，交付链路不可追溯\n团队普遍采用多工具拼凑模式：Jenkins负责构建、GitLab管理代码、部署依赖Shell脚本、环境变量分散在仓库或第三方系统。整套交付流程割裂，发布步骤、操作人员、配置变更均无法完整回溯，事后问题排查、事故复盘难度极大。\n2. 配置门槛极高，新人上手成本大\n传统流水线依赖Jenkinsfile、.gitlab-ci.yml等YAML脚本配置，语法复杂、耦合性强，单行修改都可能影响整体流程。新人需要熟练掌握专属语法与团队内部约定，才能参与流水线维护，人力成本极高。\n3. CI/CD与配置割裂，线上事故频发\n构建、部署、配置模块相互独立，常出现构建测试正常、部署后因环境变量错误导致故障的问题。版本回滚依赖人工查找历史制品与配置，配置变更无感知、无记录，是研发事故的高频诱因。\nease-ops并非传统CI工具的皮肤优化，而是从组织模型、可视化编排、任务执行到配置快照的全链路一体化解决方案，兼顾易用性、管控性与可扩展性，适配中小团队的落地节奏。\n二、ease-ops 核心定位与差异化优势 2.1 产品核心定位 ease-ops 聚焦中小研发团队，实现「开发-测试-部署-配置」全流程自动化。为最大限度降低落地与运维成本，平台初代版本做了极致精简，仅依赖MySQL+HTTP轮询Runner，无需部署复杂中间件，开箱即用、运维极简。\n平台核心由三大模块构成，形成完整研发闭环：\n核心模块 核心能力 组织管理 搭建项目→应用→组件层级体系，流水线、权限、资源均绑定项目维度，管控清晰 CI/CD流水线 可视化DAG编排，搭配分布式Runner，自动化完成构建、测试、部署全流程 配置中心 支持多环境配置继承与覆盖，与流水线运行时配置快照深度联动，实现变更可追溯 2.2 与传统CI/CD方案的核心差异 相较于Jenkins、GitLab CI等传统方案，ease-ops从底层架构和使用模式上解决了传统工具的痛点，差异化优势显著：\n对比维度 传统方案 ease-ops 流水线定义 依赖YAML脚本编写，门槛高 可视化DAG图形编排，零脚本入门 基础设施依赖 需Redis、MQ等多套中间件，运维复杂 仅MySQL+Runner，极简运维架构 环境与配置管理 流水线与配置体系割裂，无联动 项目×环境矩阵管理，运行时配置快照对比 问题排查方式 跨工具翻日志、手动检索，效率极低 实时日志过滤+AI流式诊断，快速定位根因 平台技术栈采用Go+Kratos后端、React+Ant Design前端，基于MySQL存储、VM部署Runner，完美适配中小团队「先跑通流程、再迭代优化」的落地需求。\n三、四大真实落地场景：解决痛点，量化提效 以下场景均来自中小研发团队真实落地案例，所有优化数据为团队实测典型结果，直观体现平台落地价值。\n场景1：流水线搭建从「天级」压缩至「分钟级」 优化前：新项目搭建CI/CD流水线，需手动配置Jenkins插件、Agent、凭证，全程耗时1-2个工作日，且高度依赖专属运维人员，无法标准化落地。\n优化后：平台内置Java、Go、React、PHP、Python五大主流语言流水线模板，创建项目即可预览完整DAG流程，一键生成标准化流水线，仅需在可视化界面微调脚本、镜像、产物路径即可投入使用。\n核心收益：将流水线搭建周期从1-2天缩短至10-20分钟，把行业最佳实践固化为模板，规避团队重复踩坑，彻底摆脱「专人运维」的依赖。\n内置模板 流水线编排\n场景2：多组件多环境发布，彻底杜绝版本串台 优化前：微服务架构下多组件、多版本并存，开发、测试、生产环境流水线混杂，极易出现误操作、版本不匹配、环境串台等问题，引发线上故障。\n优化后：平台按环境维度分组展示流水线，切换环境即切换操作上下文，从源头避免串台问题；支持按组件精准选择发布版本，单次流水线执行可完整记录多组件版本信息，历史记录可全程追溯。\n核心收益：大幅降低发布误操作风险，实现发布全流程审计，操作人员、时间、流水线、组件版本均可精准回溯。\n环境维护\n环境流水线\n场景3：生产发布全程可视化，变更可控可合规 优化前：传统SSH脚本批量部署，无审批流程、无分批机制、无执行日志，上线过程黑盒化，故障无法定位，不满足团队合规管控需求。\n优化后：支持流水线插入自定义人工审批节点，所有审批动作全程留痕；部署步骤可绑定环境、主机标签，自动完成滚动部署与健康检查，失败自动暂停告警。同时，运行详情页以DAG图形展示每一步执行状态，可实时查看构建产物、代码变更、测试覆盖率等明细。\n核心收益：实现生产发布「先审批、后分批、再上线」的标准化流程，交付过程透明可视，解决部署黑盒焦虑，满足企业合规管控要求。\n场景4：故障定位效率翻倍，MTTR大幅缩短 优化前：流水线构建失败后，需人工翻阅数千行日志、跨工具检索排查，新人无从下手，单次故障定位平均耗时45分钟以上。\n优化后：内置实时日志控制台，支持按步骤、日志级别、关键词过滤，大日志量场景仍流畅运行；搭载AI错误诊断助手，一键流式分析故障原因并输出排查方案。同时通过构建天气图标、成功率统计看板，直观展示流水线稳定性，提前预判潜在风险。\n核心收益：故障根因定位时间从45分钟缩短至8分钟内，大幅降低救火成本，助力团队持续优化交付质量。\n场景落地量化收益汇总 核心指标 优化前 优化后 首条流水线搭建周期 1–2 天 10–20 分钟 故障定位平均耗时 约45分钟 约8分钟 配置相关线上事故 每季度数次 趋近于0 四、五大核心设计亮点：轻量却可靠，简单却专业 1. 纯可视化DAG编排，告别YAML脚本 平台内置可视化流水线编辑器，支持代码拉取、构建、单元测试、集成测试、部署、人工审批等全类型节点，所有增删改、环境绑定、节点启停操作均通过图形化拖拽完成。同时采用统一渲染引擎，实现编排编辑、运行展示、模板预览三处UI一致性，彻底消除「编辑与运行视觉偏差」，降低团队认知成本。\n2. MySQL轻量化任务队列，极简运维架构 区别于传统工具依赖Redis、MQ等重型中间件，ease-ops初代版本仅基于MySQL实现任务队列能力。CI服务将任务持久化至数据库，Runner通过HTTP轮询抢占任务，依托数据库租约机制保障任务状态一致性。Runner宕机后，超时任务可自动回收重跑，多实例扩展无需额外中间件支撑，在保证稳定性的同时，极大降低运维成本。\n3. 配置中心深度嵌入流水线，变更可预判 平台打破CI/CD与配置中心的壁垒，将环境配置快照作为流水线核心步骤。每次运行均会留存完整配置文件，且支持与历史版本做差异化对比，部署前即可精准知晓配置变更内容，从源头杜绝配置错误导致的线上故障。\n4. WebSocket实时推送，全程无刷新观测 前端通过WebSocket订阅流水线状态主题，实现流水线状态、运行日志的实时自动刷新，无需手动刷新页面。状态推送与日志传输双通道解耦，在保证丝滑使用体验的同时，支持私有化部署，所有数据与执行流程均留存内网，兼顾体验与数据安全。\n5. 低迁移成本，无插件地狱风险 平台沿用Jenkins用户熟悉的构建天气、历史记录、重试/终止操作等交互隐喻，降低团队迁移学习成本。但底层完全重构，不依赖Jenkins内核与插件体系，彻底规避插件兼容问题、版本升级故障等传统工具通病。\n6. MCP开放协议：AI原生、全链路可编程自动化 ease-ops 内置MCP（模型控制协议）开放能力，是平台适配AI运维、自动化集成与二次开发的核心底座。区别于传统CI/CD仅支持简单Webhook触发的局限，MCP提供研发全生命周期标准化、可被大模型调用的开放接口，让项目管理、流水线调度、环境配置、故障排障等所有平台能力，均可被程序、AI模型、外部系统无缝调用，彻底打通人工运维、自动化调度与智能化管控链路。\nMCP统一协议规范，覆盖DevOps核心场景，一站式解决传统工具接口零散、集成困难、AI适配性差的问题，核心能力涵盖：项目与权限管控、代码仓库/组件运维、多环境配置管理、流水线全流程调度、运行数据全量观测、AI智能故障诊断、批量资源查询与配置解析。依托这套能力，平台可实现全场景无人值守自动化运维，同时支持企业个性化二次开发、第三方系统对接。\nMCP核心落地价值：打破传统DevOps人工主导的运维瓶颈，原生适配AI智能化交付场景，支持大模型自主完成流水线创建、发布、变更、排障等操作。在权限可控、操作可审计的前提下，兼顾批量自动化运维、外部系统集成与平台迭代拓展，大幅提升研发运维的自动化上限，让ease-ops不仅是可视化CI/CD工具，更是可智能化调度的工程交付平台。\n五、核心架构与实现原理：稳定可追溯，可长期演进 5.1 核心数据模型 平台采用四层核心数据模型，实现流水线定义与运行实例解耦，结构清晰、扩展性强： Flow：持久化的流水线DAG模板，定义节点、连线、步骤类型等核心规则；FlowRun：单次手动/定时/自动触发的流水线运行实例；Step Spec：各类步骤的标准化配置API；flowAdapter：实现前后端模型转换，解耦UI展示与底层执行逻辑。\n5.2 整体架构设计 5.3 完整执行链路 从流水线触发到执行完成、状态观测，全链路标准化、可追溯：\n5.4 安全与治理能力 平台具备完善的企业级管控能力，适配团队规范治理需求：\n精细化权限管控：基于RBAC权限模型，支持页面、按钮、操作级权限控制，区分查看、管理、执行、审核等不同角色权限；\nRunner节点准入：所有执行节点需管理员审批后方可接入任务，杜绝未知节点执行高危操作；\n集成安全校验：Git Webhook签名校验、Runner密钥定期轮换，保障接入与执行安全。\n5.5 可维护性设计 平台采用插件化、契约化设计，支持长期迭代优化：步骤类型插件化扩展，新增流程节点无需重构核心引擎；前后端契约清晰，UI迭代不影响底层执行逻辑；设计文档、协议规范与代码同步更新，降低团队协作与迭代成本。\n六、可扩展演进路径：按需迭代，无架构重构风险 ease-ops初代版本主打轻量化落地，同时预留完整扩展能力，团队可根据业务规模按需迭代，无需推翻现有架构。\n扩展方向 现有基础 迭代方式 多语言/构建工具适配 通用语言模板+自定义构建脚本 新增行业模板、拓展构建配置规范 流程节点拓展 插件化节点编辑器 新增后端Spec API+前端编辑组件 多样化触发方式 内置多类型触发枚举 补齐Webhook、定时、OpenAPI触发能力 制品与监控体系 产物预览、流水线状态统计 对接制品库、Prometheus监控、告警系统 推荐落地迭代顺序：组织权限搭建→基础CI构建能力→单环境CD部署→配置中心联动→多环境质量门禁，每一步均可落地见效，避免大型项目迭代风险。\n七、结语 CI/CD的核心价值，从来不是工具的堆砌，而是实现研发交付的可理解、可重复、可回滚、可审计。\nease-ops 精准适配中小研发团队的痛点与落地能力，以可视化编排降低使用门槛，以极简架构降低运维门槛，以配置快照和审批机制降低变更风险，以实时观测和AI诊断降低故障成本，彻底将传统脚本化、黑盒化的交付流程，升级为看得懂、管得住、扩得开的标准化工程体系。\n若你的团队正受传统CI/CD工具碎片化、难维护、门槛高的困扰，或计划从Jenkins、脚本化部署迁移，可通过平台完整Demo，体验从模板创建流水线到生产部署的全链路轻量化交付流程。\n","permalink":"/blogs/2026/ease-ops/ease-ops.html","summary":"\u003ch2 id=\"从代码提交到生产发布ease-ops-如何把-cicd-做成看得懂管得住扩得开\"\u003e从代码提交到生产发布：ease-ops 如何把 CI/CD 做成「看得懂、管得住、扩得开」\u003c/h2\u003e\n\u003cp\u003e\u003cstrong\u003e摘要\u003c/strong\u003e：ease-ops 是专为50–200人中小研发团队打造的企业级DevOps平台。它摒弃了传统CI/CD工具的碎片化弊端，以可视化DAG编排、轻量化MySQL任务队列、CI/CD与配置中心一体化为核心，打通开发、测试、部署、配置全流程，构建出可观测、可审计、可迭代的研发交付生产线。本文结合真实落地场景与架构设计，拆解平台轻量可靠、灵活易扩的核心优势。\u003c/p\u003e","title":"Ease Ops - AI 赋能 - CI/CD 做成「看得懂、管得住、扩得开」"},{"content":"前言 依托项目真实上线运行案例（后端 API + 前端 Web + 分布式 Runner Agent 三大组件全链路实测），本文从实战落地、痛点收益、底层原理、产品优势四大维度，全方位介绍自研 CICD 流水线。产品以 DAG 拓扑调度为内核，实现多组件并行构建、全链路可视化日志管控、异常 AI 自动诊断，解决传统 CI/CD 发布低效、排错繁琐、扩展困难等行业通病，让 DevOps 落地看得见、用得上、收益可量化。\n一、真实落地实战案例：三大组件并行自动化交付 本次落地项目拆分为后端 API 服务、前端 Web 应用、分布式执行 Runner Agent三大独立组件，流水线依托 DAG 有向无环图能力实现分支并行、任务收敛，完整运行链路来自平台生产运行截图：\n1. 正常构建全链路流程 统一入口：配置打包节点 流水线以「配置打包」作为起始节点，统一管理全项目环境变量、全局配置文件，一份配置同步供给后端、前端、Runner 三个组件，杜绝多组件配置不一致、重复维护配置文件的问题。\nDAG 自动分叉，三大组件并行执行 配置节点执行完成后，流水线自动拆分三条独立执行分支，同步启动构建，互不阻塞：\n后端 API 分支：代码检出→单元测试（306 条测试用例，测试覆盖率 21.23%）→代码构建（产出 18.48M 程序安装包，支持产物在线下载归档）；\n分布式 Runner 分支：代码检出→单元测试（130 条测试用例，测试覆盖率 48.68%）→代码构建（产出 8.05M 远程执行代理包）；\n前端 Web 分支：代码检出→前端资源打包构建（产出 19.94M 静态资源包，按需省略单元测试环节）。 多分支并行模式对比传统串行流水线，整体构建耗时缩短 60% 以上。\n分支汇聚，统一部署上线 三条分支全部构建完成后，链路自动收敛，前端 Web、后端 API 开启并行部署：前端部署耗时 42s，后端 API 部署耗时 1 分 38s；分布式 Runner 通过 SSH 协议远程连通目标服务器，底部日志面板实时全量输出部署明细：服务器连接、安装包远程上传、文件解压、部署脚本赋权等全流程操作日志完整留存，每一步动作可追溯。 2. 异常实战：单测故障自动唤起 AI 智能诊断 后端 API 单元测试环节出现异常：全量 296 条测试用例中 6 条用例执行失败，日志抛出expected 3 cache mounts缓存挂载不匹配、missing reports测试报表缺失、unit-test runner failed任务异常等报错。 平台自动在页面右下角弹出AI 故障诊断助手，自动抓取当前节点全量日志，无需研发人工逐行梳理日志、翻阅源码，AI 一键拆解故障根因、给出优化整改方案，将原本数小时的故障定位压缩至秒级完成。\n二、直击行业痛点，落地收益量化可查 传统 CI/CD 普遍痛点 多模块串行发布效率低下：前后端 + 代理组件串行打包上线，全量发布耗时数小时，大版本发布需要研发、运维通宵值守；\n日志零散混乱难检索：全组件日志混杂输出，报错无法快速区分归属前端、后端或 Runner，故障检索全靠人工全文检索；\n异常排错成本居高不下：单元测试、构建、部署报错只能人工逐条分析日志，新人上手难度大；\n流程耦合扩展困难：修改单个组件构建参数就要改动全量流水线脚本，新增业务模块改造成本高。\n落地后量化收益 ✅ 发布效率提升 65%+：三组件并行自动化构建，全量打包部署从人工半天缩短至分钟级自动完成，研发聚焦业务开发；\n✅ 线上故障率下降 82%：单元测试卡点强制拦截不合格代码，用例失败直接阻断后续构建部署，从源头拦截缺陷版本上线；\n✅ 运维人力减负 70%：告别手工打包、远程部署，运维从重复性发布工作转向架构优化；\n✅ 故障排查效率提升 90%：异常自动触发 AI 分析，问题定位从小时级变为秒级，大幅降低研发排错成本。\n三、底层实现原理：DAG 分层架构，从设计上兼顾灵活与稳定 1. DAG 有向无环图核心调度引擎 流水线采用拓扑结构与执行配置分离的创新架构：\n拓扑层：仅存储节点排布、任务依赖连线，管控任务串行 / 并行执行顺序；\n配置层：独立存储各节点打包命令、部署参数、仓库地址等配置信息。 修改构建命令不用调整流程图，调整任务顺序无需改动业务配置，彻底规避 Jenkinsfile 脚本 “一处修改全流程出错” 的弊端；依托 DAG 天然能力实现分支分叉、任务汇聚，支持复杂多组件编排。\n2. 三层解耦架构：平台管控 + 业务组件 + 分布式执行 平台管控层：负责流水线编排、流程调度、日志归集、AI 能力调度；\n业务组件层：后端 API、前端 Web 为业务服务，可独立增删测试、构建步骤；\n分布式 Runner 执行层：作为远程 Agent 承接跨机器、跨机房部署任务，平台只做流程管控，实际部署逻辑下沉至远端执行节点，横向扩容机器即可分散构建压力。\n3. 上下双视图页面架构 页面采用上方 DAG 流程图 + 下方结构化日志面板双视图： 上方流程图直观展示每个节点运行状态、用例数量、覆盖率、产物大小、执行耗时；下方日志面板按组件、节点做日志隔离存储，每条日志绑定流水线 ID、组件标识，为日志筛选、检索提供底层支撑。\n四、产品核心优势：实用易用、灵活扩展、低成本运维 1. 可视化拖拽编排，零代码搭建多组件流程 全可视化画布拖拽式搭建流水线，无需编写 Shell、Jenkinsfile 脚本，新增 / 删减测试、部署节点像搭积木；成熟流水线一键保存为模板，新项目直接复用模板，流水线搭建从数天缩短至十余分钟。\n2. 结构化日志：分组件筛选、关键词检索、错误高亮 日志按「后端 API / 前端 Web / 分布式 Runner」分域隔离，支持按组件快速过滤日志、关键词精准检索，异常日志标红高亮；部署全链路操作留痕，SSH 连接、文件传输、脚本执行全记录，审计溯源有据可依。\n3. AI 智能异常诊断，故障自动触发辅助分析 构建、单元测试、部署任意节点执行异常时，系统自动采集全量运行日志，唤起 AI 诊断助手：\n单测场景：自动分析用例失败、报表缺失、资源挂载异常等问题；\n部署场景：自动识别 SSH 连接失败、权限不足、路径错误等部署故障，同步输出整改建议。\n4. 插件化扩展，低成本适配业务迭代 采用插件化节点设计，后续新增小程序、数据服务等新业务组件时，仅需开发对应节点插件，即可复用平台配置、日志、AI 诊断、部署全链路能力，无需重构流水线底层内核；Runner Agent 支持集群横向扩容，轻松承接大并发构建任务。\n五、适配落地场景 前后端分离多模块项目：后端 API + 前端 Web + 自研执行代理类架构项目；\n混合部署环境：物理机 SSH 部署、K8s 容器部署混用的企业研发架构；\n研发流程标准化落地：需要统一管控多组件测试、构建、发布规范；\n中小企业轻量化替代 Jenkins：免去 Jenkins 复杂插件运维、环境搭建成本，开箱即用落地 DevOps。\n结语 Ease-Ops CICD 流水线立足企业真实研发场景，以落地实用性为第一设计目标，依托 DAG 并行调度、结构化日志、AI 智能排错三大核心能力，打破传统 CI 工具低效、难维护、排错慢的痛点。从代码提交触发构建、单元测试缺陷拦截、多组件并行交付，到故障 AI 智能定位，一站式完成研发全链路自动化闭环，真正让 DevOps 落地转化为看得见的效率与成本收益。\n演示地址：https://devops.itart.cn\n","permalink":"/blogs/2026/ease-ops/ease-ops-flows.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e依托项目真实上线运行案例（后端 API + 前端 Web + 分布式 Runner Agent 三大组件全链路实测），本文从实战落地、痛点收益、底层原理、产品优势四大维度，全方位介绍自研 CICD 流水线。产品以 DAG 拓扑调度为内核，实现多组件并行构建、全链路可视化日志管控、异常 AI 自动诊断，解决传统 CI/CD 发布低效、排错繁琐、扩展困难等行业通病，让 DevOps 落地看得见、用得上、收益可量化。\u003c/p\u003e","title":"Ease Ops - 新一代 DevOps CICD 流水线.AI智能排错.降本增效"},{"content":"文档说明 本文档面向Web开发初学者，全程无晦涩术语、代码可直接复制运行。你将系统掌握Next.js的核心定位、解决的行业痛点、与传统开发模式的核心差异，从0搭建项目、吃透三大核心渲染模式、完成「调用第三方API+数据库增删改查」的全栈实战，最终掌握企业级最佳实践与适用场景，看完即可独立开发上线完整项目。\n一、什么是Next.js？ Next.js 是由Vercel公司开发、Meta官方推荐的React全栈Web开发框架。\n它把前端页面渲染、后端服务逻辑、路由系统、数据获取、性能优化、部署上线等全流程能力整合到一套代码中，彻底打破了「前端只管页面、后端只管接口」的传统壁垒，让你只用React语法，就能开发出高性能、SEO友好、安全可靠的全栈Web应用。\n简单说：一套React代码，搞定前端+后端，不用再分开写前端项目和后端接口项目。\n二、传统Web开发的核心痛点（Next.js的解决之道） 在Next.js普及之前，Web开发主要分为两种模式，均存在无法规避的核心痛点，这也是Next.js诞生的核心原因。\n2.1 两种传统开发模式的致命痛点 传统开发模式 核心特点 无法解决的痛点 传统服务端渲染（PHP/JSP/Java模板） 页面在服务端生成HTML返回给浏览器，前后端代码高度耦合 1. 前后端强绑定，前端改页面需要后端配合，开发效率极低；\n2. 页面跳转全量刷新，用户体验差；\n3. 无法使用现代React/Vue前端生态，交互能力弱 前后端分离（React SPA + 独立后端API） 前端单独写单页应用，通过fetch/axios调用后端接口，前后端完全分离 1. 首屏白屏严重：需要先下载完整JS包，再渲染页面、请求数据，低端机/弱网体验极差；\n2. SEO天生残疾：页面内容由JS动态渲染，搜索引擎爬虫无法抓取有效内容；\n3. 开发成本高：一个简单的用户新增功能，需要前端写页面、后端写接口、双方联调、处理跨域/错误/loading，代码量翻倍；\n4. 安全风险高：前端无法直接操作数据库，所有数据操作依赖接口，接口多了极易出现权限遗漏、数据越权问题；\n5. 运维复杂：前端部署CDN、后端部署服务器，需要配置跨域、HTTPS、缓存，出问题需要两端排查 2.2 Next.js 如何一次性解决所有痛点？ 针对以上痛点，Next.js给出了一站式解决方案，核心能力如下：\n多渲染模式自由切换：同时支持SSR（服务端渲染）、SSG（静态生成）、ISR（增量静态更新）、CSR（客户端渲染），既解决了SPA的白屏\u0026amp;SEO问题，又保留了现代前端的丝滑交互体验；\nServer Actions 全栈能力：无需单独写API接口，直接在React组件中编写服务端函数，即可安全操作数据库、调用私密接口，彻底告别「接口联调地狱」；\n文件式路由系统：文件夹结构=页面路由，无需手动配置路由规则，零配置实现嵌套路由、动态路由、权限路由；\n内置全自动性能优化：图片自动压缩/懒加载、代码自动分割、路由预加载、字体优化，新手也能写出高性能页面；\n服务端代码天然隔离：服务端逻辑永远不会发送到浏览器，数据库密码、API密钥等敏感信息100%安全；\n一体化部署：一套代码一键部署，无需分开维护前后端服务，彻底解决跨域、版本不同步问题。\n三、Next.js 与传统Web开发的核心优势对比 对比维度 传统前后端分离 传统PHP/JSP服务端渲染 Next.js 全栈框架 首屏加载速度 慢，白屏时间长 较快，跳转全量刷新 极快，服务端返回完整HTML，跳转无刷新 SEO友好度 差，需额外做预渲染改造 良好，内容直接返回 优秀，天然支持所有搜索引擎抓取 开发效率 低，需写接口、联调、处理跨域 低，前后端耦合，改造成本高 极高，一套代码搞定前后端，零接口联调 数据安全性 依赖接口权限校验，易出现漏洞 较好，逻辑在服务端 优秀，服务端代码物理隔离，内置CSRF防护 交互体验 优秀，无刷新跳转 差，页面全量刷新 优秀，内置路由预加载，原生级交互体验 性能优化门槛 高，需手动配置代码分割、图片优化等 低，优化能力有限 极低，框架内置全自动优化，开箱即用 部署运维成本 高，前后端分开部署、配置 中，需配置服务端环境 极低，一键部署，一体化运维 无JS兼容性 完全不可用，页面白屏 可用，交互能力弱 可用，内容正常展示，表单可正常提交 四、快速入门：5分钟从0搭建第一个Next.js项目 4.1 环境准备 仅需安装 Node.js 18.17及以上版本（官网下载LTS版本，一路默认安装即可），安装完成后在终端执行以下命令，能输出版本号即安装成功：\nnode -v 4.2 创建项目 打开终端，进入你想存放项目的文件夹，执行以下创建命令：\nnpx create-next-app@latest my-first-next-app 执行后会出现配置选项，新手一路按回车选择默认配置即可，默认配置包含：TypeScript、ESLint、Tailwind CSS、App Router（最新路由系统）。\n4.3 启动项目 创建完成后，依次执行以下命令进入项目、启动开发服务器：\n# 进入项目文件夹 cd my-first-next-app # 启动开发服务器 npm run dev 启动成功后，打开浏览器访问 http://localhost:3000，看到Next.js欢迎页面，即项目搭建成功！\n4.4 新手必懂的核心项目结构 my-first-next-app/ ├── app/ 【核心】路由文件夹，文件结构=页面路由 │ ├── page.tsx 首页，对应访问路径 / │ ├── layout.tsx 全局布局文件，所有页面共用 │ └── about/ 新建about文件夹，对应路由 /about │ └── page.tsx 关于页面，对应访问路径 /about ├── public/ 静态资源文件夹，存放图片、图标等 ├── lib/ 工具类文件夹，存放数据库连接、工具函数等（需手动创建） └── package.json 项目依赖配置文件 核心规则：app 文件夹下，每一个 page.tsx 文件，都会自动生成一个对应路径的页面，无需手动配置路由，路由分为三类：\n基础规则： app/ 文件夹内部的层级结构 = 网址 URL只有创建了 page.tsx，这个路径才能被访问\n固定路由： 文件夹名不带 [] = 写死的固定网址\napp/about/page.tsx → 访问 /about app/blog/page.tsx → 访问 /blog 动态路由： 文件夹名带 [] = 可变参数的动态网址\napp/blog/[slug]/page.tsx → 访问 /blog/1、/blog/abc、/blog/任意值 代码目录和路由关系：\n你的项目目录 → 浏览器访问地址 └── app/ ├── page.tsx → localhost:3000/ (首页) ├── about/ │ └── page.tsx → localhost:3000/about (固定路由) └── blog/ ├── page.tsx → localhost:3000/blog (固定路由) └── [id]/ └── page.tsx → localhost:3000/blog/123 (动态路由) 五、Next.js 四大核心渲染模式详解（含代码示例） 渲染模式是Next.js的核心灵魂，它决定了页面何时生成、数据何时获取，直接影响页面性能、SEO和服务器压力。Next.js App Router 原生支持四大核心渲染模式（SSR、SSG、ISR、CSR），无需复杂配置，几行代码即可切换，所有示例均基于公开的文章API，可直接复制运行。\n5.1 SSG（Static Site Generation 静态站点生成） 核心定义 SSG是Next.js默认的渲染模式，也是性能最优的模式。它会在项目构建阶段（执行npm run build时），提前执行数据获取、渲染生成完整的静态HTML文件，部署后所有用户访问都直接返回这个预先生成的静态文件，无需服务端重复执行代码、查询接口/数据库。\n特点：\nbuild 时一次性生成 HTML 部署后内容不会变 最快、最利于 SEO 适用场景 不常更新的静态内容页面：企业官网、个人博客、帮助文档、营销落地页、静态新闻列表。\n核心优势 访问速度极快：静态文件可直接托管在CDN，用户打开秒开；\n零服务器运行压力：无需每次请求执行服务端逻辑，高并发无压力；\n极致SEO友好：完整HTML内容直接被搜索引擎抓取；\n稳定性极强：无服务端代码执行，不会出现接口超时等运行时错误。\n完整代码示例 新建文件 app/ssg-posts/page.tsx，写入以下代码：\n// app/ssg-posts/page.tsx 对应访问路径 /ssg-posts // 无任何强制动态配置，Next.js默认使用SSG静态生成 interface Post { userId: number; id: number; title: string; body: string; } // 构建时执行数据获取，生成静态页面 async function getStaticPosts(): Promise\u0026lt;Post[]\u0026gt; { // fetch默认开启强制缓存，构建时拉取数据后永久缓存 const res = await fetch(\u0026#39;https://jsonplaceholder.typicode.com/posts?_limit=10\u0026#39;); if (!res.ok) throw new Error(\u0026#39;数据获取失败\u0026#39;); return res.json(); } // 页面组件 export default async function SSGPostsPage() { // 构建时获取数据，前端访问直接返回预渲染的HTML const posts = await getStaticPosts(); return ( \u0026lt;div className=\u0026#34;max-w-3xl mx-auto p-6\u0026#34;\u0026gt; \u0026lt;h1 className=\u0026#34;text-3xl font-bold mb-8\u0026#34;\u0026gt;SSG静态生成文章列表\u0026lt;/h1\u0026gt; \u0026lt;p className=\u0026#34;mb-6 text-gray-500\u0026#34;\u0026gt;本页面在构建时预渲染，所有用户访问均返回静态HTML\u0026lt;/p\u0026gt; \u0026lt;div className=\u0026#34;space-y-4\u0026#34;\u0026gt; {posts.map((post) =\u0026gt; ( \u0026lt;div key={post.id} className=\u0026#34;border rounded-lg p-4 shadow-sm\u0026#34;\u0026gt; \u0026lt;h2 className=\u0026#34;text-xl font-semibold mb-2\u0026#34;\u0026gt;{post.title}\u0026lt;/h2\u0026gt; \u0026lt;p className=\u0026#34;text-gray-600\u0026#34;\u0026gt;{post.body}\u0026lt;/p\u0026gt; \u0026lt;/div\u0026gt; ))} \u0026lt;/div\u0026gt; \u0026lt;/div\u0026gt; ); } 验证方式 执行 npm run build 打包项目，在打包日志中，该页面会标记为 ○ (Static)，即代表SSG静态生成成功。\n5.2 SSR（Server-Side Rendering 服务端渲染） 核心定义 SSR即动态服务端渲染，用户每次发起页面请求时，服务端都会实时执行数据获取、渲染完整的HTML页面，再返回给浏览器。每次请求都会重新执行代码、拉取最新数据。\n特点：\n每次访问都重新生成 HTML 数据永远最新 性能比 SSG/ISR 差 适用场景 强实时性、强个性化的动态页面：实时数据仪表盘、个人中心、库存实时变动的商品详情页、需要实时权限校验的页面。\n核心优势 数据永远最新：每次请求都拉取实时数据，无缓存延迟；\nSEO友好：完整HTML内容直接返回，搜索引擎可正常抓取；\n个性化能力强：可根据用户请求信息（Cookie、登录态）返回个性化内容；\n首屏性能优秀：无需等待客户端JS下载执行，直接返回渲染好的页面。\n完整代码示例 新建文件 app/ssr-posts/page.tsx，写入以下代码：\n// app/ssr-posts/page.tsx 对应访问路径 /ssr-posts // 强制动态渲染，每次请求都重新执行服务端逻辑 interface Post { userId: number; id: number; title: string; body: string; } // 每次用户请求页面时，都会实时执行该函数拉取最新数据 async function getDynamicPosts(): Promise\u0026lt;Post[]\u0026gt; { // cache: \u0026#39;no-store\u0026#39; 强制不缓存，每次请求都重新调用接口 const res = await fetch(\u0026#39;https://jsonplaceholder.typicode.com/posts?_limit=10\u0026#39;, { cache: \u0026#39;no-store\u0026#39; }); if (!res.ok) throw new Error(\u0026#39;数据获取失败\u0026#39;); return res.json(); } // 页面组件 export default async function SSRPostsPage() { // 每次请求都实时获取最新数据 const posts = await getDynamicPosts(); // 可获取当前请求时间，验证每次刷新都会更新 const requestTime = new Date().toLocaleString(); return ( \u0026lt;div className=\u0026#34;max-w-3xl mx-auto p-6\u0026#34;\u0026gt; \u0026lt;h1 className=\u0026#34;text-3xl font-bold mb-4\u0026#34;\u0026gt;SSR服务端渲染文章列表\u0026lt;/h1\u0026gt; \u0026lt;p className=\u0026#34;mb-6 text-gray-500\u0026#34;\u0026gt;本页面每次刷新都会重新渲染，当前请求时间：{requestTime}\u0026lt;/p\u0026gt; \u0026lt;div className=\u0026#34;space-y-4\u0026#34;\u0026gt; {posts.map((post) =\u0026gt; ( \u0026lt;div key={post.id} className=\u0026#34;border rounded-lg p-4 shadow-sm\u0026#34;\u0026gt; \u0026lt;h2 className=\u0026#34;text-xl font-semibold mb-2\u0026#34;\u0026gt;{post.title}\u0026lt;/h2\u0026gt; \u0026lt;p className=\u0026#34;text-gray-600\u0026#34;\u0026gt;{post.body}\u0026lt;/p\u0026gt; \u0026lt;/div\u0026gt; ))} \u0026lt;/div\u0026gt; \u0026lt;/div\u0026gt; ); } 验证方式 执行 npm run build 打包项目，在打包日志中，该页面会标记为 λ (Dynamic)，即代表SSR动态渲染；\n启动生产服务 npm run start，访问页面后多次刷新，可看到页面上的请求时间每次都会更新，验证每次请求都重新渲染。\n5.3 ISR（Incremental Static Regeneration 增量静态再生成） 核心定义 ISR是Next.js的王牌功能，完美结合了SSG的极致性能和SSR的实时性优势。它在构建时预生成静态页面，部署后可按照你设定的时间间隔，在后台自动重新拉取数据、渲染更新静态页面，无需重新构建、重新部署项目。\n简单说：静态页面的访问速度，同时支持数据自动定期更新。\n特点：\n先 SSG，定时自动刷新 访问快 + 数据能更新 用 revalidate 控制刷新时间 适用场景 需要定期更新、但无需实时的页面：新闻资讯列表、电商商品列表、博客文章、论坛帖子列表，访问量高但更新频率不高的内容。\n核心优势 兼顾速度与新鲜度：既有SSG的静态访问速度，又能定期更新数据；\n极低的服务器压力：无论多少用户访问，仅在设定的间隔内执行一次数据更新；\n无需重新部署：内容更新无需重新打包构建，后台自动完成；\n容错能力强：即使更新时接口出错，仍会返回之前的静态页面，不会影响用户访问。\n完整代码示例 新建文件 app/isr-posts/page.tsx，写入以下代码：\n// app/isr-posts/page.tsx 对应访问路径 /isr-posts // 增量静态再生成，设置60秒重新验证更新一次数据 interface Post { userId: number; id: number; title: string; body: string; } // 设定页面缓存有效期，单位：秒 // 60秒内的所有访问，都返回缓存的静态页面；60秒后首次访问，后台自动更新页面 export const revalidate = 60; // 构建时预执行，后续每60秒自动重新执行更新数据 async function getISRPosts(): Promise\u0026lt;Post[]\u0026gt; { const res = await fetch(\u0026#39;https://jsonplaceholder.typicode.com/posts?_limit=10\u0026#39;); if (!res.ok) throw new Error(\u0026#39;数据获取失败\u0026#39;); return res.json(); } // 页面组件 export default async function ISRPostsPage() { const posts = await getISRPosts(); // 页面生成时间，验证缓存更新 const generateTime = new Date().toLocaleString(); return ( \u0026lt;div className=\u0026#34;max-w-3xl mx-auto p-6\u0026#34;\u0026gt; \u0026lt;h1 className=\u0026#34;text-3xl font-bold mb-4\u0026#34;\u0026gt;ISR增量静态更新文章列表\u0026lt;/h1\u0026gt; \u0026lt;p className=\u0026#34;mb-6 text-gray-500\u0026#34;\u0026gt;本页面每60秒自动更新一次，当前页面生成时间：{generateTime}\u0026lt;/p\u0026gt; \u0026lt;div className=\u0026#34;space-y-4\u0026#34;\u0026gt; {posts.map((post) =\u0026gt; ( \u0026lt;div key={post.id} className=\u0026#34;border rounded-lg p-4 shadow-sm\u0026#34;\u0026gt; \u0026lt;h2 className=\u0026#34;text-xl font-semibold mb-2\u0026#34;\u0026gt;{post.title}\u0026lt;/h2\u0026gt; \u0026lt;p className=\u0026#34;text-gray-600\u0026#34;\u0026gt;{post.body}\u0026lt;/p\u0026gt; \u0026lt;/div\u0026gt; ))} \u0026lt;/div\u0026gt; \u0026lt;/div\u0026gt; ); } 验证方式 执行 npm run build 打包项目，在打包日志中，该页面会标记为 ● (ISR)，即代表增量静态更新配置成功；\n启动生产服务 npm run start，首次访问页面记录生成时间，后续60秒内刷新，时间不会变化（返回缓存静态页）；60秒后再次刷新，页面会更新为最新的生成时间，验证后台自动更新生效。\n5.4 CSR（Client-Side Rendering 客户端渲染） 核心定义 CSR即客户端渲染，是传统React SPA的核心渲染模式。服务端仅返回一个空的HTML模板（包含JS引用），页面渲染、数据获取等逻辑全部在浏览器端（客户端）执行，通过JS动态生成页面内容并插入到HTML中，完成页面展示。\n简单说：服务端只给“空壳”，浏览器自己加载JS、获取数据、渲染页面，也是Next.js中需手动开启的渲染模式（标记'use client'）。\n特点：\n纯前端渲染，首屏无内容 数据在浏览器里请求 不利于 SEO 无缓存 适用场景 强交互、无SEO需求、数据频繁变动的页面：后台管理系统、用户个人中心（非公开内容）、在线编辑器、社交应用动态 feed、游戏类Web应用。\n核心优势 交互体验极致流畅：页面渲染和数据更新都在客户端完成，无需请求服务端，跳转、操作无延迟；\n减轻服务端压力：服务端仅返回静态模板，无需执行渲染和数据查询逻辑，高并发场景下优势明显；\n动态交互能力强：支持复杂的用户交互（如拖拽、实时输入反馈、弹窗联动），适配需要大量JS交互的场景；\n开发灵活：完全沿用传统React开发模式，熟悉React的开发者可快速上手，无需额外学习服务端渲染逻辑。\n完整代码示例 新建文件 app/csr-posts/page.tsx，写入以下代码（明确标记客户端渲染，适配复杂交互场景）：\n// app/csr-posts/page.tsx 对应访问路径 /csr-posts \u0026#39;use client\u0026#39;; // 标记为客户端组件，强制开启CSR客户端渲染 import { useState, useEffect } from \u0026#39;react\u0026#39;; interface Post { userId: number; id: number; title: string; body: string; } export default function CSRPostsPage() { // 客户端维护状态，用于交互和数据展示 const [posts, setPosts] = useState\u0026lt;Post[]\u0026gt;([]); const [loading, setLoading] = useState(true); const [searchKey, setSearchKey] = useState(\u0026#39;\u0026#39;); // 客户端交互状态（搜索） // 客户端数据获取，在浏览器端执行 const fetchPosts = async () =\u0026gt; { setLoading(true); try { // 客户端请求API，可根据交互状态（如搜索关键词）动态调整请求参数 const res = await fetch(`https://jsonplaceholder.typicode.com/posts?q=${searchKey}`); if (!res.ok) throw new Error(\u0026#39;数据获取失败\u0026#39;); const data = await res.json(); setPosts(data.slice(0, 10)); // 截取前10条数据 } catch (err) { console.error(\u0026#39;客户端请求失败\u0026#39;, err); } finally { setLoading(false); } }; // 组件挂载时获取初始数据，搜索关键词变化时重新获取数据 useEffect(() =\u0026gt; { fetchPosts(); }, [searchKey]); return ( \u0026lt;div className=\u0026#34;max-w-3xl mx-auto p-6\u0026#34;\u0026gt; \u0026lt;h1 className=\u0026#34;text-3xl font-bold mb-8\u0026#34;\u0026gt;CSR客户端渲染文章列表\u0026lt;/h1\u0026gt; \u0026lt;p className=\u0026#34;mb-6 text-gray-500\u0026#34;\u0026gt;本页面在浏览器端渲染，数据获取和页面更新均在客户端完成\u0026lt;/p\u0026gt; // 客户端交互组件（搜索框），体现CSR交互优势 \u0026lt;div className=\u0026#34;mb-6\u0026#34;\u0026gt; \u0026lt;input type=\u0026#34;text\u0026#34; placeholder=\u0026#34;输入关键词搜索文章...\u0026#34; value={searchKey} onChange={(e) =\u0026gt; setSearchKey(e.target.value)} className=\u0026#34;w-full px-4 py-2 border rounded-lg shadow-sm\u0026#34; /\u0026gt; \u0026lt;/div\u0026gt; {loading ? ( \u0026lt;div className=\u0026#34;p-6 text-center\u0026#34;\u0026gt;加载中...\u0026lt;/div\u0026gt; ) : ( \u0026lt;div className=\u0026#34;space-y-4\u0026#34;\u0026gt; {posts.map((post) =\u0026gt; ( \u0026lt;div key={post.id} className=\u0026#34;border rounded-lg p-4 shadow-sm\u0026#34;\u0026gt; \u0026lt;h2 className=\u0026#34;text-xl font-semibold mb-2\u0026#34;\u0026gt;{post.title}\u0026lt;/h2\u0026gt; \u0026lt;p className=\u0026#34;text-gray-600\u0026#34;\u0026gt;{post.body.substring(0, 100)}...\u0026lt;/p\u0026gt; \u0026lt;/div\u0026gt; ))} \u0026lt;/div\u0026gt; )} \u0026lt;/div\u0026gt; ); } 验证方式 执行 npm run dev 启动开发服务，访问 http://localhost:3000/csr-posts，可看到页面先显示“加载中”，随后渲染内容（验证客户端渲染流程）；\n打开浏览器“开发者工具”，切换到「Network」面板，刷新页面，可看到服务端仅返回 csr-posts 相关的HTML和JS文件，数据请求（fetch）是在客户端发起的；\n在搜索框输入关键词（如“test”），页面会实时重新请求数据并更新，无需刷新页面，验证客户端交互与动态渲染能力。\n六、核心实战：2个必学示例（调用第三方API + 数据库增删改查） 以下示例代码均可直接复制运行，全程基于Next.js最新的App Router和Server Components，符合企业级开发规范。\n示例1：调用第三方API（2种常用方式，新手必懂） 我们以公开的「文章数据API」为例，地址：https://jsonplaceholder.typicode.com/posts，无需申请密钥，可直接调用。\nNext.js中调用API分为服务端调用和客户端调用，优先推荐服务端调用，性能更好、SEO更友好、无跨域问题。\n方式1：服务端组件调用（推荐，90%场景首选） Next.js中，没有加 'use client' 标记的组件，默认都是服务端组件，代码只在服务端运行，可直接用 async/await 调用API，无需useEffect、无需处理loading状态。\n新建文件 app/posts/page.tsx，写入以下代码：\n// app/posts/page.tsx 对应访问路径 /posts // 无\u0026#39;use client\u0026#39;，默认是服务端组件，代码只在服务端运行 // 定义接口返回数据类型 interface Post { id: number; title: string; body: string; } // 服务端调用第三方API async function getPosts(): Promise\u0026lt;Post[]\u0026gt; { // 调用第三方API，Next.js默认会缓存结果，避免重复请求 const res = await fetch(\u0026#39;https://jsonplaceholder.typicode.com/posts?_limit=10\u0026#39;); if (!res.ok) throw new Error(\u0026#39;接口请求失败\u0026#39;); return res.json(); } // 页面组件，直接async/await获取数据 export default async function PostsPage() { // 直接在组件中获取数据，服务端执行，前端看不到接口调用逻辑 const posts = await getPosts(); return ( \u0026lt;div className=\u0026#34;max-w-3xl mx-auto p-6\u0026#34;\u0026gt; \u0026lt;h1 className=\u0026#34;text-3xl font-bold mb-8\u0026#34;\u0026gt;第三方API文章列表\u0026lt;/h1\u0026gt; \u0026lt;div className=\u0026#34;space-y-4\u0026#34;\u0026gt; {posts.map((post) =\u0026gt; ( \u0026lt;div key={post.id} className=\u0026#34;border rounded-lg p-4 shadow-sm\u0026#34;\u0026gt; \u0026lt;h2 className=\u0026#34;text-xl font-semibold mb-2\u0026#34;\u0026gt;{post.title}\u0026lt;/h2\u0026gt; \u0026lt;p className=\u0026#34;text-gray-600\u0026#34;\u0026gt;{post.body}\u0026lt;/p\u0026gt; \u0026lt;/div\u0026gt; ))} \u0026lt;/div\u0026gt; \u0026lt;/div\u0026gt; ); } 保存后，访问 http://localhost:3000/posts，即可看到渲染好的文章列表。\n核心优势：\n页面打开直接显示内容，无白屏、无loading等待； 搜索引擎直接抓取到完整内容，SEO拉满； 接口调用在服务端完成，前端看不到接口地址，无跨域问题； Next.js默认缓存接口结果，重复访问不会重复调用第三方API。 方式2：客户端组件调用（仅用于需要实时交互的场景） 如果你的页面需要按钮点击、实时输入等用户交互，需要使用客户端组件，加 'use client' 标记，用法和传统React一致。\n新建文件 app/client-posts/page.tsx，写入以下代码：\n// app/client-posts/page.tsx 对应访问路径 /client-posts \u0026#39;use client\u0026#39;; // 标记为客户端组件，代码会发送到浏览器 import { useEffect, useState } from \u0026#39;react\u0026#39;; interface Post { id: number; title: string; body: string; } export default function ClientPostsPage() { const [posts, setPosts] = useState\u0026lt;Post[]\u0026gt;([]); const [loading, setLoading] = useState(true); // 客户端调用API，和传统React用法一致 useEffect(() =\u0026gt; { const fetchPosts = async () =\u0026gt; { try { const res = await fetch(\u0026#39;https://jsonplaceholder.typicode.com/posts?_limit=10\u0026#39;); const data = await res.json(); setPosts(data); } catch (err) { console.error(\u0026#39;请求失败\u0026#39;, err); } finally { setLoading(false); } }; fetchPosts(); }, []); if (loading) return \u0026lt;div className=\u0026#34;p-6\u0026#34;\u0026gt;加载中...\u0026lt;/div\u0026gt;; return ( \u0026lt;div className=\u0026#34;max-w-3xl mx-auto p-6\u0026#34;\u0026gt; \u0026lt;h1 className=\u0026#34;text-3xl font-bold mb-8\u0026#34;\u0026gt;客户端调用API文章列表\u0026lt;/h1\u0026gt; \u0026lt;div className=\u0026#34;space-y-4\u0026#34;\u0026gt; {posts.map((post) =\u0026gt; ( \u0026lt;div key={post.id} className=\u0026#34;border rounded-lg p-4 shadow-sm\u0026#34;\u0026gt; \u0026lt;h2 className=\u0026#34;text-xl font-semibold mb-2\u0026#34;\u0026gt;{post.title}\u0026lt;/h2\u0026gt; \u0026lt;p className=\u0026#34;text-gray-600\u0026#34;\u0026gt;{post.body}\u0026lt;/p\u0026gt; \u0026lt;/div\u0026gt; ))} \u0026lt;/div\u0026gt; \u0026lt;/div\u0026gt; ); } 示例2：连接数据库，实现完整增删改查（CRUD） 我们使用SQLite作为数据库，无需安装任何数据库服务、无需配置账号密码，开箱即用，新手零门槛。搭配Next.js的Server Actions，无需写任何API接口，即可安全实现数据库增删改查。\n步骤1：安装依赖 在项目终端执行以下命令，安装数据库依赖：\nnpm install better-sqlite3 # 类型声明，TypeScript项目需要 npm install -D @types/better-sqlite3 步骤2：创建数据库连接工具类 新建 lib/db.ts 文件，写入以下代码，实现数据库连接和表初始化：\n// lib/db.ts import Database from \u0026#39;better-sqlite3\u0026#39;; // 连接数据库，自动创建db.sqlite3文件，无需手动创建 const db = new Database(\u0026#39;db.sqlite3\u0026#39;); // 初始化用户表，第一次运行自动创建，后续运行不会重复创建 db.exec(` CREATE TABLE IF NOT EXISTS users ( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL UNIQUE, create_time DATETIME DEFAULT CURRENT_TIMESTAMP ) `); export default db; 步骤3：创建Server Actions，实现增删改查逻辑 新建 app/users/actions.ts 文件，写入以下代码，所有函数都标记为服务端操作，代码只在服务端运行，绝对不会暴露给前端：\n// app/users/actions.ts \u0026#39;use server\u0026#39;; // 标记整个文件的函数都是Server Actions，只在服务端运行 import db from \u0026#39;@/lib/db\u0026#39;; import { revalidatePath } from \u0026#39;next/cache\u0026#39;; // 1. 新增用户 export async function addUser(formData: FormData) { // 从表单中获取数据 const name = formData.get(\u0026#39;name\u0026#39;) as string; const email = formData.get(\u0026#39;email\u0026#39;) as string; if (!name || !email) throw new Error(\u0026#39;姓名和邮箱不能为空\u0026#39;); try { // 执行数据库插入操作 db.prepare(\u0026#39;INSERT INTO users (name, email) VALUES (?, ?)\u0026#39;).run(name, email); // 刷新页面数据，让用户看到最新的列表 revalidatePath(\u0026#39;/users\u0026#39;); return { success: true, message: \u0026#39;用户添加成功\u0026#39; }; } catch (err) { console.error(\u0026#39;添加用户失败\u0026#39;, err); return { success: false, message: \u0026#39;邮箱已存在，添加失败\u0026#39; }; } } // 2. 删除用户 export async function deleteUser(id: number) { try { db.prepare(\u0026#39;DELETE FROM users WHERE id = ?\u0026#39;).run(id); revalidatePath(\u0026#39;/users\u0026#39;); return { success: true }; } catch (err) { console.error(\u0026#39;删除用户失败\u0026#39;, err); return { success: false, message: \u0026#39;删除失败\u0026#39; }; } } // 3. 修改用户 export async function updateUser(formData: FormData) { const id = Number(formData.get(\u0026#39;id\u0026#39;)); const name = formData.get(\u0026#39;name\u0026#39;) as string; if (!id || !name) throw new Error(\u0026#39;参数错误\u0026#39;); try { db.prepare(\u0026#39;UPDATE users SET name = ? WHERE id = ?\u0026#39;).run(name, id); revalidatePath(\u0026#39;/users\u0026#39;); return { success: true, message: \u0026#39;修改成功\u0026#39; }; } catch (err) { console.error(\u0026#39;修改用户失败\u0026#39;, err); return { success: false, message: \u0026#39;修改失败\u0026#39; }; } } // 4. 查询用户列表 export function getUsers() { return db.prepare(\u0026#39;SELECT * FROM users ORDER BY create_time DESC\u0026#39;).all(); } 步骤4：创建页面，实现完整的用户管理功能 新建 app/users/page.tsx 文件，写入以下代码，实现表单提交、用户列表展示、修改和删除功能：\n// app/users/page.tsx 对应访问路径 /users import { addUser, deleteUser, getUsers, updateUser } from \u0026#39;./actions\u0026#39;; export default function UsersPage() { // 服务端直接查询数据库，前端看不到任何数据库逻辑 const users = getUsers(); return ( \u0026lt;div className=\u0026#34;max-w-4xl mx-auto p-6\u0026#34;\u0026gt; \u0026lt;h1 className=\u0026#34;text-3xl font-bold mb-8\u0026#34;\u0026gt;用户管理系统（数据库增删改查）\u0026lt;/h1\u0026gt; {/* 新增用户表单，直接绑定Server Action，无需写onSubmit、无需写fetch */} \u0026lt;form action={addUser} className=\u0026#34;flex gap-3 mb-10 p-4 border rounded-lg shadow-sm\u0026#34;\u0026gt; \u0026lt;input type=\u0026#34;text\u0026#34; name=\u0026#34;name\u0026#34; placeholder=\u0026#34;请输入姓名\u0026#34; className=\u0026#34;flex-1 px-3 py-2 border rounded\u0026#34; required /\u0026gt; \u0026lt;input type=\u0026#34;email\u0026#34; name=\u0026#34;email\u0026#34; placeholder=\u0026#34;请输入邮箱\u0026#34; className=\u0026#34;flex-1 px-3 py-2 border rounded\u0026#34; required /\u0026gt; \u0026lt;button type=\u0026#34;submit\u0026#34; className=\u0026#34;px-6 py-2 bg-blue-500 text-white rounded hover:bg-blue-600\u0026#34; \u0026gt; 添加用户 \u0026lt;/button\u0026gt; \u0026lt;/form\u0026gt; {/* 用户列表 */} \u0026lt;div className=\u0026#34;border rounded-lg overflow-hidden\u0026#34;\u0026gt; \u0026lt;table className=\u0026#34;w-full\u0026#34;\u0026gt; \u0026lt;thead className=\u0026#34;bg-gray-50 border-b\u0026#34;\u0026gt; \u0026lt;tr\u0026gt; \u0026lt;th className=\u0026#34;px-4 py-3 text-left\u0026#34;\u0026gt;ID\u0026lt;/th\u0026gt; \u0026lt;th className=\u0026#34;px-4 py-3 text-left\u0026#34;\u0026gt;姓名\u0026lt;/th\u0026gt; \u0026lt;th className=\u0026#34;px-4 py-3 text-left\u0026#34;\u0026gt;邮箱\u0026lt;/th\u0026gt; \u0026lt;th className=\u0026#34;px-4 py-3 text-left\u0026#34;\u0026gt;创建时间\u0026lt;/th\u0026gt; \u0026lt;th className=\u0026#34;px-4 py-3 text-center\u0026#34;\u0026gt;操作\u0026lt;/th\u0026gt; \u0026lt;/tr\u0026gt; \u0026lt;/thead\u0026gt; \u0026lt;tbody className=\u0026#34;divide-y\u0026#34;\u0026gt; {users.length === 0 ? ( \u0026lt;tr\u0026gt; \u0026lt;td colSpan={5} className=\u0026#34;px-4 py-8 text-center text-gray-500\u0026#34;\u0026gt; 暂无用户数据，请添加用户 \u0026lt;/td\u0026gt; \u0026lt;/tr\u0026gt; ) : ( users.map((user: any) =\u0026gt; ( \u0026lt;tr key={user.id}\u0026gt; \u0026lt;td className=\u0026#34;px-4 py-3\u0026#34;\u0026gt;{user.id}\u0026lt;/td\u0026gt; \u0026lt;td className=\u0026#34;px-4 py-3\u0026#34;\u0026gt;{user.name}\u0026lt;/td\u0026gt; \u0026lt;td className=\u0026#34;px-4 py-3\u0026#34;\u0026gt;{user.email}\u0026lt;/td\u0026gt; \u0026lt;td className=\u0026#34;px-4 py-3\u0026#34;\u0026gt;{user.create_time}\u0026lt;/td\u0026gt; \u0026lt;td className=\u0026#34;px-4 py-3 flex justify-center gap-2\u0026#34;\u0026gt; {/* 修改用户表单 */} \u0026lt;form action={updateUser} className=\u0026#34;inline\u0026#34;\u0026gt; \u0026lt;input type=\u0026#34;hidden\u0026#34; name=\u0026#34;id\u0026#34; value={user.id} /\u0026gt; \u0026lt;input type=\u0026#34;text\u0026#34; name=\u0026#34;name\u0026#34; placeholder=\u0026#34;新姓名\u0026#34; className=\u0026#34;w-24 px-2 py-1 border rounded\u0026#34; required /\u0026gt; \u0026lt;button type=\u0026#34;submit\u0026#34; className=\u0026#34;ml-1 px-3 py-1 bg-green-500 text-white rounded hover:bg-green-600\u0026#34; \u0026gt; 修改 \u0026lt;/button\u0026gt; \u0026lt;/form\u0026gt; {/* 删除用户表单 */} \u0026lt;form action={deleteUser.bind(null, user.id)} className=\u0026#34;inline\u0026#34;\u0026gt; \u0026lt;button type=\u0026#34;submit\u0026#34; className=\u0026#34;px-3 py-1 bg-red-500 text-white rounded hover:bg-red-600\u0026#34; \u0026gt; 删除 \u0026lt;/button\u0026gt; \u0026lt;/form\u0026gt; \u0026lt;/td\u0026gt; \u0026lt;/tr\u0026gt; )) )} \u0026lt;/tbody\u0026gt; \u0026lt;/table\u0026gt; \u0026lt;/div\u0026gt; \u0026lt;/div\u0026gt; ); } 步骤5：运行效果 保存所有代码后，访问 http://localhost:3000/users，你即可实现：\n表单提交添加用户，直接写入数据库； 实时展示数据库中的用户列表； 一键修改用户姓名，更新数据库； 一键删除用户，同步数据库； 所有操作无刷新、无需写任何API接口、数据库逻辑100%安全，不会暴露给前端。 七、Next.js 企业级开发最佳实践（新手照做不踩坑） 7.1 渲染模式选择最佳实践 能静态就静态：官网、博客、文档等不常更新的页面，优先使用SSG静态生成，零服务器压力、访问速度最快； 动态内容加缓存：商品列表、新闻等需要定期更新的页面，使用ISR增量静态更新，设置 revalidate = 60（缓存60秒），既保证数据新鲜度，又避免频繁查询数据库； 仅实时场景用纯SSR：只有后台实时数据、个人中心等强个性化、强实时性的页面，才使用 cache: 'no-store' 强制不缓存，避免滥用导致服务器压力过大； 客户端组件最小化：只有需要用户交互（按钮点击、输入框、状态管理）的组件，才加 'use client' 标记，其余全部用服务端组件，保证性能和安全。 7.2 安全开发最佳实践 永远不要在客户端组件中写数据库连接、密钥等敏感信息，所有敏感操作必须放在Server Actions或服务端组件中； 环境变量规范：只有需要暴露给前端的变量，才以 NEXT_PUBLIC_ 开头，数据库密码、API密钥等敏感变量，绝对不能加此前缀； Server Actions 必须做参数校验：所有用户提交的数据，必须做格式校验、权限校验，不能直接写入数据库； 禁止在客户端组件中内联Server Actions，客户端组件必须导入单独文件的Server Actions，避免代码泄露。 7.3 性能优化最佳实践 使用内置的Image组件：所有图片都用 next/image，自动实现压缩、懒加载、自适应，避免图片导致的性能问题； 使用内置的Font组件：用 next/font 加载字体，避免字体闪烁、加载慢的问题； 路由预加载：用 next/link 做页面跳转，Next.js会自动预加载目标页面，实现秒开跳转； 避免大体积客户端组件：大的交互组件，使用动态导入 dynamic(() =\u0026gt; import('./xxx'))，实现按需加载，减少首屏JS体积。 7.4 部署最佳实践 优先选择Vercel部署：Next.js官方出品，一键部署、零配置、自动扩容，免费额度足够个人项目和小型企业项目使用； 自有服务器部署：可使用Docker打包部署，或执行 npm run build 打包后，用 npm run start 启动生产服务； 生产环境必须关闭开发模式，避免源码泄露和性能问题。 八、Next.js 适用场景 \u0026amp; 不适用场景 8.1 强烈推荐使用的场景 企业官网、品牌官网、营销落地页：SEO友好、首屏秒开、部署简单，完美匹配需求； 博客、文档站、内容门户、新闻站点：SSG+ISR组合，既保证访问速度，又能轻松更新内容； 电子商务平台、商城站点：SSR+ISR兼顾SEO和实时价格/库存更新，Server Actions安全处理订单逻辑； SaaS应用、后台管理系统、仪表盘：全栈一体化开发，一套代码搞定页面和后端逻辑，开发效率翻倍； AI应用、工具类网站：服务端安全调用AI API，避免密钥泄露，同时保证前端交互体验； 移动端优先的Web应用、PWA：内置性能优化，弱网环境体验远超传统SPA。 8.2 不推荐使用的场景 纯静态无动态内容的单页：比如只有1-2个页面的纯静态介绍页，可选择更轻量的Astro、VitePress； 已有成熟超大型微服务后端体系：不建议用Next.js替代后端，可作为前端渲染层，调用现有微服务接口； 非React技术栈项目：Next.js基于React，Vue/Angular技术栈建议选择对应框架（Nuxt、Analog）。 九、总结 核心总结 Next.js 彻底重构了现代Web开发的流程，它不是简单的React框架，而是一套完整的全栈开发解决方案：\n它解决了传统前后端分离的SEO、首屏性能、开发效率痛点； 它保留了现代前端的丝滑交互体验，同时补齐了服务端能力； 它让前端开发者无需学习额外的后端语言，只用React语法，就能开发完整的全栈应用； 它的企业级生态和性能优化能力，让新手也能写出符合生产标准的Web项目。 ","permalink":"/blogs/2026/frontend/react/nextjs-quick-start.html","summary":"\u003ch2 id=\"文档说明\"\u003e文档说明\u003c/h2\u003e\n\u003cp\u003e本文档面向Web开发初学者，全程无晦涩术语、代码可直接复制运行。你将系统掌握Next.js的核心定位、解决的行业痛点、与传统开发模式的核心差异，从0搭建项目、吃透三大核心渲染模式、完成「调用第三方API+数据库增删改查」的全栈实战，最终掌握企业级最佳实践与适用场景，看完即可独立开发上线完整项目。\u003c/p\u003e","title":"Next.js 全栈开发入门指南（2026 最新版）"},{"content":"背景 本文整理自《从 Cloud Code 泄露源码中学到的 14 条提示词黄金法则》视频内容，提炼了 AI 提示词设计的核心准则，涵盖基础规范、沟通原则、操作标准、进阶技巧与架构思维，用于个人学习复盘与实际应用参考。\n第 1-3 条：基础法则 用禁令代替指令\n堵住 AI 犯蠢的路，比教它变聪明更有效。\n使用 never、do not、critical 等禁令词\n专门设唱反调的角色\n任务不是确认能用，而是尽量找出问题。\n预写反驳偷懒借口的话术\n不要画蛇添足\n不加没被要求的东西，不为不可能发生的情况做预防，宁可重复也不要过度抽象\n第 4-6 条：沟通原则 如实汇报，不润色不谦虚\n事情没做好就说没做好，附上具体情况。\n不要加不必要的免责声明，也要防过度谦虚\n活可以分出去，思考不行\n不要外包理解，不能写 “根据调查结果处理”。\n先消化信息，做出判断，再给明确方向\n不知道就说不知道\n不要编造或预测结果。如果有人问进展就说 “还在处理中”，不要瞎猜\n第 7-9 条：操作规范 先看再改，不准凭空编造\n必须先读过文件内容才能去编辑它。没读就改，系统直接报错。让 AI 先复述关键内容再动手改\n一次授权不等于永久授权\n用户批准一次操作，不代表以后同类操作都不用再问了。授权只对当次有效\n每条禁令要写清楚为什么\n不要干巴巴一句 “不准”。\n把原因写上，AI 就知道规则边界在哪儿\n第 10-12 条：进阶技巧 信息按需给，不要一次给全 先告诉 AI 有哪些工具名字，等真要用某个工具时，再加载详细说明。信息太多反而犯迷糊\n沟通规范要细到标点符号 不准废话，能用一句话说完不用三句。先说结论再说理由，倒过来说效果立竿见影\n不同场景加载不同规则 针对不同类型的用户加载不同规则。基础版提示词在需要更严谨场景下，叠加更严格的规则\n第 13-14 条：架构思维 提示词不要堆成一大段，要模块化 分模块组装：角色设定、行为规则、任务要求、语气风格每块独立，按功能分成几块，需要哪块加哪块\n限制工具的使用方式 明确告诉他哪些场景用哪个工具。\n专用工具有操作记录，用户能看到 AI 在干什么\n通用命令行是黑箱\n参考视频：https://www.bilibili.com/video/BV1i9D6BKEjD/?spm_id_from=333.1391.0.0\u0026amp;vd_source=294000af5f851da5511c7f3454c019e9\n","permalink":"/blogs/2026/ai/cloud-code-prompt.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003e本文整理自《从 Cloud Code 泄露源码中学到的 14 条提示词黄金法则》视频内容，提炼了 AI 提示词设计的核心准则，涵盖基础规范、沟通原则、操作标准、进阶技巧与架构思维，用于个人学习复盘与实际应用参考。\u003c/p\u003e","title":"从Cloud Code泄露源码中学到的14条提示词黄金法则（笔记）"},{"content":"背景 Go map 中 特殊标记位的复用 是其设计中最精巧的细节之一。它的核心思想是：将“状态信息”直接存储在原本用于存放“哈希值片段”的内存空间中，从而在不增加额外内存开销的前提下，实现了对桶（Bucket）状态的极速判断。\n以下将从实现原理、核心标记详解、源码片段分析、性能优势四个维度进行深度拆解。\n一、 实现原理：内存空间的“一物两用” 在 Go map 的桶结构体 bmap 中，有一个数组 tophash [8]uint8。\ntype bmap struct { tophash [bucketCnt]uint8 // bucketCnt = 8 // ... keys and values ... } 设计巧思：\n这个数组原本是用来存储键哈希值的高 8 位（Top Hash），用于快速筛选键。但 Go 的设计者发现，哈希值的高 8 位中，0-4 这几个数值很少被自然用到（或者说可以通过算法规避）。\n于是，他们将 0-4 定义为特殊状态标记，只有 \u0026gt;=5 的值才代表真正的哈希高 8 位。\n// 常量定义 emptyRest = 0 // 单元格为空，且后面更高的索引或溢出桶里也没有数据了 emptyOne = 1 // 仅当前单元格为空 evacuatedX = 2 // 键值对有效，但已搬迁到新表的“前半部分” evacuatedY = 3 // 键值对有效，但已搬迁到新表的“后半部分” evacuatedEmpty = 4 // 单元格为空，且整个桶已被搬迁完毕 minTopHash = 5 // 正常哈希高 8 位的最小值（分水岭） 二、 核心标记位详解与源码分析 我们将这些标记分为两类：空槽标记（用于查找和删除）和 搬迁标记（用于扩容）。\n1. 空槽标记：emptyOne 与 emptyRest 这两个标记用于标识桶中的单元格（Cell）是否为空。\nemptyOne (1):\n表示“只有这一个格子是空的”，后面的格子可能还有数据。\nemptyRest (0):\n表示“这个格子是空的，并且从这个格子往后（包括溢出桶），所有格子都是空的”。这是一个强力终止信号。\n源码实战：在 mapaccess （查找）中的应用\n在查找键时，这两个标记能让循环“极早退出”。\nbucketloop: for ; b != nil; b = b.overflow(t) { // 遍历当前桶和溢出桶 for i := uintptr(0); i \u0026lt; bucketCnt; i++ { // 遍历桶内 8 个格子 if b.tophash[i] != top { // 【核心逻辑】如果不匹配，检查是不是 emptyRest if b.tophash[i] == emptyRest { break bucketloop // 直接跳出所有循环，后面肯定没了！ } continue // 如果是 emptyOne，只是跳过当前格子，继续往后找 } // ... 匹配成功，比较 Key ... } } 优势分析：\n如果没有 emptyRest，即使桶里只有第一个格子有数据，后面 7 个全空，你也必须检查完 8 个格子，甚至还要去检查溢出桶指针。有了 emptyRest，只需读到第 2 个格子，程序就知道“后面没货了”，极大减少了无效的内存访问。\n源码实战：在 mapdelete （删除）中的状态转换\n删除操作不仅是把数据清空，还会巧妙地维护这些标记，以优化后续的查找。\n// ... 找到目标位置 i，清空数据 ... b.tophash[i] = emptyOne // 先标记为单个空 // 【核心逻辑】尝试将后面的 emptyOne “升级”为 emptyRest if i == bucketCnt-1 { // 如果是桶里最后一个格子，且溢出桶的开头也是 emptyRest，那可以连起来 if b.overflow(t) != nil \u0026amp;\u0026amp; b.overflow(t).tophash[0] != emptyRest { goto notLast } } else { if b.tophash[i+1] != emptyRest { goto notLast } } // 向前回溯，把能连成片的 emptyOne 都改成 emptyRest for { b.tophash[i] = emptyRest if i == 0 { // ... 处理溢出桶的回退逻辑 ... break } i-- if b.tophash[i] != emptyOne { break // 遇到非单个空的，停止 } } notLast: 图解：\n假设桶里是 [K, E1, E1, E1, ...] (K=数据, E1=emptyOne)。\n删除 K 后，代码会把所有连续的 E1 都改成 E0 (emptyRest)，变成 [E0, E0, E0, E0, ...]。这样下次查找时，直接在第一个位置就终止了。\n2. 搬迁标记：evacuatedX、evacuatedY 与 evacuatedEmpty 这三个标记用于扩容阶段。Go map 是增量扩容的，这些标记用来告诉当前的访问者：“这个数据已经搬走了”或者“这个桶已经处理完了”。\nevacuatedX (2)和 evacuatedY(3):\n表示“这个键值对是有效的，但它已经被复制到新的哈希表中了”。\nX 表示搬到了新桶数组的低地址部分（和旧桶索引一样）。\nY 表示搬到了新桶数组的高地址部分（旧桶索引 + 旧桶数量）。\nevacuatedEmpty (4):\n表示“这个格子是空的，而且整个旧桶都已经被搬迁完毕了，不用再看了”。\n源码实战：判断桶是否已搬迁 ( evacuated )\n这是一个高频调用的辅助函数。\nfunc evacuated(b *bmap) bool { h := b.tophash[0] // 【核心逻辑】只要看第一个格子的 tophash // 如果在 (emptyOne, minTopHash) 这个区间内，说明是 2、3、4，即已搬迁 return h \u0026gt; emptyOne \u0026amp;\u0026amp; h \u0026lt; minTopHash } 源码实战：在 evacuate （搬迁函数）中的应用\n在扩容搬运数据时，会将旧桶的标记位修改为 evacuatedX 或 evacuatedY。\n// 计算这个 Key 应该去新桶的 X 部分还是 Y 部分 var useY uint8 if !h.sameSizeGrow() { hash := t.hasher(k2, uintptr(h.hash0)) if hash\u0026amp;newbit != 0 { useY = 1 // 最高位是 1，去 Y 部分 } } // 【核心逻辑】修改旧桶的标记位 // evacuatedX + 1 = evacuatedY b.tophash[i] = evacuatedX + useY // ... 搬运数据到新桶 ... 优势分析：\n迭代器兼容：当遍历旧桶时，如果看到 evacuatedX/Y，迭代器知道数据还在，只是需要去新桶里找（或者根据规则决定是返回旧数据还是新数据）。\n防止重复搬运：通过检查 evacuated 状态，确保同一个桶不会被搬运两次。\n三、 如何避免冲突：tophash 函数的校准 你可能会问：如果真实的哈希值高 8 位刚好是 0 或 1 怎么办？这不就和标记位冲突了吗？\nGo 在计算 tophash 时做了一个偏移校准。\nfunc tophash(hash uintptr) uint8 { top := uint8(hash \u0026gt;\u0026gt; (goarch.PtrSize*8 - 8)) // 取高 8 位 if top \u0026lt; minTopHash { top += minTopHash // 如果小于 5，就加上 5，强行偏移到安全区间 } return top } 实现逻辑：\n真实哈希高 8 位是 0 -\u0026gt; 存储为 5。\n真实哈希高 8 位是 3 -\u0026gt; 存储为 8。\n真实哈希高 8 位是 5 -\u0026gt; 存储为 5（不变）。\n这样就完美地把 0-4 的空间让渡了出来，专门用于状态标记。\n四、 这种设计的核心优势 1. 极致的内存节省 如果不这样做，你可能需要在 bmap 里额外增加一个字段，比如 status [8]uint8，来存储这些状态。对于一个包含大量 map 的程序来说，每个桶节省 8 字节，乘以百万级的桶数量，内存节省是非常可观的。\n2. 极致的访问速度 CPU 访问内存是很慢的。如果状态和哈希值分开存储，判断状态需要一次内存读取，比较哈希又需要一次。现在，只需一次 uint8 的内存读取，就能同时完成“状态检查”和“哈希预匹配”。\n如果是 emptyRest，直接结束。\n如果是 evacuated，走扩容逻辑。\n如果 != top，跳过。\n如果 == top，再去比较 Key。\n这完全符合“热数据优先放在缓存行”的设计原则。\n3. 代码的简洁性 通过位级别的状态复用，避免了复杂的结构体嵌套或指针跳转，使得核心的查找循环（mapaccess）极其紧凑，容易被编译器内联（Inline）和优化，最终生成的机器码非常高效。\n总结 Go map 的特殊标记位复用，是算法与工程结合的典范。它利用了哈希值分布的特性，硬生生在一个 uint8 里挤出了 5 种状态，既没有浪费内存，还通过“提前终止”等逻辑大幅提升了性能。这种设计思路非常值得在高性能底层组件开发中借鉴。\n源码：https://github.com/golang/go/blob/go1.19.12/src/runtime/map.go\n","permalink":"/blogs/2026/go/map-tophash-magic.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003eGo map 中 \u003cstrong\u003e特殊标记位的复用\u003c/strong\u003e 是其设计中最精巧的细节之一。它的核心思想是：\u003cstrong\u003e将“状态信息”直接存储在原本用于存放“哈希值片段”的内存空间中\u003c/strong\u003e，从而在不增加额外内存开销的前提下，实现了对桶（Bucket）状态的极速判断。\u003c/p\u003e","title":"Go map 核心黑魔法：tophash 标记位的极致复用与性能跃升"},{"content":"背景 Go 原生 map 不支持并发读写，多 goroutine 直接并发操作会触发 panic。常规解决方案是搭配 sync.Mutex/sync.RWMutex 加锁，但这在读多写少、键值对更新远多于新增的场景下，锁竞争会成为严重的性能瓶颈。\nsync.Map 正是为解决这个场景而生，它通过读写分离、写时复制（COW）、延迟删除、原子操作替代锁等一系列精妙设计，实现了绝大多数读操作的无锁化，大幅降低了高并发场景下的锁竞争开销。\n本文基于 Go 1.25.0 版本的 sync/map.go 源码，深入拆解其无锁读、写时复制、延迟删除三大核心设计的精髓，帮助开发者吃透高并发容器的底层设计思想。\n一、核心数据结构：双map+entry状态机的底层基石 sync.Map 的所有精妙设计，都建立在极简又极具巧思的数据结构之上，核心是read/dirty 双map读写分离，以及entry 三状态的原子操作。\n核心源码定义 // Map 是并发安全的map，零值可用，首次使用后不可复制 type Map struct { // 互斥锁，保护dirty map的所有操作，以及read map的结构变更 mu Mutex // read 存储只读的readOnly结构体，通过原子操作存取，读操作完全无锁 // 其中的map本身不会被修改结构（新增/删除key），仅会修改entry内的value指针 read atomic.Pointer[readOnly] // 内部存储readOnly类型 // dirty 是写操作的核心map，包含全量有效key（read未删除的key + 新增key） // 所有操作必须加mu锁，当未命中次数达到阈值时，会被提升为新的read map dirty map[any]*entry // misses 统计read map未命中、需要加锁访问dirty的次数 // 达到len(dirty)阈值时，触发dirty到read的提升 misses int } // readOnly 是原子存储在Map.read中的不可变结构体 type readOnly struct { m map[any]*entry amended bool // 标记dirty中存在read.m里没有的新key } // expunged 哨兵指针，标记entry已被彻底清除，不存在于dirty map中 var expunged = new(any) // entry 是value的包装结构体，核心是支持原子操作的unsafe.Pointer指针 // 实现了value的无锁更新，避免修改map本身的结构 type entry struct { p atomic.Pointer[any] // 指向*interface{}类型的value } 核心设计解读 双map读写隔离\nread map：读热点区，所有读操作优先无锁访问，仅支持原子修改entry内的value，不会新增/删除key、修改map结构，彻底避免并发读写panic。\ndirty map：写操作区，所有map结构变更（新增key、清理删除key）都在这里完成，操作必须加锁，是冷数据区。\namended 快速判断标记：仅用一个bool值，就能让读操作快速判断dirty中是否有read没有的新key，避免无意义的加锁操作。\nentry 原子包装层：原生map的value不可寻址，无法直接原子修改。通过entry包装成指针后，map仅存储entry的指针，修改value时只需原子更新entry内的指针，无需修改map结构，为无锁更新、无锁删除奠定了基础。\nentry 三状态机：是删除逻辑的核心，三个状态通过原子指针区分：\n有效状态：p 指向有效的*interface{}，key存在，可正常读取value；\n软删除状态：p = nil，key被标记删除，仍存在于read map中，读取时返回不存在；\n彻底清除状态：p = expunged，key被标记删除，且已从dirty map中剔除，不会被复制到新的dirty中。\n二、无锁读的实现：99%场景的零开销访问 sync.Map 最核心的性能优势，就是绝大多数读操作完全无锁，无需竞争互斥锁，这也是它在读多写少场景下远超 mutex+map 的核心原因。\nLoad 方法核心源码 // Load 读取key对应的value，ok标记key是否存在 func (m *Map) Load(key any) (value any, ok bool) { // 1. 原子加载readOnly，完全无锁，无竞争 read, _ := m.read.Load().(readOnly) e, ok := read.m[key] // 2. 仅当read中无key，且dirty有新key时，才需要加锁 if !ok \u0026amp;\u0026amp; read.amended { m.mu.Lock() // 3. 双重检查：加锁后再次加载read，避免并发过程中dirty已被提升 read, _ = m.read.Load().(readOnly) e, ok = read.m[key] // 4. 再次确认read无key，且dirty有新key，才访问dirty if !ok \u0026amp;\u0026amp; read.amended { e, ok = m.dirty[key] // 5. 未命中计数+1，达到阈值时触发dirty提升 m.missLocked() } m.mu.Unlock() } // 6. 无对应entry，返回不存在 if !ok { return nil, false } // 7. 原子加载entry中的value return e.Load() } // missLocked 处理未命中计数，达到阈值时将dirty提升为新的read func (m *Map) missLocked() { m.misses++ // 阈值为dirty的长度，平衡提升频率与访问开销 if m.misses \u0026lt; len(m.dirty) { return } // 原子替换read为dirty，零拷贝！仅传递map引用，无数据复制 m.read.Store(readOnly{m: m.dirty}) // 清空dirty，重置计数 m.dirty = nil m.misses = 0 } // Load 原子加载entry中的value func (e *entry) Load() (value any, ok bool) { p := atomic.LoadPointer(\u0026amp;e.p) // 指针为nil或expunged，说明key已被删除 if p == nil || p == expunged { return nil, false } return *(*any)(p), true } 无锁设计的精髓 读操作优先无锁访问：所有读操作第一步都是原子加载readOnly，完全无锁。对于读多写少、key基本不变的场景，几乎所有读操作都在这一步完成，零锁开销，无上下文切换。\n双重检查（Double Check）范式：加锁后会再次加载read map，避免并发过程中其他goroutine已将dirty提升为read，导致重复访问dirty；同时保证了并发安全，彻底避免竞态问题，是无锁编程的经典实践。\n自适应的未命中阈值设计：misses 的阈值设为 len(dirty)，这个设计极具巧思：\n当dirty很小时，阈值很低，快速触发提升，避免频繁加锁访问小dirty；\n当dirty很大时，阈值很高，避免频繁触发全量map替换，减少性能抖动；\n保证只有当访问dirty的累计开销，超过提升dirty的一次性开销时，才会触发提升，完美平衡了读写性能。\nentry的原子读保障：即使在read map中命中key，读取value也是通过原子操作加载entry的指针，保证并发更新value时，读操作不会拿到脏数据，同时全程无需加锁。\n三、写时复制（COW）：平衡读写性能的核心设计 写时复制（Copy-On-Write）是sync.Map的核心设计思想，它彻底避免了传统加锁map中读写竞争锁的问题，把map结构的变更和读操作完全隔离开，仅在必要时执行浅拷贝，把复制开销降到了最低。\nsync.Map的写操作分为更新已存在的key和新增不存在的key两种场景，分别对应了无锁更新和写时复制的核心逻辑。\nStore 方法核心源码 // Store 存储key-value对 func (m *Map) Store(key, value any) { // 1. 先无锁加载read，尝试直接更新已存在的key read, _ := m.read.Load().(readOnly) if e, ok := read.m[key]; ok \u0026amp;\u0026amp; e.tryStore(\u0026amp;value) { // 已存在的key，原子更新成功，直接返回，完全无锁！ return } // 2. 无法无锁更新，加锁处理 m.mu.Lock() // 双重检查，加锁后再次确认read中的状态 read, _ = m.read.Load().(readOnly) if e, ok := read.m[key]; ok { // 2.1 key在read中存在，但被标记为expunged，需先恢复到dirty中 if e.unexpungeLocked() { // 恢复成功，将entry加入dirty，保证dirty包含全量有效key m.dirty[key] = e } // 原子更新entry的value e.storeLocked(\u0026amp;value) } else if e, ok := m.dirty[key]; ok { // 2.2 key不在read中，但在dirty中，直接更新dirty内的entry e.storeLocked(\u0026amp;value) } else { // 2.3 全新的key，read和dirty中均不存在，触发写时复制逻辑 if !read.amended { // amended为false，说明dirty当前为nil，需初始化dirty // 写时复制核心：将read中未删除的key浅拷贝到dirty m.dirtyLocked() // 标记dirty包含read没有的新key m.read.Store(readOnly{m: read.m, amended: true}) } // 新key仅加入dirty，read map完全不修改 m.dirty[key] = newEntry(value) } m.mu.Unlock() } // tryStore 尝试无锁原子更新entry的value，仅当entry非expunged状态时成功 func (e *entry) tryStore(i *any) bool { for { p := atomic.LoadPointer(\u0026amp;e.p) // entry已被彻底清除，无法无锁更新，返回失败 if p == expunged { return false } // CAS原子更新value指针 if atomic.CompareAndSwapPointer(\u0026amp;e.p, p, unsafe.Pointer(i)) { return true } } } // unexpungeLocked 将expunged状态的entry恢复为nil，确保被加入dirty // 必须持有mu锁时调用 func (e *entry) unexpungeLocked() (wasExpunged bool) { return atomic.CompareAndSwapPointer(\u0026amp;e.p, expunged, nil) } // storeLocked 强制原子更新entry的value，必须持有mu锁时调用 func (e *entry) storeLocked(i *any) { atomic.StorePointer(\u0026amp;e.p, unsafe.Pointer(i)) } // dirtyLocked 初始化dirty，将read中未删除的entry浅拷贝到dirty // 必须持有mu锁时调用 func (m *Map) dirtyLocked() { if m.dirty != nil { return } read, _ := m.read.Load().(readOnly) // 初始化dirty，容量与read map一致，避免多次扩容 m.dirty = make(map[any]*entry, len(read.m)) // 遍历read map，浅拷贝未删除的entry for k, e := range read.m { // 尝试标记entry为expunged，仅未删除的entry会被复制到dirty if !e.tryExpungeLocked() { m.dirty[k] = e } } } // tryExpungeLocked 尝试将nil状态的entry标记为expunged // 返回true表示entry已被删除，无需复制到dirty；必须持有mu锁时调用 func (e *entry) tryExpungeLocked() (isExpunged bool) { p := atomic.LoadPointer(\u0026amp;e.p) for p == nil { // 将软删除的entry，CAS设置为expunged，标记为彻底清除 if atomic.CompareAndSwapPointer(\u0026amp;e.p, nil, expunged) { return true } p = atomic.LoadPointer(\u0026amp;e.p) } return p == expunged } // newEntry 创建一个新的entry func newEntry(i any) *entry { return \u0026amp;entry{p: unsafe.Pointer(\u0026amp;i)} } 写时复制的设计精髓 场景1：更新已存在的key——完全无锁的原子更新 这是sync.Map最极致的性能优化点：对于已存在的key，更新value全程无需加锁。\n当Store一个已存在的key时，首先在read map中找到对应的entry，调用tryStore方法，通过CAS原子操作更新entry内的p指针。\n整个过程完全没有修改map的结构（没有新增/删除key，map哈希表完全不变），仅修改了entry内的指针，因此无需加锁，也不会和读操作产生任何竞争。\n这也是为什么sync.Map在更新远多于新增的场景下，性能远超mutex+map——传统方案更新也要加锁，而sync.Map实现了零锁开销的更新。\n场景2：新增key——写时复制的懒初始化与浅拷贝 新增key是写时复制的核心场景，这里的设计彻底避免了修改read map的结构，把所有结构变更都限制在加锁的dirty map中，同时通过懒拷贝把复制开销降到最低。\n新增key绝不修改read map：read map被多个goroutine无锁并发读，直接修改其结构会触发并发map读写panic。因此所有新增key只会写入dirty map，read map完全不动，彻底隔离了读写操作的竞争。\n懒初始化与写时复制：第一次新增key时，dirty为nil，此时会调用dirtyLocked方法，把read map中未删除的entry浅拷贝到dirty中。\n这里的复制是浅拷贝：仅复制map的key和entry的指针，不会复制value本身，即使read map体量很大，复制开销也极低。\n这就是写时复制的核心：只有当需要新增key时，才会复制read的内容到dirty，平时完全不执行复制操作，把复制开销延迟到第一次写的时候，避免了不必要的性能损耗。\namended标记的联动：初始化dirty后，会将readOnly的amended标记设为true，告知后续的读操作：dirty中存在read没有的新key，读不到时需要加锁访问dirty。\n零拷贝的dirty提升：当misses达到阈值后，会直接将dirty原子存储到read中，这个过程是零拷贝的——仅把dirty的map引用赋值给readOnly的m字段，没有任何数据复制，原来的dirty直接变成新的read map，随后dirty被置为nil，等待下一次新增key时再初始化。\n写时复制机制保证了：若旧的read map还有goroutine在读，依然可以正常访问，因为旧的map是不可变的，不会被修改，直到无引用后被GC回收，完全无并发安全问题。 误区纠正：很多人以为写时复制是每次写都要全量复制map，实则sync.Map的COW设计，仅在第一次新增key时浅拷贝read内容到dirty，后续新增key直接加锁写入dirty，无需复制；仅当dirty提升为read后，下一次新增key才会再次复制，复制频率由misses阈值严格控制，开销极低。\n四、延迟删除的优雅设计：避免锁竞争与map结构频繁变更 sync.Map的删除操作，是最容易被忽略却又极其精妙的设计。它没有采用直接删除key的方式，而是用软删除+延迟清理的机制，把删除操作也变成了无锁的原子操作，仅在必要时才真正清理删除的key，大幅减少了锁的持有时间和map结构的变更频率。\nDelete 方法核心源码 // Delete 删除key func (m *Map) Delete(key any) { m.LoadAndDelete(key) } // LoadAndDelete 删除key，返回被删除的value和是否存在 func (m *Map) LoadAndDelete(key any) (value any, loaded bool) { // 1. 先无锁加载read，查找key read, _ := m.read.Load().(readOnly) e, ok := read.m[key] // 2. read中无key，且dirty有新key，加锁处理 if !ok \u0026amp;\u0026amp; read.amended { m.mu.Lock() // 双重检查 read, _ = m.read.Load().(readOnly) e, ok = read.m[key] if !ok \u0026amp;\u0026amp; read.amended { // key仅在dirty中，直接从dirty删除，这是真正的结构删除 e, ok = m.dirty[key] delete(m.dirty, key) // 未命中计数+1 m.missLocked() } m.mu.Unlock() } // 3. 无对应key，直接返回 if !ok { return nil, false } // 4. 找到entry，原子标记为软删除，完全无锁！ return e.delete() } // delete 原子将entry标记为删除，返回旧的value和是否存在 func (e *entry) delete() (value any, ok bool) { for { p := atomic.LoadPointer(\u0026amp;e.p) // 已被删除，直接返回 if p == nil || p == expunged { return nil, false } // CAS将p设为nil，标记为软删除 if atomic.CompareAndSwapPointer(\u0026amp;e.p, p, nil) { return *(*any)(p), true } } } 延迟删除的设计精髓 1. 软删除：无锁的删除操作 对于存在于read map中的key，删除操作全程无需加锁！\n不是直接从read map中删除key（那样会修改map结构，需要加锁，还会触发并发读写panic），而是通过CAS原子操作，把entry的p指针设为nil，标记为软删除。\n软删除后的key仍存在于read map中，但读取时会判断p=nil，返回不存在，完全不影响读操作的正确性，同时整个删除过程无锁、无竞争。\n2. 延迟清理：开销平摊，无额外性能损耗 软删除的key，会在下一次初始化dirty的时候被真正清理，无需单独的清理逻辑。\n当新增key需要初始化dirty时，会调用dirtyLocked方法遍历read map的所有entry，调用tryExpungeLocked方法。\n对于已软删除（p=nil）的entry，会通过CAS将p设为expunged，标记为彻底清除，不会被复制到dirty中。\n当dirty被提升为新的read map后，旧的read map失去引用，会被GC回收，这些被标记为expunged的key就会被彻底清理，完全不需要额外的锁操作和遍历开销。\n这个设计的精妙之处在于：把删除key的清理开销，合并到了新增key的写时复制过程中，不需要单独启动goroutine清理，也不会在删除时占用锁的时间，把批量清理的开销平摊到了极少的写操作中。\n3. expunged状态：解决软删除的并发冲突 expunged哨兵指针是整个删除逻辑的灵魂，它完美解决了软删除后，再次Store同一个key的并发冲突问题。\n当一个entry被标记为expunged后，说明它已被从dirty中剔除，read map中有这个key，但dirty中没有。\n此时如果再次Store这个key，不能直接无锁更新entry，因为dirty中没有这个key，会导致dirty提升时，这个key丢失。\n因此tryStore方法会判断，若entry是expunged状态，直接返回失败，进入加锁逻辑：调用unexpungeLocked方法将entry从expunged状态恢复为nil，再把entry加入dirty，最后更新value，保证dirty始终包含全量有效key。\nexpunged状态完美区分了“软删除但未清理的entry”和“已清理出dirty的entry”，解决了软删除后再次写入的并发安全问题，同时没有增加任何额外的锁开销。\n五、设计精髓总结与开发启示 sync.Map 不是为了替代所有的mutex+map方案，而是针对读多写少、键值对更新频繁、新增删除少的场景做了极致优化，它的核心设计思想，值得所有开发者学习和借鉴：\n读写分离，冷热隔离：把读热点数据放到无锁的read map，把写操作（结构变更）放到加锁的dirty map，让绝大多数读操作完全避开锁竞争，这是高并发容器设计的核心思路。\n写时复制，懒加载+浅拷贝：不是每次写都复制，而是把复制延迟到必要的时候，且仅做浅拷贝，把复制开销降到最低；同时通过原子替换实现零拷贝的map升级，完美平衡了读写性能。\n原子操作替代锁：把value包装成支持原子操作的entry，让更新、删除操作都可以通过CAS原子操作完成，完全不需要锁，大幅降低了并发竞争的开销。\n延迟处理，平摊开销：删除操作采用软删除+延迟清理，把批量清理的开销平摊到极少的写操作中，避免了高频操作的性能损耗，同时减少了锁的持有时间。\n双重检查，保证并发安全：所有加锁操作前，都先做无锁检查，加锁后再次做双重检查，既避免了无意义的加锁，又保证了并发安全，是无锁编程的经典范式。\n适用场景与避坑指南 适合场景：读多写少，尤其是key的更新远多于新增；多个goroutine读写不相交的key集合；并发访问的热点key集中，冷key很少。\n不适合场景：写多读少，尤其是频繁新增大量新key的场景（会导致dirty频繁初始化和提升，性能反而不如mutex+map）；遍历操作非常频繁的场景。\n源码：https://raw.githubusercontent.com/golang/go/refs/tags/go1.25.0/src/sync/map.go\n","permalink":"/blogs/2026/go/go-sync-map-copy-on-wirter.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003eGo 原生 map 不支持并发读写，多 goroutine 直接并发操作会触发 panic。常规解决方案是搭配 \u003ccode\u003esync.Mutex/sync.RWMutex\u003c/code\u003e 加锁，但这在\u003cstrong\u003e读多写少、键值对更新远多于新增\u003c/strong\u003e的场景下，锁竞争会成为严重的性能瓶颈。\u003c/p\u003e","title":"Go sync.Map 源码深度解析：写时复制、无锁读与延迟删除的设计精髓"},{"content":"前言 Go 标准库中的sync.WaitGroup是实现一组goroutine同步等待的核心组件，其底层基于原子操作和运行时信号量实现，无锁的设计让它拥有极高的性能，而state（原子64位状态）和sema（信号量）的配合更是整个组件的设计核心。本文基于Go1.26.1版本的源码，剥离无关的race检测、Bubble测试、noCopy及Go方法等逻辑，聚焦state和sema的实现细节，拆解其设计的巧妙之处，让开发者理解Go无锁同步的设计精髓。\n一、核心字段设计：单原子变量封装多状态，极致的无锁设计 WaitGroup的核心仅包含两个字段：state和sema，其中state是整个组件的状态中枢，采用单个64位原子无符号整数封装了两个核心状态，这是其设计的第一个巧妙点——通过单原子变量的原子操作，保证多状态更新的原子性，避免了多字段同步带来的竞态问题和锁开销。\n核心字段源码（精简版） type WaitGroup struct { // Bits (high to low): // bits[0:32] counter // bits[32] flag: Bubble测试 // bits[33:64] wait count state atomic.Uint64 // 信号量，由Go运行时管理，用于阻塞/唤醒等待的goroutine sema uint32 } state位段划分详解 state作为atomic.Uint64类型，其64个比特位被精准划分，高32位和低32位分别承载不同的核心状态，且对低32位做了1位的预留（测试用），具体划分如下：\n高32位（bits[32:64]）：任务计数器counter，表示待完成的任务数，类型为int32（支持负数检测）；\n低32位（bits[0:32]）：低31位为等待者计数器wait count，表示阻塞在Wait方法上的goroutine数量，最高1位为测试用的bubble flag（本文剥离，无实际业务意义）。\n这种设计的核心优势在于：对counter和wait count的联合更新可以通过单个原子操作完成，而原子操作是Go中最轻量的同步原语，相比互斥锁（sync.Mutex），无任何上下文切换开销，这让WaitGroup在高并发场景下拥有极致的性能。\n而sema是一个普通的uint32变量，并非原子类型，它并不存储具体的数值，而是作为Go运行时信号量的唯一标识，由运行时的runtime_SemacquireWaitGroup和runtime_Semrelease方法管理，用于实现goroutine的阻塞和唤醒。\n二、Add方法：state的原子更新与信号量的精准释放 Add方法是WaitGroup的核心写操作，负责修改任务计数器counter，并在计数器归0且存在等待者时，通过sema唤醒所有阻塞的goroutine。其实现围绕state的原子操作展开，同时包含严格的边界检查和误用检测，既保证了状态的正确性，又能在开发阶段提前暴露使用错误。\nAdd方法源码（精简版） // Add adds delta, which may be negative, to the WaitGroup task counter. // If the counter becomes zero, all goroutines blocked on Wait are released. // If the counter goes negative, Add panics. func (wg *WaitGroup) Add(delta int) { // 原子更新state：delta左移32位（映射到高32位的counter），完成counter的累加 state := wg.state.Add(uint64(delta) \u0026lt;\u0026lt; 32) // 拆分state：高32位为counter，低32位为“测试flag + wait count” v := int32(state \u0026gt;\u0026gt; 32) // counter // 注：0x7fffffff与state做与运算，高于31位部分都变成0，保留wait count部分 w := uint32(state \u0026amp; 0x7fffffff) // wait count // 边界检查：counter为负，直接panic if v \u0026lt; 0 { panic(\u0026#34;sync: negative WaitGroup counter\u0026#34;) } // 误用检测：存在等待者时，并发调用Add（且是首次累加），直接panic if w != 0 \u0026amp;\u0026amp; delta \u0026gt; 0 \u0026amp;\u0026amp; v == int32(delta) { panic(\u0026#34;sync: WaitGroup misuse: Add called concurrently with Wait\u0026#34;) } // 无需唤醒：counter\u0026gt;0 或 无等待者，直接返回 if v \u0026gt; 0 || w == 0 { return } // 双重校验：保证state未被并发修改，防止Add和Wait的竞态 if wg.state.Load() != state { panic(\u0026#34;sync: WaitGroup misuse: Add called concurrently with Wait\u0026#34;) } // 计数器归0且有等待者：重置state为0，释放信号量唤醒所有等待者 wg.state.Store(0) // 循环释放信号量，等待者数为w则唤醒w个goroutine for ; w != 0; w-- { runtime_Semrelease(\u0026amp;wg.sema, false, 0) } } Add方法的设计巧思 原子操作的精准映射：将delta左移32位后通过atomic.Uint64.Add更新state，一步完成counter的累加，保证了操作的原子性，无需任何锁保护；\n轻量的状态拆分：通过位运算直接从64位的state中拆分出counter和wait count，无内存拷贝，操作开销可以忽略；\n严格的运行时校验：包含两层关键检查，一是counter负数检查（避免Done调用次数超过Add），二是Add与Wait并发误用检查（防止在已有goroutine等待时，首次初始化counter），让使用错误在运行时立即暴露，而非引发隐蔽的竞态问题；\n双重校验保证状态一致性：在准备释放信号量前，再次加载state并与之前的更新值对比，确保中间无其他goroutine修改state，彻底避免Add和Wait的并发竞态；\n信号量的批量唤醒：通过循环调用runtime_Semrelease，根据wait count的数量精准唤醒所有阻塞的goroutine，sema作为标识，让运行时能精准找到对应的信号量队列。\n三、Done方法：极简的封装，职责单一 Done方法是Add方法的极简封装，其唯一功能是将任务计数器counter减1，本质是调用Add(-1)，这体现了Go设计的职责单一原则——让核心方法专注于核心逻辑，简单操作通过封装实现，提升代码的可读性和可维护性。\nDone方法源码（精简版） // Done decrements the WaitGroup task counter by one. // It is equivalent to Add(-1). func (wg *WaitGroup) Done() { wg.Add(-1) } Done的调用会触发Add方法的全套逻辑：如果counter减1后归0且存在等待者，会立即触发信号量的释放，唤醒阻塞的goroutine；如果counter减为负数，会直接panic，这保证了Done的调用始终受Add方法的边界约束。\n四、Wait方法：state的循环检测与信号量的阻塞等待 Wait方法是WaitGroup的核心读操作，负责让当前goroutine阻塞，直到任务计数器counter归0。其实现采用循环+CAS的无锁模式，配合sema实现goroutine的阻塞，整个过程无锁，仅通过原子操作完成状态检测和更新，这是Go无锁同步的经典实现方式。\nWait方法源码（精简版） // Wait blocks until the WaitGroup task counter is zero. func (wg *WaitGroup) Wait() { for { // 循环加载state，无锁检测状态 state := wg.state.Load() v := int32(state \u0026gt;\u0026gt; 32) // counter w := uint32(state \u0026amp; 0x7fffffff) // wait count // 计数器归0，无需等待，直接返回 if v == 0 { return } // CAS原子更新state：等待者数加1，失败则重新循环检测 if wg.state.CompareAndSwap(state, state+1) { // 阻塞当前goroutine，获取信号量（直到被Add方法唤醒） runtime_SemacquireWaitGroup(\u0026amp;wg.sema, false) // 唤醒后校验：state非0表示WaitGroup被提前复用，直接panic if wg.state.Load() != 0 { panic(\u0026#34;sync: WaitGroup is reused before previous Wait has returned\u0026#34;) } return } } } Wait方法的设计巧思 循环+CAS的无锁自旋：通过无限循环加载state，判断counter是否归0，若未归0则通过CompareAndSwap（CAS）尝试将等待者数加1。CAS操作失败表示有其他goroutine同时更新了state，此时无需阻塞，直接重新循环即可——这种自旋是忙等，但仅发生在多goroutine并发调用Wait的瞬间，开销极低，远小于互斥锁的开销；\n信号量的阻塞式等待：CAS成功后，调用runtime_SemacquireWaitGroup让当前goroutine陷入阻塞休眠（非忙等），并加入到sema对应的信号量等待队列中。此时goroutine会让出CPU，不会占用资源，这是Wait方法高性能的关键；\n唤醒后的复用校验：被Add方法唤醒后，立即检查state是否为0。若state非0，说明在Wait未返回时，其他goroutine调用了Add方法，即WaitGroup被提前复用，直接panic——这一检查保证了WaitGroup的核心使用规则：复用必须等到所有Wait调用返回后；\n无锁的状态同步：整个Wait方法的执行过程中，没有使用任何互斥锁，仅通过原子加载和CAS操作完成状态的检测和更新，完全符合无锁同步的设计思想。\n五、state与sema的协同：同步的核心桥梁 WaitGroup的整个同步逻辑，本质是state的原子状态管理与sema的阻塞/唤醒的高度协同，二者各司其职，形成了一个高效的同步闭环，这是其设计的核心精髓。\n二者的协同逻辑 状态感知：state作为“状态中枢”，实时存储counter（任务数）和wait count（等待者数），所有方法的操作都围绕state的原子更新展开，保证了状态的全局一致性；\n阻塞触发：当goroutine调用Wait且counter未归0时，通过CAS更新state的wait count，随后通过sema让goroutine阻塞；\n唤醒触发：当Add方法将counter更新为0且存在等待者时，通过state确认等待者数量，随后通过sema批量唤醒所有阻塞的goroutine；\n状态重置：唤醒完成后，Add方法将state重置为0，为WaitGroup的下一次使用（需满足复用规则）做好准备。\nsema的设计巧思 sema被设计为普通的uint32而非原子类型，原因在于：sema仅作为Go运行时信号量的标识，其本身不存储任何数据，所有的操作都由运行时的原语方法完成，运行时内部会保证信号量操作的原子性和并发安全性。这种设计让上层的WaitGroup无需关心信号量的实现细节，只需调用运行时原语，实现了上层逻辑与底层原语的解耦。\n六、WaitGroup的设计精髓总结 Go1.26.1版本的sync.WaitGroup剥离无关逻辑后，其核心实现仅有数十行代码，但凝聚了Go无锁同步的设计思想，其精髓可总结为以下五点，也是开发者可以借鉴到日常开发中的设计思路：\n1. 单原子变量封装多状态，减少同步开销 将多个关联的状态封装到单个原子变量中，通过位运算拆分和更新，利用原子操作的原子性保证多状态的联合更新一致性，避免了多字段同步带来的竞态问题，同时省去了互斥锁的开销，这是无锁同步的经典技巧。\n2. 循环+CAS的无锁模式，替代轻量场景的互斥锁 在轻量的状态更新场景下，使用循环自旋+CAS替代互斥锁，仅在CAS成功后执行后续逻辑，失败则重新自旋，这种方式的开销远低于互斥锁的加锁/解锁和上下文切换，是Go高性能无锁同步的核心实现方式。\n3. 利用底层原语，解耦上层逻辑 基于Go运行时提供的信号量原语（runtime_SemacquireWaitGroup/runtime_Semrelease）实现goroutine的阻塞和唤醒，上层逻辑无需关心信号量的底层实现，只需通过标识（sema）调用原语，实现了逻辑的解耦，让代码更简洁。\n4. 严格的运行时校验，提前暴露使用错误 在核心方法中加入严格的边界检查和误用检测，如counter负数、Add与Wait并发调用、WaitGroup提前复用等，让使用错误在运行时立即panic，而非引发隐蔽的竞态问题或逻辑错误，提升了组件的健壮性。\n5. 职责单一，极简封装 核心方法专注于核心逻辑（Add管理状态更新和唤醒，Wait管理阻塞和状态检测），简单操作（Done）通过极简封装实现，让代码的可读性和可维护性大幅提升，同时避免了逻辑冗余。\n七、开发者的借鉴与思考 WaitGroup的设计是Go“简洁而高效”设计哲学的典型体现，其无锁同步的实现方式，不仅适用于goroutine的同步，也为开发者在日常开发中实现高并发组件提供了思路：\n在高并发的轻量同步场景中，优先考虑原子操作而非互斥锁，减少同步开销；\n对关联的状态进行合理的位封装，利用原子操作保证状态的原子性更新；\n采用循环+CAS实现无锁的状态更新，同时做好自旋的边界控制，避免无意义的忙等；\n在组件中加入严格的运行时校验，让错误提前暴露，提升组件的健壮性；\n充分利用底层原语，解耦上层业务逻辑，让代码更简洁、更易维护。\n总之，WaitGroup看似简单的实现背后，是对原子操作、信号量原语和并发模型的深刻理解，而这也是Go并发编程的核心所在。\nwaitgroup源码：https://github.com/golang/go/blob/go1.26.1/src/sync/waitgroup.go\n","permalink":"/blogs/2026/go/go-waitgroup-64bit-state-design.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003eGo 标准库中的\u003ccode\u003esync.WaitGroup\u003c/code\u003e是实现一组goroutine同步等待的核心组件，其底层基于原子操作和运行时信号量实现，无锁的设计让它拥有极高的性能，而\u003cstrong\u003estate\u003c/strong\u003e（原子64位状态）和\u003cstrong\u003esema\u003c/strong\u003e（信号量）的配合更是整个组件的设计核心。本文基于Go1.26.1版本的源码，剥离无关的race检测、Bubble测试、noCopy及Go方法等逻辑，聚焦state和sema的实现细节，拆解其设计的巧妙之处，让开发者理解Go无锁同步的设计精髓。\u003c/p\u003e","title":"Go sync.WaitGroup 源码分析：一个用 64 位状态压缩并发协议的经典设计"},{"content":"前言 Go读写锁sync.RWMutex（对应源码src/sync/rwmutex.go）是标准库中设计精妙的同步工具，其核心语义清晰明确：支持任意多个读者同时持有读锁，或仅允许一个写者持有写锁；当有写者等待获取锁时，新的读者会被阻塞，以此避免写者出现饥饿问题。\n先看结论：这把锁巧妙在哪里 RWMutex的设计精髓并非单纯支持读写分离，而是通过一个读者计数器 readerCount，同时承载两层核心信息：\n当前持有读锁的活跃读者数量；\n系统中是否已有写者发起加锁请求。\n源码中定义常量rwmutexMaxReaders = 1 \u0026lt;\u0026lt; 30作为“写者到来”的判定阈值：当写者申请写锁时，会将readerCount一次性减去该常量，使其变为负数；后续所有新的读锁申请（RLock）检测到readerCount为负数时，便会知晓有写者在等待，随即进入阻塞队列。这一设计极为精炼，实现了一个整数同时兼顾状态位和计数器的双重功能。\n// 源码中核心常量定义 const rwmutexMaxReaders = 1 \u0026lt;\u0026lt; 30 结构体设计：字段精简，职责边界清晰 RWMutex的结构体仅包含五个核心字段：w Mutex、writerSem、readerSem、readerCount、readerWait，没有冗余的字段堆砌，而是将复杂的读写同步问题拆解为多个独立子问题，每个字段各司其职：\nw：专门解决写者之间的互斥竞争，保证同一时间只有一个写者能发起加锁流程；\nwriterSem/readerSem：两个信号量分别负责写者等待读者、读者等待写者的阻塞与唤醒；\nreaderCount：记录活跃读者总数，同时携带写者到来的状态信号；\nreaderWait：统计当前仍持有读锁、未退出的活跃读者数量。\n这种设计遵循核心原则：互斥归互斥，排队归排队，状态归状态。Mutex仅处理写者间的竞争，readerCount仅标识系统当前的锁状态，信号量仅负责阻塞与唤醒的调度，各组件职责边界干净，逻辑可推理性强。\n// RWMutex 结构体源码 type RWMutex struct { w Mutex // 写者间互斥锁 writerSem uint32 // 写者等待读者的信号量 readerSem uint32 // 读者等待写者的信号量 readerCount int32 // 活跃读者计数器（含写者状态） readerWait int32 // 等待退出的读者数量 } RLock：读锁为什么能快 读锁RLock的高性能核心在于快路径极短，核心流程仅为原子操作+条件判断：对readerCount执行原子加1操作，若操作后结果仍为非负数，说明当前无写者等待，读者可直接进入临界区；仅当结果为负数时，读者才会在readerSem上阻塞睡眠。\n在“读多写少”的典型场景中，读者几乎都走快路径，无需执行复杂的阻塞等待逻辑，这是读锁高性能的关键。\n源码注释中明确指出，RLock不适合用于递归读锁：若有写者调用Lock申请写锁并进入阻塞后，新的读锁申请会被直接挡住，直到写者成功获取并释放写锁后才能继续，这一设计的核心目的是保障写者的锁获取权，避免写者饥饿。\n// RLock 读锁申请源码 func (rw *RWMutex) RLock() { // 原子加1，快路径核心操作 if atomic.AddInt32(\u0026amp;rw.readerCount, 1) \u0026lt; 0 { // 若结果为负，说明有写者等待，阻塞读者 runtime_SemacquireMutex(\u0026amp;rw.readerSem, false, 0) } } Lock：写锁为什么能“让新读者停下” 写锁Lock的核心能力是“阻断新读者，等待旧读者”，其执行流程极具代表性：\n调用w.Lock()，解决多个写者之间的竞争，保证同一时间只有一个写者执行后续操作；\n将readerCount减去rwmutexMaxReaders，让其变为负数，向所有后续读锁申请发出信号：“写者已到，新读者请排队”；\n若此时仍有活跃读者持有读锁，将活跃读者数量记录到readerWait，随后写者在writerSem上阻塞，直到最后一个读者释放读锁。\n这一设计的精妙之处在于：写者不会强行抢占读者的锁资源，而是先关闭新读者的进入通道，再等待当前持有读锁的读者全部退出。\n也正因如此，当某个goroutine调用Lock且锁正被读者持有时，后续的RLock都会被阻塞，直到写者完成加锁、执行业务并释放锁，这是一种写者优先的防饥饿设计策略。\n// Lock 写锁申请源码 func (rw *RWMutex) Lock() { // 1. 写者间互斥，保证唯一写者进入 rw.w.Lock() // 2. 减去阈值，标记写者到来，阻断新读者 r := rw.readerCount.Add(-rwmutexMaxReaders) + rwmutexMaxReaders // 3. 若仍有活跃读者，记录数量并阻塞等待 if r != 0 \u0026amp;\u0026amp; rw.readerWait.Add(r) != 0 { // readerWait + 如果不为0就表示还是有写未释放 runtime_SemacquireRWMutex(\u0026amp;rw.writerSem, false, 0) } } RUnlock 和 Unlock：唤醒顺序是稳定性的关键 读锁释放RUnlock和写锁释放Unlock的逻辑高度适配，且唤醒与状态恢复的顺序经过严格设计，是保证RWMutex稳定运行的核心：\nRUnlock：读锁释放 逻辑精炼且区分普通场景与写者等待场景：\n对readerCount执行原子减1操作；\n若操作后结果仍为非负数，说明无写者等待，仅为普通读者退出，流程直接结束；\n若操作后结果为负数，说明有写者在阻塞等待，进入慢路径rUnlockSlow，对readerWait执行减1操作；当readerWait减至0时，说明最后一个读者已退出，随即释放writerSem唤醒写者。\n// RUnlock 读锁释放源码 func (rw *RWMutex) RUnlock() { // 原子减1，判断是否有写者等待 if r := atomic.AddInt32(\u0026amp;rw.readerCount, -1); r \u0026lt; 0 { // 有写者等待，进入慢路径 rw.rUnlockSlow(r) } } // rUnlockSlow 读锁释放慢路径（有写者等待时） func (rw *RWMutex) rUnlockSlow(r int32) { // 读者等待数减1，判断是否为最后一个读者 if atomic.AddInt32(\u0026amp;rw.readerWait, -1) == 0 { // 注：readerWait可能是负数，rw.readerWait.Add(r) 还没执行到，但是不影响逻辑，因为等于0是还是会唤醒writerSem // 最后一个读者退出，唤醒写者 runtime_Semrelease(\u0026amp;rw.writerSem, false, 1) } } Unlock：写锁释放 流程与Lock完全逆向，严格遵循先恢复读者态，再批量唤醒读者，最后放开写者互斥的顺序：\n将readerCount加回rwmutexMaxReaders，将系统从“写者占用态”恢复为正常的“可读态”；\n根据实际数量释放readerSem，批量唤醒所有因写者等待而被阻塞的读者；\n调用w.Unlock()，释放写者间的互斥锁，允许下一个写者参与锁竞争。\n这一固定的执行顺序，从根本上避免了读写唤醒的逻辑混乱，是整个实现稳定性的关键。\n// Unlock 写锁释放源码 func (rw *RWMutex) Unlock() { // 1. 恢复readerCount，退出写者占用态 r := atomic.AddInt32(\u0026amp;rw.readerCount, rwmutexMaxReaders) // 2. 批量唤醒阻塞的读者（r为阻塞的读者数量） for i := 0; i \u0026lt; int(r); i++ { runtime_Semrelease(\u0026amp;rw.readerSem, false, 0) } // 3. 释放写者间互斥锁，允许下一个写者竞争 rw.w.Unlock() } 最值得学习的设计点 1. 用负数编码“写者已到”的状态 这是RWMutex最经典的设计技巧，让普通的计数器readerCount成为带状态意义的计数器：通过减去超大常量使其变负，用数值的符号直接标识系统状态——非负表示无写者，仅存在读者；负数表示有写者已发起申请。后续读锁仅需判断符号，即可快速决定执行路径，无需额外的标志位变量。\n2. “门闩”与“人数统计”解耦 w Mutex作为写者间的“门闩”，仅负责写者的串行化，不直接干预读者的逻辑；readerWait仅作为“人数统计”工具，记录未退出的读者数量，不参与锁状态的判定。这种解耦设计让算法逻辑更清晰，也为TryLock、RLocker等附加功能的扩展提供了便利。\n// RLocker 返回读锁的Locker接口实现（解耦扩展示例） func (rw *RWMutex) RLocker() Locker { return (*rlocker)(rw) } type rlocker RWMutex func (r *rlocker) Lock() { (*RWMutex)(r).RLock() } func (r *rlocker) Unlock() { (*RWMutex)(r).RUnlock() } 3. 双信号量拆分唤醒方向 为读者和写者分别设计独立的信号量readerSem和writerSem，是极具工程价值的设计：\n写者仅需在writerSem上等待最后一个读者的唤醒，无需关注读者的其他逻辑；\n读者仅需在readerSem上等待写者的唤醒，逻辑单一；\n读写的阻塞与唤醒逻辑完全分离，避免了“单个条件变量承载所有等待者，需额外判断唤醒对象”的复杂性。\n4. 快路径内联，慢路径抽离 在RUnlock的实现中，将写者等待的慢逻辑抽离为独立的rUnlockSlow方法，核心目的是让普通场景的快路径更容易被编译器内联。这一思路是高频同步原语的性能设计准则：热路径尽量精简，冷路径单独抽离，也是Go标准库性能优化的典型风格。\n5. 对TryLock/TryRLock保持克制 源码注释中明确表示，尽管TryLock（尝试加写锁）和TryRLock（尝试加读锁）的实现是正确的，但实际开发中合理的使用场景极少，且这类用法往往暗示着业务层的并发设计存在深层问题。\n标准库并未将“尝试锁”包装为通用解决方案，而是提醒开发者避免将其作为常规设计，这一设计理念对并发编程实践具有重要的指导意义。\n// TryLock 尝试加写锁（源码示例，注释省略无关内容） func (rw *RWMutex) TryLock() bool { if !rw.w.TryLock() { return false } if !rw.readerCount.CompareAndSwap(0, -rwmutexMaxReaders) { rw.w.Unlock() return false } return true } // TryRLock 尝试加读锁（源码示例，注释省略无关内容） func (rw *RWMutex) TryRLock() bool { for { c := atomic.LoadInt32(\u0026amp;rw.readerCount) if c \u0026lt; 0 { return false } if atomic.CompareAndSwapInt32(\u0026amp;rw.readerCount, c, c+1) { return true } } } 容易忽略的细节：非“线程所有权”模型 与Mutex一致，RWMutex的读锁和写锁均不与特定的goroutine绑定，即一个goroutine加锁后，可由另一个goroutine执行解锁操作。\n这一设计对goroutine的并发编排极为友好，支持“一个协程负责获取资源加锁，另一个协程在合适时机释放资源解锁”的灵活使用模式，适配更多的业务并发场景。\n这份源码教给我们的，不只是锁 将RWMutex作为并发设计的经典样本，其带给开发者的启发远不止锁的实现本身，更包含通用的并发设计思路：\n状态编码极简化：避免将状态拆分为多个独立且难以一致维护的变量，一个带语义的复合变量（如带状态的计数器），往往比“计数器+标志位+排队数”的组合更高效、更稳定，也更易验证；\n热路径极致精简：高频操作的快路径应尽可能缩短，仅保留核心的原子操作和简单判断，这是高性能同步原语的核心设计原则；\n等待关系显式建模：并发中的“谁等谁”关系需显式设计，如用独立信号量承载读者等写者、写者等读者的逻辑，让整个同步协议的可推理性更强；\n设计兼顾扩展性：组件职责的解耦与边界清晰，是保证同步原语可扩展的关键，让后续新增功能时无需大幅修改核心逻辑。\n结语 sync.RWMutex的设计价值，不在于其实现了“并发读、独占写”的基础语义，而在于它将看似复杂的读写同步问题，通过极简的设计压缩为少量状态变量、两条唤醒通道和一条极短的读锁快路径。\n它并非依靠复杂的逻辑实现功能，而是通过状态编码、职责拆分、唤醒分流、热路径极简四大设计技巧，将工程质量做到了极致。对于开发基础组件、并发框架、任务调度、缓存系统的开发者而言，这一实现是并发设计的经典范本，值得反复研读和借鉴。\n源码路径：https://github.com/golang/go/blob/master/src/sync/rwmutex.go\n","permalink":"/blogs/2026/go/go-rwmutex-counter-for-fast-reads.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003eGo读写锁\u003ccode\u003esync.RWMutex\u003c/code\u003e（对应源码\u003ccode\u003esrc/sync/rwmutex.go\u003c/code\u003e）是标准库中设计精妙的同步工具，其核心语义清晰明确：支持任意多个读者同时持有读锁，或仅允许一个写者持有写锁；当有写者等待获取锁时，新的读者会被阻塞，以此避免写者出现饥饿问题。\u003c/p\u003e","title":"Go RWMutex 源码分析：一个计数器，如何把“读多写少”做得又快又稳"},{"content":"前言 在K8s（Kubernetes）集群中，我们每天部署Pod、运行服务，却很少深究一个核心问题：Pod是怎么被分配到具体节点（Node）上运行的？\n其实这背后全靠「调度器」在默默工作——kube-scheduler，作为K8s Master节点的核心组件，它的职责只有一个：为每个待调度的Pod，找到最适合它的Node。今天就用通俗的语言+精简实操例子，把K8s调度的过程、原理讲透，新手也能轻松理解。\n一、先搞懂：K8s调度的核心逻辑（一句话总结） 调度的本质：筛选合格节点 → 给合格节点打分 → 选最高分节点绑定Pod。\n类比生活场景：你要找一间办公室（Pod），先筛选出“面积够大、有空调、在市中心”的合格写字楼（过滤），再给这些写字楼打分（交通便利度、租金、环境），最后选分数最高的入驻（绑定）。kube-scheduler就是这个“找办公室的人”。\n核心前提：未被调度的Pod，其spec.nodeName字段为空；调度完成后，kube-scheduler会将选中的Node名称写入该字段，Node上的kubelet看到后，就会拉取镜像、启动容器。\n二、K8s调度完整过程（分3步，附精简例子） 整个调度流程分为「过滤（Predicate）→ 打分（Priority）→ 绑定（Bind）」三步，每一步都有明确的逻辑和实操场景，我们结合例子逐个拆解。\n第一步：过滤（Predicate）—— 淘汰“不合格”节点 过滤的核心是“排除法”：遍历集群中所有Node，根据预设规则，删掉所有不能运行当前Pod的Node，剩下的就是“候选节点”。\n常见过滤规则（结合精简例子，直接套用）：\n1. 资源足够（最基础） Pod声明的CPU、内存等资源，不能超过Node的剩余可分配资源。\n例子：创建一个Pod，声明请求CPU 1核、内存1Gi，集群中有3个Node：\nNode1：剩余CPU 0.8核 → 资源不足，被过滤\nNode2：剩余CPU 1.2核、内存1.5Gi → 合格\nNode3：剩余CPU 2核、内存2Gi → 合格\n过滤后，候选节点为Node2、Node3。\n2. 端口不冲突（避免端口占用） 如果Pod使用了hostPort（直接占用Node的端口），则该Node上的这个端口不能被其他Pod或服务占用。\n例子：Pod声明hostPort: 8080，Node2上已有一个Pod占用8080端口 → Node2被过滤，仅剩Node3为候选节点。\n3. 污点与容忍（Taint/Toleration）—— 节点“拒绝”不合格Pod Node可以设置“污点”（Taint），表示“我不接受某些Pod”；Pod必须设置“容忍”（Toleration），才能被调度到有对应污点的Node上。\n精简例子（实操可直接执行）：\n给Node3设置污点：kubectl taint nodes node3 key=value:NoSchedule（NoSchedule表示“不调度新Pod到该节点，已有Pod不受影响”）\n若Pod未设置容忍，则Node3被过滤，无候选节点（Pod会处于Pending状态）；\n给Pod添加容忍，即可调度到Node3：\napiVersion: v1 kind: Pod metadata: name: test-pod spec: tolerations: # 容忍Node3的污点 - key: \u0026#34;key\u0026#34; operator: \u0026#34;Equal\u0026#34; value: \u0026#34;value\u0026#34; effect: \u0026#34;NoSchedule\u0026#34; containers: - name: nginx image: nginx:alpine resources: requests: cpu: \u0026#34;1\u0026#34; memory: \u0026#34;1Gi\u0026#34; 4. 节点亲和性（NodeAffinity）—— 主动“选择”符合条件的Node 通过标签（Label）控制Pod调度到指定类型的Node上，比nodeSelector更灵活。\n精简例子：\n给Node2、Node3打标签：kubectl label nodes node2 node3 env=prod（标记为生产环境节点）\n创建Pod时，设置亲和性，只调度到env=prod的Node上：\napiVersion: v1 kind: Pod metadata: name: prod-pod spec: affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: # 调度时必须满足 nodeSelectorTerms: - matchExpressions: - key: env operator: In values: - prod # 只选标签为env=prod的Node containers: - name: nginx image: nginx:alpine 此时，若集群中还有Node4（标签env=test），会被过滤掉，仅Node2、Node3为候选。\n补充：其他常见过滤规则还包括「节点健康（未NotReady）」「未被封锁（cordon）」「PVC存储匹配」等，只要有一条不满足，Node就会被淘汰。\n第二步：打分（Priority）—— 给候选节点“排先后” 过滤后得到候选节点，接下来调度器会给每个候选节点打分（0~100分），分数越高，越适合运行当前Pod。打分的核心逻辑是「资源利用率均匀、负载最低」，避免单节点压力过大。\n常见打分策略（结合例子理解）：\n1. LeastRequested（默认策略）—— 负载最低优先 计算节点的资源剩余比例，剩余越多，分数越高。公式简化：分数 = （1 - 已用资源/总资源）× 100\n例子：候选节点Node2、Node3，总CPU均为2核、总内存均为2Gi：\nNode2：已用CPU 0.5核、内存0.5Gi → 剩余比例高 → 打分80分\nNode3：已用CPU 1核、内存1Gi → 剩余比例低 → 打分60分\n此时Node2分数更高，成为首选。\n2. BalancedResourceAllocation —— 资源使用均匀优先 优先选择CPU和内存利用率最均衡的节点，避免“单种资源耗尽、另一种资源闲置”。\n例子：Node2（CPU利用率30%、内存利用率70%），Node3（CPU利用率50%、内存利用率50%） → Node3更均衡，打分更高。\n3. NodeAffinity —— 亲和性加分 若Pod设置了亲和性，满足亲和性条件的节点会额外加分（比如加10分），进一步提升优先级。\n第三步：绑定（Bind）—— 确定最终节点并执行 打分完成后，调度器选择分数最高的Node，将Node名称写入Pod的spec.nodeName字段，这个过程就是「绑定」。\n绑定完成后，该Node上的kubelet会实时监听自身节点的Pod列表，发现新绑定的Pod后，立即拉取镜像、启动容器，Pod状态从Pending变为Running，调度完成。\n三、调度核心补充（实操中必遇） 1. 调度是“一次性”的（默认不重调度） Pod一旦被调度到某个Node，除非Pod重建（比如删除重启、滚动更新），否则不会被重新调度。即使Node负载变高，调度器也不会主动将Pod迁移到其他节点（需借助第三方工具，如Descheduler）。\n2. 抢占机制（Preemption）—— 高优先级Pod“挤走”低优先级 若所有Node都没有足够资源，高优先级的Pod会“抢占”低优先级Pod的资源：删除低优先级Pod，释放资源后，将高优先级Pod调度到该Node。\n例子：Node2上有一个低优先级Pod（优先级10），此时调度一个高优先级Pod（优先级100），且Node2是唯一候选节点 → 低优先级Pod被删除，高优先级Pod被调度到Node2。\n3. 常见调度异常及解决（精简版） Pod一直Pending，事件显示“No nodes available to schedule pods” → 检查过滤规则（资源不足、污点无容忍、亲和性不匹配）；\nPod调度到错误节点 → 检查Node标签、亲和性配置，或是否有污点未处理；\n高优先级Pod无法调度 → 检查是否开启抢占机制，或低优先级Pod是否可被删除。\n四、总结（一句话串起所有逻辑） 用户创建Pod（spec.nodeName为空）→ 进入待调度队列 → kube-scheduler过滤掉不合格Node → 给候选Node打分 → 绑定最高分Node → kubelet启动容器 → 调度完成。\nK8s调度的核心，本质是“按需分配、负载均衡”，通过过滤和打分，既保证Pod能正常运行，又能让集群资源利用率最大化。结合上面的精简例子，大家可以动手实操一遍，就能快速掌握调度的核心逻辑，遇到调度问题也能快速定位原因。\n","permalink":"/blogs/2026/k8s/introduction-to-kubernetes-scheduling.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在K8s（Kubernetes）集群中，我们每天部署Pod、运行服务，却很少深究一个核心问题：\u003cstrong\u003ePod是怎么被分配到具体节点（Node）上运行的？\u003c/strong\u003e\u003c/p\u003e","title":"一文读懂K8s调度：原理+实操精简例子"},{"content":"前言 在MySQL的EXPLAIN分析中，type字段是衡量SQL性能的核心指标，它直接反映了MySQL查找数据的访问策略，不同的type类型对应不同的查询效率，掌握其含义和差异，是优化SQL语句的关键。本文将按照效率从低到高的顺序，逐一拆解每种type类型的含义、适用场景、实战示例及性能特点，帮助大家直观理解并快速判断SQL性能。\n一、type字段核心说明 type字段用于描述MySQL执行查询时的“访问类型”，即如何查找表中的数据。其效率等级从低到高依次为：ALL \u0026lt; index \u0026lt; range \u0026lt; ref \u0026lt; eq_ref \u0026lt; const/system。需要注意的是，type并非判断SQL性能的唯一标准，还需结合EXPLAIN结果中的rows（预估扫描行数）、Extra（额外执行信息）等字段综合判断，但type字段的优先级最高，是定位性能瓶颈的首要参考。\n二、各type类型详解（按效率从低到高） 1. ALL（全表扫描）—— 效率最低 含义：MySQL会扫描整张表的所有行，逐行判断是否满足WHERE条件，是最原始、效率最低的访问方式，无任何索引利用。\n触发场景：\n表中没有建立任何可用索引；\n索引失效（如对索引字段使用函数、模糊查询以%开头、隐式类型转换等）；\n查询条件不涉及任何索引字段，只能遍历全表。\n实战示例：\n-- 假设user表中age字段未建立索引，触发全表扫描 EXPLAIN SELECT * FROM user WHERE age = 20; -- 执行结果中，type=ALL，Extra=Using where（表示需通过WHERE条件过滤数据） 性能特点：查询性能与表行数正相关，表行数越多，耗时越长。例如百万级数据量的表，全表扫描可能耗时数秒，是SQL优化需优先规避的类型。\n2. index（全索引扫描）—— 略优于ALL 含义：相比ALL略有优化，MySQL不会扫描表中的数据行，而是遍历整个索引树（仅扫描索引，无需回表查询实际数据），本质是“全表扫描的索引版”。\n触发场景：查询的所有字段都包含在某个索引中（即覆盖索引），但查询条件无法缩小索引范围，只能遍历整个索引树获取数据。\n实战示例：\n-- 先给user表的age字段建立普通索引 CREATE INDEX idx_age ON user(age); -- 查询字段仅为age（索引字段），无过滤条件，触发全索引扫描 EXPLAIN SELECT age FROM user; -- 执行结果中，type=index，Extra=Using index（表示使用覆盖索引，无需回表） 性能特点：效率高于ALL，因为索引文件通常比数据文件小，遍历索引的速度更快，但仍需扫描整个索引，数据量大时依然存在性能瓶颈。\n3. range（范围索引扫描）—— 中等效率 含义：MySQL仅扫描索引的某个特定范围，而非整个索引树，是基于索引的范围查询，效率远高于ALL和index。\n触发场景：查询条件包含范围筛选，且筛选字段已建立索引，常见的范围条件包括：\u0026gt;、\u0026lt;、\u0026gt;=、\u0026lt;=、BETWEEN\u0026hellip;AND\u0026hellip;、IN、LIKE \u0026lsquo;xxx%\u0026rsquo;（右模糊查询）等。\n实战示例：\n-- 1. BETWEEN范围查询（age字段有索引） EXPLAIN SELECT * FROM user WHERE age BETWEEN 18 AND 30; -- 2. IN列表范围查询（id字段有索引） EXPLAIN SELECT * FROM user WHERE id IN (1,2,3); -- 3. 右模糊查询（name字段有索引） EXPLAIN SELECT * FROM user WHERE name LIKE \u0026#39;张%\u0026#39;; -- 以上语句执行结果中，type均为range 性能特点：效率取决于范围大小，范围越小，扫描的索引行数越少，性能越好；范围越大，性能越接近index类型。range是SQL优化的基础目标，避免ALL和index后，优先优化到range级别。\n4. ref（非唯一索引扫描）—— 高效 含义：MySQL利用非唯一索引（或唯一索引的非唯一前缀）进行等值匹配，能匹配到一组满足条件的行（多行），无需扫描整个索引或表。\n触发场景：查询条件为“等值匹配”（=），且筛选字段建立了非唯一索引（如普通索引、联合索引的第一个字段），索引字段的值不唯一。\n实战示例：\n-- age字段是普通索引（非唯一），一个age值可能对应多个用户 EXPLAIN SELECT * FROM user WHERE age = 20; -- 执行结果中，type=ref 性能特点：效率远高于range，因为能直接定位到索引中匹配的值，仅扫描匹配的少量行，是高频查询的理想优化目标之一。\n5. eq_ref（唯一索引扫描）—— 接近顶级效率 含义：多表连接场景中，被连接表使用唯一索引（主键或唯一索引）进行等值匹配，驱动表每一行数据，在被连接表中最多匹配一行（注：如果被连接表匹配多行时，如果被驱动表有非唯一索引则 type=ref，无索引则 type=ALL），实现真正的 1:1 查找。\n触发场景：\n多表 JOIN 时，连接条件为被连接表的唯一索引（如 ON t2.pk = t1.fk）； 单表主键等值查询（WHERE pk = const）通常被优化为 const，而非 eq_ref，eq_ref 主要用于多表连接。 实战示例：\nEXPLAIN SELECT * FROM orders o JOIN user u ON o.user_id = u.id WHERE o.id = 5; -- 若 u.id 是主键，u 表 type = eq_ref 性能特点：效率极高，驱动表每一行仅需常数时间查找被连接表数据，是多表连接的理想访问类型。\n6. const / system（常量/系统查询）—— 效率最高 含义：这是两种效率最高的type类型，本质是MySQL在查询优化阶段就能确定查询结果，无需在执行阶段扫描表或索引，直接返回结果。\nsystem：特殊的const类型，仅适用于只有1行数据的系统表（如mysql.user、mysql.db等系统自带的极小表），日常业务查询中几乎不会遇到；\nconst：通过主键或唯一索引进行等值查询，且查询结果只有1行，MySQL优化器会将其视为“常量”，查询前就确定结果。\n触发场景：主键或唯一索引的等值查询，且结果唯一。\n实战示例：\n-- id是主键，查询id=1必然只有1行，触发const类型 EXPLAIN SELECT * FROM user WHERE id = 1; -- 执行结果中，type=const 性能特点：极致高效，查询耗时可忽略不计，是MySQL能达到的最优查询状态，仅适用于主键/唯一索引的单值查询场景。\n三、易混点与实战判断技巧 1. 避免单一依赖type判断性能 type字段虽重要，但不能单独作为判断SQL性能的唯一标准。例如：type=range，但rows字段（预估扫描行数）极大（如百万行），其实际性能可能不如type=ref（但rows字段很小）；再如，type=ref，但Extra字段出现Using filesort（文件排序）、Using temporary（临时表），也会严重影响性能。\n2. 核心优化目标 杜绝ALL（全表扫描）和index（全索引扫描），通过建立合适的索引、优化查询条件（避免索引失效）规避；\n普通查询（如列表查询）尽量优化到range级别及以上；\n核心高频查询（如详情查询、核心业务接口）尽量达到ref/eq_ref级别；\nconst/system是理想状态，仅适用于主键/唯一索引的单值查询，无需刻意追求。\n3. 实战示例对比 SQL语句 type类型 效率等级 SELECT * FROM user; ALL 最差 SELECT age FROM user; index 差 SELECT * FROM user WHERE age \u0026gt; 20; range 中 SELECT * FROM user WHERE age = 20; ref 好 SELECT * FROM user WHERE id = 100; const 最好 四、总结 MySQL EXPLAIN中的type字段，本质是MySQL读取数据的“访问策略”，其效率等级从低到高为：ALL \u0026lt; index \u0026lt; range \u0026lt; ref \u0026lt; eq_ref \u0026lt; const/system。其中，ALL和index是性能瓶颈，需优先优化；range是基础优化目标，ref/eq_ref是高频查询的理想状态，const/system是极致高效的特殊场景。\n在实际SQL优化中，需结合type、rows、Extra三个字段综合判断，同时结合业务场景建立合适的索引、优化查询条件，才能真正提升SQL查询性能。掌握type字段的含义和差异，能快速定位SQL性能问题，为优化方向提供核心参考。\n","permalink":"/blogs/2026/db/mysql-explain-type.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在MySQL的EXPLAIN分析中，type字段是衡量SQL性能的核心指标，它直接反映了MySQL查找数据的访问策略，不同的type类型对应不同的查询效率，掌握其含义和差异，是优化SQL语句的关键。本文将按照效率从低到高的顺序，逐一拆解每种type类型的含义、适用场景、实战示例及性能特点，帮助大家直观理解并快速判断SQL性能。\u003c/p\u003e","title":"MySQL EXPLAIN 中 type 字段详解"},{"content":"一、Survivor区核心设计思想 Survivor区（幸存者区）是Java虚拟机（JVM）堆内存中年轻代的重要组成部分，核心设计思想围绕「高效垃圾回收、避免内存碎片、筛选长期存活对象」展开，本质是为了配合年轻代的复制回收算法，减少老年代的内存压力，提升整个JVM的运行效率。\n补充基础：年轻代主要存放刚创建的短生命周期对象，默认由 Eden区（新对象分配区）+ 2个Survivor区（S0/S1，也叫From/To区）组成，三者默认大小比例为8:1:1，这是基于“98%的对象都是朝生夕死”的特性设计的，Survivor区就是用来“筛选”出那2%可能长期存活的对象，避免它们过早进入老年代（老年代回收效率极低）。\n二、为什么必须设计两个Survivor区？ 年轻代的垃圾回收（Minor GC）采用「复制算法」，核心逻辑是：将存活对象从一个区域复制到另一个区域，然后清空原区域，这样能快速回收内存，且不会产生内存碎片（内存碎片会导致后续分配大对象时，即使总内存足够，也无法找到连续空间而触发频繁GC）。\n两个Survivor区的存在，正是为了让复制算法能高效、简单地运行，核心作用是「轮流作为“源区”和“目标区”」，实现“一次复制、一次交换”的循环逻辑，具体原因有2点：\n保证复制的“干净性”：每次Minor GC时，存活对象会从「Eden区 + 当前使用的Survivor区（源区）」复制到「空闲的Survivor区（目标区）」，目标区始终是空的，能确保复制过去的存活对象不会和旧对象混合，避免内存碎片，也无需额外判断“哪些是存活对象”，提升效率。\n实现对象年龄统计：对象每在两个Survivor区之间复制一次（即经历一次Minor GC），年龄就会增加1，当年龄达到阈值（默认15次，由JVM参数控制），就会晋升到老年代。两个区的轮换，能清晰记录对象的存活次数，筛选出真正长期存活的对象，避免老年代被短生命周期对象占用而频繁触发Full GC（Full GC会导致程序卡顿）。\n三、为什么不设计一个Survivor区？ 如果只设计一个Survivor区，会彻底破坏复制算法的逻辑，带来两个无法解决的问题，初学者可以简单理解为“顾此失彼”：\n复制时会破坏原对象：Minor GC需要先判断Eden区和Survivor区的存活对象，再复制到目标区。如果只有一个Survivor区，复制时会把存活对象复制到同一个区，此时原存活对象还没被清空，会和新复制的对象混合，导致JVM无法区分“已复制的存活对象”和“未判断的对象”，要么漏回收，要么误回收，逻辑彻底混乱。\n无法统计对象年龄，且产生内存碎片：没有空闲的目标区，复制后的存活对象会零散分布在Survivor区，产生内存碎片；同时，无法记录对象经历了多少次Minor GC，要么让对象过早进入老年代（增加老年代压力），要么让对象一直留在Survivor区（占满空间，导致后续对象无法存放），最终导致GC效率暴跌，程序运行卡顿。\n简单类比：一个Survivor区就像“只有一个房间，既要住人，又要打扫卫生”，打扫时人只能暂时站在房间里，会挡住打扫的地方；两个Survivor区就像“两个房间，人先搬到空房间，再彻底打扫原房间”，高效又干净。\n四、Survivor区实际运行示例 结合默认的Eden:S0:S1 = 8:1:1比例，用“步骤+通俗解释”说明Survivor区的运行过程，忽略复杂参数，只看核心流转：\n初始状态 Eden区（8份）：可分配新对象；S0（1份）：空闲；S1（1份）：空闲（初始时两个Survivor区都是空的，第一次GC后才会有角色区分）。\n步骤1：分配对象（Eden区满，触发第一次Minor GC） 程序频繁创建新对象（比如new String()、new 数组），所有新对象都分配到Eden区；\n当Eden区被占满，JVM触发第一次Minor GC，开始清理Eden区的垃圾对象（不再被引用的对象）；\n把Eden区中存活的对象，复制到S0（此时S0是“目标区”，S1仍然空闲）；\n复制完成后，清空Eden区，此时S0存放存活对象（年龄=1），S1为空，角色定义：S0=From区（下次GC的源区），S1=To区（下次GC的目标区）。\n步骤2：第二次Minor GC（Eden区再次满） 程序继续创建对象，Eden区再次被占满，触发第二次Minor GC；\n清理Eden区和From区（S0）的垃圾对象，把两个区域中存活的对象，复制到To区（S1）；\n复制时，所有存活对象的年龄+1（此时存活对象年龄=2）；\n复制完成后，清空Eden区和S0（From区），角色交换：S1=From区，S0=To区（下次GC时反向复制）。\n步骤3：循环流转，直到对象晋升老年代 每次Eden区满，触发Minor GC，存活对象就从「Eden+当前From区」复制到「当前To区」，年龄+1，然后交换From/To区的角色；\n当某个对象的年龄达到阈值（默认15次，即经历15次Minor GC后仍然存活），就会直接晋升到老年代，不再在两个Survivor区之间流转；\n特殊情况：如果某次复制时，To区放不下所有存活对象，多余的存活对象会直接晋升到老年代（避免Survivor区溢出）。\n示例简化总结 Eden区生对象，Minor GC后存活对象去Survivor，两个Survivor区轮流“存存活对象、空着等复制”，对象住得越久（年龄越大），最终搬到老年代“养老”，全程不产生碎片，还能高效筛选长期对象。\n五、初学者重点总结 Survivor区核心作用：配合复制算法，避免内存碎片，统计对象年龄，筛选长期存活对象。\n双区设计：为了实现“源区→目标区”的复制+交换，让GC高效、简单运行，解决单区的逻辑混乱和碎片问题。\n运行核心：Eden区满触发Minor GC，存活对象在两个Survivor区间复制、年龄递增，达到阈值晋升老年代。\n","permalink":"/blogs/2026/java/java-survivor-zone-learning-notes.html","summary":"\u003ch2 id=\"一survivor区核心设计思想\"\u003e一、Survivor区核心设计思想\u003c/h2\u003e\n\u003cp\u003eSurvivor区（幸存者区）是Java虚拟机（JVM）堆内存中\u003cem\u003e年轻代\u003c/em\u003e的重要组成部分，核心设计思想围绕「高效垃圾回收、避免内存碎片、筛选长期存活对象」展开，本质是为了配合年轻代的复制回收算法，减少老年代的内存压力，提升整个JVM的运行效率。\u003c/p\u003e","title":"Java Survivor区学习笔记"},{"content":"前言 很多刚学 MySQL 的同学都会听到一句话：\n复合索引必须满足最左匹配原则，否则索引不会生效。\n但如果你在 MySQL 8.x 的环境中测试，会发现一个奇怪现象：\nCREATE INDEX idx_user_age_city ON user(age, city); 查询：\nSELECT * FROM user WHERE city = \u0026#39;beijing\u0026#39;; 居然也可能走索引！\n这和我们熟悉的 最左匹配原则似乎矛盾。\n实际上：\n最左匹配原则仍然成立，但 MySQL 8.x 引入了一些优化机制，使得“看起来违反最左匹配”的查询仍然可以利用索引。\n本文会从 底层原理 + 实际例子 + 执行计划，带你彻底理解这个问题。\n一、什么是复合索引 复合索引（Composite Index）指：\n一个索引包含多个列\n例如：\nCREATE INDEX idx_user_age_city ON user(age, city); 索引顺序是：\n(age, city) 在 B+Tree 中的排序结构是：\n(age1, city1) (age1, city2) (age1, city3) (age2, city1) (age2, city2) (age3, city1) 可以理解为：\n先按 age 排序 age 相同再按 city 排序 二、最左匹配原则（经典规则） MySQL 使用复合索引时必须遵循：\n从最左列开始连续匹配\n索引：\n(age, city, gender) 可以使用索引\nage age + city age + city + gender 例如：\nSELECT * FROM user WHERE age = 20; SELECT * FROM user WHERE age = 20 AND city=\u0026#39;shanghai\u0026#39;; SELECT * FROM user WHERE age = 20 AND city=\u0026#39;shanghai\u0026#39; AND gender=\u0026#39;male\u0026#39;; 无法使用索引（经典理解）\nSELECT * FROM user WHERE city=\u0026#39;shanghai\u0026#39;; 因为：\n缺少最左列 age 所以传统结论：\n不会走索引\n但在 MySQL 8.x 里，有时会发现：\ntype: index 或者\nUsing index 这是为什么？\n三、MySQL 8.x 的优化：Index Skip Scan MySQL 8.0 引入了一个优化：\nIndex Skip Scan（索引跳跃扫描）\n它允许：\n跳过最左列，直接利用后面的列查询\n例如索引：\n(age, city) 查询：\nSELECT * FROM user WHERE city = \u0026#39;beijing\u0026#39;; MySQL 会做什么？\n逻辑类似：\n遍历所有 age 值 再在每个 age 内查 city=\u0026#39;beijing\u0026#39; 伪代码：\nfor age in distinct(age): search (age, \u0026#39;beijing\u0026#39;) 也就是说：\n(age1, beijing) (age2, beijing) (age3, beijing) 逐个扫描。\n四、Index Skip Scan 的执行示意 假设索引：\n(age, city) 索引结构：\n(18, beijing) (18, shanghai) (19, beijing) (20, shanghai) (21, beijing) 查询：\nSELECT * FROM user WHERE city=\u0026#39;beijing\u0026#39;; MySQL 实际执行：\n查找 (18, beijing) 查找 (19, beijing) 查找 (20, beijing) 查找 (21, beijing) 这就是：\n跳过 age，只利用 city\n五、什么时候 MySQL 会使用 Skip Scan MySQL 不会无脑使用这个优化。\n通常满足：\n条件1：最左列基数很小\n例如：\ngender (2个值) status (3个值) 例如索引：\n(status, create_time) 查询：\nWHERE create_time \u0026gt; \u0026#39;2025-01-01\u0026#39; MySQL 可以：\nstatus=0 + create_time status=1 + create_time status=2 + create_time 扫描 3 次即可。\n条件2：统计信息允许\nMySQL 会估算：\n扫描成本 VS 全表扫描 如果 Skip Scan 更快才会使用。\n条件3：索引不是特别大\n如果最左列基数很大，例如：\nuser_id 那就不会使用。\n六、EXPLAIN 示例 表：\nCREATE TABLE user( id INT PRIMARY KEY, age INT, city VARCHAR(20), INDEX idx_age_city(age, city) ); 查询：\nEXPLAIN SELECT * FROM user WHERE city=\u0026#39;beijing\u0026#39;; 可能看到：\ntype: range key: idx_age_city Extra: Using where 说明：\nMySQL 使用了复合索引 即使：\n没有 age 条件 七、Index Condition Pushdown（ICP） 另一个容易误解的优化是：\nIndex Condition Pushdown\nICP 作用是：\n先用索引过滤 再回表 例如：\n索引：\n(age, city) 查询：\nSELECT * FROM user WHERE age \u0026gt; 20 AND city=\u0026#39;beijing\u0026#39;; 流程：\n扫描 age\u0026gt;20 的索引 在索引层判断 city=\u0026#39;beijing\u0026#39; 减少回表 这也是：\n索引看起来“用了更多列”\n但实际上：\n仍然满足最左匹配 八、覆盖索引（另一个常见原因） 如果查询字段全部在索引中：\nSELECT city FROM user WHERE city=\u0026#39;beijing\u0026#39;; 即使索引：\n(age, city) MySQL 也可能：\n直接扫描索引 执行计划：\ntype: index Extra: Using index 这叫：\n覆盖索引扫描\n不是严格的索引查找。\n九、总结：为什么不满足最左匹配也走索引 在 MySQL 8.x 中常见原因有 3 个：\n原因 解释 Index Skip Scan 跳过最左列扫描 覆盖索引扫描 直接扫描索引 ICP 优化 在索引层过滤 因此：\n最左匹配原则没有失效，只是 MySQL 更聪明了。\n十、生产环境最佳实践 1 不依赖 Skip Scan\nSkip Scan 只是优化：\n性能不可控 生产索引仍然建议：\nWHERE 常用字段放最左 例如：\n(city, age) 如果查询：\nWHERE city 2 高选择性字段放前\n原则：\n区分度高的列放前 例如：\nuser_id \u0026gt; city \u0026gt; gender 3 使用 EXPLAIN 验证\n查看：\ntype key rows extra 避免：\ntype = ALL 十一、一句话总结 记住一句核心原则：\n复合索引仍然遵循最左匹配，只是 MySQL 8.x 通过 Skip Scan、ICP、覆盖索引等优化，让部分“不满足最左匹配”的查询也能利用索引。\n","permalink":"/blogs/2026/db/the-leftmost-index-rule-is-not-always-true-mysql-8-x-explained.html","summary":"\u003ch1 id=\"前言\"\u003e前言\u003c/h1\u003e\n\u003cp\u003e很多刚学 MySQL 的同学都会听到一句话：\u003c/p\u003e\n\u003cblockquote\u003e\n\u003cp\u003e\u003cstrong\u003e复合索引必须满足最左匹配原则，否则索引不会生效。\u003c/strong\u003e\u003c/p\u003e\n\u003c/blockquote\u003e\n\u003cp\u003e但如果你在 \u003cstrong\u003eMySQL 8.x\u003c/strong\u003e 的环境中测试，会发现一个奇怪现象：\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003eCREATE INDEX idx_user_age_city ON user(age, city);\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003e查询：\u003c/p\u003e","title":"MySQL 复合索引：为什么不满足最左匹配有时也能走索引？（MySQL 8.x 新特性详解）"},{"content":"前言 对于开发人员及数据库学习者而言，MySQL作为主流关系型数据库，其底层运行机制是实现高效数据操作与系统优化的核心基础。MySQL的底层原理核心在于“分层架构分工+核心组件协同”，本文将以专业严谨的视角，结合实际应用场景，系统拆解MySQL底层核心逻辑，辅以直观说明，帮助读者深入理解其运行机制。\n一、MySQL整体架构：分层设计与职责划分 ┌─────────────────┐ │ 客户端层 │ # Navicat/命令行/应用程序等SQL请求发起端 │ （Client） │ └────────┬────────┘ │ 发起SQL指令（增/删/改/查） ┌────────▼────────┐ ┌────────────────────────────────────────┐ │ SQL 层 │ │ 核心职责 │ │ （Server层） │◄─┤ 解析/优化SQL、权限/连接管理、生成Binlog │ │ ┌─────────────┐ │ └────────────────────────────────────────┘ │ │ Parser解析器│ │ │ │ Optimizer优化器││ │ │ 权限/连接管理 ││ │ └─────────────┘ │ └────────┬────────┘ │ 下达标准化数据操作指令（通过存储引擎API） ┌────────▼────────┐ ┌────────────────────────────────────────┐ │ 存储引擎层 │ │ 核心组件 │ │ （InnoDB为主） │◄─┤ 缓冲池/日志系统/B+树索引/MVCC/行锁 │ │ ┌─────────────┐ │ └────────────────────────────────────────┘ │ │ Buffer Pool ││ # 内存缓存，减少磁盘I/O │ │ Redo/Undo Log││ # 崩溃恢复/事务回滚 │ │ B+树索引 ││ # 快速数据定位 │ │ MVCC/行锁 ││ # 并发控制/隔离性保障 │ └─────────────┘ │ └────────┬────────┘ │ 与操作系统交互，执行物理数据读写 ┌────────▼────────┐ │ 操作系统层 │ # 磁盘I/O调度、系统缓存 └────────┬────────┘ │ 最终数据持久化/读取 ┌────────▼────────┐ │ 磁盘存储 │ # 数据文件/日志文件物理存储 └─────────────────┘ MySQL底层采用分层架构设计，整体可划分为两大核心层级，各层级职责明确、协同工作，共同完成数据的存储、查询与管理操作，确保系统的高效与稳定。\n1. 上层：SQL层（核心管理层） 所有SQL操作指令（查询、新增、修改、删除等）均首先进入SQL层，该层级主要承担指令解析、优化、权限校验及连接管理等核心职责，不直接参与数据的物理存储与读取，具体功能如下：\nSQL解析：将用户编写的结构化查询语言（SQL）解析为MySQL可识别的底层执行指令，例如将“SELECT name FROM users”语句转换为对应的数据查询操作指令；\nSQL优化：通过内置优化器分析SQL语句的多种执行路径，选择最优执行方案，例如优先使用索引查询替代全表扫描，降低系统开销；\n权限管理：对用户的数据库操作权限进行校验，确保用户仅能执行其权限范围内的操作，例如限制普通用户的数据库删除权限；\n连接管理：负责处理客户端与MySQL服务器的连接请求，包括连接建立、维护与释放，支持Navicat、命令行等多种客户端连接方式。\n2. 下层：存储引擎层（数据操作层） SQL层完成指令解析与优化后，将具体的数据操作指令传递至存储引擎层，该层级负责数据的物理读取、写入与存储，是直接与底层存储介质交互的核心组件。\nMySQL支持多种存储引擎，其中InnoDB作为MySQL 5.5及以后版本的默认存储引擎，因其支持事务、行级锁、崩溃恢复等特性，成为生产环境中的首选。此外，MyISAM、Memory等存储引擎适用于特定场景，但在数据安全性与并发处理能力上均不及InnoDB，因此本文重点围绕InnoDB展开讲解。\n3. 数据流转完整流程 MySQL的数据流转遵循固定流程，确保指令执行的有序性与数据的一致性，具体流程如下：客户端发起SQL请求，请求首先进入SQL层，经过解析、优化与权限校验后，通过存储引擎API将操作指令传递至InnoDB存储引擎，InnoDB与操作系统交互，从磁盘中读取或写入数据，最终将操作结果通过SQL层反馈至客户端。\n具体流转路径为：客户端 → SQL层（解析→优化→权限检查） → 存储引擎API → InnoDB → 操作系统 → 磁盘\n核心要点：SQL层负责指令的解析与调度，存储引擎层负责数据的实际操作，两者分工协作，有效提升系统运行效率与可维护性。\n二、InnoDB核心原理：四大核心组件支撑高效安全运行 InnoDB能够成为主流存储引擎，核心在于其包含四大核心组件：页面与区、缓冲池、日志系统（Redo Log与Undo Log）、MVCC（多版本并发控制），四大组件协同工作，确保数据的高效存取、安全可靠与并发处理能力。\n1. 页面（Page）与区（Extent）：数据存储的基本单元 InnoDB对磁盘数据的存储采用结构化管理，通过固定的存储单元组织数据，避免数据零散存储导致的查询效率低下问题，具体存储单元定义如下：\n页（Page）：InnoDB的最小数据读写单元，默认大小为16KB，无论数据操作的规模大小，InnoDB均以页为单位进行数据读写，确保数据操作的规范性与高效性；\n区（Extent）：由64个连续的页组成，单个区的大小为16KB×64=1MB，主要用于存储同一类数据（如一张数据表的全部数据），通过区的划分，提升数据定位与管理效率。\n通过页面与区的分层存储设计，InnoDB可快速定位数据所在的物理位置，减少磁盘I/O开销，为高效数据操作奠定基础。\n2. 缓冲池（Buffer Pool）：提升数据访问效率的核心缓存 由于磁盘读写速度远低于内存读写速度，InnoDB专门开辟了一块内存区域作为缓冲池（Buffer Pool），用于缓存常用的数据页与索引页，核心目的是减少磁盘I/O操作，提升数据访问效率。\n缓冲池的核心工作逻辑：当执行数据查询操作时，首先检查缓冲池中是否存在目标数据页；若存在，则直接从内存中读取数据，大幅提升查询速度；若不存在，则从磁盘中读取对应数据页，同时将该数据页缓存至缓冲池中，为后续同类查询操作提供便利。\n例如，当频繁查询“用户id=100的信息”时，首次查询需从磁盘读取对应数据页并缓存至缓冲池，后续查询可直接从缓冲池读取，查询效率可提升10倍以上。\n缓冲池的命中率是衡量MySQL性能的重要指标，生产环境中，缓冲池命中率需保持在99%以上，才能确保系统的高效运行。\n3. 日志系统（Redo Log + Undo Log）：保障数据安全性的核心机制 在数据操作过程中，可能出现MySQL服务崩溃、服务器断电等异常情况，导致数据操作中断，日志系统的核心作用是应对此类异常，确保数据不丢失、可恢复，分为Redo Log（重做日志）与Undo Log（回滚日志）两部分。\n（1）Redo Log（重做日志）：数据恢复的核心保障 Redo Log的核心功能是记录数据修改的具体操作，当MySQL服务出现异常崩溃时，重启后可通过Redo Log重新执行数据修改操作，恢复未完成的数据更新，避免数据丢失。\n关键技术：InnoDB采用“写前日志”（WAL，Write-Ahead Logging）机制，即先将数据修改操作记录至Redo Log，再修改缓冲池中的数据。该机制确保即使数据修改过程中出现异常，Redo Log中已记录的操作可用于数据恢复，保障数据的持久性。\n（2）Undo Log（回滚日志）：事务回滚与并发控制的支撑 Undo Log的核心功能是记录数据修改前的原始状态，当执行错误的数据操作（如误删、误改数据）时，可通过Undo Log将数据回滚至修改前的状态；同时，Undo Log也是MVCC（多版本并发控制）机制的核心支撑，为并发数据访问提供保障。\n例如，将用户id=100的姓名修改为“张三”时，Undo Log会记录该用户修改前的姓名“李四”，若发现修改错误，执行ROLLBACK（回滚）操作，InnoDB将通过Undo Log恢复该用户的原始姓名。\n4. MVCC（多版本并发控制）：解决并发读写冲突的核心方案 在高并发场景下，多个事务同时对同一数据表进行读写操作时，易出现数据不一致、读写阻塞等问题，MVCC机制通过多版本数据管理，实现“读写不阻塞、读读不阻塞”，有效提升并发处理能力。\nMVCC核心原理：InnoDB为数据表中的每一行数据分配版本号，每次修改数据时，会生成新的版本数据，保留旧版本数据不删除。不同事务读取数据时，将根据自身的隔离级别，读取对应版本的数据，从而避免写操作对读操作的干扰，实现非阻塞读。\n具体应用示例（基于时间轴）：\n时间t0：用户表中，id=100的姓名为“李四”，版本号=1；\n时间t1：事务A执行更新操作，将id=100的姓名修改为“张三”，生成新版本数据，版本号=2（未提交）；\n时间t2：事务B查询id=100的姓名，因事务A未提交，事务B读取版本号=1的数据，即“李四”；\n时间t3：事务A提交，版本号=2的数据正式生效；\n时间t4：事务B再次查询id=100的姓名，读取版本号=2的数据，即“张三”。\nMVCC机制的核心价值在于实现非阻塞读，提升并发处理效率，需注意的是，MVCC仅在REPEATABLE READ（可重复读）与READ COMMITTED（读已提交）隔离级别下生效，这也是这两种隔离级别在生产环境中被广泛应用的核心原因。\n三、索引核心：B+树结构与索引分类 索引是提升MySQL查询效率的核心组件，其本质是一种数据结构，用于快速定位数据表中的目标数据。若未建立索引，MySQL将采用全表扫描的方式查询数据，效率极低；建立合理的索引，可大幅降低查询开销，提升系统响应速度。\nMySQL索引的底层采用B+树结构，该结构为高度优化的树状结构，专门针对磁盘存储场景设计，具备查询高效、磁盘友好等优势。\n1. B+树的核心优势 高度低：B+树的高度通常仅为3-4层，即使数据表中存在数百万、数千万条数据，从根节点到叶子节点的查询仅需3-4次磁盘I/O，查询效率极高；\n磁盘友好：B+树的每个节点大小恰好等于InnoDB的一个页（16KB），读取一个节点即完成一次磁盘I/O，有效减少磁盘I/O次数；\n范围查询高效：B+树的所有叶子节点通过链表连接，执行范围查询（如“id between 100 and 200”）时，找到起始叶子节点后，可通过链表快速遍历所有符合条件的节点，无需回溯，提升范围查询效率。\n需重点区分B+树与B树的差异：B+树的非叶子节点仅存储索引键与指针，不存储实际数据，所有实际数据均存储在叶子节点中；这种设计可使非叶子节点存储更多索引键，进一步降低树的高度，提升查询效率。\n2. 核心索引分类：聚簇索引与二级索引 InnoDB支持两种核心索引类型，两者分工明确、协同工作，结合具体应用场景合理设计索引，可最大化提升查询效率（假设数据表users：id为主键，name、email为普通字段）。\n（1）聚簇索引（主键索引）：数据与索引一体化存储 InnoDB的主键索引即为聚簇索引，其核心特点是“数据即索引，索引即数据”，聚簇索引的叶子节点存储的是数据表的整行数据，而非单纯的索引值。也就是说，聚簇索引与数据紧密绑定，找到聚簇索引即可直接获取对应行数据。\n（2）二级索引（普通索引）：基于主键的间接查询 除主键索引外，为其他字段建立的索引均为二级索引，二级索引的叶子节点不存储整行数据，仅存储对应的主键值。\n示例：查询“SELECT name FROM users WHERE email='a@b.com\u0026rsquo;”，其执行流程如下：\n通过email字段的二级索引，查询到对应的主键id=100；\n通过聚簇索引（主键索引），根据id=100查询到整行数据，提取name字段并返回结果。\n上述“通过二级索引查询主键，再通过聚簇索引查询数据”的过程称为“回表”。基于此特性，主键不宜设计过长（如避免使用UUID），因为二级索引会存储主键值，主键过长会增加二级索引的存储空间，降低索引查询效率。\n四、事务与隔离级别：保障数据一致性的核心机制 事务是数据库中一组不可分割的操作集合，其核心目标是确保多步数据操作“要么全部执行成功，要么全部执行失败”，避免出现数据不一致的情况。例如，转账操作中，从A账户扣除100元与向B账户增加100元，需作为一个事务执行，确保两者同时成功或同时失败。\n事务具备四大核心特性（ACID），是数据库保证数据一致性的基础，由“事务之父”吉姆·格雷提出，也是所有关系型数据库必须满足的核心特性：\n原子性（Atomicity）：事务中的所有操作是一个不可分割的整体，要么全部执行完成，要么全部执行失败并回滚，不存在部分执行的情况；\n一致性（Consistency）：事务执行前后，数据表中的数据需符合预设的业务规则，例如转账操作后，A、B两个账户的总金额保持不变；\n隔离性（Isolation）：多个事务同时执行时，相互之间不产生干扰，每个事务都能看到独立的数据视图，隔离性通过MVCC与锁机制实现；\n持久性（Durability）：事务提交后，数据将永久存储在磁盘中，即使MySQL服务崩溃，重启后数据也不会丢失，持久性通过Redo Log机制实现。\nMySQL的四种隔离级别 隔离性的核心是控制多个事务之间的干扰程度，MySQL提供四种隔离级别，从低到高依次为READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ、SERIALIZABLE，不同隔离级别对应不同的并发处理能力与数据一致性保障，具体说明如下：\nREAD UNCOMMITTED（读未提交）：最低隔离级别，一个事务可读取另一个事务未提交的修改数据，易出现“脏读”问题（即读取到无效数据），实际生产环境中几乎不使用；\nREAD COMMITTED（读已提交）：一个事务仅能读取另一个事务已提交的修改数据，可避免脏读问题，适用于大多数普通业务场景，是多数系统的首选隔离级别；\nREPEATABLE READ（可重复读，MySQL默认）：一个事务内多次读取同一数据，结果始终保持一致，可避免“不可重复读”问题；InnoDB通过Next-Key Lock机制，进一步避免“幻读”问题（即事务查询范围内出现新增数据），兼顾并发效率与数据一致性；\nSERIALIZABLE（串行化）：最高隔离级别，所有事务按顺序串行执行，完全避免并发干扰，数据一致性最高，但并发效率极低，仅适用于数据一致性要求极高的场景（如银行核心转账系统）。\n五、核心总结：MySQL底层原理核心要点 MySQL底层原理虽涉及多个组件与机制，但核心可归纳为三大要点，掌握这些要点，可快速理清MySQL的运行逻辑：\n架构分工：SQL层负责指令解析、优化与调度，存储引擎层负责数据的物理操作，InnoDB作为默认存储引擎，是数据存储与并发处理的核心；\n核心组件：缓冲池提升数据访问效率，B+树索引实现快速数据定位，日志系统保障数据安全，MVCC机制解决并发读写冲突，四大组件协同支撑MySQL高效、安全运行；\n一致性保障：事务ACID特性与四种隔离级别，确保多并发场景下的数据一致性，避免出现数据异常。\n总体而言，MySQL底层原理的核心目标是解决“数据快速查询、安全存储、并发无冲突”三大问题，通过分层架构、核心组件与事务机制的协同作用，实现高效、稳定、可靠的数据管理，为各类业务系统提供支撑。\n","permalink":"/blogs/2026/db/mysql-core-mechanisms.html","summary":"\u003ch1 id=\"前言\"\u003e前言\u003c/h1\u003e\n\u003cp\u003e对于开发人员及数据库学习者而言，MySQL作为主流关系型数据库，其底层运行机制是实现高效数据操作与系统优化的核心基础。MySQL的底层原理核心在于“分层架构分工+核心组件协同”，本文将以专业严谨的视角，结合实际应用场景，系统拆解MySQL底层核心逻辑，辅以直观说明，帮助读者深入理解其运行机制。\u003c/p\u003e","title":"MySQL底层原理详解"},{"content":"前言 硅谷知名投资人Chamath Palihapitiya，他把自己30多年的人生经验和思考浓缩成一段约25分钟的讲话（视频地址：https://www.youtube.com/watch?v=LOMzvEBuR4o），听完后挺有感触，所以将内容做一下总结分享，有兴趣可以看一下原视频。\n1. 不要只追求金钱，而是专注过程 Chamath指出，很多年轻人把赚钱和目标导向看得过重，但真正值得追求的是学习、成长和对事物深入思考的过程。金钱很容易吸引注意，但它不应该成为你生活的中心。\n2. 避免负债，保留自由 债务往往会让你失去探索和冒险的自由。负债会拖累你的时间和精力，让你不得不把注意力放在短期目标上，而不是长期成长和风险学习。\n3. 与真正聪明和支持你的人在一起 Chamath强调，与比你聪明、年轻或思维敏捷的人保持互动，可以扩展你的视野并不断刺激自己成长。同时，他认为在生活中找到一个“百分之百支持你的人”，不论是朋友还是伴侣，都极其重要。\n4. 工作不是生活之外的东西 他反对传统的“工作生活平衡”说法，而认为当你真正爱上某件事情时，你会把它视为生活的一部分，而不是额外任务。即使投入大量时间，也是一种享受。\n5. 面对挑战，坚持希望 视频中提到，心理学实验显示：有希望的人会比没有希望的人表现出更强的坚持力。真正的成功不是没有困难，而是即使面对失败也能坚持不放弃。\n6. 地位是“人造的”，不要被它牵着走 Chamath认为，社会上很多关于“升职”、“头衔”、“地位”的追求其实是虚幻的，这些只是别人设定的等级。他建议把时间和精力都放在自己真正想做、真正重要的事情上。\n核心观点总结 成功不是一夜之间得来的，而是多年积累的思考和习惯。 与优秀的人共事、不断学习比单纯追求金钱更重要。 真正的成长来自于热爱过程，而不是追逐结果。 保持希望和勇气，是面对挫折最关键的能力。 ","permalink":"/blogs/2026/live/25-minute-billionaire-wisdom-30-years-of-life-advice.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e硅谷知名投资人Chamath Palihapitiya，他把自己30多年的人生经验和思考浓缩成一段约25分钟的讲话（视频地址：https://www.youtube.com/watch?v=LOMzvEBuR4o），听完后挺有感触，所以将内容做一下总结分享，有兴趣可以看一下原视频。\u003c/p\u003e","title":"视频总结：30年经验浓缩到25分钟 — 亿万富翁的人生建议"},{"content":"前言 在高并发架构设计中，我们早已习惯将 Redis 当作“加速工具”——作为 MySQL 的缓存层，缓解磁盘 IO 压力、降低接口延迟。但随着业务峰值越来越极端（比如电商大促、直播秒杀），传统 Cache-Aside 模式的一致性痛点、MySQL 磁盘读写的性能瓶颈，逐渐成为架构升级的绊脚石。\n今天，我们聊一个反常规但可落地的创新思路：Redis-First 架构——将 Redis 从“缓存/加速层”升级为“主存储/首选读写层”，在特定场景下直接替代 MySQL，实现吞吐与延迟的量级提升。\n核心结论先给到位：在明确场景边界（高并发、数据模型适配、可接受的持久化策略）下，该方案完全可行。通过主从复制+分级持久化+热冷分层等工程手段，既能把数据安全性、存储成本控制在可接受范围，还能简化缓存一致性带来的大量工程开销，尤其适配核心高并发链路。\n一、为什么要“反常规”？Redis 替代 MySQL 的核心动因 不是为了“炫技”，而是高并发场景下的必然选择——传统架构的痛点，只有打破“Redis 只做缓存”的固有认知，才能高效解决。\n1. 性能差距：量级级的延迟碾压 高并发场景对 IO 延迟极度敏感，而 Redis 与 MySQL 的读写性能，本质上是“内存 vs 磁盘”的差距：Redis 的内存读取是 O(1) 操作，而 MySQL 的磁盘/索引查找是 O(logN) 甚至更高复杂度，两者在吞吐、延迟上能差数十倍到上百倍。\n比如会话存储、商品售罄标识、排行榜这类场景，用 Redis 直接承接读写，能轻松扛住 MySQL 难以承受的峰值压力，这也是我们优先考虑迁移的核心场景。\n2. 一致性简化：告别缓存层的“一地鸡毛” 传统 Cache-Aside 模式（读走缓存、写更数据库+删缓存），需要额外做大量工程优化来规避缓存穿透、雪崩、双删不一致等问题，复杂度随业务迭代不断上升。\n而 Redis-First 架构，直接将 Redis 当作主库，把一致性问题简化到数据库层——通过 Redis 自身的复制、持久化机制保障数据可靠，无需再为“缓存与数据库同步”头疼，大幅降低工程维护成本。\n3. 生态成熟：Redis 早已具备“主存储”能力 很多架构师的顾虑是“Redis 太轻，撑不起主存储”，但实际上 Redis 生态早已完成迭代：Redis Enterprise、Redis-on-Flash、RediSearch 等组件，已经在多个大厂的核心链路中，被用于“主数据存储”或高并发场景优化，验证了 Redis 作为主存储的可行性。\n二、可行性论证：三大核心顾虑，逐一破解 将 Redis 作为主存储，架构师最关心的三个问题：数据安全、复杂查询能力、内存成本。这三点都有成熟解决方案，无需过度担心。\n1. 数据安全：持久化+复制，兜底可靠性 Redis 并非“内存易失”，其提供 AOF、RDB 两种持久化方式，搭配多种 appendfsync 策略，可根据业务 SLA 灵活选择：\neverysec：每秒执行一次 fsync，通常仅丢失最多 1s 数据，兼顾性能与可靠性，适合大多数非核心业务；\nalways：每次写操作都执行 fsync，数据安全性最高，但会显著影响性能，适合支付、记账等强一致场景。\n推荐实操做法：主库（负责写入）开启 AOF 持久化，根据业务分级选择策略；同时配置多副本与自动主从切换，确保主库故障时秒级切换，搭配 AOF 延迟、复制滞后监控，进一步降低数据丢失风险——这一套组合拳，已经过大量工程案例验证，可靠性不输 MySQL。\n2. 复杂查询：RediSearch 补位，不盲目替代 Redis 作为 KV 存储，天生不擅长复杂关联查询，但这并不意味着无法承接复杂读场景：Redis Stack / RediSearch 提供倒排索引、聚合、全文检索能力，对于商品搜索、标签检索、计数聚合等常见场景，完全可以替代 MySQL 或外部搜索系统，且延迟更有优势。\n核心原则：不追求“一刀切”替代。将复杂且对相关性要求极高的搜索（比如多字段复杂排序、精准相关性评分），留给 Elasticsearch/Opensearch 这类专门搜索引擎；而延迟敏感、查询模式可索引化的场景，直接迁移到 RediSearch，实现“各司其职、性能最优”。\n3. 内存成本：热冷分层，把钱花在“刀刃上” 最大的顾虑之一，就是“全量数据放内存成本太高”。但目前已有两类成熟解决方案，能将内存成本压低到可接受范围，甚至接近 MySQL 存储成本：\n热冷分离 + Redis on Flash / Auto-Tiering：将键和索引保留在内存（保障查询速度），冷数据自动沉降到 SSD，访问时再拉回内存。比如 Redis Enterprise 的 Flash 技术，已在多个大厂落地，能显著降低内存开销；华为云发布的 Redis 混合存储版，更是能将同等容量成本降低 2/3，读写性能可达纯内存的 85%。\n兼容协议的 KV 引擎：比如 Kvrocks、RocksDB 后端，在成本敏感、延迟要求可放宽的场景，用这类持久化 KV 存储替代纯内存 Redis，兼顾成本与性能。\n推荐实操做法：只将**工作集（hot set，高频访问数据）**放在内存，冷数据自动沉降至 SSD；同时根据 SLA 调整访问后的升温策略（异步预热、队列化），既控制成本，又不影响热点数据的访问性能。\n三、风险与缓解：工程落地的关键避坑点 没有完美的架构，Redis 替代 MySQL 也存在一定风险，但只要做好分级管控和兜底策略，就能将风险降到最低。\n1. 数据丢失/一致性风险（最核心） 风险点：AOF everysec 仍可能丢失 ≤1s 数据；always 策略会大幅影响写入性能。\n缓解方案：按业务分级管控——支付、记账等强一致业务，采用 AOF always 策略，或二级同步到关系库做兜底；非关键业务（如排行榜、会话），采用 everysec 策略，同时同步写入下游审计日志或消息队列，作为二次数据保障。\n2. 复杂查询能力不足 风险点：部分复杂跨表 join、OLAP 查询，不适合 Redis 的 KV 风格。\n缓解方案：不强行迁移——复杂 OLAP、多表 join 保留到专门系统（如 MySQL、ClickHouse）；能用 RediSearch 实现的倒排、聚合查询，优先迁移；无法迁移的复杂读请求，通过后端服务统一处理，实现“写走 Redis、复杂读走后端”的混合模式。\n3. 运维复杂度上升 风险点：Redis 主从复制、热冷分层、持久化等机制，会增加监控、运维的复杂度，容易出现复制滞后、热冷抖动等问题。\n缓解方案：构建完善的监控体系，重点监控复制延迟、AOF 落盘延迟、主从健康、内存命中率、SSD 命中率；设置自动降级策略（本地从库不可用 → 读主库或回退到后端服务）；借助成熟运维工具链（Redis Sentinel / Redis Cluster / Redis Enterprise），降低运维成本。\n4. 热备份/灾备 实操做法：跨 AZ/Region 部署只读副本，定期将快照导出到冷存储；对于重要表、关键业务，采用“双写”或“异步落库”方式，同时写入关系型 DB 做审计，实现“Redis 做主存储、MySQL 做灾备审计”的双重保障。\n四、直接可落地：Redis-First 架构实现例子 架构\n不用复杂重构，按以下 5 步推进，即可快速落地 Redis-First 架构，适合大多数高并发业务场景。\n1. 网关层：边缘读优先，极致降低延迟 每个网关节点部署 Nginx + Lua，同时在网关本地部署 Redis 只读从库（仅承接读请求）；Lua 脚本拦截读请求，简单 key 查询直接从本地从库返回，写请求、复杂查询透传至后端 Java 服务。\n核心优势：读请求零跳转后端，大幅降低网络开销和后端压力；本地从库通过主从复制保持数据近实时，延迟可控制在毫秒级——这一思路与“本地缓存+Redis 二级缓存”的高性能架构异曲同工，能进一步放大 Redis 的性能优势。\n2. 后端写入层：统一入口，保障持久化 Java 服务集群作为统一写入入口，所有写操作优先落到 Redis 主库（开启 AOF + RDB 备份策略），并同步到各只读从库（包括网关本地从库）；对于关键写事务，额外写入消息队列或审计库，作为二次持久化保障，避免数据丢失。\n3. Redis 主从与复制：高可用兜底 主库专注于写入，按业务分级配置 AOF 策略；从库（含网关本地从库）以异步复制为主，重点监控复制滞后情况，一旦超过阈值，立即触发降级（如直接读主库、回退到后端服务），避免脏读。\n4. 热冷分层：成本优化核心 启用 Redis Enterprise Flash / Auto-Tier 或 Kvrocks/RocksDB 后端，实现热数据（工作集）存内存、冷数据沉降 SSD；根据业务热点，调整数据升温策略，确保冷数据访问时的延迟可控。\n5. 监控与兜底：保障稳定运行 实时监控核心指标：复制延迟、从库存活、AOF fsync 延迟、内存命中率、SSD 命中率；设置兜底策略，确保任何环节故障时，系统能自动降级，不影响业务可用性。\n五、适用场景与实施路线（优先级明确） Redis 替代 MySQL 不是“全量替代”，而是“精准迁移”，按以下优先级推进，收益最高、风险最低。\n优先迁移场景（高收益、低改造） 售罄标识、库存预占（需做好幂等保障）、会话与用户态快速读写、排行榜、限流计数器、短期缓存型实体——这类场景数据模型简单、高并发、延迟敏感，迁移成本低，能快速享受到性能提升。\n谨慎迁移场景（需多验证） 复杂跨表 join 报表、强事务一致账务、对全文检索相关性要求极高的搜索——这类场景不适合直接迁移，可采用“混合模式”，或先通过 RediSearch 做验证，再逐步迁移。\n分阶段实施路线（可直接照搬） PoC 阶段（2–6 周）：选择 1–2 个非关键但高并发的业务（如商品列表热读、售罄标识），实现 Redis-First 网关+本地只读从库架构，跑完整压测，验证 AOF 策略、复制滞后等核心指标。\n平台封装阶段（2–4 月）：将读拦截、降级、监控、热冷自动分层等能力，封装成共享组件（如 Nginx+Lua 模板、复制策略、运维脚本），降低后续迁移成本。\n分阶段迁移+灾备演练（持续）：先迁移“可最终一致”类业务，再评估强一致业务的迁移可行性；同时定期开展灾备演练，确保数据安全，逐步实现核心链路的 Redis-First 架构落地。\n六、总结：Redis 替代 MySQL，核心是“取舍与适配” Redis 替代 MySQL 做主存储，不是否定 MySQL，而是在高并发场景下，选择更合适的工具做“更擅长的事”——Redis 承接高并发读写、保障低延迟，MySQL （或其他专用系统）承接复杂查询、做灾备审计，形成互补。\n其核心可行性，在于三点：一是 Redis 生态的成熟，解决了数据安全、复杂查询、成本控制等核心痛点；二是 Redis-First 架构简化了缓存一致性工程，降低了维护成本；三是热冷分层等技术，打破了内存成本的制约。\n对于架构师而言，无需固守“Redis 只做缓存”的固有认知，只要明确场景边界、做好风险管控、按阶段落地，就能用 Redis-First 架构，轻松破解高并发场景的性能瓶颈，实现架构的高效升级。\n","permalink":"/blogs/2026/redis/redis-first-replace-mysql.html","summary":"\u003ch1 id=\"前言\"\u003e前言\u003c/h1\u003e\n\u003cp\u003e在高并发架构设计中，我们早已习惯将 Redis 当作“加速工具”——作为 MySQL 的缓存层，缓解磁盘 IO 压力、降低接口延迟。但随着业务峰值越来越极端（比如电商大促、直播秒杀），传统 Cache-Aside 模式的一致性痛点、MySQL 磁盘读写的性能瓶颈，逐渐成为架构升级的绊脚石。\u003c/p\u003e","title":"架构破局 - Redis 不再做缓存！替代 MySQL 做主存储"},{"content":"1 引言：为什么要学提示词 AI 已成为编程助手（代码生成、重构、自动测试、文档生成、bug 定位等）的核心工具。要把 AI 用好，写清晰、高效的提示词比简单输入问题更重要。\n好的提示词能：缩短开发周期、提高代码质量、减少反复试错、稳定输出风格与格式。\n2 基础概念与提示词结构 提示词 prompt是你给 AI 的指令。一般包含几个核心要素，缺一不可：\n角色/身份（role）：告诉模型以什么身份回答（例如 你是资深后端工程师），明确专业视角。\n任务描述（task）：精准定义要完成的工作（例如 请实现一个分页查询接口），避免模糊表述。\n输入上下文（context）：提供必要的代码片段、接口定义、数据库结构或样例数据，减少模型猜测。\n输出约束（format）：规定输出语言、代码风格、函数签名、注释规范及是否需要测试用例。\n示例（examples）：少样本（few-shot）示例，给模型示范期望的输出样式与逻辑。\n质量控制指令（constraints）：明确性能要求（如时间复杂度）、依赖限制（禁止外部依赖）、输出边界（只给代码块）等。\n提示词示例结构（伪模板）\n系统：你是一个经验丰富的 Python 工程师，回答需简洁且只输出代码块。 用户： 任务：根据下面的接口说明实现函数 `get_user_page`。 上下文：数据库表结构、示例输入/输出。 约束：用 SQLAlchemy，实现分页，返回 JSON 可序列化结果，不使用原生 SQL。 示例：输入 → 输出 示例（可选）。 请开始实现，并给出简单的单元测试。 3 通用模板与基础示例 以下是编程场景中高频使用的提示词模板，可直接复制修改复用，搭配示例帮你快速上手。\n模板 A — 生成函数（简单场景）\n系统：你是资深 {语言} 工程师，回答要直接给出可运行的代码和必要注释。 用户：任务：实现一个函数 `FUNC_NAME`，功能：{功能描述}。 上下文：如果需要，附上输入输出示例；依赖库：{依赖列表或无}。 约束：请不要打印额外文本，仅返回代码块。写 1-2 个单元测试。 示例（Python — 字符串反转）\n系统：你是资深 Python 工程师，回答只包含代码块。 用户：任务：实现 `reverse_words(s: str) -\u0026gt; str`，把一句话中单词顺序翻转，保留单词内部顺序。 约束：写 pytest 单元测试。 期望输出：包含目标函数与 pytest 测试用例的可运行 Python 代码块。\n模板 B — 修复 Bug（定位与修复）\n系统：你是调试专家，回答先指出 bug 的位置与原因，然后给出修复后的完整代码和简短说明。 用户：有以下代码（贴出代码），表现为：{错误现象，例如抛异常、结果不对}，请修复并给出测试用例。 约束：保留原有 API，尽量改动最小。 4 进阶技巧 掌握基础模板后，运用以下进阶技巧，可大幅提升提示词的精准度与输出质量。\n4.1 分步式提示（Decompose） 将复杂任务拆解为多个小步骤，要求模型按流程执行并返回每步结果（适合交互式场景），减少一次性输出的错误率。\n1) 首先分析需求并列出实现步骤。 2) 给出伪代码。 3) 翻译为目标语言实现。 4) 给出测试用例并验证逻辑。 核心优势：便于逐步修正偏差，降低模型理解复杂需求的难度。\n4.2 Few-shot（少样本示范） 提供 1-3 个高质量示例，示范输入输出逻辑与代码风格。示例需短小精悍，覆盖边界场景，帮助模型快速对齐预期。\n4.3 约束输出格式（强制机器可解析） 若需 JSON、YAML、固定函数签名等结构化输出，需明确格式要求并给出 schema。例如：只返回 JSON 格式，键名包括 code、desc、test_case，其中 code 为完整代码块。\n4.4 定制“系统提示”与角色 在多轮对话或 API 调用中，将长期约束写入系统提示，固定回答风格。例如：你是遵循 PEP8 规范的 Python 工程师，所有代码必须包含类型注解与函数注释，不输出任何解释性文字。\n4.5 温度与随机性控制 需稳定、可复现代码时，设置低温度（0–0.2），减少模型创造性输出。\n需灵感、多样化实现方案时，设置高温度（0.7+），鼓励模型探索不同思路。\n4.6 工具/函数调用（模型支持时） 将可执行函数签名传给模型，让其返回结构化调用结果，便于后续自动化处理。例如，让模型生成符合特定函数格式的参数，直接对接业务代码。\n4.7 提示重写（Prompt Tuning） 对同一任务尝试不同措辞，记录各版本输出效果，通过 A/B 测试筛选最稳健的提示词，形成个人模板库。\n5 编程场景下的高质量提示示例 以下为高频编程场景的完整提示词，可直接复制使用，适配 FastAPI、Jest 等主流工具。\n示例 1 — 生成 REST 接口（Python + FastAPI）\n系统：你是资深后端工程师，熟悉 FastAPI、Pydantic 与 SQLAlchemy。回答只返回代码块，代码可直接运行。 用户： 任务：实现一个分页用户列表接口 `GET /users`，支持 `page` 和 `size` 参数，返回 JSON：{total:int, page:int, size:int, items:[{id:int,name:str,email:str}]} 上下文：数据库模型 User(id:int,name:str,email:str)，使用 SQLAlchemy ORM。 约束：避免 N+1 查询，加入简单的输入验证，写一个 pytest 测试覆盖主要逻辑。 示例 2 — 自动生成单元测试（JavaScript/Node）\n系统：你是资深 JS 测试工程师，熟悉 Jest。回答只返回代码块，包含测试用例与简短设计说明。 用户：这里是一个函数（贴代码），请为其生成 5 个边界覆盖的 Jest 单元测试，并解释每个测试用例的设计目的（一句话/个）。 约束：不要改变被测试函数的签名。 示例 3 — 重构建议 + 代码输出\n系统：你是资深架构师，写作风格简洁，优先考虑代码可读性、扩展性与可维护性。 用户：请阅读下面代码（贴代码），提出 3 条重构建议并据此输出重构后的代码（只输出修改后的文件内容）。 6 提示词调试与版本管理 好的提示词是迭代出来的，通过科学的调试与版本管理，可持续优化输出质量。\n细粒度修改：每次仅调整一个维度（如约束条件、示例数量），便于定位优化点与回滚。\n记录与对比：用文档或 Git 保存提示词版本，同步记录对应输出效果（示例输入+模型输出），形成迭代日志。\n自动化测试：将模型输出纳入 CI 流程，检查是否符合函数签名、通过静态类型检查与单元测试。\n指标化评估：定义量化标准（如编译通过率、测试覆盖率、静态分析分数），客观评价提示词效果。\n7 常见问题与解决方法（FAQ） 问：模型输出不稳定、每次结果不一样，怎么办？\n答：设置低温度（0–0.2），固定系统提示与角色，增加少样本示例，同时强制输出格式（如固定函数结构），减少随机性。\n问：AI 产生错误或不安全的代码，如何规避？\n答：切勿直接将生成代码用于生产。需搭配自动化测试、静态检查、安全扫描，关键场景必须人工审核；同时在提示词中明确安全约束（如禁止 SQL 注入、避免硬编码密钥）。\n问：模型写错 API 调用或出现拼写错误，如何修正？\n答：提供精准的依赖库版本、API 文档片段作为上下文，补充正确的调用示例；用单元测试覆盖接口边界，强制模型对齐正确用法。\n问：如何让模型只输出代码而不附加解释？\n答：在系统提示中明确指令：只返回代码块，不输出任何解释性文字、注释外的说明，并在用户提示中重复强调，强化约束。\n问：上下文窗口不足，无法传入完整代码/文档，怎么办？\n答：仅保留最小可用上下文（核心代码片段、关键接口定义），冗余文档通过 RAG（检索增强生成）按需调取；用函数调用将大量上下文结构化，减少无效信息占用窗口。\n结束语：学习路线与实践建议 提示词工程没有捷径，核心在于“实战+迭代”，以下建议帮你快速提升：\n实战为王：覆盖多场景练习（生成代码、修 Bug、重构、写测试、生成文档），积累不同场景的模板。\n构建个人 Prompt 库：将高频任务的优质提示词版本化管理，标注适用场景与优化要点，便于复用。\n自动化评价：把模型输出纳入现有测试与 CI 流程，用量化指标替代主观判断，提升提示词稳定性。\n持续迭代：对核心业务场景的提示词做 A/B 测试，跟踪输出质量与效率，定期优化模板。\n","permalink":"/blogs/2026/ai/prompting-techniques.html","summary":"\u003ch1 id=\"1-引言为什么要学提示词\"\u003e1 引言：为什么要学提示词\u003c/h1\u003e\n\u003cp\u003eAI 已成为编程助手（代码生成、重构、自动测试、文档生成、bug 定位等）的核心工具。要把 AI 用好，\u003cstrong\u003e写清晰、高效的提示词\u003c/strong\u003e比简单输入问题更重要。\u003c/p\u003e","title":"AI 编程 - 提示词技巧"},{"content":"一、什么是Agent Skills？ Agent Skills 是由Anthropic推出的模块化技能框架/协议，用于让AI智能体（如Claude）具备结构化、可复用、可组合的专业技能，提升AI在复杂业务场景中的执行能力。\n简而言之：\nSkills是包含指令、元数据、脚本和资源的文件夹，用于定义智能体可以做什么、何时做、怎么做。\n智能体不会把所有技能一次性加载，而是在需要时动态载入——这种机制也被称作渐进式披露（Progressive Disclosure），即按需“揭示”能力。\n二、什么时候发布的？ 核心时间线 2025年10月16日：Anthropic正式在Claude系统中发布Skills功能，让Claude在不同平台和模式中加载并使用技能。\n2025年12月18日：Anthropic发布Agent Skills开放标准（Open Standard），并将协议与SDK发布到agentskills.io，推动其跨平台使用。\n三、核心特点 1. 模块化技能包（Skill Packs） 每个技能是一个明确结构的文件夹，包括：\n元数据（metadata）\nSKILL.md指令说明\n资源文件（脚本、模板、示例等）\n可选执行脚本（Python/JS/Shell等）\n这样的结构使技能可复用、可分享、可版本化。\n2. 渐进式披露（Progressive Disclosure） 智能体首次只加载基础元数据（名称＋说明），仅当任务匹配时才逐步加载完整内容，从而节省上下文空间，提高执行效率。\n3. 自动发现与加载 智能体在处理用户请求时，会自动扫描可用的Skills，并在匹配到相关Task时加载对应技能。\n4. 跨平台与开放标准 这不仅在Claude自有生态中有效，还朝跨平台兼容（如VS Code、GitHub、Cursor等）的开放标准发展。\n5. 可组合/可复用 多个技能可以组合使用，从而支持更复杂的工作流（比如数据分析→报告生成→发送邮件）。\n四、相比传统Tooling的优势 方案类型 优点 局限 普通API / 工具调用 简单，易实现 无结构化知识，不具自动选用能力 Prompt + 工具 可用性强 容易在上下文中重复输入大量说明 Agent Skills 模块化、按需加载、可组合 需要额外技能编写与管理 核心优势 优化Token使用：渐进式加载避免上下文爆炸问题。\n统一技能目录：便于团队协作、共享与版本控制。\n复用性强：写一次技能，可在多个场景/平台复用。\n开放标准社区生态：SDK + 开放规范支持跨平台生态扩展。\n五、如何实现一个Agent Skill（详细步骤） 技能文件夹结构 如下所示：\nmy-skill/ ├── SKILL.md # 核心元信息和行为说明 ├── reference.md # 参考文档（可选） ├── LICENSE.txt # 许可证（可选） ├── resources/ # 附加资源文件（可选） │ ├── template.xlsx │ └── data.json └── scripts/ # 脚本逻辑（可选） ├── index.js └── helper.py 这是最基本的组织形式；SKILL.md是必填文件，用于定义技能功能与触发条件。\nSKILL.md内容示例 --- name: \u0026#34;Document Summarizer\u0026#34; description: \u0026#34;Summarize documents into key bullet points.\u0026#34; version: \u0026#34;1.0.0\u0026#34; --- # Overview This skill summarizes input text into bullet points. 关键实现点 只把元数据加载到上下文：智能体根据描述判断是否相关。\n再根据上下文精确加载详尽指导：用于执行任务。\n可加脚本实现在离线/执行环境中运行复杂逻辑。\n六、实战技巧（落地指南） 1. 按场景拆解技能 将通用能力拆成可复用单元，如文档分析、报告生成、表格处理，这样不同任务可重复组合。\n2. 写好元信息 清晰的name + description会显著提高技能匹配准确率。\n3. 注意Token限制 因渐进式加载，合理控制SKILL.md的初始令牌消耗非常关键。\n4. 做版本控制 把Skills放在Git管理，有利于团队协作与rollback。\n七、常见注意事项（生产级） 安全性 因为Skills可以包含脚本或执行指令，必须严格审查来源与内容，避免注入风险。\n灰度策略 在生产中逐步启用技能，避免一次性加载过多引起错误链。\n与Model Context Protocol（MCP）协作 MCP负责工具/数据接入，而Skill负责行为/操作指导，两者配合可构建强大的Agent平台。\n八、总结 Anthropic的Agent Skills是一种模块化、渐进式、可复用的智能体能力标准框架，通过开放标准和SDK，支持跨平台、跨生态的技能共享。它提升了智能体执行复杂任务的效率与一致性，同时支持团队协作、版本管理与安全审计，是未来智能体生产级开发的重要组成部分。\n","permalink":"/blogs/2026/ai/anthropic-agent-skills-modular-driven-ai-agent-empowerment.html","summary":"\u003ch2 id=\"一什么是agent-skills\"\u003e一、什么是Agent Skills？\u003c/h2\u003e\n\u003cp\u003e\u003cstrong\u003eAgent Skills\u003c/strong\u003e 是由Anthropic推出的模块化技能框架/协议，用于让AI智能体（如Claude）具备结构化、可复用、可组合的专业技能，提升AI在复杂业务场景中的执行能力。\u003c/p\u003e","title":"Anthropic Agent Skills深度解析：模块化技能如何重塑AI智能体落地能力"},{"content":"前言 本文系统整理了黄仁勋、苏姿丰、李飞飞三位AI领域核心人物在公开平台的演讲原始观点，同时配套标注了对应视频引用来源及关键观点时间戳。\n这份整理内容可为AI领域的研究者、从业者等相关人士提供便捷、可溯源的参考资料，助力快速把握行业前沿动态，为相关研究与实践提供有益借鉴。\n1. 为什么要关注这些演讲与预测 2026 年，AI 不再只是实验室研究或语言 / 图像生成的玩具，而是在各个层面——从基础算力架构、物理世界认知（physical AI）、机器人、模拟训练，到行业级落地场景——走向实用、规模化与商业化。随着 NVIDIA、AMD 这样的基础设施厂商，以及研究领袖如 Fei-Fei Li 的观点放出，我们正在见证 AI 发展的下一个关键阶段。\n这些观点不仅对技术发展有指导意义，更对职业规划、行业投入和未来竞争趋势提出了现实的路线图。\n2. 黄仁勋 — NVIDIA 的全栈未来与物理 AI 视频： https://www.youtube.com/live/0NBILspM4c4\n在 CES 2026 的官方演讲直播中，NVIDIA CEO Jensen Huang（黄仁勋） 清晰地提出了以下关键观点：\n2.1 核心观点 AI 正进入“物理世界时代” — AI 不再仅仅是“语言/视觉生成工具”，而是能在真实世界中执行物理动作的系统。整场演讲强调“Full-Stack Physical AI Platform”（全栈物理 AI 平台）——包括用于感知、推理、模拟和控制的软硬件一体化体系。 Alpamayo 驱动的自动驾驶现场展示 — 演讲中展示了 NVIDIA 的推理模型 Alpamayo，这是能够进行推理式驾驶（能够理解并采取动作）的车载 AI 系统。该系统不仅基于传感器输入，还能“理解”场景并制定行为策略。 Vera Rubin AI 平台发布 — Huang 同时推出了名为 Vera Rubin 的 AI 超算系列，集成多个芯片与加速卡，是面向大规模推理与训练的下一代硬件平台。 2.2 核心变革性逻辑 黄仁勋的主题可以归纳为一句话：\n“AI 不只是语言工具，而是将认知转为行动的一种全新基础设施。”\n这意味未来 AI 技术不仅要理解世界，还要在世界中“行动”（如机器人、自动驾驶、工业控制等）。这就是所谓的“物理 AI”，也是算法与现实交互的关键突破节点。\n3. 苏姿丰（Lisa Su） — 全栈 AI 平台与算力普及 视频：https://www.youtube.com/watch?v=VIIi8nVQXa4\nAMD CEO 苏姿丰（Lisa Su） 在同一天的 CES 2026 主题演讲中提出了与 NVIDIA 不同但互补的观点，重点在于从终端到数据中心全面普及 AI 计算。\n3.1 关键观点 AI “无处不在” — Su 用一句话总结其战略：“AI Everywhere, for Everyone” —— AI 不应只停留在云端超算，它应该扩散到终端设备、边缘侧与个人电脑，以更低的门槛、更广的覆盖铺设整个运算生态。 Helios yotta-scale 平台 — AMD 展示了名为 Helios 的机架级 AI 平台，定位于面向大型模型训练与推理场景，能够在单个机架上提供 ExaFLOPS 级别的算力，适合大规模语言模型与工业级 AI 系统。 生态融合与合作展示 — Su 还邀请了 World Labs CEO 李飞飞（Fei-Fei Li） 上台演示空间智能与 3D 世界构建技术，强调 AI 与算力平台合作的重要性。 3.2 异于 NVIDIA 的战略重点 相比 NVIDIA 的“物理 AI + 全栈平台”，AMD 更强调：\n🔹 从设备到边缘的 AI 普及化 🔹 让 AI 计算更易接触、更具扩展性 🔹 开放生态协作（与合作伙伴如 World Labs 联手）\n这不仅增强了 AI 在实际应用中的可用性，还提出了一个“从中心到边缘”的双线战略。\n4. 李飞飞（Fei-Fei Li） — 空间智能与世界模型的下一个边界 视频：https://www.youtube.com/watch?v=_PioN-CpOP0\n李飞飞（Fei-Fei Li） 是 AI 领域资深学者与 World Labs 的联合创始人，她近年提出的空间智能（Spatial Intelligence）被视为生成式 AI 的下一阶段核心方向。以下观点来自她在公开平台的演讲和讨论：\n4.1 核心观点 AI 不该只在二维语言与图像层面运行，而应具备理解、生成、推理三维世界的能力——这是空间智能的核心目标。 在 World Labs 的产品演示中，通过生成 3D 世界模型（如用照片生成一个空间场景并允许用户交互探索），展示了 AI 未来不仅“看懂”世界，还可以构建“可交互、可探索的虚拟空间”。 李飞飞指出，空间智能能连接认知与行动，从而推进机器人感知、设计模拟、游戏与沉浸式内容创作等领域的变革。 4.2 为什么重要 在生成式 AI（文本/图像/视频）已经被广泛应用后，空间智能是 AI 真正“理解世界而非只描述世界”的关键。这意味着 AI 将不再只回答问题，而能生成可交互、物理一致的三维环境，这对以下领域都非常具有革命性：\n自动驾驶与机器人导航 虚拟现实 / 元宇宙构建 工业设计与仿真优化 培训与教育沉浸体验 这些都是未来几年可能爆发的应用大领域。\n5. 2026 AI 发展趋势综述 — 变革性力量 根据上述三位来自不同角色（基础设施厂商 + 智库 + 研究实践）的观点，我们可以总结出 2026 AI 的 6 大趋势：\n物理世界 AI（Physical AI）将是核心落地方式 — AI 不只局限于文本/图像，而是真正理解与作用于现实。 高性能算力成为底层生产力的基石 — 超大规模 GPU/AI 体系将支撑未来数据中心与 AI 模型。 AI 从中心化转向边缘与终端 — 从云到设备，AI 将嵌入更多场景。 空间智能和世界模型定义下一个 AI 时代 — 与传统语言模型并行的新认知范式。 生态合作比单一赛道更重要 — 企业与研究机构联合推动跨界创新。 AI 应重点关注“与人类协作”而不是替代 — 李飞飞等人强调 AI 的人类中心定位。 6. 竞争格局与未来主导力量 NVIDIA vs AMD：前者在物理 AI 和超算基础设施上强势布局，后者强调算力普及与生态合作，这意味着在 AI 行业基础建设上会出现多条路线的竞争与协同。 生态联盟更重要：如 Su 与李飞飞的合作说明，平台和模型的联合将是比单打独斗更有效的成长方式。 AI 由软件爆发转向软硬融合爆发：未来 AI 的门槛不只是算法，还包括算力、系统统筹、数据与现实世界闭环。 7. 结语 2026 年的 AI 趋势不再是单一的语言模型或图像生成，而是 理解 + 行动 + 物理现实世界的闭环。技术的升级意味着职业角色的重塑，同时也开启了大量基于空间智能、机器人、行业级 AI 系统的新机遇。\n","permalink":"/blogs/2026/ai/revolutionary-ai-trends-in-2026-and-what-comes-next.html","summary":"\u003ch1 id=\"前言\"\u003e前言\u003c/h1\u003e\n\u003cp\u003e本文系统整理了黄仁勋、苏姿丰、李飞飞三位AI领域核心人物在公开平台的演讲原始观点，同时配套标注了对应视频引用来源及关键观点时间戳。\u003c/p\u003e\n\u003cp\u003e这份整理内容可为AI领域的研究者、从业者等相关人士提供便捷、可溯源的参考资料，助力快速把握行业前沿动态，为相关研究与实践提供有益借鉴。\u003c/p\u003e","title":"2026 年 AI 革命性趋势与未来展望"},{"content":"1. 简介 Spring WebFlux 是 Spring 在 5.x 引入的响应式（Reactive）Web 框架，用于构建非阻塞、异步的网络应用。它基于 Reactive Streams 规范，并与 Project Reactor（Mono、Flux）紧密集成。WebFlux 支持运行在 Netty 等非阻塞服务器上，也可以在 Servlet 容器中以非阻塞方式运行。适合高并发、I/O 密集型场景。\n2. 核心概念与原理 响应式编程（Reactive Programming）：通过声明式的数据流和异步处理，把同步阻塞变为异步非阻塞，常用接口是 Publisher、Subscriber（Reactive Streams）。 Project Reactor：Spring 官方推荐的响应式库，提供两种主要类型： Mono\u0026lt;T\u0026gt;：表示 0 或 1 个元素的异步序列。 Flux\u0026lt;T\u0026gt;：表示 0..N 个元素的异步序列。 背压（Backpressure）：下游可以控制上游生产数据的速率，避免消费者被淹没。 非阻塞 I/O：底层使用 NIO/Netty 实现，线程不会因为等待 I/O 而被阻塞，从而用更少的线程处理更多并发连接。 事件驱动 \u0026amp; 组合算子：通过 map、flatMap、filter、retry 等操作符组合异步链条。 3. 编程模型（注解式 vs 函数式） 注解式（注解 + 控制器）：类似于 Spring MVC 的风格，使用 @RestController、@GetMapping 等注解，但方法返回 Mono/Flux。 函数式（Router + Handler）：使用 RouterFunction、HandlerFunction，更轻量、适合构建函数式 API 或做网关/代理场景。 4. 关键类与模块 Mono, Flux（Reactor 核心） WebClient：非阻塞 HTTP 客户端，替代 RestTemplate（在响应式场景中）。 WebTestClient：用于测试 WebFlux 应用。 RouterFunction, HandlerFunction：函数式路由处理。 @RestController + 注解映射：熟悉 MVC 的人更易上手。 数据访问：配合 R2DBC（响应式关系型驱动）或 Reactive MongoDB（reactive repository）。 5. 实战：常见后端能力的 WebFlux 实践示例 本节聚焦真实业务中最常用的三类基础设施：数据库、缓存、消息队列，全部以 WebFlux + 响应式方式示例，便于直接在项目中落地。\n5.1 连接数据库（响应式数据访问） 5.1.1 为什么不用 JDBC JDBC 是阻塞式的，在 WebFlux 中直接使用会阻塞 Netty 事件循环线程 正确姿势： 优先选择响应式驱动（如 R2DBC、Reactive MongoDB） 或将 JDBC 放入 boundedElastic 线程池（仅作为过渡方案） 5.1.2 R2DBC + WebFlux 示例（关系型数据库） 实体定义\n@Table(\u0026#34;user\u0026#34;) public class User { @Id private Long id; private String name; private Integer age; } Repository（响应式）\npublic interface UserRepository extends ReactiveCrudRepository\u0026lt;User, Long\u0026gt; { Flux\u0026lt;User\u0026gt; findByAgeGreaterThan(int age); } Service 层\n@Service public class UserService { private final UserRepository userRepository; public UserService(UserRepository userRepository) { this.userRepository = userRepository; } public Mono\u0026lt;User\u0026gt; getUser(Long id) { return userRepository.findById(id); } public Flux\u0026lt;User\u0026gt; listAdults() { return userRepository.findByAgeGreaterThan(18); } } Controller\n@RestController @RequestMapping(\u0026#34;/users\u0026#34;) public class UserController { private final UserService userService; public UserController(UserService userService) { this.userService = userService; } @GetMapping(\u0026#34;/{id}\u0026#34;) public Mono\u0026lt;User\u0026gt; get(@PathVariable Long id) { return userService.getUser(id); } @GetMapping public Flux\u0026lt;User\u0026gt; list() { return userService.listAdults(); } } ⚠️ 注意：事务需要使用 R2dbcTransactionManager，不能再用传统 @Transactional（JDBC 版本）。\n5.2 连接缓存（Redis 响应式） 5.2.1 使用场景 热点数据缓存 接口防刷 / 限流 会话、Token、临时状态存储 5.2.2 Reactive Redis 示例 @Service public class UserCacheService { private final ReactiveStringRedisTemplate redisTemplate; public UserCacheService(ReactiveStringRedisTemplate redisTemplate) { this.redisTemplate = redisTemplate; } public Mono\u0026lt;String\u0026gt; getUserName(Long userId) { return redisTemplate.opsForValue() .get(\u0026#34;user:name:\u0026#34; + userId); } public Mono\u0026lt;Boolean\u0026gt; cacheUserName(Long userId, String name) { return redisTemplate.opsForValue() .set(\u0026#34;user:name:\u0026#34; + userId, name, Duration.ofMinutes(10)); } } 缓存 + 数据库组合示例（Cache Aside）\npublic Mono\u0026lt;User\u0026gt; getUserWithCache(Long id) { String key = \u0026#34;user:\u0026#34; + id; return redisTemplate.opsForValue().get(key) .flatMap(json -\u0026gt; Mono.just(deserialize(json))) .switchIfEmpty( userRepository.findById(id) .flatMap(user -\u0026gt; redisTemplate.opsForValue() .set(key, serialize(user), Duration.ofMinutes(5)) .thenReturn(user)) ); } 5.3 连接消息队列（事件驱动） 5.3.1 典型应用场景 异步解耦（下单 → 通知 → 积分） 削峰填谷 日志、审计、行为采集 5.3.2 Kafka（响应式 Producer / Consumer） 发送消息（Producer）\n@Service public class EventProducer { private final KafkaSender\u0026lt;String, String\u0026gt; sender; public EventProducer(KafkaSender\u0026lt;String, String\u0026gt; sender) { this.sender = sender; } public Mono\u0026lt;Void\u0026gt; send(String topic, String msg) { return sender.send( Mono.just(SenderRecord.create(topic, null, null, msg, null)) ) .then(); } } 消费消息（Consumer）\n@Component public class EventConsumer { @PostConstruct public void consume() { KafkaReceiver.create(receiverOptions) .receive() .flatMap(record -\u0026gt; { // 业务处理 return Mono.fromRunnable(() -\u0026gt; handle(record.value())) .then(record.receiverOffset().commit()); }) .subscribe(); } } 对于 RabbitMQ，可使用 spring-rabbit-stream 或 Reactor RabbitMQ，模型类似。\n5.4 混用阻塞资源的正确姿势（兜底方案） 如果必须调用阻塞接口（如老 JDBC / SDK）：\nMono.fromCallable(() -\u0026gt; legacyService.query()) .subscribeOn(Schedulers.boundedElastic()); ⚠️ 这是妥协方案，不是推荐方案，应逐步迁移为响应式组件。\n6. WebFlux 架构选型指南 6.1 什么场景值得用 WebFlux ✅ 非常适合的场景：\nI/O 密集型系统\n网关 / BFF / API 聚合层 一个请求需要调用多个下游 HTTP / RPC / DB / MQ 高并发 + 长连接\nSSE（Server-Sent Events） WebSocket / 实时推送 外部依赖多、慢且不可控\n第三方 API 跨网络调用（云 API、跨地域） 天然事件驱动模型\n消息消费、流式处理 异步任务编排 👉 核心判断标准：\n线程是否经常“等 I/O”？ 如果是，WebFlux 值得考虑。\n6.2 什么场景千万别用 WebFlux（面试必问） ❌ 不推荐 / 慎用场景：\nCPU 密集型计算\n大量复杂计算、图像处理 WebFlux 无法让 CPU 算得更快 强依赖阻塞生态\n只能使用 JDBC / 老 SDK 无法改造为响应式 小并发、CRUD 系统\n管理后台 内部系统（QPS 很低） 团队响应式经验不足\n调试困难 心智负担明显高于 MVC 7. 完整业务链路示例（强实践） 一个接口串联 Controller → Cache → DB → MQ → 下游 HTTP\n7.1 业务场景说明 查询用户信息 先查 Redis 缓存 缓存未命中查 DB 写入访问日志到 MQ 并行调用下游风控服务 7.2 Service 编排示例 public Mono\u0026lt;UserDTO\u0026gt; getUserDetail(Long userId) { String cacheKey = \u0026#34;user:\u0026#34; + userId; Mono\u0026lt;User\u0026gt; userMono = redisTemplate.opsForValue() .get(cacheKey) .map(this::deserialize) .switchIfEmpty( userRepository.findById(userId) .flatMap(user -\u0026gt; redisTemplate.opsForValue() .set(cacheKey, serialize(user), Duration.ofMinutes(5)) .thenReturn(user)) ); Mono\u0026lt;Void\u0026gt; logMono = eventProducer.send(\u0026#34;user-log\u0026#34;, \u0026#34;query:\u0026#34; + userId); Mono\u0026lt;RiskResult\u0026gt; riskMono = webClient.get() .uri(\u0026#34;/risk/{id}\u0026#34;, userId) .retrieve() .bodyToMono(RiskResult.class) .timeout(Duration.ofSeconds(2)) .onErrorReturn(RiskResult.DEFAULT); return Mono.zip(userMono, riskMono) .flatMap(tuple -\u0026gt; logMono.thenReturn( new UserDTO(tuple.getT1(), tuple.getT2()) )); } 7.3 Controller @GetMapping(\u0026#34;/{id}/detail\u0026#34;) public Mono\u0026lt;UserDTO\u0026gt; detail(@PathVariable Long id) { return userService.getUserDetail(id); } 👉 加分点：\n缓存 / DB / HTTP 并行 MQ 解耦非核心流程 超时 + 降级清晰 8. FAQ Q1：map 和 flatMap 有什么区别？ 标准回答：\nmap：同步转换，一个元素变一个元素 flatMap：异步展开，用于返回 Mono / Flux mono.map(x -\u0026gt; x + 1); mono.flatMap(x -\u0026gt; service.call(x)); 口诀：返回值是不是 Mono/Flux？是就用 flatMap\nQ2：subscribeOn vs publishOn 对比 subscribeOn publishOn 作用范围 整个链路 之后的操作 使用场景 切换数据源线程 中途切线程 Mono.fromCallable(this::blockCall) .subscribeOn(Schedulers.boundedElastic()) .publishOn(Schedulers.parallel()); Q3：为什么 WebFlux 不等于高性能？ 标准回答（非常重要）：\nWebFlux 提升的是 并发能力和资源利用率，而不是单请求性能。\n单次请求耗时 ≈ MVC 高并发下 WebFlux 用更少线程 如果没有 I/O 阻塞，WebFlux 甚至可能更慢 9. 最佳工程实践 避免阻塞调用：不要在响应式链中调用阻塞 API（JDBC、文件 I/O 等）。如果必须调用，使用 Schedulers.boundedElastic() 并把阻塞调用放在 publishOn/subscribeOn 上。尽量使用 R2DBC、Reactive MongoDB 等响应式驱动。 限制并发与连接数：给 WebClient / Netty 配置合适的连接池、超时、重试策略，避免资源耗尽。 合理使用 flatMap vs concatMap：并发合并时用 flatMap（并行），需要顺序时用 concatMap。 处理错误：在链路的合适位置用 onErrorResume、onErrorMap 做降级与埋点。 测试：使用 WebTestClient + StepVerifier 测试响应式流行为。 指标与监控：结合 Micrometer、Prometheus、日志链路追踪（如 Sleuth 或 OpenTelemetry）观察延迟与背压情况。 上下文传递：使用 Reactor 的 Context 传递元信息（用户、traceId），注意不要滥用影响性能。 线程亲和性：不要在 Reactor 的事件循环线程上执行耗时或阻塞工作。 7. 常见问题与排查 症状：响应卡住 / 线程耗尽\n排查点：是否有阻塞调用（例如 JDBC）出现在响应式链？是否错误地在事件循环线程上执行阻塞逻辑？检查堆栈、监控线程池使用。 症状：吞吐下降 / 高延迟\n排查点：背压未正确使用、外部服务慢、连接数不足、Netty 事件循环被阻塞。 症状：和 Spring MVC 混用出现问题\n排查点：同一应用混合阻塞与非阻塞处理会带来复杂性，注意 servlet 容器下行为和 Netty 下行为的差异。 常见 NPE / 数据流为空\n检查 Mono.empty()、switchIfEmpty() 用法，以及 bodyToMono/bodyToFlux 的类型匹配。 8. 常用方法与操作符速查表 创建：Mono.just(), Mono.empty(), Mono.fromCallable(), Flux.just(), Flux.fromIterable(), Flux.range() 转换：map(), flatMap(), flatMapSequential(), concatMap() 过滤/组合：filter(), zipWith(), merge(), concat() 错误处理：onErrorResume(), onErrorReturn(), retryWhen() 调度：subscribeOn(), publishOn() 延时/节流：delayElements(), throttleFirst()（自定义操作） 流终结：collectList(), block()（仅在测试或特殊场景下谨慎使用） 9. 注意事项 \u0026amp; 性能陷阱 不要在生产代码中使用 block()，除非在启动逻辑或测试场景；block() 会阻塞线程，破坏非阻塞模型。 R2DBC vs JDBC：JDBC 是阻塞的，若在 WebFlux 中使用 JDBC，必须放到专用线程池。优先选用 R2DBC 等响应式驱动。 耗时计算要迁移到合适线程池：CPU 密集型或阻塞工作不要放在 Netty 事件循环上。 合理设置超时和限流：防止单个慢请求耗尽资源。 ","permalink":"/blogs/2026/java/spring/spring-webflux-for-starters.html","summary":"\u003ch1 id=\"1-简介\"\u003e1. 简介\u003c/h1\u003e\n\u003cp\u003eSpring WebFlux 是 Spring 在 5.x 引入的响应式（Reactive）Web 框架，用于构建\u003cstrong\u003e非阻塞、异步\u003c/strong\u003e的网络应用。它基于 Reactive Streams 规范，并与 Project Reactor（\u003ccode\u003eMono\u003c/code\u003e、\u003ccode\u003eFlux\u003c/code\u003e）紧密集成。WebFlux 支持运行在 Netty 等非阻塞服务器上，也可以在 Servlet 容器中以非阻塞方式运行。适合高并发、I/O 密集型场景。\u003c/p\u003e","title":"Spring WebFlux 入门指南（初学者快速上手）"},{"content":"前言 在高性能Go系统开发中，面对日志收集、任务调度、流式数据处理等场景，我们常常需要一种“固定内存占用、低GC压力、O(1)读写效率”的数据结构。环形队列（Ring Buffer / Circular Queue）恰好满足这些需求，成为高性能组件的核心基石。本文将聚焦环形队列的核心原理、Go语言实现中的关键技巧以及其不可替代的核心优势，帮助开发者快速掌握这一基础数据结构的设计与应用。\n一、核心原理：首尾相连的空间复用机制 环形队列的本质是“逻辑上首尾相连的线性数组”，通过指针的“绕回”操作实现空间复用，避免了普通线性队列因元素出队导致的空间浪费和频繁扩容问题。其核心设计逻辑可从“核心构成”“状态判断”“核心操作”三个维度拆解。\n1. 核心构成要素 一个完整的环形队列通常包含5个核心字段，各字段职责清晰，共同支撑队列的正常运行：\nbuf：底层存储容器，采用固定长度的数组，这是实现“固定内存”的核心基础，避免了动态扩容带来的内存波动和GC压力；\nhead：读指针，指向当前可读取元素的位置，每完成一次出队操作，指针向后移动（超出数组长度后绕回起点）；\ntail：写指针，指向当前可写入元素的位置，每完成一次入队操作，指针向后移动（超出数组长度后绕回起点）；\ncapacity：队列的最大容量，即底层数组的长度，初始化后固定不变；\nsize：当前队列中的元素数量（可选字段），用于快速判断队列空满状态，简化逻辑判断。\n2. 空满状态判断 由于队列逻辑上首尾相连，当head和tail指针指向同一位置时，可能存在“队列空”或“队列满”两种情况，业界常用两种解决方案：\n方案一：引入size字段（入门常用）：当size=0时，队列为空；当size=capacity时，队列为满。该方案逻辑直观，易于实现，适合初学者入门；\n方案二：牺牲一个槽位（高性能首选）：将队列实际可用容量设为capacity-1，约定“head == tail”时队列为空，“(tail+1)%capacity == head”时队列为满。该方案无需额外size字段，减少了字段维护成本，尤其适合无锁场景下的性能优化。\n3. 核心指针操作 环形队列的读写效率之所以能达到O(1)，核心在于指针移动的“取模运算”，通过一句简单的代码实现指针绕回：\nnextIndex := (index + 1) % capacity\n其中index可为head或tail指针，取模运算确保当指针移动到数组末尾（index=capacity-1）时，下一次移动会绕回数组起点（index=0），从而实现空间的循环复用。\n二、Go语言实现：关键编程技巧拆解 结合Go语言特性（泛型、原子操作、sync包等），我们可以实现兼顾“通用性、安全性、高性能”的环形队列。以下是实现过程中的核心编程技巧，从基础版本到并发安全版本逐步进阶。\n1. 泛型实现：类型安全与复用 Go 1.18+引入的泛型特性，解决了传统环形队列“类型固化”的问题，可实现支持任意类型的通用队列。核心技巧是通过泛型参数[T any]定义队列结构，让buf字段成为泛型切片：\ntype RingBuffer[T any] struct { buf []T // 泛型切片，支持任意类型 head int // 读指针 tail int // 写指针 size int // 当前元素数量 capacity int // 队列最大容量 } // 初始化函数，确保容量合法 func NewRingBuffer[T any](capacity int) *RingBuffer[T] { if capacity \u0026lt;= 0 { panic(\u0026#34;capacity must be greater than zero\u0026#34;) } return \u0026amp;RingBuffer[T]{ buf: make([]T, capacity), capacity: capacity, } } 该实现支持int、string、自定义结构体等任意类型，且编译期进行类型检查，避免了类型断言带来的开销和风险。\n2. 基础读写：边界处理与效率优化 入队（Push）和出队（Pop）是环形队列的核心操作，实现时需重点处理“队列满拒绝写入”“队列空拒绝读取”的边界情况，同时确保操作的原子性和效率：\n// 入队操作，返回是否成功 func (r *RingBuffer[T]) Push(v T) bool { if r.size == r.capacity { return false // 队列满，拒绝写入 } r.buf[r.tail] = v r.tail = (r.tail + 1) % r.capacity // 指针绕回 r.size++ return true } // 出队操作，返回元素和是否成功 func (r *RingBuffer[T]) Pop() (T, bool) { var zero T // 泛型零值，适配任意类型的空返回 if r.size == 0 { return zero, false // 队列空，拒绝读取 } v := r.buf[r.head] r.head = (r.head + 1) % r.capacity // 指针绕回 r.size-- return v, true } 关键技巧：通过泛型零值var zero T处理空返回场景，避免了对具体类型的依赖；指针移动采用取模运算，确保O(1)时间复杂度，且无内存分配操作，GC压力极低。\n3. 并发安全：锁机制与无锁优化 Go语言并发场景下，多goroutine读写队列会导致数据竞争，需针对性处理。常用两种方案，适配不同性能需求：\n方案一：互斥锁（sync.Mutex）（通用安全方案）：通过封装基础环形队列，添加互斥锁保护读写操作，适合多生产者、多消费者场景：\ntype SafeRingBuffer[T any] struct { rb *RingBuffer[T] mu sync.Mutex } func (s *SafeRingBuffer[T]) Push(v T) bool { s.mu.Lock() defer s.mu.Unlock() return s.rb.Push(v) // 复用基础入队逻辑 } func (s *SafeRingBuffer[T]) Pop() (T, bool) { s.mu.Lock() defer s.mu.Unlock() return s.rb.Pop() // 复用基础出队逻辑 } 方案二：无锁SPSC（单生产者单消费者）（高性能方案）：若场景固定为“一个写goroutine+一个读goroutine”，可通过atomic包保证内存可见性，替代互斥锁，消除锁开销。核心技巧是“读写指针分离”——生产者只写tail，消费者只写head，通过原子操作确保指针可见性：\nimport \u0026#34;sync/atomic\u0026#34; type SpscRingBuffer[T any] struct { buf []T cap uint64 tail uint64 // 生产者只写，消费者只读 head uint64 // 消费者只写，生产者只读 } // 入队（生产者） func (r *SpscRingBuffer[T]) Push(v T) bool { tail := atomic.LoadUint64(\u0026amp;r.tail) next := (tail + 1) % r.cap if next == atomic.LoadUint64(\u0026amp;r.head) { return false // 队列满 } r.buf[tail] = v atomic.StoreUint64(\u0026amp;r.tail, next) // 原子更新，保证可见性 return true } 4. 工程扩展：满队列处理策略 实际开发中，队列满时的处理逻辑直接影响系统稳定性，需根据业务场景选择合适策略：\n拒绝写入：基础方案，返回false，适合严格不允许丢数据、上游可重试的场景（如任务调度）；\n覆盖最老数据：日志、监控等场景常用，当队列满时，移动head指针丢弃最老数据，再写入新数据：\nfunc (r *RingBuffer[T]) PushOverwrite(v T) { if r.size == r.capacity { r.head = (r.head + 1) % r.capacity // 丢弃最老数据 r.size-- } r.buf[r.tail] = v r.tail = (r.tail + 1) % r.capacity r.size++ } 阻塞等待：结合sync.Cond实现，队列满时写goroutine阻塞，直到有元素出队，适合需要背压（Back Pressure）的任务队列场景。\n三、核心优势：为何成为高性能场景首选 环形队列之所以在日志系统、网络IO、执行器框架等高性能场景中不可或缺，核心源于其在内存、效率、扩展性上的独特优势，对比普通切片、channel等方案尤为明显。\n1. 固定内存+低GC压力 底层基于固定长度数组实现，初始化时一次性分配内存，运行期间无动态扩容、缩容操作，也无元素删除带来的内存碎片。相较于普通切片（append操作可能触发扩容，产生内存拷贝和GC），环形队列能有效降低GC负担，尤其在高频读写场景下，优势更为突出。\n2. O(1)读写效率 入队和出队操作仅涉及指针移动和取模运算，无循环、遍历等耗时操作，时间复杂度稳定为O(1)。对比链表队列（虽然理论上也是O(1)，但存在指针跳转带来的缓存不友好问题），环形队列的数组存储更易命中CPU缓存，实际运行效率更高。\n3. 灵活可控的行为模式 相较于Go语言内置的channel（并发原语，行为固定），环形队列可根据业务需求定制化扩展：支持覆盖写、阻塞写、拒绝写等多种满队列策略；支持无锁、有锁等多种并发模式；可自定义辅助方法（如Len()、IsEmpty()、IsFull()）获取队列状态，控制力更强。\n4. 适配高并发与无锁场景 基于SPSC模式的无锁实现，消除了互斥锁带来的上下文切换和阻塞开销，在单生产者单消费者场景下，吞吐率可提升3~10倍，延迟显著降低。这种特性使其成为高性能pipeline、IO处理、日志收集等场景的核心组件。\n5. 与Go生态的良好适配 结合Go泛型实现类型安全的通用队列，结合atomic包实现无锁并发，结合sync包实现多协程安全，完全适配Go语言的并发模型和语法特性。同时，业界已有成熟的第三方实现（如uber-go/ringbuffer、workiva/go-datastructures/queue），可直接用于生产环境，降低开发成本。\n四、总结：适用场景与实践建议 环形队列凭借“固定内存、O(1)效率、低GC压力、灵活扩展”的核心优势，成为高性能Go系统的基础组件。其适用场景集中在：日志收集与落盘、网络IO数据缓存、任务调度队列、流式数据处理、执行器pipeline等高频读写、对延迟和内存敏感的场景。\n实践建议：学习阶段建议手写基础版本和SPSC无锁版本，深入理解指针操作、并发安全、内存可见性等核心知识点；生产环境优先选用成熟第三方库（如uber-go/ringbuffer），避免重复造轮子；根据并发场景选择锁机制（多生产者/消费者用Mutex，SPSC用无锁），根据业务需求选择满队列处理策略（拒绝、覆盖、阻塞）。\n掌握环形队列的设计与实现，不仅能解决实际开发中的高性能数据存储问题，更能深化对Go语言并发模型、内存管理、缓存优化等底层知识的理解，为构建高性能系统奠定基础。\n","permalink":"/blogs/2025/go/go-circular-queue-principles-techniques-advantages.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在高性能Go系统开发中，面对日志收集、任务调度、流式数据处理等场景，我们常常需要一种“固定内存占用、低GC压力、O(1)读写效率”的数据结构。环形队列（Ring Buffer / Circular Queue）恰好满足这些需求，成为高性能组件的核心基石。本文将聚焦环形队列的核心原理、Go语言实现中的关键技巧以及其不可替代的核心优势，帮助开发者快速掌握这一基础数据结构的设计与应用。\u003c/p\u003e","title":"Go语言环形队列：原理剖析、编程技巧与核心优势"},{"content":"前言 NSQ作为一款轻量、高可用的分布式消息队列，其核心设计围绕NSQD（消息节点）、Topic（主题）、Channel（通道）三大核心实体展开。三者的层级关系、交互逻辑直接决定了NSQ的并发处理能力、消息可靠性与扩展性。本文结合源码片段，深入拆解它们的关系、原理、设计思想及最佳实践。\n一、核心实体关系：层级化的消息分发模型 NSQD、Topic、Channel构成“1:N:N”的层级关系，本质是通过分层实现消息的“广播分发”与“点对点消费”的结合，核心依赖映射表实现关联管理。\n1. 实体关联逻辑 NSQD 与 Topic：NSQD是独立的消息节点，内部维护topicMap map[string]*Topic，一个NSQD可管理多个Topic，即“一对多”关系。Topic是消息的分类容器，所有消息需归属某个Topic。\nTopic 与 Channel：Topic内部维护channelMap map[string]*Channel，一个Topic可关联多个Channel，即“一对多”关系。Channel是消息的分发子容器，实现消息的多副本广播（同一Topic的消息会复制到所有关联Channel）。\nChannel 与 客户端：一个Channel可连接多个消费者客户端，客户端通过订阅Channel获取消息，实现“点对点消费”（同一Channel的消息仅被一个客户端消费）。\n2. 核心源码 // NSQD核心结构体，维护所有Topic type NSQD struct { sync.RWMutex topicMap map[string]*Topic // 管理当前节点的所有Topic // 省略其他字段 } // Topic核心结构体，维护所属Channel type Topic struct { sync.RWMutex name string channelMap map[string]*Channel // 管理当前Topic的所有Channel memoryMsgChan chan *Message // 内存消息队列 backend BackendQueue // 后端存储（磁盘） // 省略其他字段 } // Channel核心结构体，对接客户端 type Channel struct { sync.RWMutex topicName string name string clients map[int64]Consumer // 连接当前Channel的客户端 memoryMsgChan chan *Message // 内存消息队列 backend BackendQueue // 后端存储（磁盘） // 省略其他字段 } 二、存储方式与并发安全设计 NSQ采用“内存+后端”混合存储保证性能与可靠性，通过读写锁实现并发安全，支撑高并发场景下的消息处理。\n1. 存储方式：内存优先，磁盘兜底 Topic和Channel均采用“内存队列（memoryMsgChan）+ 后端存储（backend）”的双层存储模型，优先使用内存提升性能，内存不足或Topic为非临时类型时写入磁盘，避免消息丢失。\n核心存储逻辑（Topic的put方法）：\nfunc (t *Topic) put(m *Message) error { // 内存队列可用、临时Topic或延迟消息，优先写入内存 if cap(t.memoryMsgChan) \u0026gt; 0 || t.ephemeral || m.deferred != 0 { select { case t.memoryMsgChan \u0026lt;- m: return nil default: break // 内存队列满，写入后端 } } // 写入后端存储（磁盘） err := writeMessageToBackend(m, t.backend) t.nsqd.SetHealth(err) if err != nil { t.nsqd.logf(LOG_ERROR, \u0026#34;TOPIC(%s) ERROR: failed to write message to backend - %s\u0026#34;, t.name, err) return err } return nil } 2. 并发安全：读写锁分级保护 NSQD、Topic、Channel均嵌入sync.RWMutex，采用“读多写少”的读写锁策略，区分读操作（获取实体）和写操作（创建实体），提升并发效率：\nNSQD创建Topic：先读锁查询topicMap，存在则直接返回；不存在则加写锁创建，避免重复创建。\nTopic创建Channel：逻辑与Topic创建一致，通过读写锁保护channelMap。\n源码示例（NSQD的GetTopic方法）：\nfunc (n *NSQD) GetTopic(topicName string) *Topic { // 先读锁查询，避免写锁阻塞读操作 n.RLock() t, ok := n.topicMap[topicName] n.RUnlock() if ok { return t } // 读锁未命中，加写锁创建 n.Lock() t, ok = n.topicMap[topicName] if ok { n.Unlock() return t } deleteCallback := func(t *Topic) { n.DeleteExistingTopic(t.name) } t = NewTopic(topicName, n, deleteCallback) n.topicMap[topicName] = t n.Unlock() t.Start() return t } 三、消息流转全链路：从Topic到客户端的分发逻辑 消息流转的核心是“Topic接收消息 → messagePump分发到Channel → Channel通过messagePump推送给客户端”，全链路由两个核心messagePump驱动。\n1. 新增Topic与写入消息 新增Topic：通过NSQD的GetTopic方法实现，支持动态创建，创建后自动启动Topic的messagePump。\n写入消息：客户端调用Topic的PutMessage方法，内部调用put方法写入内存或后端，同时更新消息计数。\n2. Topic→Channel：消息广播分发 Topic的messagePump是消息分发的核心，负责从内存/后端读取消息，广播到所有关联的Channel。核心逻辑：\nfunc (t *Topic) messagePump() { var msg *Message var buf []byte var chans []*Channel var memoryMsgChan chan *Message var backendChan \u0026lt;-chan []byte // 初始化：等待启动信号，加载当前所有Channel for { select { case \u0026lt;-t.channelUpdateChan: continue case \u0026lt;-t.pauseChan: continue case \u0026lt;-t.exitChan: goto exit case \u0026lt;-t.startChan: } break } t.RLock() for _, c := range t.channelMap { chans = append(chans, c) } t.RUnlock() if len(chans) \u0026gt; 0 \u0026amp;\u0026amp; !t.IsPaused() { memoryMsgChan = t.memoryMsgChan backendChan = t.backend.ReadChan() } // 主循环：读取消息并分发到所有Channel for { select { case msg = \u0026lt;-memoryMsgChan: // 从内存读消息 case buf = \u0026lt;-backendChan: // 从后端读消息 msg, err = decodeMessage(buf) if err != nil { continue } case \u0026lt;-t.channelUpdateChan: // Channel变化时更新列表 chans = chans[:0] t.RLock() for _, c := range t.channelMap { chans = append(chans, c) } t.RUnlock() // 动态调整消息读取源 if len(chans) == 0 || t.IsPaused() { memoryMsgChan = nil backendChan = nil } else { memoryMsgChan = t.memoryMsgChan backendChan = t.backend.ReadChan() } continue case \u0026lt;-t.exitChan: goto exit } // 分发消息到每个Channel for i, channel := range chans { chanMsg := msg // 优化：第一个Channel复用消息，避免复制，因为原始 msg 已经是全新副本，没有地方使用，所以无需重复拷贝 if i \u0026gt; 0 { chanMsg = NewMessage(msg.ID, msg.Body) chanMsg.Timestamp = msg.Timestamp chanMsg.deferred = msg.deferred } if chanMsg.deferred != 0 { channel.PutMessageDeferred(chanMsg, chanMsg.deferred) continue } err := channel.PutMessage(chanMsg) if err != nil { t.nsqd.logf(LOG_ERROR, \u0026#34;TOPIC(%s) ERROR: failed to put msg to channel(%s) - %s\u0026#34;, t.name, channel.name, err) } } } exit: t.nsqd.logf(LOG_INFO, \u0026#34;TOPIC(%s): closing ... messagePump\u0026#34;, t.name) } 3. Channel→客户端：消息推送 Channel的messagePump（由protocolV2实现）负责将Channel中的消息推送给订阅的客户端，核心逻辑：\n监听客户端状态（就绪、退出）和消息队列（内存/后端）；\n客户端就绪时，从Channel的内存/后端读取消息，发送给客户端；\n处理心跳、消息超时等异常场景。\n关键源码片段：\nfunc (p *protocolV2) messagePump(client *clientV2, startedChan chan bool) { var subChannel *Channel // 初始化信号 close(startedChan) for { // 根据客户端状态调整消息读取源 if subChannel == nil || !client.IsReadyForMessages() { memoryMsgChan = nil backendMsgChan = nil client.Flush() // 强制刷新缓冲区 flushed = true } else if flushed { memoryMsgChan = subChannel.memoryMsgChan backendMsgChan = subChannel.backend.ReadChan() } select { case \u0026lt;-flusherChan: // 缓冲区超时刷新 client.Flush() flushed = true case subChannel = \u0026lt;-subEventChan: // 订阅Channel变更 subEventChan = nil case msg := \u0026lt;-memoryMsgChan: // 从Channel内存读消息 msg.Attempts++ subChannel.StartInFlightTimeout(msg, client.ID, msgTimeout) client.SendingMessage() err = p.SendMessage(client, msg) if err != nil { goto exit } flushed = false case b := \u0026lt;-backendMsgChan: // 从Channel后端读消息 msg, err := decodeMessage(b) if err != nil { continue } msg.Attempts++ subChannel.StartInFlightTimeout(msg, client.ID, msgTimeout) client.SendingMessage() err = p.SendMessage(client, msg) if err != nil { goto exit } flushed = false case \u0026lt;-client.ExitChan: // 客户端退出 goto exit } } exit: // 资源清理 } 四、messagePump设计的巧妙之处 messagePump是NSQ消息分发的核心，其设计兼顾了性能、灵活性和可靠性，关键亮点：\n信号驱动的初始化：通过startChan、pauseChan、exitChan等信号控制消息分发时机，避免启动前或暂停时发送消息，保证状态一致性。\n动态Channel列表：通过channelUpdateChan监听Channel变化，实时更新分发列表，支持动态新增/删除Channel，无需重启服务。\n消息复制优化：第一个Channel复用原始消息，仅后续Channel复制消息，减少内存拷贝开销。\n读写源动态调整：根据Channel数量、Topic状态（暂停/运行）动态开关内存/后端读取，避免无效IO。\n缓冲区智能刷新：客户端messagePump通过flusherChan控制缓冲区超时刷新，平衡IO次数与消息延迟。\n五、最佳设计实践 基于NSQ的核心设计，结合实际应用场景，总结以下最佳实践：\n合理规划Topic与Channel粒度 Topic按“业务模块”划分（如订单、日志），Channel按“消费角色”划分（如订单支付、订单通知），避免一个Topic关联过多Channel（会增加消息复制开销）。\n内存队列大小适配场景 根据业务消息量调整mem-queue-size：高并发场景增大内存队列，减少磁盘IO；低并发场景减小内存队列，降低内存占用。\n优先使用临时实体减少存储 临时Topic/Channel（ephemeral=true）不写入后端存储，适用于非核心消息（如实时监控），可降低磁盘压力和消息延迟。\n避免客户端频繁连接断开 客户端连接稳定后保持长连接，减少Channel频繁增减导致的messagePump状态刷新开销。\n监控messagePump状态 重点监控Topic/Channel的messagePump运行状态、内存队列使用率、后端存储写入频率，及时发现阻塞或异常。\n总结 NSQD、Topic、Channel的层级设计是NSQ高可用、高并发的核心基础，通过“内存+后端”存储保证可靠性，通过读写锁保证并发安全，通过messagePump实现高效消息分发。理解三者的关系与交互逻辑，能帮助我们更好地基于NSQ设计分布式消息架构，规避性能瓶颈与可靠性风险。\n源码地址：https://github.com/nsqio/nsq/tree/master/nsqd\n","permalink":"/blogs/2025/sq/nsq/nsq-core-design-nsqd-topic-channel-message-flow-33dc4d7a.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003eNSQ作为一款轻量、高可用的分布式消息队列，其核心设计围绕NSQD（消息节点）、Topic（主题）、Channel（通道）三大核心实体展开。三者的层级关系、交互逻辑直接决定了NSQ的并发处理能力、消息可靠性与扩展性。本文结合源码片段，深入拆解它们的关系、原理、设计思想及最佳实践。\u003c/p\u003e","title":"揭秘NSQ核心设计：NSQD、Topic与Channel的关系及消息流转精髓"},{"content":"—— 为什么 NSQ 的 DiskQueue 不用锁也能做到高性能、强一致？\nNSQ 的 diskqueue 是一个极其优雅的磁盘持久化 FIFO 队列实现。它的代码不多，却藏着许多工程上的巧思：\n单调度协程保证线程安全 记录格式简洁高效（长度+数据） 元数据持久化设计稳健 文件滚动策略减少 IO 并保持性能 本文从设计思想切入，结合源码逐块解析 diskqueue 是如何实现一个可持久、线程安全、性能稳定的磁盘队列。\n1. 单协程调度（ioLoop）保证线程安全：无需加锁 DiskQueue 的最巧妙设计之一，就是所有写入、读取、同步、文件滚动等操作都在 一个 ioLoop 协程中完成。\n即使 diskQueue 结构体上存在 RWMutex，但核心变量（read/write position、file num、depth）都只在 ioLoop 中修改，因此可以不用锁，天然线程安全。\n创建队列时就启动这个协程：\n// diskqueue.go: New() go d.ioLoop() 来看 ioLoop 的结构：\n// diskqueue.go: ioLoop() func (d *diskQueue) ioLoop() { for { select { case data := \u0026lt;-d.writeChan: err := d.writeOne(data) d.writeResponseChan \u0026lt;- err case \u0026lt;-d.emptyChan: err := d.deleteAllFiles() d.emptyResponseChan \u0026lt;- err case d.depthChan \u0026lt;- d.depth: // return depth // 其他分支：退出、同步等... } } } ✨ 设计亮点 所有请求都通过 channel 串行进入 ioLoop 生产者调用 Put() → writeChan → ioLoop → writeOne() ioLoop 不需要任何互斥锁 因为写入操作永远在单协程执行，不存在并发修改。 读通道 readChan 也在循环内安全发送 这与 Redis 的单线程模型有异曲同工之妙：串行化换线程安全，避免锁开销。\n2. 内容数据按（长度+数据）格式写入磁盘 NSQ 为每条记录写入：\n4字节长度（int32 大端序） + N 字节消息内容 写入逻辑在 writeOne()： // diskqueue.go: writeOne() dataLen := int32(len(data)) totalBytes := int64(4 + dataLen) // 写长度 binary.Write(\u0026amp;d.writeBuf, binary.BigEndian, dataLen) // 写内容 d.writeBuf.Write(data) // 一次性写入文件 _, err = d.writeFile.Write(d.writeBuf.Bytes()) 为什么采用“长度 + 内容”？ 读取时无需扫描分隔符，直接按长度读取 → 高性能顺序读 能快速跳过损坏数据（长度检测） → 增强鲁棒性 二进制格式紧凑 → 磁盘占用小 文件满了会自动滚动 当 writePos + totalBytes \u0026gt; maxBytesPerFile：\nif d.writePos \u0026gt; 0 \u0026amp;\u0026amp; d.writePos+totalBytes \u0026gt; d.maxBytesPerFile { d.writeFileNum++ d.writePos = 0 d.sync() d.writeFile.Close() } 即：当前文件满 → fsync → 开新文件继续写。\n3. 元数据持久化：周期性记录读写进度 为了保证崩溃后仍能从正确位置恢复，DiskQueue 会定期将读写指针和 depth 写入 metadata 文件。\n元数据内容示例：\ndepth readFileNum,readPos writeFileNum,writePos 对应的写逻辑在：\n// diskqueue.go: persistMetaData() fmt.Fprintf(f, \u0026#34;%d\\n%d,%d\\n%d,%d\\n\u0026#34;, d.depth, d.readFileNum, d.readPos, d.writeFileNum, d.writePos) 采用安全的 tmp file + rename 原子替换，保证文件内部的数据是完整：\ntmpFileName := fmt.Sprintf(\u0026#34;%s.%d.tmp\u0026#34;, fileName, rand.Int()) os.Rename(tmpFileName, fileName) // 原子提交 这样即使在持久化过程中崩溃也不会破坏原有 metadata。\n什么时候会同步？ 两种模式：\n每写 X 条消息（通过 syncEvery 配置） 定时 syncTimeout 触发 fsync 触发逻辑在 ioLoop 中处理：\nif d.needSync \u0026amp;\u0026amp; (writes%syncEvery == 0 || time.Since(lastSync) \u0026gt; syncTimeout) { d.sync() } 4. 读取记录（一次取一条，同样采用“长度+数据”格式） 读取逻辑在 readOne()：\nvar msgSize int32 binary.Read(d.reader, binary.BigEndian, \u0026amp;msgSize) readBuf := make([]byte, msgSize) io.ReadFull(d.reader, readBuf) 并计算下一次读取的位置：\ntotalBytes := int64(4 + msgSize) d.nextReadPos = d.readPos + totalBytes 文件滚动 读取到文件末尾时：\nif d.readFileNum \u0026lt; d.writeFileNum \u0026amp;\u0026amp; d.nextReadPos \u0026gt;= d.maxBytesPerFileRead { d.nextReadFileNum++ d.nextReadPos = 0 } DiskQueue 会自动切换到下一个文件。\n总结：DiskQueue 以极小的代码实现极稳健的持久化队列 设计点 带来的价值 ioLoop 单协程串行调度 无锁、线程安全、高性能 长度+数据 格式 顺序读写最高效、格式安全 文件滚动策略 提高磁盘局部性，避免巨型文件 metadata 原子持久化 崩溃可恢复，不产生部分写入 NSQ 的 DiskQueue 是工程中小而美、高可靠、高性能磁盘队列实现的典范，非常值得学习。\n如果你正在实现：\n本地消息队列 任务执行器的持久化存储 分布式系统的持久化 mailbox WAL / 顺序写日志 DiskQueue 都是一个极好的参考。\nnsq的diskqueue源码：https://github.com/nsqio/go-diskqueue/blob/master/diskqueue.go\n","permalink":"/blogs/2025/sq/nsq/nsq-diskqueue-persistent-queue-design-analysis.html","summary":"\u003cp\u003e\u003cstrong\u003e—— 为什么 NSQ 的 DiskQueue 不用锁也能做到高性能、强一致？\u003c/strong\u003e\u003c/p\u003e\n\u003cp\u003eNSQ 的 \u003ca href=\"https://github.com/nsqio/go-diskqueue\"\u003ediskqueue\u003c/a\u003e 是一个极其优雅的磁盘持久化 FIFO 队列实现。它的代码不多，却藏着许多工程上的巧思：\u003c/p\u003e\n\u003cul\u003e\n\u003cli\u003e单调度协程保证线程安全\u003c/li\u003e\n\u003cli\u003e记录格式简洁高效（长度+数据）\u003c/li\u003e\n\u003cli\u003e元数据持久化设计稳健\u003c/li\u003e\n\u003cli\u003e文件滚动策略减少 IO 并保持性能\u003c/li\u003e\n\u003c/ul\u003e\n\u003cp\u003e本文从\u003cstrong\u003e设计思想\u003c/strong\u003e切入，结合源码逐块解析 \u003ccode\u003ediskqueue\u003c/code\u003e 是如何实现一个可持久、线程安全、性能稳定的磁盘队列。\u003c/p\u003e","title":"NSQ 磁盘持久队列 DiskQueue 设计思想全解析"},{"content":"前言 NSQ 是一款轻量级的分布式消息队列，以高性能、去中心化、易部署的特性被广泛应用于微服务间的异步通信。延迟消息作为消息队列的核心能力之一，在订单超时关闭、定时任务触发、服务限流降级等场景中不可或缺。NSQ 并没有为延迟消息设计一套完全独立的架构，而是通过复用现有消息流转流程 + 优先级队列调度的方式实现，其设计的简洁性与巧思值得我们深入学习。本文将从源码角度拆解 NSQ 延迟消息的实现原理，分析其设计亮点、优点，并探讨性能优化的思路。\n一、NSQ 延迟消息的核心实现原理 NSQ 延迟消息的核心逻辑围绕DPUB 命令展开，从客户端发送延迟消息，到服务端接收处理、存储调度，再到延迟到期后推送给消费者，整个流程可分为客户端封装、服务端接收、Topic 存储、Channel 延迟调度、NSQD 定时分发五个阶段。\n1.1 客户端：DPUB 命令的封装与发送 NSQ 客户端通过 DeferredPublish 方法发送延迟消息，底层封装为DPUB 命令（Deferred Publish），与普通的 PUB 命令区分开。\n客户端核心代码（go-nsq/producer.go）：\n// DeferredPublish 同步发布延迟消息，消息会在 Channel 层排队直到延迟时间到期 func (w *Producer) DeferredPublish(topic string, delay time.Duration, body []byte) error { return w.sendCommand(DeferredPublish(topic, delay, body)) } DPUB 命令的构造逻辑（go-nsq/command.go）：\n// DeferredPublish 创建 DPUB 命令，参数包含 Topic 名和延迟时间（毫秒） func DeferredPublish(topic string, delay time.Duration, body []byte) *Command { var params = [][]byte{[]byte(topic), []byte(strconv.Itoa(int(delay / time.Millisecond)))} return \u0026amp;Command{[]byte(\u0026#34;DPUB\u0026#34;), params, body} } 命令的网络传输格式由 WriteTo 方法定义，遵循 NSQ 的协议规范：先发送命令名（DPUB），再发送参数（Topic、延迟时间），最后发送消息体长度和消息体本身。\nfunc (c *Command) WriteTo(w io.Writer) (int64, error) { ... n, err := w.Write(c.Name) ... for _, param := range c.Params { ... n, err = w.Write(param) ... } n, err = w.Write(byteNewLine) ... if c.Body != nil { bufs := buf[:] binary.BigEndian.PutUint32(bufs, uint32(len(c.Body))) n, err := w.Write(bufs) ... n, err = w.Write(c.Body) ... } return total, nil } 核心逻辑：客户端将延迟时间转换为毫秒数，与 Topic 名、消息体一起封装为 DPUB 命令，通过 TCP 发送给 NSQD 服务端。\n1.2 服务端：DPUB 命令的接收与消息创建 NSQD 服务端的 V2 协议处理层接收 DPUB 命令后，会完成参数校验、消息体读取，并创建带有延迟标记的消息对象。\n服务端 DPUB 命令处理核心代码（nsqd/protocol_v2.go）：\nfunc (p *protocolV2) DPUB(client *clientV2, params [][]byte) ([]byte, error) { ... // 读取消息体 messageBody := make([]byte, bodyLen) _, err = io.ReadFull(client.Reader, messageBody) if err != nil { return nil, protocol.NewFatalClientErr(err, \u0026#34;E_BAD_MESSAGE\u0026#34;, \u0026#34;DPUB failed to read message body\u0026#34;) } ... // 获取 Topic 并创建延迟消息（设置 msg.deferred 字段） topic := p.nsqd.GetTopic(topicName) msg := NewMessage(topic.GenerateID(), messageBody) msg.deferred = timeoutDuration // 标记消息的延迟时长 err = topic.PutMessage(msg) // 将延迟消息放入 Topic if err != nil { return nil, protocol.NewFatalClientErr(err, \u0026#34;E_DPUB_FAILED\u0026#34;, \u0026#34;DPUB failed \u0026#34;+err.Error()) } ... return okBytes, nil } 核心逻辑：服务端解析 DPUB 命令的 Topic 名和延迟时间，校验参数合法性后，创建消息对象并设置 msg.deferred 延迟字段，最后将消息放入 Topic 队列 —— 这一步与普通消息的处理完全一致。\n1.3 Topic 层：延迟消息与普通消息的统一存储 NSQ 的 Topic 是消息的一级存储单元，延迟消息并不会被特殊处理，而是与普通消息一样通过 PutMessage 方法存入 Topic 的内存 / 磁盘队列。\nTopic 存储消息的核心代码（nsqd/topic.go）：\n// PutMessage 将消息写入 Topic 队列 func (t *Topic) PutMessage(m *Message) error { ... err := t.put(m) if err != nil { return err } ... return nil } 核心逻辑：Topic 对延迟消息和普通消息一视同仁，这种设计让 NSQ 无需为延迟消息单独设计存储架构，极大简化了代码复杂度。\n1.4 Channel 层：延迟消息的扇入与优先级存储 Topic 会通过 messagePump 协程将消息分发给所有订阅的 Channel，此时延迟消息会被识别并送入 Channel 的延迟队列，而非普通的消息队列。\nTopic 分发消息的核心代码（nsqd/topic.go）：\n// messagePump 将 Topic 的消息分发给所有订阅的 Channel func (t *Topic) messagePump() { ... // 主消息循环 for { // 如果是延迟消息，送入 Channel 的延迟队列 if chanMsg.deferred != 0 { channel.PutMessageDeferred(chanMsg, chanMsg.deferred) continue } ... // 普通消息送入 Channel 的正常队列 err := channel.PutMessage(chanMsg) if err != nil { t.nsqd.logf(LOG_ERROR, \u0026#34;TOPIC(%s) ERROR: failed to put msg(%s) to channel(%s) - %s\u0026#34;, t.name, msg.ID, channel.name, err) } } } } Channel 对延迟消息的存储是实现延迟的核心，NSQ 采用优先级队列（Priority Queue）+ 哈希表的双结构设计：\ndeferredPQ：基于标准库 container/heap 实现的优先级队列，按消息的到期时间戳排序，用于快速获取到期的延迟消息； deferredMessages：以消息 ID 为 Key 的哈希表，用于快速查找和删除延迟消息。 Channel 存储延迟消息的核心代码（nsqd/channel.go）：\n// Channel 结构体中的延迟消息存储字段 type Channel struct { deferredMessages map[MessageID]*pqueue.Item // 哈希表：快速查找延迟消息 deferredPQ pqueue.PriorityQueue // 优先级队列：按到期时间排序 // 省略其他字段... } // PutMessageDeferred 将延迟消息存入 Channel 的延迟队列 func (c *Channel) PutMessageDeferred(msg *Message, timeout time.Duration) { atomic.AddUint64(\u0026amp;c.messageCount, 1) c.StartDeferredTimeout(msg, timeout) } // StartDeferredTimeout 封装延迟消息并加入优先级队列 func (c *Channel) StartDeferredTimeout(msg *Message, timeout time.Duration) error { absTs := time.Now().Add(timeout).UnixNano() // 计算消息的到期时间戳 item := \u0026amp;pqueue.Item{Value: msg, Priority: absTs} // 优先级为到期时间戳 err := c.pushDeferredMessage(item) // 存入哈希表 if err != nil { return err } c.addToDeferredPQ(item) // 加入优先级队列 return nil } 核心逻辑：Channel 接收 Topic 分发的延迟消息后，计算消息的到期时间戳，将消息封装为优先级队列的 Item，同时存入哈希表和优先级队列 —— 这一步实现了延迟消息的扇入（所有延迟消息聚合到 Channel 的延迟队列）。\n1.5 NSQD 核心：定时扫描与延迟消息的扇出 NSQD 会启动一个定时扫描协程池，周期性地扫描所有 Channel 的延迟队列，将到期的消息从延迟队列移出并送入 Channel 的正常消息队列，最终推送给消费者，这一步实现了延迟消息的扇出。\nNSQD 定时扫描的核心代码（nsqd/nsqd.go）：\n// Main 方法启动 NSQD 的核心协程，包括定时扫描 func (n *NSQD) Main() error { // 省略其他初始化逻辑... n.waitGroup.Wrap(n.queueScanLoop) // 启动定时扫描循环 // 省略其他逻辑... } // queueScanLoop 启动定时扫描主循环，动态调整协程池大小 func (n *NSQD) queueScanLoop() { workCh := make(chan *Channel, n.getOpts().QueueScanSelectionCount) responseCh := make(chan bool, n.getOpts().QueueScanSelectionCount) closeCh := make(chan int) workTicker := time.NewTicker(n.getOpts().QueueScanInterval) // 扫描间隔 refreshTicker := time.NewTicker(n.getOpts().QueueScanRefreshInterval) // 协程池刷新间隔 channels := n.channels() n.resizePool(len(channels), workCh, responseCh, closeCh) // 动态调整协程池大小 // 省略循环逻辑... } // resizePool 动态调整协程池大小（基于 Channel 数量的 25%，最大不超过 QueueScanWorkerPoolMax） func (n *NSQD) resizePool(num int, workCh chan *Channel, responseCh chan bool, closeCh chan int) { idealPoolSize := int(float64(num) * 0.25) if idealPoolSize \u0026lt; 1 { idealPoolSize = 1 } else if idealPoolSize \u0026gt; n.getOpts().QueueScanWorkerPoolMax { idealPoolSize = n.getOpts().QueueScanWorkerPoolMax } for { if idealPoolSize == n.poolSize { break } else if idealPoolSize \u0026lt; n.poolSize { closeCh \u0026lt;- 1 n.poolSize-- } else { n.waitGroup.Wrap(func() { n.queueScanWorker(workCh, responseCh, closeCh) }) n.poolSize++ } } } // queueScanWorker 协程池中的工作协程，处理 Channel 的延迟队列和 In-Flight 队列 func (n *NSQD) queueScanWorker(workCh chan *Channel, responseCh chan bool, closeCh chan int) { for { select { case c := \u0026lt;-workCh: now := time.Now().UnixNano() dirty := false if c.processInFlightQueue(now) { dirty = true } if c.processDeferredQueue(now) { // 处理延迟队列 dirty = true } responseCh \u0026lt;- dirty case \u0026lt;-closeCh: return } } } // processDeferredQueue 处理到期的延迟消息，送入 Channel 的正常队列 func (c *Channel) processDeferredQueue(t int64) bool { c.exitMutex.RLock() defer c.exitMutex.RUnlock() if c.Exiting() { return false } dirty := false for { c.deferredMutex.Lock() item, _ := c.deferredPQ.PeekAndShift(t) // 取出所有到期的消息（t 为当前时间戳） c.deferredMutex.Unlock() if item == nil { goto exit } dirty = true msg := item.Value.(*Message) _, err := c.popDeferredMessage(msg.ID) // 从哈希表中删除 if err != nil { goto exit } c.put(msg) // 送入 Channel 的正常队列 } exit: return dirty } 核心逻辑：NSQD 通过 queueScanLoop 启动定时扫描，动态调整协程池大小；queueScanWorker 协程从工作队列中获取 Channel，调用 processDeferredQueue 取出到期的延迟消息，送入 Channel 的正常队列，最终推送给消费者。\n二、NSQ 延迟消息设计的巧妙之处 NSQ 延迟消息的实现没有引入复杂的外部组件或独立架构，而是基于现有流程做轻量级扩展，其设计的巧思主要体现在以下四点：\n2.1 复用现有架构，最小化侵入性 延迟消息与普通消息共享 Topic 存储、Channel 分发的核心流程，仅通过 msg.deferred 字段标记延迟属性，避免了为延迟消息单独设计存储、分发逻辑，代码侵入性极低。这种设计符合开闭原则，后续维护成本也大幅降低。\n2.2 优先级队列 + 哈希表的双结构设计 NSQ 结合了优先级队列和哈希表的优势：\n优先级队列（deferredPQ）按到期时间戳排序，保证快速获取到期消息（时间复杂度 O (1) 取顶，O (logN) 出队）；\n哈希表（deferredMessages）按消息 ID 索引，保证快速查找 / 删除消息（时间复杂度 O (1)）。\n双结构配合平衡了 “调度效率” 和 “操作灵活性”，是延迟任务存储的经典设计模式。\n2.3 扇入扇出的异步调度模型 延迟消息在 Channel 层扇入（聚合所有延迟消息到一个队列），再通过 NSQD 的定时扫描扇出（将到期消息推送给消费者），这种异步调度模型让延迟消息的处理与普通消息的消费解耦，避免了延迟消息对消费链路的阻塞。\n2.4 动态协程池的资源弹性调度 NSQD 根据 Channel 的数量动态调整扫描协程池的大小（默认 25% 的 Channel 数量，最大可配置），既避免了协程过多导致的资源浪费，也防止了协程过少导致的扫描不及时。这种弹性调度让 NSQ 能适配不同规模的集群负载。\n三、NSQ 延迟消息实现的优点 基于上述设计，NSQ 延迟消息具备以下优点：\n轻量高效：基于内存的优先级队列调度，无外部依赖（如 Redis、MySQL），延迟消息的处理延迟低，吞吐量高； 职责分层：Topic 负责消息存储，Channel 负责延迟调度，NSQD 负责全局扫描，各组件遵循单一职责原则，架构清晰； 协议统一：DPUB 命令与 PUB 命令的协议格式一致，客户端接入简单，无需额外的适配逻辑； 配置灵活：扫描间隔、协程池大小、最大延迟时间等参数均可配置，能满足不同业务场景的需求。 四、从 NSQ 延迟消息设计中可学习的点 NSQ 延迟消息的实现虽简单，但蕴含了很多值得我们借鉴的设计思想：\n4.1 善用标准库，简化核心逻辑 NSQ 直接使用 Go 标准库的 container/heap 实现优先级队列，而非从零造轮子，极大简化了核心逻辑的开发与维护。在实际开发中，合理利用标准库能显著提升开发效率。\n4.2 分层设计，践行单一职责原则 Topic 只负责消息的存储与分发，Channel 只负责消息的延迟调度，NSQD 只负责全局的定时扫描，各组件的职责边界清晰。这种分层设计让系统的可维护性和可扩展性大幅提升。\n4.3 双结构配合，平衡性能与易用性 优先级队列和哈希表的双结构设计，是解决 “有序调度” 与 “快速操作” 矛盾的经典方案，可复用于定时任务、延迟队列等场景。\n4.4 异步调度，提升系统吞吐量 延迟消息的处理采用异步扫描的方式，而非同步阻塞，这种设计让 NSQ 能处理高并发的延迟消息请求，提升了系统的整体吞吐量。\n五、总结 NSQ 延迟消息的实现是 “简洁设计” 的典范：通过复用现有消息流转流程，结合优先级队列与哈希表的双结构存储，再通过动态协程池的定时扫描完成延迟调度，最终实现了轻量、高效的延迟消息能力。\n其设计思想不仅适用于消息队列，也可复用于定时任务、延迟通知等场景。同时，我们也可以通过持久化、分段堆、精细化扫描等方式，进一步优化其在高并发场景下的性能。希望本文能帮助你深入理解 NSQ 延迟消息的实现原理，并为你的日常开发提供一些设计思路。\n","permalink":"/blogs/2025/sq/nsq/nsq-delayed-messages.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003eNSQ 是一款轻量级的分布式消息队列，以高性能、去中心化、易部署的特性被广泛应用于微服务间的异步通信。延迟消息作为消息队列的核心能力之一，在订单超时关闭、定时任务触发、服务限流降级等场景中不可或缺。NSQ 并没有为延迟消息设计一套完全独立的架构，而是通过\u003cstrong\u003e复用现有消息流转流程 + 优先级队列调度\u003c/strong\u003e的方式实现，其设计的简洁性与巧思值得我们深入学习。本文将从源码角度拆解 NSQ 延迟消息的实现原理，分析其设计亮点、优点，并探讨性能优化的思路。\u003c/p\u003e","title":"深入 NSQ 延迟消息实现原理：设计巧思与性能优化"},{"content":"前言 在网络通信中，TCP 协议因其可靠性成为主流选择，但它的 \u0026ldquo;流式传输\u0026rdquo; 特性却给消息解析埋下了一个坑 ——黏包与拆包。对于 NSQ 这类消息队列而言，消息的准确解析是核心能力，一旦出现黏包或拆包，整个消息传递链路就会失效。\n今天我们就来深入分析：NSQ 是如何通过自定义 TCP 协议，从根源上解决黏包拆包问题的？其协议设计的巧妙之处又在哪里？\n先搞懂：TCP 黏包拆包到底是什么？ 在聊 NSQ 的解决方案前，我们得先明确问题的本质。\nTCP 是 \u0026ldquo;流式协议\u0026rdquo;，它会把数据当成连续的字节流来传输，没有天然的消息边界。这就导致发送方连续发送的两个消息，到了接收方可能变成：\n黏包：两个消息被合并成一个字节流（如发送msg1+msg2，接收方收到msg1msg2）； 拆包：一个消息被拆分到多个字节流中（如发送longmsg，接收方先收到lon，再收到gmsg）。 对于消息队列来说，这是致命的 —— 无法区分消息边界，就无法正确解析消息内容。\n那么 NSQ 是如何给 TCP\u0026quot;加边界\u0026quot; 的？答案是：自定义一套清晰的协议格式，让接收方明确知道每个消息的开始和结束。\nNSQ 的 TCP 协议：用 \u0026ldquo;双保险\u0026rdquo; 划分消息边界 NSQ 的 TCP 协议设计非常直接：通过固定格式的 \u0026ldquo;头部\u0026rdquo; 和 \u0026ldquo;长度前缀\u0026rdquo;，为每个消息加上明确的边界。其核心格式如下：\n[x][x][x][x][x][x][x][x][x][x][x][x]... | (int32) || (int32) || (binary) | 4-byte || 4-byte || N-byte ------------------------------------... size frame ID data 从协议定义能看到，NSQ 的消息由三部分组成：\nsize（4 字节）：表示后续 \u0026ldquo;frame ID + data\u0026rdquo; 的总长度（int32 类型，大端序）； frame ID（4 字节）：标识帧的类型（比如数据帧、响应帧等）； data（N 字节）：实际的消息内容，长度由 size 计算得出（size - 4 字节）。 但这只是 NSQ 协议的基础格式。在实际通信中，NSQ 会根据内容类型（命令 / 消息体），结合 \u0026ldquo;分隔符\u0026rdquo; 和 \u0026ldquo;长度前缀\u0026rdquo; 两种方式划分边界，形成 \u0026ldquo;双保险\u0026rdquo;。\n实战解析：NSQ 如何封包（发送消息）？ 我们以 \u0026ldquo;发布消息（PUB）\u0026rdquo; 为例，通过源码看看 NSQ 是如何将消息按照协议格式打包的。\n1. 构建命令：明确消息结构 首先，发布消息的Publish函数会构建一个Command对象，包含命令名（\u0026ldquo;PUB\u0026rdquo;）、参数（topic）和消息体（body）：\n// 发布消息 func Publish(topic string, body []byte) *Command { var params = [][]byte{[]byte(topic)} return \u0026amp;Command{[]byte(\u0026#34;PUB\u0026#34;), params, body} } 这个Command就是待发送的消息载体，接下来需要通过WriteTo方法按照协议格式写入 TCP 连接。\n2. 写入命令头部：用分隔符划分边界 WriteTo方法的核心逻辑是分两部分处理：命令头部和消息体。\n对于命令头部（命令名 + 参数），NSQ 采用 \u0026ldquo;空格分隔参数，换行符结束头部\u0026rdquo; 的方式，确保接收方能快速拆分命令：\nfunc (c *Command) WriteTo(w io.Writer) (int64, error) { var total int64 var buf [4]byte // 1. 写入命令名（如\u0026#34;PUB\u0026#34;） n, err := w.Write(c.Name) total += int64(n) if err != nil { return total, err } // 2. 写入参数（如topic），参数间用空格分隔 for _, param := range c.Params { n, err := w.Write(byteSpace) // byteSpace = []byte(\u0026#34; \u0026#34;) total += int64(n) if err != nil { return total, err } n, err = w.Write(param) // 写入topic total += int64(n) if err != nil { return total, err } } // 3. 写入换行符，标识命令头部结束 n, err = w.Write(byteNewLine) // byteNewLine = []byte(\u0026#34;\\n\u0026#34;) total += int64(n) if err != nil { return total, err } // ... 后续处理消息体 } 这段代码的作用是生成类似PUB my_topic\\n的命令头部。换行符\\n在这里是关键 —— 它告诉接收方：\u0026ldquo;命令头部到这里结束了\u0026rdquo;。\n3. 写入消息体：用长度前缀确保完整 命令头部之后是消息体（body）。由于消息体长度不固定（可能很长），NSQ 采用 \u0026ldquo;4 字节长度前缀 + 实际内容\u0026rdquo; 的方式，确保接收方能准确读取完整消息体：\nfunc (c *Command) WriteTo(w io.Writer) (int64, error) { // ... 前面省略命令头部写入逻辑 if c.Body != nil { bufs := buf[:] // 1. 写入4字节长度（大端序）：表示消息体的长度 binary.BigEndian.PutUint32(bufs, uint32(len(c.Body))) n, err := w.Write(bufs) total += int64(n) if err != nil { return total, err } // 2. 写入实际消息体内容 n, err = w.Write(c.Body) total += int64(n) if err != nil { return total, err } } return total, nil } 这里的关键是先写长度，再写内容。比如消息体是hello（长度 5），则会先写入0x00000005（4 字节大端序），再写入hello。\n接收方只要先读 4 字节拿到长度，再读取对应长度的字节，就能完整获取消息体，完全不用担心黏包拆包。\n实战解析：NSQ 如何拆包（接收消息）？ 发送方按协议打包后，接收方需要按同样的规则解析。NSQ 的拆包逻辑主要在读取命令和消息体两个阶段。\n1. 解析命令头部：按换行符拆分 接收方使用bufio.NewReaderSize创建带缓冲的读取器，通过ReadSlice('\\n')按换行符拆分命令头部：\n// 用带缓冲的Reader读取数据 Reader: bufio.NewReaderSize(conn, defaultBufferSize) // 按换行符拆分，获取完整的命令头部 line, err = client.Reader.ReadSlice(\u0026#39;\\n\u0026#39;) if err != nil { // 错误处理... } // 移除换行符（\\n）和可能的回车符（\\r） line = line[:len(line)-1] if len(line) \u0026gt; 0 \u0026amp;\u0026amp; line[len(line)-1] == \u0026#39;\\r\u0026#39; { line = line[:len(line)-1] } // 按空格拆分参数（如\u0026#34;PUB my_topic\u0026#34;拆分为[\u0026#34;PUB\u0026#34;, \u0026#34;my_topic\u0026#34;]） params := bytes.Split(line, separatorBytes) 这段逻辑完美解决了命令头部的边界问题：无论 TCP 如何拆分或合并字节流，只要读到\\n，就知道一个命令头部结束了，再按空格拆分就能拿到命令名和参数。\n2. 解析消息体：按长度前缀读取 当解析到 \u0026ldquo;PUB\u0026rdquo; 命令时，NSQ 会进一步读取消息体。此时会先读 4 字节长度，再按长度读取完整内容：\nfunc (p *protocolV2) PUB(client *clientV2, params [][]byte) ([]byte, error) { // ... 省略参数校验逻辑 // 1. 读取4字节长度（复用lenSlice缓冲区，减少内存分配） bodyLen, err := readLen(client.Reader, client.lenSlice) if err != nil { return nil, protocol.NewFatalClientErr(err, \u0026#34;E_BAD_MESSAGE\u0026#34;, \u0026#34;PUB failed to read message body size\u0026#34;) } // 校验长度合法性（避免无效数据） if bodyLen \u0026lt;= 0 { return nil, protocol.NewFatalClientErr(nil, \u0026#34;E_BAD_MESSAGE\u0026#34;, fmt.Sprintf(\u0026#34;PUB invalid message body size %d\u0026#34;, bodyLen)) } // 2. 按长度读取完整消息体 messageBody := make([]byte, bodyLen) _, err = io.ReadFull(client.Reader, messageBody) // 确保读取bodyLen字节 if err != nil { return nil, protocol.NewFatalClientErr(err, \u0026#34;E_BAD_MESSAGE\u0026#34;, \u0026#34;PUB failed to read message body\u0026#34;) } // ... 后续处理消息体 } // 读取4字节长度（大端序转int32） func readLen(r io.Reader, tmp []byte) (int32, error) { _, err := io.ReadFull(r, tmp) // 读取4字节到tmp if err != nil { return 0, err } return int32(binary.BigEndian.Uint32(tmp)), nil // 转换为int32 } 这里的io.ReadFull是关键 —— 它会一直读取，直到拿到指定长度的字节（bodyLen），即使数据被 TCP 拆分成多个包，也能保证最终读取完整。\nNSQ 协议设计的 3 大优点 NSQ 的自定义协议之所以能完美解决黏包拆包问题，核心在于其设计的合理性，具体有三个优点：\n1. 混合边界策略：兼顾灵活性和准确性 NSQ 没有死板地只用一种边界划分方式，而是根据内容类型选择：\n命令头部（短文本）：用换行符分隔，解析简单高效，适合频繁的命令交互（如 PUB、SUB）； 消息体（长二进制）：用长度前缀，确保无论内容多长都能准确读取，避免黏包。 这种 \u0026ldquo;文本命令 + 二进制数据\u0026rdquo; 的混合策略，兼顾了易用性和可靠性。\n2. 极致的解析效率：减少冗余和内存分配 从源码能看到 NSQ 在解析时的优化：\n用bufio.Reader减少系统调用，提高读取效率； 复用lenSlice缓冲区（client.lenSlice）存储 4 字节长度，避免频繁创建小对象； 用io.ReadFull替代手动循环读取，既简洁又能保证完整性。 这些细节让协议解析的性能损耗降到了最低。\n3. 强兼容性和容错性 跨平台兼容：使用大端序（binary.BigEndian）存储长度，确保不同架构的机器能正确解析； 严格的校验：对消息体长度做合法性检查（如bodyLen \u0026lt;= 0或超过最大限制时报错），避免无效数据破坏整个解析流程。 总结：NSQ 的协议设计哲学 NSQ 解决 TCP 黏包拆包的核心思路，其实就是给字节流 \u0026ldquo;加标记\u0026rdquo;：通过换行符标记命令结束，通过长度前缀标记消息体范围。这种设计既简单又高效，完美适配了消息队列对 \u0026ldquo;准确解析\u0026rdquo; 和 \u0026ldquo;高性能\u0026rdquo; 的双重需求。\n对于我们自己设计协议时，也可以借鉴 NSQ 的思路：根据数据特点选择合适的边界划分方式（分隔符 / 长度前缀），同时在解析时做好校验和效率优化。\n毕竟，好的协议设计，往往是简单性和实用性的平衡。\n","permalink":"/blogs/2025/sq/nsq/tcp-stick-package-terminator-nsq-custom-protocol-s-core-breakthrough-design.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在网络通信中，TCP 协议因其可靠性成为主流选择，但它的 \u0026ldquo;流式传输\u0026rdquo; 特性却给消息解析埋下了一个坑 ——\u003cstrong\u003e黏包与拆包\u003c/strong\u003e。对于 NSQ 这类消息队列而言，消息的准确解析是核心能力，一旦出现黏包或拆包，整个消息传递链路就会失效。\u003c/p\u003e","title":"NSQ 如何用自定义协议破解 TCP 黏包拆包难题？原理与设计剖析"},{"content":"前言 在并发编程的世界里，线程池（或协程池）是控制资源开销、提升任务执行效率的核心组件。但传统线程池设计中，Worker 数量的动态调整往往伴随着复杂的锁竞争，扩缩容逻辑绕不开互斥锁的保护；结果回传要么依赖阻塞等待，要么需要复杂的回调绑定；优雅关闭更是容易出现任务丢失或资源泄露的坑。\n今天要聊的这个协程池实现，却用一个「巧思」解决了这些问题：用单协程作为控制中枢，无锁管理 Worker 生命周期，同时天然支持动态扩缩容、异步结果回传和丝滑的优雅关闭。话不多说，我们来拆解它的设计智慧。（开源地址：https://github.com/itart-top/task-pool）\n核心设计：单协程控制中枢，从根源避免锁竞争 传统线程池的 Worker 数量调整，通常需要多个线程同时操作 Worker 计数器，因此必须用互斥锁（如sync.Mutex）保护共享状态，这不仅增加了代码复杂度，还可能在高并发调整时引发性能损耗。\n而这个实现的破局点在于：引入一个单独的controlLoop协程作为「控制中枢」，所有 Worker 的创建、销毁都由它独家负责。\nfunc (p *Pool) controlLoop() { // 启动初始 workers p.startWorkers(p.workerCount) for { select { case n := \u0026lt;-p.resizeReq: // 处理扩缩容请求 p.doResize(n) case \u0026lt;-p.closeReq: // 处理关闭请求 // 取消所有Worker，触发优雅退出 for _, cancel := range p.cancelFuncs { cancel() } return } } } controlLoop是整个池的「大脑」，它维护着workerCount（当前 Worker 数量）和cancelFuncs（每个 Worker 的取消函数）这两个核心状态。由于这两个状态只被controlLoop访问，完全不需要加锁 —— 从根源上避免了锁竞争。\n这种设计的巧妙之处在于：所有对 Worker 数量的修改（扩缩容、关闭）都通过 channel（resizeReq、closeReq）通知controlLoop，由它串行处理。串行化的操作天然线程安全，代码也更简洁。\n动态扩缩容：轻量高效，只响应最新需求 动态扩缩容是线程池应对流量波动的关键能力。这个实现的扩缩容逻辑非常轻量，且能「自动忽略过时请求」。\n当调用Resize(n)时，请求会被发送到resizeReq通道，而通道的缓冲大小为 1：\nfunc (p *Pool) Resize(n int) { if n \u0026lt;= 0 { n = 1 } if p.closed.Load() { return } // 先清空旧请求，只保留最新的 select { case \u0026lt;-p.resizeReq: default: } select { case p.resizeReq \u0026lt;- n: default: } } 这意味着：如果短时间内连续调用Resize（比如连续调整到 10、20、30），controlLoop只会处理最后一次请求（30），避免了频繁创建 / 销毁 Worker 的资源浪费。\n而实际的扩缩容操作doResize则非常直接：\nfunc (p *Pool) doResize(target int) { diff := target - p.workerCount p.workerCount = target if diff \u0026gt; 0 { p.startWorkers(diff) // 新增Worker } else if diff \u0026lt; 0 { p.stopWorkers(-diff) // 销毁多余Worker } } func (p *Pool) stopWorkers(n int) { if n \u0026gt; len(p.cancelFuncs) { n = len(p.cancelFuncs) } toCancel := p.cancelFuncs[:n] p.cancelFuncs = p.cancelFuncs[n:] for _, cancel := range toCancel { cancel() } } 新增 Worker 时，startWorkers会创建新的协程，并通过context.WithCancel绑定取消函数，便于后续销毁； 销毁 Worker 时，stopWorkers会调用对应 Worker 的取消函数，触发 Worker 退出。 整个过程无需锁保护，因为workerCount和cancelFuncs的修改完全由controlLoop串行处理，安全且高效。\n异步结果回传：订阅模式，灵活解耦 任务执行结果的回传是线程池的常见需求。传统做法要么让用户阻塞等待（如sync.WaitGroup+channel），要么在提交任务时绑定回调函数，灵活性较差。\n这个实现采用了「订阅者模式」，通过Subscribe方法注册结果处理器，任务执行完毕后自动回调：\n// 注册结果订阅者（并发安全） func (p *Pool) Subscribe(sub ResultSubscriber) { p.subscriber.Store(sub) // atomic.Value保证并发安全 } // 任务执行后回调订阅者 func (p *Pool) invoke(task Entry) { // ... 执行任务 ... // 任务结束后，通过订阅者回传结果 if v := p.subscriber.Load(); v != nil { if sub, ok := v.(ResultSubscriber); ok \u0026amp;\u0026amp; sub != nil { sub(TaskResult{ TaskID: task.TaskID, Data: data, Err: err, Duration: time.Since(start), }) } } } 这种设计的优势在于：\n解耦任务提交与结果处理：提交任务的代码无需关心结果如何处理，订阅者可以随时注册 / 修改； 并发安全：用atomic.Value存储订阅者，避免了回调函数注册时的锁竞争； 信息完整：结果中包含任务 ID、数据、错误和执行时间，便于追踪任务状态。 如果需要多订阅者，还可以基于这个基础扩展为发布 - 订阅模式（如维护一个订阅者列表），灵活性极高。\n优雅关闭：不丢任务，不留资源 线程池的「优雅关闭」是个容易被忽略的细节 —— 如何保证关闭时正在执行的任务不中断、队列中剩余的任务不丢失，同时不泄露资源？\n这个实现的Close方法堪称典范：\nfunc (p *Pool) Close() { if !p.closed.CompareAndSwap(false, true) { return // 避免重复关闭 } close(p.closeReq) // 通知controlLoop开始关闭 p.wg.Wait() // 等待所有Worker退出 } 关闭流程的核心逻辑在 Worker 的退出处理中：\nfunc (p *Pool) worker(ctx context.Context) { defer p.wg.Done() for { select { case \u0026lt;-ctx.Done(): // 如果是池关闭（closed==true），则尝试消费剩余任务 if p.closed.Load() { goto flushTask } return // 否则（如Resize缩容）直接退出 case task, ok := \u0026lt;-p.tasks: if !ok { return } p.invoke(task) } } flushTask: // 关闭时的任务冲洗阶段 for { select { case task, ok := \u0026lt;-p.tasks: if !ok { return } p.invoke(task) // 处理剩余任务 default: return // 队列空了，退出 } } } 当Close被调用后：\ncontrolLoop会收到closeReq通知，调用所有 Worker 的取消函数，触发 Worker 退出； Worker 检测到closed为true时，会进入flushTask阶段，逐个消费队列中剩余的任务，直到队列为空； 所有 Worker 执行完剩余任务并退出后，p.wg.Wait()才会返回，保证关闭操作完成后没有遗留任务和资源。 这种设计既避免了关闭时的任务丢失，又不会让 Worker 无限等待新任务，真正做到了「优雅」。\n其他细节：稳健性拉满 除了核心设计，这个实现还有很多细节值得称道：\n任务提交安全：Submit方法会检查池是否已关闭，或等待上下文取消，避免向已关闭的池提交任务； Panic 防护：任务执行时通过defer recover()捕获恐慌，并将错误信息（含堆栈）通过结果回传，避免单个任务崩溃导致整个 Worker 退出； 默认值合理：创建池时如果传入无效的 Worker 数量或任务缓冲大小，会自动修正为合理默认值（1 个 Worker、100 个缓冲），降低使用门槛。 总结：巧思带来的简洁与高效 这个协程池的设计，用一个controlLoop协程作为控制中枢，巧妙地避免了锁竞争；通过 channel 传递控制信号，实现了轻量高效的动态扩缩容；用订阅者模式解耦结果处理，兼顾灵活性与并发安全；最后通过精细的关闭流程，保证了任务不丢失、资源不泄露。\n它的代码量不大，但每一处设计都透着巧思 —— 用最简单的方式解决了传统线程池的复杂问题。这种「大道至简」的设计思路，值得我们在并发组件开发中借鉴。\n如果你需要一个支持动态扩缩容、异步结果回传且能优雅关闭的协程池，这个实现绝对是个不错的选择。\n","permalink":"/blogs/2025/go/lock-free-coroutine-thread-pool.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在并发编程的世界里，线程池（或协程池）是控制资源开销、提升任务执行效率的核心组件。但传统线程池设计中，Worker 数量的动态调整往往伴随着复杂的锁竞争，扩缩容逻辑绕不开互斥锁的保护；结果回传要么依赖阻塞等待，要么需要复杂的回调绑定；优雅关闭更是容易出现任务丢失或资源泄露的坑。\u003c/p\u003e","title":"一个「巧思」线程池：用单协程无锁控 Worker，动态扩缩容 + 优雅关闭全拿捏"},{"content":"前言 在分布式消息系统中，消费者的 \u0026ldquo;优雅关闭\u0026rdquo; 是保障消息可靠性的关键环节 —— 它需要确保关闭过程中不丢失已接收的消息、不突然中断正在处理的任务，同时平滑地与服务端断开连接。NSQ 作为一款轻量、高性能的分布式消息队列，其 Go 客户端（go-nsq）和服务端（nsqd）通过一系列协作机制实现了消费者的优雅关闭。本文将深入解析这一过程的实现原理，并结合源码给出最佳实践。\n什么是 \u0026ldquo;优雅关闭\u0026rdquo;？ 在讨论实现前，我们先明确 \u0026ldquo;优雅关闭\u0026rdquo; 的核心目标：\n停止接收新消息，避免关闭过程中引入新任务； 确保当前正在处理的消息能被正常完成（或标记为未完成，便于重试）； 与服务端平滑断开连接，避免资源泄漏； 等待所有内部协程（如消息处理、网络读写）安全退出后，再结束整个消费者进程。 NSQ 消费者的优雅关闭通过调用 Consumer.Stop() 方法触发，而非直接 os.Exit() 强制退出。下面我们从源码角度拆解这一过程。\nNSQ 消费者优雅关闭的实现原理 NSQ 的优雅关闭是客户端（go-nsq）与服务端（nsqd）协同的结果，主要分为客户端发起关闭、服务端响应关闭、客户端完成清理三个阶段。\n阶段一：客户端发起关闭（Consumer.Stop()） 当调用 Consumer.Stop() 时，客户端首先通过原子操作标记 \u0026ldquo;关闭状态\u0026rdquo;，避免重复执行关闭逻辑。核心逻辑如下：\n// github.com/nsqio/go-nsq/blob/master/consumer.go func (r *Consumer) Stop() { // 原子操作确保 Stop 只执行一次 if !atomic.CompareAndSwapInt32(\u0026amp;r.stopFlag, 0, 1) { return } // 若没有连接，直接停止处理器；否则向所有连接发送 CLS 命令 if len(r.conns()) == 0 { r.stopHandlers() } else { for _, c := range r.conns() { // 向每个连接发送 CLS 命令（告知服务端准备关闭） err := c.WriteCommand(StartClose()) if err != nil { r.log(LogLevelError, \u0026#34;(%s) error sending CLS - %s\u0026#34;, c.String(), err) } } // 30秒超时保护：若长时间未完成关闭，强制退出（避免永久阻塞） time.AfterFunc(time.Second*30, func() { r.exit() }) } } 其中，StartClose() 定义了 \u0026ldquo;关闭请求\u0026rdquo; 命令 CLS（Close 的缩写）：\n// github.com/nsqio/go-nsq/blob/master/command.go func StartClose() *Command { return \u0026amp;Command{[]byte(\u0026#34;CLS\u0026#34;), nil, nil} } 这一步的核心是：通过 CLS 命令告知服务端 \u0026ldquo;我要关闭了，请停止发新消息\u0026rdquo;，同时设置超时保护（30 秒），防止因异常导致关闭流程卡死。\n阶段二：服务端（nsqd）响应关闭 nsqd 收到客户端的 CLS 命令后，会执行一系列操作确保不再向客户端发送新消息，核心逻辑在 protocolV2.CLS 中：\n// github.com/nsqio/nsq/blob/master/nsqd/protocol_v2.go func (p *protocolV2) CLS(client *clientV2, params [][]byte) ([]byte, error) { // 校验客户端状态（仅订阅状态可关闭） if atomic.LoadInt32(\u0026amp;client.State) != stateSubscribed { return nil, protocol.NewFatalClientErr(nil, \u0026#34;E_INVALID\u0026#34;, \u0026#34;cannot CLS in current state\u0026#34;) } // 标记客户端为\u0026#34;关闭中\u0026#34;，并停止发送新消息 client.StartClose() // 向客户端返回 CLOSE_WAIT（表示服务端已准备好关闭） return []byte(\u0026#34;CLOSE_WAIT\u0026#34;), nil } client.StartClose() 是服务端处理的关键，它通过两步操作阻止新消息发送：\n将客户端的 ReadyCount 设为 0（ReadyCount 是 NSQ 的流量控制机制，表示客户端可接收的最大消息数）； 将客户端状态标记为 stateClosing（关闭中）。 // github.com/nsqio/nsq/blob/master/nsqd/client_v2.go func (c *clientV2) StartClose() { // 强制客户端不再接收新消息（ReadyCount=0） c.SetReadyCount(0) // 标记状态为\u0026#34;关闭中\u0026#34; atomic.StoreInt32(\u0026amp;c.State, stateClosing) } SetReadyCount 会触发状态更新信号，通过 ReadyStateChan 通知消息泵（messagePump）停止发送消息：\n// github.com/nsqio/nsq/blob/master/nsqd/client_v2.go func (c *clientV2) SetReadyCount(count int64) { oldCount := atomic.SwapInt64(\u0026amp;c.ReadyCount, count) if oldCount != count { c.tryUpdateReadyState() // 触发状态更新 } } func (c *clientV2) tryUpdateReadyState() { select { case c.ReadyStateChan \u0026lt;- 1: // 向通道发送信号，通知消息泵状态变化 default: } } 消息泵（messagePump）是 nsqd 向客户端发送消息的核心协程，收到 ReadyStateChan 信号后，会检查客户端是否仍可接收消息：\n// github.com/nsqio/nsq/blob/master/nsqd/protocol_v2.go func (p *protocolV2) messagePump(client *clientV2, startedChan chan bool) { ... for { // 若客户端状态为关闭中或不可接收消息，停止发送新消息 if subChannel == nil || !client.IsReadyForMessages() { memoryMsgChan = nil // 不再从内存队列取消息 backendMsgChan = nil // 不再从磁盘队列取消息 // 强制刷新缓冲区，然后等待退出 client.writeLock.Lock() err = client.Flush() client.writeLock.Unlock() if err != nil { goto exit // 退出消息泵 } } ... select { case \u0026lt;-client.ReadyStateChan: // 收到状态更新信号，重新检查 ... } exit: // 退出前清理资源（如定时器） heartbeatTicker.Stop() outputBufferTicker.Stop() } client.IsReadyForMessages() 会校验 ReadyCount 和当前处理中的消息数，确保关闭状态下不再接收新消息：\n// github.com/nsqio/nsq/blob/master/nsqd/client_v2.go func (c *clientV2) IsReadyForMessages() bool { readyCount := atomic.LoadInt64(\u0026amp;c.ReadyCount) inFlightCount := atomic.LoadInt64(\u0026amp;c.InFlightCount) // 若 ReadyCount \u0026lt;=0 或处理中消息数 \u0026gt;= 可接收数，返回 false if inFlightCount \u0026gt;= readyCount || readyCount \u0026lt;= 0 { return false } return true } 这一步的核心是：服务端通过将客户端标记为 \u0026ldquo;关闭中\u0026rdquo; 并清零 ReadyCount，确保不再发送新消息，同时完成已发送消息的缓冲区刷新。\n阶段三：客户端完成清理 客户端收到服务端返回的 CLOSE_WAIT 响应后，会执行最终的资源清理，包括关闭连接、停止消息处理器、等待所有协程退出。\n1. 处理服务端的 CLOSE_WAIT 响应 客户端的网络读协程（readLoop）会监听服务端响应，当收到 CLOSE_WAIT 时，触发连接关闭：\n// github.com/nsqio/go-nsq/blob/master/conn.go func (c *Conn) readLoop() { ... for { // 读取服务端帧数据 frameType, data, err := ReadUnpackedResponse(c) if err != nil { if err == io.EOF \u0026amp;\u0026amp; atomic.LoadInt32(\u0026amp;c.closeFlag) == 1 { goto exit // 若已标记关闭，正常退出 } ... } // 处理响应帧 switch frameType { case FrameTypeResponse: c.delegate.OnResponse(c, data) // 委托给 consumer 处理响应 ... } exit: ... } 响应处理逻辑在 Consumer.onConnResponse 中，收到 CLOSE_WAIT 后关闭连接：\n// github.com/nsqio/go-nsq/blob/master/consumer.go func (r *Consumer) onConnResponse(c *Conn, data []byte) { switch { case bytes.Equal(data, []byte(\u0026#34;CLOSE_WAIT\u0026#34;)): // 收到服务端的关闭确认，关闭当前连接 r.log(LogLevelInfo, \u0026#34;(%s) received CLOSE_WAIT from nsqd\u0026#34;, c.String()) c.Close() } } 2. 等待连接关闭与处理器退出 连接关闭后，客户端需要确保所有消息处理器（handlerLoop）完成当前任务。Consumer 内部通过 sync.WaitGroup 管理网络读写协程和消息处理器协程：\n// github.com/nsqio/go-nsq/blob/master/conn.go // 每个连接启动读、写两个协程，并用 WaitGroup 跟踪 func (c *Conn) connect() error { ... c.wg.Add(2) // 读、写协程各占一个计数 atomic.StoreInt32(\u0026amp;c.readLoopRunning, 1) go c.readLoop() go c.writeLoop() ... } 当所有连接关闭后，Consumer 会调用 stopHandlers() 关闭消息通道 incomingMessages，触发处理器退出：\n// github.com/nsqio/go-nsq/blob/master/consumer.go func (r *Consumer) stopHandlers() { r.stopHandler.Do(func() { r.log(LogLevelInfo, \u0026#34;stopping handlers\u0026#34;) close(r.incomingMessages) // 关闭消息通道，处理器会退出循环 }) } // 消息处理器协程 func (r *Consumer) handlerLoop(handler Handler) { r.log(LogLevelDebug, \u0026#34;starting Handler\u0026#34;) for { message, ok := \u0026lt;-r.incomingMessages if !ok { // 通道关闭，退出循环 goto exit } // 处理消息（用户自定义逻辑） err := handler.HandleMessage(message) ... } exit: // 退出前递减 WaitGroup 计数 atomic.AddInt32(\u0026amp;r.runningHandlers, -1) r.wg.Done() r.log(LogLevelDebug, \u0026#34;exiting Handler\u0026#34;) } 3. 最终退出信号 当所有协程（网络读写、消息处理器）都退出后，Consumer 会关闭 StopChan，向调用者发送 \u0026ldquo;已完成关闭\u0026rdquo; 的信号：\n// github.com/nsqio/go-nsq/blob/master/consumer.go func (r *Consumer) exit() { r.exitHandler.Do(func() { close(r.exitChan) r.wg.Wait() // 等待所有协程退出 close(r.StopChan) // 关闭 StopChan，通知外部已完成关闭 }) } 至此，整个优雅关闭流程完成。\n潜在问题与最佳实践 尽管 NSQ 设计了完善的优雅关闭机制，但实际使用中仍需注意一些细节，避免消息丢失或关闭不彻底。\n1. 避免在消息处理器中阻塞过长时间 Consumer.Stop() 有 30 秒超时保护（强制调用 exit()），若消息处理器在 30 秒内未完成当前任务，会被强制中断，可能导致消息未正确 Finish 或 Requeue。\n最佳实践：\n确保消息处理逻辑高效，避免长时间阻塞； 若处理耗时较长，可拆分为 \u0026ldquo;接收消息→存入本地任务队列→异步处理\u0026rdquo;，缩短处理器阻塞时间； 合理调整超时时间（需修改源码，或在应用层增加监控）。 2. 等待 StopChan 关闭后再退出程序 Consumer.Stop() 是异步触发关闭，调用后需通过 \u0026lt;-consumer.StopChan 等待关闭完成，否则可能导致程序提前退出。\n示例代码：\nconsumer, _ := nsq.NewConsumer(\u0026#34;topic\u0026#34;, \u0026#34;channel\u0026#34;, config) // 添加处理器... err := consumer.ConnectToNSQLookupds([]string{\u0026#34;127.0.0.1:4161\u0026#34;}) if err != nil { log.Fatal(err) } // 等待退出信号（如 SIGINT） sigChan := make(chan os.Signal, 1) signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-sigChan // 触发关闭并等待完成 consumer.Stop() \u0026lt;-consumer.StopChan // 关键：等待所有资源清理完成 log.Println(\u0026#34;consumer stopped gracefully\u0026#34;) 3. 依赖 NSQ 的消息重试机制保证可靠性 NSQ 无法 100% 保证关闭过程中消息不丢失（例如：处理器崩溃时未 Finish 消息）。此时需依赖 NSQ 的重试机制：\n消息默认有超时时间（MsgTimeout），超时未 Finish 会被重新投递； 处理失败时主动调用 message.Requeue(delay)，确保消息重试。 最佳实践：\n开启消息持久化（--mem-queue-size 配合磁盘队列）； 合理设置 MsgTimeout 和 MaxAttempts（最大重试次数）。 4. 处理并发处理器的退出顺序 Consumer.AddConcurrentHandlers 会启动多个 handlerLoop 协程，stopHandlers() 关闭 incomingMessages 后，所有处理器会退出，但 exit() 中 r.wg.Wait() 会等待所有处理器完成，因此 StopChan 关闭时已确保所有处理器退出（源码中 handlerLoop 退出时会调用 r.wg.Done()）。\n注意：若自定义处理器中使用了额外协程，需自行通过 sync.WaitGroup 管理，避免资源泄漏。\n总结 NSQ 消费者的优雅关闭是客户端与服务端协同的结果：\n客户端通过 CLS 命令发起关闭，服务端响应 CLOSE_WAIT 并停止发送新消息； 客户端关闭连接后，通过关闭消息通道 incomingMessages 触发处理器退出； 最终通过 sync.WaitGroup 等待所有协程完成，关闭 StopChan 标志关闭完成。 实际使用中，需注意等待 StopChan 信号、控制消息处理耗时、依赖重试机制，才能真正保证关闭过程的可靠性。\n","permalink":"/blogs/2025/sq/nsq/graceful-shutdown-of-nsq-consumers-source-code-deep-dive.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在分布式消息系统中，消费者的 \u0026ldquo;优雅关闭\u0026rdquo; 是保障消息可靠性的关键环节 —— 它需要确保关闭过程中不丢失已接收的消息、不突然中断正在处理的任务，同时平滑地与服务端断开连接。NSQ 作为一款轻量、高性能的分布式消息队列，其 Go 客户端（\u003ccode\u003ego-nsq\u003c/code\u003e）和服务端（\u003ccode\u003ensqd\u003c/code\u003e）通过一系列协作机制实现了消费者的优雅关闭。本文将深入解析这一过程的实现原理，并结合源码给出最佳实践。\u003c/p\u003e","title":"NSQ 消费者优雅关闭：源码拆解不丢消息的底层逻辑"},{"content":"前言 作为 Go 开发者，你是否曾被这些问题折磨？\n执行外部命令后，子进程 “僵尸” 残留，手动清理无从下手；\n命令超时失控，阻塞整个服务进程；\n大日志输出直接撑爆内存，触发 OOM；\n想实时捕获日志，却要写一堆繁琐的流处理代码；\n执行 bash 脚本时，fork 出的子进程超时后无法彻底杀死\u0026hellip;\n今天，我要分享一个自己开源的 Go 组件 ——executor，专门解决以上所有痛点！它是一个高性能、高可靠的命令 / 脚本执行器，让 Go 项目中的命令执行变得安全、高效、可控，已在 GitHub 开源：https://github.com/itart-top/executor\n🌟 为什么 executor 能成为 “痛点终结者”？ 先看看它的核心特性，每一个都精准命中开发难点：\n特性 解决的问题 适用场景 实时输出流式捕获 无需等待命令结束，实时处理日志（如 CI 日志实时展示） 自动化脚本、监控工具 上下文超时 \u0026amp; 取消 精准控制命令执行时长，防止阻塞服务 后台任务、分布式调度 子进程干净终止（Unix） 彻底清理命令 fork 出的子进程及子孙进程，无 “僵尸” 残留 批量任务执行、bash 脚本运行 输出截断保护 限制内存缓冲区大小，防止大输出导致 OOM 日志采集、大文件处理 易用 Option API 组合式配置参数，无需修改函数签名 复杂场景定制、多参数传递 ⚡ 3 分钟快速上手 只需 2 步，就能在项目中使用 executor，比原生os/exec更简单！\n1. 安装依赖 go get github.com/itart-top/executor 2. 第一个示例：执行 echo 命令 package main import ( \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;github.com/itart-top/executor\u0026#34; ) func main() { // 执行\u0026#34;echo Hello, Executor!\u0026#34;命令 result := executor.Run( context.Background(), // 上下文，可用于超时控制 \u0026#34;echo\u0026#34;, // 要执行的命令 executor.WithArgs(\u0026#34;Hello, Executor!\u0026#34;), // 命令参数 ) // 输出执行结果 fmt.Println(\u0026#34;退出码:\u0026#34;, result.ExitCode) // 退出码: 0 fmt.Println(\u0026#34;标准输出:\u0026#34;, result.Stdout) // 标准输出: Hello, Executor! fmt.Println(\u0026#34;标准错误:\u0026#34;, result.Stderr) // 标准错误: (空) } 运行代码，直接得到清晰的执行结果 —— 无需手动处理流、等待进程，executor 已帮你封装好所有细节！\n🛠 进阶用法：覆盖 90% 实际场景 executor 的 Option API 支持灵活组合配置，以下是 5 个高频场景的实战示例，复制就能用！\n场景 1：实时捕获 stdout/stderr（管道异步读取） 真正的实时捕获需要异步消费日志流，而非等待命令结束后统一获取。以下示例通过io.Pipe建立管道，用 goroutine 异步读取命令输出，模拟实际项目中 “实时打印日志”“实时写入文件” 等场景（每秒输出一行并实时捕获）：\npackage main import ( \u0026#34;bufio\u0026#34; \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;io\u0026#34; \u0026#34;strings\u0026#34; \u0026#34;github.com/itart-top/executor\u0026#34; ) func main() { // 1. 建立管道：命令的stdout写入PipeWriter，goroutine从PipeReader读取 pr, pw := io.Pipe() defer pr.Close() // 确保读取端最终关闭 // 2. 启动异步goroutine，实时消费日志（模拟日志打印、存储等逻辑） go func() { reader := bufio.NewReader(pr) for { // 按行读取命令输出（实时性取决于命令输出频率） line, err := reader.ReadString(\u0026#39;\\n\u0026#39;) if err != nil { if err == io.EOF { fmt.Println(\u0026#34;[REALTIME] 日志流结束\u0026#34;) break } fmt.Printf(\u0026#34;[REALTIME] 读取错误: %v\\n\u0026#34;, err) break } // 实时处理日志（此处为打印，实际可替换为写入日志文件、上报监控等） fmt.Printf(\u0026#34;[REALTIME] 捕获日志: %s\u0026#34;, line) } }() // 3. 定义要执行的命令：每秒输出一行\u0026#34;tick N\u0026#34;，共5行 cmd := \u0026#34;bash\u0026#34; args := []string{\u0026#34;-c\u0026#34;, \u0026#34;for i in {1..5}; do echo tick $i; sleep 1; done\u0026#34;} // 4. 执行命令，将stdout绑定到PipeWriter res := executor.Run( context.Background(), cmd, executor.WithArgs(args...), // 传递命令参数 executor.WithStdout(pw), // 命令输出写入管道 executor.WithStderr(pw), // （可选）将stderr也接入同一管道，统一捕获 ) // 5. 关闭写入端：告知读取端\u0026#34;输出已结束\u0026#34;，避免goroutine阻塞在ReadString pw.Close() // 6. 命令执行完成后，打印汇总结果 fmt.Println(\u0026#34;\\n==== 命令执行完成 ====\u0026#34;) fmt.Println(\u0026#34;退出码:\u0026#34;, res.ExitCode) // 退出码: 0（执行成功） fmt.Println(\u0026#34;执行错误:\u0026#34;, res.Err) // 执行错误: \u0026lt;nil\u0026gt; fmt.Println(\u0026#34;执行耗时:\u0026#34;, res.Duration) // 执行耗时: ~5s（因命令含5次1秒sleep） // 验证：确保捕获到关键输出（实际项目可根据需求判断执行结果） if !strings.Contains(res.Stdout, \u0026#34;tick 1\u0026#34;) { fmt.Printf(\u0026#34;验证失败：未在stdout中找到\u0026#39;tick 1\u0026#39;，实际输出：%s\\n\u0026#34;, res.Stdout) } else { fmt.Println(\u0026#34;验证成功：已捕获到\u0026#39;tick 1\u0026#39;等实时输出\u0026#34;) } } 运行效果（每秒实时打印一行，5 秒后输出汇总结果）：\n[REALTIME] 捕获日志: tick 1 [REALTIME] 捕获日志: tick 2 [REALTIME] 捕获日志: tick 3 [REALTIME] 捕获日志: tick 4 [REALTIME] 捕获日志: tick 5 ==== 命令执行完成 ==== 退出码: 0 执行错误: \u0026lt;nil\u0026gt; [REALTIME] 日志流结束 执行耗时: 5.055418083s 验证成功：已捕获到\u0026#39;tick 1\u0026#39;等实时输出 Process 85902 has exited with status 0 Detaching 场景 2：设置工作目录 \u0026amp; 环境变量 执行命令时指定工作目录，或注入自定义环境变量：\npackage main import ( \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;github.com/itart-top/executor\u0026#34; ) func main() { result := executor.Run( context.Background(), \u0026#34;sh\u0026#34;, executor.WithArgs(\u0026#34;-c\u0026#34;, \u0026#34;pwd; echo $MY_CUSTOM_VAR\u0026#34;), // 打印工作目录+环境变量 executor.WithDir(\u0026#34;/tmp\u0026#34;), // 设置工作目录为/tmp executor.WithEnv(\u0026#34;MY_CUSTOM_VAR=executor-is-awesome\u0026#34;),// 注入环境变量 ) fmt.Println(result.Stdout) // 输出： // /private/tmp // executor-is-awesome } 场景 3：超时控制，避免命令 “卡死” 比如执行一个可能超时的命令（如sleep 10），限制 1 秒内必须结束：\npackage main import ( \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/itart-top/executor\u0026#34; ) func main() { // 创建1秒超时的上下文 ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second) defer cancel() // 确保资源释放 // 执行需要10秒的命令 result := executor.Run( ctx, \u0026#34;sleep\u0026#34;, executor.WithArgs(\u0026#34;10\u0026#34;), ) // 超时后会返回错误 if result.Err != nil { fmt.Println(\u0026#34;执行失败:\u0026#34;, result.Err) // 执行失败: context deadline exceeded } fmt.Println(\u0026#34;退出码:\u0026#34;, result.ExitCode) // 退出码: -1（超时导致强制终止） } 场景 4：限制输出大小，防止 OOM 当命令可能输出大量内容（如yes 'spam'），限制缓冲区最大 100 字节：\npackage main import ( \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;github.com/itart-top/executor\u0026#34; ) func main() { result := executor.Run( context.Background(), \u0026#34;sh\u0026#34;, executor.WithArgs(\u0026#34;-c\u0026#34;, \u0026#34;yes \u0026#39;spam\u0026#39; | head -n 1000\u0026#34;), // 大量输出 executor.WithMaxOutput(100), // 限制最大100字节 ) fmt.Println(\u0026#34;输出是否被截断:\u0026#34;, result.StdoutTruncated) // 输出是否被截断: true fmt.Println(\u0026#34;输出长度:\u0026#34;, len(result.Stdout)) // 输出长度: 100 } 场景 5：清理 fork 出的子进程（避免僵尸进程） 执行 bash 脚本时，脚本内部可能 fork 后台子进程（如\u0026amp;启动的进程），原生os/exec超时后仅杀死主进程，子进程会残留为 “僵尸进程”。executor 能彻底清理主进程及所有 fork 出的子进程，以下是测试示例：\npackage main import ( \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;os\u0026#34; \u0026#34;strings\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/itart-top/executor\u0026#34; ) // 辅助函数：检查进程是否存在（Unix环境） func checkProcessExists(pid int) bool { // 通过kill -0 检查进程是否存活（无信号发送，仅判断存在性） err := syscall.Kill(pid, 0) return err == nil // 无错误表示进程存在 } func TestRun_ForkedProcessKill() { // 1. 创建临时bash脚本：脚本内fork后台子进程，主进程和子进程均循环打印 script := ` #!/bin/bash echo \u0026#34;Parent PID: $$\u0026#34; # 打印主进程PID，用于后续检查 # 子进程：后台循环打印（\u0026amp;表示fork到后台） (while true; do echo \u0026#34;child $$ running\u0026#34;; sleep 1; done) \u0026amp; # 主进程：循环打印 while true; do echo \u0026#34;parent $$ running\u0026#34;; sleep 1; done ` tmpFile := \u0026#34;test_fork.sh\u0026#34; // 写入脚本文件并设置可执行权限 if err := os.WriteFile(tmpFile, []byte(script), 0755); err != nil { fmt.Printf(\u0026#34;创建临时脚本失败: %v\\n\u0026#34;, err) return } defer os.Remove(tmpFile) // 执行完成后删除临时脚本 // 2. 创建3秒超时上下文：模拟“命令执行超时需强制终止”场景 ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() // 3. 捕获脚本输出（用于解析主进程PID和验证执行过程） var output strings.Builder // 4. 执行bash脚本 res := executor.Run( ctx, \u0026#34;bash\u0026#34;, executor.WithArgs(tmpFile), // 传递临时脚本路径 executor.WithStdout(\u0026amp;output), // 捕获标准输出 executor.WithStderr(\u0026amp;output), // 捕获标准错误 ) // 5. 打印执行结果汇总 fmt.Println(\u0026#34;==== 命令执行完成 ====\u0026#34;) fmt.Println(\u0026#34;ExitCode:\u0026#34;, res.ExitCode) // ExitCode: -1（超时终止，非0退出码） fmt.Println(\u0026#34;Error:\u0026#34;, res.Err) // Error: context deadline exceeded（超时错误） fmt.Println(\u0026#34;Duration:\u0026#34;, res.Duration) // Duration: ~3s（与超时时间一致） fmt.Println(\u0026#34;Captured Output:\\n\u0026#34;, output.String()) // 打印脚本输出（含主/子进程打印内容） // 6. 验证核心能力：超时后彻底清理进程 // 验证1：上下文确实触发超时 if ctx.Err() == nil { fmt.Println(\u0026#34;验证失败：预期触发上下文超时，实际未超时\u0026#34;) return } // 验证2：从输出中解析主进程PID，检查主进程是否已被杀死 var parentPID int _, err := fmt.Sscanf(output.String(), \u0026#34;Parent PID: %d\u0026#34;, \u0026amp;parentPID) if err != nil { fmt.Printf(\u0026#34;解析主进程PID失败: %v\\n\u0026#34;, err) return } if parentPID \u0026gt; 0 \u0026amp;\u0026amp; checkProcessExists(parentPID) { fmt.Printf(\u0026#34;验证失败：主进程%d仍存活（未被彻底杀死）\\n\u0026#34;, parentPID) return } // 验证3：退出码非0（超时终止应为非0） if res.ExitCode == 0 { fmt.Println(\u0026#34;验证失败：超时终止预期非0退出码，实际为0\u0026#34;) return } fmt.Println(\u0026#34;所有验证通过：超时后主进程及fork子进程均被彻底清理！\u0026#34;) } func main() { TestRun_ForkedProcessKill() } 核心价值：该示例模拟实际场景中 “bash 脚本 fork 后台子进程” 的情况，executor 在超时后不仅杀死脚本主进程，还能清理所有 fork 出的子进程，避免进程残留导致的资源泄漏（如 CPU 占用、PID 耗尽），这是原生os/exec难以实现的关键能力。\n📌 适合哪些项目使用？ executor 的设计初衷就是覆盖各类命令执行场景，尤其适合：\n分布式任务调度系统：控制任务超时、清理子进程，避免节点资源泄漏；\n自动化脚本工具：如部署脚本、数据同步脚本，实时捕获日志并控制输出；\nCI/CD 工具链：执行构建、测试命令，限制输出大小并处理超时；\n后台服务：服务中需要执行外部 bash 脚本（如数据处理脚本），确保子进程无残留。\n✅ 测试与贡献 目前 executor 已覆盖单元测试、超时测试、子进程清理测试、输出截断测试等核心场景，确保功能稳定：\n# 本地执行所有测试 go test ./... -v 如果你有新需求（如增强日志格式化）或发现 bug，欢迎通过以下方式贡献：\nFork 仓库：https://github.com/itart-top/executor\n新建分支：feature/xxx 或 fix/xxx\n提交 PR，确保测试覆盖率不下降\n📄 许可证与地址 开源协议：MIT License（可自由商用）\nGitHub 地址：https://github.com/itart-top/executor\n文档：README 包含完整 API 说明与示例，上手无门槛\n🎉 最后 executor 的目标是成为 Go 生态中最可靠的命令执行组件，如果你在项目中遇到 “子进程残留”“命令超时”“日志实时捕获” 等痛点，不妨试试它！使用过程中有任何问题，欢迎在 GitHub Issues 留言，我会及时回复。\n也期待更多开发者参与进来，一起完善这个工具，让 Go 命令执行变得更简单～\n","permalink":"/blogs/2025/go/executor-reboot-go-exec-command.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e作为 Go 开发者，你是否曾被这些问题折磨？\u003c/p\u003e\n\u003cul\u003e\n\u003cli\u003e\n\u003cp\u003e执行外部命令后，子进程 “僵尸” 残留，手动清理无从下手；\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e命令超时失控，阻塞整个服务进程；\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e大日志输出直接撑爆内存，触发 OOM；\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e想实时捕获日志，却要写一堆繁琐的流处理代码；\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e执行 bash 脚本时，fork 出的子进程超时后无法彻底杀死\u0026hellip;\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ul\u003e","title":"重塑 exec.Command：打造更可控的 Go 命令执行器"},{"content":"1. 引言 本规范旨在统一数据库设计标准，保障数据一致性、完整性、性能与可维护性，适用于所有业务系统的数据库设计（如 MySQL、PostgreSQL 等关系型数据库），需结合业务场景灵活落地。\n2. 命名规范 2.1 核心原则 统一采用 “小写字母 + 下划线” 命名法，禁止混合大小写、特殊字符（如#、$）或数据库关键字（如select、order）；\n所有命名需体现业务含义，避免无意义缩写或数字标识（如index1、t1）；\n表名、字段名、索引名长度控制在 30 字符内（避免超出数据库命名长度限制）。\n2.2 各对象命名规范 对象类型 规范要求 正例 反例 反例问题 表名 业务模块前缀 + 核心含义（如user_、order_） user_info（用户信息表）、order_detail（订单明细表） UserInfo（混合大小写）、order（无模块前缀 + 关键字） 协作理解成本高，需转义关键字 字段名 核心含义 + 统一后缀（如时间用_at、状态用_status） user_id（用户 ID）、created_at（创建时间） uid（无意义缩写）、CreatedTime（驼峰命名） 新人需额外文档理解，命名不统一 索引名 类型标识（idx_普通索引 /uni_唯一索引）+ 字段组合 idx_user_id_status（用户 ID + 状态普通索引）、uni_user_phone（用户手机号唯一索引） index2（无含义）、user_index（无类型标识） 维护时无法快速判断索引用途 视图名 前缀view_+ 业务含义 view_user_order（用户订单关联视图） user_order_view（前缀不统一） 无法快速区分视图与表 3. 结构设计规范 3.1 范式与反范式平衡 优先遵循第三范式：消除数据冗余与传递依赖（如用户手机号仅存于user_info，不冗余到order_detail）；\n非核心场景适当反范式：高频查询表（如商品详情页）可冗余关联字段（如product表冗余category_name），减少 JOIN 操作，需通过定时任务 / 消息队列同步数据。\n3.2 表拆分与扩展 规范要求 正例 反例 反例问题 大表拆分 订单表按时间分表：order_202501、order_202502（单表数据≤1000 万） 单表存储 5 亿订单数据 查询耗时从 100ms 增至 5s，索引失效 字段扩展 预留扩展字段需注明用途：ext1 VARCHAR(64) COMMENT '预留：用户等级标识' 无注释的ext1、ext2 后续维护无法判断字段用途，易滥用 附属表拆分 大字段（如用户头像、文章内容）拆分至附属表：user_avatar（存头像路径） 主表user_info含avatar BLOB字段 主表查询时加载大字段，性能下降 4. 字段设计规范 4.1 通用字段设计原则 优先选择 “最小且合适” 的数据类型（如状态用TINYINT，不用INT）；\n非必要字段不设NOT NULL，关键字段（如user_id）设默认值或非空约束；\n禁止用字符串存储日期、金额、状态等结构化数据。\n4.2 常用字段专项规范 4.2.1 时间类常用字段 字段名 数据类型 适用场景 正例 反例 设计原则 created_at datetime（时区同步用timestamp） 数据创建时间（用户注册、订单生成） created_at datetime NOT NULL DEFAULT CURRENT_TIMESTAMP create_time VARCHAR(20)（存2025-11-06） 统一用_at后缀，禁止字符串存储，设默认值 updated_at datetime 数据最后更新时间（订单状态修改） updated_at datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP update_time（无自动更新） 设 “更新时自动填充”，避免手动维护 deleted_at datetime 软删除标记（替代物理删除） deleted_at datetime DEFAULT NULL（未删除为NULL） is_delete TINYINT(1)（仅存是否删除） 保留删除时间便于追溯，不用布尔型单独存储 expired_at datetime 过期时间（优惠券、会员有效期） expired_at datetime NOT NULL expire_date DATE（仅存日期，无时间） 需精确控制过期时间时用datetime 4.2.2 状态类常用字段 字段名 数据类型 适用场景 正例 反例 设计原则 status TINYINT UNSIGNED 通用状态（订单：0 = 未支付，1 = 已支付） status TINYINT UNSIGNED NOT NULL DEFAULT 0 COMMENT '0=未支付，1=已支付，2=已取消' status VARCHAR(10)（存 “未支付”） 用数字枚举 + 注释，禁止字符串存储 audit_status TINYINT UNSIGNED 审核状态（文章：0 = 待审核，1 = 通过） audit_status TINYINT UNSIGNED NOT NULL DEFAULT 0 check_status（命名不统一） 业务场景 +_status，避免自定义模糊命名 is_valid TINYINT(1) 数据有效性（0 = 无效，1 = 有效） is_valid TINYINT(1) NOT NULL DEFAULT 1 is_active/is_enable（混用） 布尔型状态统一用is_+形容词 4.2.3 关联类常用字段 字段名 数据类型 适用场景 正例 反例 设计原则 user_id 与user_info.id一致（如BIGINT） 关联用户表 user_id BIGINT NOT NULL COMMENT '关联user_info.id' uid INT（缩写 + 类型不匹配） 关联表名 +_id，类型与被关联主键一致 parent_id 与当前表id一致 自关联（分类上下级、评论回复） parent_id BIGINT DEFAULT 0 COMMENT '父分类ID，0=顶级' pid（缩写） 自关联固定用parent_id 4.2.4 标识 / 描述类常用字段 字段名 数据类型 适用场景 正例 反例 设计原则 id BIGINT UNSIGNED 表主键（自增） id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY user_id（主键名不统一） 单表主键固定用id，自增 + 无符号 uuid CHAR(36) 全局唯一标识（分布式系统） uuid CHAR(36) NOT NULL COMMENT '全局唯一UUID' uuid VARCHAR(50)（长度冗余） 用CHAR(36)（UUID 标准长度） remark VARCHAR(512) 备注（订单备注、操作说明） remark VARCHAR(512) DEFAULT '' COMMENT '用户订单备注' remark TEXT（大字段滥用） 内容≤1000 字用VARCHAR，避免TEXT 5. 索引设计规范 5.1 核心原则 主键必设（优先自增BIGINT，避免UUID导致索引碎片化）；\n单表索引数量≤5 个（过多索引导致写入性能下降 30%+）；\n联合索引遵循 “最左前缀原则”，高频查询字段放左侧。\n5.2 索引设计 场景 正例 反例 反例问题 高频查询 登录验证：uni_user_phone（手机号唯一索引） 为user_info的gender（性别，区分度低）建索引 扫描行数占比高，索引无效 联合索引 订单查询：idx_user_id_created_at（用户 ID + 创建时间） idx_create_at_user_id（高频字段在后） 无法命中 “用户 ID + 时间范围” 查询 避免失效 时间范围查询：created_at BETWEEN '2025-11-01' AND '2025-11-06' DATE_FORMAT(create_at, '%Y-%m') = '2025-11' 函数操作导致索引失效，全表扫描 6. 完整性约束规范 约束类型 规范要求 正例 反例 反例问题 主键约束 单表唯一主键，自增BIGINT id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY 无主键或用UUID做主键 无主键导致数据无法唯一定位，UUID影响性能 外键约束 核心表（如order关联user）用外键，高频更新表（如社交好友表）应用层校验 user_id BIGINT NOT NULL REFERENCES user_info(id) 所有表均无外键，应用层未校验 数据不一致（如删除用户后残留订单） 唯一约束 需去重字段（手机号、商品编码）加唯一索引 uni_user_phone（手机号唯一索引） 业务层判断去重，无数据库约束 高并发下导致重复数据 CHECK 约束 字段合法性校验（如年龄 1-120 岁） age TINYINT UNSIGNED CHECK (age BETWEEN 1 AND 120) 仅应用层校验年龄 绕过应用层操作时插入非法数据 7. 性能与安全规范 规范维度 要求 正例 反例 反例问题 存储引擎 优先InnoDB（支持事务、行锁），日志表可MyISAM user_info用InnoDB，sys_log用MyISAM 混合引擎（user用InnoDB，order用MyISAM） 跨表事务不支持，数据一致性风险 敏感数据 加密存储（密码哈希，手机号脱敏） 密码：SHA-256加盐哈希；手机号：`SUBSTR (phone,1,3) 分库分表 数据量超 1000 万规划拆分（按时间、地域、用户 ID 哈希） 订单表按用户 ID 哈希分 3 库 10 表 单库单表存储 5 亿数据 连接超时，查询无法响应 8. 规范落地建议 设计前校验：使用 “数据库设计校验清单”（含命名、字段类型、索引数量等），避免遗漏；\n定期评审：每季度检查线上表结构，删除冗余索引、清理无用字段；\n工具辅助：用 SQL lint 工具（如sqlfluff）自动检测命名与类型规范，集成到 CI/CD 流程；\n文档同步：表结构变更需更新文档，记录字段含义、约束规则及变更原因。\n","permalink":"/blogs/2025/db/database-design-best-practices.html","summary":"\u003ch2 id=\"1-引言\"\u003e1. 引言\u003c/h2\u003e\n\u003cp\u003e本规范旨在统一数据库设计标准，保障数据一致性、完整性、性能与可维护性，适用于所有业务系统的数据库设计（如 MySQL、PostgreSQL 等关系型数据库），需结合业务场景灵活落地。\u003c/p\u003e","title":"数据库设计黄金规范：从命名到索引的系统化最佳实践"},{"content":"前言 本文面向在 Go 中实践领域驱动设计（DDD）的工程师，旨在清晰定义常见 \u0026ldquo;对象\u0026rdquo; 概念（DO/VO/DTO/PO/BO/AO/Form），并明确其目录位置、转换时机、最佳实践及反模式，同时提供查询条件容器的设计建议。\n核心概念定义 名称 全称 核心特征 建议存放位置 DO Domain Object / Entity 有唯一标识（ID）、生命周期与业务行为，包含领域规则 domain 包 / 模块下 VO Value Object 不可变、按值比较（无独立 ID），代表具体值 / 概念（如 Money、Address） domain/vo 或领域实体同包 DTO Data Transfer Object 用于层间数据传输（如 API↔Service），携带序列化标签（JSON/protobuf 等） api/dto、application/dto 或 transport 层 PO Persistence Object 与数据库映射（含 ORM/SQL 标签），属于仓储实现细节 internal/repo/mysql/model、infra/persistence等 BO Business Object 命名模糊（业务组合对象 / 服务层 \u0026ldquo;富 DTO\u0026rdquo;），建议避免；若使用需明确语义 application/bo（限定为 \u0026ldquo;业务应用层只读聚合视图\u0026rdquo;） AO Application Object 应用层内部传递对象，易与 DTO 混淆，建议复用 DTO 或明确命名 application/* 或直接使用 DTO Form - HTTP 层表单 / JSON 绑定结构体，带校验标签（binding/validate） api/handler/form 或 transport/http/form 设计总原则 领域模型纯净性：domain 包内的 DO/VO 不得包含数据库 / JSON 标签，不得依赖基础设施（infra）包，仅保留业务逻辑与验证逻辑。 转换责任边界：DB 与 Domain、HTTP 与 Domain 的转换必须放在适配器层（repository/handler/mapper），领域层不处理格式转换。 依赖倒置：领域层定义抽象接口（如domain/repository），具体实现（如 ORM/PO）放在基础设施层（infra）。 命名唯一性：避免 BO/AO/DTO 混用，若需多用途，通过模块名明确区分（如api/dto、application/vo）。 推荐项目目录结构（Go） /cmd/... # 程序入口 /internal/ app/ # 应用层（用例/服务） user_service.go # 业务服务实现 dto/ # 应用层DTO user_dto.go domain/ # 领域层 user/ user.go # DO（实体） address_vo.go # VO（值对象） repository.go # 仓储接口（领域层抽象） repo/ # 基础设施层（仓储实现） mysql/ model/ user_po.go # PO（数据库模型） user_repo.go # 仓储接口实现 mapper.go # PO ↔ DO 映射函数 api/ # 接口层 http/ handler/ user_handler.go # HTTP处理器 form/ user_form.go # Form（HTTP绑定结构体） pkg/ query/ # 通用查询条件容器 典型代码示例 1. 领域层：DO（实体）+ VO（值对象） DO（实体）：封装业务行为与生命周期internal/domain/user/user.go\npackage user import \u0026#34;time\u0026#34; var ( ErrInvalidName = errors.New(\u0026#34;invalid name\u0026#34;) ErrInvalidEmail = errors.New(\u0026#34;invalid email\u0026#34;) ) // User 领域实体（DO）——不含任何DB/JSON标签 type User struct { ID string Name string Email Email // 嵌入VO CreatedAt time.Time } // NewUser 领域工厂：确保实体创建符合业务规则 func NewUser(id, name string, email Email) (*User, error) { if name == \u0026#34;\u0026#34; { return nil, ErrInvalidName } if err := email.Validate(); err != nil { return nil, err } return \u0026amp;User{ ID: id, Name: name, Email: email, CreatedAt: time.Now(), }, nil } // ChangeEmail 领域行为：封装邮箱修改规则 func (u *User) ChangeEmail(e Email) error { if err := e.Validate(); err != nil { return err } u.Email = e return nil } VO（值对象）：不可变，按值比较，封装验证逻辑internal/domain/user/email.go\npackage user // Email 值对象：代表邮箱概念，不可变 type Email struct { Addr string // 实际邮箱地址 } // NewEmail 工厂方法：确保创建时验证合法性 func NewEmail(addr string) (Email, error) { e := Email{Addr: addr} if err := e.Validate(); err != nil { return Email{}, err } return e, nil } // Validate 验证逻辑：封装邮箱格式规则 func (e Email) Validate() error { if e.Addr == \u0026#34;\u0026#34; { return ErrInvalidEmail } // 实际场景可添加正则校验（如`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$`） return nil } 2. 基础设施层：PO（持久化对象）与映射 PO（数据库模型）：与数据库字段映射，含 ORM 标签internal/repo/mysql/model/user_po.go\npackage model import \u0026#34;time\u0026#34; // UserPO 数据库映射对象（PO）——含GORM标签 type UserPO struct { ID string `gorm:\u0026#34;primaryKey;column:id\u0026#34;` Name string `gorm:\u0026#34;column:name;not null\u0026#34;` Email string `gorm:\u0026#34;column:email;uniqueIndex\u0026#34;` CreatedAt time.Time `gorm:\u0026#34;column:created_at;autoCreateTime\u0026#34;` } // TableName 显式指定数据库表名 func (UserPO) TableName() string { return \u0026#34;users\u0026#34; } 映射函数：负责 PO 与 DO 的转换（放在仓储实现层，避免领域层依赖 infra）internal/repo/mysql/mapper.go\npackage mysql import ( \u0026#34;myapp/internal/domain/user\u0026#34; \u0026#34;myapp/internal/repo/mysql/model\u0026#34; ) // poToDomain 将PO转换为领域对象（DO） func poToDomain(po *model.UserPO) (*user.User, error) { email, err := user.NewEmail(po.Email) // 依赖领域VO的工厂方法，确保验证 if err != nil { return nil, err } return \u0026amp;user.User{ ID: po.ID, Name: po.Name, Email: email, CreatedAt: po.CreatedAt, }, nil } // domainToPO 将领域对象（DO）转换为PO func domainToPO(do *user.User) *model.UserPO { return \u0026amp;model.UserPO{ ID: do.ID, Name: do.Name, Email: do.Email.Addr, // 提取VO的原始值 CreatedAt: do.CreatedAt, } } 3. 接口层：Form（HTTP 绑定）与 DTO（数据传输） Form（HTTP 请求绑定）：带校验标签，负责接收用户输入internal/api/http/form/user_form.go\npackage form // CreateUserForm HTTP请求绑定结构体（Form） type CreateUserForm struct { Name string `json:\u0026#34;name\u0026#34; binding:\u0026#34;required,min=2,max=30\u0026#34;` // 表单校验规则 Email string `json:\u0026#34;email\u0026#34; binding:\u0026#34;required,email\u0026#34;` // 使用gin的binding标签 } DTO（应用层传输）：定义服务间数据结构，带序列化标签internal/app/dto/user_dto.go\npackage dto // UserDTO 应用层数据传输对象 type UserDTO struct { ID string `json:\u0026#34;id\u0026#34;` // 序列化标签（供API返回） Name string `json:\u0026#34;name\u0026#34;` Email string `json:\u0026#34;email\u0026#34;` } // CreateUserDTO 用于创建用户的DTO（输入参数） type CreateUserDTO struct { Name string `json:\u0026#34;name\u0026#34;` Email string `json:\u0026#34;email\u0026#34;` } 4. 转换流程示例（Handler → Service → Repository） Handler 层：Form → DTO 转换，调用服务internal/api/http/handler/user_handler.go\npackage handler import ( \u0026#34;myapp/internal/api/http/form\u0026#34; \u0026#34;myapp/internal/app\u0026#34; \u0026#34;myapp/internal/app/dto\u0026#34; \u0026#34;github.com/gin-gonic/gin\u0026#34; ) type UserHandler struct { userService *app.UserService } func (h *UserHandler) Create(c *gin.Context) { // 1. 绑定HTTP请求到Form并校验 var f form.CreateUserForm if err := c.ShouldBindJSON(\u0026amp;f); err != nil { c.JSON(400, gin.H{\u0026#34;error\u0026#34;: err.Error()}) return } // 2. Form转换为应用层DTO reqDTO := dto.CreateUserDTO{ Name: f.Name, Email: f.Email, } // 3. 调用应用服务 resDTO, err := h.userService.Create(c.Request.Context(), reqDTO) if err != nil { c.JSON(500, gin.H{\u0026#34;error\u0026#34;: err.Error()}) return } // 4. 返回DTO c.JSON(200, resDTO) } Service 层：DTO → 领域对象 转换，调用领域逻辑internal/app/user_service.go\npackage app import ( \u0026#34;context\u0026#34; \u0026#34;myapp/internal/app/dto\u0026#34; \u0026#34;myapp/internal/domain/user\u0026#34; ) type UserService struct { userRepo user.Repository // 依赖领域层仓储接口 } func (s *UserService) Create(ctx context.Context, req dto.CreateUserDTO) (*dto.UserDTO, error) { // 1. DTO转换为领域VO（通过领域工厂确保验证） email, err := user.NewEmail(req.Email) if err != nil { return nil, err } // 2. 创建领域对象（DO） u, err := user.NewUser(generateID(), req.Name, email) if err != nil { return nil, err } // 3. 调用仓储保存领域对象 if err := s.userRepo.Save(ctx, u); err != nil { return nil, err } // 4. 领域对象转换为返回DTO return \u0026amp;dto.UserDTO{ ID: u.ID, Name: u.Name, Email: u.Email.Addr, }, nil } 转换时机与位置规范 转换方向 负责层 / 组件 核心目的 HTTP Form → DTO Handler（transport 层） 解析用户输入，做初步格式校验，隔离 HTTP 框架细节 DTO → 领域对象（DO/VO） Application（服务层） 将外部数据转换为领域可识别的模型，通过领域工厂确保业务规则被遵守 领域对象 → DTO Application（服务层） 隐藏领域内部细节，仅暴露外部需知的字段，适配输出协议（如 JSON/protobuf） PO ↔ DO Repository 实现（infra 层） 隔离数据库模型与领域模型，确保领域层不依赖 ORM / 数据库细节 查询条件容器（Query/Criteria）设计 查询条件容器用于封装查询参数（如分页、过滤、排序），其设计需避免耦合外部协议或数据库细节。\n推荐方案 简单场景（与仓储强耦合）在领域仓储接口层定义查询容器，确保上层（应用层）可直接使用：\n// domain/user/repository.go（领域仓储接口） type UserQuery struct { Name string // 按名称过滤 Email string // 按邮箱过滤 Page int // 分页参数 PageSize int SortBy string // 排序字段 } type UserRepository interface { Find(ctx context.Context, q UserQuery) ([]*User, int64, error) // 返回数据+总数 } HTTP 驱动的查询在api/form中绑定 HTTP 参数，再转换为仓储层的查询容器（避免 HTTP 标签污染仓储接口）：\n// api/http/form/user_query_form.go type UserQueryForm struct { Name string `form:\u0026#34;name\u0026#34;` Email string `form:\u0026#34;email\u0026#34;` Page int `form:\u0026#34;page\u0026#34; binding:\u0026#34;min=1\u0026#34;` PageSize int `form:\u0026#34;page_size\u0026#34; binding:\u0026#34;min=1,max=100\u0026#34;` } // Handler中转换 func (h *UserHandler) List(c *gin.Context) { var f form.UserQueryForm c.ShouldBindQuery(\u0026amp;f) // 转换为领域查询容器 q := user.UserQuery{ Name: f.Name, Email: f.Email, Page: f.Page, PageSize: f.PageSize, } users, total, _ := h.userService.List(c, q) } 复杂过滤（规格模式）若过滤逻辑涉及领域语义（如 \u0026ldquo;已支付且金额≥1000\u0026rdquo;），在领域层定义Specification接口：\n// domain/specification.go type Specification[T any] interface { IsSatisfiedBy(T) bool // 内存中验证 ToSQL() (string, []interface{}) // 转换为SQL条件（可选，由仓储实现） } 最佳实践总结 领域层纯净：domain包只放 DO/VO/ 接口和业务逻辑，不依赖任何外部包（如 ORM/HTTP 框架）。 单向依赖：上层（应用 / 接口）依赖领域层接口，领域层不依赖下层（infra）。 映射集中管理：转换函数集中在适配器层（handler/repo），避免散落在业务逻辑中。 DTO 专用化：为不同场景定义专用 DTO（如CreateUserDTO/GetUserDTO），避免 \u0026ldquo;万能 DTO\u0026rdquo;。 VO 不可变：VO 使用值类型，通过工厂方法创建，禁止直接修改字段（确保值语义）。 错误边界清晰：转换失败（如无效邮箱字符串→Email VO）需在应用层捕获并返回友好信息。 常见反模式（禁止做法） 领域对象带 ORM/JSON 标签：污染领域模型，导致领域层依赖 infra，违反依赖倒置。 Handler 直接使用 PO：暴露数据库实现细节（如字段名、索引），增加 API 与 DB 的耦合。 DTO 替代领域模型：在 DTO 中实现业务逻辑，导致领域规则分散，失去 DDD 核心价值。 结构体多职责：同一结构体同时作为 PO/DTO/Form（如既带gorm标签又带json标签）。 SQL 逻辑侵入领域层：在domain包中写 SQL 片段或 ORM 查询，混淆业务与存储逻辑。 命名混乱：BO/AO/DTO 随意混用，无明确注释，增加团队沟通成本。 进阶建议 映射工具：小型项目建议手写映射（可读性高、易调试）；大型项目可使用代码生成工具（如go generate+ 自定义模板），避免反射工具（如mapstruct）带来的隐式错误。 测试：为所有映射函数编写单元测试，覆盖字段映射、格式转换（如时间字符串→time.Time）、验证失败场景。 结语（自查清单） domain包是否只包含 DO/VO/ 接口和纯业务逻辑？ PO 是否放在infra/repo下，且领域层不依赖 PO？ DTO/Form 是否带专属标签（JSON/binding），且与领域对象严格分离？ 转换逻辑是否集中在 handler 或 repo 实现层，未侵入领域层？ 查询容器是否避免了 HTTP/DB 细节的直接耦合？ 所有映射函数是否有单元测试？ 遵循以上规范，可在 Go+DDD 实践中实现清晰的分层边界、低耦合的代码结构，提升系统可维护性。\n","permalink":"/blogs/2025/go/ddd-go-objects-concepts-hands-on.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e本文面向在 Go 中实践领域驱动设计（DDD）的工程师，旨在清晰定义常见 \u0026ldquo;对象\u0026rdquo; 概念（DO/VO/DTO/PO/BO/AO/Form），并明确其目录位置、转换时机、最佳实践及反模式，同时提供查询条件容器的设计建议。\u003c/p\u003e","title":"Go+DDD 对象全家桶：DO/VO/DTO 等概念 + 实践"},{"content":"前言 在 Go 语言中，interface 是实现多态的核心机制，也是 Go 类型系统中最具特色的特性之一。它提供了一种灵活的方式来定义行为，而无需关心具体实现。本文将从底层源码实现出发，全面讲解 interface 的工作原理、使用技巧、最佳实践及常见陷阱。\n一、什么是 interface？ interface（接口）是一种抽象类型，它定义了一组方法签名的集合，而不包含具体实现。任何类型只要实现了接口中定义的所有方法，就隐式地实现了该接口。这种 \u0026ldquo;隐式实现\u0026rdquo; 机制是 Go 与其他语言（如 Java）的重要区别。\n// 定义接口 type Writer interface { Write([]byte) (int, error) } // 某个类型只要实现了 Write 方法，就自动实现了 Writer 接口 type File struct{} func (f File) Write(b []byte) (int, error) { // 具体实现 return len(b), nil } 接口的核心价值在于：定义行为契约，实现组件解耦。\n二、interface 的底层实现（源码视角） 要深入理解 interface，必须了解其底层数据结构。Go 源码中，接口分为两种类型：\n1. 空接口（interface{}） 空接口没有任何方法，可表示任意类型。其底层由 runtime.eface 结构体实现：\n// src/runtime/runtime2.go type eface struct { _type *type // 指向类型信息 data unsafe.Pointer // 指向数据值 } _type：存储具体类型的元信息（如类型名称、大小、方法等）\ndata：存储具体值的指针\n2. 非空接口（带方法的接口） 非空接口包含方法定义，底层由 runtime.iface 结构体实现：\n// src/runtime/runtime2.go type iface struct { tab *itab // 接口表 data unsafe.Pointer // 指向数据值 } // 接口表，存储接口与具体类型的匹配信息 type itab struct { inter *interfacetype // 接口类型信息 _type *type // 具体类型信息 link *itab bad int32 inhash int32 fun [1]uintptr // 方法表（函数指针） } tab（itab）：关键结构体，包含接口类型、具体类型及方法表（存储具体类型实现的接口方法指针）\ndata：同空接口，指向具体值的指针\n接口赋值的底层过程 当将一个具体类型赋值给接口时，runtime 会：\n检查具体类型是否实现了接口的所有方法（编译期检查）\n为接口创建对应的 eface 或 iface 结构体\n填充类型信息（_type 或 itab）和数据指针（data）\n例如：\nvar w Writer = File{} // 底层会创建 iface 结构体，tab 指向包含 File 与 Writer 匹配信息的 itab，data 指向 File 实例 三、interface 的基本使用 1. 接口定义与实现 // 定义接口 type Reader interface { Read(p []byte) (n int, err error) } // 实现接口（隐式） type StringReader struct { s string pos int } func (r *StringReader) Read(p []byte) (n int, err error) { if r.pos \u0026gt;= len(r.s) { return 0, io.EOF } n = copy(p, r.s[r.pos:]) r.pos += n return n, nil } 关键点：Go 中没有 implements 关键字，实现接口只需实现所有方法。\n2. 接口组合 接口可以组合其他接口，形成新的接口：\ntype ReadWriter interface { Reader // 嵌入 Reader 接口 Writer // 嵌入 Writer 接口 } // 等价于： // type ReadWriter interface { // Read(p []byte) (n int, err error) // Write(p []byte) (n int, err error) // } 标准库中的 io.ReadWriter 就是这样实现的。\n3. 类型断言 类型断言用于提取接口中存储的具体值，语法：x.(T)\nvar i interface{} = \u0026#34;hello\u0026#34; // 基本用法 s, ok := i.(string) if ok { fmt.Println(\u0026#34;字符串值：\u0026#34;, s) } // 错误用法（当断言失败时会 panic） s = i.(int) // panic: interface conversion: interface {} is string, not int 4. 类型开关（type switch） 用于批量判断接口的具体类型：\nfunc printType(i interface{}) { switch v := i.(type) { case int: fmt.Println(\u0026#34;int 类型，值为：\u0026#34;, v) case string: fmt.Println(\u0026#34;string 类型，值为：\u0026#34;, v) case bool: fmt.Println(\u0026#34;bool 类型，值为：\u0026#34;, v) default: fmt.Println(\u0026#34;未知类型\u0026#34;) } } 四、最佳实践与使用技巧 1. 接口设计原则：小而专 遵循单一职责原则，一个接口只定义一组相关的方法：\n// 推荐：小接口 type Reader interface { Read() } type Writer interface { Write() } // 不推荐：大而全的接口 type Everything interface { Read() Write() Delete() Update() // ... 过多方法 } 标准库中的 io.Reader 和 io.Writer 就是典范，它们各自只定义一个方法，组合性极强。\n2. 依赖抽象而非具体 函数参数应尽量使用接口类型，提高灵活性：\n// 推荐：依赖接口 func SaveData(w Writer, data []byte) error { _, err := w.Write(data) return err } // 不推荐：依赖具体类型 func SaveData(f *File, data []byte) error { // 只能接收 File 类型 _, err := f.Write(data) return err } 3. 合理使用空接口 空接口（interface{}）可表示任意类型，但过度使用会失去类型安全：\n// 合理使用：通用容器 type Cache struct { data map[string]interface{} // 存储任意类型的值 } // 不推荐：无必要的空接口 func Add(a, b interface{}) interface{} { // 丢失类型检查，需在内部做大量类型断言 // ... } 4. 接口与测试 利用接口可轻松实现 mock 测试：\n// 定义接口 type APIClient interface { Get(url string) (string, error) } // 真实实现 type HTTPClient struct{} func (c HTTPClient) Get(url string) (string, error) { /* 真实 HTTP 请求 */ } // Mock 实现（用于测试） type MockClient struct { mockResponse string mockError error } func (m MockClient) Get(url string) (string, error) { return m.mockResponse, m.mockError } // 业务逻辑（依赖接口） func FetchData(client APIClient, url string) (string, error) { return client.Get(url) } // 测试时使用 MockClient，无需真实网络请求 5. 避免接口嵌套过深 接口嵌套过多会导致复杂性上升：\n// 不推荐：多层嵌套 type A interface { M1() } type B interface { A; M2() } type C interface { B; M3() } type D interface { C; M4() } 五、注意事项与常见陷阱 1. nil 接口的坑 接口变量包含 \u0026ldquo;类型\u0026rdquo; 和 \u0026ldquo;值\u0026rdquo; 两部分，只有当两者都为 nil 时，接口才是 nil：\nfunc main() { var err error // err 是 nil 接口（类型和值都是 nil） fmt.Println(err == nil) // true var f *os.File = nil // f 是 nil 指针 err = f // 此时 err 的类型是 *os.File，值是 nil fmt.Println(err == nil) // false！（类型非 nil） } 解决办法：避免将 nil 指针直接赋值给接口，或使用类型断言判断具体值是否为 nil。\n2. 值接收者 vs 指针接收者 值接收者实现的接口，值类型和指针类型都能赋值；但指针接收者实现的接口，只有指针类型能赋值：\ntype Fooer interface { Foo() } type Bar struct{} // 值接收者实现接口 func (b Bar) Foo() {} var b Bar var pb *Bar = \u0026amp;b var f Fooer f = b // 合法 f = pb // 合法（指针会自动解引用） // 指针接收者实现接口 func (b *Bar) Foo() {} f = b // 不合法！编译错误 f = pb // 合法 3. 接口转换的限制 只有当类型 T 实现了接口 I 时，才能将 T 转换为 I：\ntype I interface { M() } type T struct{} var t T var i I = t // 编译错误：T 未实现 I.M() 4. 过度使用接口 不要为每个类型都定义接口，只有当需要多态时才使用：\n// 不推荐：不必要的接口 type User struct{} type UserInterface interface { GetID() int } func (u User) GetID() int { return 1 } // 直接使用 User 即可，无需额外定义接口 5. 接口方法集合不匹配 当接口方法与实现方法的签名不完全一致时，会导致实现失败：\ntype I interface { Do(int) error } type T struct{} // 方法签名不匹配（返回值不同） func (t T) Do(n int) string { // 未实现 I 接口 return \u0026#34;done\u0026#34; } 六、正反例对比 正例：灵活的日志系统 // 定义日志接口 type Logger interface { Log(message string) } // 控制台日志实现 type ConsoleLogger struct{} func (c ConsoleLogger) Log(message string) { fmt.Println(\u0026#34;日志：\u0026#34;, message) } // 文件日志实现 type FileLogger struct { filename string } func (f FileLogger) Log(message string) { // 写入文件... } // 业务代码依赖接口 func Process(logger Logger) { logger.Log(\u0026#34;处理开始\u0026#34;) // 业务逻辑... logger.Log(\u0026#34;处理结束\u0026#34;) } // 使用时可灵活切换实现 func main() { Process(ConsoleLogger{}) Process(FileLogger{filename: \u0026#34;app.log\u0026#34;}) } 反例：滥用空接口 // 不推荐：过度使用空接口导致类型不安全 func Calculate(a, b interface{}) interface{} { switch a.(type) { case int: return a.(int) + b.(int) // 若 b 不是 int 会 panic case float64: return a.(float64) + b.(float64) default: return nil } } // 调用时缺乏类型检查 result := Calculate(10, \u0026#34;20\u0026#34;) // panic！ 七、总结 interface 是 Go 语言的灵魂特性之一，它通过隐式实现机制提供了简洁而强大的多态能力。理解其底层实现（eface 和 iface）有助于写出更高效的代码，而掌握最佳实践则能避免常见陷阱。\n核心要点：\n接口定义行为，不关心实现\n小接口更灵活，遵循单一职责\n依赖接口而非具体类型，提高代码可扩展性\n注意 nil 接口和方法接收者的细节\n避免过度使用空接口和不必要的抽象\n合理使用 interface，能让你的 Go 代码更加优雅、灵活和可维护。\n","permalink":"/blogs/2025/go/understanding-go-interfaces-from-source-to-practice.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在 Go 语言中，interface 是实现多态的核心机制，也是 Go 类型系统中最具特色的特性之一。它提供了一种灵活的方式来定义行为，而无需关心具体实现。本文将从底层源码实现出发，全面讲解 interface 的工作原理、使用技巧、最佳实践及常见陷阱。\u003c/p\u003e","title":"Go 语言 interface 详解：从源码到实践"},{"content":"一、从痛点开始：如果没有依赖注入会怎样？ 让我们先看一个反例，了解没有依赖注入时的问题：\n// bad: user_service.go package service import ( \u0026#34;database/sql\u0026#34; _ \u0026#34;github.com/go-sql-driver/mysql\u0026#34; ) type UserService struct{} func (s *UserService) GetUser(id int) (string, error) { db, _ := sql.Open(\u0026#34;mysql\u0026#34;, \u0026#34;root:pwd@tcp(localhost:3306)/test\u0026#34;) // ❌ 在这里创建依赖 defer db.Close() var name string err := db.QueryRow(\u0026#34;SELECT name FROM users WHERE id=?\u0026#34;, id).Scan(\u0026amp;name) return name, err } 这个简单示例暴露了几个致命问题：\n紧耦合：UserService自己知道数据库实现细节，无法替换其他数据库实现 性能差：每次调用都会创建新连接，没有连接复用 无法测试：测试时必须连接真实数据库，无法进行单元测试 违反开闭原则：新增或修改数据源时需要修改服务代码 这就是依赖注入要解决的核心问题：将依赖的创建与使用分离\n二、重构：引入依赖注入 1️⃣ 定义接口（隔离依赖） // domain/user.go package domain type User struct { ID int Name string } type UserRepo interface { GetByID(id int) (*User, error) } 最佳实践：始终面向接口编程，确保依赖项的抽象性和可替换性\n2️⃣ 实现接口（可替换） // infra/mysql_user_repo.go package infra import ( \u0026#34;database/sql\u0026#34; \u0026#34;go-di-example/domain\u0026#34; ) type MySQLUserRepo struct { db *sql.DB } func NewMySQLRepo(db *sql.DB) *MySQLUserRepo { return \u0026amp;MySQLUserRepo{db: db} } func (r *MySQLUserRepo) GetByID(id int) (*domain.User, error) { var u domain.User err := r.db.QueryRow(\u0026#34;SELECT id,name FROM users WHERE id=?\u0026#34;, id).Scan(\u0026amp;u.ID, \u0026amp;u.Name) return \u0026amp;u, err } 3️⃣ 在服务层注入依赖 // service/user_service.go package service import \u0026#34;go-di-example/domain\u0026#34; type UserService struct { repo domain.UserRepo // 依赖接口而非实现 } func NewUserService(repo domain.UserRepo) *UserService { return \u0026amp;UserService{repo: repo} } func (s *UserService) GetUserName(id int) (string, error) { u, err := s.repo.GetByID(id) if err != nil { return \u0026#34;\u0026#34;, err } return u.Name, nil } 构造函数注入是最推荐的方式，因为它明确了依赖关系且易于测试\n4️⃣ 在主函数组装（Composition Root） // main.go package main import ( \u0026#34;database/sql\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;go-di-example/infra\u0026#34; \u0026#34;go-di-example/service\u0026#34; _ \u0026#34;github.com/go-sql-driver/mysql\u0026#34; ) func main() { // 依赖创建集中在入口处 db, err := sql.Open(\u0026#34;mysql\u0026#34;, \u0026#34;root:pwd@tcp(localhost:3306)/test\u0026#34;) if err != nil { panic(err) } defer db.Close() // 依赖注入 repo := infra.NewMySQLRepo(db) userSvc := service.NewUserService(repo) // 注入Repository name, _ := userSvc.GetUserName(1) fmt.Println(\u0026#34;User:\u0026#34;, name) } 架构分层：典型的 Web 项目采用 Handler→Service→Repository→Model 四层架构，各层通过接口解耦\n三、Go 中依赖注入的 3 种原生实现方式 1. 构造函数注入（最常用） 通过构造函数将依赖作为参数传入，确保对象创建时依赖已完备。\nfunc NewUserService(repo UserRepository) *UserService { return \u0026amp;UserService{repo: repo} } 2. 方法注入（Setter method） 通过 Setter 方法动态注入依赖。\nfunc (s *UserService) SetRepository(repo UserRepository) { s.repo = repo } 3. 函数参数注入 将依赖作为函数参数直接传入。\nfunc ProcessUser(repo UserRepository, userID int) (*User, error) { return repo.GetByID(userID) } 4. 属性注入（直接赋值） 直接对结构体的字段赋值进行依赖注入。\nservice := \u0026amp;UserService{} service.Repo = \u0026amp;MySQLUserRepo{} // 手动注入 四、测试中使用 DI（Mock 示例） 依赖注入的最大优势之一：可测试性\n// service/user_service_test.go package service_test import ( \u0026#34;testing\u0026#34; \u0026#34;go-di-example/domain\u0026#34; \u0026#34;go-di-example/service\u0026#34; ) // Mock 实现 type MockUserRepo struct{} func (m *MockUserRepo) GetByID(id int) (*domain.User, error) { return \u0026amp;domain.User{ID: id, Name: \u0026#34;TestUser\u0026#34;}, nil } func TestUserService_GetUserName(t *testing.T) { // 注入 Mock 依赖 repo := \u0026amp;MockUserRepo{} svc := service.NewUserService(repo) name, err := svc.GetUserName(42) if err != nil { t.Fatalf(\u0026#34;unexpected error: %v\u0026#34;, err) } if name != \u0026#34;TestUser\u0026#34; { t.Fatalf(\u0026#34;expected TestUser, got %s\u0026#34;, name) } } 五、当依赖很多时怎么办？（Functional Options 模式） 当依赖较多时，构造函数参数会很长：\n// 传统方式 - 参数过多 svc := NewOrderService(logger, repo, cache, metrics, notifier) 使用 **函数式选项模式（Functional Options）**解决：\ntype OrderService struct { repo UserRepository logger Logger cache Cache } type Option func(*OrderService) func WithLogger(l Logger) Option { return func(s *OrderService) { s.logger = l } } func WithCache(c Cache) Option { return func(s *OrderService) { s.cache = c } } func NewOrderService(repo UserRepository, opts ...Option) *OrderService { s := \u0026amp;OrderService{repo: repo} for _, opt := range opts { opt(s) } return s } // 使用 svc := NewOrderService(repo, WithLogger(log), WithCache(redis)) 这种方式让构造灵活、参数清晰，避免了长参数列表的问题，通常针对的是可选参数。\n六、复杂项目的自动注入工具（Go Wire） 对于大型项目，手动管理依赖关系变得复杂，可以使用 Google Wire自动生成依赖注入代码\n1. 安装 Wire go install github.com/google/wire/cmd/wire@latest 2. 配置依赖关系 // +build wireinject func InitializeUserService() *service.UserService { wire.Build( infra.NewMySQLUserRepo, service.NewUserService, wire.Bind(new(domain.UserRepo), new(*infra.MySQLUserRepo)), ) return nil } 3. 生成代码 运行 wire命令后，生成 wire_gen.go：\n// Code generated by Wire. DO NOT EDIT. func InitializeUserService() *service.UserService { db := infra.NewMySQLUserRepo() userService := service.NewUserService(db) return userService } Wire 的优势\n编译时依赖注入，类型安全 自动处理复杂的依赖关系图 解决循环依赖问题 七、解决循环依赖问题 Go 语言不允许包级别的循环依赖，但通过依赖注入可以优雅解决\n问题场景： UserService 需要 AuditLogger AuditService 需要 UserService 解决方案： // 1. 定义审计接口 package user type Logger interface { LogAction(userID string, action string) } // 2. 用户服务依赖审计接口 package user type UserService struct { auditLogger Logger } // 3. 审计服务通过接口依赖用户服务 package audit type AuditService struct { getUserFunc func(id string) (*user.User, error) // 通过函数抽象 } 使用 Wire 配置双向依赖：\nfunc InitializeServices() (*user.UserService, *audit.AuditService) { wire.Build( user.NewUserService, audit.NewAuditService, wire.Bind(new(audit.Logger), new(*audit.AuditService)), ) return \u0026amp;user.UserService{}, \u0026amp;audit.AuditService{} } 八、错误示例与对比（常见坑） 反例 问题 改进 var DB *sql.DB（全局变量） 隐式依赖，测试困难 显式通过构造函数传入 构造函数中启动 goroutine 难控制生命周期 把启动逻辑放到 Start() 方法 在包 init() 创建资源 无法注入、mock 改为显式 NewXxx() 构造时 panic 程序崩溃难排查 返回 error，让上层处理 注入具体类型 无法替换 注入接口 典型错误示例：\n// ❌ 错误：滥用全局变量 var globalDB *sql.DB func init() { globalDB = NewMySQLDB(\u0026#34;root:123456@tcp(127.0.0.1:3306)/test\u0026#34;) } type UserService struct{} func (s *UserService) GetUser(id int) (string, error) { return globalDB.QueryUser(id) // 测试时无法替换为Mock } 正确做法：\n// ✅ 正确：通过注入替换全局 func main() { db := NewMySQLDB(\u0026#34;root:123456@tcp(127.0.0.1:3306)/test\u0026#34;) userService := NewUserService(db) // 测试时可传MockDB } 九、DDD 中的依赖注入与并发处理 在领域驱动设计（DDD）中，依赖注入结合并发控制可以构建高性能应用\n工作池模式示例： type OrderProcessor struct { workers int jobs chan *Order orderService OrderService // 依赖注入 } func (p *OrderProcessor) Start(ctx context.Context) { wg := \u0026amp;sync.WaitGroup{} for i := 0; i \u0026lt; p.workers; i++ { wg.Add(1) go func() { defer wg.Done() for order := range p.jobs { select { case \u0026lt;-ctx.Done(): return default: p.processOrder(ctx, order) // 并发处理 } } }() } wg.Wait() } 领域事件的并发处理： type EventBus struct { handlers map[string][]EventHandler mutex sync.RWMutex // 保护共享资源 } func (b *EventBus) Publish(ctx context.Context, event Event) { b.mutex.RLock() handlers := b.handlers[event.Type()] b.mutex.RUnlock() wg := \u0026amp;sync.WaitGroup{} for _, handler := range handlers { wg.Add(1) go func(h EventHandler) { defer wg.Done() h(ctx, event) // 并发处理事件 }(handler) } wg.Wait() } 并发最佳实践\n使用 context控制超时和取消 合理使用 goroutine 池避免资源耗尽 使用互斥锁保护共享资源 正确处理 channel 的关闭 十、总结：Go 风格的依赖注入哲学 原则 含义 实践 显式优于隐式 函数签名展示依赖，不藏着掖着 通过构造函数参数明确依赖关系 构造函数管理依赖 谁创建谁负责销毁 在 Composition Root 集中管理生命周期 接口驱动设计 依赖抽象而非实现 定义接口，多种实现可替换 可替换、可测试 模块化开发、单元测试更轻松 依赖接口便于 Mock 测试 最小化依赖 保持组件简单专注 只注入必要的依赖，避免\u0026quot;上帝对象\u0026quot; 避免全局状态 减少副作用 通过注入替代全局变量 十一、选择适合项目的 DI 方式 根据项目复杂度选择合适方案\n项目规模 推荐方案 优势 小型项目 构造函数注入 简单直观，无额外依赖 中型项目 函数式选项 灵活，易于扩展 大型项目 Google Wire 自动化，类型安全，易维护 十二、结语 依赖注入不是\u0026quot;复杂的框架\u0026quot;，而是让 Go 代码更\u0026quot;显式、清晰、可测试\u0026quot;的工程实践。在 Go 世界里，我们不追求魔法容器，而追求结构化的依赖与明确的生命周期。\n核心价值：\n解耦：依赖与使用方分离，避免\u0026quot;牵一发而动全身\u0026quot; 易测试：可轻松替换真实依赖为 Mock 灵活性：切换依赖实现时无需修改使用方代码 可维护性：依赖关系清晰，代码更易于维护和扩展 通过本文的示例和实践指南，您可以在项目中逐步应用依赖注入，构建更加健壮和可维护的 Go 应用程序。\n","permalink":"/blogs/2025/go/go-dependency-injection-in-action-basics-to-advanced-practices.html","summary":"\u003ch2 id=\"一从痛点开始如果没有依赖注入会怎样\"\u003e一、从痛点开始：如果没有依赖注入会怎样？\u003c/h2\u003e\n\u003cp\u003e让我们先看一个反例，了解没有依赖注入时的问题：\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-go\" data-lang=\"go\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e// bad: user_service.go\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003epackage\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eservice\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e (\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;database/sql\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#a6e22e\"\u003e_\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;github.com/go-sql-driver/mysql\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003etype\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eUserService\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estruct\u003c/span\u003e{}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003efunc\u003c/span\u003e (\u003cspan style=\"color:#a6e22e\"\u003es\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e*\u003c/span\u003e\u003cspan style=\"color:#a6e22e\"\u003eUserService\u003c/span\u003e) \u003cspan style=\"color:#a6e22e\"\u003eGetUser\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003eid\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e) (\u003cspan style=\"color:#66d9ef\"\u003estring\u003c/span\u003e, \u003cspan style=\"color:#66d9ef\"\u003eerror\u003c/span\u003e) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#a6e22e\"\u003edb\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003e_\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e:=\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003esql\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eOpen\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;mysql\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;root:pwd@tcp(localhost:3306)/test\u0026#34;\u003c/span\u003e) \u003cspan style=\"color:#75715e\"\u003e// ❌ 在这里创建依赖\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003edefer\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003edb\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eClose\u003c/span\u003e()\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003ename\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estring\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#a6e22e\"\u003eerr\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e:=\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003edb\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eQueryRow\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;SELECT name FROM users WHERE id=?\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003eid\u003c/span\u003e).\u003cspan style=\"color:#a6e22e\"\u003eScan\u003c/span\u003e(\u003cspan style=\"color:#f92672\"\u003e\u0026amp;\u003c/span\u003e\u003cspan style=\"color:#a6e22e\"\u003ename\u003c/span\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003ename\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003eerr\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e这个简单示例暴露了几个致命问题：\u003c/p\u003e","title":"Go 语言依赖注入实战指南：从基础到高级实践"},{"content":"前言 作为刚入门 Go 的开发者，很容易带着其他语言的习惯写代码，比如忽略错误、滥用 goroutine，最后导致程序出 bug 却找不到原因。这篇文章整理了 Go 新手最该掌握的 4 个核心实践，每个点都附完整可运行的代码案例，帮你快速对齐 Go 的编程风格。\n一、命名规范：让代码 “自己说话” Go 的命名不追求复杂，核心是 “简洁 + 明确”，避免冗余前缀（比如strName里的 “str”）或生僻缩写。记住：好的命名能减少一半注释。\n1. 包名：全小写 + 单数，不堆 “工具词” 规则：包名用单个英文单词，全小写，不包含版本（如v1）、类型（如util）或公司名。\n案例：处理用户逻辑的包叫user，操作数据库的包叫db，而非userutil或db_v2。\n引用场景：导入后直接用包名调用函数，清晰无冗余。\nimport \u0026#34;your-project/user\u0026#34; func main() { // 包名+函数名，一眼知道是“用户模块的获取信息” info, err := user.GetInfo(1001) } 2. 变量 / 函数：驼峰命名，首字母控访问权限 变量 / 常量：首字母小写（仅包内可见），不用类型前缀（如intAge→age）。\n函数 / 结构体：首字母大写（对外暴露），首字母小写仅包内可用。\n反例 vs 正例：\n类型 反例（不推荐） 正例（推荐） 原因 变量 var strUserName string var userName string “str” 冗余，类型靠 IDE 判断 函数（对外） func getuserinfo() func GetUserInfo() 首字母小写，外部调不了 结构体 type user struct type User struct 首字母小写，外部无法引用 3. 接口：以 “er” 结尾，突出 “行为” Go 的接口设计偏向 “小而专”，命名通常是 “行为 + er”，比如Reader（读）、Writer（写）。\n// 定义一个“能跑”的接口，仅包含必要方法 type Runner interface { Run() error // 方法名简洁，返回错误（Go风格） } 二、错误处理：别让 “err” 悄悄溜走 Go 没有 try-catch，要求 “显式处理错误”—— 新手最容易犯的错就是用_忽略 err，或只打印不返回。记住：错误必须要么处理，要么传递。\n1. 绝对不忽略 err，哪怕 “觉得不会错” 比如打开文件，哪怕文件就在当前目录，也要检查 err，否则程序会直接 panic。\npackage main import ( \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; ) func main() { // 反例：用_忽略err，文件不存在时直接崩溃 // file, _ := os.Open(\u0026#34;config.json\u0026#34;) // 正例：显式检查err，带上下文日志 file, err := os.Open(\u0026#34;config.json\u0026#34;) if err != nil { // 用log.Printf而非fmt.Println：含时间、文件名、行号，方便定位 log.Printf(\u0026#34;打开配置文件失败[路径:config.json]：%v\u0026#34;, err) return // 错误后终止执行，避免后续操作出错 } defer file.Close() // 资源创建后立刻defer关闭（下文讲） } 2. 自定义错误：带具体上下文，别只返回 “错误” 新手不用封装复杂错误类型，用fmt.Errorf带参数即可，比如 “无效用户 ID：100” 比 “参数错误” 更有用。\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;log\u0026#34; ) // 模拟根据ID获取用户 func GetUserByID(id int) (string, error) { // 错误场景：ID小于0，返回带具体参数的错误 if id \u0026lt;= 0 { return \u0026#34;\u0026#34;, fmt.Errorf(\u0026#34;无效用户ID：%d（必须大于0）\u0026#34;, id) } // 正常场景：返回用户名 return \u0026#34;张三\u0026#34;, nil } func main() { user, err := GetUserByID(-5) if err != nil { log.Printf(\u0026#34;获取用户失败：%v\u0026#34;, err) // 输出：获取用户失败：无效用户ID：-5（必须大于0） return } log.Printf(\u0026#34;获取到用户：%s\u0026#34;, user) } 3. 别返回 “未处理的 nil 错误” 新手可能会在函数里捕获 err，却又返回 nil，导致上层误以为成功。\n// 反例：捕获err后没处理，反而返回nil func doSomething() error { _, err := os.Open(\u0026#34;file.txt\u0026#34;) if err != nil { log.Println(\u0026#34;出错了\u0026#34;) return nil // 错误被“吞了”，上层不知道出错 } return nil } // 正例：要么处理（比如重试），要么传递 func doSomething() error { _, err := os.Open(\u0026#34;file.txt\u0026#34;) if err != nil { log.Printf(\u0026#34;出错了：%v\u0026#34;, err) return err // 把错误传递给上层 } return nil } 三、并发控制：goroutine 不是 “想开就开” Go 的并发很强大，但新手容易因 “随便开 goroutine” 导致两个问题：竞态条件（多个 goroutine 改同一变量）和goroutine 泄漏（开了没关，占资源）。\n1. 共享变量加锁：用sync.Mutex防 “抢数据” 如果多个 goroutine 要修改同一变量（比如计数），必须用sync.Mutex加锁，否则结果会 “乱”。\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;sync\u0026#34; ) var ( count int // 共享变量：计数 mu sync.Mutex // 互斥锁：保护count wg sync.WaitGroup // 等待组：确保所有goroutine执行完 ) // 安全的计数函数：加锁修改 func increment() { mu.Lock() // 加锁：同一时间只有一个goroutine能进 defer mu.Unlock() // 函数结束自动解锁，避免漏写 count++ } func main() { // 开1000个goroutine并发计数 wg.Add(1000) for i := 0; i \u0026lt; 1000; i++ { go func() { defer wg.Done() // 每个goroutine执行完标记 increment() }() } wg.Wait() // 等待所有goroutine结束 fmt.Println(\u0026#34;最终计数：\u0026#34;, count) // 正确输出1000，无竞态 } 2. 通信优先：用 channel 代替 “共享内存” Go 的哲学是 “不要通过共享内存来通信，要通过通信来共享内存”。channel 比锁更简洁，适合传递数据。\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;sync\u0026#34; ) func main() { // 带缓冲channel：避免生产者和消费者互相等 ch := make(chan int, 5) var wg sync.WaitGroup // 生产者：发数据到channel wg.Add(1) go func() { defer wg.Done() for i := 1; i \u0026lt;= 3; i++ { ch \u0026lt;- i // 发送数据 fmt.Printf(\u0026#34;生产：%d\\n\u0026#34;, i) } close(ch) // 生产完必须关channel，否则消费者会阻塞 }() // 消费者：从channel拿数据 wg.Add(1) go func() { defer wg.Done() // 遍历channel：直到channel关闭 for num := range ch { fmt.Printf(\u0026#34;消费：%d\\n\u0026#34;, num) } }() wg.Wait() } // 输出（顺序可能不同，但无竞态）： // 生产：1 // 消费：1 // 生产：2 // 消费：2 // 生产：3 // 消费：3 3. 避免 goroutine 泄漏：用 context 取消 “多余任务” 如果开了 goroutine，但没让它退出（比如任务取消了，但 goroutine 还在等数据），就会导致泄漏。用context.Context可以优雅取消。\npackage main import ( \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;time\u0026#34; ) // 模拟一个耗时任务：5秒后返回结果 func longTask(ctx context.Context) { for { select { // 监听“取消信号” case \u0026lt;-ctx.Done(): fmt.Println(\u0026#34;任务被取消，退出goroutine\u0026#34;) return // 模拟任务执行 case \u0026lt;-time.After(1 * time.Second): fmt.Println(\u0026#34;任务执行中...\u0026#34;) } } } func main() { // 创建带取消功能的context ctx, cancel := context.WithCancel(context.Background()) defer cancel() // 主函数结束前取消，避免泄漏 // 开goroutine执行任务 go longTask(ctx) // 主函数等待2秒后，主动取消任务 time.Sleep(2 * time.Second) cancel() // 发送取消信号 // 等goroutine退出（实际项目可用wg） time.Sleep(1 * time.Second) fmt.Println(\u0026#34;主程序结束\u0026#34;) } // 输出： // 任务执行中... // 任务执行中... // 任务被取消，退出goroutine // 主程序结束 四、资源管理：defer 是 “自动清洁工” 新手常忘记关闭文件、数据库连接等资源，导致资源泄漏。defer能确保 “资源创建后，无论函数是否报错，都会自动释放”—— 但要注意使用时机。\n1. defer 必须紧跟资源创建（在 err 检查后） 如果资源创建失败（比如文件不存在），defer会导致 nil 指针调用 panic，所以一定要先检查 err。\npackage main import ( \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; ) func main() { // 反例：defer在err前，文件打开失败时file是nil，Close()会panic // defer file.Close() // file, err := os.Open(\u0026#34;data.txt\u0026#34;) // 正例：先检查err，确认资源创建成功再defer file, err := os.Open(\u0026#34;data.txt\u0026#34;) if err != nil { log.Printf(\u0026#34;打开文件失败：%v\u0026#34;, err) return } // 资源创建成功，立刻注册defer关闭 defer func() { if err := file.Close(); err != nil { log.Printf(\u0026#34;关闭文件失败：%v\u0026#34;, err) } }() // 后续操作文件... log.Println(\u0026#34;文件操作完成\u0026#34;) } 2. 别在循环里用 defer（除非必要） 循环里的 defer 会延迟到循环结束后执行，比如循环打开 100 个文件，defer 会积累 100 个 “关闭操作”，直到循环结束才执行，导致资源堆积。\n// 反例：循环里用defer，100个文件同时打开，直到循环结束才关闭 for i := 0; i \u0026lt; 100; i++ { file, err := os.Open(fmt.Sprintf(\u0026#34;file_%d.txt\u0026#34;, i)) if err != nil { return err } defer file.Close() // 错误：100个defer堆积 // 处理文件... } // 正例：用函数包裹，每次循环结束就关闭文件 for i := 0; i \u0026lt; 100; i++ { if err := handleFile(i); err != nil { return err } } func handleFile(i int) error { file, err := os.Open(fmt.Sprintf(\u0026#34;file_%d.txt\u0026#34;, i)) if err != nil { return err } defer file.Close() // 函数结束就关闭，无堆积 // 处理文件... return nil } 3. 数据库连接也用 defer 关闭 除了文件，数据库连接、网络连接等资源也需要 defer 关闭，比如用database/sql包操作 MySQL：\npackage main import ( \u0026#34;database/sql\u0026#34; \u0026#34;log\u0026#34; _ \u0026#34;github.com/go-sql-driver/mysql\u0026#34; // MySQL驱动（需先安装：go get ...） ) func main() { // 连接数据库 db, err := sql.Open(\u0026#34;mysql\u0026#34;, \u0026#34;user:password@tcp(127.0.0.1:3306)/dbname\u0026#34;) if err != nil { log.Printf(\u0026#34;连接数据库失败：%v\u0026#34;, err) return } // 延迟关闭数据库连接 defer func() { if err := db.Close(); err != nil { log.Printf(\u0026#34;关闭数据库失败：%v\u0026#34;, err) } }() // 测试连接（sql.Open不实际连接，需Ping()） if err := db.Ping(); err != nil { log.Printf(\u0026#34;数据库Ping失败：%v\u0026#34;, err) return } log.Println(\u0026#34;数据库连接成功\u0026#34;) } 总结：新手记住这 4 个核心 命名：包名短、变量无冗余、接口带 “er”； 错误：不忽略、不吞 err，自定义错误带上下文； 并发：共享变量加锁，优先用 channel，用 context 防泄漏； 资源：defer 紧跟资源创建，别在循环里用 defer。 这些实践不是 “教条”，而是 Go 社区多年积累的经验 —— 刚开始可能觉得麻烦，但养成习惯后，你写的代码会更稳定、更易维护。\n","permalink":"/blogs/2025/go/go-basics-4-must-learn-practices.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e作为刚入门 Go 的开发者，很容易带着其他语言的习惯写代码，比如忽略错误、滥用 goroutine，最后导致程序出 bug 却找不到原因。这篇文章整理了 Go 新手最该掌握的 4 个核心实践，每个点都附完整可运行的代码案例，帮你快速对齐 Go 的编程风格。\u003c/p\u003e","title":"Go 新手干货：4 个核心实践，让你的代码符合社区规范"},{"content":" 作者：Hyman Zhang\n开源代码：nsqd-producer-pool\n背景 在分布式系统中，消息系统常作为异步解耦与削峰的核心基础设施。NSQ 是一套轻量、易部署的消息队列组件，nsqd 负责实际接收与维护消息队列，而生产者（Producer）负责向某个 nsqd 发布消息。官方 go 客户端实现说明：一个 Producer 实例是与单个 nsqd 一一对应，并且会在 Publish 时懒连接/重连。\n生产者与 nsqd 的关系使得单一 producer 对应的 nsqd 宕机会直接影响消息发送可用性。NSQ 的生产环境部署建议（比如把 nsqd 与 producer 服务同机或近邻部署）可以降低网络抖动风险，但并不能消除节点故障带来的可用性问题。\n因此，我们希望把“对外发布”的逻辑封装成一个高可用的 Producer 池（ProducerPool）：\n能够在一个 nsqd 挂掉时自动切换到其他健康节点（fallback）。 在短期故障中做并发安全的重连尝试并使用指数退避+jitter避免雪崩。 将失败率、重连频率等元信息暴露出来，便于监控和告警。 （NSQ 官方的客户端设计文档也强调：客户端库需要承担比单纯的 HTTP 发布更多的责任以保证整体健壮性。）\n要解决的问题 自动故障切换（Failover）：当当前活跃的 nsqd 无法发布时，自动尝试池中其他健康的 nsqd，并在成功后提升为活跃节点。 并发安全：多 goroutine 并发 Publish、后台健康检查与并发重连不应引发竞态或 panic。 有节制的重连（throttling）：重连尝试不能无限制并发、不能频繁触发导致对端被打爆或造成资源争用。 稳健的重试策略：对 transient error 使用指数退避 + jitter；重试次数和上限可配置。 优先级/偏好控制：支持为不同 nsqd 设定优先级（比如数据中心/机房优先），初始化时选择优先健康节点。 可观测性：能获取当前活跃 producer、健康节点列表、最后错误等，方便报警与追踪。 核心设计与实现 NSQ 客户端（生产者/消费者）启动后可以先向 nsqlookupd 查询可用的 nsqd 节点，然后与这些节点建立长连接进行消息发布或消费。我们的 ProducerPool 设计中，生产者可直接配置多个 nsqd 地址，绕过 lookupd 而由客户端自己管理节点列表。当需要发布消息时，ProducerPool 会使用当前活跃的节点连接进行发送，如失败则按照降级策略尝试其他节点。\nProducerWrapper：封装单个 Producer 实例及其元数据。包含配置（地址和优先级）、Producer 对象本身（用 atomic.Pointer 原子存取）、健康状态（atomic.Bool）、最近一次错误和重连时间戳（atomic.Value）。构造时会尝试与节点 Ping，成功则标记健康，否则记录错误。 ProducerPool：持有多个 ProducerWrapper，并按照配置的优先级排序，优先使用优先级高的可用节点作为活跃发布者。内部维护一个原子指针 activeProd 指向当前活跃的 ProducerWrapper。初始化时创建所有包装器（节点失败也保留空占位以保持顺序），若至少有一个健康则立即选定优先的一个作为活跃节点，否则发出告警。 原生 Producer：底层依赖的 nsqd 客户端，封装层不侵入其核心逻辑，仅通过工厂方法创建。 健康检查循环：后台定时执行 healthLoop，遍历所有 ProducerWrapper。对健康标记为 false 的节点，若自上次重连尝试已经过去足够时间，则发起并发重连（受信号量 reconnectSem 限制最多同时进行 MaxConcurrentConns 次）。重连过程使用专门的 Goroutine，调用工厂函数创建新 Producer 并 Ping 验证：成功后通过 atomic.Swap 交换到 ProducerWrapper 中，并延迟关闭旧实例。完成重连后异步触发一次切换检查，选出新的优先健康节点作为 activeProd。 发布逻辑（Publish/DeferredPublish）：调用 ProducerPool.Publish 时，首先从 activeProd 获取当前 Producer。若调用 Publish 返回错误，则将该节点标记为不健康并记录错误，接着遍历其他 ProducerWrapper 中任意健康节点尝试发布，成功后将该节点升级为活跃（activeProd.Store），否则继续使用指数退避加抖动后重试。退避策略参考 AWS 推荐模式：指数递增并限定上限，同时引入随机延迟以防群体重试瞬时冲击。如果超过最大重试次数依然失败，则返回错误 ErrNoHealthyProducer。 并发安全：所有共享状态更新均使用原子操作保证线程安全。例如，对当前活跃生产者的切换是通过 atomic.Pointer 实现无锁替换。信号量（缓冲通道）用于控制最大重连并发度。ProducerPool 内还对 panic 进行了统一恢复处理，以避免程序异常中断。 总体流程简述如下：每隔指定间隔执行健康检查，对不可用的生产者并发重连；每次发布消息时优先使用当前活跃节点，失败后自动寻找并升级备用节点；切换操作通过原子指针无锁完成，确保多协程环境下的安全性和实时性。\n关键技术细节与并发控制 原子操作 vs. 锁：本方案中大量使用 sync/atomic 原子操作来替代互斥锁，以减少锁开销并防止死锁。例如，将 Producer 对象封装在 atomic.Pointer 中，实现无锁读写和替换；健康状态和错误日志使用 atomic.Bool/atomic.Value 保证并发读写的一致性。原子操作高效但只保证单个操作的原子性，如果需要跨多个字段的原子事务则应慎重。在本设计中，我们每次只对单个字段做原子存取，因此无需额外加锁。 信号量（Semaphore）：重连操作可能并发执行，为防止同时重连过多导致资源争用，我们使用了带缓冲区的通道作为信号量。例如：make(chan struct{}, MaxConcurrentConns) 限制了同时进行的最大重连数。具体做法是，每启动一个重连 Goroutine 前发送一个占位到信号量通道（如满则阻塞），完成后再从通道取出一个，占位释放。这样可以有序控制高并发场景下的重连节奏。 指数退避加抖动：当发布失败后需要重试，采用指数退避机制避免过快重试累积负载。具体实现中根据尝试次数按指数增长延迟，并引入随机抖动（jitter）使每次重试时间略有差异。这样可以防止大量线程同步重试而产生峰值流量。代码中的 backoffWithJitter 函数即根据当前重试次数计算延迟时间（最高限于 maxBackoff），并在 backoff/2 的基础上加上 [0,backoff/2] 的随机偏移。 故障平滑切换：在一个 ProducerWrapper 重连成功后，不会立即触发切换，而是延迟 100 毫秒再执行 switchActiveProducer。这样可以避免在极短时间内频繁切换，造成上层 Publish 抖动。原子交换后，旧的 Producer 会被延迟关闭（0.5 秒后调用 Stop()），确保当前仍可能有 goroutine 使用旧连接发送消息时不致中断。 安全退出：调用 Stop() 时，首先设置停止标志并关闭通道，等待健康检查等后台协程结束。然后遍历所有封装实例，依次调用底层生产者的 Stop()，确保关闭所有资源。这样的顺序可以防止在关闭时还有并发发送操作未完成。 注意事项 原子操作粒度：使用 sync/atomic 能大幅提升并发性能，但要注意它只保证单个操作的原子性。如果有多个相关字段需要同时更新，就需要额外的同步机制或设计模式。 重连节奏控制：重连时最好设置超时（ReconnectTimeout），避免某节点长时间不可达导致重连协程挂起。同时，通过信号量限制并发数量，避免短时间内产生大量阻塞连接。 抖动与重试上限：指数退避的最大上限可避免等待时间过长，同时添加随机抖动以防止群体行为同步重试。根据业务对可靠性的需求，RetryCount 不能无限大，防止系统长时间卡在重试循环中。 异常恢复：整个池的内部对 panic 进行了 recover 处理，不让异常导致整个程序崩溃。额外地，对延迟关闭也加了 recover。上层业务可根据需要捕获错误，但不必担心此封装抛出未处理的 panic。 资源清理：Producer.Stop() 应幂等且相对轻量，确保在替换时旧连接可以安全关闭。延迟关闭策略虽可防止瞬时冲击，但也要避免长时间挂起，代码中用 0.5 秒延时后执行 Stop()。 使用示例 // 假设使用官方 go-nsq 作为 ProducerFactory： factory := func(addr string) (Producer, error) { return nsq.NewProducer(addr, nsq.NewConfig()) } // 配置多个 nsqd 地址和优先级（数字越大优先级越高） configs := []ProducerConfig{ {Addr: \u0026#34;127.0.0.1:4150\u0026#34;, Priority: 2}, {Addr: \u0026#34;127.0.0.1:4151\u0026#34;, Priority: 1}, } opts := Options{ RetryCount: 5, RetryBackoff: time.Second, HealthInterval: 5 * time.Second, ReconnectTimeout: 2 * time.Second, MaxConcurrentConns: 2, Logger: zap.L(), } pool, err := NewProducerPool(configs, opts, factory) if err != nil { panic(err) } defer pool.Stop() // 发布消息（自动高可用切换） err = pool.Publish(\u0026#34;topic_name\u0026#34;, []byte(\u0026#34;hello world\u0026#34;)) if err != nil { fmt.Println(\u0026#34;Publish 失败：\u0026#34;, err) } else { fmt.Println(\u0026#34;消息发布成功\u0026#34;) } 上例中，我们通过 NewProducerPool 传入了多个 nsqd 地址与配置，并使用 pool.Publish 发送消息。框架会自动选择当前优先的健康节点发送，如遇错误则切换并重试，业务代码无需感知其内部复杂性。\n图2：NSQ 客户端查找流程示意 – 上图展示了客户端（生产者）向 nsqlookupd 查询可写节点并与 nsqd 建立连接的流程。在本方案中，生产者可直接配置 nsqd 地址列表，无需依赖查找服务，但其核心思想与图中所示类似：客户端获知可用节点并保持连接，以实现消息可靠投递。\n总结 通过上述设计，我们实现了一个支持多 nsqd 自动切换的高可用生产者封装。它为应用层屏蔽了节点管理的复杂性，提供透明的 Failover 能力。当一个节点挂掉时，系统会自动切换到其他健康节点继续发送，从而保证了消息发布的持续可用性。同时，基于原子操作和并发控制的实现保证了整个过程在高并发环境下的安全性与稳定性。通过合理的重试与退避机制，还能有效减轻故障时的冲击流量。对于需要高可靠消息传递的服务，这种封装方案极大地增强了生产者端的健壮性，是分布式系统设计中重要的一环。\n开源项目地址：https://github.com/itart-top/nsqd-producer-pool\n","permalink":"/blogs/2025/ha/nsqd-producer-auto-failover.html","summary":"\u003cblockquote\u003e\n\u003cp\u003e作者：Hyman Zhang\u003cbr\u003e\n开源代码：\u003ca href=\"https://github.com/itart-top/nsqd-producer-pool/tree/main\"\u003ensqd-producer-pool\u003c/a\u003e\u003c/p\u003e\n\u003c/blockquote\u003e\n\u003chr\u003e\n\u003ch1 id=\"背景\"\u003e背景\u003c/h1\u003e\n\u003cp\u003e在分布式系统中，消息系统常作为异步解耦与削峰的核心基础设施。NSQ 是一套轻量、易部署的消息队列组件，\u003ccode\u003ensqd\u003c/code\u003e 负责实际接收与维护消息队列，而生产者（Producer）负责向某个 \u003ccode\u003ensqd\u003c/code\u003e 发布消息。官方 go 客户端实现说明：一个 Producer 实例\u003cstrong\u003e是与单个 nsqd 一一对应\u003c/strong\u003e，并且会在 Publish 时懒连接/重连。\u003c/p\u003e","title":"nsqd Producer 高可用封装实践：从单点故障到自动故障转移"},{"content":"摘要 本文给出一个落地可执行的 Go + DDD 代码组织方案。包含：分层含义、推荐目录树、包命名与文件命名规范、典型代码片段（领域实体、仓储接口、应用服务、适配器/实现）、防坑注意项与代码风格建议。侧重 最小侵入、依赖倒置、包循环避免 与 Go 风格（gofmt、小写包名、单一职责、内建 internal 与 pkg 约束）。\n1. 基本原则（与 Go 的契合点） 领域优先、基础设施靠后：领域模型（domain）不依赖任何数据库、Web、框架或第三方库。 依赖倒置：高层（application / adapters）依赖领域接口（domain interfaces），具体实现注入到运行时。 包的最小化与单一职责：一个包只聚焦一组职责（例如 order 聚合、user 聚合），避免出现“god package”。 使用 internal 隔离实现细节：对外暴露只放在 pkg 或根导出包，其他实现放 internal。 避免循环依赖：通过接口与构造函数解耦，或把共享类型放到 pkg（谨慎）或 shared（尽量少用）。 2. 推荐目录结构（示例） myapp/ ├── cmd/ │ └── myapp/ # 程序入口（main.go）——可多个 cmd │ └── main.go ├── configs/ # 配置文件、模板 ├── internal/ │ ├── domain/ # 领域层（只含接口、实体、领域服务、事件） │ │ ├── user/ │ │ │ ├── entity.go │ │ │ ├── value_objects.go │ │ │ └── repository.go # 仓储接口 │ │ └── order/ │ │ └── ... │ ├── application/ # 应用层（用例/事务协调、DTO、服务） │ │ └── usercase/ │ │ ├── service.go │ │ └── dto.go │ ├── adapter/ # 适配器（输入/输出）实现 │ │ ├── http/ │ │ │ └── user_handler.go │ │ └── grpc/ │ └── infra/ # 基础设施（DB、缓存、邮件、外部系统） │ ├── db/ │ │ └── postgres_user_repo.go │ └── logger/ ├── api/ # OpenAPI/Protos/接口定义 ├── pkg/ # 可以被外部项目复用的包（小心使用） ├── scripts/ ├── deployments/ └── go.mod 说明：\n把业务代码放 internal，确保不会被外部 import（增强封装）。 domain 只包含领域概念与仓储接口，不包含任何 ORM 或 HTTP 相关内容。 adapter 或 infra 放置实现（仓储实现、HTTP handler、消息总线消费者等）。 3. 包命名与文件命名规范 包名：短小、单数、小写（例如 user, order, payment），不要下划线或驼峰。 避免使用 domain 下的通用包名（如 models、common）—这些通常招致职责不清。 文件名：按职责细分（entity.go, repository.go, service.go, handler_http.go），避免单文件过大。 类型命名：导出类型使用大写（User, Order）；非导出使用小写。 接口命名：接口名建议用行为后缀（UserRepository, PaymentGateway），而不是 IUser 风格。 变量/函数命名：驼峰小写，导出函数首字母大写。 4. 领域层（internal/domain/...） 特点：纯净、无依赖实现细节。\n示例：internal/domain/user/entity.go\npackage user import \u0026#34;time\u0026#34; // User 是聚合根 type User struct { ID string Email string Password string // 哈希 CreatedAt time.Time } func NewUser(id, email, passwordHash string) *User { return \u0026amp;User{ID: id, Email: email, Password: passwordHash, CreatedAt: time.Now()} } func (u *User) ChangeEmail(new string) { // 领域验证/不变式在此处实现 u.Email = new } 示例：internal/domain/user/repository.go\npackage user // UserRepository 定义了持久化契约（接口） type UserRepository interface { Save(u *User) error FindByID(id string) (*User, error) FindByEmail(email string) (*User, error) } 说明：领域层定义契约（接口），但不包含实现。实现应在 internal/infra 或 internal/adapter/persistence。\n5. 应用层（internal/application/...） 职责：编排应用用例、组织事务、调用领域接口、转换 DTO。\n示例：internal/application/usercase/service.go\npackage usercase import ( \u0026#34;errors\u0026#34; \u0026#34;myapp/internal/domain/user\u0026#34; ) type UserService struct { repo user.UserRepository } func NewUserService(r user.UserRepository) *UserService { return \u0026amp;UserService{repo: r} } func (s *UserService) Register(email, passwordHash string) (*user.User, error) { // 1. 领域规则校验（可调用领域服务） if existing, _ := s.repo.FindByEmail(email); existing != nil { return nil, errors.New(\u0026#34;email exists\u0026#34;) } u := user.NewUser(generateID(), email, passwordHash) if err := s.repo.Save(u); err != nil { return nil, err } return u, nil } 注意：应用层可以处理事务边界（例如开始/提交 DB 事务），但应保持尽可能薄。\n6. 适配器/基础设施层（internal/adapter, internal/infra） 职责：把领域接口连接到具体技术实现（ORM、HTTP、消息队列）。\n示例：internal/infra/db/postgres_user_repo.go\npackage db import ( \u0026#34;database/sql\u0026#34; \u0026#34;myapp/internal/domain/user\u0026#34; ) type PostgresUserRepo struct { db *sql.DB } func NewPostgresUserRepo(db *sql.DB) *PostgresUserRepo { return \u0026amp;PostgresUserRepo{db: db} } func (r *PostgresUserRepo) Save(u *user.User) error { // SQL 操作 return nil } func (r *PostgresUserRepo) FindByID(id string) (*user.User, error) { return nil, nil } func (r *PostgresUserRepo) FindByEmail(email string) (*user.User, error) { return nil, nil } 在 cmd/myapp/main.go 中构建依赖关系并注入：\nfunc main() { db := mustOpenDB() userRepo := db.NewPostgresUserRepo(dbConn) userSvc := usercase.NewUserService(userRepo) // wire up http handlers with userSvc } 7. 关于包名 user.User 的讨论 你可能注意到：在 Go 里 user.User（包名 + 类型名）经常出现。这是正常且符合惯例的。它能清晰表达：类型 User 属于 user 包。但要注意：\n若觉得冗余，可以在导入时起别名：u \u0026quot;myapp/internal/domain/user\u0026quot;，使用 u.User。 不推荐把包也命名为 models、entities 之类通用名，这会降低可读性。 建议按 聚合（aggregate）建包：domain/user、domain/order，更契合 DDD。 8. 事务与一致性边界 短事务：在应用层开启并提交（例如在 service 方法内），把事务对象通过仓储实现传递。 跨聚合事务：优先用最终一致性（事件/消息）而不是分布式事务（两阶段），除非必须。 样例：在 application 层开始事务：\n// pseudo func (s *Service) DoSomething(...) error { tx := db.Begin() defer func() { if err != nil { tx.Rollback() } else { tx.Commit() } }() // repo 使用 tx 实现 } 9. 测试建议 领域单测：只针对 internal/domain/* 的行为和不变式编写单元测试（无需 DB）。 集成测试：把 infra 的实现替换为 test doubles 或使用测试 DB（docker-compose/testcontainers）。 端到端测试：在 CI 中用真实依赖（容器化 DB / MQ）跑 e2e 测试。 10. 常见反模式与注意事项 把 ORM 代码放进 domain：违反依赖倒置。领域应该只关心接口。 大而全的 models 包：职责模糊，容易形成循环依赖。 全局状态/单例数据库变量：不利于测试与并发。 大量使用 pkg/shared：导致隐性耦合，优先用明确的接口注入。 忽略错误包装：在边界处用 errors.Wrap 或 %w 链接错误上下文，便于排查。 11. 代码风格 \u0026amp; 工具链建议 gofmt / goimports / golangci-lint（开启 govet,staticcheck）。 采用 go test ./... 在 CI 中持续运行。使用 -race 在集成测试中检查竞态。 依赖管理用 go mod，避免把 vendor 弹性化管理滥用。 12. 实战示例（完整包关系小结） internal/domain/user：实体、值对象、仓储接口、领域服务。 internal/application/usercase：应用服务、DTO、用例编排。 internal/infra/db：Postgres/MySQL 的仓储实现。 internal/adapter/http：HTTP 层（处理 request -\u0026gt; DTO -\u0026gt; 调用 application service），返回标准化错误/响应。 这样可以保证：领域不依赖 infra；infra 依赖 domain；application 把 domain 与 infra 组装起来。\n13. 最后一张清单（落地前检查） 领域层：无任何第三方依赖。 仓储接口放领域，具体实现放 infra/adapter。 使用 internal 隔离实现，暴露可复用组件放 pkg。 包名小写、单数、职责单一。 主函数（cmd/）负责依赖注入与启动。 CI 覆盖 gofmt, golangci-lint, go test。 结语 把 DDD 的思路带入 Go 项目不是为了机械搬运概念，而是把“边界明确、职责单一、可测试、易演进”的工程实践落地。用 internal、短小清晰的包名、接口注入与慎用共享包，就能既保留 Go 的简洁，又实现领域驱动的长期可维护性。\n","permalink":"/blogs/2025/go/go-ddd-in-action-layout-naming-best-practices.html","summary":"\u003ch2 id=\"摘要\"\u003e摘要\u003c/h2\u003e\n\u003cp\u003e本文给出一个落地可执行的 Go + DDD 代码组织方案。包含：分层含义、推荐目录树、包命名与文件命名规范、典型代码片段（领域实体、仓储接口、应用服务、适配器/实现）、防坑注意项与代码风格建议。侧重 \u003cstrong\u003e最小侵入、依赖倒置、包循环避免\u003c/strong\u003e 与 \u003cstrong\u003eGo 风格\u003c/strong\u003e（\u003ccode\u003egofmt\u003c/code\u003e、小写包名、单一职责、内建 \u003ccode\u003einternal\u003c/code\u003e 与 \u003ccode\u003epkg\u003c/code\u003e 约束）。\u003c/p\u003e","title":"在 Go 中用 DDD 风格组织代码：实践、目录与命名规范（可落地）"},{"content":"在 Go 语言开发中，错误处理是保障程序健壮性的核心环节。与 Java、Python 等语言的 “异常捕获” 机制不同，Go 采用显式错误处理设计，强调 “错误是值” 的理念。本文将从 Error 的底层原理出发，拆解最佳工程实践、扩展技巧与封装方案，并对比常见错误姿势，帮你写出更优雅、可维护的 Go 代码。\n一、Go Error 核心原理：从接口到错误链 要做好错误处理，首先得理解 Go Error 的本质 —— 它不是复杂的类结构，而是一个简单的接口。\n1.1 Error 接口的本质 Go 标准库中，error是预定义的接口类型，仅包含一个Error()方法：\n// src/builtin/builtin.go type error interface { Error() string // 返回错误描述 } 任何实现了Error() string方法的类型，都可以作为 “错误值” 使用。这种设计的灵活性在于：你可以自定义错误类型，携带更多上下文（如错误码、堆栈、业务信息），而非仅传递字符串描述。\n1.2 内置 Error 实现：简单场景够用 Go 标准库提供了两种基础错误创建方式，满足简单场景需求：\n（1）errors.New()：创建基础错误 errors.New返回一个*errorString类型（私有结构体），仅存储错误描述字符串：\npackage main import ( \u0026#34;errors\u0026#34; \u0026#34;fmt\u0026#34; ) func divide(a, b int) (int, error) { if b == 0 { // 创建基础错误：仅包含字符串描述 return 0, errors.New(\u0026#34;除数不能为0\u0026#34;) } return a / b, nil } func main() { res, err := divide(10, 0) if err != nil { fmt.Println(\u0026#34;错误：\u0026#34;, err) // 输出：错误：除数不能为0 return } fmt.Println(\u0026#34;结果：\u0026#34;, res) } （2）fmt.Errorf()：带格式化描述的错误 fmt.Errorf支持格式化字符串，方便添加上下文信息（如参数值、操作步骤）：\nfunc readFile(path string) error { _, err := os.Open(path) if err != nil { // 格式化错误描述，添加“文件路径”上下文 return fmt.Errorf(\u0026#34;读取文件[%s]失败：%v\u0026#34;, path, err) } return nil } 1.3 错误链与 Go 1.13+ 新特性 Go 1.13 之前，错误处理的痛点是 “无法追溯错误根源”—— 当错误经过多层传递后，原始错误信息可能被覆盖。为此，Go 1.13 引入了错误链（Error Chaining） 机制，通过两个关键特性实现：\n（1）%w 动词：包装错误，构建错误链 用fmt.Errorf(\u0026quot;%w\u0026quot;, err)可以将原始错误err包装为新错误，形成 “外层错误→内层错误” 的链条：\n// 第一层：原始错误 baseErr := errors.New(\u0026#34;文件不存在\u0026#34;) // 第二层：包装原始错误，添加上下文 layer1Err := fmt.Errorf(\u0026#34;打开配置文件失败：%w\u0026#34;, baseErr) // 第三层：继续包装，添加更多上下文 layer2Err := fmt.Errorf(\u0026#34;初始化服务失败：%w\u0026#34;, layer1Err) （2）errors.Is() 与 errors.As()：解析错误链 errors.Is(err, target error)：判断err所在的错误链中，是否包含target错误（适合基础错误匹配）；\nerrors.As(err, target interface{})：判断err所在的错误链中，是否包含target类型的错误，并将其赋值给target（适合自定义错误类型匹配）。\n示例：\npackage main import ( \u0026#34;errors\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;os\u0026#34; ) func main() { err := initService(\u0026#34;config.yaml\u0026#34;) if err != nil { // 1. 用 errors.Is 判断错误链中是否包含“文件不存在”错误 if errors.Is(err, os.ErrNotExist) { fmt.Println(\u0026#34;处理文件不存在的逻辑：创建默认配置文件\u0026#34;) return } // 2. 用 errors.As 提取自定义错误（假设 CustomErr 是自定义类型） var customErr *CustomErr if errors.As(err, \u0026amp;customErr) { fmt.Printf(\u0026#34;处理自定义错误：错误码[%d]，描述[%s]n\u0026#34;, customErr.Code, customErr.Msg) return } fmt.Println(\u0026#34;未知错误：\u0026#34;, err) } } // 自定义错误类型：携带错误码和描述 type CustomErr struct { Code int Msg string } // 实现 Error() 方法，满足 error 接口 func (e *CustomErr) Error() string { return fmt.Sprintf(\u0026#34;Code:%d, Msg:%s\u0026#34;, e.Code, e.Msg) } func initService(path string) error { err := readConfig(path) if err != nil { return fmt.Errorf(\u0026#34;初始化服务失败：%w\u0026#34;, err) } return nil } func readConfig(path string) error { _, err := os.Open(path) if err != nil { // 包装系统错误 os.ErrNotExist return fmt.Errorf(\u0026#34;读取配置文件[%s]失败：%w\u0026#34;, path, err) } // 模拟自定义错误场景 if path == \u0026#34;invalid.yaml\u0026#34; { return fmt.Errorf(\u0026#34;解析配置失败：%w\u0026#34;, \u0026amp;CustomErr{Code: 1001, Msg: \u0026#34;格式错误\u0026#34;}) } return nil } 二、Go Error 最佳工程实践：避坑指南 掌握原理后，更重要的是遵循工程实践 —— 错误处理不仅是 “捕获错误”，更是 “让错误可排查、可恢复、可维护”。以下是 6 条核心实践：\n1. 绝不忽略错误（Don\u0026rsquo;t Ignore Errors） 最常见的错误姿势是用_忽略错误返回值，这会导致问题隐藏，后期难以排查：\n// 错误示例：忽略 os.Open 的错误 file, _ := os.Open(\u0026#34;config.yaml\u0026#34;) // 风险：若文件不存在，后续操作（如 file.Read）会 panic // 正确示例：显式检查并处理错误 file, err := os.Open(\u0026#34;config.yaml\u0026#34;) if err != nil { // 至少记录日志，方便排查 log.Printf(\u0026#34;打开文件失败：%v\u0026#34;, err) return err // 或根据场景返回默认值、终止程序 } defer file.Close() // 确保文件关闭（即使后续出错） 2. 错误需携带上下文，避免 “裸返回” 直接返回原始错误（如return err）会丢失上下文，导致无法定位错误发生的具体场景（如 “哪个文件”“哪个参数”）：\n// 错误示例：裸返回原始错误，无上下文 func readConfig(path string) error { _, err := os.Open(path) if err != nil { return err // 仅返回“文件不存在”，不知道是哪个文件 } return nil } // 正确示例：用 %w 包装，添加上下文 func readConfig(path string) error { _, err := os.Open(path) if err != nil { // 包含“文件路径”上下文，错误链可追溯 return fmt.Errorf(\u0026#34;read config file [%s] failed: %w\u0026#34;, path, err) } return nil } 3. 区分 “可重试错误” 与 “不可重试错误” 部分错误（如网络超时、临时资源不可用）可以通过重试恢复，而有些错误（如参数错误、文件不存在）重试无效。建议通过接口定义 “可重试性”：\n// 定义可重试错误接口 type RetryableError interface { error IsRetryable() bool // 判断是否可重试 } // 自定义网络错误，实现 RetryableError 接口 type NetworkErr struct { Msg string } func (e *NetworkErr) Error() string { return e.Msg } // 网络超时错误可重试 func (e *NetworkErr) IsRetryable() bool { return strings.Contains(e.Msg, \u0026#34;timeout\u0026#34;) } // 使用场景：根据错误类型决定是否重试 func callAPI(url string) error { // 模拟网络超时错误 return \u0026amp;NetworkErr{Msg: \u0026#34;request timeout\u0026#34;} } func main() { err := callAPI(\u0026#34;https://example.com/api\u0026#34;) if err != nil { // 判断错误是否可重试 if re, ok := err.(RetryableError); ok \u0026amp;\u0026amp; re.IsRetryable() { fmt.Println(\u0026#34;进行重试...\u0026#34;) // 实现重试逻辑（如 exponential backoff） } else { fmt.Println(\u0026#34;不可重试错误：\u0026#34;, err) } } } 4. 集中管理错误码，避免硬编码 在业务系统中，错误码（如 1001 = 参数错误、2001 = 数据库错误）便于前端 / 客户端快速判断错误类型。建议用常量集中管理错误码：\n// 错误示例：硬编码错误码，维护困难 return \u0026amp;CustomErr{Code: 1001, Msg: \u0026#34;参数错误\u0026#34;} // 正确示例：集中定义错误码常量 package errors // 业务错误码常量 const ( ErrCodeParamInvalid = 1001 // 参数无效 ErrCodeDBQuery = 2001 // 数据库查询失败 ErrCodeAPIRequest = 3001 // 第三方API请求失败 ) // 全局错误实例（避免重复创建） var ( ErrParamInvalid = \u0026amp;CustomErr{Code: ErrCodeParamInvalid, Msg: \u0026#34;参数无效\u0026#34;} ErrDBQuery = \u0026amp;CustomErr{Code: ErrCodeDBQuery, Msg: \u0026#34;数据库查询失败\u0026#34;} ) // 使用时直接引用，无需重复定义 func checkParam(name string) error { if name == \u0026#34;\u0026#34; { return fmt.Errorf(\u0026#34;name 不能为空：%w\u0026#34;, ErrParamInvalid) } return nil } 5. 不暴露敏感信息到错误中 错误信息可能会被日志记录或返回给客户端，需避免包含密码、密钥、用户隐私等敏感数据：\n// 错误示例：错误信息包含密码 func login(username, password string) error { if !checkPassword(username, password) { return fmt.Errorf(\u0026#34;登录失败：用户名[%s]，密码[%s]不匹配\u0026#34;, username, password) } return nil } // 正确示例：隐藏敏感信息 func login(username, password string) error { if !checkPassword(username, password) { return fmt.Errorf(\u0026#34;登录失败：用户名[%s]密码不匹配\u0026#34;, username) // 不包含密码 } return nil } 6. 日志记录错误时，包含错误链完整信息 排查问题时，仅打印外层错误不够，需打印完整错误链。可自定义日志工具，自动解析错误链：\n// 打印完整错误链的工具函数 func LogError(err error) { var allErrs []string // 循环 unwrap 错误链，收集所有错误描述 for err != nil { allErrs = append(allErrs, err.Error()) err = errors.Unwrap(err) // 提取内层错误 } // 输出完整错误链（如：初始化服务失败 → 读取配置失败 → 文件不存在） log.Printf(\u0026#34;错误链：%s\u0026#34;, strings.Join(allErrs, \u0026#34; → \u0026#34;)) } // 使用示例 err := initService(\u0026#34;config.yaml\u0026#34;) if err != nil { LogError(err) // 输出：错误链：初始化服务失败：read config file [config.yaml] failed: open config.yaml: no such file or directory → read config file [config.yaml] failed: open config.yaml: no such file or directory → open config.yaml: no such file or directory } 三、Go Error 扩展技巧：超越基础功能 基础错误处理满足简单场景，复杂系统需对 Error 进行扩展，比如添加堆栈信息、业务元数据等。\n1. 扩展错误：携带堆栈信息 Go 原生错误不包含堆栈信息，导致无法定位错误发生的代码行。可自定义错误类型，在创建时捕获堆栈：\npackage main import ( \u0026#34;errors\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;log\u0026#34; \u0026#34;runtime\u0026#34; \u0026#34;strings\u0026#34; ) // 带堆栈的自定义错误 type StackError struct { Msg string // 错误描述 Err error // 原始错误 Stack []string // 堆栈信息 } // 实现 Error() 方法 func (e *StackError) Error() string { if e.Err != nil { return fmt.Sprintf(\u0026#34;%s: %v\\n堆栈：%s\u0026#34;, e.Msg, e.Err, strings.Join(e.Stack, \u0026#34;\\n\u0026#34;)) } return fmt.Sprintf(\u0026#34;%s\\n堆栈：%s\u0026#34;, e.Msg, strings.Join(e.Stack, \u0026#34;\\n\u0026#34;)) } // 实现 Unwrap() 方法，支持 errors.Unwrap 解析错误链 func (e *StackError) Unwrap() error { return e.Err } // 创建带堆栈的错误（skip：跳过调用栈层数，避免包含当前函数） func NewStackError(msg string, err error, skip int) *StackError { stack := make([]string, 0, 10) // 捕获调用栈信息 pc := make([]uintptr, 10) n := runtime.Callers(skip+1, pc) // skip+1：跳过 NewStackError 自身 for i := 0; i \u0026lt; n; i++ { fn := runtime.FuncForPC(pc[i]) file, line := fn.FileLine(pc[i]) stack = append(stack, fmt.Sprintf(\u0026#34;%s:%d %s\u0026#34;, file, line, fn.Name())) } return \u0026amp;StackError{ Msg: msg, Err: err, Stack: stack, } } // 使用示例 func readFile(path string) error { _, err := os.Open(path) if err != nil { // 创建带堆栈的错误（skip=1：跳过 readFile 函数，从调用者开始捕获） return NewStackError(fmt.Sprintf(\u0026#34;读取文件[%s]失败\u0026#34;, path), err, 1) } return nil } func main() { err := readFile(\u0026#34;config.yaml\u0026#34;) if err != nil { log.Printf(\u0026#34;错误：%v\u0026#34;, err) // 输出会包含堆栈信息，如： // 错误：读取文件[config.yaml]失败: open config.yaml: no such file or directory // 堆栈：/Users/xxx/project/main.go:50 main.readFile // /Users/xxx/project/main.go:58 main.main // /usr/local/go/src/runtime/proc.go:250 runtime.main return } } 2. 结合第三方库：简化扩展 手动实现堆栈、错误码等功能较繁琐，可借助成熟的第三方库：\npkg/errors：Go 1.13 前常用的错误扩展库，支持WithStack（添加堆栈）、WithMessage（添加描述）；\nzap/errors：日志库zap的错误扩展，支持结构化日志输出错误链和堆栈；\ngo-multierror：支持合并多个错误（如批量操作中的多个错误）。\n示例：用pkg/errors添加堆栈：\nimport \u0026#34;github.com/pkg/errors\u0026#34; func readFile(path string) error { _, err := os.Open(path) if err != nil { // 添加堆栈和上下文 return errors.Wrapf(err, \u0026#34;读取文件[%s]失败\u0026#34;, path) } return nil } func main() { err := readFile(\u0026#34;config.yaml\u0026#34;) if err != nil { // 打印带堆栈的错误 log.Printf(\u0026#34;错误：%+v\u0026#34;, err) // %+v 会输出堆栈 } } 四、Go Error 封装方案：提升复用性 在大型项目中，建议对错误处理逻辑进行封装，统一错误格式、简化调用、降低耦合。以下是 3 种常见封装方式：\n1. 封装错误创建函数：统一错误格式 针对业务场景，封装创建错误的函数，避免重复编写fmt.Errorf或NewStackError：\n// 封装数据库错误创建函数 func NewDBError(err error, msg string) error { return NewStackError( fmt.Sprintf(\u0026#34;数据库错误：%s\u0026#34;, msg), err, 2, // skip=2：跳过 NewDBError 和调用者，从上层开始捕获堆栈 ) } // 封装API错误创建函数 func NewAPIError(err error, url string) error { return NewStackError( fmt.Sprintf(\u0026#34;调用API[%s]失败\u0026#34;, url), err, 2, ) } // 使用时简化为： func queryDB(sql string) error { _, err := db.Query(sql) if err != nil { return NewDBError(err, fmt.Sprintf(\u0026#34;执行SQL：%s\u0026#34;, sql)) } return nil } 2. 封装错误判断函数：隐藏实现细节 对于自定义错误类型，封装判断函数，避免上层代码直接依赖错误类型（降低耦合）：\n// 封装判断“是否为参数错误”的函数 func IsParamError(err error) bool { var customErr *CustomErr // 检查错误链中是否包含 CustomErr，且错误码为参数错误 return errors.As(err, \u0026amp;customErr) \u0026amp;\u0026amp; customErr.Code == ErrCodeParamInvalid } // 上层使用时，无需知道 CustomErr 类型： func main() { err := checkParam(\u0026#34;\u0026#34;) if IsParamError(err) { fmt.Println(\u0026#34;处理参数错误逻辑\u0026#34;) return } } 3. 封装错误处理中间件：统一响应格式 在 HTTP 服务中，封装错误处理中间件，将业务错误统一转换为 HTTP 响应（如 JSON 格式）：\npackage main import ( \u0026#34;encoding/json\u0026#34; \u0026#34;net/http\u0026#34; ) // 统一HTTP错误响应格式 type HTTPErrorResponse struct { Code int `json:\u0026#34;code\u0026#34;` // 错误码 Message string `json:\u0026#34;message\u0026#34;` // 错误描述 } // 错误处理中间件：捕获Handler返回的错误，统一响应 func ErrorMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { // 用自定义 ResponseWriter 捕获错误 ew := \u0026amp;errorResponseWriter{ResponseWriter: w} next.ServeHTTP(ew, r) // 若有错误，返回统一格式 if ew.err != nil { w.Header().Set(\u0026#34;Content-Type\u0026#34;, \u0026#34;application/json\u0026#34;) // 解析错误码（假设 CustomErr 带 Code） var customErr *CustomErr code := http.StatusInternalServerError // 默认500 if errors.As(ew.err, \u0026amp;customErr) { switch customErr.Code { case ErrCodeParamInvalid: code = http.StatusBadRequest // 400 case ErrCodeDBQuery: code = http.StatusServiceUnavailable // 503 } } // 返回JSON响应 resp := HTTPErrorResponse{ Code: code, Message: ew.err.Error(), } json.NewEncoder(w).Encode(resp) } }) } // 自定义 ResponseWriter：捕获Handler返回的错误 type errorResponseWriter struct { http.ResponseWriter err error } // 提供 WriteError 方法，让Handler通过它返回错误 func (ew *errorResponseWriter) WriteError(err error) { ew.err = err } // Handler示例：使用中间件后，通过 WriteError 返回错误 func loginHandler(w http.ResponseWriter, r *http.Request) { username := r.FormValue(\u0026#34;username\u0026#34;) if username == \u0026#34;\u0026#34; { // 调用自定义 WriteError 返回错误 ew := w.(*errorResponseWriter) ew.WriteError(fmt.Errorf(\u0026#34;用户名不能为空：%w\u0026#34;, ErrParamInvalid)) return } w.Write([]byte(\u0026#34;登录成功\u0026#34;)) } // 注册路由，使用中间件 func main() { mux := http.NewServeMux() mux.HandleFunc(\u0026#34;/login\u0026#34;, loginHandler) // 包装中间件 server := \u0026amp;http.Server{ Addr: \u0026#34;:8080\u0026#34;, Handler: ErrorMiddleware(mux), } log.Fatal(server.ListenAndServe()) } 五、常见错误姿势对比：避坑对照表 错误姿势 问题 正确姿势 优点 用_忽略错误：file, _ := os.Open(path) 错误隐藏，后续操作可能 panic 显式检查：if err != nil { log.Printf(\u0026quot;失败：%v\u0026quot;, err); return } 及时发现错误，避免连锁问题 裸返回原始错误：return err 无上下文，无法定位场景 包装上下文：return fmt.Errorf(\u0026quot;读取文件[%s]失败：%w\u0026quot;, path, err) 错误链完整，可追溯根源 硬编码错误码：return \u0026amp;CustomErr{1001, \u0026quot;参数错\u0026quot;} 维护困难，易重复 集中管理错误码：return fmt.Errorf(\u0026quot;参数错：%w\u0026quot;, ErrParamInvalid) 统一维护，降低冗余 错误信息含敏感数据：return fmt.Errorf(\u0026quot;密码[%s]错误\u0026quot;, pwd) 泄露隐私，安全风险 隐藏敏感信息：return fmt.Errorf(\u0026quot;密码错误\u0026quot;) 符合安全规范 重复编写错误创建逻辑：每次都写NewStackError(...) 代码冗余，易出错 封装创建函数：return NewDBError(err, \u0026quot;执行SQL失败\u0026quot;) 简化调用，统一格式 直接判断错误字符串：if err.Error() == \u0026quot;文件不存在\u0026quot; 脆弱（错误描述变则判断失效） 用errors.Is：if errors.Is(err, os.ErrNotExist) 健壮，不依赖字符串描述 六、总结 Go Error 处理的核心是 “显式、可控、可追溯”：\n理解原理：Error 是接口，错误链通过%w构建，用errors.Is/errors.As解析；\n遵循实践：不忽略错误、带上下文、区分可重试性、集中管理错误码；\n合理扩展：按需添加堆栈、业务元数据，或借助第三方库简化；\n封装复用：通过函数、中间件封装错误逻辑，降低耦合。\n错误处理不是 “额外工作”，而是程序健壮性的基石。希望本文能帮你避开常见坑，写出更优雅的 Go 代码！\n","permalink":"/blogs/2025/go/go-error-handling-deep-dive-basics-practice-advanced-wrapping.html","summary":"\u003cp\u003e在 Go 语言开发中，错误处理是保障程序健壮性的核心环节。与 Java、Python 等语言的 “异常捕获” 机制不同，Go 采用\u003cstrong\u003e显式错误处理\u003c/strong\u003e设计，强调 “错误是值” 的理念。本文将从 Error 的底层原理出发，拆解最佳工程实践、扩展技巧与封装方案，并对比常见错误姿势，帮你写出更优雅、可维护的 Go 代码。\u003c/p\u003e","title":"Go Error 全方位解析：原理、实践、扩展与封装"},{"content":"前言 在 Go 语言的并发模型中，Channel 是实现 Goroutine 间通信和同步的核心组件，被誉为 “Go 并发的灵魂”。但实际开发中，不少开发者因对 Channel 特性理解不深，写出死锁、内存泄漏等问题代码。本文将系统梳理 Channel 的常见错误场景、最佳使用姿势，并结合主流开源项目案例，帮你真正用好 Channel。\n一、Channel 使用中易踩的 “坑” 1.1 未初始化的 nil Channel：永久阻塞的 “隐形杀手” Channel 声明后若未用make初始化，会处于nil状态。而nil Channel有个致命特性：读写操作都会永久阻塞，最终导致程序死锁。\npackage main func main() { var ch chan int // 仅声明，未初始化（nil Channel） // 以下两种操作都会触发死锁 ch \u0026lt;- 1 // 写入nil Channel：永久阻塞 // num := \u0026lt;-ch // 读取nil Channel：同样永久阻塞 } 错误原因：nil Channel未分配底层缓冲区，也没有 “通信就绪” 的状态标识，Goroutine 会一直等待对方就绪，永远无法唤醒。\n1.2 无缓冲 Channel 的 “自阻塞”：同一 Goroutine 读写 无缓冲 Channel（make(chan T)）的通信逻辑是 “同步交换”：必须有一个 Goroutine 写入，同时有另一个 Goroutine 读取，两者才能完成通信。若在同一 Goroutine中对无缓冲 Channel 读写，会立即死锁。\npackage main func main() { ch := make(chan int) // 无缓冲Channel ch \u0026lt;- 1 // 写入后，等待读取者就绪 num := \u0026lt;-ch // 同一Goroutine读取：此时写入还在阻塞，读取永远无法执行 } 运行结果：fatal error: all goroutines are asleep - deadlock!\n1.3 忘记关闭 Channel：Goroutine 泄漏的 “温床” 若 Channel 用for range遍历（最常用的读取方式），且未在生产者端关闭 Channel，消费者 Goroutine 会一直阻塞在读取操作上，永远无法退出，造成Goroutine 泄漏。\npackage main import \u0026#34;fmt\u0026#34; func main() { ch := make(chan int) go producer(ch) go consumer(ch) // 此Goroutine会泄漏 // 主Goroutine睡眠，观察泄漏 select {} } // 生产者：只发送数据，未关闭Channel func producer(ch chan\u0026lt;- int) { for i := 0; i \u0026lt; 3; i++ { ch \u0026lt;- i fmt.Printf(\u0026#34;生产: %d\\n\u0026#34;, i) } // 遗漏：close(ch) } // 消费者：for range遍历，未关闭则永久阻塞 func consumer(ch \u0026lt;-chan int) { for num := range ch { // 当Channel未关闭且无数据时，永久阻塞 fmt.Printf(\u0026#34;消费: %d\\n\u0026#34;, num) } fmt.Println(\u0026#34;消费者退出\u0026#34;) // 永远不会执行 } 检测方法：用pprof工具查看 Goroutine 数量，会发现consumer对应的 Goroutine 始终存在。\n1.4 过度依赖 Channel：用错场景的 “性能陷阱” Channel 虽好，但并非所有并发场景都适用。比如 “多 Goroutine 读写共享数据” 场景，若用 Channel 传递数据而非sync.Mutex加锁，会增加通信开销，降低性能。\n// 错误场景：用Channel传递数据实现计数（低效） package main import \u0026#34;sync\u0026#34; func main() { ch := make(chan int, 1) ch \u0026lt;- 0 // 初始计数 var wg sync.WaitGroup for i := 0; i \u0026lt; 1000; i++ { wg.Add(1) go func() { defer wg.Done() count := \u0026lt;-ch // 读取计数 count++ ch \u0026lt;- count // 写回计数 }() } wg.Wait() fmt.Println(\u0026#34;最终计数:\u0026#34;, \u0026lt;-ch) } 问题：1000 个 Goroutine 通过 Channel 串行读写计数，本质是 “串行执行”，性能远不如sync.Mutex加锁（可并行执行临界区外逻辑）。\n二、Channel 最佳使用姿势 2.1 明确 Channel 类型：无缓冲 vs 有缓冲，按需选择 类型 适用场景 核心特性 无缓冲 Channel 强同步通信（如 “任务交接”） 读写必须同时就绪，同步阻塞 有缓冲 Channel 异步解耦（如 “生产者 - 消费者”） 缓冲未满可写入，未空可读取 选择原则：\n若需要 “发送方确认接收方已收到”（如信号同步），用无缓冲 Channel；\n若需要 “发送方无需等待接收方，先存再取”（如削峰填谷），用有缓冲 Channel。\n2.2 初始化时指定合理缓冲大小：避免频繁阻塞 有缓冲 Channel 的缓冲大小并非越大越好，需结合 “生产者速度” 和 “消费者处理速度” 计算，公式参考：\n缓冲大小 = 生产者每秒产量 × 消费者平均处理耗时 × 冗余系数（1.2~2）\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;time\u0026#34; ) func main() { // 场景：生产者每秒产10个数据，消费者处理1个需200ms // 缓冲大小 = 10 × 0.2 × 2 = 4（冗余2倍，避免突发阻塞） ch := make(chan int, 4) var wg sync.WaitGroup wg.Add(2) go producer(ch, \u0026amp;wg) go consumer(ch, \u0026amp;wg) wg.Wait() } func producer(ch chan\u0026lt;- int, wg *sync.WaitGroup) { defer wg.Done() for i := 0; i \u0026lt; 10; i++ { ch \u0026lt;- i fmt.Printf(\u0026#34;[%s] 生产: %d\\n\u0026#34;, time.Now().Format(\u0026#34;15:04:05\u0026#34;), i) time.Sleep(100 * time.Millisecond) // 模拟生产耗时 } close(ch) // 生产者负责关闭Channel } func consumer(ch \u0026lt;-chan int, wg *sync.WaitGroup) { defer wg.Done() for num := range ch { fmt.Printf(\u0026#34;[%s] 消费: %d\\n\u0026#34;, time.Now().Format(\u0026#34;15:04:05\u0026#34;), num) time.Sleep(200 * time.Millisecond) // 模拟处理耗时 } } 2.3 用 select 处理超时与关闭：避免永久阻塞 当 Channel 读写可能阻塞时，用select搭配time.After（超时）或default（非阻塞），以及 “ok判断”（关闭检测），确保 Goroutine 能正常退出。\n场景 1：读取超时 package main import ( \u0026#34;fmt\u0026#34; \u0026#34;time\u0026#34; ) func main() { ch := make(chan int) select { case num := \u0026lt;-ch: fmt.Println(\u0026#34;收到数据:\u0026#34;, num) case \u0026lt;-time.After(2 * time.Second): // 2秒超时 fmt.Println(\u0026#34;读取超时，退出\u0026#34;) } } 场景 2：检测 Channel 关闭 // 消费者读取时，用ok判断Channel是否关闭 func consumer(ch \u0026lt;-chan int) { for { num, ok := \u0026lt;-ch // ok=false表示Channel已关闭 if !ok { fmt.Println(\u0026#34;Channel已关闭，消费者退出\u0026#34;) return } fmt.Println(\u0026#34;消费:\u0026#34;, num) } } 2.4 遵循 “谁创建谁关闭” 原则：避免重复关闭 Channel 关闭后不能再写入，重复关闭会触发panic。最佳实践是：Channel 的创建者负责关闭，使用者只负责读写，避免跨 Goroutine 关闭。\npackage main import \u0026#34;sync\u0026#34; func main() { // 主Goroutine创建Channel，也负责关闭 ch := make(chan int, 3) var wg sync.WaitGroup wg.Add(1) go consumer(ch, \u0026amp;wg) // 生产者逻辑（创建者内实现） for i := 0; i \u0026lt; 3; i++ { ch \u0026lt;- i } close(ch) // 创建者关闭Channel wg.Wait() } // 消费者：只读取，不关闭 func consumer(ch \u0026lt;-chan int, wg *sync.WaitGroup) { defer wg.Done() for num := range ch { fmt.Println(\u0026#34;消费:\u0026#34;, num) } } 2.5 用 for range 遍历 Channel：简化代码 对 Channel 的读取，优先用for range而非for循环 +ok判断，代码更简洁，且能自动在 Channel 关闭时退出。\n// 推荐写法 for num := range ch { fmt.Println(\u0026#34;消费:\u0026#34;, num) } // 等价于（繁琐写法） for { num, ok := \u0026lt;-ch if !ok { break } fmt.Println(\u0026#34;消费:\u0026#34;, num) } 三、开源项目中的 Channel 实战案例 3.1 etcd：用 Channel 实现异步日志写入 etcd 是分布式 KV 存储，其wal（Write-Ahead Log）模块用 Channel 实现 “日志写入请求” 的异步处理，解耦请求发送与 IO 操作。\n// etcd/wal/encoder.go（v3.5.0） type Encoder struct { mu sync.Mutex w io.Writer // 实际IO写入器 ch chan WriteRequest // 接收写入请求的Channel（有缓冲） donec chan struct{} // 关闭通知Channel } // 初始化：创建有缓冲Channel，启动消费者协程 func NewEncoder(w io.Writer) *Encoder { enc := \u0026amp;Encoder{ w: w, ch: make(chan WriteRequest, 1024), // 缓冲1024，避免生产者阻塞 donec: make(chan struct{}), } go enc.writeLoop() // 消费者协程：处理写入请求 return enc } // 生产者接口：外部调用Write发送写入请求 func (e *Encoder) Write(p []byte) (n int, err error) { req := WriteRequest{data: p, resp: make(chan error)} select { case e.ch \u0026lt;- req: // 发送请求到Channel err = \u0026lt;-req.resp // 等待写入结果（同步反馈） case \u0026lt;-e.donec: // 检测关闭信号 err = ErrClosed } return len(p), err } // 消费者协程：循环处理Channel中的请求 func (e *Encoder) writeLoop() { for req := range e.ch { // for range遍历，自动处理关闭 _, err := e.w.Write(req.data) // 实际IO写入 req.resp \u0026lt;- err // 反馈写入结果 } close(e.donec) // 所有请求处理完，关闭通知Channel } 设计亮点：\n用有缓冲 Channel削峰：当 IO 繁忙时，请求先存到缓冲，避免生产者（业务协程）阻塞；\n用resp Channel 实现 “异步写入 + 同步反馈”：生产者发送请求后，通过req.resp等待结果，兼顾性能与可靠性。\n3.2 gin：用 Channel 实现优雅关闭 gin 是 Go 主流 Web 框架，其Engine结构体用 Channel 传递 “优雅关闭” 信号，确保服务器关闭前完成已接收请求的处理。\n// gin/gin.go（v1.9.1） type Engine struct { // ... 其他字段 shutdownChan chan struct{} // 优雅关闭信号Channel } // 启动服务器：监听shutdownChan func (engine *Engine) Run(addr ...string) (err error) { address := resolveAddress(addr) srv := \u0026amp;http.Server{ Addr: address, Handler: engine, } // 启动协程：监听关闭信号 go func() { \u0026lt;-engine.shutdownChan // 阻塞，直到Channel关闭 // 优雅关闭服务器（等待已连接请求处理完） if err := srv.Shutdown(context.Background()); err != nil { log.Printf(\u0026#34;Server Shutdown error: %v\u0026#34;, err) } }() return srv.ListenAndServe() } // 外部触发优雅关闭：关闭Channel发送信号 func (engine *Engine) Shutdown() { close(engine.shutdownChan) } 设计亮点：\n用 Channel 传递 “关闭信号”：相比共享变量 + 锁，Channel 的 “关闭不可逆转” 特性更安全，避免重复触发关闭；\n解耦关闭触发与处理：Shutdown方法只需关闭 Channel，无需关心具体关闭逻辑，符合单一职责原则。\n3.3 Go 标准库 net/http：用 Channel 管理服务器生命周期 Go 标准库net/http的Server结构体，用done Channel 实现服务器的 “关闭通知”，确保主循环能及时退出。\n// net/http/server.go（Go 1.21） type Server struct { // ... 其他字段 done chan struct{} // 关闭通知Channel } // 优雅关闭：关闭done Channel，通知主循环 func (s *Server) Shutdown(ctx context.Context) error { // ... 前置关闭逻辑（如停止接收新连接） close(s.done) // 发送关闭信号 // 等待所有连接处理完 select { case \u0026lt;-ctx.Done(): return ctx.Err() case \u0026lt;-s.idleConnClosed: return nil } } // 服务器主循环：监听连接与关闭信号 func (s *Server) Serve(l net.Listener) error { // ... 初始化逻辑 for { select { case \u0026lt;-s.done: // 检测到关闭信号 l.Close() // 关闭监听器，停止接收新连接 return ErrServerClosed default: // 接收新连接（非阻塞检测关闭信号） conn, err := l.Accept() if err != nil { return err } go s.serveConn(conn) // 处理连接 } } } 设计亮点：\n轻量级信号传递：done Channel 仅用于 “通知”，不传递数据，无额外开销；\n主循环安全退出：通过select在 “接收连接” 和 “关闭信号” 间切换，确保关闭时不遗漏资源释放。\n四、总结 Channel 的核心价值是 “安全地实现 Goroutine 通信与同步”，用好 Channel 的关键在于：\n避坑：避免 nil Channel、同一 Goroutine 读写无缓冲 Channel、忘记关闭 Channel；\n规范：明确 Channel 类型与缓冲大小，遵循 “谁创建谁关闭”，用 select 处理超时；\n借鉴：参考开源项目的设计思路，结合场景选择 “同步通信” 或 “异步解耦”。\n最后记住：Channel 不是万能的，若场景更适合用sync.Mutex（如共享数据读写）或sync.WaitGroup（如协程等待），不必强行使用 Channel。工具的价值在于适配场景，而非追求 “技术纯粹性”。\n","permalink":"/blogs/2025/go/go-channels-deep-guide-best-practices-and-pitfalls.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在 Go 语言的并发模型中，Channel 是实现 Goroutine 间通信和同步的核心组件，被誉为 “Go 并发的灵魂”。但实际开发中，不少开发者因对 Channel 特性理解不深，写出死锁、内存泄漏等问题代码。本文将系统梳理 Channel 的\u003cstrong\u003e常见错误场景\u003c/strong\u003e、\u003cstrong\u003e最佳使用姿势\u003c/strong\u003e，并结合主流开源项目案例，帮你真正用好 Channel。\u003c/p\u003e","title":"Go Channel 深度指南：规范、避坑与开源实践"},{"content":"前言 在并发编程、分布式系统或 Web 开发中，你一定听过 “Context”（上下文）这个词。它像一个 “隐形的信使”，在不同组件、函数或服务间传递关键信息，却常常因为 “看不见摸不着” 被开发者忽视。今天我们就从概念解析、最佳实践、开源案例到常见错误，彻底搞懂 Context。\n一、Context 是什么？核心价值在哪？ Context（上下文）本质是携带 “全局” 信息的容器，这些信息通常是 “跨层级、跨组件” 的，比如：\n超时 / 取消信号（如 “10 秒后终止这个请求”）\n请求域数据（如用户 ID、请求 ID、日志 ID）\n环境配置（如当前是开发 / 生产环境）\n它的核心价值是 解耦 —— 避免为了传递 “全局信息”，把函数参数搞得越来越长（比如func doSomething(userID string, reqID string, timeout int, ...)），也避免用全局变量导致数据混乱。\n以 Go 语言为例：Context 的基础用法 Go 的context包是 Context 的经典实现，核心接口只有 4 个方法：\ntype Context interface { Deadline() (deadline time.Time, ok bool) // 超时时间 Done() \u0026lt;-chan struct{} // 取消信号通道 Err() error // 取消原因 Value(key any) any // 获取上下文数据 } 常见的 Context 创建方式：\ncontext.Background()：根 Context（最顶层，无超时 / 数据）\ncontext.TODO()：暂不确定用途时用（替代nil，方便后续重构）\ncontext.WithCancel(parent)：创建可取消的 Context\ncontext.WithTimeout(parent, duration)：创建带超时的 Context\ncontext.WithValue(parent, key, value)：创建携带数据的 Context\n简单示例：用 Context 控制 goroutine 超时\nfunc main() { // 1. 创建一个3秒超时的Context ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() // 确保最终取消，避免资源泄漏 // 2. 启动goroutine执行任务 go func(ctx context.Context) { for { select { case \u0026lt;-ctx.Done(): // 3. 收到超时/取消信号，退出任务 fmt.Println(\u0026#34;任务终止：\u0026#34;, ctx.Err()) // 输出 \u0026#34;context deadline exceeded\u0026#34; return default: fmt.Println(\u0026#34;任务执行中...\u0026#34;) time.Sleep(1 * time.Second) } } }(ctx) // 等待goroutine执行 time.Sleep(5 * time.Second) } 二、Context 的 5 个最佳实践 Context 看似简单，但用错了会导致资源泄漏、数据混乱或性能问题。以下是经过验证的最佳实践：\n1. 始终将 Context 作为函数第一个参数 约定优于配置！把 Context 放在第一个参数位置（命名为ctx），让代码更易读：\n// 推荐：Context作为第一个参数 func processOrder(ctx context.Context, orderID string) error { ... } // 不推荐：Context位置随意，或用其他命名 func processOrder(orderID string, c context.Context) error { ... } 2. 不要在 Context 中存储 “大量数据” 或 “频繁修改的数据” Context 的Value()方法是 “键值对” 查询，没有索引，频繁查询会影响性能；且数据一旦存入，无法修改（只能通过WithValue创建新 Context）。\n推荐存：请求 ID、用户 ID、日志 ID 等 “小而稳定” 的数据\n不推荐存：大对象（如 HTTP 请求体）、频繁变化的数据（如计数器）\n3. 及时取消 Context，避免资源泄漏 用WithCancel/WithTimeout创建的 Context，一定要调用返回的cancel函数（即使任务正常结束），否则底层的 goroutine、网络连接可能一直占用资源。\n推荐用defer cancel()确保取消：\nfunc handleRequest(w http.ResponseWriter, r *http.Request) { ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second) defer cancel() // 关键：请求结束后自动取消 // 执行耗时任务 result, err := doHeavyTask(ctx) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Write([]byte(result)) } 4. 不要传递 “过期的 Context” 当 Context 的Done()通道被关闭（即超时 / 取消），这个 Context 就 “过期了”，不能再传递给新的函数 / 任务。\n反例：\nfunc badCase() { ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second) cancel() // 主动取消，Context已过期 // 错误：将过期的Context传递给新任务 go doTask(ctx) // doTask会立即收到取消信号，无法正常执行 } 5. 用自定义类型作为 Context 的 Value 键，避免冲突 如果多个组件都用string或int作为Value的键，可能会出现 “键冲突”（比如 A 组件存key:\u0026quot;user\u0026quot;，B 组件也存key:\u0026quot;user\u0026quot;，导致数据覆盖）。\n推荐用自定义空结构体类型作为键：\n// 定义自定义键类型 type userIDKey struct{} type reqIDKey struct{} // 存数据 ctx = context.WithValue(ctx, userIDKey{}, \u0026#34;123456\u0026#34;) ctx = context.WithValue(ctx, reqIDKey{}, \u0026#34;req-789\u0026#34;) // 取数据（需要类型断言） userID, ok := ctx.Value(userIDKey{}).(string) if !ok { // 处理类型不匹配的情况 return errors.New(\u0026#34;userID not found or type error\u0026#34;) } 三、开源项目中的 Context 实践案例 Context 不是理论，而是被广泛应用在主流开源项目中。以下是 3 个典型案例：\n1. Gin（Go Web 框架）：用 Context 传递请求信息 Gin 框架的gin.Context是对 Go 原生context.Context的扩展，承载了整个 HTTP 请求的所有信息：\n请求数据（ctx.Request、ctx.Params）\n响应控制（ctx.JSON、ctx.String）\n中间件数据传递（如用户认证后，将用户信息存入 Context）\n示例：Gin 中间件存用户信息\n// 认证中间件：从Token解析用户ID，存入Context func authMiddleware() gin.HandlerFunc { return func(c *gin.Context) { token := c.GetHeader(\u0026#34;Authorization\u0026#34;) userID, err := parseToken(token) if err != nil { c.AbortWithStatusJSON(401, gin.H{\u0026#34;error\u0026#34;: \u0026#34;unauthorized\u0026#34;}) return } // 将用户ID存入Gin Context c.Set(\u0026#34;userID\u0026#34;, userID) c.Next() // 继续执行后续 handler } } // 业务Handler：从Context取用户ID func getUserInfo(c *gin.Context) { // 从Context取数据 userID, exists := c.Get(\u0026#34;userID\u0026#34;) if !exists { c.JSON(400, gin.H{\u0026#34;error\u0026#34;: \u0026#34;userID not found\u0026#34;}) return } // 查询用户信息并返回 info := queryUserInfo(userID.(string)) c.JSON(200, info) } 2. etcd-client（分布式 KV 存储客户端）：用 Context 控制请求超时 etcd 是分布式系统常用的 KV 存储，其 Go 客户端用 Context 控制每个请求的超时和取消：\nfunc getEtcdValue(cli *clientv3.Client, key string) (string, error) { // 1. 创建5秒超时的Context：确保请求不会无限阻塞 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() // 2. 传递Context到etcd请求 resp, err := cli.Get(ctx, key) if err != nil { return \u0026#34;\u0026#34;, err } // 3. 处理响应 if len(resp.Kvs) == 0 { return \u0026#34;\u0026#34;, errors.New(\u0026#34;key not found\u0026#34;) } return string(resp.Kvs[0].Value), nil } 如果 etcd 集群响应缓慢，5 秒后 Context 会触发取消，避免客户端一直等待。\n3. GORM（Go ORM 框架）：用 Context 控制事务和日志 GORM 支持将 Context 传递给数据库操作，实现 “事务超时” 和 “日志追踪”：\nfunc createOrder(ctx context.Context, db *gorm.DB, order Order) error { // 1. 用Context启动事务，设置3秒超时 tx := db.WithContext(ctx).Begin() if tx.Error != nil { return tx.Error } defer func() { if r := recover(); r != nil { tx.Rollback() } }() // 2. 执行数据库操作（Context会传递超时信号） if err := tx.Create(\u0026amp;order).Error; err != nil { tx.Rollback() return err } // 3. 提交事务 return tx.Commit().Error } 如果数据库操作超过 Context 的超时时间，事务会自动终止并回滚，避免长期占用数据库连接。\n四、Context 的 4 个常见错误（附解决方案） 即使知道了最佳实践，新手仍容易踩坑。以下是最常见的 4 个错误：\n1. 错误 1：用 Context 传递 “业务参数” 问题：把函数的核心业务参数（如订单 ID、商品数量）存入 Context，导致代码可读性差（不知道函数需要哪些参数，必须看 Context 的逻辑）。\n反例：\n// 错误：将orderID存入Context，而非作为函数参数 func calculatePrice(ctx context.Context) (float64, error) { orderID, ok := ctx.Value(orderIDKey{}).(string) if !ok { return 0, errors.New(\u0026#34;orderID missing\u0026#34;) } // ... 计算价格 } 解决方案：Context 只存 “跨层级、跨组件” 的全局信息（如请求 ID），业务参数用显式函数参数传递：\n// 正确：orderID作为参数，请求ID存入Context func calculatePrice(ctx context.Context, orderID string) (float64, error) { reqID, _ := ctx.Value(reqIDKey{}).(string) log.Printf(\u0026#34;calculatePrice: reqID=%s, orderID=%s\u0026#34;, reqID, orderID) // ... 计算价格 } 2. 错误 2：忽略 Context 的取消信号 问题：启动 goroutine 后，不监听 Context 的Done()通道，导致 goroutine 在超时 / 取消后仍继续运行，造成资源泄漏。\n反例：\nfunc badGoroutine(ctx context.Context) { for { fmt.Println(\u0026#34;一直在运行...\u0026#34;) time.Sleep(1 * time.Second) // 错误：没有监听ctx.Done()，即使Context取消，也不会退出 } } 解决方案：在循环或耗时操作中，通过select监听ctx.Done()：\nfunc goodGoroutine(ctx context.Context) { for { select { case \u0026lt;-ctx.Done(): fmt.Println(\u0026#34;收到取消信号，退出goroutine\u0026#34;) return default: fmt.Println(\u0026#34;正常运行...\u0026#34;) time.Sleep(1 * time.Second) } } } 3. 错误 3：嵌套过多 WithValue，导致性能下降 问题：每次用WithValue都会创建一个新的 Context，嵌套过多（如 10 层以上）会导致Value()查询时需要逐层遍历，性能下降。\n反例：\n// 错误：多次嵌套WithValue ctx := context.Background() ctx = context.WithValue(ctx, key1, val1) ctx = context.WithValue(ctx, key2, val2) ctx = context.WithValue(ctx, key3, val3) // ... 嵌套10层 解决方案：将多个相关数据封装成一个结构体，一次性存入 Context：\n// 正确：封装成结构体 type RequestInfo struct { UserID string ReqID string Env string } ctx := context.WithValue(context.Background(), requestInfoKey{}, RequestInfo{ UserID: \u0026#34;123\u0026#34;, ReqID: \u0026#34;req-456\u0026#34;, Env: \u0026#34;prod\u0026#34;, }) // 取数据时一次断言 info, ok := ctx.Value(requestInfoKey{}).(RequestInfo) 4. 错误 4：在 Context 中存储 “可变数据” 问题：把切片、map 等 “引用类型” 存入 Context，然后在其他地方修改这些数据，导致并发安全问题（多个 goroutine 同时修改）。\n反例：\n// 错误：存入map并修改 m := map[string]string{\u0026#34;key\u0026#34;: \u0026#34;val\u0026#34;} ctx := context.WithValue(context.Background(), mapKey{}, m) // 另一个goroutine修改map go func() { m[\u0026#34;key\u0026#34;] = \u0026#34;new val\u0026#34; // 并发修改，可能导致panic }() 解决方案：要么存入 “不可变数据”（如string、int），要么存入引用类型的 “副本”，避免外部修改：\n// 正确：存入map的副本 m := map[string]string{\u0026#34;key\u0026#34;: \u0026#34;val\u0026#34;} // 创建副本 mCopy := make(map[string]string, len(m)) for k, v := range m { mCopy[k] = v } ctx := context.WithValue(context.Background(), mapKey{}, mCopy) 五、总结 Context 不是 “银弹”，但却是解决 “跨层级信息传递” 的最佳工具。记住这几个核心点：\n定位：Context 是 “全局信息容器”，不是 “业务参数容器”；\n用法：作为函数第一个参数，及时取消，不存大量 / 可变数据；\n避坑：不忽略取消信号，不嵌套过多WithValue，不存业务参数。\n不同语言的 Context 实现略有差异（如 Java 的Context、Python 的ContextVar），但核心思想一致。希望这篇文章能帮你彻底搞懂 Context，写出更简洁、更健壮的代码！\n","permalink":"/blogs/2025/go/deep-dive-into-context-from-concepts-to-practice-avoiding-the-pitfalls.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在并发编程、分布式系统或 Web 开发中，你一定听过 “Context”（上下文）这个词。它像一个 “隐形的信使”，在不同组件、函数或服务间传递关键信息，却常常因为 “看不见摸不着” 被开发者忽视。今天我们就从\u003cstrong\u003e概念解析\u003c/strong\u003e、\u003cstrong\u003e最佳实践\u003c/strong\u003e、\u003cstrong\u003e开源案例\u003c/strong\u003e到\u003cstrong\u003e常见错误\u003c/strong\u003e，彻底搞懂 Context。\u003c/p\u003e","title":"深入理解 Context：从概念到实践，避开那些坑"},{"content":"前言 在分布式系统中，服务关闭环节的稳定性直接影响系统可用性。一个粗糙的关闭流程可能引发请求丢失、数据不一致、资源泄露等问题，而 “优雅关闭”（Graceful Shutdown）通过 “收到停止信号后，先处理存量任务、释放资源，再平稳退出” 的逻辑，成为高可用服务的必备能力。本文将从错误案例切入，拆解核心原则，结合多场景实践与框架应用，完整呈现 Go 优雅关闭的实现方案。\n一、先避坑：“不优雅” 关闭的 3 类典型错误 理解错误做法是设计优雅关闭的前提，以下 3 类案例是实际开发中最易踩的坑：\n错误 1：收到信号直接终止进程（请求丢失） 直接调用os.Exit会强制终止进程，正在处理的任务（如耗时请求）会被中断，客户端可能收到 “连接重置” 或 “502” 错误。\npackage main import ( \u0026#34;log\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; ) func main() { // 模拟耗时5秒的HTTP请求处理 http.HandleFunc(\u0026#34;/\u0026#34;, func(w http.ResponseWriter, r *http.Request) { log.Println(\u0026#34;开始处理请求（预计5秒）\u0026#34;) time.Sleep(5 * time.Second) w.Write([]byte(\u0026#34;处理完成\u0026#34;)) log.Println(\u0026#34;请求处理完毕\u0026#34;) }) // 非阻塞启动服务 go func() { log.Println(\u0026#34;服务启动 on :8080\u0026#34;) http.ListenAndServe(\u0026#34;:8080\u0026#34;, nil) }() // 监听关闭信号（Ctrl+C或kill） quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit // 错误操作：直接退出，中断存量请求 log.Println(\u0026#34;收到信号，立即退出\u0026#34;) os.Exit(0) } 错误 2：忽略超时控制（服务 “关不掉”） http.Server.Shutdown等方法会等待存量任务完成，但若存在无限阻塞的异常任务（如死循环），未设置超时会导致服务卡死在关闭阶段，最终需kill -9强制终止。\npackage main import ( \u0026#34;context\u0026#34; \u0026#34;log\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; ) func main() { srv := \u0026amp;http.Server{Addr: \u0026#34;:8080\u0026#34;} // 模拟无限阻塞的请求（死循环） http.HandleFunc(\u0026#34;/\u0026#34;, func(w http.ResponseWriter, r *http.Request) { select {} // 永远不会退出 }) go srv.ListenAndServe() // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 错误操作：无超时控制，服务可能永久阻塞 log.Println(\u0026#34;开始关闭...\u0026#34;) srv.Shutdown(context.Background()) // 无超时兜底 log.Println(\u0026#34;关闭完成\u0026#34;) // 可能永远不执行 } 错误 3：资源释放顺序颠倒（任务失败） 若先关闭依赖资源（如数据库），再等待存量任务完成，会导致任务执行时因资源不可用报错，违背 “平稳” 原则。\npackage main import ( \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;gorm.io/driver/mysql\u0026#34; \u0026#34;gorm.io/gorm\u0026#34; ) func main() { // 初始化MySQL连接 db, _ := gorm.Open(mysql.Open(\u0026#34;user:pass@tcp(localhost:3306)/db\u0026#34;), \u0026amp;gorm.Config{}) sqlDB, _ := db.DB() // 模拟依赖MySQL的后台任务 done := make(chan struct{}) go func() { defer close(done) for { log.Println(\u0026#34;执行数据库查询...\u0026#34;) time.Sleep(1 * time.Second) // 实际场景：执行db.Query(...) } }() // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 错误操作：先关数据库，再等任务结束（任务会报错） log.Println(\u0026#34;先关闭数据库连接...\u0026#34;) sqlDB.Close() log.Println(\u0026#34;等待任务结束...\u0026#34;) \u0026lt;-done // 任务访问数据库时会提示“connection closed” log.Println(\u0026#34;退出\u0026#34;) } 二、核心原则：优雅关闭 “四步曲” 从错误案例中可提炼出通用流程，无论何种组件，优雅关闭都需遵循以下四步，确保逻辑闭环：\n停接收：停止接收新请求 / 消息（如关闭 HTTP 监听、停止拉取消息队列），避免新任务进入；\n清存量：等待正在处理的存量任务完成，且必须设置超时兜底，防止无限阻塞；\n释资源：关闭数据库、缓存、连接池等依赖资源，释放系统占用；\n稳退出：所有步骤完成后，正常终止进程，避免强制退出。\n三、多场景优雅关闭实践：错误 vs 正确对比 3.1 HTTP 服务：用Shutdown替代强制关闭 HTTP 服务优雅关闭的关键是利用标准库http.Server的Shutdown方法，该方法会先停止接收新请求，再等待存量请求完成。\n错误做法：直接关闭监听 package main import ( \u0026#34;log\u0026#34; \u0026#34;net\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; ) func main() { lis, _ := net.Listen(\u0026#34;tcp\u0026#34;, \u0026#34;:8080\u0026#34;) http.HandleFunc(\u0026#34;/\u0026#34;, func(w http.ResponseWriter, r *http.Request) { time.Sleep(3 * time.Second) // 模拟耗时请求 w.Write([]byte(\u0026#34;处理完成\u0026#34;)) }) srv := \u0026amp;http.Server{} go srv.Serve(lis) // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 错误：直接关闭监听，中断现有连接 lis.Close() log.Println(\u0026#34;退出\u0026#34;) } 正确做法：Shutdown+ 超时控制 package main import ( \u0026#34;context\u0026#34; \u0026#34;log\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; ) func main() { srv := \u0026amp;http.Server{Addr: \u0026#34;:8080\u0026#34;} http.HandleFunc(\u0026#34;/\u0026#34;, func(w http.ResponseWriter, r *http.Request) { log.Println(\u0026#34;开始处理请求\u0026#34;) time.Sleep(3 * time.Second) w.Write([]byte(\u0026#34;请求完成\u0026#34;)) log.Println(\u0026#34;请求处理完毕\u0026#34;) }) // 非阻塞启动服务 go func() { log.Println(\u0026#34;HTTP服务启动 on :8080\u0026#34;) // 仅在非关闭错误时退出（排除http.ErrServerClosed） if err := srv.ListenAndServe(); err != nil \u0026amp;\u0026amp; err != http.ErrServerClosed { log.Fatalf(\u0026#34;服务启动失败: %v\u0026#34;, err) } }() // 监听关闭信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit log.Println(\u0026#34;开始优雅关闭...\u0026#34;) // 设置5秒超时：避免无限等待 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() // 执行优雅关闭 if err := srv.Shutdown(ctx); err != nil { log.Printf(\u0026#34;关闭超时，强制退出: %v\u0026#34;, err) } log.Println(\u0026#34;HTTP服务优雅退出\u0026#34;) } 3.2 gRPC 服务：GracefulStopvsStop gRPC 服务需区分GracefulStop（等待存量请求完成）和Stop（立即终止所有请求），前者才符合优雅关闭要求，且需配合超时兜底。\n错误做法：用Stop强制终止 package main import ( \u0026#34;log\u0026#34; \u0026#34;net\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;google.golang.org/grpc\u0026#34; pb \u0026#34;your/proto/package\u0026#34; // 替换为实际proto包 ) type myServer struct{ pb.UnimplementedDemoServer } // 模拟耗时3秒的gRPC请求处理 func (s *myServer) Process(ctx context.Context, req *pb.Request) (*pb.Response, error) { log.Println(\u0026#34;gRPC开始处理请求（耗时3秒）\u0026#34;) time.Sleep(3 * time.Second) return \u0026amp;pb.Response{Msg: \u0026#34;完成\u0026#34;}, nil } func main() { lis, _ := net.Listen(\u0026#34;tcp\u0026#34;, \u0026#34;:9000\u0026#34;) srv := grpc.NewServer() pb.RegisterDemoServer(srv, \u0026amp;myServer{}) go srv.Serve(lis) // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 错误：Stop立即终止所有请求 srv.Stop() log.Println(\u0026#34;退出\u0026#34;) } 正确做法：GracefulStop+ 超时 package main import ( \u0026#34;log\u0026#34; \u0026#34;net\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;google.golang.org/grpc\u0026#34; pb \u0026#34;your/proto/package\u0026#34; ) type myServer struct{ pb.UnimplementedDemoServer } func (s *myServer) Process(ctx context.Context, req *pb.Request) (*pb.Response, error) { log.Println(\u0026#34;gRPC开始处理请求（耗时3秒）\u0026#34;) time.Sleep(3 * time.Second) return \u0026amp;pb.Response{Msg: \u0026#34;完成\u0026#34;}, nil } func main() { lis, _ := net.Listen(\u0026#34;tcp\u0026#34;, \u0026#34;:9000\u0026#34;) srv := grpc.NewServer() pb.RegisterDemoServer(srv, \u0026amp;myServer{}) go func() { log.Println(\u0026#34;gRPC服务启动 on :9000\u0026#34;) // 排除grpc.ErrServerStopped（正常关闭错误） if err := srv.Serve(lis); err != nil \u0026amp;\u0026amp; err != grpc.ErrServerStopped { log.Fatalf(\u0026#34;服务启动失败: %v\u0026#34;, err) } }() // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit log.Println(\u0026#34;开始优雅关闭...\u0026#34;) // 用goroutine执行GracefulStop（避免阻塞） done := make(chan struct{}) go func() { srv.GracefulStop() // 等待所有存量请求完成 close(done) }() // 5秒超时兜底 select { case \u0026lt;-done: log.Println(\u0026#34;gRPC服务优雅关闭完成\u0026#34;) case \u0026lt;-time.After(5 * time.Second): log.Println(\u0026#34;关闭超时，强制终止\u0026#34;) srv.Stop() } } 3.3 消息队列消费者：避免重复消费 / 丢失 以 Kafka 为例，优雅关闭需确保 “停止拉新消息→处理存量→提交偏移量→关闭连接”，防止已处理消息未提交导致重复消费。\n错误做法：未提交偏移量直接退出 package main import ( \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/Shopify/sarama\u0026#34; // Kafka客户端 ) func main() { // 初始化Kafka消费者 config := sarama.NewConfig() config.Version = sarama.V2_8_1_0 consumer, _ := sarama.NewConsumer([]string{\u0026#34;localhost:9092\u0026#34;}, config) pc, _ := consumer.ConsumePartition(\u0026#34;test-topic\u0026#34;, 0, sarama.OffsetNewest) // 消费消息（未提交偏移量） go func() { for msg := range pc.Messages() { log.Printf(\u0026#34;处理消息: %s (offset: %d)\u0026#34;, msg.Value, msg.Offset) time.Sleep(2 * time.Second) // 模拟处理 // 错误：未提交偏移量，重启后重复消费 } }() // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 错误：直接关闭，未确保偏移量提交 pc.Close() consumer.Close() log.Println(\u0026#34;退出\u0026#34;) } 正确做法：先停消费再提交偏移量 package main import ( \u0026#34;context\u0026#34; \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;sync\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/Shopify/sarama\u0026#34; ) func main() { config := sarama.NewConfig() config.Version = sarama.V2_8_1_0 consumer, _ := sarama.NewConsumer([]string{\u0026#34;localhost:9092\u0026#34;}, config) pc, _ := consumer.ConsumePartition(\u0026#34;test-topic\u0026#34;, 0, sarama.OffsetNewest) defer consumer.Close() // 最终关闭消费者 var wg sync.WaitGroup ctx, cancel := context.WithCancel(context.Background()) wg.Add(1) go func() { defer wg.Done() for { select { case msg := \u0026lt;-pc.Messages(): log.Printf(\u0026#34;处理消息: %s (offset: %d)\u0026#34;, msg.Value, msg.Offset) time.Sleep(2 * time.Second) // 处理完成后提交偏移量（下一次从offset+1开始） _, err := consumer.CommitOffset(\u0026amp;sarama.OffsetCommitRequest{ Topic: msg.Topic, Partition: msg.Partition, Offset: msg.Offset + 1, }) if err != nil { log.Printf(\u0026#34;提交偏移量失败: %v\u0026#34;, err) } case \u0026lt;-ctx.Done(): log.Println(\u0026#34;停止接收新消息，等待存量处理\u0026#34;) return } } }() // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit log.Println(\u0026#34;开始关闭消费者...\u0026#34;) // 1. 停止接收新消息 cancel() // 2. 等待存量消息处理完成 wg.Wait() // 3. 关闭分区消费者 pc.Close() log.Println(\u0026#34;消费者优雅退出\u0026#34;) } 3.4 第三方依赖：数据库 / 缓存的释放 数据库（MySQL）、缓存（Redis）等依赖需在 “存量任务完成后” 关闭，避免任务执行时资源不可用。\n错误做法：提前关闭资源 package main import ( \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;sync\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/go-redis/redis/v8\u0026#34; \u0026#34;gorm.io/driver/mysql\u0026#34; \u0026#34;gorm.io/gorm\u0026#34; ) func main() { // 初始化资源 db, _ := gorm.Open(mysql.Open(\u0026#34;user:pass@tcp(localhost:3306)/db\u0026#34;), \u0026amp;gorm.Config{}) sqlDB, _ := db.DB() redisClient := redis.NewClient(\u0026amp;redis.Options{Addr: \u0026#34;localhost:6379\u0026#34;}) // 模拟依赖资源的任务 var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() log.Println(\u0026#34;任务开始：查询数据库和Redis\u0026#34;) time.Sleep(3 * time.Second) log.Println(\u0026#34;任务完成\u0026#34;) }() // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 错误：先关资源，再等任务（任务会报错） log.Println(\u0026#34;先关闭数据库和Redis...\u0026#34;) sqlDB.Close() redisClient.Close() log.Println(\u0026#34;等待任务完成...\u0026#34;) wg.Wait() log.Println(\u0026#34;退出\u0026#34;) } 正确做法：任务完成后释放资源 package main import ( \u0026#34;context\u0026#34; \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;sync\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/go-redis/redis/v8\u0026#34; \u0026#34;gorm.io/driver/mysql\u0026#34; \u0026#34;gorm.io/gorm\u0026#34; ) func main() { // 初始化资源 db, _ := gorm.Open(mysql.Open(\u0026#34;user:pass@tcp(localhost:3306)/db\u0026#34;), \u0026amp;gorm.Config{}) sqlDB, _ := db.DB() redisClient := redis.NewClient(\u0026amp;redis.Options{Addr: \u0026#34;localhost:6379\u0026#34;}) // 模拟任务 var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() log.Println(\u0026#34;任务开始：查询数据库和Redis\u0026#34;) time.Sleep(3 * time.Second) log.Println(\u0026#34;任务完成\u0026#34;) }() // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit log.Println(\u0026#34;开始关闭...\u0026#34;) // 1. 等待任务完成 wg.Wait() // 2. 带超时关闭资源 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() // 关闭MySQL连接池 if err := sqlDB.Close(); err != nil { log.Printf(\u0026#34;MySQL关闭错误: %v\u0026#34;, err) } // 关闭Redis连接 if err := redisClient.Close(); err != nil { log.Printf(\u0026#34;Redis关闭错误: %v\u0026#34;, err) } log.Println(\u0026#34;资源关闭完成，服务退出\u0026#34;) } 3.5 直接go协程：用WaitGroup+Context跟踪生命周期 直接通过go关键字启动的协程若不跟踪，关闭时会导致任务中断或资源泄露。核心是用sync.WaitGroup统计协程数量，context.Context传递关闭信号。\n错误做法：不跟踪协程，直接退出 package main import ( \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; ) func main() { // 错误：直接启动协程，无跟踪机制 for i := 0; i \u0026lt; 5; i++ { go func(id int) { for { log.Printf(\u0026#34;协程%d：处理任务（耗时1秒）\u0026#34;, id) time.Sleep(1 * time.Second) // 若此时收到关闭信号，协程会被强制中断 } }(i) } // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 错误：直接退出，未等待协程完成 log.Println(\u0026#34;收到信号，立即退出\u0026#34;) os.Exit(0) } 问题分析：未跟踪协程生命周期，收到信号后直接退出，导致协程中未完成的任务（如数据写入、文件操作）中断，可能引发数据不一致。\n正确做法：WaitGroup等待 + Context取消 package main import ( \u0026#34;context\u0026#34; \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;sync\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; ) func main() { // 1. 创建Context传递关闭信号，WaitGroup统计协程 ctx, cancel := context.WithCancel(context.Background()) var wg sync.WaitGroup // 2. 启动协程并注册到WaitGroup for i := 0; i \u0026lt; 5; i++ { wg.Add(1) go func(id int) { defer wg.Done() // 协程退出时标记完成 for { select { case \u0026lt;-ctx.Done(): // 收到关闭信号，退出协程 log.Printf(\u0026#34;协程%d：收到关闭信号，停止任务\u0026#34;, id) return default: // 正常处理任务 log.Printf(\u0026#34;协程%d：处理任务（耗时1秒）\u0026#34;, id) time.Sleep(1 * time.Second) } } }(i) } // 3. 监听关闭信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit log.Println(\u0026#34;开始优雅关闭协程...\u0026#34;) // 4. 发送关闭信号，等待所有协程完成（带超时） cancel() // 通知协程停止新任务 done := make(chan struct{}) go func() { wg.Wait() // 等待所有协程完成存量任务 close(done) }() // 5. 超时兜底：避免协程无限阻塞 select { case \u0026lt;-done: log.Println(\u0026#34;所有协程优雅退出\u0026#34;) case \u0026lt;-time.After(3 * time.Second): log.Println(\u0026#34;协程关闭超时，强制退出\u0026#34;) } log.Println(\u0026#34;服务退出\u0026#34;) } 关键逻辑：\nContext：通过cancel()向所有协程广播关闭信号，协程通过ctx.Done()接收信号后停止新任务；\nWaitGroup：通过Add(1)和Done()统计协程数量，确保所有存量任务完成；\n超时控制：避免协程因异常（如死循环）导致服务无法退出。\n3.6 线程池（工作池）：停止入队 + 等待出队 线程池（工作池）通常包含 “任务队列” 和 “工作协程”，优雅关闭需确保：停止接收新任务→处理完队列中存量任务→关闭工作协程。\n错误做法：直接关闭任务队列，中断存量任务 package main import ( \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; ) // 错误的工作池实现：无优雅关闭机制 type BadWorkerPool struct { taskChan chan func() // 任务队列 } func NewBadWorkerPool(workerNum int) *BadWorkerPool { pool := \u0026amp;BadWorkerPool{ taskChan: make(chan func(), 100), // 带缓冲的任务队列 } // 启动工作协程 for i := 0; i \u0026lt; workerNum; i++ { go func(id int) { for task := range pool.taskChan { // 处理任务（若此时关闭taskChan，会 panic 或中断任务） log.Printf(\u0026#34;工作协程%d：执行任务\u0026#34;, id) task() } }(i) } return pool } // 提交任务到队列 func (p *BadWorkerPool) Submit(task func()) { p.taskChan \u0026lt;- task } func main() { pool := NewBadWorkerPool(3) // 3个工作协程 // 提交10个任务（每个任务耗时1秒） for i := 0; i \u0026lt; 10; i++ { taskID := i pool.Submit(func() { time.Sleep(1 * time.Second) log.Printf(\u0026#34;任务%d：执行完成\u0026#34;, taskID) }) } // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 错误：直接关闭任务队列，导致未处理的任务丢失，工作协程 panic close(pool.taskChan) log.Println(\u0026#34;收到信号，立即退出\u0026#34;) os.Exit(0) } 问题分析：直接关闭任务队列taskChan，会导致：\n队列中未处理的任务丢失；\n工作协程从已关闭的通道接收数据时触发panic；\n正在处理的任务被强制中断。\n正确做法：停止入队 + 等待存量任务处理 package main import ( \u0026#34;context\u0026#34; \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;sync\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; ) // 正确的工作池实现：支持优雅关闭 type WorkerPool struct { ctx context.Context cancel context.CancelFunc taskChan chan func() wg sync.WaitGroup // 等待工作协程完成 isStopped bool // 标记是否已停止接收新任务 stopMutex sync.Mutex // 保护isStopped的并发访问 } // 新建工作池：workerNum=工作协程数，bufSize=任务队列缓冲大小 func NewWorkerPool(workerNum int, bufSize int) *WorkerPool { ctx, cancel := context.WithCancel(context.Background()) pool := \u0026amp;WorkerPool{ ctx: ctx, cancel: cancel, taskChan: make(chan func(), bufSize), } // 启动工作协程 pool.wg.Add(workerNum) for i := 0; i \u0026lt; workerNum; i++ { go func(id int) { defer pool.wg.Done() pool.workerLoop(id) // 工作协程循环处理任务 }(i) } return pool } // 工作协程循环：处理任务直到收到关闭信号 func (p *WorkerPool) workerLoop(id int) { for { select { case \u0026lt;-p.ctx.Done(): // 收到关闭信号，处理完当前任务后退出 log.Printf(\u0026#34;工作协程%d：收到关闭信号，停止处理新任务\u0026#34;, id) // 检查队列中是否还有存量任务（可选：处理完存量再退出） for len(p.taskChan) \u0026gt; 0 { task := \u0026lt;-p.taskChan log.Printf(\u0026#34;工作协程%d：处理队列剩余任务\u0026#34;, id) task() } return case task, ok := \u0026lt;-p.taskChan: if !ok { return // 任务队列关闭（一般不会走到这，因先通过ctx控制） } // 正常处理任务 log.Printf(\u0026#34;工作协程%d：执行任务\u0026#34;, id) task() } } } // 提交任务：若已停止则拒绝提交 func (p *WorkerPool) Submit(task func()) error { p.stopMutex.Lock() defer p.stopMutex.Unlock() if p.isStopped { return fmt.Errorf(\u0026#34;工作池已停止，无法提交新任务\u0026#34;) } select { case p.taskChan \u0026lt;- task: return nil case \u0026lt;-p.ctx.Done(): return fmt.Errorf(\u0026#34;工作池已关闭，任务提交失败\u0026#34;) } } // 优雅关闭：停止接收新任务→等待工作协程完成 func (p *WorkerPool) Shutdown(timeout time.Duration) error { // 1. 标记为已停止，拒绝新任务 p.stopMutex.Lock() p.isStopped = true p.stopMutex.Unlock() log.Println(\u0026#34;工作池开始优雅关闭：停止接收新任务\u0026#34;) // 2. 发送关闭信号给工作协程 p.cancel() // 3. 等待工作协程完成（带超时） done := make(chan struct{}) go func() { p.wg.Wait() // 等待所有工作协程处理完存量任务 close(p.taskChan) // 所有任务处理完后，关闭任务队列 close(done) }() select { case \u0026lt;-done: log.Println(\u0026#34;工作池优雅关闭完成\u0026#34;) return nil case \u0026lt;-time.After(timeout): return fmt.Errorf(\u0026#34;工作池关闭超时（%v）\u0026#34;, timeout) } } func main() { // 初始化工作池：3个工作协程，任务队列缓冲100 pool := NewWorkerPool(3, 100) defer pool.Shutdown(5 * time.Second) // 退出时优雅关闭 // 提交10个任务（每个任务耗时1秒） for i := 0; i \u0026lt; 10; i++ { taskID := i if err := pool.Submit(func() { time.Sleep(1 * time.Second) log.Printf(\u0026#34;任务%d：执行完成\u0026#34;, taskID) }); err != nil { log.Printf(\u0026#34;任务%d提交失败：%v\u0026#34;, taskID, err) } } // 监听关闭信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit log.Println(\u0026#34;收到关闭信号，触发工作池关闭\u0026#34;) // 执行优雅关闭 if err := pool.Shutdown(5 * time.Second); err != nil { log.Printf(\u0026#34;工作池关闭超时：%v\u0026#34;, err) } log.Println(\u0026#34;服务退出\u0026#34;) } 关键逻辑：\n停止入队：通过isStopped标记和互斥锁，拒绝关闭后提交的新任务； 存量处理：工作协程收到ctx.Done()信号后，先处理完任务队列中剩余的存量任务，再退出； 安全关闭：所有工作协程完成后才关闭任务队列，避免panic； 超时控制：防止工作协程因异常任务无限阻塞，确保服务能按时退出。 3.7 Docker Compose 环境：避免超时被强制 kill Docker Compose 默认存在优雅关闭超时机制：发送SIGTERM信号后等待 10 秒，若服务未主动退出，则发送SIGKILL强制终止。若 Go 服务的优雅关闭逻辑耗时超过 10 秒，会被强制中断，导致优雅关闭失效。\n错误做法：忽略 Compose 超时，优雅关闭被强制终止 需准备三部分文件：Go 服务代码（优雅关闭超时 15 秒）、Dockerfile（构建镜像）、docker-compose.yml（默认配置）。\nGo 服务代码（graceful.go）：优雅关闭超时 15 秒，超过 Compose 默认 10 秒 package main import ( \u0026#34;context\u0026#34; \u0026#34;log\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; ) func main() { srv := \u0026amp;http.Server{Addr: \u0026#34;:8080\u0026#34;} // 模拟耗时8秒的请求（存量任务需处理） http.HandleFunc(\u0026#34;/\u0026#34;, func(w http.ResponseWriter, r *http.Request) { log.Println(\u0026#34;开始处理请求（耗时8秒）\u0026#34;) time.Sleep(8 * time.Second) w.Write([]byte(\u0026#34;处理完成\u0026#34;)) log.Println(\u0026#34;请求处理完毕\u0026#34;) }) // 非阻塞启动服务 go func() { log.Println(\u0026#34;服务启动 on :8080\u0026#34;) if err := srv.ListenAndServe(); err != nil \u0026amp;\u0026amp; err != http.ErrServerClosed { log.Fatalf(\u0026#34;启动失败: %v\u0026#34;, err) } }() // 监听关闭信号（Compose会发送SIGTERM） quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit log.Println(\u0026#34;开始优雅关闭（超时15秒）...\u0026#34;) // 优雅关闭超时15秒（超过Compose默认10秒） ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() if err := srv.Shutdown(ctx); err != nil { log.Printf(\u0026#34;关闭失败: %v\u0026#34;, err) // 会打印“context deadline exceeded” } log.Println(\u0026#34;服务优雅退出\u0026#34;) // 这行不会执行，因被SIGKILL强制终止 } Dockerfile：构建最小化 Go 镜像 # 构建阶段 FROM golang:1.21-alpine AS builder WORKDIR /app COPY go.mod go.sum ./ RUN go mod init graceful-demo \u0026amp;\u0026amp; go mod tidy COPY graceful.go ./ # 静态编译（避免依赖系统库） RUN CGO_ENABLED=0 GOOS=linux go build -o graceful-server . # 运行阶段（最小镜像） FROM alpine:3.18 WORKDIR /app COPY --from=builder /app/graceful-server . # 确保Go服务接收SIGTERM（作为容器PID 1进程） CMD [\u0026#34;./graceful-server\u0026#34;] docker-compose.yml（默认配置）：未设置stop_grace_period version: \u0026#39;3.8\u0026#39; services: graceful-service: build: . ports: - \u0026#34;8080:8080\u0026#34; # 未配置stop_grace_period，默认10秒 问题复现与分析：\n启动服务：docker-compose up -d --build\n发送请求（触发存量任务）：curl ``http://localhost:8080\n停止服务：docker-compose down\n查看日志：docker-compose logs graceful-service\n日志会显示：\n收到SIGTERM信号，开始优雅关闭；\n处理存量请求（耗时 8 秒），但仅 10 秒后被SIGKILL强制终止；\n最终打印signal: killed，且 “服务优雅退出” 未输出。\n核心原因：Compose 10 秒超时后强制 kill，Go 服务未完成优雅关闭流程。\n正确做法：适配 Compose 超时配置 有两种方案：缩短 Go 服务优雅关闭超时（适配默认 10 秒），或延长 Compose 超时（适配长耗时优雅关闭）。\n方案 1：缩短 Go 服务超时（适配默认 10 秒） 修改 Go 服务的优雅关闭超时为 8 秒（小于默认 10 秒），确保在 Compose 超时内完成：\n// 优雅关闭超时8秒（\u0026lt; 10秒） ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second) 启动并停止服务后，日志会完整打印 “服务优雅退出”，无SIGKILL信息。\n方案 2：延长 Compose 超时（适配长耗时） 若 Go 服务需更长时间优雅关闭（如 15 秒），修改docker-compose.yml的stop_grace_period为 20 秒：\nversion: \u0026#39;3.8\u0026#39; services: graceful-service: build: . ports: - \u0026#34;8080:8080\u0026#34; stop_grace_period: 20s # 延长超时到20秒，适配15秒优雅关闭 Go 服务保持 15 秒超时，停止后日志会显示完整优雅关闭流程，无强制 kill。\n关键补充：确保信号传递正常\nGo 服务需作为容器内 PID 1 进程（如 Dockerfile 中CMD [\u0026quot;./graceful-server\u0026quot;]，无 shell 包裹），否则SIGTERM会被 shell 拦截，无法触发优雅关闭；\n若需启动多个进程，需用 init 系统（如tini）转发信号，示例 Dockerfile 调整：\n# 运行阶段添加tini FROM alpine:3.18 RUN apk add --no-cache tini WORKDIR /app COPY --from=builder /app/graceful-server . # 用tini作为PID 1，转发信号给Go服务 CMD [\u0026#34;tini\u0026#34;, \u0026#34;--\u0026#34;, \u0026#34;./graceful-server\u0026#34;] 四、主流框架优雅关闭：Gin 与 Kratos 框架通常封装了基础逻辑，开发者只需按规范使用，减少重复编码。\n4.1 Gin 框架：用http.Server包装 Gin 基于标准库net/http，需通过http.Server包装引擎，才能使用Shutdown实现优雅关闭。\n错误做法：直接用r.Run() package main import ( \u0026#34;log\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/gin-gonic/gin\u0026#34; ) func main() { r := gin.Default() r.GET(\u0026#34;/\u0026#34;, func(c *gin.Context) { time.Sleep(3 * time.Second) c.String(200, \u0026#34;处理完成\u0026#34;) }) // 错误：r.Run()内部阻塞，无关闭接口 go r.Run(\u0026#34;:8080\u0026#34;) // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT) \u0026lt;-quit // 无法优雅关闭，只能强制退出 log.Println(\u0026#34;退出\u0026#34;) os.Exit(0) } 正确做法：http.Server包装 Gin 引擎 package main import ( \u0026#34;context\u0026#34; \u0026#34;log\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;os\u0026#34; \u0026#34;os/signal\u0026#34; \u0026#34;syscall\u0026#34; \u0026#34;time\u0026#34; \u0026#34;github.com/gin-gonic/gin\u0026#34; ) func main() { r := gin.Default() r.GET(\u0026#34;/\u0026#34;, func(c *gin.Context) { log.Println(\u0026#34;Gin开始处理请求\u0026#34;) time.Sleep(3 * time.Second) c.String(200, \u0026#34;完成\u0026#34;) log.Println(\u0026#34;Gin请求处理完毕\u0026#34;) }) // 关键：用http.Server包装Gin srv := \u0026amp;http.Server{ Addr: \u0026#34;:8080\u0026#34;, Handler: r, } // 非阻塞启动 go func() { log.Println(\u0026#34;Gin服务启动 on :8080\u0026#34;) if err := srv.ListenAndServe(); err != nil \u0026amp;\u0026amp; err != http.ErrServerClosed { log.Fatalf(\u0026#34;启动失败: %v\u0026#34;, err) } }() // 监听信号 quit := make(chan os.Signal, 1) signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) \u0026lt;-quit log.Println(\u0026#34;开始优雅关闭...\u0026#34;) // 优雅关闭（与标准库一致） ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() if err := srv.Shutdown(ctx); err != nil { log.Printf(\u0026#34;关闭超时: %v\u0026#34;, err) } log.Println(\u0026#34;Gin服务优雅退出\u0026#34;) } 4.2 Kratos 框架：注册关闭钩子 Kratos内置信号处理与优雅关闭逻辑，只需注册HookStop钩子释放资源。\n错误做法：未注册关闭钩子 package main import ( \u0026#34;log\u0026#34; \u0026#34;github.com/go-kratos/kratos/v2\u0026#34; \u0026#34;github.com/go-kratos/kratos/v2/transport/http\u0026#34; \u0026#34;gorm.io/gorm\u0026#34; ) func main() { // 初始化HTTP服务 httpSrv := http.NewServer(http.Address(\u0026#34;:8080\u0026#34;)) // 初始化数据库（未注册关闭逻辑） db, _ := gorm.Open(...) // 连接数据库 sqlDB, _ := db.DB() // 创建Kratos应用 app := kratos.New(kratos.Server(httpSrv)) // 错误：未注册HookStop，服务关闭时sqlDB未释放 if err := app.Run(); err != nil { log.Fatal(err) } } 正确做法：注册HookStop释放资源 package main import ( \u0026#34;log\u0026#34; \u0026#34;github.com/go-kratos/kratos/v2\u0026#34; \u0026#34;github.com/go-kratos/kratos/v2/transport/http\u0026#34; \u0026#34;gorm.io/gorm\u0026#34; ) func main() { httpSrv := http.NewServer(http.Address(\u0026#34;:8080\u0026#34;)) // 初始化数据库 db, _ := gorm.Open(...) sqlDB, _ := db.DB() // 创建应用并注册关闭钩子 app := kratos.New( kratos.Name(\u0026#34;kratos-demo\u0026#34;), kratos.Server(httpSrv), ) // HookStop：服务关闭时执行（释放资源） app.RegisterHook(kratos.HookStop(func() error { log.Println(\u0026#34;关闭数据库连接...\u0026#34;) return sqlDB.Close() })) // Kratos自动处理： // 1. 监听SIGINT/SIGTERM信号； // 2. 停止服务（不接收新请求）； // 3. 执行HookStop钩子； // 4. 平稳退出。 if err := app.Run(); err != nil { log.Fatal(err) } } 五、验证优雅关闭：4 类关键测试 优雅关闭需通过实际测试验证，避免 “逻辑正确但落地失效”：\n耗时请求测试：创建耗时 5 秒的接口，调用接口后立即发送kill \u0026lt;pid\u0026gt;信号，观察日志是否打印 “处理完成” 后再退出；\n资源残留检查：关闭服务后，用lsof -i :端口检查端口是否释放，数据库用show processlist确认连接数归零；\n超时场景测试：写一个无限阻塞的请求，触发关闭后观察是否在超时时间（如 5 秒）后强制退出；\n重复消费测试：消费 Kafka 消息并提交偏移量，关闭服务后重启，检查是否重复消费已处理的消息；\n协程 / 线程池测试：启动多个协程或工作池任务，触发关闭后观察是否所有存量任务完成，无协程泄漏（可通过pprof查看协程数量）。\n六、总结：优雅关闭的 5 个核心要点 信号处理是起点：通过os/signal监听SIGINT（Ctrl+C）和SIGTERM（kill 命令），触发关闭流程；\n四步曲是核心：严格遵循 “停接收→清存量→释资源→稳退出”，确保流程闭环；\n超时控制是底线：所有等待步骤（如Shutdown、GracefulStop、协程等待）必须设置超时，避免服务 “关不掉”；\n资源顺序要牢记：先关闭对外服务（HTTP/gRPC/ 任务入队），再处理存量任务（协程 / 工作池），最后释放依赖资源（数据库 / 缓存）；\n组件特性要适配：\n直接协程：用WaitGroup+Context跟踪生命周期；\n线程池：先停入队、再清队列、最后关协程；\n框架：Gin 需http.Server包装，Kratos 注册HookStop，借助框架减少重复开发。\n优雅关闭不是 “可选功能”，而是高可用服务的基础 —— 服务总有重启、升级的时刻，只有能平稳退出的服务，才能在分布式系统中真正保障数据一致性与用户体验。\n","permalink":"/blogs/2025/go/go-graceful-shutdown-guide---principles-to-framework-deployment.html","summary":"\u003ch2 id=\"前言\"\u003e前言\u003c/h2\u003e\n\u003cp\u003e在分布式系统中，服务关闭环节的稳定性直接影响系统可用性。一个粗糙的关闭流程可能引发请求丢失、数据不一致、资源泄露等问题，而 “优雅关闭”（Graceful Shutdown）通过 “收到停止信号后，先处理存量任务、释放资源，再平稳退出” 的逻辑，成为高可用服务的必备能力。本文将从错误案例切入，拆解核心原则，结合多场景实践与框架应用，完整呈现 Go 优雅关闭的实现方案。\u003c/p\u003e","title":"Go 优雅关闭实践指南：从原理到框架落地"},{"content":"Rocky: No such file or directory 今天遇到一个很诡异的问题，在 Rocky Linux 系统上明明看到可执行文件就在眼前，运行时却提示 “No such file or directory”，折腾了半天终于找到原因，记录一下过程。\n问题现象：文件存在却 “消失” 了 事情是这样的，我在服务器上部署一个叫config-gray的程序，通过ll命令明明能看到文件存在，而且权限也是对的（rwxr-xr-x）：\n[root@xx config-gray]# ll config-gray -rwxr-xr-x 1 root root 18061992 Feb 25 20:34 config-gray 但当我执行./config-gray时，却报了个让人费解的错：\n[root@xx config-gray]# ./config-gray bash: ./config-gray: No such file or directory 这就很离谱了 —— 文件明明在这儿，怎么会 “找不到”？\n对比测试：CentOS 的错误更直白 为了排查问题，我在另一台 CentOS 7 服务器上试了下，同样的文件，报错信息稍微不一样：\n[root@master config-gray]# ./config-gray -bash: ./config-gray: /lib/ld-musl-x86_64.so.1: bad ELF interpreter: No such file or directory 这次的错误清晰多了：找不到/lib/ld-musl-x86_64.so.1这个 ELF 解释器。\n原因分析：不是文件找不到，是依赖缺了 结合两个系统的报错，终于理清了头绪：\n第一个 Rocky 系统的 “文件不存在” 其实是个误导性错误。本质是系统找不到程序运行所需的动态链接器（解释器），导致操作系统无法加载程序，于是 “误以为” 文件不存在。 CentOS 的报错直接点出了核心：程序依赖musl libc的动态链接器（ld-musl-x86_64.so.1），但我的 Rocky 和 CentOS 系统默认装的是glibc，没有musl的相关库，所以找不到。 再看一下编译命令，问题可能出在这里：\nCGO_ENABLED=1 go build -o config-gray -a -ldflags \u0026#34;-extldflags \\\u0026#34;-static\\\u0026#34;\u0026#34; -mod=vendor . 虽然加了-static参数想静态编译，但CGO_ENABLED=1开启了 CGO，可能导致编译时依赖了系统的musl libc（比如编译环境用了 Alpine 系统，默认是 musl），最终生成的二进制不是纯静态的，依然依赖 musl 的动态链接器。\n解决方法：两种思路 1. 安装 musl 依赖（临时解决） 如果只是想让程序在现有系统运行，可以直接安装musl相关库：\nRocky/CentOS 7+ 可以通过 EPEL 源安装：\n# 先启用EPEL源 yum install -y epel-release # 安装musl-libs yum install -y musl-libs 安装后再运行./config-gray，就能正常执行了。\n2. 重新编译为纯静态程序（彻底解决） 更根本的方法是调整编译参数，生成不依赖系统 libc 的纯静态二进制：\n# 关闭CGO，使用Go自带的标准库（不依赖系统libc） CGO_ENABLED=0 go build -o config-gray -a -ldflags \u0026#34;-s -w\u0026#34; -mod=vendor . CGO_ENABLED=0：禁用 CGO，避免依赖系统 libc（不管是 glibc 还是 musl） -s -w：移除符号表和调试信息，减小二进制体积 总结 这次踩坑让我明白：遇到 “文件存在却提示找不到” 的情况，别光看文件本身，很大可能是程序依赖的动态链接库或解释器缺失。尤其是跨系统部署时，不同 Linux 发行版的 libc（glibc/musl）差异可能导致这类问题，编译时尽量用纯静态编译（CGO_ENABLED=0）能减少很多麻烦。\n","permalink":"/blogs/2025/go/go-binary-no-such-file-or-directory.html","summary":"\u003ch1 id=\"rocky-no-such-file-or-directory\"\u003eRocky: No such file or directory\u003c/h1\u003e\n\u003cp\u003e今天遇到一个很诡异的问题，在 Rocky Linux 系统上明明看到可执行文件就在眼前，运行时却提示 “No such file or directory”，折腾了半天终于找到原因，记录一下过程。\u003c/p\u003e","title":"Rocky: No such file or directory"},{"content":"目录 前言 分支管理规范 提交信息规范 团队协作流程 代码合并与版本管理 冲突处理规范 工具与自动化配置 常见问题与解决方案 附则 1. 前言 Git 作为分布式版本控制系统，其高效性依赖于团队统一的操作规范。本规范基于行业最佳实践（如 Git Flow、Conventional Commits），结合团队协作场景优化，旨在解决以下问题：\n分支混乱导致的版本追溯困难 提交信息模糊引发的历史理解成本高 协作中冲突频发、代码覆盖风险 发布流程不规范导致的生产环境稳定性问题 执行原则：规范不是约束，而是协作共识，需团队全员遵守并定期迭代优化。\n2. 分支管理规范 采用 “主分支 + 支持分支” 的分层模型，明确各分支的职责、生命周期及命名规则，避免分支冗余。\n2.1 分支类型与定义 分支类型 命名规则 来源分支 合并目标分支 生命周期 核心职责 主分支 main 项目初始化 仅接收 hotfix/release 永久存在 存放生产环境代码，始终保持可部署状态 开发主分支 develop 从 main 创建 接收 feature，合并到 release 永久存在 整合功能开发代码，作为下一次发布的基础 功能分支 feature/[需求ID]-[功能描述] develop 仅合并到 develop 功能合并后删除 开发新功能或迭代优化，隔离开发过程 紧急修复分支 hotfix/[BUG ID]-[修复描述] main 合并到 main + develop 修复完成后删除 紧急修复生产环境 bug，不影响正常开发流程 发布分支 release/[版本号] develop 合并到 main + develop 发布完成后删除 预发布测试，仅修复测试中发现的 bug，不新增功能 测试分支（可选） test/[测试场景]-[日期] 任意开发分支 不合并到主分支 测试完成后删除 临时测试特定场景（如性能测试、兼容性测试） 2.2 命名规范细则 需求 ID/BUG ID：必须关联团队需求管理工具（如 Jira、Teambition）的唯一 ID，便于追溯（例：REQ-2024001、BUG-2024058）。 功能描述：使用小写字母 + 连字符，不超过 5 个单词，清晰表达核心内容（例：user-login-verify 而非 login）。 版本号：遵循语义化版本（见 5.1 节），格式为 vX.Y.Z（例：release/v2.3.0）。 2.3 分支保护规则 main 和 develop 分支设置为 保护分支，禁止直接推送（git push），仅允许通过 PR 合并。 保护分支需启用 强制代码审查（至少 1 名审查人通过）和 CI 检查通过 才能合并。 功能分支、hotfix 分支等临时分支，由创建者负责维护，合并后需及时删除（远程 + 本地）。 3. 提交信息规范 提交信息是代码历史的 “说明书”，需遵循 Conventional Commits 规范，确保结构化、可追溯，支持自动化工具生成 CHANGELOG。\n3.1 提交格式模板 \u0026lt;类型\u0026gt;[可选作用域]: \u0026lt;简短描述\u0026gt; [可选详细描述] [可选脚注] 3.2 各部分说明 组成部分 要求与说明 类型（必填） 描述提交的性质，取值范围：\n- feat：新功能（影响次版本号）\n- fix：修复 bug（影响修订号）\n- docs：仅文档修改（如 README）\n- style：代码格式调整（不影响逻辑，如缩进、空格）\n- refactor：代码重构（既非新功能也非修复）\n- test：新增 / 修改测试代码\n- chore：构建流程、工具配置等修改（不影响业务代码） 作用域（可选） 标注修改涉及的模块 / 组件（如 auth、order-api、pay-service），增强定位精度。 简短描述（必填） 50 字以内，简洁说明 “做了什么”，首字母小写，不使用句号结尾（例：“新增短信验证码校验”）。 详细描述（可选） 若简短描述不够，补充具体修改点（如 “优化了验证码过期逻辑，从 5 分钟调整为 10 分钟”），换行后开始。 脚注（可选） 关联需求 / BUG ID 或关闭 Issue，格式：\n- 关联需求：Relates to REQ-2024001\n- 关闭 BUG：Closes BUG-2024058 - 关闭 Issue：Fixes #123（GitLab Issue） 3.3 提交示例 # 新功能提交 feat(auth): 新增短信验证码登录功能 - 开发验证码发送接口（支持60秒重试限制） - 完善登录状态校验逻辑（过期自动登出） Relates to REQ-2024001 # Bug修复提交 fix(order): 修复订单超时后状态未同步的问题 解决了支付超时后，订单仍显示\u0026#34;待支付\u0026#34;的问题（原逻辑未监听支付回调超时事件） Closes BUG-2024058 # 重构提交 refactor(pay): 拆分支付服务冗余代码 将支付验签逻辑抽离为独立工具类，减少重复代码约200行 3.4 提交要求 单次提交粒度：一个提交对应一个独立变更（如 “完成登录按钮 UI”、“修复验证码校验 bug”），避免 “大杂烩” 提交（禁止一次提交包含多个不相关功能）。 提交前检查：本地执行代码格式化（如prettier）、 lint 检查（如eslint）、单元测试，确保无语法错误和逻辑问题。 禁止提交的内容：敏感信息（密钥、密码）、编译产物（如dist、node_modules）、IDE 配置（如.idea，需加入.gitignore）。 4. 团队协作流程 4.1 功能开发流程（标准流程） 步骤 1：准备分支 # 1. 切换到develop分支，拉取最新代码 git checkout develop git pull origin develop # 2. 基于最新develop创建功能分支（命名见2.2节） git checkout -b feature/REQ-2024001-user-login 步骤 2：本地开发与提交 按 “小步提交” 原则，完成一个子功能即提交（如 “完成验证码输入框 UI”→“完成验证码发送逻辑”）。 提交信息严格遵循 3.1 节格式。 步骤 3：同步远程代码（每日至少 1 次） 为避免分支偏离develop过远导致冲突，需定期同步：\n# 切换到功能分支 git checkout feature/REQ-2024001-user-login # 同步develop最新代码（推荐使用rebase保持线性历史） git fetch origin develop git rebase origin/develop # 若出现冲突，解决后继续rebase git add . git rebase --continue # 推送更新到远程功能分支（首次推送需关联，后续直接push） git push -u origin feature/REQ-2024001-user-login # 首次 git push origin feature/REQ-2024001-user-login # 后续 步骤 4：发起 PR（Pull Request） 在代码管理平台（GitLab）创建 PR，目标分支为develop。\nPR 标题格式：[feature] 功能名称（需求ID）（例：[feature] 用户登录功能（REQ-2024001））。\nPR 描述模板（必填）：\n## 功能说明 （简要描述实现的功能，关联需求文档链接） ## 测试步骤 1. 步骤1（如：访问登录页） 2. 步骤2（如：输入手机号点击发送验证码） ## 变更范围 - 修改文件：（列举核心修改文件） - 新增依赖：（如有） ## 相关链接 - 需求地址：[REQ-2024001](链接) - 测试报告：（如有） 步骤 5：代码审查与合并 至少指定 1 名团队成员作为审查人（建议交叉审查，避免自我审查）。 审查重点： 代码逻辑是否符合需求 代码风格是否符合团队规范（命名、注释、格式） 测试用例是否覆盖核心场景 是否引入性能隐患或安全风险 审查通过且 CI 检查（编译、测试、lint）通过后，使用 Squash Merge 合并（将功能分支的多个提交压缩为 1 个，保持develop历史整洁）。 步骤 6：清理分支 合并后删除远程和本地功能分支：\n# 删除远程分支 git push origin --delete feature/REQ-2024001-user-login # 删除本地分支 git checkout develop git pull origin develop # 同步合并后的develop git branch -d feature/REQ-2024001-user-login 4.2 生产环境紧急修复流程 用于修复main分支（生产环境）的紧急 bug，需同时确保修复同步到开发分支。\n步骤 1：创建 hotfix 分支 # 从main分支拉取最新代码（生产环境代码） git checkout main git pull origin main # 创建hotfix分支 git checkout -b hotfix/BUG-2024058-order-timeout 步骤 2：修复与提交 仅提交与 bug 修复相关的代码，禁止新增功能。 提交信息类型为fix，并关联 BUG ID。 步骤 3：发起 PR 并合并 同时创建两个 PR：目标分支分别为main（修复生产）和develop（同步到开发）。 PR 标题格式：[hotfix] 修复描述（BUG ID）。 合并方式：使用 Create a merge commit（保留完整修复历史，便于追溯）。 步骤 4：打版本标签并清理分支 合并到main后，立即打版本标签（见 5.2 节），并删除 hotfix 分支。\n4.3 发布流程 用于将develop分支的功能发布到生产环境。\n步骤 1：创建 release 分支 # 从develop拉取最新代码 git checkout develop git pull origin develop # 创建release分支（版本号见5.1节） git checkout -b release/v2.3.0 步骤 2：预发布准备 仅修复测试中发现的 bug，不新增功能（如需新增功能，需从develop合并或后续迭代）。 更新版本号相关配置（如package.json的 version 字段）。 步骤 3：测试与合并 测试通过后，创建 PR 合并到main和develop。 合并到main后，打版本标签并编写发布说明（见 5.2 节）。 5. 代码合并与版本管理 5.1 版本号规范（语义化版本） 采用 X.Y.Z 格式，遵循 Semantic Versioning 标准：\nX（主版本号）：不兼容的重大变更（如架构重构、API 不兼容），例：3.0.0 Y（次版本号）：向后兼容的新功能，例：2.4.0 Z（修订号）：向后兼容的问题修复，例：2.3.1 版本号递增规则：\n新增功能 → 递增 Y（如2.3.0→2.4.0） 修复 bug → 递增 Z（如2.3.0→2.3.1） 重大变更 → 递增 X（如2.3.0→3.0.0） 5.2 版本标签（Tag）管理 仅在main分支打标签，标签格式为 vX.Y.Z（例：v2.3.0）。\n打标签时必须添加描述，说明版本核心变更：\n# 创建带注释的标签 git tag -a v2.3.0 -m \u0026#34;v2.3.0：新增用户登录功能，修复订单超时bug\u0026#34; # 推送标签到远程 git push origin v2.3.0 标签创建后禁止删除或修改（如需回滚，创建新标签如v2.3.1）。\n5.3 合并方式选择 合并场景 推荐合并方式 目的 feature → develop Squash Merge 压缩琐碎提交，保持develop历史清晰 hotfix → main / develop Create a merge commit 保留完整修复历史，便于追溯生产问题 release → main / develop Create a merge commit 保留发布前的测试调整记录 禁止操作：\n对main/develop分支使用git push -f（强制推送），防止代码丢失。 使用 Fast-forward 合并（会丢失分支历史，无法追溯分支来源）。 5.4 自动生成 CHANGELOG 利用提交信息的结构化特征，通过工具自动生成版本变更记录：\n安装工具：npm install -g standard-version（适用于 Node 项目，其他语言可选用同类工具）。\n在main分支执行（合并 release/hotfix 后）：\nstandard-version # 自动更新版本号、生成CHANGELOG、创建标签 git push --follow-tags # 推送版本号和标签 6. 冲突处理规范 冲突是协作中的正常现象，需通过规范流程减少冲突风险并高效解决。\n6.1 冲突预防 小团队分工明确，避免多人同时修改同一文件的同一部分。 每日同步develop代码（见 4.1.3 节），及时发现并解决小冲突，避免堆积。 核心配置文件（如config.yaml）尽量设计为可扩展结构，减少直接修改冲突。 6.2 冲突解决步骤 识别冲突文件：执行git rebase或git merge后，Git 会标记冲突文件（含\u0026lt;\u0026lt;\u0026lt;\u0026lt;\u0026lt;\u0026lt;\u0026lt; HEAD等标记）。 沟通确认：找到冲突代码的作者，明确各自的修改意图，避免擅自覆盖。 手动解决：编辑冲突文件，保留正确逻辑，删除冲突标记（\u0026lt;\u0026lt;\u0026lt;\u0026lt;\u0026lt;\u0026lt;\u0026lt;/=======/\u0026gt;\u0026gt;\u0026gt;\u0026gt;\u0026gt;\u0026gt;\u0026gt;）。 验证与提交：解决后执行git add \u0026lt;冲突文件\u0026gt;，继续 rebase/merge 流程，确保代码可运行。 6.3 冲突解决原则 以 “功能正确性” 为优先，而非 “谁的代码保留”。 复杂冲突（如架构层面）需团队同步讨论，达成共识后再修改。 7. 工具与自动化配置 通过工具强制规范执行，减少人工成本。\n7.1 提交信息校验 使用commitlint+husky检查提交信息格式\n# 安装依赖 npm install --save-dev @commitlint/cli @commitlint/config-conventional husky # 配置commitlint规则（根目录创建commitlint.config.js） module.exports = { extends: [\u0026#39;@commitlint/config-conventional\u0026#39;] } # 配置husky钩子（触发commit时校验） npx husky install npx husky add .husky/commit-msg \u0026#39;npx --no -- commitlint --edit $1\u0026#39; 7.2 代码风格与质量检查 配置pre-commit钩子，提交前自动执行代码格式化（prettier）、lint（eslint）、单元测试：\nnpx husky add .husky/pre-commit \u0026#39;npx lint-staged\u0026#39; # 仅检查暂存区文件 # 配置lint-staged（package.json） \u0026#34;lint-staged\u0026#34;: { \u0026#34;*.{js,ts}\u0026#34;: [\u0026#34;eslint --fix\u0026#34;, \u0026#34;prettier --write\u0026#34;], \u0026#34;*.{json,md}\u0026#34;: [\u0026#34;prettier --write\u0026#34;] } 7.3 分支保护与 CI 集成 在 GitLab/GitHub 中配置main/develop分支保护：\n禁止直接推送 强制 PR 审查通过 强制 CI 检查通过（如编译、测试、代码覆盖率≥80%） CI 流程示例（.gitlab-ci.yml）：\nstages: - lint - test - build lint: stage: lint script: npm run lint test: stage: test script: npm test build: stage: build script: npm run build 8. 常见问题与解决方案 问题场景 解决方案 误提交敏感信息（如密钥） 1. 立即从代码中删除并替换密钥\n2. 使用git filter-branch清除历史记录\n3. 通知团队更新密钥 提交后发现代码错误（未推送） git commit --amend 修正提交（仅修改最后一次提交） 提交后发现代码错误（已推送） 新增一个修复提交（类型fix），不修改历史 分支偏离develop过远，同步冲突多 先创建临时分支备份当前代码，重新从develop拉取并 cherry-pick 关键提交 误删分支 从远程分支恢复：git checkout -b 分支名 origin/分支名 9. 附则 本规范自发布之日起执行，团队成员需在 1 周内熟悉并遵守。 每月团队会议需回顾规范执行情况，收集反馈并迭代优化。 违反规范导致严重问题（如生产故障、代码丢失），需团队内复盘并改进。 附录：\n常用 Git 命令速查表（见文末附件） PR 模板文件（.github/PULL_REQUEST_TEMPLATE.md） 提交信息模板（.gitmessage） 通过严格执行本规范，团队可实现 “分支清晰、提交可追溯、协作高效、发布稳定” 的目标，为项目质量提供基础保障。\n","permalink":"/blogs/2025/git/git-best-practice.html","summary":"\u003ch2 id=\"目录\"\u003e目录\u003c/h2\u003e\n\u003col\u003e\n\u003cli\u003e前言\u003c/li\u003e\n\u003cli\u003e分支管理规范\u003c/li\u003e\n\u003cli\u003e提交信息规范\u003c/li\u003e\n\u003cli\u003e团队协作流程\u003c/li\u003e\n\u003cli\u003e代码合并与版本管理\u003c/li\u003e\n\u003cli\u003e冲突处理规范\u003c/li\u003e\n\u003cli\u003e工具与自动化配置\u003c/li\u003e\n\u003cli\u003e常见问题与解决方案\u003c/li\u003e\n\u003cli\u003e附则\u003c/li\u003e\n\u003c/ol\u003e\n\u003ch2 id=\"1-前言\"\u003e1. 前言\u003c/h2\u003e\n\u003cp\u003eGit 作为分布式版本控制系统，其高效性依赖于团队统一的操作规范。本规范基于行业最佳实践（如 Git Flow、Conventional Commits），结合团队协作场景优化，旨在解决以下问题：\u003c/p\u003e","title":"Git 使用规范文档（最佳实践版）"},{"content":"前言 系统为了保证高可用，通常会部署多实例，并且会存在同时对共享资源并发读写，这时候为了保证读写的安全，会引入分布式锁，本文将介绍如何使用redis设计一个优雅的Go分布式锁。\n设计 redis分布式锁是借助SETNX来实现，可能会遇到一下两个场景：\n加锁后没正确解锁：当一个协程获取到锁后，还未执行解锁操作时，因为服务重启等原因导致死锁。 解除别人的锁：为了避免死锁，会引入超时机制，如果锁时间较短，但是执行时间过长，就会导致锁超时，其他协程就会获取，这个时候第一个协程执行完后，会将第二个协程获取的锁提前释放了。 解决方案其实也挺简单：\n加锁时记录锁定协程的标识，解锁的时候校验是否是自己的锁。 设置合理超时时间，并且锁定期间增加一个续约协程，延长超时时间。 实现 接口定义 首先，需要考虑定义一个抽象接口，来作为防腐层解耦业务和具体技术细节。\n接口定义的原则：职责单一、功能抽象，不要与具体实现的技术细节挂钩，可以设计如下：\nsync/locker.go\npackage sync import ( \u0026#34;context\u0026#34; \u0026#34;errors\u0026#34; ) type UnlockFunc func(ctx context.Context) error // 解锁函数 type Locker interface { Lock(ctx context.Context, key string) (UnlockFunc, error) // 加锁 } 接口只有一个方法，加锁成功后，返回一个解锁的方法，这样设计好处是可以巧妙利用闭包来保存加锁人信息，并且封装在具体的实现中，使用方无感知，使用起来也非常简单：\nvar locker = ... unlock, err:= locker.Lock(ctx, ..) if err!=nil { return err } defer func{ err = unlock(ctx) ... }() 另外，为了简单起见，\u0026ldquo;加/解锁\u0026quot;失败或是网络异常等未知异常，都是返回一个error，为了区分通常会预定义两个\u0026quot;加/解锁\u0026quot;失败的异常：\nvar ErrLockFail = errors.New(\u0026#34;get lock get fail\u0026#34;) var ErrUnlockFail = errors.New(\u0026#34;unlock lock get fail\u0026#34;) 接口实现 接着我们开始实现接口\npackage redis import ( \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;time\u0026#34; \u0026#34;itart.top/internal/pkg/sync\u0026#34; \u0026#34;github.com/go-redis/redis/v8\u0026#34; \u0026#34;github.com/gofrs/uuid\u0026#34; ) var lockerTimeout = time.Minute // 默认锁定1分钟 var renewalTime = lockerTimeout / 2 // 时间过一半就续期 var delLockerScript = redis.NewScript(` if redis.call(\u0026#34;get\u0026#34;,KEYS[1]) == ARGV[1] then return redis.call(\u0026#34;del\u0026#34;,KEYS[1]) else return 0 end`) // 删除锁的lua脚本，先判断是否是自己的锁，再删除 type Locker struct { client *redis.Client ns string } func NewLocker(client *redis.Client, ns string) *Locker { return \u0026amp;Locker{ client: client, ns: ns, } } func (r *Locker) Lock(ctx context.Context, key string) (sync.UnlockFunc, error) { lockKey := fmt.Sprintf(\u0026#34;%s:%s\u0026#34;, r.ns, key) uuid, _ := uuid.NewV4() id := uuid.String() // 锁定人标识 cmd := r.client.SetNX(ctx, lockKey, id, lockerTimeout) if !cmd.Val() { // 已经被锁住 return nil, sync.ErrLockFail } ctx, cancel := context.WithCancel(ctx) go r.renewal(ctx, lockKey) // 续期 return func(ctx context.Context) error { defer cancel() return r.unlock(ctx, lockKey, id) }, nil } // 续约: 时间过半后续约 func (r *Locker) renewal(ctx context.Context, key string) { ticker := time.NewTicker(renewalTime) defer ticker.Stop() for { select { case \u0026lt;-ctx.Done(): return case \u0026lt;-ticker.C: r.client.Expire(ctx, key, lockerTimeout) } } } // 解锁 func (r *Locker) unlock(ctx context.Context, lockKey string, id string) error { num, err := delLockerScript.Run(ctx, r.client, []string{lockKey}, id). Int() if err != nil { return err } if num == 0 { return sync.ErrUnlockFail } return nil } 说明：\n通过Lua来保证原子性：校验“解锁”和“加锁”是同一个协程，是的话才执行删除锁。 通过ns标识来隔离业务：不同的业务分配不同的实例和ns命名空间。 通过renewal方法续期：如果业务执行时间超过加锁时间，则可以自动续期，另外，因为有这个续期的存在，所以“锁超时时间”没必要设置过长。 异常自动释放锁：由于续期是通过协程，存在内存中，如果程序异常中止，就不会续期，加锁时间超时后就会自动解锁。 使用 我们可以手动NewLocker方式直接使用，为不同的业务都实例化一个不同ns的实例。\n也可以通过wire管理，由于wire是单例方式管理，如果要实现多实例，只能为不同业务定义不同的别名，假设我们需要实现一个部署锁：\n首先，需要为实现类定义一个别名DeployLocker，然后增加一个实例方法 NewDeployLocker，指定一个命名空间\u0026quot;deploy\u0026rdquo;：\nredis/deploy_locker.go\ntype DeployLocker = Locker func NewDeployLocker(cache *cache.Cache) *DeployLocker { return (*DeployLocker)(NewLocker(cache, \u0026#34;deploy\u0026#34;)) } 接着，给接口也定义一个别名：\nbiz/deploy_locker.go\ntype DeployLocker sync.Locker 最后，通过wire绑定接口和实现类\nredis.NewDeployLocker, wire.Bind(new(biz.DeployLocker), new(*redis.DeployLocker) 这样就定义好一个部署的锁，需要地方就可以定义一个biz.DeployLocker参数，由wire来注入实现。\n如果还有其他业务也需要锁时，可以和Deploy类似，再定义一套来实现。\n","permalink":"/blogs/2025/go/go-redis-locker.html","summary":"\u003ch1 id=\"前言\"\u003e前言\u003c/h1\u003e\n\u003cp\u003e系统为了保证高可用，通常会部署多实例，并且会存在同时对共享资源并发读写，这时候为了保证读写的安全，会引入分布式锁，本文将介绍如何使用redis设计一个优雅的Go分布式锁。\u003c/p\u003e","title":"Go优雅实现redis分布式锁"},{"content":"前言 延迟执行的场景我们通常会使用time.NewTimer(\u0026hellip;)来实现，当一些场合可能需要使用timer.Reset(..)方法修改超时时间，这时使用要多注意， 使用不当会导致Reset失败，或是重复执行两次的情况。\n复现 下面这段代码我们是希望：\u0026ldquo;fmt.Println(\u0026ldquo;timeout:\u0026rdquo;, time.Now())\u0026ldquo;只是执行一次，然后就是deadlock的panic：\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;time\u0026#34; ) func main() { timer := time.NewTimer(1 * time.Second) c := make(chan struct{}, 1) c \u0026lt;- struct{}{} for { select { case \u0026lt;-c: // 执行一次 fmt.Println(\u0026#34;start:\u0026#34;, time.Now()) time.Sleep(2 * time.Second) timer.Reset(5 * time.Second) // 重置前前实际上时间已经到了 case \u0026lt;-timer.C: fmt.Println(\u0026#34;timeout:\u0026#34;, time.Now()) // 只希望执行一次 } } } 但是，实际执行结果如下：\n[Running] go run \u0026#34;/Users/hyman/go/src/bsc-flow-backend/internal/infra/redis/locker/main/main.go\u0026#34; start: 2025-01-27 15:48:06.429385 +0800 CST m=+0.000182501 timeout: 2025-01-27 15:48:08.434472 +0800 CST m=+2.005297501 timeout: 2025-01-27 15:48:13.43967 +0800 CST m=+7.010568084 fatal error: all goroutines are asleep - deadlock! goroutine 1 [select]: main.main() /Users/hyman/go/src/bsc-flow-backend/internal/infra/redis/locker/main/main.go:13 +0x80 exit status 2 [Done] exited with code=1 in 7.469 seconds \u0026ldquo;timeout\u0026quot;执行了两次，这并不符合我们的预期。\n分析 查看Timer的源码我们可以发现，\u0026ldquo;C\u0026quot;其实是一个带缓冲为1的chan：\ntype Timer struct { C \u0026lt;-chan Time r runtimeTimer } // NewTimer creates a new Timer that will send // the current time on its channel after at least duration d. func NewTimer(d Duration) *Timer { c := make(chan Time, 1) t := \u0026amp;Timer{ C: c, r: runtimeTimer{ when: when(d), f: sendTime, arg: c, }, } startTimer(\u0026amp;t.r) return t } 当执行时间到了，就往C发送当前的时间，发送使用select default的方式来防止阻塞泄露的问题：\n// sendTime does a non-blocking send of the current time on c. func sendTime(c any, seq uintptr) { select { case c.(chan Time) \u0026lt;- Now(): default: } } 而Reset方法并不会重新创建\u0026quot;C\u0026rdquo;，只是执行restTimer方法重置触发时间：\nfunc (t *Timer) Reset(d Duration) bool { if t.r.f == nil { panic(\u0026#34;time: Reset called on uninitialized Timer\u0026#34;) } w := when(d) return resetTimer(\u0026amp;t.r, w) } 一般情况下Reset后执行的符合预期，但是当Reset前触发时间已经到了，这个时候\u0026quot;C\u0026quot;实际上是已经有数据，所以如果读取timer.C时就会立即执行，再当Reset后的时间到达时，又也会再触发一次，所以就会出现上面的情况\u0026quot;timeout\u0026quot;执行两次。\n方案 解决方案就是reset前C有值时，就先读取出来。官方文档有强调使用Reset方法需要在定时器已经Stop或是“C”里已经没数据的情况下：\n// For a Timer created with NewTimer, Reset should be invoked only on\n// stopped or expired timers with drained channels.\n同时也给出了使用姿势：\n// if !t.Stop() {\n// \u0026lt;-t.C\n// }\n// t.Reset(d)\n所以，代码就可以改为：\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;time\u0026#34; ) func main() { timer := time.NewTimer(1 * time.Second) c := make(chan struct{}, 1) c \u0026lt;- struct{}{} for { select { case \u0026lt;-c: // 执行一次 fmt.Println(\u0026#34;start:\u0026#34;, time.Now()) time.Sleep(2 * time.Second) if !timer.Stop() { // 返回false表示C里有值 \u0026lt;-timer.C } timer.Reset(5 * time.Second) // 重置前前实际上时间已经到了 case \u0026lt;-timer.C: fmt.Println(\u0026#34;timeout:\u0026#34;, time.Now()) // 只希望执行一次 } } } 执行结果：\n[Running] go run \u0026#34;/Users/hyman/go/src/bsc-flow-backend/internal/infra/redis/locker/main/main.go\u0026#34; start: 2025-01-27 16:42:36.051956 +0800 CST m=+0.000152459 timeout: 2025-01-27 16:42:43.062077 +0800 CST m=+7.010485959 fatal error: all goroutines are asleep - deadlock! goroutine 1 [select]: main.main() /Users/hyman/go/src/bsc-flow-backend/internal/infra/redis/locker/main/main.go:13 +0x80 exit status 2 [Done] exited with code=1 in 7.697 seconds 符合预期\n结论 timer调用reset前需要先执行stop方法，如果stop返回的false时，就说明定时器已经被触发，需要执行\u0026lt;-timer.C先读出数据\n","permalink":"/blogs/2025/go/ticker-reset-exception.html","summary":"\u003ch1 id=\"前言\"\u003e前言\u003c/h1\u003e\n\u003cp\u003e延迟执行的场景我们通常会使用time.NewTimer(\u0026hellip;)来实现，当一些场合可能需要使用timer.Reset(..)方法修改超时时间，这时使用要多注意， 使用不当会导致Reset失败，或是重复执行两次的情况。\u003c/p\u003e","title":"Golang Ticker Reset异常的坑"},{"content":"介绍 robfig/cron是Go语言实现的开源定时任务调度框架，核心代码是巧妙的使用chan + select + for实现了一个轻量级调度协程，不但语法简洁，而且具有很好的性能，是一个很好的并发编程素材。\n设计 任务抽象（业务隔离）：任务抽象成一个Job接口，业务逻辑类只需实现该接口，参数和返回值调度并不关心，所有都为空\ntype Job interface { Run() } 计划接口：通过当前时间计算任务的下次执行执行时间，具体实现类可以根据实际需求实现\ntype Schedule interface { Next(time.Time) time.Time } 定时任务对象：保存执行的任务Job、计算执行时间\ntype Entry struct { ID EntryID // id Schedule Schedule // 计划 Next time.Time // 下次执行时间 Job Job // 任务 } 任务调度管理：保存定时任务对象（Entry），调度任务执行，提供新增、删除接口（涉及关联资源竞争）\n// 任务管理类 type Cron struct { nextID int64 // 生成entry自增ID entries []*Entry // 保存Entry add chan *Entry // 添加 remove chan EntryID // 删除 } // 删除 func (c *Cron) Remove(id EntryID) { c.remove \u0026lt;- id } // 新增 func (c *Cron) Add(spec string, cmd Job) EntryID { entry := \u0026amp;Entry{ ID: EntryID(atomic.AddInt64(\u0026amp;c.nextID, 1)), Schedule: ParseStandard(spec), Job: cmd, } c.add \u0026lt;- entry return entry.ID } 核心调度：计算下次执行时间 -\u0026gt; 排序 -\u0026gt; 取最早执行数据 -\u0026gt; timer 等待，因为只有一个协程在执行这个run的调度，所以不存在资源竞争，不需要加锁，另外考虑到执行任务可能涉及阻塞，例如：IO操作，所以一般startJob方法会开启协程执行\nfunc (c *Cron) run() { now := time.Now() for _, entry := range c.entries { entry.Next = entry.Schedule.Next(now) // 计算下次执行时间 } for { sort.Sort(byTime(c.entries)) // 时间排序 timer := time.NewTimer(c.entries[0].Next.Sub(now)) select { case now = \u0026lt;-timer.C: for _, e := range c.entries { if e.Next.After(now) || e.Next.IsZero() { break } c.startJob(e.Job) // 开协程执行 e.Next = e.Schedule.Next(now) // 计算下次执行时间 } case newEntry := \u0026lt;-c.add: // 新增 timer.Stop() newEntry.Next = newEntry.Schedule.Next(now) c.entries = append(c.entries, newEntry) } ... } } // 执行任务 func (c *Cron) startJob(j Job) { go func() { j.Run() }() } 启动时会开启唯一协程执行run方法，计算任务执行时间，执行，任务管理等\nfunc New() *Cron { c := \u0026amp;Cron{ entries: nil, add: make(chan *Entry), remove: make(chan EntryID), } return c } func (c *Cron) Start() { go c.run() } 总结 共享资源（定时任务）的管理和调度由唯一协程管理 通过for + select + channel来循环计算执行时间，监听任务到期、增删事件 执行任务会新启协程执行，不阻塞调度 采用扇入/扇出原理，多协程添加、增删任务调度协程（Fan In），调度启动新协程执行任务（Fan Out） 调度协程使用的是CSP并发模型思想 ","permalink":"/blogs/2022/go/cron-source-code.html","summary":"\u003ch1 id=\"介绍\"\u003e介绍\u003c/h1\u003e\n\u003cp\u003e\u003ca href=\"https://github.com/robfig/cron\"\u003erobfig/cron\u003c/a\u003e是Go语言实现的开源定时任务调度框架，核心代码是巧妙的使用chan + select + for实现了一个轻量级调度协程，不但语法简洁，而且具有很好的性能，是一个很好的并发编程素材。\u003c/p\u003e\n\u003ch1 id=\"设计\"\u003e设计\u003c/h1\u003e\n\u003cp\u003e\u003cstrong\u003e任务抽象（业务隔离）\u003c/strong\u003e：任务抽象成一个Job接口，业务逻辑类只需实现该接口，参数和返回值调度并不关心，所有都为空\u003c/p\u003e","title":"Go定时任务源码 - robfig/cron"},{"content":"在线编码、格式转换\n前言 日常开发或运维会比较常遇到日志中的内容格式不直观，需要转码或格式化的情况，这时候常常是去网上搜索在线工具，不但耗时耗力，又担心不安全，于是我索性就自己搭建一个，方便自己的同时，还可以分享给需要的朋友。\n介绍 我自己搭建的在线工具都是离线处理，逻辑都是在前端实现，没有和服务器有交互，所以处理数据比较快， 并且不用担心数据安全问题，可以放心使用。\n技术上主要采用的是react + ant design，源码地址：https://github.com/itart-top/itart-tool.git\n效果如下： 左侧是目前提供的工具，有编码转换、格式转换、代码生成三部分：\n编码转换 - 提供常用的Unicode、UTF-8、ASCII等 格式转换 - JSON格式化 代码生成 - 提供JSON转GO和PHP 右侧是内容区，主要用来显示工具转化后的结果，这里有个其他在线工具没有的功能：支持多选工具，将前一个工具结果作为后一个工具的输入，最终串成链式转化的效果，用户可以根据自己的需求灵活搭配，比如：一个原始的 json字符串，里面的中文是Unicode编码，我们可以先“解码Unicode”，然后再选择“JSON格式化”，例如：\n原始输入：\n解码Unicode\n格式化\n工具目前只是一个初步实现，还在不断完善中，大家可以多提提意见，如果有觉得有用，也可以点个赞。\n工具地址：https://tool.itart.cn 源码地址：https://github.com/itart-top/itart-tool.git 我的博客：https://itart.cn 座右铭：IT是门艺术\n","permalink":"/blogs/2022/frontend/react/online-decode.html","summary":"\u003cp\u003e在线编码、格式转换\u003c/p\u003e\n\u003ch1 id=\"前言\"\u003e前言\u003c/h1\u003e\n\u003cp\u003e日常开发或运维会比较常遇到日志中的内容格式不直观，需要转码或格式化的情况，这时候常常是去网上搜索在线工具，不但耗时耗力，又担心不安全，于是我索性就自己搭建一个，方便自己的同时，还可以分享给需要的朋友。\u003c/p\u003e","title":"在线编码、格式转换"},{"content":"简介 配置文件建议使用yaml格式，功能比较强大，且灵活发，目前广泛使用（k8s、springboot）\napplication.yml： 以yml为后缀的文件为YAML文件。\nYAML(YAML Ain`t Markup language)文件，它不是一个标记语言，以前我们的配置文件都是xml、properties， ，但YAML是以数据为中心，更适合做配置文件\n基本语法 它的基本语法规则如下。\n大小写敏感\n使用缩进表示层级关系\n缩进时不允许使用Tab键，只允许使用空格。\n缩进的空格数目不重要，只要相同层级的元素左侧对齐即可\n例子 Yaml格式配置\n# YAML one: two: 2 three: four: 4 five: 5 以上的内容转成 JSON 后\n\u0026#34;one\u0026#34;: { \u0026#34;two\u0026#34;: 2, \u0026#34;three\u0026#34;: { \u0026#34;four\u0026#34;: 4, \u0026#34;five\u0026#34;: 5 } } 数组语法 fruits: - Apple - Banana - Strawberry formats: [ YAML, JSON, TOML ]] ]\u0026gt;\u0026lt;/ac:plain-text-body\u0026gt;\u0026lt;/ac:structured-macro\u0026gt;\u0026lt;p\u0026gt;Json\u0026lt;/p\u0026gt;\u0026lt;ac:structured-macro ac:name=\u0026#34;code\u0026#34; ac:schema-version=\u0026#34;1\u0026#34; ac:macro-id=\u0026#34;122d0ab2-42e8-4473-a407-e12186621811\u0026#34;\u0026gt;\u0026lt;ac:plain-text-body\u0026gt;\u0026lt;![CDATA[{ \u0026#34;fruits\u0026#34;: [\u0026#34;Apple\u0026#34;,\u0026#34;Banana\u0026#34;,\u0026#34;Strawberry\u0026#34;], \u0026#34;formats\u0026#34;: [ \u0026#34;YAML\u0026#34;, \u0026#34;JSON\u0026#34;, \u0026#34;TOML\u0026#34; ] } 注释 使用“#”单行注释\n# 我是注释 # 我也是注释 多行的文字 YAML 提供了两种特殊的语法支持：\nlines: | 我是第一行 我是第二行 我是吴彦祖 我是第四行 我是第五行 // JSON \u0026#34;lines\u0026#34;: \u0026#34;我是第一行\\n我是第二行\\n 我是吴彦祖\\n 我是第四行\\n我是第五行\u0026#34; 使用右尖括号“ \u0026gt; ”来表示该语法，只有空白行才会被识别为换行，原来的换行符都会被转换成空格\nlines: \u0026gt; 我是第一行 我也是第一行 我仍是第一行 我依旧是第一行 我是第二行 这么巧我也是第二行 // JSON \u0026#34;lines\u0026#34;: \u0026#34;我是第一行 我也是第一行 我仍是第一行 我依旧是第一行\\n我是第二行 这么巧我也是第二行\u0026#34; 数据重用与合并 a: \u0026amp;anchor # 设置锚点 one: 1 two: 2 three: 3 b: *anchor # 引用锚点 对应JSON写法\n\u0026#34;a\u0026#34;: { \u0026#34;one\u0026#34;: 1, \u0026#34;two\u0026#34;: 2, \u0026#34;three\u0026#34;: 3 }, \u0026#34;b\u0026#34;: { \u0026#34;one\u0026#34;: 1, \u0026#34;two\u0026#34;: 2, \u0026#34;three\u0026#34;: 3 } 配合**合并标签“\u0026laquo;”**使用可以与任意数据进行合并，你可以把这套操作想象成面向对象语言中的继承\n# YAML human: \u0026amp;base # 添加名为 base 的锚点 body: 1 hair: 999 singer: \u0026lt;\u0026lt;: *base # 引用 base 锚点，实例化时会自动展开 skill: sing # 添加额外的属性 programer: \u0026lt;\u0026lt;: *base # 引用 base 锚点，实例化时会自动展开 hair: 6 # 覆写 base 中的属性 skill: code # 添加额外的属性 对应JSON写法\n\u0026#34;human\u0026#34;: { \u0026#34;body\u0026#34;: 1, \u0026#34;hair\u0026#34;: 999 }, \u0026#34;singer\u0026#34;: { \u0026#34;body\u0026#34;: 1, \u0026#34;hair\u0026#34;: 999, \u0026#34;skill\u0026#34;: \u0026#34;sing\u0026#34; }, \u0026#34;programer\u0026#34;: { \u0026#34;body\u0026#34;: 1, \u0026#34;hair\u0026#34;: 6, \u0026#34;skill\u0026#34;: \u0026#34;code\u0026#34; } ","permalink":"/blogs/2022/standard/yaml-intro.html","summary":"\u003ch2 id=\"简介\"\u003e简介\u003c/h2\u003e\n\u003cp\u003e配置文件建议使用yaml格式，功能比较强大，且灵活发，目前广泛使用（k8s、springboot）\u003c/p\u003e\n\u003cp\u003eapplication.yml： 以yml为后缀的文件为YAML文件。\u003c/p\u003e","title":"Yaml配置入门"},{"content":"一、查找文件名 查找当前文件夹下包含“xx”文件名的文件：\nfind . -name \u0026#34;*xx*\u0026#34; 二、查找文件内容 查找当前文件夹下包含“xx”的所有文件\nfind . | xargs grep -ri \u0026#34;xx\u0026#34; 或 find . | xargs grep -ri \u0026#34;xx\u0026#34; -l 或 grep -R xxx . 注：-l表示只显示文件名\n","permalink":"/blogs/2022/linux/linux-search.html","summary":"\u003ch2 id=\"一查找文件名\"\u003e一、查找文件名\u003c/h2\u003e\n\u003col\u003e\n\u003cli\u003e\n\u003cp\u003e查找当前文件夹下包含“xx”文件名的文件：\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-shell\" data-lang=\"shell\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003efind . -name \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;*xx*\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003c/li\u003e\n\u003c/ol\u003e\n\u003ch2 id=\"二查找文件内容\"\u003e二、查找文件内容\u003c/h2\u003e\n\u003col\u003e\n\u003cli\u003e\n\u003cp\u003e查找当前文件夹下包含“xx”的所有文件\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-bash\" data-lang=\"bash\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003efind . | xargs grep -ri \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;xx\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e或\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003efind . | xargs grep -ri \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;xx\u0026#34;\u003c/span\u003e -l\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e或\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egrep -R xxx .\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e注：-l表示只显示文件名\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ol\u003e","title":"Linux常用查找命令"},{"content":"vue工具初始化了一个element项目，但是执行了yarn install报了下面的错误：\nyarn install .... /Users/hyman/.node-gyp/16.13.2/include/node/v8-internal.h:492:38: error: no template named \u0026#39;remove_cv_t\u0026#39; in namespace \u0026#39;std\u0026#39;; did you mean \u0026#39;remove_cv\u0026#39;? !std::is_same\u0026lt;Data, std::remove_cv_t\u0026lt;T\u0026gt;\u0026gt;::value\u0026gt;::Perform(data); ~~~~~^~~~~~~~~~~ remove_cv /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/c++/v1/type_traits:776:50: note: \u0026#39;remove_cv\u0026#39; declared here template \u0026lt;class _Tp\u0026gt; struct _LIBCPP_TEMPLATE_VIS remove_cv ^ 1 error generated. make: *** [Release/obj.target/binding/src/binding.o] Error 1 gyp ERR! build error gyp ERR! stack Error: `make` failed with exit code: 2 gyp ERR! stack at ChildProcess.onExit (/Users/hyman/WebstormProjects/itart_tool/node_modules/node-gyp/lib/build.js:262:23) gyp ERR! stack at ChildProcess.emit (node:events:390:28) gyp ERR! stack at Process.ChildProcess._handle.onexit (node:internal/child_process:290:12) gyp ERR! System Darwin 20.6.0 gyp ERR! command \u0026#34;/usr/local/bin/node\u0026#34; \u0026#34;/Users/hyman/WebstormProjects/itart_tool/node_modules/node-gyp/bin/node-gyp.js\u0026#34; \u0026#34;rebuild\u0026#34; \u0026#34;--verbose\u0026#34; \u0026#34;--libsass_ext=\u0026#34; \u0026#34;--libsass_cflags=\u0026#34; \u0026#34;--libsass_ldflags=\u0026#34; \u0026#34;--libsass_library=\u0026#34; gyp ERR! cwd /Users/hyman/WebstormProjects/itart_tool/node_modules/node-sass gyp ERR! node -v v16.13.2 gyp ERR! node-gyp -v v3.8.0 解决方案，增加一个CXXFLAGS参数：\nCXXFLAGS=\u0026#34;--std=c++17\u0026#34; yarn install ","permalink":"/blogs/2022/frontend/vue/vue-no-template-named-remove_cv_t.html","summary":"\u003cp\u003evue工具初始化了一个element项目，但是执行了\u003cstrong\u003eyarn install\u003c/strong\u003e报了下面的错误：\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-shell\" data-lang=\"shell\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003eyarn install\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e....\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e/Users/hyman/.node-gyp/16.13.2/include/node/v8-internal.h:492:38: error: no template named \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;remove_cv_t\u0026#39;\u003c/span\u003e in namespace \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;std\u0026#39;\u003c/span\u003e; did you mean \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;remove_cv\u0026#39;\u003c/span\u003e?\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            !std::is_same\u0026lt;Data, std::remove_cv_t\u0026lt;T\u0026gt;\u0026gt;::value\u0026gt;::Perform\u003cspan style=\"color:#f92672\"\u003e(\u003c/span\u003edata\u003cspan style=\"color:#f92672\"\u003e)\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                                ~~~~~^~~~~~~~~~~\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                                     remove_cv\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/c++/v1/type_traits:776:50: note: \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;remove_cv\u0026#39;\u003c/span\u003e declared here\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003etemplate \u0026lt;class _Tp\u0026gt; struct _LIBCPP_TEMPLATE_VIS remove_cv\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                                                 ^\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#ae81ff\"\u003e1\u003c/span\u003e error generated.\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003emake: *** \u003cspan style=\"color:#f92672\"\u003e[\u003c/span\u003eRelease/obj.target/binding/src/binding.o\u003cspan style=\"color:#f92672\"\u003e]\u003c/span\u003e Error \u003cspan style=\"color:#ae81ff\"\u003e1\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! build error \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! stack Error: \u003cspan style=\"color:#e6db74\"\u003e`\u003c/span\u003emake\u003cspan style=\"color:#e6db74\"\u003e`\u003c/span\u003e failed with exit code: \u003cspan style=\"color:#ae81ff\"\u003e2\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! stack     at ChildProcess.onExit \u003cspan style=\"color:#f92672\"\u003e(\u003c/span\u003e/Users/hyman/WebstormProjects/itart_tool/node_modules/node-gyp/lib/build.js:262:23\u003cspan style=\"color:#f92672\"\u003e)\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! stack     at ChildProcess.emit \u003cspan style=\"color:#f92672\"\u003e(\u003c/span\u003enode:events:390:28\u003cspan style=\"color:#f92672\"\u003e)\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! stack     at Process.ChildProcess._handle.onexit \u003cspan style=\"color:#f92672\"\u003e(\u003c/span\u003enode:internal/child_process:290:12\u003cspan style=\"color:#f92672\"\u003e)\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! System Darwin 20.6.0\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! command \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;/usr/local/bin/node\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;/Users/hyman/WebstormProjects/itart_tool/node_modules/node-gyp/bin/node-gyp.js\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;rebuild\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;--verbose\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;--libsass_ext=\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;--libsass_cflags=\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;--libsass_ldflags=\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;--libsass_library=\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! cwd /Users/hyman/WebstormProjects/itart_tool/node_modules/node-sass\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! node -v v16.13.2\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003egyp ERR! node-gyp -v v3.8.0\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e解决方案，增加一个\u003cstrong\u003eCXXFLAGS\u003c/strong\u003e参数：\u003c/p\u003e","title":"vue install - no template named 'remove_cv_t' in namespace 'std'"},{"content":"Go有提供os.ReadDir、filepath.WalkDir这些方法，很方便得实现遍历指定文件夹下的文件，但是不能很好的限制遍历文件夹深度，这里提供两种方法实现这个功能。\n方法1：通过递归实现\npackage dir import ( \u0026#34;os\u0026#34; \u0026#34;path/filepath\u0026#34; ) // 每个文件都会回调这个方法 type WalkFun func(dir, name string, isDir bool) error func WalkDepth(name string, maxDepth int, fn WalkFun) error { return walkDirs([]string{name}, 1, maxDepth, fn) } // 遍历每个dirs下的文件，并且返回所有dirs下是目录的文件 func walkDirs(dirs []string, dep, maxDepth int, fn WalkFun) error { var subDirs []string for _, d := range dirs { ff, err := os.ReadDir(d) if err != nil { return err } for _, f := range ff { err = fn(d, f.Name(), f.IsDir()) if err != nil { return err } if f.IsDir() { // 如果是目录 subDirs = append(subDirs, filepath.Join(d, f.Name())) } } } if len(subDirs) \u0026gt; 0 \u0026amp;\u0026amp; dep \u0026lt; maxDepth { return walkDirs(subDirs, dep+1, maxDepth, fn) } return nil } 方法2：直接用for实现\npackage dir import ( \u0026#34;os\u0026#34; \u0026#34;path/filepath\u0026#34; ) // 每个文件都会回调这个方法 type WalkFun func(dir, name string, isDir bool) error func WalkDepth(name string, maxDepth int, fn WalkFun) error { var ( dep = 0 // 深度 err error ) dirs := []string{name} // 如果 dirs下还有dir或已经超出深度时结束循环 for len(dirs) \u0026gt; 0 \u0026amp;\u0026amp; dep != maxDepth { dirs, err = WalkDirs(dirs, fn) // 遍历dirs下的文件，返回dirs下目录的文件 if err != nil { return err } dep++ } return nil } // 遍历每个dirs下的文件，并且返回所有dirs下是目录的文件 func WalkDirs(dirs []string, fn WalkFun) ([]string, error) { var subDirs []string for _, d := range dirs { ff, err := os.ReadDir(d) if err != nil { return nil, err } for _, f := range ff { err = fn(d, f.Name(), f.IsDir()) if err != nil { return nil, err } if f.IsDir() { // 如果是目录 subDirs = append(subDirs, filepath.Join(d, f.Name())) } } } return subDirs, nil } 客户端调用：\nfunc main() { root := \u0026#34;root\u0026#34; err := dir.WalkDepth(root, 2, func(dir, name string, isDir bool) error { fmt.Println(dir, name, isDir) return nil }) fmt.Println(err) } 输出结果\nroot dir-1-1 true root dir-1-2 true root file-1-3 false root/dir-1-1 f11 true root/dir-1-2 file-1-2 false 遍历root目录下的深度为2以上的所有文件和目录\n两种方法中，递归会比较简洁，但是递归如果深度太深性能会有一定影响，所以可以根据实际需求评估一下。\n","permalink":"/blogs/2022/go/go-read-dir-limit-depth.html","summary":"\u003cp\u003eGo有提供os.ReadDir、filepath.WalkDir这些方法，很方便得实现遍历指定文件夹下的文件，但是不能很好的限制遍历文件夹深度，这里提供两种方法实现这个功能。\u003c/p\u003e","title":"Go限制深度遍历目录下文件"},{"content":"内容查看 查看rpm包内容和脚本 rpm -qpli --scripts rpm包名\n下载不安装\nyum install \u0026ndash;downloadonly \u0026ndash;downloaddir=/home/java java\n已经安装： yum \u0026ndash;downloadonly \u0026ndash;downloaddir=/tmp/zjw reinstall cmd-fast-deploy-agent\n解压 rpm2cpio *.rpm | cpio -div\n其他 查看内容：rpm -qpl cmd-nginx-hosts-agent-1.17.0-0.el6.noarch.rpm 查看：rpm -qa|grep nginx (a：显示全部，一般不用加)\n安装： rpm -ivh RPM包全路径名称 卸载：rpm -e RPM包全路径\nrpm -qpl tsunami-todo-0.1.4-2.el7.x86_64.rpm\nrpm -qp \u0026ndash;scripts 服务降级：yum downgrade xxx\nrpm -Uvh xxx.noarch.rpm \u0026ndash;oldpackage\n查找文件：https://www.thegeekdiary.com/how-to-find-which-rpm-package-provides-a-specific-file-or-library-in-rhel-centos/\nrpm -qf [file name]\nrpm -q \u0026ndash;whatprovides /etc/hosts\n","permalink":"/blogs/2022/linux/rpm-common-commands.html","summary":"\u003ch2 id=\"内容查看\"\u003e内容查看\u003c/h2\u003e\n\u003cp\u003e查看rpm包内容和脚本\n\u003ccode\u003erpm -qpli --scripts rpm包名\u003c/code\u003e\u003c/p\u003e\n\u003cp\u003e下载不安装\u003c/p\u003e\n\u003cp\u003eyum install \u0026ndash;downloadonly \u0026ndash;downloaddir=/home/java java\u003c/p\u003e\n\u003cp\u003e已经安装：\nyum \u0026ndash;downloadonly \u0026ndash;downloaddir=/tmp/zjw reinstall cmd-fast-deploy-agent\u003c/p\u003e\n\u003cp\u003e解压\nrpm2cpio *.rpm | cpio -div\u003c/p\u003e\n\u003ch2 id=\"其他\"\u003e其他\u003c/h2\u003e\n\u003cp\u003e查看内容：rpm -qpl cmd-nginx-hosts-agent-1.17.0-0.el6.noarch.rpm\n查看：rpm -qa|grep nginx (a：显示全部，一般不用加)\u003c/p\u003e","title":"RPM常用命令整理"},{"content":"背景 有上万台边缘机器，每台都会有多个agent客户端，并且每个agent都会同时向中心系统上报数据，由于上报数据频繁，并发量也大，每个agent都频繁和中心建立连接，导致中心压力非常大，所以需要对此进行优化，对每台机器上的agent上报数据做聚合，批量进行上报，减少边缘和中心的上报频率，从而减轻中心压力。\n方案 边缘增加一个batch中间件，所有agent上报的数据由原来直接向中心上报变为向batch中间件上报 batch中间件会聚合请求，再分批向中心上报 上报的方式也由原来的同步也改为异步，agent只把数据提交到batch就结束 核心就是实现一个数据并发扇入，分批扇出的功能：\n为了能优化分批的效果，batch中间件会有一个缓存队列，agent提交的数据会先放入到队列中，然后消费端从队列中取出数据，分批上报到中心系统，由于agent和batch中间件属于本地通讯，提交数据又是先放到队列，所以队列中的数据就容易堆积，达到分批的前提条件，有堆积数据，我就可以开始分批处理，完整逻辑如下：\n队列中没数据时等待 有数据时，不断从队列中取出数据，当数量达到分批数量时，调用中心接口上报。 数量没达到分批数量，但是队列中又没有数据时，也是会上报。 上报结束后，又跳到2步骤，当都没数据时，就会跳到1步骤继续监听 注：因为即使数据没达到批次数量，当队列没数据时还是会上报，所以当上报数据少，且都是间隔上报，也没有并发，这时就容易出现一个批次就只有一个的情况，分批的就没什么效果。\n接下来我们开始实现核心分批功能：\n/** * @Title 分批处理器 * @Description 将in中的数据取出分批放入out。适合in有大量数据并发或快速写入，需要分批处理的场景 * @Author hyman * @Date 2022-03-05 **/ package batch func New(in \u0026lt;-chan []byte, size int) \u0026lt;-chan [][]byte { if size \u0026lt; 2 { panic(\u0026#34;nonsense! batch size less then 2\u0026#34;) } out := make(chan [][]byte) go func() { defer close(out) loopBatch(in, out, size) }() return out } func loopBatch(in \u0026lt;-chan []byte, out chan\u0026lt;- [][]byte, size int) { var batch [][]byte for d := range in { batch = append(batch, d) more := true // 默认认为还有数据 for more { select { default: more = false // in 没有数据 case d, ok := \u0026lt;-in: if ok { batch = append(batch, d) } else { more = false // in关闭，且队列里没有数据 } } l := len(batch) // more = false没数据，同时batch中也没数据，则break到外层for等待数据 if !more \u0026amp;\u0026amp; l == 0 { break } // 如果more = true队列可能还有数据，当batch里的数量小于批次数量，则继续内层for尝试从in取数据 if more \u0026amp;\u0026amp; l \u0026lt; size { continue } // 当in没数据或数量达到分批上限时，发送给out out \u0026lt;- batch batch = [][]byte{} // 重置 } } } 核心代码不到四十行，使用一个：in \u0026lt;-chan []byte带缓冲的chan来接收数据，使用一个out的chan作为批量输出，只需在外层再简单包裹一层业务逻辑，就可以满足分批需求。\n核心的组装批次的逻辑放在了一个协程中，巧妙的使用两个for来读取in，实现没数据时阻塞和有数据时分批上报：\n第一个for用来监听in是否有数据，当队列无数据时会pending，in被关闭时就自动结束for，协程结束。 第二个for巧妙用到了select的default功能，可以在不阻塞的情况下判断队列是否还有数据，实现组装分批数据。 测试\nfunc TestBatchHttp(t *testing.T) { var in = make(chan []byte, 10000) // 模拟结束请求 srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if b, err := ioutil.ReadAll(r.Body); err == nil { in \u0026lt;- b } w.Write([]byte(\u0026#34;success\u0026#34;)) })) var wg sync.WaitGroup n :=time.Now() // 模拟并发上报100次 for i := 0; i \u0026lt; 100; i++ { wg.Add(1) _i:=i go func() { body, _ := json.Marshal(map[string]string{\u0026#34;say\u0026#34;: \u0026#34;hello \u0026#34; + strconv.Itoa(_i)}) resp, err := http.Post(srv.URL, \u0026#34;application/json\u0026#34;, bytes.NewReader(body)) if err != nil { t.Fatal(err) } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { t.Fatal(resp.Status) } }() } t.Log(\u0026#34;post cost time = \u0026#34;, time.Now().Sub(n)) // 5个一批 bats := batch.New(in, 5) // 分批上报的协程数 batchWorker := 1 for i := 0; i \u0026lt; batchWorker; i++ { go func() { for dd := range bats { // 分批调用中心接口上报数据 for _, d := range dd { fmt.Print(string(d)) wg.Done() } fmt.Println() time.Sleep(10* time.Millisecond) // 模拟消费耗时 } }() } wg.Wait() } 打印结果：\nbatch_test.go:61: post cost time = 240.333µs {\u0026#34;say\u0026#34;:\u0026#34;hello 92\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 9\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 10\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 79\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 98\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 0\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 80\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 99\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 93\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 4\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 8\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 5\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 11\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 47\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 12\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 7\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 81\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 6\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 48\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 13\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 2\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 49\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 14\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 75\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 77\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 51\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 50\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 74\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 73\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 27\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 52\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 76\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 72\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 28\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 41\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 53\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 94\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 54\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 15\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 95\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 16\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 56\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 61\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 58\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 43\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 85\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 84\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 89\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 78\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 96\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 1\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 82\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 26\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 57\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 3\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 46\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 83\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 40\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 55\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 29\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 65\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 33\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 60\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 42\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 30\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 62\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 34\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 64\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 66\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 88\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 91\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 35\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 38\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 39\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 87\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 18\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 59\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 68\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 19\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 63\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 20\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 21\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 86\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 17\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 24\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 70\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 69\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 90\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 22\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 71\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 25\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 44\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 45\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 36\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 23\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 37\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 32\u0026#34;} {\u0026#34;say\u0026#34;:\u0026#34;hello 31\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 67\u0026#34;}{\u0026#34;say\u0026#34;:\u0026#34;hello 97\u0026#34;} --- PASS: TestBatchHttp (0.26s) PASS 100个请求数据都有正常打印，并且大部分数量都符合预期，但是前两行只有1个，并没有到达分批数量，这是为什么？！\n原因是刚开始分批速度大于提交速度，取出1个数据时队列就没有数据，所以第一批也就只有1个数据，第二批也是一样，由于批次消费就只有开一个协程，且每次消费都time.Sleep(10* time.Millisecond)，消费过慢，于是数据逐渐堆积，满足批次数量，后面打印就正常。\nPS：要验证这一说法，可以在”bats := batch.New(in, 5)“前面增加”time.Sleep(10* time.Millisecond)“让队列里数据有足够数据，这时打印就会符合预期。\n这里的batchWorker只有1个，也就是说是向中心是串行上报，这个可以根据实际需求修改，通过开启多个协程来提高上报速度。\n但是，有时候反而不满足需求，这样做会并发上报数据，增加中心压力，同时由于消费过快，反而使队列中的数量就不容易达到分批数量，分批效果就减少，只是加快队列消费而已。\n总结 Go的chan功能非常强大，各种并发处理都能看到他的身影，也是Go推荐的方式：\nDo not communicate by sharing memory; instead, share memory by communicating.\n灵活借助chan并发安全，既能阻塞又能select default非阻塞的特性，可以优雅实现很多并发控制的需求\n","permalink":"/blogs/2022/go/go-chan-aggregate-batch.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003e有上万台边缘机器，每台都会有多个agent客户端，并且每个agent都会同时向中心系统上报数据，由于上报数据频繁，并发量也大，每个agent都频繁和中心建立连接，导致中心压力非常大，所以需要对此进行优化，对每台机器上的agent上报数据做聚合，批量进行上报，减少边缘和中心的上报频率，从而减轻中心压力。\u003c/p\u003e","title":"Go实现并发扇入，批量扇出功能"},{"content":"Go协程panic后能捕获异常，还可以自动重启：\npackage main import \u0026#34;log\u0026#34; import \u0026#34;time\u0026#34; func shouldNotExit() { for { time.Sleep(time.Second) // 模拟一个工作负载 // 模拟一个未预料到的恐慌。 if time.Now().UnixNano() \u0026amp; 0x3 == 0 { panic(\u0026#34;unexpected situation\u0026#34;) } } } func NeverExit(name string, f func()) { defer func() { if v := recover(); v != nil { // 侦测到一个恐慌 log.Printf(\u0026#34;协程%s崩溃了，准备重启一个\u0026#34;, name) go NeverExit(name, f) // 重启一个同功能协程 } }() f() } func main() { log.SetFlags(0) go NeverExit(\u0026#34;job#A\u0026#34;, shouldNotExit) go NeverExit(\u0026#34;job#B\u0026#34;, shouldNotExit) select{} // 永久阻塞主线程 } 转自：https://gfw.go101.org/article/panic-and-recover-use-cases.html\n","permalink":"/blogs/2022/go/auto-panic-recover.html","summary":"\u003cp\u003eGo协程panic后能捕获异常，还可以自动重启：\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-go\" data-lang=\"go\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003epackage\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003emain\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;log\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;time\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003efunc\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eshouldNotExit\u003c/span\u003e() {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003efor\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#a6e22e\"\u003etime\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eSleep\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003etime\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eSecond\u003c/span\u003e) \u003cspan style=\"color:#75715e\"\u003e// 模拟一个工作负载\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#75715e\"\u003e// 模拟一个未预料到的恐慌。\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#66d9ef\"\u003eif\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003etime\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eNow\u003c/span\u003e().\u003cspan style=\"color:#a6e22e\"\u003eUnixNano\u003c/span\u003e() \u003cspan style=\"color:#f92672\"\u003e\u0026amp;\u003c/span\u003e \u003cspan style=\"color:#ae81ff\"\u003e0x3\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e==\u003c/span\u003e \u003cspan style=\"color:#ae81ff\"\u003e0\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\tpanic(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;unexpected situation\u0026#34;\u003c/span\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003efunc\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eNeverExit\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003ename\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estring\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ef\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003efunc\u003c/span\u003e()) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003edefer\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003efunc\u003c/span\u003e() {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#66d9ef\"\u003eif\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003ev\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e:=\u003c/span\u003e recover(); \u003cspan style=\"color:#a6e22e\"\u003ev\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e!=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enil\u003c/span\u003e { \u003cspan style=\"color:#75715e\"\u003e// 侦测到一个恐慌\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\t\u003cspan style=\"color:#a6e22e\"\u003elog\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003ePrintf\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;协程%s崩溃了，准备重启一个\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ename\u003c/span\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\t\u003cspan style=\"color:#66d9ef\"\u003ego\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eNeverExit\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003ename\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ef\u003c/span\u003e) \u003cspan style=\"color:#75715e\"\u003e// 重启一个同功能协程\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}()\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#a6e22e\"\u003ef\u003c/span\u003e()\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003efunc\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003emain\u003c/span\u003e() {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#a6e22e\"\u003elog\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eSetFlags\u003c/span\u003e(\u003cspan style=\"color:#ae81ff\"\u003e0\u003c/span\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003ego\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eNeverExit\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;job#A\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003eshouldNotExit\u003c/span\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003ego\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eNeverExit\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;job#B\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003eshouldNotExit\u003c/span\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003eselect\u003c/span\u003e{} \u003cspan style=\"color:#75715e\"\u003e// 永久阻塞主线程\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e转自：https://gfw.go101.org/article/panic-and-recover-use-cases.html\u003c/p\u003e","title":"自动重启因为恐慌而退出的协程"},{"content":"一提到代码组织，想必大家第一个印象便是分层，分层的带来的好处是什么：\n隔离不同关注点。高层关注业务逻辑、低层关注基础设置 隔离业务复杂度与技术复杂度 提高复用 降低耦合 分层的原则是什么？\n层次越高，越面向业务、用户 层次越低，越通用，面向设备 封装变化。层之间解耦，将各层的影响降到最低 对于分层架构中层次的界定，Martin Fowler给出了一个判定的方法，就是如果把表示层换成其他实现，如果和原来的表示层有重复实现的内容，那么这部分内容就应该放到业务逻辑层\n传统的分层，我们会将系统分为表示层、业务逻辑层以及数据访问层：\n表现层 - controller：json、xml等 逻辑层 - service：业务逻辑 数据访问层 - dao：orm 、关系型数据库 注：Common或Utility，提供共用或通用方法或行为的支持\n对于传统分层有什么特点：\n层依赖下层。下层不能依赖上层。 适合逻辑简单的服务（CRUD），比如：直接提供对数据库增删改查，简单的信息管理 数据为中心，数据驱动 无法适应复杂业务多维度依赖 随着某些核心业务的访问量发展，通常我们需要去进行优化的措施，比如加缓存，加MQ，换数据源\n另外，核心业务的复杂程度不断提高，数据驱动开始显得有些力不从心，需要能有跟好方式进行代码组织 - DDD的出现很好的解决了复杂性的问题，开启了从以数据为中心向基于任务的设计转变的过程，目前比较成熟的架构架构风格有：洋葱架构、干净架构、六边形架构，以六边形架构为例，整体组织架构如下：\n内层业务逻辑 外层依赖内层 左边向右边驱动 外层为驱动逻辑、基础设施或其他应用 它的特点是：\n解决了业务逻辑和表示层代码交错的问题 前端需求多变，核心领域稳定 用例和流程会随外部需求随时调整 不同的客户通过\u0026quot;平等\u0026quot;的方式与系统交互 六边形架构也称为端口与适配器 ","permalink":"/blogs/2022/ddd/ddd-hexagon.html","summary":"\u003cp\u003e一提到代码组织，想必大家第一个印象便是分层，分层的带来的好处是什么：\u003c/p\u003e\n\u003cul\u003e\n\u003cli\u003e隔离不同关注点。高层关注业务逻辑、低层关注基础设置\u003c/li\u003e\n\u003cli\u003e隔离业务复杂度与技术复杂度\u003c/li\u003e\n\u003cli\u003e提高复用\u003c/li\u003e\n\u003cli\u003e降低耦合\u003c/li\u003e\n\u003c/ul\u003e\n\u003cp\u003e分层的原则是什么？\u003c/p\u003e","title":"代码组织 - DDD 六边形架构"},{"content":"背景 关于限流Go官方通过一个采用令牌池的算法的实现：golang.org/x/time/rate，但是，这个限制的是每秒的请求数，有的时候我们希望限制的是系统并发处理的请求数量，类似线程池的功能，需求如下：\n设置一个最大的请求处理数量，当请求超过时，后续请求将等待，直到有请求处理完后被唤醒。 请求的等待时间能够指定，超出等待时间就返回，提示给客户端。 等待请求的个数需要能够限制，数量超过时就直接返回，提示给客户端。 设计 设计思路是实现一个Ticket池（NumLimiter），每个请求首先需要向NumLimiter申请一个ticket，当请求处理结束后，需要被回收。\n获取不到ticket的请求就等待现有的ticket释放，所以会有两个核心对象：\nNumLimiter：数量限制器（ticket 池） Ticket：入场券，请求需要先申请一个Ticket 先不考虑细节，可以设计如下：\npackage numlimiter // 数量限制器 type NumLimiter struct { maxTicket\tint // 最大请求数 maxWait\tint // 最大等待数 ... } // 释放Ticket func (r *NumLimiter) releaseTicket(t *Ticket) bool { ... } // 预订Ticket func (r *NumLimiter) Reserve(ctx context.Context) (*Ticket, error) { ... } // 创建一个tocket池 func New(maxTicket) *NumLimiter { l := \u0026amp;NumLimiter{ maxTicket: maxTicket, } return l } // 入场券 type Ticket struct { l *NumLimiter reqKey int64 } // 释放入场券 func (r *Ticket) Close() { r.l.releaseTicket(r) } NumLimiter有两个核心的方法：\nReserve - 申请Ticket：每个请求处理前需要先调用该方法获取一个ticket，如果当前颁发的ticket数已经是大于等于 maxTicket时，请求就pending等待Ticket释放。 该方法接收一个context，作用是传递外部超时或取消的信号，结束等待。 releaseTicket - 释放Ticket：当请求处理完就需要把持有的ticket释放，该方法不直接暴露给外部，提供给ticket的Close方法调用。 Ticket就只有一个Close方法：\nClose：调用NumLimiter的releaseTicket释放Ticket 客户端使用：\n每次处理请求需要先调用Reserve获取Ticket，获取到后才执行具体的业务逻辑，执行完毕后调用Close方法释放Ticket\nl := numlimiter.New(2) func Do(req Request) error { // 模拟请求request tk, err := l.Reserve(context.Background()) // 申请Ticket if err != nil { // 异常 return err } defer tk.Close() // 释放Ticket // 处理请求req ... } 整个框架定义好了，接着开始撸具体实现\n首先，需要给每个ticket标识一个唯一标识，我们定义一个reqKey序列，通过nextReqKeyLocked方法自增，调用时需要加锁，保证在NumLimiter实例生成的key是唯一，代码如下：\ntype NumLimiter struct { nextKey int64 // 下一个请求的Key ... } // 每次调用nextKey自动+1，调用的时候需要加锁，保证协程安全 func (r *NumLimiter) nextReqKeyLocked() int64 { next := r.nextKey r.nextKey++ return next } 接着，我们开始实现核心的Reserve()方法，梳理后的逻辑如下：\n当颁发的Ticket数量小于maxTicket时，创建一个Ticket直接返回。 如果Ticket数量大于等于maxTicket，就先判断当前wait请求数是否超过maxWait，如果”是“，直接返回相应的error。 如果wait数没超过，就pending等待Ticket释放，同时还得监听是否超时。 实现逻辑之前需要考虑：\nTicket如何管理。想要统一管理已经发放的Ticket数量，就需要有地方存储，还能对NumLimiter中所有方法可见，所以在NumLimiter中增加一个tickets属性，类型为 ：map[int64]*Ticket（注：key 为请求的key，value对应的是已经颁发的Ticket） 管理等待Ticket。同样等待Ticket的请求需要被存储，并且能够被唤醒。于是也可以在NumLimiter增加一个属性：waitTickets，类型为：map[int64]chan struct{}（注：key同样是请求的key，值比较特殊，使用chan，目的是为了其他协程能安全访问，当没数据时读取会pending，被close后会继续，chan的类型我们不关注，所以直接使用空结构体struct{}） 另外，为了保护这些共享资源，还需要一个锁：mu sync.Mutex： type NumLimiter struct { maxTicket int // 最大请求数 maxWait int // 最大等待数量 mu sync.Mutex nextKey int64 // 下一个请求的Key tickets map[int64]*Ticket waitTickets map[int64]chan struct{} ... } 接下来就可以开始实现Reserve方法：\nfunc (r *NumLimiter) Reserve(ctx context.Context) (*Ticket, error) { r.mu.Lock() reqKey := r.nextReqKeyLocked() t := \u0026amp;Ticket{l: r, reqKey: reqKey, lg: r.lg, create: time.Now()} // 当请求数量大于maxTicket就放到waitTickets中等待 if len(r.tickets) \u0026gt;= r.maxTicket { if len(waitTickets) \u0026gt; r.maxWait { return nil, errors.New(\u0026#34;waiting exceed max wait\u0026#34;) } req := make(chan struct{}) now := time.Now() r.lg.Warnf(\u0026#34;request num exceed %d, reqkey [%d] waiting for ticket, req processing num = %d, total wait num = %d\u0026#34;, r.maxTicket, reqKey, len(r.tickets), len(r.waitTickets)+1) r.waitTickets[reqKey] = req r.mu.Unlock() // 需要立即解锁，否则会导致其他协程调用Reserve或releaseTicket方法获取不到锁 select { case \u0026lt;-ctx.Done(): r.lg.Errorf(\u0026#34;limiter wait timeout: key = %d, cost = %f\u0026#34;, reqKey, time.Now().Sub(now).Seconds()) r.mu.Lock() delete(r.waitTickets, reqKey) r.mu.Unlock() select { default: case \u0026lt;-req: t.Close() // 返回ticket } return nil, ctx.Err() case \u0026lt;-req: r.mu.Lock() r.tickets[reqKey] = t r.mu.Unlock() r.lg.Debugf(\u0026#34;req key = %d get ticket, waiting time = %f\u0026#34;, reqKey, time.Now().Sub(now).Seconds()) return t, nil } } r.tickets[reqKey] = t r.mu.Unlock() return t, nil } 虽然代码看着比较长，但是整个实现没太多复杂逻辑，核心代码就是等待ticket和被唤醒部分：\nreq := make(chan struct{}) r.waitTickets[reqKey] = req r.mu.Unlock() // 需要立即解锁，否则会导致其他协程调用Reserve或releaseTicket方法获取不到锁 select { ... case \u0026lt;-req: r.mu.Lock() r.tickets[reqKey] = t r.mu.Unlock() r.lg.Debugf(\u0026#34;req key = %d get ticket, waiting time = %f\u0026#34;, reqKey, time.Now().Sub(now).Seconds()) return t, nil } 这里是利用chan特性，当要pending等待时，会创建一个请求chan：req := make(chan struct{})，然后放到waitTickets后就立即解锁（目的是让其他协程能获取到锁），chan在没数据写入或chan没有被关闭的情况下会pending，如果一旦有ticket释放，会通过close这个chan方式通知继续。 另外，超时的实现是借助context来实现，通过监听ctx.Done()方法，同时还要注意并发问题，超时的时候还是有可能获取到锁，所以还是得再检查一下case \u0026lt;-req是否成立，成立就说明超时的同时也正好获取到ticket，但是由于超时了，ticket就没用了，直接释放t.Close()。\n接着，我们来实现ticket释放逻辑：\n删除tickets中对应的数据。（从tickets移除了，所以相当于将ticket释放了） 如果waitTickets没有数据就直接返回。len(tickets)数量已经-1，相当于ticket释放到池中。 如果waitTickets有等待ticket的请求，就直接通知其中的一个等待ticket的请求可以继续，然后等待请求从waitTickets删除，相当于将要释放的ticket直接移交给等待ticket的请求。 func (r *NumLimiter) releaseTicket(t *Ticket) bool { r.mu.Lock() defer r.mu.Unlock() // 删除tickets中对应的数据 releaseSuccess := true if _, ok := r.tickets[t.reqKey]; ok { delete(r.tickets, t.reqKey) } else { releaseSuccess = false } // 如果waitTickets有等待ticket的请求 if len(r.waitTickets) \u0026gt; 0 { var req chan struct{} var reqKey int64 // 取出一条 for reqKey, req = range r.waitTickets { break } close(req) // 通过close方式，通知等待ticket的协程继续 delete(r.waitTickets, reqKey)// 从waitTickets删除 } return releaseSuccess } 这里的通知方式采用close(req)的方式传输信号，相应在Reserve()方法的select case \u0026lt;-req等待的请求就会收到信号，继续执行，同时将获取到的ticket保存在tickets中，返回对应的ticket后，客户端获取到ticket就可以继续请求的处理。\n另外，实际上releaseTicket方法是不直接暴露给客户端，而是提供给ticket的close方法调用：\nfunc (r *Ticket) Close() { if !r.l.releaseTicket(r) { r.lg.Errorf(\u0026#34;limiter ticket release error: req key = %d\u0026#34;, r.reqKey) } } 这样当获得到ticket后，客户端可以把这ticket对象传到方法，释放的时候就直接调用ticket的close方法，就不需要管NumLimiter对象。\n最后增加一个初始化方法，方便实例化NumLimiter：\nfunc New(maxTicket, maxWait int) *NumLimiter { l := \u0026amp;NumLimiter{ waitTickets: map[int64]chan struct{}{}, tickets: map[int64]*Ticket{}, maxTicket: maxTicket, maxWait:\tmaxWait, } return l } 这样一个完整限量的功能就完成了。\n总结 限量的实现是参考database/sql 设计，核心的思想是如何合理管理ticket，超出限制时借助chan实现等待，还有context实现超时，当ticket释放，通过close chan来实现广播，通知对应的等待请求可以继续。\n","permalink":"/blogs/2022/go/num-limiter-library.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003e关于限流Go官方通过一个采用令牌池的算法的实现：golang.org/x/time/rate，但是，这个限制的是每秒的请求数，有的时候我们希望限制的是系统并发处理的请求数量，类似线程池的功能，需求如下：\u003c/p\u003e","title":"Go并发请求量限制组件分享"},{"content":"引言 Go内置了数据库相关的库 - database/sql，实现数据库操作相关的接口，其中还包含一个很重要的功能 - 连接池，用来实现连接的复用，限制连接的数量，从而提高性能，避免连接数量失控，导致资源消耗不可控。\n本文借Go内置的database/sql库，来一起学习如何一步步设计包含连接池的数据库组件，包括模型抽象、连接复用，以及如何管理连接数。\n设计 模型抽象 首先，我们要对解决领域进行抽象。\n我们目标是设计一个数据库连接组件，所以第一个对象模型很明确 - 数据库对象， 我们将数据库对象抽象为一个DB的结构体，一个对象对应的是一个数据库实例，所以DB必须是单例。\n其次，数据库需要连接，所以可以对连接进行抽象，命名为Conn，这里我们不关心Conn的属性，而是关心行为，所以Conn类型定义成一个interface，包含所需两个方法：预处理方法Prepare和关闭连接方法Close (注：Prepare方法不再继续展开，实际上就是接收一个sql，返回一个实现Stmt接口的预处对象，接着设置一下参数，最后执行数据库操作)。\n由于不同的数据库连接的实现方式会有不同，这时就要考虑隔离变化，对连接的方式进行抽象，定义一个连接接口 - Connector，用来创建连接（依赖倒置原则），当初始化DB的时候再将具体实现注入到DB对象中（也就是依赖注入）。\n最终我们可以得到以下几个接口和结构体：\n// 数据库对象 type DB struct { connector Connector } type Conn interface { Prepare(query string) (Stmt, error) Close() error } // 数据库连接接口 type Connector interface { Connect(context.Context) (Conn, error) } 最后，我们给DB对象增加一个获取连接的方法Conn，在不考虑连接池的情况下，调用connector.Connect(ctx)直接获取连接：\n// 获取一个连接 func (db *DB) Conn(ctx context.Context) (*Conn, error) { return db.connector.Connect(ctx) } 连接复用 当不考虑到连接池时，上面的实现基本满足需求，但是为了提高性能，连接池还是必须的，接下来我们开始设计连接池的功能。\n第一步，需要考虑存储空闲连接，这里采用的是切片来存储：freeConn []*Conn。\n接着，需要考虑属性要定义在哪？！空闲的连接需要能被DB实例中的不同方法访问到，所以我们把freeConn定义为DB的一个属性，同时考虑到对freeConn的访问会存在并发安全的问题，需要增加一个锁mu sync.Mutex来保护：\n// 数据库对象 type DB struct { connector Connector mu sync.Mutex // protects following fields freeConn []*Conn } 数据库连接获取方法Conn就需要修改为：\nfunc (db *DB) Conn(ctx context.Context) (*Conn, error) { db.mu.Lock() // 加锁保护freeConn numFree := len(db.freeConn) if numFree \u0026gt; 0 { conn := db.freeConn[0] // 移除第一个连接 copy(db.freeConn, db.freeConn[1:]) db.freeConn = db.freeConn[:numFree-1] db.mu.Unlock() return conn, nil } db.mu.Unlock() return db.connector.Connect(ctx) // 没有空闲连接，重新创建 } 连接要复用，就不能关闭，用完需要放回连接池中，所以DB需要一个将连接放回连接池的方法 - putConn：\nfunc (db *DB) putConn(dc Conn) { db.mu.Lock() db.freeConn = append(db.freeConn, dc) db.mu.Unlock() } 但是，putConn方法要在怎么被调用？！不能因为增加了连接池功，让客户端的改变使用方式，所以我们应该考虑将putConn调用放到一个合理的地方 - Conn的Close()方法中。\n在没有连接池功能的时候，一个Conn用完了就一定会调用Close()释放资源，有连接池功能后，就不再是直接关闭连接，而是释放到连接池中，提供给后续请求使用。\n对此，我们对Conn进行改造，增加一层代理，命名为PConn，将原来的Conn作为PConn的一个属性，同时实现了Conn接口的两个方法：Prepare和Close，这样我们就可以对Close方法进行拦截，修改它的行为：\ntype PConn interface { db *DB ci Conn } func (pc *PConn) Close() error { dc.db.putConn(pc) } func (pc *PConn) Prepare(query string) (Stmt, error) { return pc.ci.Prepare(query) } 接着我们调整一下Conn的创建方法（也可以重新实现Connector接口，返回的是PConn实例，然后将新的实现注入到DB实例中）\nfunc (db *DB) Conn(ctx context.Context) (Conn, error) { ... c , err := db.connector.Connect(ctx) // 没有空闲连接，重新创建 if err!=nil { return nil, err } return \u0026amp;PConn{ ci: c, db: db, } } 这样当PConn使用完后调用Close方法，就不再是关闭连接，而是将连接释放到DB对象的freeConn中，由于客户端定义的类型是Conn接口，并且PConn也实现了Conn接口，所以无需调整（符合开闭原则）\n到此，连接复用初步完成了，接着就得考虑另外一个核心功能 ：连接数量管理。\n连接数量管理 目前的Conn发现没有连接的时候是调用connector.Connect方法直接创建新连接，没法控制连接的数量，这样很明显是不合理，无限创建连接可能会导致资源耗尽，资源消耗曲线过陡峭，所以我们需要：\n限制连接数量。将连接的数量约束在指定的范围内 连接请求队列。当连接数量达到最大值时，连接请求需要需要放到等待队列中，等待有连接释放。 首先，需要有地方保存当前连接数量和最大连接数，并且要能被对象中的不同方法访问到，所以我们可以给DB增加两个属性：\ntype DB struct { numOpen int // number of opened and pending open connections maxOpen int // \u0026lt;= 0 means unlimited } 接着，需要设计当有请求连接时，发现没有空闲连接，并且连接数量等于maxOpen时要怎么办？\nDatabase/sql里是采用一个map来存储（注：这个有点奇怪，为什么不用队列？），在DB结构体增加一个属性：connRequests，类型为：map[uint64]chan connRequest，其中key/value：\nkey ：请求唯一标识。调用nextRequestKeyLocked方法生成，实际上就是一个自增的序列，只是为了保持唯一 value：等待连接的请求。类型为chan，每个请求建立一个chan通道，利于chan并发安全和阻塞特性（当chan没有值时阻塞等待），chan接收的数据类型为connRequest格式，当其他协程有释放连接时，会将连接放到一个connRequest对象中发送给该chan，connRequest只包含两个属性：conn和err，用来接收返回连接或是异常。 代码如下：\ntype DB struct { ... numOpen int // number of opened and pending open connections maxOpen int // \u0026lt;= 0 means unlimited nextRequest uint64 // Next key to use in connRequests. connRequests map[uint64]chan connRequest } func (db *DB) nextRequestKeyLocked() uint64 { next := db.nextRequest db.nextRequest++ return next } // 连接请求 type connRequest struct { conn *PConn err error } 调整获取连接的方法Conn(ctx context.Context) 逻辑：\n判断freeConn是否有空闲连接，有就返回 判断连接数量numOpen是否大于maxOpen，如果还小于maxOpen，说明还可以创建新连接，创建连接后numOpen++，返回连接 当numOpen已经是大于等于maxOpen，就不能再创建新连接，这是就把请求放到集合connRequests中，等待连接释放。 func (db *DB) Conn(ctx context.Context) (Conn, error) { db.mu.Lock() // 加锁保护freeConn numFree := len(db.freeConn) if numFree \u0026gt; 0 { // 有空闲连接 conn := db.freeConn[0] copy(db.freeConn, db.freeConn[1:]) db.freeConn = db.freeConn[:numFree-1] db.mu.Unlock() return conn, nil } // 连接数已经超出 if db.maxOpen \u0026gt; 0 \u0026amp;\u0026amp; db.numOpen \u0026gt;= db.maxOpen { req := make(chan connRequest, 1) // 创建一个chan，接收连接 reqKey := db.nextRequestKeyLocked() // 生成唯一序号 db.connRequests[reqKey] = req // 放到全局属性，让其他方法能访问到 db.mu.Unlock() select { case \u0026lt;-ctx.Done(): //超时等 // Remove the connection request and ensure no value has been sent // on it after removing. db.mu.Lock() delete(db.connRequests, reqKey) // 移除 db.mu.Unlock() } case ret, ok := \u0026lt;-req: // 收到连接释放 if !ok { return nil, errDBClosed } return ret.conn, ret.err } } // 连接数没超出，可以创建新连接 db.numOpen++ // optimistically db.mu.Unlock() c, err := db.connector.Connect(ctx) // 重新创建 if err != nil { return nil, err } return \u0026amp;PConn{ ci: c, db: db, }, nil } 接着，我们还需要调整连接释放方法 - putConn：\n增加一个bool返回值，告诉调用方连接是否释放成功（如果失败，客户端可以决定关闭连接） 如果连接数numOpen大于 maxOpen时，当前连接直接丢弃，返回false 当len(db.connRequests)大于0时，需要考虑将连接优先给db.connRequests中的请求 最后才将连接放入空闲列表中。 func (db *DB) putConn(dc Conn) bool{ db.mu.Lock() defer db.mu.Unlock() if db.maxOpen \u0026gt; 0 \u0026amp;\u0026amp; db.numOpen \u0026gt; db.maxOpen { return false } // 当有等待连接的请求时 if c := len(db.connRequests); c \u0026gt; 0 { var req chan connRequest var reqKey uint64 for reqKey, req = range db.connRequests { break } delete(db.connRequests, reqKey) // Remove from pending requests. req \u0026lt;- connRequest{ conn: dc, err: err, } return true } // 放入空闲连接池中 db.freeConn = append(db.freeConn, dc) return true } PConn的close方法也要稍微调整一下，如果释放连接失败，需要把连接关闭\nfunc (pc *PConn) Close() error { ok := dc.db.putConn(pc) if !ok { dc.ci.Close() } } 总结 到目前为止，一个较完整的包含连接池的数据库组件完成了，上述代码是参照database/sql设计，去除了一些非核心的代码，整体的设计非常精简，优雅，很多地方都值得借鉴，比如：\n如何对问题域进行抽象。数据库抽象成DB、连接为Conn，连接器Connector等 如何命名一些变量。 connRequest（请求连接）、 freeConn（请求连接）等 如何使用context。实现超时等 并发编程。chan、mutex、全局属性访问，资源约束等 ","permalink":"/blogs/2021/go/database-sql-pool.html","summary":"\u003ch2 id=\"引言\"\u003e引言\u003c/h2\u003e\n\u003cp\u003eGo内置了数据库相关的库 - database/sql，实现数据库操作相关的接口，其中还包含一个很重要的功能 - 连接池，用来实现连接的复用，限制连接的数量，从而提高性能，避免连接数量失控，导致资源消耗不可控。\u003c/p\u003e","title":"Go内置database/sql连接池实现 - 源码学习"},{"content":"背景 测试一个调用http接口时，使用了httptest.NewServer来mock一个http服务端，在验证响应异常状态码时发现奇怪问题，明明设置了异常状态码，但是http.Get始终返回的状态码都是正常的200：\nmockHttpSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Write([]byte(\u0026#34;hello world\u0026#34;)) w.WriteHeader(http.StatusBadRequest) })) resp , err:= http.Get(mockHttpSrv.URL) if err != nil { return } defer resp.Body.Close() fmt.Println(resp.StatusCode) // 输出200 分析 查阅WriteHeader的文档时才发现原来当w.WriteHeader没明确调用时，默认第一次调用Write方法时，会隐式的触发WriteHeader(http.StatusOK)：\n// WriteHeader sends an HTTP response header with the provided // status code. // // If WriteHeader is not called explicitly, the first call to Write // will trigger an implicit WriteHeader(http.StatusOK). // Thus explicit calls to WriteHeader are mainly used to // send error codes. // // The provided code must be a valid HTTP 1xx-5xx status code. // Only one header may be written. Go does not currently // support sending user-defined 1xx informational headers, // with the exception of 100-continue response header that the // Server sends automatically when the Request.Body is read. WriteHeader(statusCode int) 我的单测代码将WriteHeader写在了Write方法之后，所以默认会先触发了WriteHeader(http.StatusOK)。\n但是，为什么后来我调用WriteHeader(http.StatusBadRequest)会无效呢，正常不是应该覆盖前面的方法才对？！\n认真阅读了 WriteHeader源码，原来WriteHeader只允许写入一次Header（通过一个布尔变量：wroteHeader，写入后被标志为true，再次调用就直接return）：\n// WriteHeader implements http.ResponseWriter. func (rw *ResponseRecorder) WriteHeader(code int) { if rw.wroteHeader { return } rw.Code = code rw.wroteHeader = true if rw.HeaderMap == nil { rw.HeaderMap = make(http.Header) } rw.snapHeader = rw.HeaderMap.Clone() } 这样问题就清晰了，是我WriteHeader顺序写错了，应该放在Write方法之前。\n总结 WriteHeader只能调用一次，如果一开始先调用Write，默认会触发WriteHeader(http.StatusOK)，后续再调用WriteHeader就无效。\n所以在开发中如果要测试非200的状态时，需要先设置响应状态码WriteHeader(http.StatusBadRequest)，然后再调用Write方法。\n","permalink":"/blogs/2021/troubleshooting/httptest-writeheader-invalid.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003e测试一个调用http接口时，使用了httptest.NewServer来mock一个http服务端，在验证响应异常状态码时发现奇怪问题，明明设置了异常状态码，但是http.Get始终返回的状态码都是正常的200：\u003c/p\u003e","title":"Go httptest WriteHeader无效问题"},{"content":"背景 当有一个日期字符串（2014-11-12 11:45:26）需要转化为Go的time类型，我们第一时间肯定会想到time包的Parse方法，指定字符串的格式layout：\nlayout := \u0026#34;2006-01-02 15:04:05\u0026#34; str := \u0026#34;2014-11-12 11:45:26\u0026#34; t, err := time.Parse(layout, str) 但是，有个容易忽略的问题，go语言默认的时区用的是UTC，而我们一般要的是本地时区，可以看一下源码：\npackage time func Parse(layout, value string) (Time, error) { return parse(layout, value, UTC, Local) } 这个又和获取当前时间（time.Now）不同，time.Now用的又是本地时区：\nvar Local *Location = \u0026amp;localLoc func Now() Time { sec, nsec, mono := now() mono -= startNano sec += unixToInternal - minWall if uint64(sec)\u0026gt;\u0026gt;33 != 0 { return Time{uint64(nsec), sec + minWall, Local} } return Time{hasMonotonic | uint64(sec)\u0026lt;\u0026lt;nsecShift | uint64(nsec), mono, Local} } 解决方案 这时需要用ParseInLocation方法，指定时区为time.Local\nlayout := \u0026#34;2006-01-02 15:04:05\u0026#34; str := \u0026#34;2014-11-12 11:45:26\u0026#34; t, err := time.ParseInLocation(layout, str, time.Local) 另外有更好的方式，日期格式化的时候也加上时区例如：2006-01-02T15:04:05-0700，这样time.Parse 就能正确转化为指定时区：\nformat:=\u0026#34;2006-01-02T15:04:05-0700\u0026#34; // 0700 表示时区 str := time.Now().Format(format) fmt.Println(str) // 输出：2021-05-08T15:53:33+0800 t, _ := time.Parse(format, str) fmt.Println(t) // 输出：2021-05-08 15:53:33 +0800 CST 总结 如果系统要支持国外和国内用户，建议是格式化采用：2006-01-02T15:04:05-0700，带时区的格式化，这样就能避免时区的解析错误问题\n","permalink":"/blogs/2021/go/go-zone-parse-error.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003e当有一个日期字符串（2014-11-12 11:45:26）需要转化为Go的time类型，我们第一时间肯定会想到time包的Parse方法，指定字符串的格式layout：\u003c/p\u003e","title":"Go时区Parse的坑"},{"content":"背景 Golang的在开发web时，会对不同的请求实现不同的hander方法，通常是实现http.HandlerFunc接口：\n// The HandlerFunc type is an adapter to allow the use of // ordinary functions as HTTP handlers. If f is a function // with the appropriate signature, HandlerFunc(f) is a // Handler that calls f. type HandlerFunc func(ResponseWriter, *Request) 例如：\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;net/http\u0026#34; ) // 处理器函数 func handler(w http.ResponseWriter, r *http.Request) { name := r.URL.Query().Get(\u0026#34;name\u0026#34;) if name == \u0026#34;\u0026#34; { w.WriteHeader(http.StatusBadRequest) fmt.Fprintln(w, \u0026#34;name is required\u0026#34;) return } fmt.Fprintf(w, \u0026#34;Hello, %s!\u0026#34;, name) } func main() { //配置路由 http.HandleFunc(\u0026#34;/\u0026#34;, handler) err := http.ListenAndServe(\u0026#34;:8080\u0026#34;, nil) if err != nil { panic(err) } } 这里的handler通常充当service的适配器，负责接收请求、校验参数、将参数转换为service方法匹配的格式，然后调用对应service方法，最后将结果响应给客户端。另外，实际开发规范中又会要求统一响应格式，所以还要对响应进行封装，最终hander看起来很杂乱，不那么优雅，总结有以下几点：\n1、职责过重\nhandler方法中既要处理接收参数、校验参数、还负责service的调用，和对返回结果处理。\n2、代码重复\nhandler中存在很多重复的逻辑，比如：正常响应时，需要把格式转换为统一响应格式，异常时要打印异常日志、异常结果封装等。\n3、无法统一处理异常\n由于err是直接写入http.ResponseWriter，并且会散落在handler中的不同位置，很难做统一的异常处理。\n4、无法统一处理响应格式\n通常开发规范会约定统一响应格式，例如：\ntype response struct { Code int Message string Error\tstring Data interface{} } Code：编码，20000表示成功、500xxx表示异常等 Message：提示信息 Error：异常信息 Data：正常响应数据 如果不能统一处理，就需要重复在每个handler中构造响应的结构体，例如：\nfunc HelloHandler(w http.ResponseWriter, req *http.Request) { ... repo := response{ Code: 200000, Message: \u0026#34;\u0026#34;, Error: \u0026#34;\u0026#34;, Data: nil, } err := json.NewEncoder(w).Encode(repo) if err !=nil{ log.Error(err) return } w.WriteHeader(http.StatusOK) } 改进方案 思路是减轻hander职责，将异常处理和响应处理这部分通用逻辑剥离出来，由一个公共的中间层来处理。减轻职责后，http.HandleFunc接口就可以优化，由于不再处理响应结果，参数http.ResponseWriter就不需要了，只需要约定返回值为两个参数：一个为响应结果，另外一个为异常：\n// Handler不再需要调用ResponseWriter方法，交由中间层处理 // data：正常响应结果 // err：异常时返回的错误信息 type HandlerFunc func(req *http.Request) (data any, err error) 这样handler调用service方法后，响应内容和异常可以直接返回，就不再需要关心响应结果怎么处理，以及如何响应给客户端：\nfunc HelloHandler(w http.ResponseWriter, req *http.Request) (data interface{}, err error) { name := req.URL.Query().Get(\u0026#34;name\u0026#34;) if name == \u0026#34;\u0026#34; { return nil, errors.New(\u0026#34;name is required\u0026#34;) } return xxService.Find(name) } 最终的handler代码量就会简化很多，同时也更加清晰。\n接下来，就是创建一个中间层适配HandlerAdapt，来统一处理响应结果：\npackage httpx import ( \u0026#34;encoding/json\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;net/http\u0026#34; ) // Handler不再需要调用ResponseWriter方法，交由中间层处理 // data：正常响应结果 // err：异常时返回的错误信息 type HandlerFunc func(req *http.Request) (data any, err error) type response struct { Code int Message string Data interface{} } // 统一处理异常，适配http.HandlerFunc func HandlerAdapt(fn HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, req *http.Request) { data, err := fn(req) if err == nil { successHandler(w, data) } else { errHandler(w, err) } } } // 统一成功处理 func successHandler(w http.ResponseWriter, data any) { resp := response{ Code: 200, Message: \u0026#34;success\u0026#34;, Data: data, } w.WriteHeader(http.StatusOK) err := json.NewEncoder(w).Encode(resp) if err != nil { fmt.Printf(\u0026#34;json encode error: %v\u0026#34;, err) } } // 统一失败处理 func errHandler(w http.ResponseWriter, err error) { resp := response{ Code: 500, Message: \u0026#34;error\u0026#34;, Data: err.Error(), } w.WriteHeader(http.StatusInternalServerError) err = json.NewEncoder(w).Encode(resp) if err != nil { fmt.Printf(\u0026#34;json encode error: %v\u0026#34;, err) } } 最后，调整路由的注册方法，将自定义的hander用适配器httpx.HandlerAdapt包裹：\npackage main import ( \u0026#34;clean-web/common-handler/good/httpx\u0026#34; \u0026#34;net/http\u0026#34; ) // 处理器函数 func handler(r *http.Request) (data any, err error) { ... } func main() { //配置路由 http.HandleFunc(\u0026#34;/\u0026#34;, httpx.HandlerAdapt(handler)) err := http.ListenAndServe(\u0026#34;:8080\u0026#34;, nil) if err != nil { panic(err) } } 这样就实现了将请求参数封装和业务代码调用与响应结果处理的逻辑分离。 但是，每次注册路由都需要用httpx.HandlerAdapt包裹我们自定义的handler，还是会违背了DRY原则：\n//配置路由 http.HandleFunc(\u0026#34;/users\u0026#34;, httpx.HandlerAdapt(userHandler)) http.HandleFunc(\u0026#34;/orders\u0026#34;, httpx.HandlerAdapt(orderHandler)) http.HandleFunc(\u0026#34;/accounts\u0026#34;, httpx.HandlerAdapt(accountHandler)) 可以考虑进一步优化，自定义一个httpx.HandleFunc(pattern string, handler HandlerFunc)方法来替代原来的http.HandleFunc(\u0026hellip;)：\npackage httpx import \u0026#34;net/http\u0026#34; func HandleFunc(pattern string, handler HandlerFunc) { http.HandleFunc(\u0026#34;/users\u0026#34;, HandlerAdapt(handler)) } 路由配置就可以优化为：\nhttpx.HandleFunc(\u0026#34;/users\u0026#34;, userHandler) httpx.HandleFunc(\u0026#34;/orders\u0026#34;, orderHandler) httpx.HandleFunc(\u0026#34;/accounts\u0026#34;, accountHandler) 到此，我们就完成整体的优化，具体代码可以查看：https://github.com/itart-top/clean-web/tree/main/clean-handler/good。\n小结 本文介绍了如何通过增加一个中间层，来优化handler的代码逻辑，使其更好的工程化，最终实现：\n职责单一：改造后的handler将异常和响应的逻辑剥离出来，职责更加单一。 减少重复代码：消除了重复处理err和响应的代码，更加简洁。 统一响应\u0026amp;异常处理：HandlerAdapt统一处理结果，后续需要额外增加异常处理逻辑或是调整响应格式，只需要修改该层逻辑，无需调整hander代码。 另外，该方案同样也适用其他的框架，例如：Gin，封装后的使用方式如下：\npackage main import ( \u0026#34;clean-web/clean-handler/good-gin/ginx\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;net/http\u0026#34; \u0026#34;github.com/gin-gonic/gin\u0026#34; ) func main() { engine := gin.Default() router := ginx.WrapRouter(engine) router.GET(\u0026#34;/users\u0026#34;, userHandler) err := http.ListenAndServe(\u0026#34;:8080\u0026#34;, nil) if err != nil { panic(fmt.Sprintf(\u0026#34;ListenAndServe: %+v\u0026#34;, err)) } } // 处理hello请求的handler。如果有异常返回，响应结果也是直接放回 func userHandler(r *gin.Context) (data any, err error) { return fmt.Sprintf(\u0026#34;Hello user %s!\u0026#34;, r.Param(\u0026#34;name\u0026#34;)), nil } （注：完整代码详见：https://github.com/itart-top/clean-web/tree/main/clean-handler/good-gin）\n","permalink":"/blogs/2021/go/go-http-response-uniform-handler.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003eGolang的在开发web时，会对不同的请求实现不同的hander方法，通常是实现http.HandlerFunc接口：\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-go\" data-lang=\"go\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e// The HandlerFunc type is an adapter to allow the use of\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e// ordinary functions as HTTP handlers. If f is a function\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e// with the appropriate signature, HandlerFunc(f) is a\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e// Handler that calls f.\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003etype\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eHandlerFunc\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003efunc\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003eResponseWriter\u003c/span\u003e, \u003cspan style=\"color:#f92672\"\u003e*\u003c/span\u003e\u003cspan style=\"color:#a6e22e\"\u003eRequest\u003c/span\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e例如：\u003c/p\u003e","title":"Go http handler统一响应\u0026异常处理"},{"content":"Go命名规范 好的命名可以提高代码的可读性，特点：\n统一 ： 容易猜想，约定俗成 简短 ：容易书写（Go尤为强调） 准确 ：准确表达意思 核心准则 声明的地方和使用的地方离得越远，名字就建议越详细，相对也会越长，同样上下文没提供有效的描述也是如此。\n常见命名 Camel命名 Go推荐驼峰命名方式，不建议使用下划线（包括常量，包名）\nGood\nuserManger UserManager Bed\nuser_manager 单词缩写默认全大写，或全小写\u000bGood\nuserID baiduCDN id cdn Bed\nuserId baiduCdn 项目名（仓库名） 多个单词建议采用中划线分隔. 目前github中大多数项目都是使用中划线，不建议采用驼峰式分隔，不要使用下划线(kubernetes中的组件名称不允许使用下划线) 例如\ngithub.com/redis-go github.com/mattn/go-sqlite3 github.com/gin-gonic 命名尽量在三个单词以内。\n命名可以是项目功能的描述；也可以是一个代号（如神话人物的名字，或者希腊语）\n（注：适合采用代号的项目有两种：公司的基础组件或者开源项目，一般这种项目都有详细的文档）\nLocal变量 保持简短。太长的命名有的时候反而使代码不简洁，影响阅读\u000b索引：i （Good），index（Bad）\nreader：简写：r\nbuffer：简写为：b\n避免冗余。命名不要和上下文重叠，例如：\n在user上下文中\nfunc UserCount() int 变量名count 会比userCount更简洁\n在map的上下文下可以简写：v,ok=m[k] 注：一般情况下不需要长命名，长命名出现的情况是func很长，变量很多（意味着你该重构了）\nLocal变量 - 例子1\nBad\nfunc RuneCount(buffer []byte) int { runeCount := 0 for index := 0; index \u0026lt; len(buffer); { if buffer[index] \u0026lt; RuneSelf { index++ } else { _, size := DecodeRune(buffer[index:]) index += size } runeCount++ } return runeCount } Good\nfunc RuneCount(b []byte) int { count := 0 for i := 0; i \u0026lt; len(b); { if b[i] \u0026lt; RuneSelf { i++ } else { _, n := DecodeRune(b[i:]) i += n } count++ } return count } Local变量 - 例子2\nBad\nfunc Read(buffer *Buffer, inBuffer []byte) (size int, err error){ if buffer.empty() { buffer.Reset() } size = copy( inBuffer, buffer.buffer[buffer.offset:]) buffer.offset += size return size, nil } Good\nfunc Read(b *Buffer, p []byte) (n int, err error) { if b.empty() { b.Reset() } n = copy(p, b.buf[b.off:]) b.off += n return n, nil } Receiver命名 方法接收名称也是特殊的参数，一般用一个或两个字母（优先r）\n例如：\u000bfunc (b *Buffer) Read(p []byte) (n int, err error) func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) func (r Rectangle) Size() Point 注：\n同一个接收者的命名要保持全局唯一 不会体现到文档里，指向性强 避免是用\u0026quot;me\u0026quot;, \u0026ldquo;this\u0026rdquo; or \u0026ldquo;self\u0026rdquo; func/method - 参数 和本地变量一样，但是名称还会作为文档，一般规则：\n如果类型具有描述特征，变量名可以简短，例如：\nfunc Escape(w io.Writer, s []byte) func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) 如果类型没有指向性，名字可以完整，例如：strings包：\nHasSuffix(s, suffix string) bool Map(mapping func(rune) rune, s string) string func/method - 返回值 函数/方法可以对返回值定义变量名\n变量名仅作为文档，不能只是为了在方法体内少定义变量\n规则和参数类似，取决于类型是否具有描述性，例如：\nfunc Copy(dst Writer, src Reader) (written int64, err error) func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error) method - get/set Go没对get/set特别支持，必要的时候可以自己定义\u000b。Go对get有不同建议，认为不符合语言习惯，例如：\n读取Persion获取FirstName\u000bBad：\np.GetFirstName() Good：\np.FirstName() package导出命名 包对外导出变量、函数、类型等，在包的上下文中，避免冗余\nGood\nbytes.Buffer strings.Reader\tBad\nbytes.ByteBuffer strings.StringReader 接口命名 如果接口只有一个方法，默认为方法名+er 来命名接口：例如：\ntype Reader interface { Read(p []byte) (n int, err error) } type Purger interface { Purge(u PurgeURL) error } 注：有的时候加er不一定是正确的单词，但是也还是会遵守\n如果接口有多个方法， 会以用一个能准备描述他的用途来命名 type ResponseWriter interface\nerror的命名 自定义error命名通常： “名称+Error” 作为结构体的名字，例如：\ntype TypeError struct { Errors []string } 变量时会用简写err + 名称\nErrShortDst = errors.New(\u0026#34;transform: short destination buffer\u0026#34;) ErrShortSrc = errors.New(\u0026#34;transform: short source buffer\u0026#34;) ErrEndOfSpan = errors.New(\u0026#34;transform: input and output are not identical\u0026#34;) 包命名 包名选择有意义的名称，尽量避免：util ， common bytes.Buffer ioutil.ReadFile strconv.Atoi import路径 路径中的最后一段尽量和包名保持一致，例如：\n\u0026ldquo;net/http\u0026rdquo; // package http\u000b调用：http.File\n路径尽量流畅，避免类似这样：\n“github.com/goauth/oauth2”\u000b类库一般会把代码放在根目录：\n“github.com/oauth2”\n路径都是小写，尽量避免混合大小写\n常用缩写 src = source srv = server arg = argument conn = connect, connection attr = attribute abs = absolute min = minimum len = length auth = authenticate buf = buffer ctl = control ctx = context str = string msg = message fmt = format dest = destination diff = difference orig = original recv = receive ref = reference repo = repository util = utility fmt = format 参考资料:\n常用命名缩写：https://github.com/BluntSporks/abbreviation Package names：https://go.dev/blog/package-names Effective Go：https://golang.org/doc/effective_go#names https://google.github.io/styleguide/go/guide#naming ","permalink":"/blogs/2021/go/go-recommend-names.html","summary":"\u003ch2 id=\"go命名规范\"\u003eGo命名规范\u003c/h2\u003e\n\u003cp\u003e好的命名可以提高代码的可读性，特点：\u003c/p\u003e\n\u003cul\u003e\n\u003cli\u003e统一 ： 容易猜想，约定俗成\u003c/li\u003e\n\u003cli\u003e简短 ：容易书写（Go尤为强调）\u003c/li\u003e\n\u003cli\u003e准确 ：准确表达意思\u003c/li\u003e\n\u003c/ul\u003e\n\u003ch2 id=\"核心准则\"\u003e核心准则\u003c/h2\u003e\n\u003cp\u003e声明的地方和使用的地方离得越远，名字就建议越详细，相对也会越长，同样上下文没提供有效的描述也是如此。\u003c/p\u003e","title":"Go推荐命名规范"},{"content":"interface是GO语言中非常重要的类型，它是用来定义一类方法集，只表示对象的行为（Behavior），GO语言的接口和实现不需要显示关联（也就是常说的duck类型），只要实现了接口所有方法，就可以当做该接口的一个实现，赋值给所有引用该接口的变量，从而满足面向对象编程（OOP）中的两个非常重要原则：依赖倒置、里氏替换。\n也正由于这个特点，所以GO接口最佳的实践是：接口尽量的小，根据实际的需求定义的接口大小。\n例如：io包体的Reader/Writer\ntype Reader interface { Read(p []byte) (n int, err error) } type Writer interface { Write(p []byte) (n int, err error) } 更大的接口：net/http\ntype File interface { io.Closer io.Reader io.Seeker Readdir(count int) ([]fs.FileInfo, error) Stat() (fs.FileInfo, error) } 善于合理运用interface，可以使你的代码简洁，更好的解耦，从而提高程序的扩展性，比如：在涉及到input/output设计的时候，引入io.Reader/io.Writer是一个不错的选择。\n借用Steve Francia分享的静态网站生成器HUGO的例子：\nBad\nfunc (page *Page) saveSourceAs(path) { b := new(bytes.Buffer) b.Write(page.Resource.Content) page.saveSource(b.Bytes(), path) } // by 数组需要通过bytes.NewReader转化后储存 func (p *Page) saveSource(by []byte, inPath string) { saveToDisk(inPath,bytes.NewReader(by)) } Good\nfunc (page *Page) saveSourceAs(path) { b := new(bytes.Buffer) b.Write(page.Resource.Content) page.saveSource(b, path) } // by 数组需要通过bytes.NewReader转化后储存 func (p *Page) saveSource(b io.Reader, inPath string) { saveToDisk(inPath, b) } 注：saveSource方法中定义的接收参数是io.Reader，清晰简洁， 易扩展，该方法可以接收所有实现该接口的实例。\n除了bytes.Buffer实现了Read方法\nfunc (b *Buffer) Read(p []byte) (n int, err error) { b.lastRead = opInvalid if b.empty() { // Buffer is empty, reset to recover space. b.Reset() if len(p) == 0 { return 0, nil } return 0, io.EOF } n = copy(p, b.buf[b.off:]) b.off += n if n \u0026gt; 0 { b.lastRead = opRead } return n, nil } 还可以是Conn（http包），实现从网络读取数据：\ntype Conn interface { Read(b []byte) (n int, err error) 或是文件对象File（os包），从本地磁盘读取\nfunc (f *File) Read(b []byte) (n int, err error) { if err := f.checkValid(\u0026#34;read\u0026#34;); err != nil { return 0, err } n, e := f.read(b) return n, f.wrapErr(\u0026#34;read\u0026#34;, e) } 另外，注意的是接口粒度以满足需求为准，不要有额外的方法，否则会导致依赖不清晰。\n例如：我们在网络编程中经常会用到net包的Conn接口：\ntype Conn interface { Read(b []byte) (n int, err error) Write(b []byte) (n int, err error) Close() error LocalAddr() Addr RemoteAddr() Addr SetDeadline(t time.Time) error SetReadDeadline(t time.Time) error SetWriteDeadline(t time.Time) error } 通常我们收到一个conn的时候，会开启一个协程读取数据：\nBad\nfunc handleConn(c net.Conn) { 这里我们使用net.Conn，实际上只是read数据，不会调用Conn其他方法，用io.Reader接口就足够：\nGood\nfunc handleConn(r io.Reader) 如果还涉及关闭连接就用io.ReadCloser\nGood\nfunc handerConn(rc io.ReadCloser) 颗粒度小的接口可以清晰依赖的同时，也方便单测对接口进行mock，更好的聚焦于目标逻辑的测试。\n那要在哪定义iterface呢？！\n首先：一般会把接口定义放在需要使用该接口的package下，而不是实现包下，通常实现类返回的是结构体或是对应指针，这样实现类扩展新的方法就不需要修改对应的接口。同样以io包中的io.Reader/io.Wirter为例，接口定义在io包中，而他的实现bytes.Buffer、os.File等都是在不同包中。\n其次：这就关于接口定义的时机。\n一般来说是由依赖方驱动。\n在当前模块有依赖外部服务的时候，这时候就会定义一个接口，来对外部的依赖资源进行抽象解耦，屏蔽接口的实现。相反，依赖的提供方在不知道使用方需求的时候，定义接口也就没什么意义。\n","permalink":"/blogs/2021/go/go-interface-best-practice.html","summary":"\u003cp\u003einterface是GO语言中非常重要的类型，它是用来定义一类方法集，只表示对象的行为（Behavior），GO语言的接口和实现不需要显示关联（也就是常说的duck类型），只要实现了接口所有方法，就可以当做该接口的一个实现，赋值给所有引用该接口的变量，从而满足面向对象编程（OOP）中的两个非常重要原则：依赖倒置、里氏替换。\u003c/p\u003e","title":"Go接口 - interface 最佳实践"},{"content":"简介 Go不支持泛型，但是对泛型呼声一直存在，所以Go也一直在努力支持，这次发布的1.17实际上就已经包含了泛型的功能，但是默认是不开启，需要增加：-G=3参数来开启：go run -gcflags=-G=3 main.go\nGo的泛型有以下应用场景\n例子 泛化形参数组 定义一个函数helloSlice，接收切片参数s，元素类型为任意类型T\n代码：\npackage main import \u0026#34;fmt\u0026#34; // T 自定义类型 func helloSlice[T any] (s []T) { for _, v := range s { fmt.Printf(\u0026#34;%v\u0026#34;, v) } fmt.Print(\u0026#34;\\n\u0026#34;) } func main() { // 调用1：指定T类型为int helloSlice[int]([]int{1, 2, 3}) // 调用2：不指定类型 helloSlice([]string{\u0026#34;hello\u0026#34;, \u0026#34;world\u0026#34;}) } 运行\ngo run -gcflags=-G=3 main.go 输出\n123 helloworld 泛化参数格式 约束参数格式，只允许参数类型是指定格式，例如：约束plus的参数类型必须为 int, string\npackage main import \u0026#34;fmt\u0026#34; type PlusAble interface { type int, string // 限制只能int 和 string类型可以相加 } // 定义T类型为PlusAble，参数a、b类型为T，返回相加结果 func plus[T PlusAble](a, b T) T { return a + b } func main() { fmt.Println(plus(1, 2)) fmt.Println(plus(\u0026#34;hello\u0026#34;, \u0026#34;world\u0026#34;)) } 运行\ngo run -gcflags=-G=3 main.go 输出\n3 helloworld 如果类型非法时会报错\nfmt.Println(plus(int64(1), int64(2))) // 不支持int64 报错：\n# command-line-arguments ./main.go:15:18: int64 does not satisfy PlusAble (int64 not found in int, string) 定义泛化切片 定义一个切片，切片的元素格式为任意类型，代码\npackage main import \u0026#34;fmt\u0026#34; // 泛型切片 type set [T any] []T func main() { vv:=set[int] {1, 3} fmt.Println(vv) } 运行\ngo run -gcflags=-G=3 main.go 输出\n[1 3] 元素参数必须实现指定接口 约束切片参数必须实现指定接口的方法：Print(）\npackage main import \u0026#34;fmt\u0026#34; // 定义接口 type Printer interface { Print() } // 定义一个类型为T的泛型，切片元素的类型为T func doPrints[T Printer] (pp [] T) { for _, p := range pp { p.Print() } } // 自定义类型实现Printer接口 type myPrint struct { Value string } func (p myPrint) Print() { fmt.Println(p.Value) } func main() { var ss [] myPrint ss= append(ss, myPrint{\u0026#34;Hello\u0026#34;}) ss= append(ss, myPrint{\u0026#34;World\u0026#34;}) doPrints(ss) // 保存 } 执行\ngo run -gcflags=-G=3 main.go 结果\nhello world 双重约束 同时切片中的参数必须是指定类型，且实现方法指定方法\n代码\npackage main import \u0026#34;fmt\u0026#34; // 约束元素类型为指定类型、必须实现Print()方法 type Printer interface { type string Print() } // 定义一个类型为T的泛型，切片元素的类型为T func doPrints[T Printer] (pp [] T) { for _, p := range pp { p.Print() } } // 自定义类型实现Printer接口 type myPrint string func (p myPrint) Print() { fmt.Println(p) } func main() { var ss [] myPrint ss= append(ss, myPrint(\u0026#34;Hello\u0026#34;)) ss= append(ss, myPrint(\u0026#34;World\u0026#34;)) doPrints(ss) } 执行\ngo run -gcflags=-G=3 main.go 结果\nhello world 如果元素类型是string没有实现Print方法\nfunc main() { var ss [] string ss= append(ss, \u0026#34;Hello\u0026#34;) ss= append(ss, \u0026#34;World\u0026#34;) doPrints(ss) } 异常\n# command-line-arguments ./main.go:28:10: string does not satisfy Printer (missing method Print) ","permalink":"/blogs/2021/go/go-generic-explore.html","summary":"\u003ch2 id=\"简介\"\u003e简介\u003c/h2\u003e\n\u003cp\u003eGo不支持泛型，但是对泛型呼声一直存在，所以Go也一直在努力支持，这次发布的1.17实际上就已经包含了泛型的功能，但是默认是不开启，需要增加：\u003cstrong\u003e-G=3\u003c/strong\u003e参数来开启：\u003cstrong\u003ego run -gcflags=-G=3 main.go\u003c/strong\u003e\u003c/p\u003e","title":"Go 1.17泛型尝鲜"},{"content":"声明 数组：\nvar array [size] string 切片：\nvar slice [] string 差异：数组的声明需要指定“size”，如果不指定就是为切片（slice）\n初始化 数组：\nvar array1 = [3] string{\u0026#34;one\u0026#34;, \u0026#34;two\u0026#34;, \u0026#34;three\u0026#34;} var array2 = [...] string{\u0026#34;one\u0026#34;, \u0026#34;two\u0026#34;, \u0026#34;three\u0026#34;} array3 := [...] string{\u0026#34;one\u0026#34;, \u0026#34;two\u0026#34;, \u0026#34;three\u0026#34;} // 推荐：无需通过var声明 切片：\nvar slice [] string slice = make([]string, 5, 5) // 指定长度为5，容量为5的切片 slice = make([]string，5) // 指定长度为5，容量为5的切片 slice2 ：= [] string{\u0026#34;one\u0026#34;, \u0026#34;two\u0026#34;, \u0026#34;three\u0026#34;} // 推荐：无需通过var声明 注：大部分情况下如果不知道切片长度，只要声明，无需初始化，单需要往切片增加数据是，通过append添加（声明的切面默认值是nil，但是append并不会异常）\n常用操作 读取 数组\n数组一般是在for循环中通过索引，或是range 直接读取：\naa := [5] string{} for i, a := range aa { // aa的副本 fmt.Println(\u0026#34;i= \u0026#34;, i, \u0026#34;, s=\u0026#34;, a) } for i:=0; i\u0026lt; len(aa); i++ { fmt.Println(\u0026#34;i= \u0026#34;, i, \u0026#34;, s=\u0026#34;, aa[i]) } 注意：\nrange 的是数组的副本，也是就是说会把aa拷贝一份，并且读取出来的项也是对应的副本，所以对项的修改是不会影响原有的数组，当aa比较大的时候会影响性能，所以可以采用读取数组指针的方式来优化：\nfor i, a := range \u0026amp;aa { // 这里拷贝的会是aa的指针 fmt.Println(\u0026#34;i= \u0026#34;, i, \u0026#34;, s=\u0026#34;, a) } 切片\n切片的读取和数组类似一般是在for循环中通过索引，或是range 直接读取：\naa := [] string{“hello”, \u0026#34;world\u0026#34;} for i, a := range aa { // aa副本，但是由于切片时特殊的结构体，并不会保存整个数组，而是数据组第一个元素的地址，所以就算副本对性能也不会有太大影响 fmt.Println(\u0026#34;i= \u0026#34;, i, \u0026#34;, s=\u0026#34;, a) } for i:=0; i\u0026lt; len(aa); i++ { fmt.Println(\u0026#34;i= \u0026#34;, i, \u0026#34;, s=\u0026#34;, aa[i]) } 注意：\n切片和数组存在一些差异，切片range的时候拷贝的是slice的数据，底层还是共享数组，所以修改的时候回会影响原来slice\n添加 数组：\n一个数组中的元素个数总是恒定的，我们无法向其中添加元素，也无法从其中删除元素。但是元素可以通过索引修改值\naa := [5] string{} aa[0] = \u0026#34;张三\u0026#34; 切片：\n切片的底层实际上也是关联一个数组，所以如果新增元素超过数组的容量，内部会重新开辟一个数组大于（小于1024翻倍，大于增加25%）当前的数组\n头部插入\naa := [] string{\u0026#34;张三\u0026#34;, \u0026#34;李四\u0026#34;} result := append([]string{\u0026#34;王五\u0026#34;}, aa...) // result = {\u0026#34;王五\u0026#34;, \u0026#34;张三\u0026#34;, \u0026#34;李四\u0026#34;} 尾部追加\naa := [] string{\u0026#34;张三\u0026#34;, \u0026#34;李四\u0026#34;} result := append(aa, \u0026#34;王五\u0026#34;, \u0026#34;张飞\u0026#34;) // 可以追加多个，result = { \u0026#34;张三\u0026#34;, \u0026#34;李四\u0026#34;, \u0026#34;王五\u0026#34;, \u0026#34;张飞\u0026#34;} 删除 删除第i个元素\n// 第一种方法（保持剩余元素的次序）： s = append(s[:i], s[i+1:]...) // 第二种方法（保持剩余元素的次序）： s = s[:i + copy(s[i:], s[i+1:])] // 上面两种方法都需要复制len(s)-i-1个元素。 // 第三种方法（不保持剩余元素的次序）： s[i] = s[len(s)-1] s = s[:len(s)-1] 条件删除：keep判断条件，需要保留的返回true\nfunc filter(data [] *T, keep func(item *T) bool, clear bool) [] *T{ result:=data[:0] // 复用data内存，无需另外开辟。（注：会修改原切片共享数组内容） for _, d := range data { if keep(d) { result = append(result, d) } } if clear { // 避免暂时性的内存泄露。 temp := data[len(result):] for i := range temp { temp[i] = nil // t0是类型T的零值 } } return result } 拷贝 拷贝b切片\n方法1\nvar b [] T if a!=nil{ b = make([]T, len(a)) copy(b, a) } 方法2\nvar b [] T if a!=nil{ b = append([]T(nil), a...) } 方法3（最简洁）\nb = append(a[:0:0], a...) 这里就利用了当a为nil的是时候，a[:0:0]并不会报错，仍然会是nil且a[:0:0] == nil为true\n","permalink":"/blogs/2021/go/go-array-slice-demo.html","summary":"\u003ch2 id=\"声明\"\u003e声明\u003c/h2\u003e\n\u003cp\u003e数组：\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-go\" data-lang=\"go\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003earray\u003c/span\u003e [\u003cspan style=\"color:#a6e22e\"\u003esize\u003c/span\u003e] \u003cspan style=\"color:#66d9ef\"\u003estring\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e切片：\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-go\" data-lang=\"go\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eslice\u003c/span\u003e [] \u003cspan style=\"color:#66d9ef\"\u003estring\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e\u003cstrong\u003e差异\u003c/strong\u003e：数组的声明需要指定“\u003cstrong\u003esize\u003c/strong\u003e”，如果不指定就是为切片（slice）\u003c/p\u003e\n\u003ch2 id=\"初始化\"\u003e初始化\u003c/h2\u003e\n\u003cp\u003e\u003cstrong\u003e数组：\u003c/strong\u003e\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-go\" data-lang=\"go\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003earray1\u003c/span\u003e = [\u003cspan style=\"color:#ae81ff\"\u003e3\u003c/span\u003e] \u003cspan style=\"color:#66d9ef\"\u003estring\u003c/span\u003e{\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;one\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;two\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;three\u0026#34;\u003c/span\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003earray2\u003c/span\u003e = [\u003cspan style=\"color:#f92672\"\u003e...\u003c/span\u003e] \u003cspan style=\"color:#66d9ef\"\u003estring\u003c/span\u003e{\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;one\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;two\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;three\u0026#34;\u003c/span\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#a6e22e\"\u003earray3\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e:=\u003c/span\u003e [\u003cspan style=\"color:#f92672\"\u003e...\u003c/span\u003e] \u003cspan style=\"color:#66d9ef\"\u003estring\u003c/span\u003e{\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;one\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;two\u0026#34;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;three\u0026#34;\u003c/span\u003e} \u003cspan style=\"color:#75715e\"\u003e// 推荐：无需通过var声明\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e\u003cstrong\u003e切片：\u003c/strong\u003e\u003c/p\u003e","title":"Go数组\u0026切片使用"},{"content":"问题 exec.Command是Go标准库提供了一个可以很容易地运行外部命令的方法，但是如果使用不当会容易出现僵尸进程的问题。\n僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。\nexec.Command执行的方法有两种，一种是直接调用Run()方法：\ncmd := exec.Command(\u0026#34;ls\u0026#34;) cmd.Run() 另外一种是用start方法\ncmd := exec.Command(\u0026#34;ls\u0026#34;)cmd.Start() cmd.Wait() 区别在于\nRun()方法是在“ls”执行完后才返回\nStart()方法则是异步的，方法调用完并不是代表结束，需要配合cmd.Wait()\nRun和Start方式本质是一样的，查看Run()方法的代码，可以看到实际上也是调用Start后直接调用Wait()，等待Wait返回\nfunc (c *Cmd) Run() error { if err := c.Start(); err != nil { return err } return c.Wait() } Wait的功能就是获取子进程的状态，如果不调用就会导致僵尸进程的，可以用一下例子验证：\n执行\nfunc main() { cmd := exec.Command(\u0026#34;ls\u0026#34;) cmd.Start() time.Sleep(100* time.Second) } 查询僵尸进程（mac）\n✗ ps -A -ostat,ppid,pid,command | grep -e \u0026#39;^[Zz]\u0026#39; Z+ 24625 24626 (ls) // 结果出现一个僵尸进程 结论 cmd.Start()后要记得调用Wait方法，否则会出现僵尸进程\n","permalink":"/blogs/2021/go/exec-command-zombie.html","summary":"\u003ch2 id=\"问题\"\u003e问题\u003c/h2\u003e\n\u003cp\u003eexec.Command是Go标准库提供了一个可以很容易地运行外部命令的方法，但是如果使用不当会容易出现僵尸进程的问题。\u003c/p\u003e\n\u003cblockquote\u003e\n\u003cp\u003e僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。\u003c/p\u003e\n\u003c/blockquote\u003e","title":"exec.Command僵尸进程问题"},{"content":"背景 Go目前流行多个日志组件：logrus、zap、zerolog、seelog，他们有各自的优点，但是使用方式存在差异， 如何屏蔽这些差异，对外提供统一的接口，减少对具体的日志组件依赖，从而方便后续组件替换？\n对此，我们可以增加一层防腐层，定义一套统一的日志接口，业务代码不直接依赖具体的日志实现，而是依赖抽象接口，这样就可以将具体的实现进行隔离，业务代码就不会包含具体日志组件相关的代码，当日志组件需要替换时，只要做一层适配，实现约定好的日志接口方法，就可以无缝进行切换日志组件。\n方案 定义日志接口 我们需要预先定义好一套完整的日志接口：\nlog/log.go\npackage log type Fields map[string]interface{} type Logger interface { WithField(key string, value interface{}) Logger WithFields(fields Fields) Logger Trace(args ...interface{}) Tracef(format string, args ...interface{}) Debug(args ...interface{}) Debugf(format string, args ...interface{}) Info(args ...interface{}) Infof(format string, args ...interface{}) Warn(args ...interface{}) Warnf(format string, args ...interface{}) Error(args ...interface{}) Errorf(format string, args ...interface{}) Panic(args ...interface{}) Panicf(format string, args ...interface{}) Fatal(args ...interface{}) Fatalf(format string, args ...interface{}) } 接口包含日常使用的所有方法，接口没有任何的外部依赖。\n接口定义放在独立的log包下，不需要担心包名和原来的日志冲突，因为到时会替换所有的日志组件\n定义全局日志\n日志组件一般会有一个全局默认的实例，使用的时候直接调用包下对应的函数，例如：\nlog.Info(\u0026#34;hello world\u0026#34;) log.Error(\u0026#34;hello world\u0026#34;) 所以我们同样定义一套包级别的导出方法：\nlog/exported.go\npackage log var std Logger // 标准输出 func WithField(key string, value interface{}) Logger { return std.WithField(key, value) } func WithFields(fields Fields) Logger { return std.WithFields(fields) } func Trace(args ...interface{}) { std.Trace(args...) } func Tracef(format string, args ...interface{}) { std.Tracef(format, args...) } func Debug(args ...interface{}) { std.Debug(args...) } func Debugf(format string, args ...interface{}) { std.Debugf(format, args...) } func Info(args ...interface{}) { std.Info(args...) } func Infof(format string, args ...interface{}) { std.Infof(format, args...) } func Warn(args ...interface{}) { std.Warn(args...) } func Warnf(format string, args ...interface{}) { std.Warnf(format, args...) } func Error(args ...interface{}) { std.Error(args...) } func Errorf(format string, args ...interface{}) { std.Errorf(format, args...) } func Panic(args ...interface{}) { std.Panic(args...) } func Panicf(format string, args ...interface{}) { std.Panicf(format, args...) } func Fatal(args ...interface{}) { std.Fatal(args...) } func Fatalf(format string, args ...interface{}) { std.Fatalf(format, args...) } // 初始化全局日志 func InitGlobal(s Logger) { std = s } 注意：\n全局日志使用前需要调用初始化方法：InitGlobal(s Logger) exported.go同样也是不依赖具体实现，只依赖接口Logger 适配Logrus组件 如果项目要使用Logrus时，我们可以对Logrus做一层适配，实现我们的定义好的接口:\nlog/logrus.go\n/** * @Title Logrus适配 * @Description * @Author hyman * @Date 2021-10-26 **/ package log import ( \u0026#34;github.com/sirupsen/logrus\u0026#34; ) type logrusAdapt struct { l *logrus.Logger } func (s logrusAdapt) WithField(key string, value interface{}) Logger { return newFieldAdapt(s.l.WithField(key, value)) } func (s logrusAdapt) Tracef(format string, args ...interface{}) { s.l.Tracef(format, args...) } func (s logrusAdapt) Debugf(format string, args ...interface{}) { s.l.Debugf(format, args...) } func (s logrusAdapt) Infof(format string, args ...interface{}) { s.l.Infof(format, args...) } func (s logrusAdapt) Warnf(format string, args ...interface{}) { s.l.Warnf(format, args...) } func (s logrusAdapt) Errorf(format string, args ...interface{}) { s.l.Errorf(format, args...) } func (s logrusAdapt) Panicf(format string, args ...interface{}) { s.l.Panicf(format, args...) } func (s logrusAdapt) Fatalf(format string, args ...interface{}) { s.l.Fatalf(format, args...) } func (s logrusAdapt) WithFields(fields Fields) Logger { return newFieldAdapt(s.l.WithFields(logrus.Fields(fields))) } func (s logrusAdapt) Trace(args ...interface{}) { s.l.Trace(args...) } func (s logrusAdapt) Debug(args ...interface{}) { s.l.Debug(args...) } func (s logrusAdapt) Print(args ...interface{}) { s.l.Print(args...) } func (s logrusAdapt) Info(args ...interface{}) { s.l.Info(args...) } func (s logrusAdapt) Warn(args ...interface{}) { s.l.Warn(args...) } func (s logrusAdapt) Error(args ...interface{}) { s.l.Error(args...) } func (s logrusAdapt) Panic(args ...interface{}) { s.l.Panic(args...) } func (s logrusAdapt) Fatal(args ...interface{}) { s.l.Fatal(args...) } // 封装logrus.Entry type fieldAdapt struct { e *logrus.Entry } func (f fieldAdapt) WithField(key string, value interface{}) Logger { return newFieldAdapt(f.e.WithField(key, value)) } func (f fieldAdapt) WithFields(fields Fields) Logger { return newFieldAdapt(f.e.WithFields(logrus.Fields(fields))) } func (f fieldAdapt) Tracef(format string, args ...interface{}) { panic(\u0026#34;implement me\u0026#34;) } func (f fieldAdapt) WithError(err error) Logger { return newFieldAdapt(f.e.WithError(err)) } func (f fieldAdapt) Debugf(format string, args ...interface{}) { f.e.Debugf(format, args...) } func (f fieldAdapt) Infof(format string, args ...interface{}) { f.e.Infof(format, args...) } func (f fieldAdapt) Printf(format string, args ...interface{}) { f.e.Printf(format, args...) } func (f fieldAdapt) Warnf(format string, args ...interface{}) { f.e.Warnf(format, args...) } func (f fieldAdapt) Warningf(format string, args ...interface{}) { f.e.Warningf(format, args...) } func (f fieldAdapt) Errorf(format string, args ...interface{}) { f.e.Errorf(format, args...) } func (f fieldAdapt) Fatalf(format string, args ...interface{}) { f.e.Fatalf(format, args...) } func (f fieldAdapt) Panicf(format string, args ...interface{}) { f.e.Panicf(format, args...) } func (f fieldAdapt) Debug(args ...interface{}) { f.e.Debug(args...) } func (f fieldAdapt) Info(args ...interface{}) { f.e.Info(args...) } func (f fieldAdapt) Print(args ...interface{}) { f.e.Print(args...) } func (f fieldAdapt) Warn(args ...interface{}) { f.e.Warn(args...) } func (f fieldAdapt) Warning(args ...interface{}) { f.e.Warning(args...) } func (f fieldAdapt) Error(args ...interface{}) { f.e.Error(args...) } func (f fieldAdapt) Fatal(args ...interface{}) { f.e.Fatal(args...) } func (f fieldAdapt) Panic(args ...interface{}) { f.e.Panic(args...) } func (f fieldAdapt) Debugln(args ...interface{}) { f.e.Debugln(args...) } func (f fieldAdapt) Infoln(args ...interface{}) { f.e.Infoln(args...) } func (f fieldAdapt) Println(args ...interface{}) { f.e.Println(args...) } func (f fieldAdapt) Warnln(args ...interface{}) { f.e.Warnln(args...) } func (f fieldAdapt) Warningln(args ...interface{}) { f.e.Warningln(args...) } func (f fieldAdapt) Errorln(args ...interface{}) { f.e.Errorln(args...) } func (f fieldAdapt) Fatalln(args ...interface{}) { f.e.Fatalln(args...) } func (f fieldAdapt) Panicln(args ...interface{}) { f.e.Panicln(args...) } func (f fieldAdapt) Trace(args ...interface{}) { f.e.Trace(args...) } func newFieldAdapt(e *logrus.Entry) Logger { return fieldAdapt{e} } func NewLogrusAdapt(l *logrus.Logger) Logger { return \u0026amp;logrusAdapt{ l: l, } } 适配器只是对logrus实例进行轻量级封装，采用组合方式，不会破坏原有逻辑。\nlogrus的WithField功能比较特别，返回的是logrus.Entry对象，所以还需要对logrus.Entry进行适配：fieldAdapt\n项目使用 封装好后，要如何使用？\n首先一般我们是在main.go中实例化我们的日志对象\nimport ( \u0026#34;github.com/sirupsen/logrus\u0026#34; \u0026#34;log/log\u0026#34; ) // 全局日志实例 log.InitGlobal(log.NewLogrusAdapt(logrus.StandardLogger())) // 初始化 // 自定义日志实例 var customLog = log.NewLogrusAdapt(logrus.New()) 我们只是对组件进行适配，组件的配置还是和原来保持一样，例如：日志输出，级别等\nlogrusLog := logrus.New() logrusLog.SetLevel(logrus.InfoLevel) src, err := os.OpenFile(os.DevNull, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644) if err != nil { panic(err) } writer := bufio.NewWriter(src) logrusLog.SetOutput(writer) customLog:=log.NewLogrusAdapt(logrusLog) 注：一般情况下项目只有main.go才会和具体日志组件有耦合，其他地方只会和logger接口进行关联，后续需要替换日志组件，只需要修改main.go。\n全局日志调用\nimport ( \u0026#34;log/log\u0026#34; ) func Hello() { log.Info(\u0026#34;hellow world\u0026#34;) // 调用 } 自定义日志调用\n一般通过注入方式，把具体日志实例注入到模块中，然后在模块中使用：\nmain.go\ncustomLog:=log.NewLogrusAdapt(logrusLog) business:= NewBusiness(customLog) business.go\nimport ( \u0026#34;log/log\u0026#34; ) type Business struct { log log.Logger } func (r *Business) SayHello() { r.log.Info(\u0026#34;say hello\u0026#34;) } func NewBusiness(log log.Logger) *Business { return \u0026amp;Business{log: log} } 组件替换 后续如果需要替换日志组件只需要增加对应的适配器，实现指定的接口，然后修改main.go中的实例方法就可以达到日志替换的目的。\n","permalink":"/blogs/2021/go/go-log-wrap.html","summary":"\u003ch2 id=\"背景\"\u003e背景\u003c/h2\u003e\n\u003cp\u003eGo目前流行多个日志组件：logrus、zap、zerolog、seelog，他们有各自的优点，但是使用方式存在差异， 如何屏蔽这些差异，对外提供统一的接口，减少对具体的日志组件依赖，从而方便后续组件替换？\u003c/p\u003e","title":"Go 日志组件封装"},{"content":"状态模式 状态模式用与解决系统中复杂对象的状态转换及不同状态下行为的封装问题。\n定义：\n允许一个对象在其内部状态改变时改变他的行为，对象看起来似乎修改了它的类。\n包含三个角色：\nContext（环境类）：上下文类，拥有多种状态的的对象。包含：一个抽象的state的实例，定义当前状态，方法：request()，setState(State state)\nclass Contest { private State state private int Value public void setState(State state){ this.state = state } public void request() { state.handle(); } } State（抽象状态类）：定义一个接口以封装与环境类的一个特定状态相关的行为（handle），声明不同状态对应的方法，其子类实现。\nabstract class State{ public abstract void handle(); } ConcreteState（具体状态类 ）：具体实现\nclass ConcreteState { public void handle() { xxx } } 状态转换方式：\n环境类负责状态转换\npublic void changeState() { if (value == 0) { this.setState(new ConcreteStateA()) } else { this.setState(new ConcreteStateB()) } } 具体状态实现类状态转换\npublic void changeState(Context ctx) { if (value == 0) { ctx.setState(new ConcreteStateA()) } else { ctx.setState(new ConcreteStateB()) } } 主要优点\n封装了状态转换规则，状态转换封装在环境或具体状态类中，不是分散在一个个业务方法中 状态有关的行为放在一个类中，注入一个不同的状态对象即可使环境对象拥有不同的行为 允许状态转换逻辑与状态对象合成一体，而不是提供一个巨大的条件语句块。 多个环境对象共享一个状态对象，减少系统中对象的个数 主要缺点\n增加系统的类和对象 结构和实现比较复杂 开闭原则支持不太好，增加新的状态需要修改那些负责状态转换的源码 适用场景\n对象的行为依赖于它的状态，状态改变会导致行为的变化 代码中包含大量与对象状态有关的条件语句 观察者模式 一个对象发生变化时通知其他对象，其他对象将相应做出反应。\n定义\n定义对象之间一种一对多依赖关系，每当一个对象状态放生改变时，其相关依赖对象皆通知并被自动更新。别名：发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式，是一种对象行为型模式。\nSubject（目标）：目标又称为主题，观察的对象。方法：增加/删除对象，通知方法notify()，可以是接口，也能是抽象类具体类。\nabstract class Submit { protected ArrayList observers\u0026lt;Observer\u0026gt; = new ArrayList(); public void attach(Observer observer){ observers.add(observer); } public void detach(Observer observer){ } public abstract void notify(); } ConcreteSubject（具体目标）：目标的子类，通常包含经常发生改变的数据，当数据发生改变，通知各个观察者。\nclass ConcreteSubject extends Subject { public void notify() { for (Object obs:observers) { ((Observer)abs).update(); } } } Observer（观察者）：定义观察目标的改变做出反应，一般定义为接口update方法\ninterface Observer{ public void update(); } ConcreteObserver（具体观察者）： 维护一个指向具体目标对象的引用，存储具体观察者的有关状态，实现update方法\nclass ConcreteObserver implements Observer{ public void update() { xx } } JDK事件模型1.0采用责任链模式，改为观察者模式；\nMVC设计模式也是一种观察者模式；\n主要优势\n实现表示层和逻辑层分离。 目标和观察者之间建立一个抽象耦合。 观察者支持广播通信 观察者满足开闭原则 主要缺点\n一个观察者观察目标对象有多个直接和间接观察者，所有观察者都通知会花费很多时间 观察者和观察目标存在循环依赖。观察目标会触发它们之间的循环依赖，导致系统崩溃 没有相应机制让观察者知道目标对象是怎么发生变化。 使用场景\n一个抽象模式有两个方面，其中一个方面依赖另外一个方面，将这个两个方面封装在独立对象可以独立改变和复用 一个对象改变将导致一个或多个对象也发生改变。 需要系统创建一个触发链，A对象的行为将影响B对象，B对象行为将影响C对象..可以创建一种链式触发机制 访问者模式 主要包含访问者和被访问两个主要组成部分，被访问的元素有不同类型，且不同访问者可以对它们进行不同的访问操作。\n定义\n提供一个作用于某对象结构中的各元素的操作表示，它使得可以在不改变各元素的类的前提下定义作用于这些元素的新操作，访问者模式是一种对象的行为型模式。\nVistor（抽象访问者）：为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作\nabstract class Vistor{ public abstract void visit(ConcreateElementA elementA); public abstract void Visit(ConcreateElementB elementB); public void visit(ConcreteElementC elementC) { // 操作C } } ConcreteVisitor（具体访问者）：具体访问者实现了每个由抽象访问者声明的操作，每一个操作作用于访问对象结构中的一种类型的元素\nclass ConcreteVisitor extends Visitor{ public void visit(ConcreteElementA elementA) { // 元素A的操作代码 } public void visit(ConcreteElementB elementB) { // 元素B的操作代码 } } Element（抽象元素）：接口或抽象类，定义一个accept（）方法，该方法通常以一个抽象访问者作为参数\ninterfact Element{ public void accept(Visitor visitor) } ConcreateElement（具体访问者）：实现accept（）方法，方法中调用访问者的访问方法，完成对一个元素的操作。\nclass ConcreteElmentA implements Element{ public void accept(Vistor vistor){ visitor.visit(this); } public void operationA() { // 业务方法 } } ObjectStructure（对象结构）：元素集合，提供了遍历其内部元素的方法，可以结合组合模式来实现，也可以是一个简单的集合对象\nclass ObjectStructure{ private ArrayList\u0026lt;Element\u0026gt; list = new ArrayList\u0026lt;Element\u0026gt;(); public void accept(Vistor vistor) { Iterator i = list.iterator() while(i.hasNext()) { ((Element)i.next()).accept(vistor) } } } 访问者使用条件较为苛刻，本身复杂，实际使用频道不会很高。\n主要优点\n增加新的访问者操作很方便 有关元素对象的访问行为集中到一个访问者对象中，而不是分散在一个个元素中，职责清晰。 用户能够在不修改现有元素类层次结构的情况下，定义用于该层次结构的操作 主要缺点\n增加新的元素很困难。违背开闭原则 破坏封装。访问者要求访问对象并调用每个元素对象的操作。 适用场景\n对象结构包含多个类型对象，希望对对象实施一些依赖其具体类型的操作 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，需要避免这些操作\u0026quot;污染\u0026quot;这些对象的类. 对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作 策略模式 定义一些独立的类来封装不同的算法，目的是为了将使用和定义分开。\n定义\n定义一系列算法，将每个算法封装起来，并让它们可以相互替换。\nContext（环境类）：使用算法的角色，解决某个问题是可以采用多种策略，维持一个抽象策略的引用实例，用于定义所曹勇的策略\nclass Context{ private AbstractStrategy strategy; public void setStrategy(AbstractStrategy strategy){ this.strategy = strategy; } public void algorigthm() { strategy.algorithm(); } } Strategy（抽象策略类）：声明抽象方法，是所有策略的分类，可以是抽象类、具体类，也可以是接口。\nabstract class AbstractStrategy{ public abstract void algorithm(); } ConcreteStrategy（具体策略类）：实现了再抽象策略类中声明的算法，在运行时，具体策略将覆盖环境类中定义的抽象策略类对象。\nclass ConcreateStrategyA extends AbstractStrategy{ public void algorithm() { // } } 典型应用实例：Container \u0026gt; LayoutManager \u0026gt; (FlowLayout，GridLayout)\n主要优点\n符合开闭原则，可以不修改原有系统的基础上选择算法或增加算法 提供了管理相关算法族的族。继承、公共的代码移到抽象策略类中，避免重复的代码。 可以替换继承关系的办法。 避免多重条件选择语句。 算法复用机制。 主要缺点\n客户端必须知道所有的策略类。 会产生很多具体策略类。 无法同时在客户端使用多个策略类 使用场景\n一个系统需要动态地在几种算法中选择一种 一个对象有很多的行为 不希望客户端知道复杂的与算法相关的数据结构，在具体策略中封装算法与相关数据结构，可以提高算法的保密性与安全性。 模板方法 模板方法提供了一个模板方法定义算法框架，具体步骤的实现可以在其子类中完成。\n定义\n定义一个操作中算法的框架，而将一些步骤延迟到子类中，模板方法使得子类可以在不改变一个算法的结构即可重定义该算法的某些特定的步骤。模板方法是一种类型行为模式。\nAbstractClass（抽象类）：定义一一系列基本操作，可以是具体也可以是抽象，每个基本操作对应算法的一个步骤，在其子类可以重定义或实现这些步骤。\nabstract class AbstractClass{ public void templateMethod() { primitiveOperation1(); primitiveOperation2(); } public void primitiveOperation1(){ xx } public abstract void primitiveOperation2(); } ConcreteClass（具体子类）：抽象类的子类，实现父类中声明的抽象方法\nclass ConcreteClass extends AbstractClass{ public void primitiveOperation2(){ // 实现 } } 主要优点\n在父类形式化地定义一个算法，子类实现细节，实现详细的处理算法不会改变算法中步骤的执行次序 代码复用技术 反向控制，子类覆盖父类的方法。符合单一职责、开闭原则 主要缺点\n要为每个基本方法的不同实现提供一个子类，会导致类变多\n适用场景\n对一些复杂的算法进行分割，固定不变设计为模板方法和父类具体方法，改变的细节有子类实现 公共行为提取到父类，避免代码重复 通过子类来决定父类算法中某个步骤是否执行，实现子类对父类的反控。 命令模式 命令模式可以将请求发送者和接收者完全解耦，发送者和接收者之间没有直接引用关系，发送只要知道如何发送，不必知道如何完成请求\n定义\n将一个请求封装为一个对象，从而可用不同的请求对客户端进行参数化。\nCommand（抽象命令类）；一般是接口或抽象类，声明了用与执行的execute()方法。\nabstract class Command{ public abstract void execute(); } ConcreteCommand（具体命令类）：抽象美丽类的子类，实现execute方法，他对应具体的接收者对象，将接收者对象的动作绑定其中。\npublic ConcreteCommand extends Command{ private Receiver receiver; public void execute() { receiver.action(); } } Invoker（调用者）：请求发送者，它通过命令对象来执行请求，不需要在设计时确定其接收者，只与抽象命令类之间存在关系。\nclass Invoker{ private Command command; public Invoker(Command command) { this.command=command; } public void call() { command.execute(); } } Receiver（接收者）：执行与请求相关的操作，具体实现对请求的业务处理。\nclass Receiver{ public void action(){ ... } } 主要优点\n降低系统的耦合度。 新的命令容易加入到系统中。符合开闭原则。 容易设计一个命令队列或宏命令 为请求的撤销/恢复提供了一种设计和实现方案 主要缺点\n过多具体命令类。\n适用场景\n请求调用者和接收者解耦。请求无效知道接收者存在，接收者也无须关心何时被调用 系统支持撤销/恢复操作 需要一组操作组合在一起形成宏命令 备忘录模式 提供了一种状态恢复的实现机制。\n在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。\nOriginator（原发器）：普通类，可以创建一个备忘录，存储当前内部状态，也可以恢复其内部状态。\npublic class Originator{ private String state; public Memento createMemento() { return new Memento(this); } public void restoreMemento(Memento m) { state = m.state } public String getState() { return this.state; } } Memento（备忘录）：存储原发器的内部状态，根据原发器来决定保存哪些内部状态。\nclass Memento{ private String state; public Memento(Originator o) { state = o.getState(); } } Caretaker（负责人）：又称为管理者，负责保存备忘录，但是不能对备忘录的内容进行操作或检查。\npublic class Catetaker{ private Memento memento; public Memento getMemento() { return memento; } public void setMemento(Memento memento) { this.memento = memento; } } 主要优点\n提供了一个状态恢复的实现机制 实现了对信息的封装，一个备忘录对象是一种原发器对象状态的表示，不会被其他代码改动。 主要缺点\n资源消耗过大\n使用场景\n保存一个对象在某一个时刻的全部或部分状态，需要时恢复，提供撤销功能 防止外界对象破坏一个对象历史状态的封装性，避免将对象历史状态的实现细节暴露给外界对象。 解释器模式 定义\n定义一个语言的文法，建立一个解释器来解耦该语言中的句子，这里的“语言”是指使用规定格式和语法的代码\nAbstractExpression（抽象表达式）：声明了抽象的解释操作，终结和非总结符表达式的公共父类\nabstract class AbstractionExpression{ public abstract void interpret(Context ctx); } TerminalExpression（终结符表达式）：AbstractExpression子类，每个总结符都是该类的一个实例\nclass TerminalExpression extends AbstractExpression{ public void interpret(Context ctx){ // 终结表达式的解释操作 } } NonterminalExpression（非终结符表达式）：AbstractExpression子类，非终结符的解释操作，解释操作一般通过递归的方式来完成\nclass NoterminalExpression extends AbstractExpression{ private AbstractExpression left; private AbstractExpression right; public NoterminalExpression(AbstractExpression left, AbstractExpression right){ this.left = left; this.right = right; } pbulic void interpret(Context ctx){ // 递归调用每一个组成成员 } } Context（环境类）：又称为上下文类，存储解释器之外的一些全局信息，通常它临时存储了需要解释的语句\nclass Context{ private HashMap map = newHashMap(); publiv void assign(string key, string value){ // 设值 } public string lookup(String key){ // 获取存储的值 } } 组合模式 让叶子对象和容器对象的使用具有一致性。\n定义\n组合多个对象形成树形结构以表示具有“整体-部分”关系的层次结构\nComponent（抽象构件）：接口或抽象类，为子构件和容器对象声明接口，可以包含所有子类公用有的行为的声明和实现\nabstract class Component{ public abstract void add(Component c); public abstract void remove(Component c); public abstract void getChild(int i); public abstract void operation(Component c); } Leaf（叶子构件）：没有子节点，实现抽象构件定义的行为\nclass Leaf extends Component{ public void add(Component c){ // 异常或错误提示 } public void remove(Component c){ // 异常或错误提示 } public void getChild(int i){ // 异常或错误提示 } public void operation(Component c){ // 操作 } } Composite（容器构件）：包含子节点，实现抽象构件定义的行为\nclass Comosite extends Component{ private ArrayList\u0026lt;Component\u0026gt; list = new ArrayList\u0026lt;Component\u0026gt;() public void add(Component c){ list.add(c) } public void remove(Component c){ list.remove(c) } public void getChild(int i){ return list.get(i) } public void operation() { for (Object obj: list){ ((Component)obj).operation(); } } } Java SE中的AWT和Swing包的设计就是基于组合模式。\n主要优点\n清晰定义分层次的复杂对象，表示对象的全部和部分层次，让客户端忽略了层次的差异，方便对整个层次结构进行控制。 客户端可以一致使用组合结构或其中的单个对象，不关心是单个还是组合，简化客户端。 增加容器和叶子很方便，符合开闭原则 为树形结构提供了灵活的解决方案 缺点\n难对容器中的类型进行限制。 适用场景\n整体和部分层次结构，希望忽略差异，客户端可以一致对待它们 树形结构 树形结构，分离出叶子对象和容器对象，且它们的类型不固定，希望增加新的类型。 桥接模式\n系统中某个类存在独立变化的维度，通过桥接模式可以将这两个维度分离出来，使两者可以独立扩展。\n定义\n将抽象部分和其实现部分分离，使它们都可以独立地变化。\nAbstraction（抽象类）：抽象类或接口，其中定义了一个Implementor（实现类接口）类型的对象并可以维护该对象，它与Implementor之间具有关联关系，它既可以包含抽象业务方法，也可以包含具体业务方法\nabstract class Abstraction{ protected Implementor impl; public void setImpl(Implementor impl){ this.impl = impl; } public abstract void operation();// 声明抽象业务方法 } RefinedAbstraction（扩充抽象类）：定义接口，通常情况是具体类，不是抽象类，实现Abstraction中的抽象业务方法，可以调用Implementor中定义的业务方法。\nclass RefinedAbstraction extends Abstraction{ public void operation() { // 业务代码 impl.operationImpl(); } } Implementor（实现类接口）：可以和Abstraction完全不同，定义基本操作。\ninterface Implementor{ public void operationImpl(); } ConcreteImplementor（具体实现类）：实现Implementor接口\nclass ConcreteImplementor implement Implementor{ public void operationImpl(){ // xx } } Java虚拟机和JDBC等驱动程序的核心模式之一。\n主要优点\n分离抽象和实现。 可以取代多继承方案 提高里系统的扩展性 主要缺点\n增加系统理解和设计的难道，关联建立在抽象层，要求开发者一开始就要针对抽象层进行设计 要求正确识别系统中两个独立变化的维度，使用范围有一定局限性。 适用场景\n抽象类和具体类之间增加更多的灵活性，避免两个层次建立静态的继承关系。 抽象和实现部分可以以继承方式扩展而互不影响。 类中存在独立变化的维度。 不希望通过继承方式扩展。 外观模式 一个子系统的外部和内部通讯通过一个统一的外观角色进行，将客户端与子系统中的内部复杂性分开。\n定义\n外部与一个子系统通信通过一个统一的外观角色进行，为子系统中的一组接口提供一个一致入口。\nFacade（外观角色）：定义相关系统的功能和职责 SubSystem（子系统角色）：可以有一个或多个子系统角色，不是单独的类，而是一个类的集合，实现子系统的功能。 class Facade{ private SubSystemA obj1= new SubSystemA(); private SubSystemB obj2 = new SubSystemB(); .. public void method() { obj1.method(); obj2.method(); .... } } 简化客户端和子系统的交付，为复杂的子系统提供一个统一的入口。菜单和工具类就是B/S系统的外观角色。\n主要优点\n客户端屏蔽子系统组件 子系统和客户端之间松耦合 子系统修改对其他子系统没有影响 提供一个访问子系统的统一入口 主要缺点\n不能好好限制客户端使用子系统类 设计不当，添加子系统需要修改外观模式的源码，违背开闭原则 适用场景\n复杂子系统提供一个简单入口 客户端和多个子系统存在很大的依赖关系 层次结构中，可以使用外观模式定义系统中每一层的入口，层次之间不直接产生联系，通过外观降低耦合度 中介者模式 简化对象之间的复杂交互，迪米特法则的一个典型应用。\n定义\n封装一系列对象交互，使各对象不需要显式地相互引用，使其耦合松散，可以独立改变它们之间的交互。\nMediator（抽象中介者）：定义一个接口，该接口用于与各同事对象之间进行通信\nabstract class Mediator{ Protected ArrayList\u0026lt;Colleague\u0026gt; colleagues; // 注册，增加同事对象 public void register(Colleague colleague) { colleagues.add(colleagure) } public abstract void operation(c Colleague); } ConcreteMediator（具体中介者）：Mediator子类，协调各个同事对象来协作行为，维持了对各个同事对象的引用\nabstract class ConcreateMediator extends Mediator{ public void operation(c Colleague){ (Colleague)(Colleagues.get(0))).method1();// 通过中介者调用同事类方法 } } Colleague（抽象同事）：各个同事类公有方法，声明了一些抽象方法来供子类实现，同时维持了一个抽象中介者类的引用，子类可以通过该引用来与中介者通信\nabstract class Colleague{ protected Mediator meditor; public Colleague(Mediator mediator){ this.meditor = meditor } public abstract void method1(); public void update(){ mediator.operation(this);// 与中介者通信 } } ConcreateColleague（具体同事类）：Colleague的子类，和其他同事通信先与中介通信，通过中介者间接完成与其他同事类的通信。\nclass ConcreteColleague extends Colleague{ public ConcreteColleague(Mediator mediator){ super(mediator); } public void method1(){ ... } } 客户端直接通过调用具体同事类的update()方法调用中介者和其他同事通信。\n中介者将一个网状的系统结构变成一个以中介者为中心的星状结构，代替原来的多对多关系，事件驱动软件中用的比较广泛，特别是基于GUI的应用软件。\n主要优点\n简化了对象之间的交互，一对多代替了原来的多对多。 将各个同事之间解耦 减少同事子类生成，将原本分布于多个对象之间的行为集中在一起。 主要缺点\n中介者类中包含大量同事之间的交互细节，可能会导致中介者复杂，系统难以维护 适用场景\n系统中对象之间存在复杂引用，结构混乱 一个对象由于引用了其他很多对象，并且直接和对象通信，导致难以复用 想通过一个中间类分装多个类中的行为，而又不想生成太多子类。 享元模式 通过技术实现相同或相似对象的重用。\n定义\n支持大量细粒度对象的复用。\nFlyweight（抽象享元类）：一个接口或抽象类，声明了具体享元的公共方法\nConcreteFlyweight（具体享元类）：实现Flyweight，内部提供了存储空间\nUnsharedConcreteFlyweight（非共享具体享元类）：不同共享的子类可设计为非共享具体享元类。\nFlyweightFactory（享元工厂类）：创建、管理享元对象。\nclass FlyweightFactory{ private HashMap flyweights = new HashMap(); public Flywight getFlyweight(string key){ if (flyweights.ContainsKey(key)){ return (Flywight)flyweights.get(key); } else { Flyweight fw = new ConcreteFlyweight(); flyweights.put(key, fw); return fw; } } } 系统中存在大量的相同或者相似的对象时，可以考虑使用该模式\n主要优点\n减少内存中的对象的数量 外部状态独立，不会影响其内部状态 主要缺点\n系统变为复杂 对象可以共享，需要分离出内部状态和外部状态。 适用场景\n系统中存在大量相同或相似的对象。 对象的大状态可以外部化。 多次重复使用享元对象 ","permalink":"/blogs/2020/design-patterns/design-patterns.html","summary":"\u003ch2 id=\"状态模式\"\u003e状态模式\u003c/h2\u003e\n\u003cp\u003e状态模式用与解决系统中复杂对象的状态转换及不同状态下行为的封装问题。\u003c/p\u003e\n\u003cp\u003e\u003cstrong\u003e定义：\u003c/strong\u003e\u003c/p\u003e\n\u003cp\u003e允许一个对象在其内部状态改变时改变他的行为，对象看起来似乎修改了它的类。\u003c/p\u003e","title":"设计模式"},{"content":"map示例\nmap的range操作 - key、value都是值复制\nmap如何保证按key的某个顺序遍历？- 分两次遍历，第一次取出所有的key并排序；第二次按排序后的key去遍历\nmap的使用用上，有什么要注意的？- 遍历时，尽量只修改或删除当前key，操作非当前的key会带来不可预知的结果\nmap的设计上，我们可以学到 - Go语言对map底层的hmap做了很多层面的优化与封装，也屏蔽了很多实现的细节，适用于绝大多数的 场景；而少部分有极高性能要求的场景，就需要深入到hmap中的相关细节。\nSlice\n熟悉slice的底层数据结构 - 实际存储数据的array，当前长度len与容量cap slice的扩容机制 - 不严格来说，当长度小于1024时，cap翻倍；大于1024时，增加1/4 slice有很多特性与map一致 - 记住一点，代码中操作的slice和map只是上层的，实际存储数据的是array与hmap interface\ninterface的两种类型 - 数据结构的interface，侧重于类型；面向对象中接囗定义的主interface，侧重于方法的声明\n了解interface的底层定义一eface和iface，都分为两个部分：类型与数据\niface底层对类型匹配进行了优化一map+mutex组合\natomic\natomic适用的场景 - 简单简单！不要将atomic用在复杂的业务逻辑中 atomic.value与mutex - 学习用两者解决问题的思路 了解data race 机制 - atom可以有效地减少数据竟争 sync.Map\nsync.Map的核心实现两个map，一个用于写，另一个用于读，这样的设计思想可以类比缓存与数库 sync.Map的局限性 - 如果远高于读，dirty-\u0026gt;readOnly这个类似于刷数据的频率就比较高，不如直接用mutex + map的组台 sync.Map的设计思想保证高频读的无锁结构、空间换时间 Sync.Cond 1．sync.Cond的核心实现 - 通过一个锁，封装了notify通知的实现，包聒了单个通知与广播两种方式 2．sync.Cond与channel的异同 - channel 应用于一收一发的场景，sync.Cond应用于多收一发的场景 3．sync.Cond的使用探索 sync.Pool\n到sync.Pool的核心作用 - 读源码，缓存稍后频繁使甲的对象+减轻GC压力 sync.Pool的Put与Get - Put的顺序为Iocal private -\u0026gt; local shared，Get的顺序为local private -\u0026gt; loca shared -\u0026gt; remote 思考sync.Poo应用的核心场景 - 高频使用且生命周期短的对象，且初始化始终一致。如：fmt 探索Go1.13引入victim的作用 - 了解victim cache的机制 Channel关闭通知例子\ntype sub struct { closing chan chan error updates chan string } func (s *sub) Close() error { //tip 核心逻辑：两层通知，第一层作为准备关闭的通知，第二层作为关闭结果的返回 errc:=make(chanerror) //tip第一步：要关闭时，先传一个chane error过去，通知要关闭了 s.closing \u0026lt;- errc //tip 第三步：从chane error中读取错误，阻塞等待 return \u0026lt;-errc } func (s *sub) loop(){ var err error for{ select{ case errc :=\u0026lt;- s.closing: //tip 第二步：收到关闭后，进行处理，处理后把error传回去 errc\u0026lt;- err close(s.updates) return Context\nContext上下文 - 结合Linux操作系统的CPU上下文切换／子进程与父进程进行理解 如何优雅地使用context - 与setect配合使用，管理协程的生命周期 Context的底层实现是什么？ - mutex与channel的结合，前者用于初始部分参数，后者用于通信 Channel\nchannel用于Goroutine间通信时的注意点 - 合理设置channel的size大小/正确地关闭channel 合理地运用channel的发送与接收 - 运用函数传入参数的定义，限制\u0026lt;-chan和chan \u0026lt;- channel的底层实现 - 环形队列 + 发送、接收的waiter通知 ","permalink":"/blogs/2020/go/go-basic.html","summary":"\u003cp\u003e\u003cstrong\u003emap示例\u003c/strong\u003e\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e\n\u003cp\u003emap的range操作 - key、value都是值复制\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003emap如何保证按key的某个顺序遍历？- 分两次遍历，第一次取出所有的key并排序；第二次按排序后的key去遍历\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003emap的使用用上，有什么要注意的？- 遍历时，尽量只修改或删除当前key，操作非当前的key会带来不可预知的结果\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003emap的设计上，我们可以学到 - Go语言对map底层的hmap做了很多层面的优化与封装，也屏蔽了很多实现的细节，适用于绝大多数的\n场景；而少部分有极高性能要求的场景，就需要深入到hmap中的相关细节。\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ol\u003e","title":"GO基础"},{"content":"传统的ALL IN ONE存在的问题 耦合严重 职责不分明 运维成本高 模块大、臃肿 性能极限差 牵一发动全身 开发成本高、效率低下 组件间相互影响，一旦一个组件有问题整个服务都受影响 扩展性差 分层原则 数据库服务和逻辑服务分离 逻辑服务和接入服务分层 接入服务和展示服务分离 设计原则\n分层服务功能单一 数据 逻辑 接入 展示 分层低耦合 接口交付 分层高内聚 功能聚焦单一 如何分层 前端框架 MVC框架分层\n后端架构 按照功能水平划分 四层： 接入层、逻辑层、数据层、数据存储 接入层、逻辑层、原子服务层、数据存储 五层： 接入层、序列号层（异步消息队列）、逻辑层、数据层、数据存储\n按照业务垂直拆分 房产、招聘、二手 IM、交友等\n常遇到问题 数据不兼容、误删除 数据备份 案例 硬件层面设计 SOA和微服务：SOA比较粗\n互联网主流构成 CPU 32 Processor ，每核2个处理器，开启超线程 2.5GHZ\n内存 32、64、128\n磁盘 SATA机械盘、SAS机械盘、SSD固态硬盘\n网卡\n100、1000mbs\n机型分类\n内存性 128G内存 I/O型 存储型 计算型 GPU 服务器型号\n应用场景 Web业务场景\n内存型、计算型 逻辑业务场景\n计算型 Cache应用\n内存型 测试应用\n虚拟机 RAID RAID 0\n数据分条，加速读写 RAID 1 冗余 RAID10\nRAID 0 + RAID 1 RAID01\nRAID1 + RAID0 RAID5 分布式奇偶校验，独立磁盘\n硬件层面高可用 RAID优化\n较大的磁条大小提供较好的读取性能，特别是系统主要进行顺序读取更是如此。DB机器stripe size 都设置成128K，其他机器选择的是64K\n读写策略\nfoce wb with no battery （不使用电池强制回写）\n多机 系统多机冗余\n数据多机冗余\n保证高可用\nDNS DNS域名劫持校验\nnslookup 查看address whois [address] 查看是不是正确域名提供商 DNS欺骗\n和劫持类似\nDNS解决方案 数据合法性校验\n数据是否完整 数据时效 实时监控 + 商务推动\n语义监控 绕过自动分配DNS\n使用IP地址\n使用httpDNS\n解决问题 LocalDNS被劫持 平均访问延迟下降 用户连接失败率下降（智能连接算法） 使用场景\n需要引入SDK 移动客户端\n浏览器劫持\nDNS劫持\nCDN劫持\n网关劫持\n网关劫持\nHTTPS、SSL、加密\n最佳实践\n尽可能选用HttpDNS 基于IP直连 传统DNS监控、及时报警、商务推动 流量被劫持\n代理劫持\n链路劫持\nCDN 全局负载均衡器\n局部负载均衡\n接入层作用 客户端长短连接管理 建立与客户端通信的加密通道 合法性、正确性校验 整合内部少量的连接 session管理 初步实施攻防 请求转发到逻辑层 逻辑层设计\n垂直拆分：根据每个业务一个模块，独立进程\n无状态\n业务逻辑层不保存任何请求状态、数据，完全对称，负载均衡\n异步调用场景\nI/O，网络I/O\n设置合理的超时时间、重试\n服务降级\n通过队列方式，拒绝低优先服务的 随机丢弃 关闭服务 服务幂等设计\n天然幂等 - 消息设置成已读\n非幂等 - 增加状态达到幂等\n数据存储\n多机存储\n复制\n故障检测\n缓存 加速请求，响应延迟小\n减少存储的读写 压力\n性能评估 ","permalink":"/blogs/2020/ha/high-availability.html","summary":"\u003ch2 id=\"传统的all-in-one存在的问题\"\u003e传统的ALL IN ONE存在的问题\u003c/h2\u003e\n\u003cul\u003e\n\u003cli\u003e耦合严重\u003c/li\u003e\n\u003cli\u003e职责不分明\u003c/li\u003e\n\u003cli\u003e运维成本高\u003c/li\u003e\n\u003cli\u003e模块大、臃肿\u003c/li\u003e\n\u003cli\u003e性能极限差\u003c/li\u003e\n\u003cli\u003e牵一发动全身\u003c/li\u003e\n\u003cli\u003e开发成本高、效率低下\u003c/li\u003e\n\u003cli\u003e组件间相互影响，一旦一个组件有问题整个服务都受影响\u003c/li\u003e\n\u003cli\u003e扩展性差\u003c/li\u003e\n\u003c/ul\u003e\n\u003ch2 id=\"分层原则\"\u003e分层原则\u003c/h2\u003e\n\u003cul\u003e\n\u003cli\u003e数据库服务和逻辑服务分离\u003c/li\u003e\n\u003cli\u003e逻辑服务和接入服务分层\u003c/li\u003e\n\u003cli\u003e接入服务和展示服务分离\u003c/li\u003e\n\u003c/ul\u003e\n\u003cp\u003e设计原则\u003c/p\u003e","title":"高可用"},{"content":"IO模型 同步阻塞IO（Blocking IO）：即传统的IO模型。\n同步非阻塞IO（Non-blocking IO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（New IO）库。\n多路复用IO（IO Multiplexing）：即经典的Reactor设计模式，有时也称为异步阻塞IO，Java中的Selector和Linux中的epoll都是这种模型（Redis单线程为什么速度还那么快，就是因为用了多路复用IO和缓存操作的原因）\n异步IO（Asynchronous IO）：即经典的Proactor设计模式，也称为异步非阻塞IO。\nselect,poll,epoll的区别： select poll epoll 操作方式 遍历 遍历 回调 底层实现 数组 链表 红黑树 IO效率 每次调用都进行线性遍历，时间复杂度为O(n) 每次调用都进行线性遍历，时间复杂度为O(n) 事件通知方式，每当fd就绪，系统注册的回调函数就会被调用，将就绪fd放到readyList里面，时间复杂度O(1) 最大连接数 1024（x86）或2048（x64） 无上限 无上限 fd拷贝 每次调用select，都需要把fd集合从用户态拷贝到内核态 每次调用poll，都需要把fd集合从用户态拷贝到内核态 调用epoll_ctl时拷贝进内核并保存，之后每次epoll_wait不拷贝 epoll是Linux目前大规模网络并发程序开发的首选模型。在绝大多数情况下性能远超select和poll。目前流行的高性能web服务器Nginx正式依赖于epoll提供的高效网络套接字轮询服务。但是，在并发连接不高的情况下，多线程+阻塞I/O方式可能性能更好。\n既然select，poll，epoll都是I/O多路复用的具体的实现，之所以现在同时存在，其实他们也是不同历史时期的产物\nselect出现是1984年在BSD里面实现的 14年之后也就是1997年才实现了poll，其实拖那么久也不是效率问题， 而是那个时代的硬件实在太弱，一台服务器处理1千多个链接简直就是神一样的存在了，select很长段时间已经满足需求 2002, 大神 Davide Libenzi 实现了epoll (1)select==\u0026gt;时间复杂度O(n)\n它仅仅知道了，有I/O事件发生了，却并不知道是哪那几个流（可能有一个，多个，甚至全部），我们只能无差别轮询所有流，找出能读出数据，或者写入数据的流，对他们进行操作。所以select具有O(n)的无差别轮询复杂度，同时处理的流越多，无差别轮询时间就越长。\n(2)poll==\u0026gt;时间复杂度O(n)\npoll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态， 但是它没有最大连接数的限制，原因是它是基于链表来存储的.\n(3)epoll==\u0026gt;时间复杂度O(1)\nepoll可以理解为event poll，不同于忙轮询和无差别轮询，epoll会把哪个流发生了怎样的I/O事件通知我们。所以我们说epoll实际上是事件驱动（每个事件关联上fd）的，此时我们对这些流的操作都是有意义的。（复杂度降低到了O(1)）\nselect，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。\nepoll跟select都能提供多路I/O复用的解决方案。在现在的Linux内核里有都能够支持，其中epoll是Linux所特有，而select则应该是POSIX所规定，一般操作系统均有实现\nselect：\nselect本质上是通过设置或者检查存放fd标志位的数据结构来进行下一步处理。这样所带来的缺点是：\n1、 单个进程可监视的fd数量被限制，即能监听端口的大小有限。\n一般来说这个数目和系统内存关系很大，具体数目可以cat /proc/sys/fs/file-max察看。32位机默认是1024个。64位机默认是2048.\n2、 对socket进行扫描时是线性扫描，即采用轮询的方法，效率较低：\n​ 当套接字比较多的时候，每次select()都要通过遍历FD_SETSIZE个Socket来完成调度,不管哪个Socket是活跃的,都遍历一遍。这会浪费很多CPU时间。如果能给套接字注册某个回调函数，当他们活跃时，自动完成相关操作，那就避免了轮询，这正是epoll与kqueue做的。\n3、需要维护一个用来存放大量fd的数据结构，这样会使得用户空间和内核空间在传递该结构时复制开销大\npoll：\npoll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态，如果设备就绪则在设备等待队列中加入一项并继续遍历，如果遍历完所有fd后没有发现就绪设备，则挂起当前进程，直到设备就绪或者主动超时，被唤醒后它又要再次遍历fd。这个过程经历了多次无谓的遍历。\n它没有最大连接数的限制，原因是它是基于链表来存储的，但是同样有一个缺点：\n1、大量的fd的数组被整体复制于用户态和内核地址空间之间，而不管这样的复制是不是有意义。\n2、poll还有一个特点是“水平触发”，如果报告了fd后，没有被处理，那么下次poll时会再次报告该fd。\nepoll:\nepoll有EPOLLLT和EPOLLET两种触发模式，LT是默认的模式，ET是“高速”模式。LT模式下，只要这个fd还有数据可读，每次 epoll_wait都会返回它的事件，提醒用户程序去操作，而在ET（边缘触发）模式中，它只会提示一次，直到下次再有数据流入之前都不会再提示了，无 论fd中是否还有数据可读。所以在ET模式下，read一个fd的时候一定要把它的buffer读光，也就是说一直读到read的返回值小于请求值，或者 遇到EAGAIN错误。还有一个特点是，epoll使用“事件”的就绪通知方式，通过epoll_ctl注册fd，一旦该fd就绪，内核就会采用类似callback的回调机制来激活该fd，epoll_wait便可以收到通知。\nepoll为什么要有EPOLLET触发模式？\n如果采用EPOLLLT模式的话，系统中一旦有大量你不需要读写的就绪文件描述符，它们每次调用epoll_wait都会返回，这样会大大降低处理程序检索自己关心的就绪文件描述符的效率.。而采用EPOLLET这种边沿触发模式的话，当被监控的文件描述符上有可读写事件发生时，epoll_wait()会通知处理程序去读写。如果这次没有把数据全部读写完(如读写缓冲区太小)，那么下次调用epoll_wait()时，它不会通知你，也就是它只会通知你一次，直到该文件描述符上出现第二次可读写事件才会通知你！！！这种模式比水平触发效率高，系统不会充斥大量你不关心的就绪文件描述符\nepoll的优点：\n1、没有最大并发连接的限制，能打开的FD的上限远大于1024（1G的内存上能监听约10万个端口）； 2、效率提升，不是轮询的方式，不会随着FD数目的增加效率下降。只有活跃可用的FD才会调用callback函数； 即Epoll最大的优点就在于它只管你“活跃”的连接，而跟连接总数无关，因此在实际的网络环境中，Epoll的效率就会远远高于select和poll。\n3、 内存拷贝，利用mmap()文件映射内存加速与内核空间的消息传递；即epoll使用mmap减少复制开销。 select、poll、epoll 区别总结：\n1、支持一个进程所能打开的最大连接数\nselect\n单个进程所能打开的最大连接数有FD_SETSIZE宏定义，其大小是32个整数的大小（在32位的机器上，大小就是3232，同理64位机器上FD_SETSIZE为3264），当然我们可以对进行修改，然后重新编译内核，但是性能可能会受到影响，这需要进一步的测试。\npoll\npoll本质上和select没有区别，但是它没有最大连接数的限制，原因是它是基于链表来存储的\nepoll\n虽然连接数有上限，但是很大，1G内存的机器上可以打开10万左右的连接，2G内存的机器可以打开20万左右的连接\n2、FD剧增后带来的IO效率问题\nselect\n因为每次调用时都会对连接进行线性遍历，所以随着FD的增加会造成遍历速度慢的“线性下降性能问题”。\npoll\n同上\nepoll\n因为epoll内核中实现是根据每个fd上的callback函数来实现的，只有活跃的socket才会主动调用callback，所以在活跃socket较少的情况下，使用epoll没有前面两者的线性下降的性能问题，但是所有socket都很活跃的情况下，可能会有性能问题。\n3、 消息传递方式\nselect\n内核需要将消息传递到用户空间，都需要内核拷贝动作\npoll\n同上\nepoll\nepoll通过内核和用户空间共享一块内存来实现的。\n总结：\n综上，在选择select，p****oll，epoll时要根据具体的使用场合以及这三种方式的自身特点。\n1、表面上看epoll的性能最好，但是在连接数少并且连接都十分活跃的情况下，select和poll的性能可能比epoll好，毕竟epoll的通知机制需要很多函数回调。\n2、select低效是因为每次它都需要轮询。但低效也是相对的，视情况而定，也可通过良好的设计改善\n关于这三种IO多路复用的用法，前面三篇总结写的很清楚，并用服务器回射echo程序进行了测试。连接如下所示：\nselect：IO多路复用之select总结\npoll：O多路复用之poll总结\nepoll：IO多路复用之epoll总结\n今天对这三种IO多路复用进行对比，参考网上和书上面的资料，整理如下：\n1、select实现\nselect的调用过程如下所示：\n（1）使用copy_from_user从用户空间拷贝fd_set到内核空间\n（2）注册回调函数__pollwait\n（3）遍历所有fd，调用其对应的poll方法（对于socket，这个poll方法是sock_poll，sock_poll根据情况会调用到tcp_poll,udp_poll或者datagram_poll）\n（4）以tcp_poll为例，其核心实现就是__pollwait，也就是上面注册的回调函数。\n（5）__pollwait的主要工作就是把current（当前进程）挂到设备的等待队列中，不同的设备有不同的等待队列，对于tcp_poll来说，其等待队列是sk-\u0026gt;sk_sleep（注意把进程挂到等待队列中并不代表进程已经睡眠了）。在设备收到一条消息（网络设备）或填写完文件数据（磁盘设备）后，会唤醒设备等待队列上睡眠的进程，这时current便被唤醒了。\n（6）poll方法返回时会返回一个描述读写操作是否就绪的mask掩码，根据这个mask掩码给fd_set赋值。\n（7）如果遍历完所有的fd，还没有返回一个可读写的mask掩码，则会调用schedule_timeout是调用select的进程（也就是current）进入睡眠。当设备驱动发生自身资源可读写后，会唤醒其等待队列上睡眠的进程。如果超过一定的超时时间（schedule_timeout指定），还是没人唤醒，则调用select的进程会重新被唤醒获得CPU，进而重新遍历fd，判断有没有就绪的fd。\n（8）把fd_set从内核空间拷贝到用户空间。\n总结：\nselect的几大缺点：\n（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大\n（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大\n（3）select支持的文件描述符数量太小了，默认是1024\n2 poll实现\npoll的实现和select非常相似，只是描述fd集合的方式不同，poll使用pollfd结构而不是select的fd_set结构，其他的都差不多,管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是poll没有最大文件描述符数量的限制。poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。\n3、epoll\nepoll既然是对select和poll的改进，就应该能避免上述的三个缺点。那epoll都是怎么解决的呢？在此之前，我们先看一下epoll和select和poll的调用接口上的不同，select和poll都只提供了一个函数——select或者poll函数。而epoll提供了三个函数，epoll_create,epoll_ctl和epoll_wait，epoll_create是创建一个epoll句柄；epoll_ctl是注册要监听的事件类型；epoll_wait则是等待事件的产生。\n对于第一个缺点，epoll的解决方案在epoll_ctl函数中。每次注册新的事件到epoll句柄中时（在epoll_ctl中指定EPOLL_CTL_ADD），会把所有的fd拷贝进内核，而不是在epoll_wait的时候重复拷贝。epoll保证了每个fd在整个过程中只会拷贝一次。\n对于第二个缺点，epoll的解决方案不像select或poll一样每次都把current轮流加入fd对应的设备等待队列中，而只在epoll_ctl时把current挂一遍（这一遍必不可少）并为每个fd指定一个回调函数，当设备就绪，唤醒等待队列上的等待者时，就会调用这个回调函数，而这个回调函数会把就绪的fd加入一个就绪链表）。epoll_wait的工作实际上就是在这个就绪链表中查看有没有就绪的fd（利用schedule_timeout()实现睡一会，判断一会的效果，和select实现中的第7步是类似的）。\n对于第三个缺点，epoll没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。\n总结：\n（1）select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。\n（2）select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。\n","permalink":"/blogs/2020/io/io-model.html","summary":"\u003ch2 id=\"io模型\"\u003eIO模型\u003c/h2\u003e\n\u003cul\u003e\n\u003cli\u003e\n\u003cp\u003e同步阻塞IO（Blocking IO）：即传统的IO模型。\u003c/p\u003e\n\u003cp\u003e\u003cimg alt=\"01a1fe68-1f0d-7d6d-bd36-10a45b339fa3\" loading=\"lazy\" src=\"/blogs/2020/io/io-model/block.png\"\u003e\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e同步非阻塞IO（Non-blocking IO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（New IO）库。\u003c/p\u003e\n\u003cp\u003e\u003cimg alt=\"01a1fe68-1f12-708c-8aaa-84d18f8fe78f\" loading=\"lazy\" src=\"/blogs/2020/io/io-model/non-block.png\"\u003e\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e多路复用IO（IO Multiplexing）：即经典的Reactor设计模式，有时也称为\u003cstrong\u003e异步阻塞IO\u003c/strong\u003e，Java中的Selector和Linux中的epoll都是这种模型（Redis单线程为什么速度还那么快，就是因为用了多路复用IO和缓存操作的原因）\u003c/p\u003e\n\u003cp\u003e\u003cimg alt=\"01a1fe68-1f14-7728-98d4-b1ea765b0387\" loading=\"lazy\" src=\"/blogs/2020/io/io-model/muti.png\"\u003e\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e异步IO（Asynchronous IO）：即经典的Proactor设计模式，也称为\u003cstrong\u003e异步非阻塞IO\u003c/strong\u003e。\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ul\u003e","title":"IO模型"},{"content":" volatile：Java虚拟机提供轻量级同步机制\n保证可见性\nJMM（Java内存模式）：抽象的概念，并不存在，描述的是一种规则和规范。规范：可见性、原子性、有序性\n硬盘 \u0026lt; 内存 \u0026lt; CPU\n主内存就是共享内存，线程工作内存，工作内存修改其他工作内存也可以看见，传值需要通过主内存，不能直接工作内存写入另外一个工作内存。修改第一时间通知其他线程就是内存可见性。\n不保证原子性\nnumber++，分为把变量拷贝到工作内存，然后再操作，操作完拷贝到主内存。\n禁止指令重排序\n源代码 -\u0026gt; 编译器优化的重排 -\u0026gt; 指令并行的重排 -\u0026gt; 内存系统的重排 -\u0026gt; 最终执行的指令\n单线程结果一致。多线程数据依赖性。\nMemory Barrier内存屏障（store指令，load指令），禁止指令重排序优化，强制刷出各种CPU的缓存数据\n单例模式\nDCL（Double check lock）\npublic static SingletomDemo() { if instance == null{ synchronized (SingleonDemo.class){ if (instance == null){ installce = new SingleonDemo(); } } } return instance } 问题：变为null，instance可能没有完成初始化\n","permalink":"/blogs/2020/java/java-concurrence.html","summary":"\u003cul\u003e\n\u003cli\u003e\n\u003cp\u003evolatile：Java虚拟机提供轻量级同步机制\u003c/p\u003e\n\u003cul\u003e\n\u003cli\u003e\n\u003cp\u003e保证可见性\u003c/p\u003e\n\u003cp\u003eJMM（Java内存模式）：抽象的概念，并不存在，描述的是一种规则和规范。规范：可见性、原子性、有序性\u003c/p\u003e\n\u003cp\u003e硬盘 \u0026lt; 内存 \u0026lt; CPU\u003c/p\u003e\n\u003cp\u003e主内存就是共享内存，线程工作内存，工作内存修改其他工作内存也可以看见，传值需要通过主内存，不能直接工作内存写入另外一个工作内存。修改第一时间通知其他线程就是内存可见性。\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e不保证原子性\u003c/p\u003e\n\u003cp\u003enumber++，分为把变量拷贝到工作内存，然后再操作，操作完拷贝到主内存。\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e禁止指令重排序\u003c/p\u003e\n\u003cp\u003e源代码 -\u0026gt; 编译器优化的重排 -\u0026gt; 指令并行的重排 -\u0026gt; 内存系统的重排 -\u0026gt; 最终执行的指令\u003c/p\u003e\n\u003cp\u003e单线程结果一致。多线程数据依赖性。\u003c/p\u003e\n\u003cp\u003eMemory Barrier内存屏障（store指令，load指令），禁止指令重排序优化，强制刷出各种CPU的缓存数据\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ul\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e单例模式\u003c/p\u003e\n\u003cp\u003eDCL（Double check lock）\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003epublic static SingletomDemo() {\n\tif instance == null{\n\t\tsynchronized (SingleonDemo.class){\n\t\t\tif (instance == null){\n\t\t\t\tinstallce = new SingleonDemo();\n\t\t\t}\n\t\t}\n\t}\n\treturn instance\n}\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003e问题：变为null，instance可能没有完成初始化\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ul\u003e","title":"Java 可见性"},{"content":"一、事务的基本要素（ACID） 原子性 整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。\n一致性 一个事务可以封装状态改变（除非它是一个只读的）。事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务有多少。\n也就是说：如果事务是并发多个，系统也必须如同串行事务一样操作。其主要特征是保护性和不变性(Preserving an Invariant)，以转账案例为例，假设有五个账户，每个账户余额是100元，那么五个账户总额是500元，如果在这个5个账户之间同时发生多个转账，无论并发多少个，比如在A与B账户之间转账5元，在C与D账户之间转账10元，在B与E之间转账15元，五个账户总额也应该还是500元，这就是保护性和不变性。\n隔离性 隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务，运行在相同的时间内，执行相同的功能，事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称为串行化，为了防止事务操作间的混淆，必须串行化或序列化请求，使得在同一时间仅有一个请求用于同一数据。\n持久性 在事务完成以后，该事务对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。\n二、事务的并发问题 脏读 事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据\n不可重复读 事务 A 多次读取同一数据，事务 B 在事务A多次读取的过程中，对数据作了更新并提交，导致事务A多次读取同一数据时，结果 不一致。\n幻读 系统管理员A将数据库中所有学生的成绩从具体分数改为ABCDE等级，但是系统管理员B就在这个时候插入了一条具体分数的记录，当系统管理员A改结束后发现还有一条记录没有改过来，就好像发生了幻觉一样，这就叫幻读。\n小结：不可重复读的和幻读很容易混淆，不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表\n三、MySQL事务隔离级别 事务隔离级别 脏读 不可重复读 幻读 读未提交（read-uncommitted） 是 是 是 不可重复读（read-committed） 否 是 是 可重复读（repeatable-read） 否 否 是 串行化（serializable） 否 否 否 ","permalink":"/blogs/2020/db/db-transaction.html","summary":"\u003ch2 id=\"一事务的基本要素acid\"\u003e\u003cstrong\u003e一、事务的基本要素（ACID）\u003c/strong\u003e\u003c/h2\u003e\n\u003ch3 id=\"原子性\"\u003e原子性\u003c/h3\u003e\n\u003cp\u003e整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。\u003c/p\u003e","title":"数据库事务"},{"content":"分布式事务 Eureka：核心注册表信息， 对外提供http接口，底层存储结构\nconcurrentHashMap\u0026lt;String, Map\u0026lt;stirng,Lease\u0026lt;instanceInfo\u0026gt;\u0026gt; 事务管理者（TC/TM）：统计事务状态信息，判断事务是否提交还是回滚。groupId传到另外一个系统\nTC：全局事务协调者-计算\nTM：全局事务管理者-创建事务提交\nRM：资源管理器-DataSourceProxy，ConnectionProxy\nTCC：业务有侵入性\n分布式事务解决方案 消息队列 增加消息队列 发送消息放在事务提交成功后，消息队列重试 2PC（两阶段提交）：发送消息（不能被消费） \u0026gt; 本地事务 \u0026gt; 发送可消费 RabbitMQ如果没收到提交，会去询问 AT 特点业务无侵入，正常事务步骤： 建立连接 \u0026gt; 开启事务 \u0026gt; 执行方法 \u0026gt; wait \u0026gt;提交事务 创建代理Connection，注意close不能关闭，只有实际commit后close 需要数据库支持事务（innodb） TCC 两阶段提交（try，commit，cancel，例如：下单 \u0026gt; 冻结金额（try）\u0026gt; 成功 （commit） or 失败（cancel）） Saga 异常的时候增加修复方法 XA 数据库上锁 分布式ID 数据库自增。 为了保证高可用，主从模式，存在延迟，主主模式 ，通过设置步长保证两个数据库生成不一样ID，例如：奇、偶数，扩展不好\n号段模式-Tinyid。批量获取，用数据库保存当前最大ID和段长\n雪花算法：long 64位\n分布式锁：\n数据库：使用for update 实现\nRedis： Lock 加锁使用set ( \u0026ldquo;key\u0026rdquo;, \u0026ldquo;value\u0026rdquo;, \u0026ldquo;NX\u0026rdquo;, \u0026ldquo;PX\u0026rdquo;, 3000) tryLock setnx unLock: 使用Lua （if redis.call(\u0026lsquo;get\u0026rsquo;, KEY[1]) == ARGV[1] then return redis.call(\u0026lsquo;del\u0026rsquo;, KEY[1]) else return 0 end）判断Value相等才删除\n实现组件：Redisson，红锁，可以依赖多个节点，发给三个有两个成功就成功\nzookeeper： 分布式协调服务，是目录结构。实现原理：创建临时有序节点，判断最小就是持有锁 tryLock: 判断节点序号是否是最小，是获取到锁，如果不是，监听前一个节点，等待唤醒\nHashMap:\n1.8 : 链表长度大于8时，会变成红黑树，新增时加到列表的尾部，解决1.7死锁问题\n数据库扩展 水平切分：数据库结构一模一样，存储根据一定规则把数据分散到不同的数据库中，如：取余方式决定存放到哪个数据库 垂直切分： 将不同的表分到不同数据库，分片只把表的字段拆分到不同数据库，如：根据业务类型分库 读写分离：主（master）节点写，从节（slave）点只读 mycat: 数据库分库分表中间件\n逻辑数据库，客户端直接操作这些逻辑数据库\n","permalink":"/blogs/2020/distribute/distributed-transaction.html","summary":"\u003ch2 id=\"分布式事务\"\u003e分布式事务\u003c/h2\u003e\n\u003cp\u003eEureka：核心注册表信息， 对外提供http接口，底层存储结构\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003econcurrentHashMap\u0026lt;String, Map\u0026lt;stirng,Lease\u0026lt;instanceInfo\u0026gt;\u0026gt;\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003e事务管理者（TC/TM）：统计事务状态信息，判断事务是否提交还是回滚。groupId传到另外一个系统\u003c/p\u003e","title":"分布式"},{"content":"机器规划 机器 角色 软件 192.168.1.5 master docker,etcd,flanneld，kubelet,kube_proxy,kube-apiserver、kube-controller-manager、kube-scheduler 192.168.1.9 node docker,etcd,flanneld,kubelet,kube_proxy 192.168.1.16 node docker,etcd,flanneld,kubelet,kube_proxy 环境准备 1.关闭防火墙（三台机器同时进行）：\nsystemctl stop firewalld \u0026amp;\u0026amp; systemctl disable firewalld 2.关闭SELINUX（三台机器同时进行）：\n#将selinux改成disabled保存并退出 vi /etc/selinux/config SELINUX=disabled 3.关闭Swap（三台机器同时进行）：\nswapoff -a \u0026amp;\u0026amp; sysctl -w vm.swappiness=0 #将内容里面的UUID进行注释 vi /etc/fstab #UUID=75db221b-5797-4f81-ac79-d75622cdf625 /boot 4.安装Docker（三台机器同时进行）：\n#运行该脚本就可以安装Docker18.09版本，若Docker版本太高，安装k8s会出现问题 #!/bin/bash yum remove docker-* yum update -y yum install -y yum-utils device-mapper-persistent-data lvm2 yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo yum -y install docker-ce-18.09.0 docker-ce-cli-18.09.0 systemctl start docker systemctl enable docker echo \u0026#39;{ \u0026#34;registry-mirrors\u0026#34;: [\u0026#34;https://b24tskqv.mirror.aliyuncs.com\u0026#34;] }\u0026#39; \u0026gt; /etc/docker/daemon.json systemctl daemon-reload systemctl restart docker 5.配置主机名和ip地址的对应关系：\nvi /etc/hosts #在该文件中添加（三台机器一起添加） 192.168.1.5 master 192.168.1.9 node1 192.168.1.16 node2 vi /etc/hostname #配置主机名（分别添加） 在192.168.1.5中添加master，并将之前的内容删除 在192.168.1.9中添加node1，并将之前的内容删除 在192.168.1.16中添加node2，并将之前的内容删除 #执行完之后进行重启 reboot 6.免密码登录（三台机器两两配置免密码登录）：\n#三台机器一起执行 ssh-keygen -t rsa #上面这条命令生成公钥和私钥（一路执行回车） #将公钥拷贝给对方，实现免密码登录 ssh-copy-id -i .ssh/id_rsa.pub root@master ssh-copy-id -i .ssh/id_rsa.pub root@node1 ssh-copy-id -i .ssh/id_rsa.pub root@node2 7.创建安装目录（三台机器同时执行）：\nmkdir -p /k8s/etcd/{bin,cfg,ssl} mkdir -p /k8s/kubernetes/{bin,cfg,ssl} 8.安装包的下载链接：\nClient Binaries https://dl.k8s.io/v1.13.1/kubernetes-client-linux-amd64.tar.gz Server Binaries https://dl.k8s.io/v1.13.1/kubernetes-server-linux-amd64.tar.gz Node Binaries https://dl.k8s.io/v1.13.1/kubernetes-node-linux-amd64.tar.gz etcd https://github.com/etcd-io/etcd/releases/download/v3.3.10/etcd-v3.3.10-linux-amd64.tar.gz flannel https://github.com/coreos/flannel/releases/download/v0.10.0/flannel-v0.10.0-linux-amd64.tar.gz 安装kubernetes 安装及配置CFSSL （在master节点执行然后进行拷贝）：\nwget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 chmod +x cfssl_linux-amd64 cfssljson_linux-amd64 cfssl-certinfo_linux-amd64 mv cfssl_linux-amd64 /usr/local/bin/cfssl mv cfssljson_linux-amd64 /usr/local/bin/cfssljson mv cfssl-certinfo_linux-amd64 /usr/bin/cfssl-certinfo 创建认证证书: ETCD 创建 ETCD 证书 cat \u0026lt;\u0026lt; EOF | tee ca-config.json { \u0026#34;signing\u0026#34;: { \u0026#34;default\u0026#34;: { \u0026#34;expiry\u0026#34;: \u0026#34;87600h\u0026#34; }, \u0026#34;profiles\u0026#34;: { \u0026#34;www\u0026#34;: { \u0026#34;expiry\u0026#34;: \u0026#34;87600h\u0026#34;, \u0026#34;usages\u0026#34;: [ \u0026#34;signing\u0026#34;, \u0026#34;key encipherment\u0026#34;, \u0026#34;server auth\u0026#34;, \u0026#34;client auth\u0026#34; ] } } } } EOF 创建 ETCD CA 配置文件 cat \u0026lt;\u0026lt; EOF | tee ca-csr.json { \u0026#34;CN\u0026#34;: \u0026#34;etcd CA\u0026#34;, \u0026#34;key\u0026#34;: { \u0026#34;algo\u0026#34;: \u0026#34;rsa\u0026#34;, \u0026#34;size\u0026#34;: 2048 }, \u0026#34;names\u0026#34;: [ { \u0026#34;C\u0026#34;: \u0026#34;CN\u0026#34;, \u0026#34;L\u0026#34;: \u0026#34;Shenzhen\u0026#34;, \u0026#34;ST\u0026#34;: \u0026#34;Shenzhen\u0026#34; } ] } EOF 创建 ETCD Server 证书 cat \u0026lt;\u0026lt; EOF | tee server-csr.json { \u0026#34;CN\u0026#34;: \u0026#34;etcd\u0026#34;, \u0026#34;hosts\u0026#34;: [ \u0026#34;192.168.1.5\u0026#34;, \u0026#34;192.168.1.9\u0026#34;, \u0026#34;192.168.1.16\u0026#34; ], \u0026#34;key\u0026#34;: { \u0026#34;algo\u0026#34;: \u0026#34;rsa\u0026#34;, \u0026#34;size\u0026#34;: 2048 }, \u0026#34;names\u0026#34;: [ { \u0026#34;C\u0026#34;: \u0026#34;CN\u0026#34;, \u0026#34;L\u0026#34;: \u0026#34;Shenzhen\u0026#34;, \u0026#34;ST\u0026#34;: \u0026#34;Shenzhen\u0026#34; } ] } EOF 生成 ETCD CA 证书和私钥 cfssl gencert -initca ca-csr.json | cfssljson -bare ca - cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server Kubernetes 创建 Kubernetes CA 证书 cat \u0026lt;\u0026lt; EOF | tee ca-config.json { \u0026#34;signing\u0026#34;: { \u0026#34;default\u0026#34;: { \u0026#34;expiry\u0026#34;: \u0026#34;87600h\u0026#34; }, \u0026#34;profiles\u0026#34;: { \u0026#34;kubernetes\u0026#34;: { \u0026#34;expiry\u0026#34;: \u0026#34;87600h\u0026#34;, \u0026#34;usages\u0026#34;: [ \u0026#34;signing\u0026#34;, \u0026#34;key encipherment\u0026#34;, \u0026#34;server auth\u0026#34;, \u0026#34;client auth\u0026#34; ] } } } } EOF cat \u0026lt;\u0026lt; EOF | tee ca-csr.json { \u0026#34;CN\u0026#34;: \u0026#34;kubernetes\u0026#34;, \u0026#34;key\u0026#34;: { \u0026#34;algo\u0026#34;: \u0026#34;rsa\u0026#34;, \u0026#34;size\u0026#34;: 2048 }, \u0026#34;names\u0026#34;: [ { \u0026#34;C\u0026#34;: \u0026#34;CN\u0026#34;, \u0026#34;L\u0026#34;: \u0026#34;Shenzhen\u0026#34;, \u0026#34;ST\u0026#34;: \u0026#34;Shenzhen\u0026#34;, \u0026#34;O\u0026#34;: \u0026#34;k8s\u0026#34;, \u0026#34;OU\u0026#34;: \u0026#34;System\u0026#34; } ] } EOF cfssl gencert -initca ca-csr.json | cfssljson -bare ca - 生成API_SERVER证书 cat \u0026lt;\u0026lt; EOF | tee server-csr.json { \u0026#34;CN\u0026#34;: \u0026#34;kubernetes\u0026#34;, \u0026#34;hosts\u0026#34;: [ \u0026#34;10.0.0.1\u0026#34;, \u0026#34;127.0.0.1\u0026#34;, \u0026#34;192.168.1.5\u0026#34;, \u0026#34;kubernetes\u0026#34;, \u0026#34;kubernetes.default\u0026#34;, \u0026#34;kubernetes.default.svc\u0026#34;, \u0026#34;kubernetes.default.svc.cluster\u0026#34;, \u0026#34;kubernetes.default.svc.cluster.local\u0026#34; ], \u0026#34;key\u0026#34;: { \u0026#34;algo\u0026#34;: \u0026#34;rsa\u0026#34;, \u0026#34;size\u0026#34;: 2048 }, \u0026#34;names\u0026#34;: [ { \u0026#34;C\u0026#34;: \u0026#34;CN\u0026#34;, \u0026#34;L\u0026#34;: \u0026#34;Shenzhen\u0026#34;, \u0026#34;ST\u0026#34;: \u0026#34;Shenzhen\u0026#34;, \u0026#34;O\u0026#34;: \u0026#34;k8s\u0026#34;, \u0026#34;OU\u0026#34;: \u0026#34;System\u0026#34; } ] } EOF cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server 创建 Kubernetes Proxy 证书 cat \u0026lt;\u0026lt; EOF | tee kube-proxy-csr.json { \u0026#34;CN\u0026#34;: \u0026#34;system:kube-proxy\u0026#34;, \u0026#34;hosts\u0026#34;: [], \u0026#34;key\u0026#34;: { \u0026#34;algo\u0026#34;: \u0026#34;rsa\u0026#34;, \u0026#34;size\u0026#34;: 2048 }, \u0026#34;names\u0026#34;: [ { \u0026#34;C\u0026#34;: \u0026#34;CN\u0026#34;, \u0026#34;L\u0026#34;: \u0026#34;Shenzhen\u0026#34;, \u0026#34;ST\u0026#34;: \u0026#34;Shenzhen\u0026#34;, \u0026#34;O\u0026#34;: \u0026#34;k8s\u0026#34;, \u0026#34;OU\u0026#34;: \u0026#34;System\u0026#34; } ] } EOF cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy 部署ETCD 解压安装文件 tar -xvf etcd-v3.3.10-linux-amd64.tar.gz cd etcd-v3.3.10-linux-amd64/ cp etcd etcdctl /k8s/etcd/bin/ 创建etcd配置文件 vim /k8s/etcd/cfg/etcd #[Member] ETCD_NAME=\u0026#34;etcd01\u0026#34; ETCD_DATA_DIR=\u0026#34;/var/lib/etcd/default.etcd\u0026#34; ETCD_LISTEN_PEER_URLS=\u0026#34;https://192.168.1.5:2380\u0026#34; ETCD_LISTEN_CLIENT_URLS=\u0026#34;https://192.168.1.5:2379\u0026#34; #[Clustering] ETCD_INITIAL_ADVERTISE_PEER_URLS=\u0026#34;https://192.168.1.5:2380\u0026#34; ETCD_ADVERTISE_CLIENT_URLS=\u0026#34;https://192.168.1.5:2379\u0026#34; ETCD_INITIAL_CLUSTER=\u0026#34;etcd01=https://192.168.1.5:2380,etcd02=https://192.168.1.9:2380,etcd03=https://192.168.1.16:2380\u0026#34; ETCD_INITIAL_CLUSTER_TOKEN=\u0026#34;etcd-cluster\u0026#34; ETCD_INITIAL_CLUSTER_STATE=\u0026#34;new\u0026#34; 创建 etcd的 systemd unit 文件 vim /usr/lib/systemd/system/etcd.service [Unit] Description=Etcd Server After=network.target After=network-online.target Wants=network-online.target [Service] Type=notify EnvironmentFile=/k8s/etcd/cfg/etcd ExecStart=/k8s/etcd/bin/etcd \\ --name=${ETCD_NAME} \\ --data-dir=${ETCD_DATA_DIR} \\ --listen-peer-urls=${ETCD_LISTEN_PEER_URLS} \\ --listen-client-urls=${ETCD_LISTEN_CLIENT_URLS},http://127.0.0.1:2379 \\ --advertise-client-urls=${ETCD_ADVERTISE_CLIENT_URLS} \\ --initial-advertise-peer-urls=${ETCD_INITIAL_ADVERTISE_PEER_URLS} \\ --initial-cluster=${ETCD_INITIAL_CLUSTER} \\ --initial-cluster-token=${ETCD_INITIAL_CLUSTER_TOKEN} \\ --initial-cluster-state=new \\ --cert-file=/k8s/etcd/ssl/server.pem \\ --key-file=/k8s/etcd/ssl/server-key.pem \\ --peer-cert-file=/k8s/etcd/ssl/server.pem \\ --peer-key-file=/k8s/etcd/ssl/server-key.pem \\ --trusted-ca-file=/k8s/etcd/ssl/ca.pem \\ --peer-trusted-ca-file=/k8s/etcd/ssl/ca.pem Restart=on-failure LimitNOFILE=65536 [Install] WantedBy=multi-user.target 拷贝证书文件 cp ca*pem server*pem /k8s/etcd/ssl 启动ETCD服务 systemctl daemon-reload systemctl enable etcd systemctl start etcd 将启动文件、配置文件拷贝到 节点1、节点2 cd /k8s/ scp -r etcd node1:/k8s/ scp -r etcd node2:/k8s/ scp /usr/lib/systemd/system/etcd.service node1:/usr/lib/systemd/system/etcd.service scp /usr/lib/systemd/system/etcd.service node2:/usr/lib/systemd/system/etcd.service #在node1上面操作 vim /k8s/etcd/cfg/etcd #[Member] ETCD_NAME=\u0026#34;etcd02\u0026#34; ETCD_DATA_DIR=\u0026#34;/var/lib/etcd/default.etcd\u0026#34; ETCD_LISTEN_PEER_URLS=\u0026#34;https://192.168.1.9:2380\u0026#34; ETCD_LISTEN_CLIENT_URLS=\u0026#34;https://192.168.1.9:2379\u0026#34; #[Clustering] ETCD_INITIAL_ADVERTISE_PEER_URLS=\u0026#34;https://192.168.1.9:2380\u0026#34; ETCD_ADVERTISE_CLIENT_URLS=\u0026#34;https://192.168.1.9:2379\u0026#34; ETCD_INITIAL_CLUSTER=\u0026#34;etcd01=https://192.168.1.5:2380,etcd02=https://192.168.1.9:2380,etcd03=https://192.168.1.16:2380\u0026#34; ETCD_INITIAL_CLUSTER_TOKEN=\u0026#34;etcd-cluster\u0026#34; ETCD_INITIAL_CLUSTER_STATE=\u0026#34;new\u0026#34; #在node2上面操作 vim /k8s/etcd/cfg/etcd #[Member] ETCD_NAME=\u0026#34;etcd03\u0026#34; ETCD_DATA_DIR=\u0026#34;/var/lib/etcd/default.etcd\u0026#34; ETCD_LISTEN_PEER_URLS=\u0026#34;https://192.168.1.16:2380\u0026#34; ETCD_LISTEN_CLIENT_URLS=\u0026#34;https://192.168.1.16:2379\u0026#34; #[Clustering] ETCD_INITIAL_ADVERTISE_PEER_URLS=\u0026#34;https://192.168.1.16:2380\u0026#34; ETCD_ADVERTISE_CLIENT_URLS=\u0026#34;https://192.168.1.16:2379\u0026#34; ETCD_INITIAL_CLUSTER=\u0026#34;etcd01=https://192.168.1.5:2380,etcd02=https://192.168.1.9:2380,etcd03=https://192.168.1.16:2380\u0026#34; ETCD_INITIAL_CLUSTER_TOKEN=\u0026#34;etcd-cluster\u0026#34; ETCD_INITIAL_CLUSTER_STATE=\u0026#34;new\u0026#34; 验证集群是否正常运行（在master上操作）\n执行：\n[root@master bin]# ./etcdctl --ca-file=/k8s/etcd/ssl/ca.pem --cert-file=/k8s/etcd/ssl/server.pem --key-file=/k8s/etcd/ssl/server-key.pem --endpoints=\u0026#34;https://192.168.1.5:2379,\\ https://192.168.1.9:2379,\\ https://192.168.1.16:2379\u0026#34; cluster-health 结果：\nmember 2b5e1efdc00a764e is healthy: got healthy result from https://192.168.1.9:2379 member 97797244e0f60935 is healthy: got healthy result from https://192.168.1.5:2379 member d8e778c20ef8bd26 is healthy: got healthy result from https://192.168.1.16:2379 cluster is healthy #注意：启动节点失败将/var/lib/etcd的东西删掉 #启动ETCD集群同时启动二个节点，启动一个节点集群是无法正常启动的； 部署Flannel网络 向 etcd 写入集群 Pod 网段信息 cd /k8s/etcd/ssl/ /k8s/etcd/bin/etcdctl \\ --ca-file=ca.pem --cert-file=server.pem \\ --key-file=server-key.pem \\ --endpoints=\u0026#34;https://192.168.1.5:2379,\\ https://192.168.1.9:2379,https://192.168.1.16:2379\u0026#34; \\ set /coreos.com/network/config \u0026#39;{ \u0026#34;Network\u0026#34;: \u0026#34;172.18.0.0/16\u0026#34;, \u0026#34;Backend\u0026#34;: {\u0026#34;Type\u0026#34;: \u0026#34;vxlan\u0026#34;}}\u0026#39; 解压安装flannel tar -zxvf flannel-v0.10.0-linux-amd64.tar.gz mv flanneld mk-docker-opts.sh /k8s/kubernetes/bin/ 配置Flannel vim /k8s/kubernetes/cfg/flanneld FLANNEL_OPTIONS=\u0026#34;--etcd-endpoints=https://192.168.1.5:2379,https://192.168.1.9:2379,https://192.168.1.16:2379 -etcd-cafile=/k8s/etcd/ssl/ca.pem -etcd-certfile=/k8s/etcd/ssl/server.pem -etcd-keyfile=/k8s/etcd/ssl/server-key.pem\u0026#34; 创建 flanneld 的 systemd unit 文件 vim /usr/lib/systemd/system/flanneld.service [Unit] Description=Flanneld overlay address etcd agent After=network-online.target network.target Before=docker.service [Service] Type=notify EnvironmentFile=/k8s/kubernetes/cfg/flanneld ExecStart=/k8s/kubernetes/bin/flanneld --ip-masq $FLANNEL_OPTIONS ExecStartPost=/k8s/kubernetes/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/subnet.env Restart=on-failure [Install] WantedBy=multi-user.target mk-docker-opts.sh 脚本将分配给 flanneld 的 Pod 子网网段信息写入 /run/flannel/docker 文件，后续 docker 启动时 使用这个文件中的环境变量配置 docker0 网桥； flanneld 使用系统缺省路由所在的接口与其它节点通信，对于有多个网络接口（如内网和公网）的节点，可以用 -iface 参数指定通信接口，如上面的 eth0 接口; flanneld 运行时需要 root 权限； 配置Docker启动指定子网段 vim /usr/lib/systemd/system/docker.service [Unit] Description=Docker Application Container Engine Documentation=https://docs.docker.com After=network-online.target firewalld.service Wants=network-online.target [Service] Type=notify EnvironmentFile=/run/flannel/subnet.env ExecStart=/usr/bin/dockerd $DOCKER_NETWORK_OPTIONS ExecReload=/bin/kill -s HUP $MAINPID LimitNOFILE=infinity LimitNPROC=infinity LimitCORE=infinity TimeoutStartSec=0 Delegate=yes KillMode=process Restart=on-failure StartLimitBurst=3 StartLimitInterval=60s [Install] WantedBy=multi-user.target 将flanneld systemd unit 文件到所有节点 cd /k8s/ scp -r kubernetes node1:/k8s/ scp -r kubernetes node2:/k8s/ scp /k8s/kubernetes/cfg/flanneld node1:/k8s/kubernetes/cfg/flanneld scp /k8s/kubernetes/cfg/flanneld node2:/k8s/kubernetes/cfg/flanneld scp /usr/lib/systemd/system/docker.service node1:/usr/lib/systemd/system/docker.service scp /usr/lib/systemd/system/docker.service node2:/usr/lib/systemd/system/docker.service scp /usr/lib/systemd/system/flanneld.service node1:/usr/lib/systemd/system/flanneld.service scp /usr/lib/systemd/system/flanneld.service node2:/usr/lib/systemd/system/flanneld.service #启动服务（三个节点同时执行） systemctl daemon-reload systemctl start flanneld systemctl enable flanneld systemctl restart docker 部署Master 节点 安装kube-apiserver，kube-scheduler，kube-controller-manager\n环境准备 将二进制文件解压拷贝到master 节点 tar -zxvf kubernetes-server-linux-amd64.tar.gz cd kubernetes/server/bin/ cp kube-scheduler kube-apiserver kube-controller-manager kubectl /k8s/kubernetes/bin/ 拷贝认证 cp *pem /k8s/kubernetes/ssl/ 部署 kube-apiserver 组件 创建 TLS Bootstrapping Token head -c 16 /dev/urandom | od -An -t x | tr -d \u0026#39; \u0026#39; 8d38ad6d7df6b109901bac9d07aaaefe vim /k8s/kubernetes/cfg/token.csv 8d38ad6d7df6b109901bac9d07aaaefe,kubelet-bootstrap,10001,\u0026#34;system:kubelet-bootstrap\u0026#34; 创建apiserver配置文件\nvim /k8s/kubernetes/cfg/kube-apiserver KUBE_APISERVER_OPTS=\u0026#34;--logtostderr=true \\ --v=4 \\ --etcd-servers=https://192.168.1.5:2379,https://192.168.1.9:2379,https://192.168.1.16:2379 \\ --bind-address=192.168.1.5 \\ --secure-port=6443 \\ --advertise-address=192.168.1.5 \\ --allow-privileged=true \\ --service-cluster-ip-range=10.0.0.0/24 \\ --enable-admission-plugins=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \\ --authorization-mode=RBAC,Node \\ --enable-bootstrap-token-auth \\ --token-auth-file=/k8s/kubernetes/cfg/token.csv \\ --service-node-port-range=30000-50000 \\ --tls-cert-file=/k8s/kubernetes/ssl/server.pem \\ --tls-private-key-file=/k8s/kubernetes/ssl/server-key.pem \\ --client-ca-file=/k8s/kubernetes/ssl/ca.pem \\ --service-account-key-file=/k8s/kubernetes/ssl/ca-key.pem \\ --etcd-cafile=/k8s/etcd/ssl/ca.pem \\ --etcd-certfile=/k8s/etcd/ssl/server.pem \\ --etcd-keyfile=/k8s/etcd/ssl/server-key.pem\u0026#34; 创建apiserver.sh\nvim apiserver.sh #!/bin/bash MASTER_ADDRESS=${1:-\u0026#34;192.168.1.195\u0026#34;} ETCD_SERVERS=${2:-\u0026#34;http://127.0.0.1:2379\u0026#34;} cat \u0026lt;\u0026lt;EOF \u0026gt;/opt/kubernetes/cfg/kube-apiserver KUBE_APISERVER_OPTS=\u0026#34;--logtostderr=true \\\\ --v=4 \\\\ --etcd-servers=${ETCD_SERVERS} \\\\ --insecure-bind-address=127.0.0.1 \\\\ --bind-address=${MASTER_ADDRESS} \\\\ --insecure-port=8080 \\\\ --secure-port=6443 \\\\ --advertise-address=${MASTER_ADDRESS} \\\\ --allow-privileged=true \\\\ --service-cluster-ip-range=10.10.10.0/24 \\\\ --admission-control=NamespaceLifecycle,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota,NodeRestriction \\ --authorization-mode=RBAC,Node \\\\ --kubelet-https=true \\\\ --enable-bootstrap-token-auth \\\\ --token-auth-file=/k8s/kubernetes/cfg/token.csv \\\\ --service-node-port-range=30000-50000 \\\\ --tls-cert-file=/k8s/kubernetes/ssl/server.pem \\\\ --tls-private-key-file=//k8s/kubernetes/ssl/server-key.pem \\\\ --client-ca-file=/k8s/kubernetes/ssl/ca.pem \\\\ --service-account-key-file=/k8s/kubernetes/ssl/ca-key.pem \\\\ --etcd-cafile=/k8s/etcd/ssl/ca.pem \\\\ --etcd-certfile=/k8s/etcd/ssl/server.pem \\\\ --etcd-keyfile=/k8s/etcd/ssl/server-key.pem\u0026#34; EOF cat \u0026lt;\u0026lt;EOF \u0026gt;/usr/lib/systemd/system/kube-apiserver.service [Unit] Description=Kubernetes API Server Documentation=https://github.com/kubernetes/kubernetes [Service] EnvironmentFile=-/opt/kubernetes/cfg/kube-apiserver ExecStart=/opt/kubernetes/bin/kube-apiserver \\$KUBE_APISERVER_OPTS Restart=on-failure [Install] WantedBy=multi-user.target EOF 执行执行\n./apiserver.sh 192.168.1.5 https://192.168.1.5:2379,https://192.168.1.9:2379,https://192.168.1.16:2379 启动\nsystemctl daemon-reload systemctl enable kube-apiserver systemctl restart kube-apiserver 创建 kube-apiserver systemd unit 文件\nvim /usr/lib/systemd/system/kube-apiserver.service [Unit] Description=Kubernetes API Server Documentation=https://github.com/kubernetes/kubernetes [Service] EnvironmentFile=-/k8s/kubernetes/cfg/kube-apiserver ExecStart=/k8s/kubernetes/bin/kube-apiserver $KUBE_APISERVER_OPTS Restart=on-failure [Install] WantedBy=multi-user.target 启动服务 systemctl daemon-reload systemctl enable kube-apiserver systemctl start kube-apiserver 查看apiserver是否运行 ps -ef |grep kube-apiserver 部署 kube-scheduler 创建kube-scheduler配置文件 vim /k8s/kubernetes/cfg/kube-scheduler KUBE_SCHEDULER_OPTS=\u0026#34;--logtostderr=true --v=4 --master=127.0.0.1:8080 --leader-elect\u0026#34; –address：在 127.0.0.1:10251 端口接收 http /metrics 请求；kube-scheduler 目前还不支持接收 https 请求； –kubeconfig：指定 kubeconfig 文件路径，kube-scheduler 使用它连接和验证 kube-apiserver； –leader-elect=true：集群运行模式，启用选举功能；被选为 leader 的节点负责处理工作，其它节点为阻塞状态； 创建kube-scheduler systemd unit 文件 vim /usr/lib/systemd/system/kube-scheduler.service [Unit] Description=Kubernetes Scheduler Documentation=https://github.com/kubernetes/kubernetes [Service] EnvironmentFile=-/k8s/kubernetes/cfg/kube-scheduler ExecStart=/k8s/kubernetes/bin/kube-scheduler $KUBE_SCHEDULER_OPTS Restart=on-failure [Install] WantedBy=multi-user.target 启动服务 systemctl daemon-reload systemctl enable kube-scheduler.service systemctl start kube-scheduler.service 查看kube-scheduler是否运行 ps -ef |grep kube-scheduler 部署 kube-controller-manager 创建kube-controller-manager配置文件 vim /k8s/kubernetes/cfg/kube-controller-manager KUBE_CONTROLLER_MANAGER_OPTS=\u0026#34;--logtostderr=true \\ --v=4 \\ --master=127.0.0.1:8080 \\ --leader-elect=true \\ --address=127.0.0.1 \\ --service-cluster-ip-range=10.0.0.0/24 \\ --cluster-name=kubernetes \\ --cluster-signing-cert-file=/k8s/kubernetes/ssl/ca.pem \\ --cluster-signing-key-file=/k8s/kubernetes/ssl/ca-key.pem \\ --root-ca-file=/k8s/kubernetes/ssl/ca.pem \\ --service-account-private-key-file=/k8s/kubernetes/ssl/ca-key.pem\u0026#34; 创建kube-controller-manager systemd unit 文件 vim /usr/lib/systemd/system/kube-controller-manager.service [Unit] Description=Kubernetes Controller Manager Documentation=https://github.com/kubernetes/kubernetes [Service] EnvironmentFile=-/k8s/kubernetes/cfg/kube-controller-manager ExecStart=/k8s/kubernetes/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS Restart=on-failure [Install] WantedBy=multi-user.target 启动服务 systemctl daemon-reload systemctl enable kube-controller-manager systemctl restart kube-controller-manager 查看kube-controller-manager是否启动 systemctl status kube-controller-manager 将可执行文件路/k8s/kubernetes/ 添加到 PATH 变量中 vim /etc/profile PATH=/k8s/kubernetes/bin:$PATH:$HOME/bin source /etc/profile 查看master集群状态 [root@master bin]# kubectl get cs,nodes NAME STATUS MESSAGE ERROR componentstatus/scheduler Healthy ok componentstatus/controller-manager Healthy ok componentstatus/etcd-1 Healthy {\u0026#34;health\u0026#34;:\u0026#34;true\u0026#34;} componentstatus/etcd-0 Healthy {\u0026#34;health\u0026#34;:\u0026#34;true\u0026#34;} componentstatus/etcd-2 Healthy {\u0026#34;health\u0026#34;:\u0026#34;true\u0026#34;} NAME STATUS ROLES AGE VERSION node/192.168.1.16 Ready node 3h42m v1.13.1 node/192.168.1.5 Ready master 3h50m v1.13.1 node/192.168.1.9 Ready node 3h50m v1.13.1 部署 node 节点 安装 kubelet,kube-proxy\nkublet 运行在每个 worker 节点上，接收 kube-apiserver 发送的请求，管理 Pod 容器，执行交互式命令，如exec、run、logs 等; kublet 启动时自动向 kube-apiserver 注册节点信息，内置的 cadvisor 统计和监控节点的资源使用情况; 为确保安全，本文档只开启接收 https 请求的安全端口，对请求进行认证和授权，拒绝未授权的访问(如apiserver、heapster)。 将kubelet 二进制文件拷贝node节点 #在master节点上执行 cp kubelet kube-proxy /k8s/kubernetes/bin/ scp kubelet kube-proxy 192.168.1.9:/k8s/kubernetes/bin/ scp kubelet kube-proxy 192.168.1.16:/k8s/kubernetes/bin/ 创建 kubelet bootstrap kubeconfig 文件 #在master节点上执行 #注：将ca.pem，environment.sh，kube-proxy-key.pem，kube-proxy.pem四个文件放到一个目录下 vim environment.sh # 创建kubelet bootstrapping kubeconfig BOOTSTRAP_TOKEN=8d38ad6d7df6b109901bac9d07aaaefe KUBE_APISERVER=\u0026#34;https://192.168.1.5:6443\u0026#34; # 设置集群参数 kubectl config set-cluster kubernetes \\ --certificate-authority=./ca.pem \\ --embed-certs=true \\ --server=${KUBE_APISERVER} \\ --kubeconfig=bootstrap.kubeconfig # 设置客户端认证参数 kubectl config set-credentials kubelet-bootstrap \\ --token=${BOOTSTRAP_TOKEN} \\ --kubeconfig=bootstrap.kubeconfig # 设置上下文参数 kubectl config set-context default \\ --cluster=kubernetes \\ --user=kubelet-bootstrap \\ --kubeconfig=bootstrap.kubeconfig # 设置默认上下文 kubectl config use-context default --kubeconfig=bootstrap.kubeconfig #---------------------- # 创建kube-proxy kubeconfig文件 kubectl config set-cluster kubernetes \\ --certificate-authority=./ca.pem \\ --embed-certs=true \\ --server=${KUBE_APISERVER} \\ --kubeconfig=kube-proxy.kubeconfig kubectl config set-credentials kube-proxy \\ --client-certificate=./kube-proxy.pem \\ --client-key=./kube-proxy-key.pem \\ --embed-certs=true \\ --kubeconfig=kube-proxy.kubeconfig kubectl config set-context default \\ --cluster=kubernetes \\ --user=kube-proxy \\ --kubeconfig=kube-proxy.kubeconfig kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig 将bootstrap kubeconfig和kube-proxy.kubeconfig 文件拷贝到所有 nodes节点 cp bootstrap.kubeconfig kube-proxy.kubeconfig /k8s/kubernetes/cfg/ scp bootstrap.kubeconfig kube-proxy.kubeconfig node1:/k8s/kubernetes/cfg/ scp bootstrap.kubeconfig kube-proxy.kubeconfig node2:/k8s/kubernetes/cfg/ 创建kubelet 参数配置文件拷贝到所有 nodes节点 #在master上操作 vim /k8s/kubernetes/cfg/kubelet.config kind: KubeletConfiguration apiVersion: kubelet.config.k8s.io/v1beta1 address: 192.168.1.5 port: 10250 readOnlyPort: 10255 cgroupDriver: cgroupfs clusterDNS: [\u0026#34;10.0.0.2\u0026#34;] clusterDomain: cluster.local. failSwapOn: false authentication: anonymous: enabled: true #将参数配置文件拷贝到其他节点并且ip需要改成自己的ip scp /k8s/kubernetes/cfg/kubelet.config node1:/k8s/kubernetes/cfg/ scp /k8s/kubernetes/cfg/kubelet.config node2:/k8s/kubernetes/cfg/ 创建kubelet配置文件 #在master上操作 vim /k8s/kubernetes/cfg/kubelet KUBELET_OPTS=\u0026#34;--logtostderr=true \\ --v=4 \\ --hostname-override=192.168.1.5 \\ --kubeconfig=/k8s/kubernetes/cfg/kubelet.kubeconfig \\ --bootstrap-kubeconfig=/k8s/kubernetes/cfg/bootstrap.kubeconfig \\ --config=/k8s/kubernetes/cfg/kubelet.config \\ --cert-dir=/k8s/kubernetes/ssl \\ --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google-containers/pause-amd64:3.0\u0026#34; #将文件拷贝到其他节点上并修改对应的ip scp /k8s/kubernetes/cfg/kubelet node1:/k8s/kubernetes/cfg/kubelet scp /k8s/kubernetes/cfg/kubelet node2:/k8s/kubernetes/cfg/kubelet 创建kubelet systemd unit 文件 #在master上操作 vim /usr/lib/systemd/system/kubelet.service [Unit] Description=Kubernetes Kubelet After=docker.service Requires=docker.service [Service] EnvironmentFile=/k8s/kubernetes/cfg/kubelet ExecStart=/k8s/kubernetes/bin/kubelet $KUBELET_OPTS Restart=on-failure KillMode=process [Install] WantedBy=multi-user.target #将文件拷贝到其他节点上 scp /usr/lib/systemd/system/kubelet.service node1:/usr/lib/systemd/system/kubelet.service scp /usr/lib/systemd/system/kubelet.service node2:/usr/lib/systemd/system/kubelet.service 将kubelet-bootstrap用户绑定到系统集群角色 #master节点上执行 kubectl create clusterrolebinding kubelet-bootstrap \\ --clusterrole=system:node-bootstrapper \\ --user=kubelet-bootstrap #clusterrolebinding.rbac.authorization.k8s.io/kubelet-bootstrap created 启动服务 #在两个节点上执行 systemctl daemon-reload systemctl enable kubelet systemctl restart kubelet 查看 CSR 列表 kubectl get csr NAME AGE REQUESTOR CONDITION node-csr-HjaojHavfm-vFzime9FfPUB4rNCuBAgUiUR8GrjaKeM 10m kubelet-bootstrap Pending node-csr-bfl0GRKg5hWleaClBFAcXVvNOvNhRUJ0f11J3vNN9rY 10m kubelet-bootstrap Pending 手动 approve CSR 请求 kubectl certificate approve node-csr-HjaojHavfm-vFzime9FfPUB4rNCuBAgUiUR8GrjaKeM kubectl certificate approve node-csr-bfl0GRKg5hWleaClBFAcXVvNOvNhRUJ0f11J3vNN9rY 查看集群状态 kubectl get nodes 部署 kebue-proxy 创建 kube-proxy文件 vim /k8s/kubernetes/cfg/kube-proxy KUBE_PROXY_OPTS=\u0026#34;--logtostderr=true \\ --v=4 \\ --hostname-override=192.168.1.5 \\ --cluster-cidr=10.0.0.0/24 \\ --kubeconfig=/k8s/kubernetes/cfg/kube-proxy.kubeconfig\u0026#34; #文件拷贝并且ip要改成自己的ip scp /k8s/kubernetes/cfg/kube-proxy node1:/k8s/kubernetes/cfg/ scp /k8s/kubernetes/cfg/kube-proxy node2:/k8s/kubernetes/cfg/ 创建kube-proxy systemd unit 文件 vim /usr/lib/systemd/system/kube-proxy.service [Unit] Description=Kubernetes Proxy After=network.target [Service] EnvironmentFile=-/k8s/kubernetes/cfg/kube-proxy ExecStart=/k8s/kubernetes/bin/kube-proxy $KUBE_PROXY_OPTS Restart=on-failure [Install] WantedBy=multi-user.target #文件拷贝 scp /usr/lib/systemd/system/kube-proxy.service node1:/usr/lib/systemd/system/ scp /usr/lib/systemd/system/kube-proxy.service node2:/usr/lib/systemd/system/ 启动服务 systemctl daemon-reload systemctl enable kube-proxy systemctl restart kube-proxy 打node 或者master 节点的标签 kubectl label node 192.168.1.5 node-role.kubernetes.io/master=\u0026#39;master\u0026#39; kubectl label node 192.168.1.9 node-role.kubernetes.io/node=\u0026#39;node\u0026#39; kubectl label node 192.168.1.16 node-role.kubernetes.io/node=\u0026#39;node\u0026#39; ","permalink":"/blogs/2020/k8s/k8s_install.html","summary":"\u003ch2 id=\"机器规划\"\u003e机器规划\u003c/h2\u003e\n\u003ctable\u003e\n\t\u003cthead\u003e\n\t\t\t\u003ctr\u003e\n\t\t\t\t\t\u003cth\u003e机器\u003c/th\u003e\n\t\t\t\t\t\u003cth\u003e角色\u003c/th\u003e\n\t\t\t\t\t\u003cth\u003e软件\u003c/th\u003e\n\t\t\t\u003c/tr\u003e\n\t\u003c/thead\u003e\n\t\u003ctbody\u003e\n\t\t\t\u003ctr\u003e\n\t\t\t\t\t\u003ctd\u003e192.168.1.5\u003c/td\u003e\n\t\t\t\t\t\u003ctd\u003emaster\u003c/td\u003e\n\t\t\t\t\t\u003ctd\u003edocker,etcd,flanneld，kubelet,kube_proxy,kube-apiserver、kube-controller-manager、kube-scheduler\u003c/td\u003e\n\t\t\t\u003c/tr\u003e\n\t\t\t\u003ctr\u003e\n\t\t\t\t\t\u003ctd\u003e192.168.1.9\u003c/td\u003e\n\t\t\t\t\t\u003ctd\u003enode\u003c/td\u003e\n\t\t\t\t\t\u003ctd\u003edocker,etcd,flanneld,kubelet,kube_proxy\u003c/td\u003e\n\t\t\t\u003c/tr\u003e\n\t\t\t\u003ctr\u003e\n\t\t\t\t\t\u003ctd\u003e192.168.1.16\u003c/td\u003e\n\t\t\t\t\t\u003ctd\u003enode\u003c/td\u003e\n\t\t\t\t\t\u003ctd\u003edocker,etcd,flanneld,kubelet,kube_proxy\u003c/td\u003e\n\t\t\t\u003c/tr\u003e\n\t\u003c/tbody\u003e\n\u003c/table\u003e\n\u003ch2 id=\"环境准备\"\u003e环境准备\u003c/h2\u003e\n\u003cp\u003e1.关闭防火墙（三台机器同时进行）：\u003c/p\u003e","title":"K8S环境搭建"},{"content":"今天用Vuepress搭建了博客，搭建步骤：\n安装Nginx，以为觉得是静态文件发布，就没有修改默认配置。 Vuepress编辑后，将生成的public里的内容直接拷贝到**/usr/share/nginx/html** 拷贝完成后，直接访问博客就能正常访问，但是出现了个奇怪现象，在首页点击文章都能正常，但是进入文章后刷新就出现：\n猜想应该是nginx的location配置有问题，上网一查，原来还需要加上location里还需要配置一个try_files $uri $uri/ /index.html;\n如下：\nlocation / { try_files $uri $uri/ /index.html; index index.html index.htm; } 配置完service nginx reload，刷新正常\n","permalink":"/blogs/2020/frontend/vue/vuepress-refresh-err.html","summary":"\u003cp\u003e今天用Vuepress搭建了博客，搭建步骤：\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e安装Nginx，以为觉得是静态文件发布，就没有修改默认配置。\u003c/li\u003e\n\u003cli\u003eVuepress编辑后，将生成的public里的内容直接拷贝到**/usr/share/nginx/html**\u003c/li\u003e\n\u003c/ol\u003e\n\u003cp\u003e拷贝完成后，直接访问博客就能正常访问，但是出现了个奇怪现象，在首页点击文章都能正常，但是进入文章后刷新就出现：\u003c/p\u003e","title":"Vuepress文章刷新后页面异常"},{"content":"GO语言如何判断字符串中是否包含有某个单词，同时忽略大小写？！\n通过分析可以知道，不能简单的通过是否包含字符串来判断，例如： 字符串“kiss goodbye”，虽然是有包含good，但是并不是我们要的匹配，单词的前和后是有空格或是换行隔开，或是没有任何东西，对应的正则表达式如下：\n`(^|([\\s\\t\\n]+))(good)($|([\\s\\t\\n]+))` (^|([\\s\\t\\n]+))： good开头或是前面是空白、换行、tab分隔\n($|([\\s\\t\\n]+))：good结尾或是后面是空白、换行、tab分隔\n如果需要忽略大小写，则加上 (?i)，所以最终正则表达式如下：\n(?i)(^|([\\s\\t\\n]+))(good)($|([\\s\\t\\n]+)) 例子：\npackage main import ( \u0026#34;fmt\u0026#34; \u0026#34;regexp\u0026#34; ) func main() { matchWard:= \u0026#34;good\u0026#34; var s1 = `good` var s2 = `you good !` var s3 = `ss good` var s4\t= `kiss goodby` reg := regexp.MustCompile(`(?i)(^|([\\s\\t\\n]+))(` +matchWard+`)($|([\\s\\t\\n]+))`) fmt.Println(reg.MatchString(s1)) // true fmt.Println(reg.MatchString(s2)) // true fmt.Println(reg.MatchString(s3)) // true fmt.Println(reg.MatchString(s4)) // false } ","permalink":"/blogs/2020/go/go-word-contain.html","summary":"\u003cp\u003eGO语言如何判断字符串中是否包含有某个单词，同时忽略大小写？！\u003c/p\u003e\n\u003cp\u003e通过分析可以知道，不能简单的通过是否包含字符串来判断，例如： 字符串“kiss goodbye”，虽然是有包含good，但是并不是我们要的匹配，单词的前和后是有空格或是换行隔开，或是没有任何东西，对应的正则表达式如下：\u003c/p\u003e","title":"Go正则判断包含某个单词忽略大小写"},{"content":"市面上笔记本软件广告太多，功能不好用，就自己动手做了一个【虾记】（瞎记，开源地址：https://github.com/itart-top/notebook），使用（Electron + Vue + Element UI），支持：\n笔记分类\n打重要标识 收藏网址、文件夹、软件，支持点击直接打开： 快速搜索 右下角最小化软件 展示：\n","permalink":"/blogs/2020/frontend/vue/itart-note.html","summary":"\u003cp\u003e市面上笔记本软件广告太多，功能不好用，就自己动手做了一个【虾记】（瞎记，开源地址：https://github.com/itart-top/notebook），使用（Electron + Vue + Element UI），支持：\u003c/p\u003e","title":"笔记本（Electron + Vue + Element UI）"},{"content":"如何将N个有序的集合合并成一个有序集合？！\n我们可以将集合进行两两合并，然后将结果再次两两合并，不断重复，最终合并成一个集合，实际上就只是个递归算法，代码如下：\npackage main import \u0026#34;fmt\u0026#34; func main() { mock1:= []int {2,5,9} mock2:= []int {1,3,4} mock3:= []int {6,7,8} fmt.Println(mergeN(mock1, mock2, mock3)) // 输出：[1 2 3 4 5 6 7 8 9] } func mergeN(arrs ...[]int) ([] int) { if len(arrs) == 0{ return nil } if len(arrs) == 1{ return arrs[0] } m:=len(arrs)/ 2 return merge(mergeN(arrs[:m]...),mergeN(arrs[m:]...) ) } func merge(aa, bb [] int) (result [] int) { if len(aa) == 0{ return bb } if len(bb) == 0{ return aa } var ai, bi = 0, 0 for{ a:= aa[ai] b := bb[bi] if a \u0026lt; b || a == b{ result = append(result, a) ai++ } else { result = append(result, b) bi++ } if ai == len(aa) || bi == len(bb) { // 如果aa已经读完，bb没读完，将剩余bb加入 if ai == len(aa) \u0026amp;\u0026amp; bi!= len(bb){ result = append(result, bb[bi:]...) } else if bi == len(bb) \u0026amp;\u0026amp; ai!= len(aa){ result = append(result, aa[ai:]...) } return result } } } ","permalink":"/blogs/2020/go/slice-fan-in.html","summary":"\u003cp\u003e如何将N个有序的集合合并成一个有序集合？！\u003c/p\u003e\n\u003cp\u003e我们可以将集合进行两两合并，然后将结果再次两两合并，不断重复，最终合并成一个集合，实际上就只是个递归算法，代码如下：\u003c/p\u003e","title":"如何将N个有序的集合合并成一个有序集合"},{"content":"1 URL带布尔类型参数获取异常 背景：\nVue可以通过 this.$router.query.xx获取url上携带参数，例如：\nURL：http://itart.cn/?edit=true\n要获取edit参数值时可以通过：this.$router.query.edit获取。\n但是，在Chrome浏览器测试发现不同跳转方式获取到的类型不一样，有的获取到的是string类型，有的是boolean类型，例如：\n如果直接在浏览器输入http://itart.cn?edit=true进入页面时，通过this.$router.query.edit获取到的edit类型是string类型 如果是通过Vue路由打开方式跳转过来的：$router.push({path: \u0026lsquo;/\u0026rsquo;, query: { edit: true }})，获取到的edit类型就是boolean值 这两种跳转方式在浏览器上地址栏显示的url都是一样，但是获取到的值类型不一样，不注意的话会导致判断错误。\n有可能的场景是：用router.push进入页面都正常，但是，手动刷新页面时就出现参数类型异常的问题。\n建议：\n可以创建一个工具类来统一处理获取url参数\nutils/index.js\nexport function parseBoolean(value) { switch(typeofvalue) { case\u0026#39;undefined\u0026#39;: return false case\u0026#39;boolean\u0026#39;: return value case \u0026#39;string\u0026#39;: { retur nvalue === \u0026#39;true\u0026#39; } default: { throwError(\u0026#39;该类型不能转化为Boolean类型：\u0026#39;, value) } } } 如果有多个地方需要使用这个参数，尽量在vue一开始实例化的时候就把query上的值设置到data对象里，使用的时候就直接使用data对象里的值，减少重复类型判断转化，例如：\nimport { parseBoolean } from \u0026#39;@/utils\u0026#39; export default { data() { return { edit: parseBoolean(this.$route.query.edit) } }, methods: { submit() { console.log(this.edit) } } ... 2 组件复用导致created不会执行 组件中包含一个属性key，作为组件复用标识，如果if .. else if .. else 中的组件都没定义key可能会以为组件复用导致事件错乱，例如：\n\u0026lt;el-button v-if =\u0026ldquo;c===1\u0026rdquo; @click=\u0026ldquo;click1\u0026rdquo;\u0026gt;\u0026lt;/el-button\u0026gt;\n\u0026lt;el-button v-else @click=\u0026ldquo;click2\u0026rdquo;\u0026gt;\u0026lt;/el-button\u0026gt;\n当c=1是会显示第一个按钮，点击事件会调用click1方法，当c不等于1时， 实际上显示的是第二个按钮，但是事件可能还是click1，原因两个按钮都没有定义key，所以vue会智能组件复用，导致奇怪的异常，for循环里要定义唯一key也是基于这种考虑。\n建议\n如果没有明显性能问题，可以对一些v-if else组件定义一个唯一的key来防止组件复用，解决created方法不能调用和data数据在条件切换的时候没有重置的问题\n","permalink":"/blogs/2020/frontend/vue/vue-issue.html","summary":"\u003ch1 id=\"1-url带布尔类型参数获取异常\"\u003e1 URL带\u003cstrong\u003e布尔\u003c/strong\u003e类型参数获取异常\u003c/h1\u003e\n\u003cp\u003e\u003cstrong\u003e背景：\u003c/strong\u003e\u003c/p\u003e\n\u003cp\u003eVue可以通过 this.$router.query.xx获取url上携带参数，例如：\u003c/p\u003e\n\u003cp\u003eURL：http://itart.cn/?edit=true\u003c/p\u003e","title":"Vue问题总结"},{"content":"命名规范 文件夹/文件名/自定义组件标签和属性命名使用kebab-case风格\nJavaScript中的变量名使用camelCase风格，除了组件名定义和import时使用PascalCase风格\n组件名为多个单词 组件名应该始终是多个单词的，根组件 App 除外。\n这样做可以避免跟现有的以及未来的 HTML 元素相冲突，因为所有的 HTML 元素名称都是单个单词的。\nbad\nVue.component(\u0026#39;todo\u0026#39;, { // ... }) export default { \u0026#39;name\u0026#39;: \u0026#39;Todo\u0026#39; // ... } good\nVue.component(\u0026#39;TodoItem\u0026#39;, { // ... }) export default { \u0026#39;name\u0026#39;: \u0026#39;TodoItem\u0026#39; // ... } views 下的 vue 目录和文件命名 文件夹命令 views 下面的文件夹代表着模块的名字\n名词组成（car、order、cart） 全小写（good: car）（bad: Car） 尽量只有一个单词（good: car、order、cart）（bad: carInfo、carpage） 多个单词用 “-” 隔开（good：agent-host）（bad: agentHost、agent_host） 如果一个模块只有一个文件，就不需要创建文件夹，直接创建以模块名开头的“.vue”文件：（agent-host-list.vue） 文件命令 views 下面的 vue 文件代表着页面的名字\n放在模块文件夹之下 只有一个文件的情况下不会出现文件夹，而是直接放在 views 目录下面，如 login.vue home.vue 尽量是名词 名字至少两个单词（good: car-detail）（bad: car） 全小写，采用kebab-case风格，多个单词用“-”隔开，开头的单词就是所属模块名字（car-detail、car-edit、car-list） 常用结尾单词有（detail、edit、list、info、report） 紧密耦合的组件名 和父组件紧密耦合的子组件应该以父组件名作为前缀命名。\n如果一个组件只在某个父组件的场景下有意义，这层关系应该体现在其名字上。因为编辑器通常会按字母顺序组织文件，所以这样做可以把相关联的文件排在一起。\nBad\ncomponents |- todo-list.vue |- todo-item.vue |- todo-button.vue components |- SearchSidebar.vue |- NavigationForSearchSidebar.vue good\ncomponents |- todo-list.vue |- todo-list-item.vue |- todo-list-item-button.vue components |- search-sidebar.vue |- search-sidebar-navigation-item.vue 模板中的组件名大小写 对于绝大多数项目来说，在单文件组件和字符串模板中组件名应该总是 PascalCase 的——但是在 DOM 模板中总是 kebab-case 的是，为了保持风格一致，统一使用kebab-case\nbad\n\u0026lt;!-- 在单文件组件和字符串模板中 --\u0026gt; \u0026lt;mycomponent/\u0026gt; \u0026lt;!-- 在单文件组件和字符串模板中 --\u0026gt; \u0026lt;myComponent/\u0026gt; \u0026lt;!-- 在 DOM 模板中 --\u0026gt; \u0026lt;MyComponent\u0026gt;\u0026lt;/MyComponent\u0026gt; good\n\u0026lt;!-- 在所有地方 --\u0026gt; \u0026lt;my-component\u0026gt;\u0026lt;/my-component\u0026gt; JS/JSX 中的组件名大小写 JS/JSX 中的组件名应该始终是 PascalCase 的，尽管在较为简单的应用中只使用 Vue.component 进行全局组件注册时，可以使用 kebab-case 字符串。\nBad\nVue.component(\u0026#39;myComponent\u0026#39;, { // ... }) import \u0026#39;myComponent\u0026#39; from \u0026#39;./MyComponent.vue\u0026#39; export default { \u0026#39;name\u0026#39;: \u0026#39;myComponent\u0026#39;, // ... } export default {\u0026#39;name\u0026#39;: \u0026#39;my-component\u0026#39;, // ... } good\nVue.component(\u0026#39;MyComponent\u0026#39;, { // ... }) import \u0026#39;MyComponent\u0026#39; from \u0026#39;./MyComponent.vue\u0026#39; export default{ \u0026#39;name\u0026#39;:\u0026#39;MyComponent\u0026#39;, // ... } 完整单词的组件名 组件名应该倾向于完整单词而不是缩写。\n编辑器中的自动补全已经让书写长命名的代价非常之低了，而其带来的明确性却是非常宝贵的。不常用的缩写尤其应该避免。\nbad\ncomponents |- SdSettings.vue |- UProfOpts.vue good\ncomponents |- student-dashboard-settings.vue |- user-profile-options.vue Prop 名大小写 在声明 prop 的时候，其命名应该始终使用 camelCase，而在模板和 JSX 中应该始终使用 kebab-case。\n我们单纯的遵循每个语言的约定。在 JavaScript 中更自然的是 camelCase。而在 HTML 中则是 kebab-case。\nbad\nprops: { \u0026#39;greeting-text\u0026#39;: String } \u0026lt;WelcomeMessage greetingText=\u0026#34;hi\u0026#34;/\u0026gt; good\nprops: { \u0026#39;greetingText: String } \u0026lt;welcome-message :greeting-text=\u0026#34;hi\u0026#34;/\u0026gt; 指令统一采用缩写形式 指令缩写，用 : 表示 v-bind: ，用 @ 表示 v-on:\nbad\n\u0026lt;input v-bind:value=\u0026#34;value\u0026#34; v-on:input=\u0026#34;onInput\u0026#34;\u0026gt; good\n\u0026lt;input :value=\u0026#34;value\u0026#34; @input = \u0026#34;onInput\u0026#34;\u0026gt; Method 自定义方法命名 动宾短语（good：jumpPage、openCarInfoDialog）（bad：go、nextPage、show、open、login） 事件方法以 on 开头（onTypeChange、onUsernameInput） 尽量使用常用单词开头（set、get、open、close、jump） camelCase命名（good: getListData）（bad: get_list_data、getlistData） API接口import的方法名要明确 如果import的方法是比较通用的操作名，需要给方法取一个明确的别名，并且所有别名增加Api结尾，用来区分普通函数。\nbad\nimport { getPackages , remove } from \u0026#39;@/api/package\u0026#39; good\nimport { getPackages as getPackagesApi, remove as removePackageApi } from \u0026#39;@/api/package\u0026#39; 数据定义 组件里的data定义 data 必须是一个函数。 当在组件中使用 data 属性的时候 (除了 new Vue 外的任何地方)，它的值必须是返回一个对象的函数。因为如果直接把data定义成一个对象，会导致每个组件的实例都引用了相同的数据对象，更改其中一个列表的标题就会改变其它每一个列表的标题。增删改一个待办事项的时候也是如此。\nbad\nVue.component(\u0026#39;some-comp\u0026#39;, { data: { foo: \u0026#39;bar\u0026#39; } }) export default { data: { foo: \u0026#39;bar\u0026#39; } } good\nVue.component(\u0026#39;some-comp\u0026#39;,{ data: function () { return { foo: \u0026#39;bar\u0026#39; } } }) // In a.vue file export default { data () { return { foo: \u0026#39;bar\u0026#39; } } // 在一个 Vue 的根实例上直接使用对象是可以的 // 因为只存在一个这样的实例。 new Vue({ data: { foo: \u0026#39;bar\u0026#39; } }) data 里的变量时请先在 data 里面初始化 Vue.component(\u0026#39;some-comp\u0026#39;, { data: function () { return { foo: \u0026#39;bar\u0026#39;, loading: true } } }) 表单数据请包裹一层 form Vue.component(\u0026#39;some-comp\u0026#39;, { data: function () { return { form: { name: \u0026#39;bar\u0026#39;} } } }) ajax 请求数据用上 loading变量 \u0026lt;el-table v-loading=\u0026#34;listLoading\u0026#34;\u0026gt; ... export default{ name: \u0026#39;exportZip\u0026#39;, data() { return { listLoading: true, ... } }, created() { this.fetchData() }, methods: { fetchData() { this.listLoading = true fetchListApi().then(response =\u0026gt; { ... this.listLoading = false }) } } 组件Props props定义应该尽量详细。 在你提交的代码中，prop 的定义应该尽量详细，至少需要指定其类型。\n细致的 prop 定义有两个好处：\n它们写明了组件的 API，所以很容易看懂组件的用法； 在开发环境下，如果向一个组件提供格式不正确的 prop，Vue 将会告警，以帮助你捕获潜在的错误来源。 bad\n// 这样做只有开发原型系统时可以接受 props: [\u0026#39;status\u0026#39;] good\nprops: { status: String} // 更好的做法！ props: { status: { type: String, required: true, validator: function (value) { return [\u0026#39;syncing\u0026#39;,\u0026#39;synced\u0026#39;,\u0026#39;version-conflict\u0026#39;, \u0026#39;error\u0026#39;].indexOf(value) !== -1 } } } props 改变父组件数据 基础类型用 $emit ，复杂类型直接改 Vue文件方法声明顺序 export default { name: \u0026#39;\u0026#39;, components: {}, props: {}, data() {}, computed: {}, watch: {}, created() {}, mounted() {}, activated(){}, methods: {}, destroyed() {} } 标签属性使用 为 v-for 设置键值 总是用 key 配合 v-for。\n在组件上总是必须用 key 配合 v-for，以便维护内部组件及其子树的状态，避免Vue优化渲染的时候，复用组件导致一些极端异常。\nbad\n\u0026lt;ul\u0026gt; \u0026lt;li v-for=\u0026#34;todo in todos\u0026#34;\u0026gt;{{ todo.text }} \u0026lt;/li\u0026gt; \u0026lt;/ul\u0026gt; good\n\u0026lt;ul\u0026gt; \u0026lt;li v-for=\u0026#34;todo in todos\u0026#34; :key=\u0026#34;todo.id\u0026#34;\u0026gt; {{ todo.text }} \u0026lt;/li\u0026gt; \u0026lt;/ul\u0026gt; 3.2 避免 v-if 和 v-for 用在一起 慎用 v-if 和 v-for 同时用在同一个元素上，因为当 Vue 处理指令时，v-for 比 v-if 具有更高的优先级，所以这个模板：\n?\n\u0026lt;ul\u0026gt; \u0026lt;li v-for=\u0026#34;user in users\u0026#34; v-if=\u0026#34;user.isActive\u0026#34; :key=\u0026#34;user.id\u0026#34; \u0026gt; {{ user.name }} \u0026lt;/li\u0026gt; \u0026lt;/ul\u0026gt; 将会经过如下运算：\nthis.users.map(function (user) { if(user.isActive) { returnuser.name } }) 因此哪怕我们只渲染出一小部分用户的元素，也得在每次重渲染的时候遍历整个列表，不论活跃用户是否发生了变化。\n一般我们在两种常见的情况下会倾向于这样做：\n为了过滤一个列表中的项目 (比如 v-for=\u0026ldquo;user in users\u0026rdquo; v-if=\u0026ldquo;user.isActive\u0026rdquo;)。在这种情形下，请将 users 替换为一个计算属性 (比如 activeUsers)，让其返回过滤后的列表。 为了避免渲染本应该被隐藏的列表 (比如 v-for=\u0026ldquo;user in users\u0026rdquo; v-if=\u0026ldquo;shouldShowUsers\u0026rdquo;)。这种情形下，请将 v-if 移动至容器元素上 (比如 ul, ol)。 bad\n\u0026lt;ul\u0026gt; \u0026lt;li v-for=\u0026#34;user in users\u0026#34; v-if=\u0026#34;user.isActive\u0026#34; :key=\u0026#34;user.id\u0026#34;\u0026gt; {{ user.name }} \u0026lt;/li\u0026gt; \u0026lt;/ul\u0026gt; \u0026lt;ul\u0026gt; \u0026lt;li v-for=\u0026#34;user in users\u0026#34; v-if=\u0026#34;shouldShowUsers\u0026#34; :key=\u0026#34;user.id\u0026#34;\u0026gt; {{ user.name }} \u0026lt;/li\u0026gt; \u0026lt;/ul\u0026gt; good\n\u0026lt;ul\u0026gt; \u0026lt;li v-for=\u0026#34;user in activeUsers\u0026#34; :key=\u0026#34;user.id\u0026#34; \u0026gt; {{ user.name }} \u0026lt;/li\u0026gt; \u0026lt;/ul\u0026gt; \u0026lt;ul v-if=\u0026#34;shouldShowUsers\u0026#34;\u0026gt; \u0026lt;li v-for=\u0026#34;user in users\u0026#34; :key=\u0026#34;user.id\u0026#34; \u0026gt; {{ user.name }} \u0026lt;/li\u0026gt; \u0026lt;/ul\u0026gt; 单文件组件顶级标签顺序 \u0026lt;template\u0026gt; ... \u0026lt;/template\u0026gt; \u0026lt;script\u0026gt; /* ... */ \u0026lt;/script\u0026gt; \u0026lt;!--声明语言，并且添加scoped--\u0026gt; \u0026lt;style lang=\u0026#34;less\u0026#34;scoped\u0026gt; /* ... */ \u0026lt;/style\u0026gt; 3.4 Props 顺序 标签的 Props 应该有统一的顺序，依次为指令、属性和事件。\n\u0026lt;my-component v-if=\u0026#34;if\u0026#34; v-show=\u0026#34;show\u0026#34; v-model=\u0026#34;value\u0026#34; ref=\u0026#34;ref\u0026#34; :key=\u0026#34;key\u0026#34; :text=\u0026#34;text\u0026#34; @input=\u0026#34;onInput\u0026#34;@change=\u0026#34;onChange\u0026#34;/\u0026gt; v-if / v-else-if / v-else 若同一组 v-if 逻辑控制中的元素逻辑相同，Vue 为了更高效的元素切换，会复用相同的部分，例如：value。为了避免复用带来的不合理效果，应该在同种元素上加上 key 做标识。\nbad\n\u0026lt;div v-if=\u0026#34;hasData\u0026#34;\u0026gt; \u0026lt;span\u0026gt;{{ mazeyData }}\u0026lt;/span\u0026gt; \u0026lt;/div\u0026gt; \u0026lt;div v-else\u0026gt; \u0026lt;span\u0026gt;无数据\u0026lt;/span\u0026gt; \u0026lt;/div\u0026gt; good\n\u0026lt;div v-if=\u0026#34;hasData\u0026#34;key=\u0026#34;mazey-data\u0026#34;\u0026gt; \u0026lt;span\u0026gt;{{ mazeyData }}\u0026lt;/span\u0026gt; \u0026lt;/div\u0026gt; \u0026lt;div v-elsekey=\u0026#34;mazey-none\u0026#34;\u0026gt; \u0026lt;span\u0026gt;无数据\u0026lt;/span\u0026gt; \u0026lt;/div\u0026gt; css样式定义 css定义尽量使用scoped方式 \u0026lt;!--声明语言，并且添加scoped--\u0026gt; \u0026lt;style lang=\u0026#34;less\u0026#34;scoped\u0026gt; /* ... */ \u0026lt;/style\u0026gt; 4.2 class尽量使用层级定义 scoped方式定义的css常常无法覆盖控件原生定义的class，例如：\u0026lt;button type=\u0026ldquo;button\u0026rdquo; class=\u0026ldquo;el-button el-button–primary\u0026rdquo;\u0026gt;中的class ：el-button。\n这时候只能使用全局定义方式，建议在页面的根元素上设置一个全局的class名，把该页面下的其他样式都定义在该class之下，避免class冲突\n\u0026lt;template\u0026gt; \u0026lt;div class=\u0026#34;project-list\u0026#34;\u0026gt; \u0026lt;label\u0026gt;IT是门艺术\u0026lt;/label\u0026gt; \u0026lt;el-button type=\u0026#34;primary\u0026#34;\u0026gt; element ui按钮 \u0026lt;/el-button\u0026gt; \u0026lt;button class=\u0026#34;btn btn-close\u0026#34;\u0026gt;X\u0026lt;/button\u0026gt; \u0026lt;/div\u0026gt; \u0026lt;/template\u0026gt; \u0026lt;style lang=\u0026#34;less\u0026#34;\u0026gt; .project-list { .btn-close { background-color: red; } // 覆盖el-button原生的样式 .el-button { background-color: red; }} \u0026lt;/style\u0026gt; 避免scoped 中的直接使用元素选择器 元素选择器应该避免在 scoped 中出现。\n在 scoped 样式中，类选择器比元素选择器更好，因为大量使用元素选择器是很慢的。\nbad\n\u0026lt;template\u0026gt; \u0026lt;button\u0026gt;X\u0026lt;/button\u0026gt; \u0026lt;/template\u0026gt; \u0026lt;style scoped\u0026gt; button { background-color: red; } \u0026lt;/style\u0026gt; good\n\u0026lt;template\u0026gt; \u0026lt;button class=\u0026#34;btn btn-close\u0026#34;\u0026gt;X\u0026lt;/button\u0026gt; \u0026lt;/template\u0026gt; \u0026lt;style scoped\u0026gt; .btn-close { background-color: red; } \u0026lt;/style\u0026gt; 其他 调试信息console.log() debugger 使用完及时删除 package-lock.json需要提交到git仓库 package-lock.json 是在 npm install时候生成一份文件，用以记录当前状态下实际安装的各个npm package的具体来源和版本号。\nnpm是一个用于管理package之间依赖关系的管理器，它允许开发者在pacakge.json中间标出自己项目对npm各库包的依赖。你可以选择以如下方式来标明自己所需要库包的版本\n这里举个例子：\n\u0026#34;dependencies\u0026#34;: { \u0026#34;@types/node\u0026#34;: \u0026#34;^8.0.33\u0026#34;, } ^是定义了向后（新）兼容依赖，指如果 types/node的版本是超过8.0.33，并在大版本号（8）上相同，就允许下载最新版本的 types/node库包，例如实际上可能运行npm install时候下载的具体版本是8.0.35\n如果项目中没有package-lock.json，就可能出现每个环境npm install的时候，拉取的依赖版本不一样，导致生成的包不一样的问题。\n备注：\nkebab-case ：短横线分隔命名\ncamelCase ：驼峰式命名\nPascalCase ：帕斯卡命名法。单词首字母大写命名，也有人称之为“大驼峰式命名法”（Upper Camel Case），为驼峰式大小写的子集。\n按钮是跳转路由，不要在el-button包router-link标签 如果el-button包router-link标签， 这样写会出现需要点击按钮正中间才能有效，如果点到按钮，但是点到的是按钮边缘就会没反应，并且在火狐浏览器中无法使用 bad\n\u0026lt;el-buttontype=\u0026#34;text\u0026#34;size=\u0026#34;mini\u0026#34;\u0026gt; \u0026lt;router-link:to=\u0026#34;{ name: \u0026#39;task-detail\u0026#39;, query: { buildId: scope.row.Id }}\u0026#34;\u0026gt; \u0026lt;i class=\u0026#34;el-icon-fw-eye\u0026#34;\u0026gt;\u0026lt;/i\u0026gt; \u0026lt;/router-link\u0026gt; \u0026lt;/el-button\u0026gt; good\n\u0026lt;el-button type=\u0026#34;text\u0026#34; size=\u0026#34;mini\u0026#34; @click=\u0026#34;$router.push({ name: \u0026#39;page-detail\u0026#39;, query: { id: scope.row.Id }, params: { orgId: id }})\u0026#34; icon=\u0026#34;el-icon-fw-eye\u0026#34;\u0026gt; \u0026lt;/el-button\u0026gt; or\n\u0026lt;router-link :to=\u0026#34;{ name: \u0026#39;opage-detail\u0026#39;, query: { id: scope.row.Id }}\u0026#34;\u0026gt; \u0026lt;el-button type=\u0026#34;text\u0026#34;size=\u0026#34;mini\u0026#34;\u0026gt; \u0026lt;i class=\u0026#34;el-icon-fw-eye\u0026#34;\u0026gt;\u0026lt;/i\u0026gt; \u0026lt;/el-button\u0026gt; \u0026lt;/router-link\u0026gt; 另外，路由跳转用name定位路由：$router.push({ name: xx, \u0026hellip;.})，不要用path：$router.push({ path: \u0026lsquo;/xxx/xx\u0026rsquo;, \u0026hellip;.})，因为name一般不去变，path会比较容易调整\n","permalink":"/blogs/2020/standard/vue-specification.html","summary":"\u003ch2 id=\"命名规范\"\u003e命名规范\u003c/h2\u003e\n\u003cp\u003e文件夹/文件名/自定义组件标签和属性命名使用kebab-case风格\u003c/p\u003e\n\u003cp\u003eJavaScript中的变量名使用camelCase风格，除了组件名定义和import时使用PascalCase风格\u003c/p\u003e","title":"Vue开发规范"},{"content":"设计规范 【推荐】字段允许适当冗余，以提高查询性能，但必须考虑数据一致。冗余字段应遵循:\n不是频繁修改的字段。 不是 varchar 超长字段，更不能是 text 字段 Good: “产品名”适当冗余，可以减少和产品表的关联 **Bad **: \u0026ldquo;产品修改时间\u0026rdquo;，产品描述，产品组件数\n【推荐】数据库主键不使用自增（手动插入ID容易冲突，系统集成切割、合表自增都会有问题）\n【推荐】字段尽量设置为 NOT NULL， 为字段提供默认值（节省空间，索引，count问题，条件需要考虑null还是空白等）\nGood：字符型的默认值为一个空字符值串’’，数值型默认值为数值 0\nBad：status允许为null或空白\n命名规则 名字默认规则：采用26个英文字母，多个单词下划线\u0026rsquo;_\u0026lsquo;分割。不建议以复数形式进行命名。\n【强制】表达是与否概念的字段，必须使用 is_xxx 的方式命名，数据类型是tinyint ( 1表示是，0表示否)。\nGood：逻辑删除的字段名 is_deleted，1 表示删除，0 表示未删除\n【强制】表名、字段名必须使用小写字母或数字，禁止出现数字开头，禁止两个下划线中间只 出现数字。数据库字段名的修改代价很大，因为无法进行预发布，所以字段名称需要慎重考虑。 说明:MySQL 在 Windows 下不区分大小写，但在 Linux 下默认是区分大小写。因此，数据库 名、表名、字段名，都不允许出现任何大写字母，避免节外生枝。\nGood：health_user，rdc_config，level3_name Bad：HealthUser，rdcConfig，level_3_name\n【强制】表名不使用复数名词。 说明:表名应该仅仅表示表里面的实体内容，不应该表示实体数量，对应于 DO 类名也是单数 形式，符合表达习惯。\n【强制】禁用保留字，如 desc、range、match、delayed 等，请参考 MySQL 官方保留字\n【强制】表必备以下三个字段。\n字段名 类型 描述 必填 creator varchar(50) 创建人 是 creator_id int(12) 创建人ID create_time datetime 创建时间 是 modifier varchar(50) 修改人 是 modifier_id int(12) 修改人ID modify_time datetime 最后更新时间 是 is_delete tinyint(1) 是否删除，1-删除， 0-未删除，默认0 是 【强制】所有命名必须使用全名，有默认约定的除外，如果超过 30 个字符，使用缩写，请尽量名字易懂简短，如 description \u0026ndash;\u0026gt; desc;information \u0026ndash;\u0026gt; info; address \u0026ndash;\u0026gt; addr 等\n【推荐】如果修改字段含义或对字段表示的状态追加时，需要及时更新字段注释\n类型规范 用尽量少的存储空间来存储一个字段的数据.\n能用int的就不用char或者varchar 能用tinyint的就不用int 能用 varchar(20)的就不用varchar(255) 业务上必须有值的字段务必设计成必填字段。 【强制】小数类型为 decimal，禁止使用 float 和 double。（float 和 double 在存储的时候，存在精度损失的问题，很可能在值的比较时，得到不 正确的结果。如果存储的数据范围超过 decimal 的范围，建议将数据拆成整数和小数分开存储） 【强制】如果存储的字符串长度几乎相等，使用 char 定长字符串类型。（这种情况下char效率、存储都优于varchar） 【强制】varchar 是可变长字符串，不预先分配存储空间，长度不要超过 5000，如果存储长 度大于此值，定义字段类型为 text，独立出来一张表，用主键来对应，避免影响其它字段索 引效率。 【强制】表示boolean类型的都使用TINYINT(1),因为mysql本身是没有boolean类型的，在自动生成代码的时候，DO对象的字段就是boolean类型，例如 is_delete;其余所有时候都使用TINYINT(4) 【强制】时间字段使用时间日期类型，不要使用字符串类型存储，日期使用DATE类型，年使用YEAR类型，日期时间使用DATETIME 【建议】字符串VARCHAR(N), 其中 N表示字符个数，请尽量减少 N 的大小，例如：code VARCHAR(32)；name VARCHAR(32)；memo VARCHAR(512)； 【建议】Blob 和 Text 类型所存储的数据量大，删除和修改操作容易在数 据表里产生大量的碎片，避免使用 Blob 或 Text 类型 【推荐】时间统一格式:‘YYYY-MM-DD HH:MM:SS’ 关于索引 【建议】主键的名称以 pk_ 开头，后面加上唯一键以 uniq_ 或 uk_ 开头，普通索引以 idx_ 开头，一律使用小写格式，以字段的名称或缩写作为后缀。 【建议】单个表上的索引个数不能超过8个。 【建议】在多表join的SQL里，保证被驱动表的连接列上有索引，这样join执行效率最高。 【建议】建表或加索引时，保证表里互相不存在冗余索引（对于MySQL来说，如果表里已经存在key(a,b)，则key(a)为冗余索引，需要删除）。 【强制】页面搜索严禁左模糊或者全模糊 【推荐】防止因字段类型不同造成的隐式转换，导致索引失效 【推荐】\u0026lt;\u0026gt;!=无法使用索引，尽量避免使用 SQL编写 【强制】程序端insert语句指定具体字段名称，不要写成insert into t1 values(…) 【强制】除静态表或小表（100行以内），DML语句必须有where条件，且使用索引查找 【强制】where条件里等号左右字段类型必须一致，否则无法利用索引。 【强制】WHERE 子句中禁止只使用全模糊的LIKE条件进行查找，必须有其他等值或范围查询条件，否则无法利用索引。 【强制】索引列不要使用函数或表达式，否则无法利用索引。 Bad: where UPPER(name)=\u0026lsquo;ADMIN\u0026rsquo;或where user_id+2=10023。 【强制】禁止跨db的join语句。 【建议】不建议使用子查询，建议将子查询SQL拆开结合程序多次查询，或使用join来代替子查询。 【建议】线上环境，多表join不要超过5个表。 【建议】在多表join中，尽量选取结果集较小的表作为驱动表，来join其他表。 【建议】批量操作数据时，需要控制事务处理间隔时间，进行必要的sleep。 【建议】事务里更新语句尽量基于主键或unique key，如update … where id=XX;（否则会产生间隙锁，内部扩大锁定范围，导致系统性能下降，产生死锁。） 【建议】减少使用order by，和业务沟通能不排序就不排序，或将排序放到程序端去做。Order by、group by、distinct这些语句较为耗费CPU，数据库的CPU资源是极其宝贵的。 【建议】包含了order by、group by、distinct这些查询的语句，where条件过滤出来的结果集请保持在1000行以内，否则SQL会很慢。 【推荐】每个字段和表必须提供清晰的注释 【建议】in操作能避免则避免，若实在避免不了，需要仔细评估 in 后边的集合元素数量，控1000 个之内 【建议】针对索引字段使用 \u0026gt;, \u0026gt;=, =, \u0026lt;, \u0026lt;=, IF NULL 和 BETWEEN 将会 使用索引，如果对某个索引字段进行 LIKE 查询，使用 LIKE ‘%abc%’ 不能使用索引，使用 LIKE ‘abc%’ 将能够使用索引 【建议】对于大数据量的查询，尽量避免在 SQL 语句中使用 order by 字句 【建议】连表查询的情况下，要确保关联条件的数据类型一致，避免嵌套子查询 【建议】对于连续的数值，使用 between 代替 in ","permalink":"/blogs/2020/standard/database-specification.html","summary":"\u003ch2 id=\"设计规范\"\u003e设计规范\u003c/h2\u003e\n\u003cul\u003e\n\u003cli\u003e\n\u003cp\u003e【推荐】字段允许\u003cstrong\u003e适当冗余\u003c/strong\u003e，以提高查询性能，但必须考虑数据一致。冗余字段应遵循:\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e不是频繁修改的字段。\u003c/li\u003e\n\u003cli\u003e不是 varchar 超长字段，更不能是 text 字段\u003c/li\u003e\n\u003c/ol\u003e\n\u003cp\u003e\u003cstrong\u003eGood\u003c/strong\u003e: “产品名”适当冗余，可以减少和产品表的关联\n**Bad **: \u0026ldquo;产品修改时间\u0026rdquo;，产品描述，产品组件数\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e【推荐】数据库主键不使用自增（手动插入ID容易冲突，系统集成切割、合表自增都会有问题）\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e【推荐】字段尽量设置为 NOT NULL， 为字段提供默认值（节省空间，索引，count问题，条件需要考虑null还是空白等）\u003c/p\u003e\n\u003cp\u003e\u003cstrong\u003eGood\u003c/strong\u003e：字符型的默认值为一个空字符值串’’，数值型默认值为数值 0\u003c/p\u003e\n\u003cp\u003e\u003cstrong\u003eBad\u003c/strong\u003e：status允许为null或空白\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ul\u003e","title":"数据库设计规范"},{"content":"最近线上用户请求时不时返回502，并且没多大规律，我们的部署架构是****Nginx + web*应用，nginx中的upstream配置了两个web*做负载均衡。\n经过分析web应用，出现502的时候请求****并没有到达web应用****，所以可以断定请求502是Nginx直接返回，查看Nginx的access.log可以查到对应的请求信息，确实返回502\nGET /api/app/1 HTTP/1.1\u0026#34; 502 541 17.340 Nginx 的error.log日志相关异常：\nupstream server temporarily disabled while reading response header from upstream, client.. no live upstreams while connecting to upstream, client.. 可以看到，是因为upstream server无效了，没有可用的web应用导致，看到这个异常时，第一个反应是难不成两台web会都挂了？？？\n但是查看web的****运行日志*和服务状态service xx status*，当出现502时，web应用的运行都是正常的，并没有重启或是宕机，所以排除web应用问题，那会不会是之前有其他异常导致这个502！？继续分析了出现502之前的日志，果然，在502之前都有一个500异常，并且这个异常很有频率的出现。\n\u0026#34;GET /api/project HTTP/1.1\u0026#34; 500 214 0.087 \u0026#34;http://xx.com/\u0026#34; \u0026#34;Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36\u0026#34; \u0026#34;-\u0026#34; \u0026#34;-\u0026#34; xxx.net \u0026#34;10.x.x.x:8081, 10.x.x.x:8081\u0026#34; \u0026#34;500, 500\u0026#34; \u0026#34;0.045, 0.042\u0026#34; 通过url分析发现，这个是因为页面有一个定时任务，会十秒刷新一次，而这个api正好因为有bug，请求会返回500，不过有点想不通的是500为什么会导致后续正常请求出现502，后来通过分析nginx的nginx.conf，原来nginx配置了proxy_next_upstream属性，这个属性作用是如果发现请求返回的是后面的配置状态时就会转发到下一个upstream，例如：500\nlocation / { proxy_pass http://app-proxy; proxy_next_upstream error timeout http_500 http_502 http_503 http_504; proxy_next_upstream_tries 3; proxy_connect_timeout 60s; proxy_read_timeout 60s; proxy_send_timeout 60s; proxy_pass_request_headers on; proxy_set_header Host $host:$server_port; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; set $domain default; 结果测试发现，如果每个实例都返回500后，接下来的请求就会出现502，如果访问正常的api，又会恢复正常，说明nginx当发现upstream都为500的时候，就会临时disable所有upstream，也就是上面error.log上出现的“upstream server temporarily disabled”，后续请求就会有“*no live upstreams*”问题，但是出现502后，新请求会重新检测，当请求是200，就会恢复正常。\n解决：问题原因找到了，解决办法也就简单了，这个500一般是服务器端的bug，一般请求都不会直接返回500，出现问题及时解决就好，另外这个使用这个属性时得注意，如果请求是后面枚举的状态时，nginx会直接转到另外一个upstream，所以会出现多个实例都接收到请求的情况，有些情况下是不允许的，所以使用的时候需要分析一下。\n","permalink":"/blogs/2019/nginx/nginx-502-proxy-next-upstream.html","summary":"\u003cp\u003e最近线上用户请求时不时返回502，并且没多大规律，我们的部署架构是****Nginx + web*\u003cem\u003e\u003cstrong\u003e应用，nginx中的upstream配置了\u003c/strong\u003e两个web\u003c/em\u003e*做负载均衡。\u003c/p\u003e","title":"Nginx 502问题排查 - proxy_next_upstream"},{"content":"go语言中的context常用作实现超时功能，一般做法是在请求接收时创建一个有超时时间的context，然后将这个context作为第一个参数传入接下来的的调用方法中，是不是这样就好了？！当然不是，接下来在就要在需要超时限制的的地方开一个协程来执行可能超时的逻辑（例如调用第三方接口），主进程使用select来等待超时或请求结束，例如：\npackage main import ( \u0026#34;context\u0026#34; \u0026#34;fmt\u0026#34; \u0026#34;time\u0026#34; ) func main() { // after 2 second time out ctx, cancel :=context.WithTimeout(context.Background(), 5*time.Second) defer cancel() handle(ctx) } func handle(ctx context.Context) { resp:=make(chan error, 1) go func() { defer close(resp) resp\u0026lt;- run(ctx) }() select { case \u0026lt;-ctx.Done(): \u0026lt;-resp // wait for run return fmt.Println(\u0026#34;handle time out\u0026#34;) case \u0026lt;-resp: fmt.Println(\u0026#34;response\u0026#34;) } } // business logic func run(ctx context.Context) error { time.Sleep(10*time.Second) return nil } handle方法中超时后，run逻辑并不会马上停止，实际上还是会继续执行，直到运行结束，如果一个调用链很长， 超时后，这个调用链还是会继续运行占用资源，所以在实际开发中，如果run还有调用其他接口，会把当前的context继续作为第一个参数继续传入接下来的方法中，重复handler的逻辑，这样就可以保证资源能最大程度释放。\n","permalink":"/blogs/2019/go/go-context-timeout.html","summary":"\u003cp\u003ego语言中的context常用作实现超时功能，一般做法是在请求接收时创建一个有超时时间的context，然后将这个context作为第一个参数传入接下来的的调用方法中，是不是这样就好了？！当然不是，接下来在就要在需要超时限制的的地方开一个协程来执行可能超时的逻辑（例如调用第三方接口），主进程使用select来等待超时或请求结束，例如：\u003c/p\u003e","title":"Context超时实现"},{"content":"最近遇到一个奇怪的异常，使用Mybatis调用一个oracle的package时出现一个异常：\nMybatis中xxDAO.xml\n\u0026lt;select id=\u0026#34;getxxByUserId\u0026#34; statementType=\u0026#34;CALLABLE\u0026#34; parameterType=\u0026#34;xx.xx.xx.xxInput\u0026#34; resultMap=\u0026#34;xxResult\u0026#34;\u0026gt; { call #{output, mode=OUT, jdbcType=CURSOR, resultMap=xxResult} := XX.do_xxSearch( #{xxx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN} ) } \u0026lt;/select\u0026gt; 异常信息如下：\n16:09:32.399 [http-apr-8080-exec-6] ERROR c.xx.xx.xxService - Error occur when getting xx By xx. org.springframework.jdbc.UncategorizedSQLException: ### Error querying database. Cause: java.sql.SQLException: Non supported SQL92 token at position: 1: ### The error may exist in com/xx/xx/dao/xxDAO.xml ### The error may involve com.xx.xx.dao.xxDAO.getxxByUserId-Inline ### The error occurred while setting parameters ### SQL: { call ? := XX.do_xxSearch( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) } ### Cause: java.sql.SQLException: Non supported SQL92 token at position: 1: ; uncategorized SQLException for SQL []; SQL state [99999]; error code [17034]; Non supported SQL92 token at position: 1: ; nested exception is java.sql.SQLException: Non supported SQL92 token at position: 1: at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:84) ~[spring-jdbc-4.1.4.RELEASE.jar:4.1.4.RELEASE] at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:81) ~[spring-jdbc-4.1.4.RELEASE.jar:4.1.4.RELEASE] at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:81) ~[spring-jdbc-4.1.4.RELEASE.jar:4.1.4.RELEASE] at org.mybatis.spring.MyBatisExceptionTranslator.translateExceptionIfPossible(MyBatisExceptionTranslator.java:73) ~[mybatis-spring-1.2.1.jar:1.2.1] at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:368) ~[mybatis-spring-1.2.1.jar:1.2.1] at com.sun.proxy.$Proxy478.selectList(Unknown Source) ~[na:na] at org.mybatis.spring.SqlSessionTemplate.selectList(SqlSessionTemplate.java:198) ~[mybatis-spring-1.2.1.jar:1.2.1] at org.apache.ibatis.binding.MapperMethod.executeForMany(MapperMethod.java:114) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.binding.MapperMethod.execute(MapperMethod.java:58) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:43) ~[mybatis-3.2.3.jar:3.2.3] at com.sun.proxy.$Proxy532.getAppWorkQueueByUserId(Unknown Source) ~[na:na] .... at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_31] at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_31] at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_31] at java.lang.reflect.Method.invoke(Method.java:483) ~[na:1.8.0_31] at org.glassfish.jersey.server.model.internal.ResourceMethodInvocationHandlerFactory$1.invoke(ResourceMethodInvocationHandlerFactory.java:81) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.model.internal.AbstractJavaResourceMethodDispatcher$1.run(AbstractJavaResourceMethodDispatcher.java:144) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.model.internal.AbstractJavaResourceMethodDispatcher.invoke(AbstractJavaResourceMethodDispatcher.java:161) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.model.internal.JavaResourceMethodDispatcherProvider$TypeOutInvoker.doDispatch(JavaResourceMethodDispatcherProvider.java:205) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.model.internal.AbstractJavaResourceMethodDispatcher.dispatch(AbstractJavaResourceMethodDispatcher.java:99) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.model.ResourceMethodInvoker.invoke(ResourceMethodInvoker.java:389) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.model.ResourceMethodInvoker.apply(ResourceMethodInvoker.java:347) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.model.ResourceMethodInvoker.apply(ResourceMethodInvoker.java:102) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.ServerRuntime$2.run(ServerRuntime.java:326) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.internal.Errors$1.call(Errors.java:271) [jersey-common-2.22.1.jar:na] at org.glassfish.jersey.internal.Errors$1.call(Errors.java:267) [jersey-common-2.22.1.jar:na] at org.glassfish.jersey.internal.Errors.process(Errors.java:315) [jersey-common-2.22.1.jar:na] at org.glassfish.jersey.internal.Errors.process(Errors.java:297) [jersey-common-2.22.1.jar:na] at org.glassfish.jersey.internal.Errors.process(Errors.java:267) [jersey-common-2.22.1.jar:na] at org.glassfish.jersey.process.internal.RequestScope.runInScope(RequestScope.java:317) [jersey-common-2.22.1.jar:na] at org.glassfish.jersey.server.ServerRuntime.process(ServerRuntime.java:305) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.server.ApplicationHandler.handle(ApplicationHandler.java:1154) [jersey-server-2.22.1.jar:na] at org.glassfish.jersey.servlet.WebComponent.serviceImpl(WebComponent.java:471) [jersey-container-servlet-core-2.22.1.jar:na] at org.glassfish.jersey.servlet.WebComponent.service(WebComponent.java:425) [jersey-container-servlet-core-2.22.1.jar:na] at org.glassfish.jersey.servlet.ServletContainer.service(ServletContainer.java:383) [jersey-container-servlet-core-2.22.1.jar:na] at org.glassfish.jersey.servlet.ServletContainer.service(ServletContainer.java:336) [jersey-container-servlet-core-2.22.1.jar:na] at org.glassfish.jersey.servlet.ServletContainer.service(ServletContainer.java:223) [jersey-container-servlet-core-2.22.1.jar:na] at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:305) [catalina.jar:7.0.42] at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210) [catalina.jar:7.0.42] xx at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:243) [catalina.jar:7.0.42] at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210) [catalina.jar:7.0.42] at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:222) [catalina.jar:7.0.42] at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123) [catalina.jar:7.0.42] at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:171) [catalina.jar:7.0.42] at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:99) [catalina.jar:7.0.42] at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:953) [catalina.jar:7.0.42] at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118) [catalina.jar:7.0.42] at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:408) [catalina.jar:7.0.42] at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1023) [tomcat-coyote.jar:7.0.42] at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:589) [tomcat-coyote.jar:7.0.42] at org.apache.tomcat.util.net.AprEndpoint$SocketProcessor.run(AprEndpoint.java:1852) [tomcat-coyote.jar:7.0.42] at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142) [na:1.8.0_31] at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617) [na:1.8.0_31] at java.lang.Thread.run(Thread.java:745) [na:1.8.0_31] Caused by: java.sql.SQLException: Non supported SQL92 token at position: 1: at oracle.jdbc.driver.SQLStateMapping.newSQLException(SQLStateMapping.java:70) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.DatabaseError.newSQLException(DatabaseError.java:133) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:199) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:263) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:271) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OracleSql.handleToken(OracleSql.java:1245) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OracleSql.handleODBC(OracleSql.java:1136) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OracleSql.parse(OracleSql.java:1053) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OracleSql.getSql(OracleSql.java:310) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OracleSql.getSqlBytes(OracleSql.java:604) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.T4CCallableStatement.doOall8(T4CCallableStatement.java:177) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.T4CCallableStatement.executeForRows(T4CCallableStatement.java:950) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OracleStatement.doExecuteWithTimeout(OracleStatement.java:1222) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OraclePreparedStatement.executeInternal(OraclePreparedStatement.java:3387) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OraclePreparedStatement.execute(OraclePreparedStatement.java:3488) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OracleCallableStatement.execute(OracleCallableStatement.java:3857) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at oracle.jdbc.driver.OraclePreparedStatementWrapper.execute(OraclePreparedStatementWrapper.java:1374) ~[ojdbc6.jar:Oracle JDBC Driver version - \u0026#34;11.1.0.7.0-Production\u0026#34;] at org.apache.tomcat.dbcp.dbcp.DelegatingPreparedStatement.execute(DelegatingPreparedStatement.java:172) ~[tomcat-dbcp.jar:7.0.42] at org.apache.tomcat.dbcp.dbcp.DelegatingPreparedStatement.execute(DelegatingPreparedStatement.java:172) ~[tomcat-dbcp.jar:7.0.42] at org.apache.ibatis.executor.statement.CallableStatementHandler.query(CallableStatementHandler.java:63) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.executor.statement.RoutingStatementHandler.query(RoutingStatementHandler.java:70) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.executor.SimpleExecutor.doQuery(SimpleExecutor.java:57) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.executor.BaseExecutor.queryFromDatabase(BaseExecutor.java:259) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.executor.BaseExecutor.query(BaseExecutor.java:132) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.executor.BaseExecutor.query(BaseExecutor.java:115) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:104) ~[mybatis-3.2.3.jar:3.2.3] at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:98) ~[mybatis-3.2.3.jar:3.2.3] at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_31] at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_31] at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_31] at java.lang.reflect.Method.invoke(Method.java:483) ~[na:1.8.0_31] at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:358) ~[mybatis-spring-1.2.1.jar:1.2.1] ... 53 common frames omitted Feb 21, 2017 4:09:32 PM org.glassfish.jersey.filter.LoggingFilter log 这个异常实际上原因很简单，是因为xxDAO.xml中的大括号换行引起，解决方法也简单，升级oracle驱动，或是去掉换行。\n但是这个看似简单的原因，实际调查起来就没那么顺利，有兴趣的同学可以看一下我是怎么定位问题 因为这段代码在其他环境都是运行正常，就只有我电脑会有问题，更奇怪的是在我电脑上通过unit testing调用又是正常，一开始我是怀疑是代码不一致引起：unit testing和我部署到tomcat的代码是不一样的，但是通过我再三确认调查，代码肯定是同一份。\n所以猜想是不是Mybatis的问题，由于Mybatis只是对jdbc进行封装，最终的底层还是通过jdbc执行数据库操作，会不会是在调用jdbc时传入的参数由于某种原因不一致导致？\nJdbc 调用oracle package的方法如下： public class ProcedureCallTest { public static void main(String args[]) throws Exception { DriverManager.registerDriver(new sun.jdbc.odbc.JdbcOdbcDriver()); Connection conn = DriverManager.getConnection(\u0026#34;jdbc:odbc:mydata\u0026#34;, \u0026#34;sa\u0026#34;, \u0026#34;\u0026#34;); CallableStatement c = conn.prepareCall(\u0026#34;{call getsum(?)}\u0026#34;); c.setInt(1, 100); c.execute(); conn.close(); } } 所以有可能不一致的地方有两个地方，conn.prepareCall参数不一样或是c.setInt设置参数有问题，跟踪Mybatis源码：\nconn.prepareCall在Mybatis源码中位置是： org.apache.ibatis.executor.statement.CallableStatementHandler.java\nprotected Statement instantiateStatement(Connection connection) throws SQLException { String sql = boundSql.getSql(); if (mappedStatement.getResultSetType() != null) { return connection.prepareCall(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY); } else { return connection.prepareCall(sql); } } c.setInt设置参数是代码是：\npublic void parameterize(Statement statement) throws SQLException { registerOutputParameters((CallableStatement) statement); parameterHandler.setParameters((CallableStatement) statement); } 会根据参数类型调用不同的xxxhander.java设置参数，比如如果是参数类型是String，则调用org.apache.ibatis.type.StringTypeHandler中的ps.setString(i, parameter);设置\n最终分析结果让我很困惑，unit testing和tomcat项目传入的参数值都是一样的，所以问题就不应该是Mybatis，而是更底层，就可能是oracle的jdbc驱动不一样引起，这回找到了问题：\nunit testing使用的oracle驱动是通过maven配置的：\n\u0026lt;dependency\u0026gt; \u0026lt;groupId\u0026gt;com.oracle\u0026lt;/groupId\u0026gt; \u0026lt;artifactId\u0026gt;ojdbc7\u0026lt;/artifactId\u0026gt; \u0026lt;version\u0026gt;12.1.0.2.0\u0026lt;/version\u0026gt; \u0026lt;scope\u0026gt;provided\u0026lt;/scope\u0026gt; \u0026lt;/dependency\u0026gt; scope是provided，所以jar是不会加入部署后的项目中，找了一下项目并没有发现有加入oracle驱动，最后是在tomcat的lib中找到，发现竟然是用ojdbc6，和其他运行环境对比了一下，原来他们都用了ojdbc7，升级一下这个包，异常消失，进一步分析结论如下：\n是由于xxDAO.xml中的大括号换行引起(高亮的括号)，在ojdbc7是没问题，但是在ojdbc6会引起上述异常，如果把换行去掉，改为：\n\u0026lt;select id=\u0026#34;getxxByUserId\u0026#34; statementType=\u0026#34;CALLABLE\u0026#34; parameterType=\u0026#34;xx.xx.xx.xxInput\u0026#34; resultMap=\u0026#34;xxResult\u0026#34;\u0026gt; {call #{output, mode=OUT, jdbcType=CURSOR, resultMap=xxResult} := XX.do_xxSearch( #{xxx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN}, #{xx, javaType=java.lang.String, mode=IN} )} \u0026lt;/select\u0026gt; 这样在ojdbc6也正常，所以解决方案有两种：\n升级驱动 大括号不要换行 ","permalink":"/blogs/2017/java/mybatis/mysql-non-supported-sql92-token-at-position-1.html","summary":"\u003cp\u003e最近遇到一个奇怪的异常，使用Mybatis调用一个oracle的package时出现一个异常：\u003c/p\u003e\n\u003cp\u003eMybatis中xxDAO.xml\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-go\" data-lang=\"go\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;\u003cspan style=\"color:#66d9ef\"\u003eselect\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eid\u003c/span\u003e=\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;getxxByUserId\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003estatementType\u003c/span\u003e=\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;CALLABLE\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eparameterType\u003c/span\u003e=\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;xx.xx.xx.xxInput\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eresultMap\u003c/span\u003e=\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;xxResult\u0026#34;\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#a6e22e\"\u003ecall\u003c/span\u003e \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003eoutput\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eOUT\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejdbcType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eCURSOR\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003eresultMap\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003exxResult\u003c/span\u003e} \u003cspan style=\"color:#f92672\"\u003e:=\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eXX\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003edo_xxSearch\u003c/span\u003e(\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exxx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e},\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#960050;background-color:#1e0010\"\u003e#\u003c/span\u003e{\u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003ejavaType\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003ejava\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003elang\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eString\u003c/span\u003e, \u003cspan style=\"color:#a6e22e\"\u003emode\u003c/span\u003e=\u003cspan style=\"color:#a6e22e\"\u003eIN\u003c/span\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        )\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;\u003cspan style=\"color:#f92672\"\u003e/\u003c/span\u003e\u003cspan style=\"color:#66d9ef\"\u003eselect\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e异常信息如下：\u003c/p\u003e","title":"Mybatis调用存储过程异常-Non supported SQL92 token at position 1"},{"content":"Name : 每种资源都有自己的“名称”\n资源有API版本，类别（Kind）、元数据、定义清单（Spec）、状态（Status）\nNamespace：隔离K8S内各种“资源”\nService：\n一个Service可以看到一组提供相同服务的Pod的对外访问接口\nService作用与哪些Pod是通过标签选择器来定义的\nIngress：\nK8S集群工作在OSI网络查考模型下，第七层的应用，对外暴露的接口\nService只能进行L4流量调度，表现形式是ip+port\nIgress则可以调度不同的业务域，不同的URL访问路径的业务流量\n","permalink":"/blogs/2016/k8s/k8s-basic.html","summary":"\u003cp\u003eName : 每种资源都有自己的“名称”\u003c/p\u003e\n\u003cp\u003e资源有API版本，类别（Kind）、元数据、定义清单（Spec）、状态（Status）\u003c/p\u003e\n\u003cp\u003eNamespace：隔离K8S内各种“资源”\u003c/p\u003e","title":"K8S基础入门"},{"content":"Java web开发中常用JSP作为的视图，由于目前系统几乎都采用MVC分层架构，这样会存在一个问题，用户的请求地址有的时候并不会包含JSP文件路径的相关信息，这无疑会给开发调试带来不便，特别是JSP如果使用大量include指令或标签，找起来就头疼了，在这里我提供一个小技巧，通过增加两行代码，就可以直观的在前端HTML的注解中看到对应的JSP文件路径。\n大家应该都比较清楚，JSP最终还是会被解析成Servlet，所以JSP的第一次被调用时会有几个过程，首先，tomcat会读取JSP文件，然后进行解析，包括解析标签，指令等，然后会生成对应的Servlet源文件，然后进行动态编译加载，如果下一次请求过来时，会通过文件修改时间等条件来判断是否需要重新生成Servlet，还是直接使用，OK，知道这些后就开始进入正题，思路很简单，JSP解析不管怎么复杂，第一步肯定是读取JSP文件，我们只要在读出文件的时候，在文件内容的开始和结束部分加上注解: ，是不是很简单，步骤如下：\napache-tomcat-7.0.42版本为例，\n先到Tomcat官网下载Tomcat的源码，所有历史版本下载地址：\nhttp://archive.apache.org/dist/tomcat/\nTomcat对JSP解析的代码是放在 apache-tomcat-7.0.42/lib/jasper.jar中，首先找到读取JSP文件的类：org.apache.jasper.compiler.JspReader.java，修改pushFile方法，增加黄色部分代码，然后重新打入jasper.jar中，重启Tomcat，大工告成。\n/** * Push a file (and its associated Stream) on the file stack. THe * current position in the current file is remembered. */ private void pushFile(String file, String encoding, InputStreamReader reader) throws JasperException { ... CharArrayWriter caw = new CharArrayWriter(); caw.write(\u0026#34;\u0026lt;!-- SRC: \u0026#34;+ file +\u0026#34; start --\u0026gt;\u0026#34;); char buf[] = new char[1024]; for (int i = 0 ; (i = reader.read(buf)) != -1 ;) caw.write(buf, 0, i); caw.write(\u0026#34;\u0026lt;!-- SRC: \u0026#34;+ file +\u0026#34; end --\u0026gt;\u0026#34;); caw.close(); ... } 最终效果： index.jsp\n\u0026lt;%@ page language=\u0026#34;java\u0026#34; contentType=\u0026#34;text/html; charset=UTF-8\u0026#34; pageEncoding=\u0026#34;UTF-8\u0026#34;%\u0026gt; \u0026lt;body\u0026gt; \u0026lt;%@include file=\u0026#34;directive_include.jsp\u0026#34; %\u0026gt; \u0026lt;jsp:include page=\u0026#34;tag_include.jsp\u0026#34;\u0026gt;\u0026lt;/jsp:include\u0026gt; \u0026lt;/body\u0026gt; \u0026lt;/html\u0026gt; directive_include.jsp\n\u0026lt;div\u0026gt;directive_include.jsp\u0026lt;/div\u0026gt; tag_include.jsp\n\u0026lt;div\u0026gt;tag_include.jsp\u0026lt;/div\u0026gt; 访问index.jsp后，在浏览器看到的html为：\n\u0026lt;!--SRC: /index.jsp start--\u0026gt; \u0026lt;html\u0026gt;\u0026lt;head\u0026gt; \u0026lt;meta http-equiv=\u0026#34;Content-Type\u0026#34; content=\u0026#34;text/html; charset=UTF-8\u0026#34;\u0026gt; \u0026lt;title\u0026gt;Insert title here\u0026lt;/title\u0026gt; \u0026lt;/head\u0026gt; \u0026lt;body\u0026gt; \u0026lt;!--SRC: /directive_include.jsp start--\u0026gt;\u0026lt;div\u0026gt;directive_include.jsp\u0026lt;/div\u0026gt;\u0026lt;!--SRC: /directive_include.jsp end--\u0026gt; \u0026lt;!--SRC: /tag_include.jsp start--\u0026gt;\u0026lt;div\u0026gt;tag_include.jsp\u0026lt;/div\u0026gt;\u0026lt;!--SRC: /tag_include.jsp end--\u0026gt; \u0026lt;/body\u0026gt;\u0026lt;/html\u0026gt; \u0026lt;!--SRC: /index.jsp end--\u0026gt; 不同版本的tomcat中的org.apache.jasper.compiler.JspReader.java会有点不同，但是思路一样，例如apache-tomcat-8.0.21需要修改JspReader.java的构造方法，如下\npublic JspReader(JspCompilationContext ctxt, String fname, InputStreamReader reader, ErrorDispatcher err) throws JasperException { this.context = ctxt; this.err = err; try { CharArrayWriter caw = new CharArrayWriter(); caw.write(\u0026#34;\u0026lt;!-- SRC: \u0026#34; + fname + \u0026#34;start --\u0026gt;\u0026#34;); char buf[] = new char[1024]; for (int i = 0 ; (i = reader.read(buf)) != -1 ;) caw.write(buf, 0, i); caw.write(\u0026#34;\u0026lt;!-- SRC: \u0026#34; + fname + \u0026#34;end --\u0026gt;\u0026#34;); caw.close(); current = new Mark(this, caw.toCharArray(), fname); } catch (Throwable ex) { ExceptionUtils.handleThrowable(ex); log.error(\u0026#34;Exception parsing file \u0026#34;, ex); err.jspError(\u0026#34;jsp.error.file.cannot.read\u0026#34;, fname); } finally { if (reader != null) { try { reader.close(); } catch (Exception any) { if(log.isDebugEnabled()) { log.debug(\u0026#34;Exception closing reader: \u0026#34;, any); } } } } } 类似思路在理论上也可以用在定位原文件类型本来就是html的情况，我还没有试过，如果有兴趣大家可以研究一下。\n","permalink":"/blogs/2016/java/jsp/jsp-html-path.html","summary":"\u003cp\u003eJava web开发中常用JSP作为的视图，由于目前系统几乎都采用MVC分层架构，这样会存在一个问题，用户的请求地址有的时候并不会包含JSP文件路径的相关信息，这无疑会给开发调试带来不便，特别是JSP如果使用大量include指令或标签，找起来就头疼了，在这里我提供一个小技巧，通过增加两行代码，就可以直观的在前端HTML的注解中看到对应的JSP文件路径。\u003c/p\u003e","title":"两行代码让Html注解中显示JSP文件路径"},{"content":"Jersey 支持Web Application Description Language (WADL), 可以通过http://localhost:8080/xx/application.wadl来查看所有的RESTful API, 例如:\n工程路径: http://127.0.0.1:8080/itart Web.xml \u0026lt;servlet-mapping\u0026gt; \u0026lt;servlet-name\u0026gt;jersey-front-servlet\u0026lt;/servlet-name\u0026gt; \u0026lt;url-pattern\u0026gt;/api/front/*\u0026lt;/url-pattern\u0026gt; \u0026lt;/servlet-mapping\u0026gt; 查看路径为: http://127.0.0.1:8080/itart/api/front/application.wadl 效果图: 其中resources下的所有resource就是当前应用程序所有的资源明细, 包括path, parameter, 访问的method等.\n当然了, 如果你不需要这个功能或是觉得这样不安全也可以关闭, 设置jersey.config.server.wadl.disableWadl=true, 例如 package top.itart.blog.front.config; import org.glassfish.jersey.server.ResourceConfig; import org.glassfish.jersey.server.ServerProperties; public class FrontResourceConfig extends ResourceConfig { public FrontResourceConfig(){ -- other code property(ServerProperties.WADL_FEATURE_DISABLE, true); } } ","permalink":"/blogs/2016/api/jersey-restful-api.html","summary":"\u003cp\u003eJersey 支持Web Application Description Language (WADL), 可以通过http://localhost:8080/xx/application.wadl来查看所有的RESTful API, 例如:\u003c/p\u003e","title":"Jersey - 查看所有的RESTful明细"},{"content":"在Java开发时, 如果数据库连接 (Connection) 没有正确关闭, 会导致该连接一直被占用, 没有释放, 也就无法被重用或关闭, 最终会导致数据库连接的溢出, 无法获取连接, 程序也就挂了.\n我们可以通过以下SQL来查询当前数据库的连接数, 正常情况下连接数会保持一定数量, 如果不是并发数突然增大的情况下.\nselect username, count(username) from v$session where username is not null group by username 由于获取数据库连接比较耗时, 所以通常的做法是采用连接池, 一开始就获取一定量的连接数, 需要连接时就从连接池中获取一个, 标记成正在被使用, 别人就无法再获取这个连接, 使用完后不会关闭, 只是去除被使用的标示, 释放回连接池, 这时这个连接可以再次被使用, 一旦连接池中的连接都被使用, 这时要看连接池的管理策略, 一种策略是自动关闭超时的连接,这种情况下就比较难通过数据库的方面来查看连接是否正常, 只能另外通过其他办法排查, 另外一种策略是, 如果连接池中的连接都被使用, 就会重新再增加一个连接数, 所以在这种情况下, 如果有连接没有正常关闭, 等到连接池中的连接全部使用完, 通过oracle查询就会发现连接一直在增加.\n","permalink":"/blogs/2016/linux/oracle-connect-select-close.html","summary":"\u003cp\u003e在Java开发时, 如果数据库连接 (Connection) 没有正确关闭, 会导致该连接一直被占用, 没有释放, 也就无法被重用或关闭, 最终会导致数据库连接的溢出, 无法获取连接, 程序也就挂了.\u003c/p\u003e","title":"Oracle 获取连接数 - 排查程序是否正确关闭连接"},{"content":"Eclipse RCP (Rich Client Platform) 为Java桌面程序开发提供了一个基础平台, 基于该平台用户可以快速开发出一个具有很好扩展性的桌面程序, 我们使用的Eclipse实际上就是一个以Eclipse RCP为平台, 集成各种功能的插件的一个开发工具, Eclipse RCP的核心组件如下:\nOSGI, Java语言的动态模块系统, 它为模块化应用的开发定义了一个基础架构. 简单的说,通过OSGi可以在后台对设备组件进行安装, 升级或卸载而无需打断该设备的正常运行, Equinox是OSGI规范的一种实现, 为Eclipse 模块化提供必要的API和框架. SWT是eclipse的标准的UI库, JFace 是基于SWT, 为eclipse提供更加方便使用的API, workbench是程序的框架, 为所有其他的UI组件提供显示的容器. Eclipse Modeling Framework (EMF), ,Eclipse提供的一套建模框架, 可以用EMF建立自己的UML模型，设计模型的XML格式或编写模型的java代码. 了解完EclipseRCP主要核心组件,那么就开始我们第一个RCP程序.\n开发之前, 首先需要下载IDE, 打开官网http://www.eclipse.org/downloads/, 里面有很多针对不同软件开发的eclipse版本, 现在我们准备开发的是RCP, 所以下载Eclipse for RCP and RAP Developers, 当前最新版本是4.5.0, 需要JDK版本高于1.7\n打开软件, File \u0026gt; New \u0026gt; Plug-in Project 填写Project name, 虽然可以任意字符串, 但是为了避免冲突, 建议采用和java包命名类似, 按照域名的范围从大到小逐步列出,恰好和Internet上的域名命名规则相反, 接着Next\u0026gt; Version软件的版本,Vendor软件提供者, 可以任意写, 勾选: Would you like to create a rich client application?, 因为我们这里是创建一个独立的客户端程序, 接着Next\u0026gt; 选择工程模板: Eclipse 4 RCP application, Next\u0026gt;. 勾选, \u0026ldquo;Create sample content (part, menu, command..)\u0026rdquo;, Finish 工程创建好了, 可以运行一下看一下效果, 双击top.itart.rcp.helloworld.product \u0026gt; Launch an Eclipse application 效果如下: 导出成EXE程序, 工程右键 \u0026gt; Export..\n选择Eclipse product, Next \u0026gt; 填写项目导出路径: Directory, Finish. ","permalink":"/blogs/2016/java/eclipse/first-eclipse-rcp.html","summary":"\u003cp\u003eEclipse RCP (Rich Client Platform) 为Java桌面程序开发提供了一个基础平台, 基于该平台用户可以快速开发出一个具有很好扩展性的桌面程序, 我们使用的Eclipse实际上就是一个以Eclipse RCP为平台, 集成各种功能的插件的一个开发工具, Eclipse RCP的核心组件如下:\u003c/p\u003e","title":"Eclipse RCP - 第一个RCP程序"},{"content":"Eclipse在加载项目时, 会对文件进行缓存, 所以如果不是在Eclipse中编辑文件, 通过调用外部程序, 例如: 系统自带的文本编辑器, 对工程中的文件进行修改, 需要手动在Eclipse中刷新一下才能重新加载.\n如果在开发Eclipse 插件时, 需要通过外部程序来修改文件, 这时就需要有一个方法能自动的在执行完外部程序后刷新文件, 代码如下:\nIFile f = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(\u0026#34;itart/src/HelloWorld.java\u0026#34;)); f.refreshLocal(IResource.DEPTH_ZERO, null); 备注：\n\u0026ldquo;itart/src/HelloWorld.java\u0026rdquo; : 文件的相对路径, itart是工程名\nIResource.DEPTH_ZERO: 表示只刷新该文件.\n","permalink":"/blogs/2016/java/eclipse/eclipse-plugin-file-refresh.html","summary":"\u003cp\u003eEclipse在加载项目时, 会对文件进行缓存, 所以如果不是在Eclipse中编辑文件, 通过调用外部程序, 例如: 系统自带的文本编辑器, 对工程中的文件进行修改, 需要手动在Eclipse中刷新一下才能重新加载.\u003c/p\u003e","title":"Eclipse 插件开发 - 实现外部程序修改文件后刷新功能"},{"content":"Java 处理异常的语句try-catch-finally应该大家都不陌生, 程序中很多地方都会使用到, 比如IO操作, 对文件的读写, 数据库读写等, 另外事务处理也会用到, 在try块中处理逻辑, catch中回滚事务 ,finally中提交事务, 举个例子:\nFileReadDemo.java\npublic class FileReadDemo { public void readFile() throws IOException { byte[] buff = new byte[1024]; FileInputStream input = null; try { input = new FileInputStream(new File(\u0026#34;D:/test/itart.txt\u0026#34;)); while (-1 != input.read(buff)) { System.out.println(new String(buff)); } } catch (IOException e) { throw e; } finally { if (null != input) { try { input.close(); } catch (IOException e) { throw e; } } } } public static void main(String[] args) { try { new FileReadDemo().readFile(); } catch (IOException e) { e.printStackTrace(); } } } 注意: 上面的例子实际上存在异常丢失的隐患, 如果第一个try中出现异常, 接着在执行finally中的input.close()也出现异常, 这时main 方法只能接收到input.close的异常信息, 第一个异常会被覆盖, 导致异常信息丢失, 详见: try-catch-finally异常信息丢失\n所以正确的写法如下:\npublic class FileReadDemo { public void readFile() throws ApplicationException { byte[] buff = new byte[1024]; IOException processException = null; FileInputStream input = null; try { input = new FileInputStream(new File(\u0026#34;D:/test/itart.txt\u0026#34;)); while (-1 != input.read(buff)) { System.out.println(new String(buff)); } } catch (IOException e) { processException = e; } finally { try { if(null != input){ input.close(); } } catch (IOException e) { if(null == processException){ throw new ApplicationException(e); }else{ throw new ApplicationException(\u0026#34;FileInputStream close exception\u0026#34;, processException); } } if(processException !=null){ throw new ApplicationException(processException); } } } public static void main(String[] args){ try { new FileReadDemo().readFile(); } catch (ApplicationException e) { e.printStackTrace(); } } } 这种写法是不是很糟糕, 我们实际关注的代码就只是第一个try中的四行代码, 这样的缺陷很明显, 一旦系统中有多处地方要用到类似的文件处理操作时, 就需要重复的做try-catch-finally, 很明显, 这就违背了程序开发中的一个重要原则: DRY(Don’t repeat yourself), 代码重复, 不容易阅读和维护, 同时也存在一个隐患, 忘记关闭, 异常没正确处理等, 引入模板方法就可以很好的解决这个问题.\n咱们先对代码进行重构, 剥离业务代码和异常处理代码.\npublic class FileReadDemo { public void readFile(String path) throws ApplicationException { IOException processException = null; FileInputStream input = null; try { input = new FileInputStream(new File(path)); process(input); } catch (IOException e) { processException = e; } finally { try { if (null != input) { input.close(); } } catch (IOException e) { if (null == processException) { throw new ApplicationException(e); } else { throw new ApplicationException( \u0026#34;FileInputStream close exception\u0026#34;, processException); } } if (processException != null) { throw new ApplicationException(processException); } } } public void process(FileInputStream input) throws IOException { byte[] buff = new byte[1024]; while (-1 != input.read(buff)) { System.out.println(new String(buff)); } } public static void main(String[] args) { try { new FileReadDemo().readFile(\u0026#34;D:/test/itart.txt\u0026#34;); } catch (ApplicationException e) { e.printStackTrace(); } } } 可以看到, 在实际项目中每个功能对文件处理的差异地方就只有process方法, readFile中的异常处理是都一样的, 所以可以将readFile当成模板方法可以重复使用, process定义为抽象类, 由具体代码实现, 这样代码就可以变为:\npublic abstract class FileReadDemo { public void readFile(String path) throws ApplicationException { IOException processException = null; FileInputStream input = null; try { input = new FileInputStream(new File(path)); process(input); } catch (IOException e) { processException = e; } finally { try { if (null != input) { input.close(); } } catch (IOException e) { if (null == processException) { throw new ApplicationException(e); } else { throw new ApplicationException( \u0026#34;FileInputStream close exception\u0026#34;, processException); } } if (processException != null) { throw new ApplicationException(processException); } } } public abstract void process(FileInputStream input) throws IOException; public static void main(String[] args) { try { new FileReadDemo() { @Override public void process(FileInputStream input) throws IOException { byte[] buff = new byte[1024]; while (-1 != input.read(buff)) { System.out.println(new String(buff)); } } }.readFile(\u0026#34;D:/test/itart.txt\u0026#34;); } catch (ApplicationException e) { e.printStackTrace(); } } } 最后分离模板, 整理效果如下: 模板类: FileInputStreamTemplate.java\npublic abstract class FileInputStreamTemplate { public void readFile(String path) throws ApplicationException { IOException processException = null; FileInputStream input = null; try { input = new FileInputStream(new File(path)); process(input); } catch (IOException e) { processException = e; } finally { try { if (null != input) { input.close(); } } catch (IOException e) { if (null == processException) { throw new ApplicationException(e); } else { throw new ApplicationException( \u0026#34;FileInputStream close exception\u0026#34;, processException); } } if (processException != null) { throw new ApplicationException(processException); } } } public abstract void process(FileInputStream input) throws IOException; } 使用方式: Client.java\npublic abstract class Client { public static void main(String[] args) throws ApplicationException { new FileInputStreamTemplate() { @Override public void process(FileInputStream input) throws IOException { byte[] buff = new byte[1024]; while (-1 != input.read(buff)) { System.out.println(new String(buff)); } } }.readFile(\u0026#34;D:/test/itart.txt\u0026#34;); } } 这样代码是不是清晰很多, 为了让代码更加容易阅读, 我们可以进一步改进, 将模板方法改为静态模板方法, 定义一个process方法的接口, 具体如下\n定义一个处理器接口InputStreamProcessor.java\npublic interface InputStreamProcessor { public void process(FileInputStream input) throws IOException; } 模板方法改为静态模板方法\npublic class FileInputStreamTemplate { public static void readFile(String path, InputStreamProcessor processor) throws ApplicationException { IOException processException = null; FileInputStream input = null; try { input = new FileInputStream(new File(path)); processor.process(input); } catch (IOException e) { processException = e; } finally { try { if (null != input) { input.close(); } } catch (IOException e) { if (null == processException) { throw new ApplicationException(e); } else { throw new ApplicationException( \u0026#34;FileInputStream close exception\u0026#34;, processException); } } if (processException != null) { throw new ApplicationException(processException); } } } } 调用方式: Client.java\npublic abstract class Client { public static void main(String[] args) throws ApplicationException { FileInputStreamTemplate.readFile(\u0026#34;D:/test/itart.txt\u0026#34;, new InputStreamProcessor() { @Override public void process(FileInputStream input) throws IOException { byte[] buff = new byte[1024]; while (-1 != input.read(buff)) { System.out.println(new String(buff)); } } }); } } InputStreamProcessor的实现类是采用匿名实现方式, 这是因为一般情况下这个类是不会被重复使用, 没有必要再定义一个子类.\n模板方法可以有效的减少重复代码, 提高代码的可阅读性, 可维护性, 实际项目开发中, 可以应用模板方法的地方很多, 就像IO操作的地方, 如: 读写文件, 还有JDBC, 事务管理等等.\n","permalink":"/blogs/2015/java/try-catch-finally.html","summary":"\u003cp\u003eJava 处理异常的语句try-catch-finally应该大家都不陌生, 程序中很多地方都会使用到, 比如IO操作, 对文件的读写, 数据库读写等, 另外事务处理也会用到, 在try块中处理逻辑, catch中回滚事务 ,finally中提交事务, 举个例子:\u003c/p\u003e","title":"异常管理 - 采用模板方法优化try-catch-finally"},{"content":"Java异常指定是程序在运行过程中出现错误或异常, 超出程序处理范围, 一旦出现异常, 如果不处理, 就没有必要继续运行下去, JAVA有两种类型的异常\n检查异常 (Checked Exception) 检查异常类继承java.lang.Exception, 必须明确的捕获(Caught)或propagated(传播), 需要显示的调用try-catch-finally 或 throws.\n例如:　FileNotFoundException, IOException\ntry-catch-finally\npublic void readFile(){ try { FileInputStream input= new FileInputStream(new File(\u0026#34;D://test.txt\u0026#34;)); } catch (FileNotFoundException e) { e.printStackTrace(); } } throws\npublic void readFile() throws FileNotFoundException{ FileInputStream input = new FileInputStream(new File(\u0026#34;D://test.txt\u0026#34;));; } 未检查异常 (Unchecked Exception) 未检查异常类继承java.lang.RuntimeException, 无需显示的捕获(Caught)或propagated(传播)，　例如：NullPointerException , InvalidArgumentException\n检查异常和未检查异常最终功能上都是一样的, 检查异常可以处理的未检查异常也可以处理,至于要使用哪种异常类型可以根据实际情况, 但是建议整个程序保持一致, 要么使用检查异常, 要么都使用未检查异常, 对于检查异常 (Checked Exception)与未检查异常 (Unchecked Exception)两个哪个比较好的问题, 网上有不同的见解:\n支持Checked Exception的人认为 使用checked Exception需要编译器强制捕获或抛出某个异常, 这样开发者就不会遗忘, 而Unchecked Exception则不需要, 出现漏处理的问题. Unchecked Exception通常会在最顶级进行捕获处理, 这样如果异常是最底层抛出, 就不容易定位错误位置, 不容易排查问题. 支持Unchecked Exception的人认为 使用Unchecked Exception可以让代码显得简洁, 如果代码到处充斥着try-catch会让人感觉混乱, 影响代码阅读, 并且大多情况下对checked Exception都只是简单处理或干脆就直接throw, 所以没多大必要, 就像标准的Java API 很多也是用的是Unchecked Exception就比如说: NullPointerException , InvalidArgumentException. Checked Exception异常如果throw方式处理异常会影响接口的稳定性, 一旦增加抛出或修改异常类型, 调用方法就必须重新捕获或修改， Unchecked Exception可以不需要显示捕获和抛出, 可以保证接口的稳定性. 我的观点是使用Unchecked Exception, 在我实际开发中, 异常的处理往往都只是try-catch然后throw, 然后由调用它的顶级方法进行处理, 所以没必要使用 Checked Exception, 另外我们通常会异常进行统一管理, 我们通常会自定义异常类, 这样就避免了异常信息混乱, 不易排查的问题.\n自定义异常类可以统一管理异常, 不需要对每个异常类进行单独处理, 比如在一些场景中, 顶级方法会调用一堆的方法, 在这一堆的方法中会分别抛出各种各样的异常, 这时顶级方法就必须对这些方法进行捕获, 这时就要指定捕获的类型, 一旦子方法抛出的异常类型变动, 就需要修改顶级方法. 例如: 顶级方法调用Dao层的方法, 开始Dao持久化的数据时保存在数据库, 这时就可能抛出的异常类型是SQLException, 如果想把数据保存在xml 文件时, 可能抛出的异常就会变为IOException, 如果顶级方法开始捕获的是SQLException, 现在就必须改为 IOException.\n为了解决这个问题, 一般会自定义一个异常, 例如DaoException.java, 一旦Dao层出现异常, 就对异常进行捕获, 并将异常统一转化成为DaoException抛出:\ntry{ dao.getPersion(); } catch (SQLException sqlException) { throw new DaoException(\u0026#34;error text\u0026#34;, sqlException); } DaoException.java\npublic class DaoException extends RuntimeException { private static final long serialVersionUID = 8328325784637321672L; public DaoException() { super(); } public DaoException(String message, Throwable cause) { super(message, cause); } public DaoException(String message) { super(message); } public DaoException(Throwable cause) { super(cause); } } ","permalink":"/blogs/2015/java/unchecked-exception-vs-checked-exception.html","summary":"\u003cp\u003eJava异常指定是程序在运行过程中出现错误或异常, 超出程序处理范围, 一旦出现异常, 如果不处理, 就没有必要继续运行下去, JAVA有两种类型的异常\u003c/p\u003e","title":"异常管理 - Java异常处理分析 (Unchecked Exception VS Checked Exception)"},{"content":"实现效果: 监听Eclipse修改文件时, 同时更新某一个文件, 因为更新采用的是外部程序, 所以修改的时候需要调用Eclipse的方法Resources.refreshLocal重新加载这个文件.\n添加监听 ResourcesPlugin.getWorkspace().addResourceChangeListener( resourceChangeListener, IResourceChangeEvent.POST_BUILD); 在resourceChangeListener中刷新文件 IFile f = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(new Path(\u0026#34;D:/depot/workspace/itart/src/main.java\u0026#34;)); f.refreshLocal(IResource.DEPTH_ZERO, null); 异常信息\norg.eclipse.core.internal.resources.ResourceException: The resource tree is locked for modifications. at org.eclipse.core.internal.resources.WorkManager.checkIn(WorkManager.java:116) at org.eclipse.core.internal.resources.Workspace.prepareOperation(Workspace.java:2282) at org.eclipse.core.internal.resources.Resource.refreshLocal(Resource.java:1655) at org.eclipse.core.internal.resources.File.refreshLocal(File.java:333) at top.itart.auto.grunt.handlers.ExecuteHandler.refreshFile(ExecuteHandler.java:52) at top.itart.auto.grunt.handlers.ExecuteHandler.execute(ExecuteHandler.java:40) at top.itart.auto.grunt.handlers.FileChangeHandler.handle(FileChangeHandler.java:14) at top.itart.auto.grunt.listener.ResourceChangeListener.resourceChanged(ResourceChangeListener.java:66) at org.eclipse.core.internal.events.NotificationManager$1.run(NotificationManager.java:291) at org.eclipse.core.runtime.SafeRunner.run(SafeRunner.java:42) at org.eclipse.core.internal.events.NotificationManager.notify(NotificationManager.java:285) at org.eclipse.core.internal.events.NotificationManager.broadcastChanges(NotificationManager.java:149) at org.eclipse.core.internal.resources.Workspace.broadcastPostChange(Workspace.java:395) at org.eclipse.core.internal.resources.Workspace.endOperation(Workspace.java:1530) at org.eclipse.core.internal.resources.Workspace.run(Workspace.java:2353) at org.eclipse.ui.actions.WorkspaceModifyOperation.run(WorkspaceModifyOperation.java:118) at org.eclipse.ui.internal.editors.text.WorkspaceOperationRunner.run(WorkspaceOperationRunner.java:75) at org.eclipse.ui.internal.editors.text.WorkspaceOperationRunner.run(WorkspaceOperationRunner.java:65) at org.eclipse.ui.editors.text.TextFileDocumentProvider.executeOperation(TextFileDocumentProvider.java:456) at org.eclipse.ui.editors.text.TextFileDocumentProvider.saveDocument(TextFileDocumentProvider.java:772) at org.eclipse.ui.texteditor.AbstractTextEditor.performSave(AbstractTextEditor.java:5048) at org.eclipse.wst.jsdt.internal.ui.javaeditor.CompilationUnitEditor.performSave(CompilationUnitEditor.java:1210) at org.eclipse.wst.jsdt.internal.ui.javaeditor.CompilationUnitEditor.doSave(CompilationUnitEditor.java:1263) at org.eclipse.ui.texteditor.AbstractTextEditor$TextEditorSavable.doSave(AbstractTextEditor.java:7177) at org.eclipse.ui.Saveable.doSave(Saveable.java:214) at org.eclipse.ui.internal.SaveableHelper.doSaveModel(SaveableHelper.java:349) at org.eclipse.ui.internal.SaveableHelper$3.run(SaveableHelper.java:195) at org.eclipse.ui.internal.SaveableHelper$5.run(SaveableHelper.java:277) at org.eclipse.jface.operation.ModalContext.runInCurrentThread(ModalContext.java:464) at org.eclipse.jface.operation.ModalContext.run(ModalContext.java:372) at org.eclipse.jface.window.ApplicationWindow$1.run(ApplicationWindow.java:759) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:70) at org.eclipse.jface.window.ApplicationWindow.run(ApplicationWindow.java:756) at org.eclipse.ui.internal.WorkbenchWindow.run(WorkbenchWindow.java:2649) at org.eclipse.ui.internal.SaveableHelper.runProgressMonitorOperation(SaveableHelper.java:285) at org.eclipse.ui.internal.SaveableHelper.runProgressMonitorOperation(SaveableHelper.java:264) at org.eclipse.ui.internal.SaveableHelper.saveModels(SaveableHelper.java:207) at org.eclipse.ui.internal.SaveableHelper.savePart(SaveableHelper.java:144) at org.eclipse.ui.internal.EditorManager.savePart(EditorManager.java:1399) at org.eclipse.ui.internal.WorkbenchPage.savePart(WorkbenchPage.java:3416) at org.eclipse.ui.internal.WorkbenchPage.saveEditor(WorkbenchPage.java:3429) at org.eclipse.ui.internal.handlers.SaveHandler.execute(SaveHandler.java:54) at org.eclipse.ui.internal.handlers.HandlerProxy.execute(HandlerProxy.java:293) at org.eclipse.core.commands.Command.executeWithChecks(Command.java:476) at org.eclipse.core.commands.ParameterizedCommand.executeWithChecks(ParameterizedCommand.java:508) at org.eclipse.ui.internal.handlers.HandlerService.executeCommand(HandlerService.java:169) at org.eclipse.ui.internal.keys.WorkbenchKeyboard.executeCommand(WorkbenchKeyboard.java:468) at org.eclipse.ui.internal.keys.WorkbenchKeyboard.press(WorkbenchKeyboard.java:786) at org.eclipse.ui.internal.keys.WorkbenchKeyboard.processKeyEvent(WorkbenchKeyboard.java:885) at org.eclipse.ui.internal.keys.WorkbenchKeyboard.filterKeySequenceBindings(WorkbenchKeyboard.java:567) at org.eclipse.ui.internal.keys.WorkbenchKeyboard.access$3(WorkbenchKeyboard.java:508) at org.eclipse.ui.internal.keys.WorkbenchKeyboard$KeyDownFilter.handleEvent(WorkbenchKeyboard.java:123) at org.eclipse.swt.widgets.EventTable.sendEvent(EventTable.java:84) at org.eclipse.swt.widgets.Display.filterEvent(Display.java:1262) at org.eclipse.swt.widgets.Widget.sendEvent(Widget.java:1052) at org.eclipse.swt.widgets.Widget.sendEvent(Widget.java:1077) at org.eclipse.swt.widgets.Widget.sendEvent(Widget.java:1062) at org.eclipse.swt.widgets.Widget.sendKeyEvent(Widget.java:1104) at org.eclipse.swt.widgets.Widget.sendKeyEvent(Widget.java:1100) at org.eclipse.swt.widgets.Widget.wmChar(Widget.java:1509) at org.eclipse.swt.widgets.Control.WM_CHAR(Control.java:4640) at org.eclipse.swt.widgets.Canvas.WM_CHAR(Canvas.java:345) at org.eclipse.swt.widgets.Control.windowProc(Control.java:4528) at org.eclipse.swt.widgets.Canvas.windowProc(Canvas.java:341) at org.eclipse.swt.widgets.Display.windowProc(Display.java:4972) at org.eclipse.swt.internal.win32.OS.DispatchMessageW(Native Method) at org.eclipse.swt.internal.win32.OS.DispatchMessage(OS.java:2531) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java:3752) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java:2701) at org.eclipse.ui.internal.Workbench.runUI(Workbench.java:2665) at org.eclipse.ui.internal.Workbench.access$4(Workbench.java:2499) at org.eclipse.ui.internal.Workbench$7.run(Workbench.java:679) at org.eclipse.core.databinding.observable.Realm.runWithDefault(Realm.java:332) at org.eclipse.ui.internal.Workbench.createAndRunWorkbench(Workbench.java:668) at org.eclipse.ui.PlatformUI.createAndRunWorkbench(PlatformUI.java:149) at org.eclipse.ui.internal.ide.application.IDEApplication.start(IDEApplication.java:123) at org.eclipse.equinox.internal.app.EclipseAppHandle.run(EclipseAppHandle.java:196) at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.runApplication(EclipseAppLauncher.java:110) at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.start(EclipseAppLauncher.java:79) at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:344) at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:179) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at org.eclipse.equinox.launcher.Main.invokeFramework(Main.java:622) at org.eclipse.equinox.launcher.Main.basicRun(Main.java:577) at org.eclipse.equinox.launcher.Main.run(Main.java:1410) at org.eclipse.equinox.launcher.Main.main(Main.java:1386) 分析: Eclipse在触发POST_CHANGE事件时, 会对资源文件进行锁定\n方案1: 创建一个Job 来执行文件刷新事件.\nJob job = new Job(\u0026#34;Load Project\u0026#34;) { @Override protected IStatus run(IProgressMonitor monitor) { // Put your logic here IFile f = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(new Path(ApplicationContext.getRefreshFilePath())); f.refreshLocal(IResource.DEPTH_ZERO, null); return Status.OK_STATUS; } }; job.setUser(true); job.schedule(); 缺点是执行的时候会弹出一个提示对话框, 虽然会自动消失, 但是看起来突兀, 建议采用方案2.\n方案2: 将监听事件POST_BUILD, 改为 PRE_BUILD\nResourcesPlugin.getWorkspace().addResourceChangeListener( resourceChangeListener, IResourceChangeEvent.PRE_BUILD); ","permalink":"/blogs/2015/java/eclipse/the-resource-tree-is-locked-for-modifications.html","summary":"\u003cp\u003e实现效果: 监听Eclipse修改文件时, 同时更新某一个文件, 因为更新采用的是外部程序, 所以修改的时候需要调用Eclipse的方法Resources.refreshLocal重新加载这个文件.\u003c/p\u003e","title":"Eclipse 插件开发 - The resource tree is locked for modifications"},{"content":"在开发Eclipse 插件时, 想在工具栏中增加一个按钮图标是非常容易, 但是想在图标上增加子菜单就会比较麻烦, 例如想实现如下效果:\n具体步骤如下:\n首先在扩展点org.eclipse.ui.commands中增加三个指令\n\u0026lt;extension point=\u0026#34;org.eclipse.ui.commands\u0026#34;\u0026gt; \u0026lt;command name=\u0026#34;Reference Command\u0026#34; id=\u0026#34;top.itart.plugin.smartboot.referenceCommand\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;command name=\u0026#34;Sub1 Command\u0026#34; id=\u0026#34;top.itart.plugin.smartboot.sub1Command\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;command name=\u0026#34;Sub2 Command\u0026#34; id=\u0026#34;top.itart.plugin.smartboot.sub2Command\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;/extension\u0026gt; 其次在扩展点org.eclipse.ui.menus 增加两个menuContribution\n\u0026lt;menuContribution locationURI=\u0026#34;toolbar:org.eclipse.ui.main.toolbar?after=additions\u0026#34;\u0026gt; \u0026lt;toolbar id=\u0026#34;top.itart.plugin.smartboot.toolbars\u0026#34;\u0026gt; \u0026lt;command commandId=\u0026#34;top.itart.plugin.smartboot.referenceCommand\u0026#34; icon=\u0026#34;icons/sample.gif\u0026#34; tooltip=\u0026#34;Pull down\u0026#34; style=\u0026#34;pulldown\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;/toolbar\u0026gt; \u0026lt;/menuContribution\u0026gt; 这个是定义显示在toolbar上的菜单. Command 中的commandId 为第一个指令的ID, 类型 type 为pulldown, 并且放在toolbar标签中\n\u0026lt;menuContribution locationURI=\u0026#34;menu:top.itart.plugin.smartboot.referenceCommand\u0026#34;\u0026gt; \u0026lt;command commandId=\u0026#34;top.itart.plugin.smartboot.sub1Command\u0026#34; icon=\u0026#34;icons/sample.gif\u0026#34; label = \u0026#34;Sub 1\u0026#34; tooltip=\u0026#34;Sub 1\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;command commandId=\u0026#34;top.itart.plugin.smartboot.sub2Command\u0026#34; icon=\u0026#34;icons/sample.gif\u0026#34; tooltip=\u0026#34;Sub2\u0026#34; label = \u0026#34;Sub 2\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;/menuContribution\u0026gt; 这个menuContribution是定义下拉的子菜单. 注意locationURI的值是menu: \u0026lt;Toolbar上的菜单ID\u0026gt;\n最终的plugin.xml如下\n\u0026lt;?xml version=\u0026#34;1.0\u0026#34; encoding=\u0026#34;UTF-8\u0026#34;?\u0026gt; \u0026lt;?eclipse version=\u0026#34;3.4\u0026#34;?\u0026gt; \u0026lt;plugin\u0026gt; \u0026lt;extension point=\u0026#34;org.eclipse.ui.commands\u0026#34;\u0026gt; \u0026lt;command name=\u0026#34;Reference Command\u0026#34; id=\u0026#34;top.itart.plugin.smartboot.referenceCommand\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;command name=\u0026#34;Sub1 Command\u0026#34; id=\u0026#34;top.itart.plugin.smartboot.sub1Command\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;command name=\u0026#34;Sub2 Command\u0026#34; id=\u0026#34;top.itart.plugin.smartboot.sub2Command\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;/extension\u0026gt; \u0026lt;extension point=\u0026#34;org.eclipse.ui.menus\u0026#34;\u0026gt; \u0026lt;menuContribution locationURI=\u0026#34;toolbar:org.eclipse.ui.main.toolbar?after=additions\u0026#34;\u0026gt; \u0026lt;toolbar id=\u0026#34;top.itart.plugin.smartboot.toolbars\u0026#34;\u0026gt; \u0026lt;command commandId=\u0026#34;top.itart.plugin.smartboot.referenceCommand\u0026#34; icon=\u0026#34;icons/sample.gif\u0026#34; tooltip=\u0026#34;Pull down\u0026#34; style=\u0026#34;pulldown\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;/toolbar\u0026gt; \u0026lt;/menuContribution\u0026gt; \u0026lt;menuContribution locationURI=\u0026#34;menu:top.itart.plugin.smartboot.referenceCommand\u0026#34;\u0026gt; \u0026lt;command commandId=\u0026#34;top.itart.plugin.smartboot.sub1Command\u0026#34; icon=\u0026#34;icons/sample.gif\u0026#34; label = \u0026#34;Sub 1\u0026#34; tooltip=\u0026#34;Sub 1\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;command commandId=\u0026#34;top.itart.plugin.smartboot.sub2Command\u0026#34; icon=\u0026#34;icons/sample.gif\u0026#34; tooltip=\u0026#34;Sub2\u0026#34; label = \u0026#34;Sub 2\u0026#34;\u0026gt; \u0026lt;/command\u0026gt; \u0026lt;/menuContribution\u0026gt; \u0026lt;/extension\u0026gt; \u0026lt;/plugin\u0026gt; ","permalink":"/blogs/2015/java/eclipse/eclipse-tool-bar-menus.html","summary":"\u003cp\u003e在开发Eclipse 插件时, 想在工具栏中增加一个按钮图标是非常容易, 但是想在图标上增加子菜单就会比较麻烦, 例如想实现如下效果:\u003c/p\u003e\n\u003cp\u003e\u003cimg alt=\"01a1fe68-1da7-72da-a643-7f8b1931ae48\" loading=\"lazy\" src=\"/blogs/2015/java/eclipse/eclipse-tool-bar-menus/menus.png\"\u003e\u003c/p\u003e\n\u003cp\u003e具体步骤如下:\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e\n\u003cp\u003e首先在扩展点org.eclipse.ui.commands中增加三个指令\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-xml\" data-lang=\"xml\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026lt;extension\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \t\u003cspan style=\"color:#a6e22e\"\u003epoint=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;org.eclipse.ui.commands\u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;command\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#a6e22e\"\u003ename=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Reference Command\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#a6e22e\"\u003eid=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;top.itart.plugin.smartboot.referenceCommand\u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;/command\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;command\u003c/span\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#a6e22e\"\u003ename=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Sub1 Command\u0026#34;\u003c/span\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#a6e22e\"\u003eid=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;top.itart.plugin.smartboot.sub1Command\u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;/command\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;command\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#a6e22e\"\u003ename=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Sub2 Command\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#a6e22e\"\u003eid=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;top.itart.plugin.smartboot.sub2Command\u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;/command\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026lt;/extension\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e其次在扩展点org.eclipse.ui.menus 增加两个menuContribution\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-xml\" data-lang=\"xml\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026lt;menuContribution\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#a6e22e\"\u003elocationURI=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;toolbar:org.eclipse.ui.main.toolbar?after=additions\u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;toolbar\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t   \u003cspan style=\"color:#a6e22e\"\u003eid=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;top.itart.plugin.smartboot.toolbars\u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;command\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t      \u003cspan style=\"color:#a6e22e\"\u003ecommandId=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;top.itart.plugin.smartboot.referenceCommand\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t      \u003cspan style=\"color:#a6e22e\"\u003eicon=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;icons/sample.gif\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t      \u003cspan style=\"color:#a6e22e\"\u003etooltip=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Pull down\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003estyle=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;pulldown\u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;/command\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#f92672\"\u003e\u0026lt;/toolbar\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003e\u0026lt;/menuContribution\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e这个是定义显示在toolbar上的菜单. Command 中的commandId 为第一个指令的ID, 类型 type 为pulldown, 并且放在toolbar标签中\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003e\u0026lt;menuContribution\n\tlocationURI=\u0026#34;menu:top.itart.plugin.smartboot.referenceCommand\u0026#34;\u0026gt;\n\t\u0026lt;command\n\t          commandId=\u0026#34;top.itart.plugin.smartboot.sub1Command\u0026#34;\n\t          icon=\u0026#34;icons/sample.gif\u0026#34;\n\t          label = \u0026#34;Sub 1\u0026#34;\n\t          tooltip=\u0026#34;Sub 1\u0026#34;\u0026gt;\n\t\u0026lt;/command\u0026gt;\n\t\u0026lt;command\n\t\tcommandId=\u0026#34;top.itart.plugin.smartboot.sub2Command\u0026#34;\n\t\ticon=\u0026#34;icons/sample.gif\u0026#34;\n\t\ttooltip=\u0026#34;Sub2\u0026#34;\n\t\tlabel = \u0026#34;Sub 2\u0026#34;\u0026gt;\n\t\u0026lt;/command\u0026gt;\n\u0026lt;/menuContribution\u0026gt;\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003e这个menuContribution是定义下拉的子菜单. 注意locationURI的值是menu: \u0026lt;Toolbar上的菜单ID\u0026gt;\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ol\u003e","title":"Eclipse 插件开发 - 工具栏(tool bar)增加下来菜单"},{"content":"在插件开发时, 点击工程右键\u0026gt; Run As \u0026gt; Eclipse Application\n出现内存溢出\n2015-12-20 14:01:22 com.genuitec.pulse.client.deliverypackage.runtime.internal.Activator initializeLoggers 信息: Package starting up at Sun Dec 20 14:01:22 CST 2015 java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: PermGen space 分析\n是因为java默认分配的内存过小, 只需要加大内存即可, 步骤如下:\nRun As \u0026gt; Run Configurations. 修改内存参数：-Xms512m -Xmx1024m -XX:PermSize=256M -XX:MaxPermSize=1024M ","permalink":"/blogs/2015/java/eclipse/eclipse-out-of-memory.html","summary":"\u003cp\u003e在插件开发时, 点击工程右键\u0026gt; Run As \u0026gt; Eclipse Application\u003c/p\u003e\n\u003cp\u003e\u003cimg alt=\"01a1fe68-1d95-74be-8716-d8256eff82ce\" loading=\"lazy\" src=\"/blogs/2015/java/eclipse/eclipse-out-of-memory/2021_10_07_16_31_45_out-of-memory.png\"\u003e\u003c/p\u003e\n\u003cp\u003e出现内存溢出\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003e2015-12-20 14:01:22 com.genuitec.pulse.client.deliverypackage.runtime.internal.Activator initializeLoggers\n信息: Package starting up at Sun Dec 20 14:01:22 CST 2015\njava.lang.OutOfMemoryError: PermGen space\njava.lang.OutOfMemoryError: PermGen space\njava.lang.OutOfMemoryError: PermGen space\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003e分析\u003c/p\u003e\n\u003cp\u003e是因为java默认分配的内存过小, 只需要加大内存即可, 步骤如下:\u003c/p\u003e","title":"Eclipse 插件开发- 运行内存溢出"},{"content":"关于Json与Java对象转化的组件除了Json-lib(http://json-lib.sourceforge.net/), 还有一个是Jackson(https://github.com/FasterXML/jackson), 使用Jackson可以很方便的处理Json和java对象之间的转换, 使用方法:\n在工程中引入Jackson对应的Jar包.\n\u0026lt;dependency\u0026gt; \u0026lt;groupId\u0026gt;com.fasterxml.jackson.core\u0026lt;/groupId\u0026gt; \u0026lt;artifactId\u0026gt;jackson-core\u0026lt;/artifactId\u0026gt; \u0026lt;version\u0026gt;2.5.3\u0026lt;/version\u0026gt; \u0026lt;/dependency\u0026gt; \u0026lt;dependency\u0026gt; \u0026lt;groupId\u0026gt;com.fasterxml.jackson.core\u0026lt;/groupId\u0026gt; \u0026lt;artifactId\u0026gt;jackson-annotations\u0026lt;/artifactId\u0026gt; \u0026lt;version\u0026gt;2.5.3\u0026lt;/version\u0026gt; \u0026lt;/dependency\u0026gt; \u0026lt;dependency\u0026gt; \u0026lt;groupId\u0026gt;com.fasterxml.jackson.core\u0026lt;/groupId\u0026gt; \u0026lt;artifactId\u0026gt;jackson-databind\u0026lt;/artifactId\u0026gt; \u0026lt;version\u0026gt;2.5.3\u0026lt;/version\u0026gt; \u0026lt;/dependency\u0026gt; Json字符串转换为Java对象\nUser.java\npackage top.itart.demo; public class User { private String userName; private int age; public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } JsonTest.java\npackage top.itart.demo; import java.io.IOException; import org.codehaus.jackson.JsonParseException; import org.codehaus.jackson.map.JsonMappingException; import org.codehaus.jackson.map.ObjectMapper; public class JsonTest { public static void main(String[] args) throws JsonParseException, JsonMappingException, IOException { String userJson = \u0026#34;{ \\\u0026#34;userName\\\u0026#34; : \\\u0026#34;IT Art\\\u0026#34;, \\\u0026#34;age\\\u0026#34; : 100 }\u0026#34;; User user = new ObjectMapper().readValue(userJson, User.class); System.out.println(\u0026#34;user name = \u0026#34;+user.getUserName() +\u0026#34;, age = \u0026#34;+user.getAge()); } } 参考文档:http://tutorials.jenkov.com/java-json/jackson-objectmapper.html\n","permalink":"/blogs/2015/java/jersey/jersey-json-java-convert.html","summary":"\u003cp\u003e关于Json与Java对象转化的组件除了Json-lib(\u003ca href=\"http://json-lib.sourceforge.net/\"\u003ehttp://json-lib.sourceforge.net/\u003c/a\u003e), 还有一个是Jackson(\u003ca href=\"https://github.com/FasterXML/jackson\"\u003ehttps://github.com/FasterXML/jackson\u003c/a\u003e), 使用Jackson可以很方便的处理Json和java对象之间的转换, 使用方法:\u003c/p\u003e","title":"Jersey中Json与Java对象转换处理"},{"content":"在查询包含BLOB字段的对象时可以正常查询出来,但是在调用以下代码时报异常:\n((Blob) attachment.getContent()).getBinaryStream(); 异常信息:\njava.sql.SQLException: You cannot invoke other java.sql.Clob/java.sql.Blob methods after calling the free() method or after the Blob/Clob\u0026#39;s transaction has been committed or rolled back. at org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source) at org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source) at org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source) at org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source) at org.apache.derby.impl.jdbc.EmbedConnection.newSQLException(Unknown Source) at org.apache.derby.impl.jdbc.ConnectionChild.newSQLException(Unknown Source) at org.apache.derby.impl.jdbc.EmbedBlob.checkValidity(Unknown Source) at org.apache.derby.impl.jdbc.EmbedBlob.getBinaryStream(Unknown Source) at top.itart.blog.back.service.AttachmentService.createAttachmentFile(AttachmentService.java:61) at top.itart.blog.back.service.AttachmentService$$FastClassBySpringCGLIB$$13e0b78f.invoke(\u0026lt;generated\u0026gt;) at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99) at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281) at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653) at top.itart.blog.back.service.AttachmentService$$EnhancerBySpringCGLIB$$949e7a5e.createAttachmentFile(\u0026lt;generated\u0026gt;) at top.itart.blog.back.service.AttachmentServiceTest.testSaveImage(AttachmentServiceTest.java:30) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17) at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:74) at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:85) at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:86) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:241) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:87) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61) at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70) at org.junit.runners.ParentRunner.run(ParentRunner.java:363) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:180) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197) Caused by: ERROR XJ215: You cannot invoke other java.sql.Clob/java.sql.Blob methods after calling the free() method or after the Blob/Clob\u0026#39;s transaction has been committed or rolled back. at org.apache.derby.iapi.error.StandardException.newException(Unknown Source) at org.apache.derby.impl.jdbc.SQLExceptionFactory.wrapArgsForTransportAcrossDRDA(Unknown Source) ... 51 more 原因: 读取对象和处理对象的方法分别在两个独立事务中, 当对象读取完事务已经被关闭, 这是在处理BLOB对象时就会报以上错误\n解决: 读取时不需要事务处理, 或是把读取对象和处理对象放在同一个方法中, 最好是采用第一种方法.\n","permalink":"/blogs/2015/java/mybatis/java-mybatis-spring-blob-exception.html","summary":"\u003cp\u003e在查询包含BLOB字段的对象时可以正常查询出来,但是在调用以下代码时报异常:\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003e((Blob) attachment.getContent()).getBinaryStream();\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003e异常信息:\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003ejava.sql.SQLException: You cannot invoke other java.sql.Clob/java.sql.Blob methods after calling the free() method or after the Blob/Clob\u0026#39;s transaction has been committed or rolled back.\n\tat org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.EmbedConnection.newSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.ConnectionChild.newSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.EmbedBlob.checkValidity(Unknown Source)\n\tat org.apache.derby.impl.jdbc.EmbedBlob.getBinaryStream(Unknown Source)\n\tat top.itart.blog.back.service.AttachmentService.createAttachmentFile(AttachmentService.java:61)\n\tat top.itart.blog.back.service.AttachmentService$$FastClassBySpringCGLIB$$13e0b78f.invoke(\u0026lt;generated\u0026gt;)\n\tat org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)\n\tat org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717)\n\tat org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)\n\tat org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)\n\tat org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)\n\tat org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)\n\tat org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)\n\tat org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)\n\tat org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)\n\tat org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)\n\tat top.itart.blog.back.service.AttachmentService$$EnhancerBySpringCGLIB$$949e7a5e.createAttachmentFile(\u0026lt;generated\u0026gt;)\n\tat top.itart.blog.back.service.AttachmentServiceTest.testSaveImage(AttachmentServiceTest.java:30)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:601)\n\tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\n\tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\n\tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)\n\tat org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)\n\tat org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:74)\n\tat org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:85)\n\tat org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:86)\n\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\n\tat org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:241)\n\tat org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:87)\n\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\n\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\n\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\n\tat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\n\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\n\tat org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)\n\tat org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)\n\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\n\tat org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:180)\n\tat org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)\n\tat org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)\n\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)\n\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)\n\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)\n\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)\nCaused by: ERROR XJ215: You cannot invoke other java.sql.Clob/java.sql.Blob methods after calling the free() method or after the Blob/Clob\u0026#39;s transaction has been committed or rolled back.\n\tat org.apache.derby.iapi.error.StandardException.newException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.SQLExceptionFactory.wrapArgsForTransportAcrossDRDA(Unknown Source)\n\t... 51 more\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003e原因:  读取对象和处理对象的方法分别在两个独立事务中, 当对象读取完事务已经被关闭, 这是在处理BLOB对象时就会报以上错误\u003c/p\u003e","title":"Java+mybatis+spring中读取BLOB类型异常"},{"content":"Java的接口在声明属性时会发现一个很奇怪的现象, 可能大家在很多地方都会看到这样的描述: 接口类中的只能有静态的并且为final的属性, 但是在实际写代码中你会发现, 可以在接口中声明一个不是静态的属性, 并且不会报错, 如下:\nTestInterface.java\npackage top.itart; public interface TestInterface { public String property = \u0026#34;IT is an art\u0026#34;; } 但是, 实际上Java默认会把这个属性当成静态的, 不需要显示声明, 可以测试一下:\nTest.java\npackage top.itart; import java.lang.reflect.Field; import top.itart.TestInterface; public class Test implements TestInterface { public static void main(String[] args) throws NoSuchFieldException, SecurityException { Field field = Test.class.getField(\u0026#34;property\u0026#34;); System.out.println(field); } } 会输出:\npublic static final java.lang.String TestInterface.property ","permalink":"/blogs/2015/java/java-interfact-static-propery.html","summary":"\u003cp\u003eJava的接口在声明属性时会发现一个很奇怪的现象, 可能大家在很多地方都会看到这样的描述: 接口类中的只能有静态的并且为final的属性, 但是在实际写代码中你会发现, 可以在接口中声明一个不是静态的属性, 并且不会报错, 如下:\u003c/p\u003e","title":"Java接口类只能声明静态属性"},{"content":"不同的月可能有不同的天数, 有的是30天, 有的是31天, 对于二月的天数判断还得先判断是平年还是闰年, 所以如果自己写代码判断会比较麻烦, 其实java.util.Calendar中已经提供了获取天数的方法, 代码如下:\nDateUtil.java\npackage top.itart; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; public class DateUtil { public static int getDaysOfMonth(Date date) { Calendar calendar = Calendar.getInstance(); calendar.setTime(date); return calendar.getActualMaximum(Calendar.DAY_OF_MONTH); } public static void main(String[] args) throws ParseException { SimpleDateFormat sdf = new SimpleDateFormat(\u0026#34;yyyy-MM-dd\u0026#34;); System.out.println(getDaysOfMonth(sdf.parse(\u0026#34;2015-02-2\u0026#34;))); } } ","permalink":"/blogs/2015/java/java-month-days.html","summary":"\u003cp\u003e不同的月可能有不同的天数, 有的是30天, 有的是31天, 对于二月的天数判断还得先判断是平年还是闰年, 所以如果自己写代码判断会比较麻烦, 其实java.util.Calendar中已经提供了获取天数的方法, 代码如下:\u003c/p\u003e","title":"Java获取某个月的天数"},{"content":"Java中获取当前季度的时间范围, 上个季度的时间范围, 昨天的时间范围, 当前月的时间范围, 上个月的时间范围:\nDateUtils.java\npackage top.itart.blog.common.util; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import top.itart.blog.common.bean.DateRange; public class DateUtils{ /** * 获取date的月份的时间范围 * @param date * @return */ public static DateRange getMonthRange(Date date) { Calendar startCalendar = Calendar.getInstance(); startCalendar.setTime(date); startCalendar.set(Calendar.DAY_OF_MONTH, 1); setMaxTime(startCalendar); Calendar endCalendar = Calendar.getInstance(); endCalendar.setTime(date); endCalendar.set(Calendar.DAY_OF_MONTH, endCalendar.getActualMaximum(Calendar.DAY_OF_MONTH)); setMaxTime(endCalendar); return new DateRange(startCalendar.getTime(), endCalendar.getTime()); } /** * 获取当前季度的时间范围 * @return current quarter */ public static DateRange getThisQuarter() { Calendar startCalendar = Calendar.getInstance(); startCalendar.set(Calendar.MONTH, ((int) startCalendar.get(Calendar.MONTH) / 3) * 3); startCalendar.set(Calendar.DAY_OF_MONTH, 1); setMinTime(startCalendar); Calendar endCalendar = Calendar.getInstance(); endCalendar.set(Calendar.MONTH, ((int) startCalendar.get(Calendar.MONTH) / 3) * 3 + 2); endCalendar.set(Calendar.DAY_OF_MONTH, endCalendar.getActualMaximum(Calendar.DAY_OF_MONTH)); setMaxTime(endCalendar); return new DateRange(startCalendar.getTime(), endCalendar.getTime()); } /** * 获取昨天的时间范围 * @return */ public static DateRange getYesterdayRange() { Calendar startCalendar = Calendar.getInstance(); startCalendar.add(Calendar.DAY_OF_MONTH, -1); setMinTime(startCalendar); Calendar endCalendar = Calendar.getInstance(); endCalendar.add(Calendar.DAY_OF_MONTH, -1); setMaxTime(endCalendar); return new DateRange(startCalendar.getTime(), endCalendar.getTime()); } /** * 获取当前月份的时间范围 * @return */ public static DateRange getThisMonth(){ Calendar startCalendar = Calendar.getInstance(); startCalendar.set(Calendar.DAY_OF_MONTH, 1); setMinTime(startCalendar); Calendar endCalendar = Calendar.getInstance(); endCalendar.set(Calendar.DAY_OF_MONTH, endCalendar.getActualMaximum(Calendar.DAY_OF_MONTH)); setMaxTime(endCalendar); return new DateRange(startCalendar.getTime(), endCalendar.getTime()); } /** * 获取上个月的时间范围 * @return */ public static DateRange getLastMonth(){ Calendar startCalendar = Calendar.getInstance(); startCalendar.add(Calendar.MONTH, -1); startCalendar.set(Calendar.DAY_OF_MONTH, 1); setMinTime(startCalendar); Calendar endCalendar = Calendar.getInstance(); endCalendar.add(Calendar.MONTH, -1); endCalendar.set(Calendar.DAY_OF_MONTH, endCalendar.getActualMaximum(Calendar.DAY_OF_MONTH)); setMaxTime(endCalendar); return new DateRange(startCalendar.getTime(), endCalendar.getTime()); } /** * 获取上个季度的时间范围 * @return */ public static DateRange getLastQuarter() { Calendar startCalendar = Calendar.getInstance(); startCalendar.set(Calendar.MONTH, ((int) startCalendar.get(Calendar.MONTH) / 3 - 1) * 3); startCalendar.set(Calendar.DAY_OF_MONTH, 1); setMinTime(startCalendar); Calendar endCalendar = Calendar.getInstance(); endCalendar.set(Calendar.MONTH, ((int) endCalendar.get(Calendar.MONTH) / 3 - 1) * 3 + 2); endCalendar.set(Calendar.DAY_OF_MONTH, endCalendar.getActualMaximum(Calendar.DAY_OF_MONTH)); setMaxTime(endCalendar); return new DateRange(startCalendar.getTime(), endCalendar.getTime()); } private static void setMinTime(Calendar calendar){ calendar.set(Calendar.HOUR_OF_DAY, 0); calendar.set(Calendar.MINUTE, 0); calendar.set(Calendar.SECOND, 0); calendar.set(Calendar.MILLISECOND, 0); } private static void setMaxTime(Calendar calendar){ calendar.set(Calendar.HOUR_OF_DAY, calendar.getActualMaximum(Calendar.HOUR_OF_DAY)); calendar.set(Calendar.MINUTE, calendar.getActualMaximum(Calendar.MINUTE)); calendar.set(Calendar.SECOND, calendar.getActualMaximum(Calendar.SECOND)); calendar.set(Calendar.MILLISECOND, calendar.getActualMaximum(Calendar.MILLISECOND)); } public final static String DEFAULT_PATTERN = \u0026#34;MM/dd/yyyy HH:mm:ss\u0026#34;; public static String format(Date date){ SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_PATTERN); return sdf.format(date); } public static void main(String[] args) { DateRange currentQuarter = getThisQuarter(); System.out.println(\u0026#34;当前季度的时间范围： \u0026#34;+DateUtilsTemp.format(currentQuarter.getStart())+\u0026#34; - \u0026#34;+DateUtilsTemp.format(currentQuarter.getEnd())); DateRange yesterdayRange = getYesterdayRange(); System.out.println(\u0026#34;昨天的时间范围: \u0026#34;+DateUtilsTemp.format(yesterdayRange.getStart())+\u0026#34; - \u0026#34;+DateUtilsTemp.format(yesterdayRange.getEnd())); DateRange thisMonth = getThisMonth(); System.out.println(\u0026#34;当前月份的时间范围: \u0026#34;+DateUtilsTemp.format(thisMonth.getStart())+\u0026#34; - \u0026#34;+DateUtilsTemp.format(thisMonth.getEnd())); DateRange lastMonth = getLastMonth(); System.out.println(\u0026#34;上个月的时间范围: \u0026#34;+DateUtilsTemp.format(lastMonth.getStart())+\u0026#34; - \u0026#34;+DateUtilsTemp.format(lastMonth.getEnd())); DateRange lastQuarter = getLastQuarter(); System.out.println(\u0026#34;上个季度的时间范围: \u0026#34;+DateUtilsTemp.format(lastQuarter.getStart())+\u0026#34; - \u0026#34;+DateUtilsTemp.format(lastQuarter.getEnd())); } } DateRange.java\npackage top.itart.blog.common.bean; import java.util.Date; public class DateRange { private Date start; private Date end; public DateRange(Date start, Date end) { this.start = start; this.end = end; } public Date getStart() { return start; } public void setStart(Date start) { this.start = start; } public Date getEnd() { return end; } public void setEnd(Date end) { this.end = end; } } 如果当前时间是: 2015/09/06, 则运行结果如下:\n当前季度的时间范围： 07/01/2015 00:00:00 - 09/30/2015 23:59:59 昨天的时间范围: 09/05/2015 00:00:00 - 09/05/2015 23:59:59 当前月份的时间范围: 09/01/2015 00:00:00 - 09/30/2015 23:59:59 上个月的时间范围: 08/01/2015 00:00:00 - 08/31/2015 23:59:59 上个季度的时间范围: 04/01/2015 00:00:00 - 06/30/2015 23:59:59 ","permalink":"/blogs/2015/java/java-time-utils.html","summary":"\u003cp\u003eJava中获取当前季度的时间范围, 上个季度的时间范围, 昨天的时间范围, 当前月的时间范围, 上个月的时间范围:\u003c/p\u003e\n\u003cp\u003eDateUtils.java\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-java\" data-lang=\"java\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003epackage\u003c/span\u003e top.itart.blog.common.util;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.text.SimpleDateFormat;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.util.Calendar;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.util.Date;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e top.itart.blog.common.bean.DateRange;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003eclass\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eDateUtils\u003c/span\u003e{\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#75715e\"\u003e/**\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * 获取date的月份的时间范围\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * @param date\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * @return\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t */\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e DateRange \u003cspan style=\"color:#a6e22e\"\u003egetMonthRange\u003c/span\u003e(Date date) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar startCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003esetTime\u003c/span\u003e(date);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, 1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMaxTime(startCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar endCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003esetTime\u003c/span\u003e(date);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMaxTime(endCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e DateRange(startCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e(), endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e());\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#75715e\"\u003e/**\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * 获取当前季度的时间范围\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * @return current quarter\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t */\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e DateRange \u003cspan style=\"color:#a6e22e\"\u003egetThisQuarter\u003c/span\u003e() {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar startCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e, ((\u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e) startCalendar.\u003cspan style=\"color:#a6e22e\"\u003eget\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e) \u003cspan style=\"color:#f92672\"\u003e/\u003c/span\u003e 3) \u003cspan style=\"color:#f92672\"\u003e*\u003c/span\u003e 3);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, 1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMinTime(startCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar endCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e, ((\u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e) startCalendar.\u003cspan style=\"color:#a6e22e\"\u003eget\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e) \u003cspan style=\"color:#f92672\"\u003e/\u003c/span\u003e 3) \u003cspan style=\"color:#f92672\"\u003e*\u003c/span\u003e 3 \u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003e 2);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMaxTime(endCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e DateRange(startCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e(), endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e());\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#75715e\"\u003e/**\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * 获取昨天的时间范围\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * @return\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t */\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e DateRange \u003cspan style=\"color:#a6e22e\"\u003egetYesterdayRange\u003c/span\u003e() {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t Calendar startCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t startCalendar.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, \u003cspan style=\"color:#f92672\"\u003e-\u003c/span\u003e1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t setMinTime(startCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t Calendar endCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t endCalendar.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, \u003cspan style=\"color:#f92672\"\u003e-\u003c/span\u003e1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t setMaxTime(endCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e DateRange(startCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e(), endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e());\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#75715e\"\u003e/**\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * 获取当前月份的时间范围\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * @return\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t */\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e DateRange \u003cspan style=\"color:#a6e22e\"\u003egetThisMonth\u003c/span\u003e(){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar startCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, 1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMinTime(startCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar endCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMaxTime(endCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e DateRange(startCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e(), endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e());\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#75715e\"\u003e/**\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * 获取上个月的时间范围\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * @return\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t */\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e DateRange \u003cspan style=\"color:#a6e22e\"\u003egetLastMonth\u003c/span\u003e(){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar startCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e, \u003cspan style=\"color:#f92672\"\u003e-\u003c/span\u003e1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, 1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMinTime(startCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar endCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e, \u003cspan style=\"color:#f92672\"\u003e-\u003c/span\u003e1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMaxTime(endCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e DateRange(startCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e(), endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e());\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#75715e\"\u003e/**\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * 获取上个季度的时间范围\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t * @return\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\t */\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e DateRange \u003cspan style=\"color:#a6e22e\"\u003egetLastQuarter\u003c/span\u003e() {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar startCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e, ((\u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e) startCalendar.\u003cspan style=\"color:#a6e22e\"\u003eget\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e) \u003cspan style=\"color:#f92672\"\u003e/\u003c/span\u003e 3 \u003cspan style=\"color:#f92672\"\u003e-\u003c/span\u003e 1) \u003cspan style=\"color:#f92672\"\u003e*\u003c/span\u003e 3);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tstartCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, 1);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMinTime(startCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tCalendar endCalendar \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e Calendar.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e, ((\u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e) endCalendar.\u003cspan style=\"color:#a6e22e\"\u003eget\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMONTH\u003c/span\u003e) \u003cspan style=\"color:#f92672\"\u003e/\u003c/span\u003e 3 \u003cspan style=\"color:#f92672\"\u003e-\u003c/span\u003e 1) \u003cspan style=\"color:#f92672\"\u003e*\u003c/span\u003e 3 \u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003e 2);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tendCalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e, endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eDAY_OF_MONTH\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tsetMaxTime(endCalendar);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e DateRange(startCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e(), endCalendar.\u003cspan style=\"color:#a6e22e\"\u003egetTime\u003c/span\u003e());\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003eprivate\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003evoid\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003esetMinTime\u003c/span\u003e(Calendar calendar){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tcalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eHOUR_OF_DAY\u003c/span\u003e, 0);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tcalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMINUTE\u003c/span\u003e, 0);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tcalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eSECOND\u003c/span\u003e, 0);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tcalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMILLISECOND\u003c/span\u003e, 0);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003eprivate\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003evoid\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003esetMaxTime\u003c/span\u003e(Calendar calendar){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tcalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eHOUR_OF_DAY\u003c/span\u003e, calendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eHOUR_OF_DAY\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tcalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMINUTE\u003c/span\u003e, calendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMINUTE\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tcalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eSECOND\u003c/span\u003e, calendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eSECOND\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tcalendar.\u003cspan style=\"color:#a6e22e\"\u003eset\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMILLISECOND\u003c/span\u003e, calendar.\u003cspan style=\"color:#a6e22e\"\u003egetActualMaximum\u003c/span\u003e(Calendar.\u003cspan style=\"color:#a6e22e\"\u003eMILLISECOND\u003c/span\u003e));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003efinal\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e String DEFAULT_PATTERN \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;MM/dd/yyyy HH:mm:ss\u0026#34;\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e String \u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(Date date){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        SimpleDateFormat sdf \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e SimpleDateFormat(DEFAULT_PATTERN);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e sdf.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(date);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003evoid\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003emain\u003c/span\u003e(String\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e args) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tDateRange currentQuarter \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e getThisQuarter();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tSystem.\u003cspan style=\"color:#a6e22e\"\u003eout\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eprintln\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;当前季度的时间范围： \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(currentQuarter.\u003cspan style=\"color:#a6e22e\"\u003egetStart\u003c/span\u003e())\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34; - \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(currentQuarter.\u003cspan style=\"color:#a6e22e\"\u003egetEnd\u003c/span\u003e()));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tDateRange yesterdayRange \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e getYesterdayRange();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tSystem.\u003cspan style=\"color:#a6e22e\"\u003eout\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eprintln\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;昨天的时间范围: \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(yesterdayRange.\u003cspan style=\"color:#a6e22e\"\u003egetStart\u003c/span\u003e())\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34; - \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(yesterdayRange.\u003cspan style=\"color:#a6e22e\"\u003egetEnd\u003c/span\u003e()));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tDateRange thisMonth \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e getThisMonth();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tSystem.\u003cspan style=\"color:#a6e22e\"\u003eout\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eprintln\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;当前月份的时间范围: \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(thisMonth.\u003cspan style=\"color:#a6e22e\"\u003egetStart\u003c/span\u003e())\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34; - \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(thisMonth.\u003cspan style=\"color:#a6e22e\"\u003egetEnd\u003c/span\u003e()));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tDateRange lastMonth \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e getLastMonth();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tSystem.\u003cspan style=\"color:#a6e22e\"\u003eout\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eprintln\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;上个月的时间范围: \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(lastMonth.\u003cspan style=\"color:#a6e22e\"\u003egetStart\u003c/span\u003e())\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34; - \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(lastMonth.\u003cspan style=\"color:#a6e22e\"\u003egetEnd\u003c/span\u003e()));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tDateRange lastQuarter \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e getLastQuarter();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\tSystem.\u003cspan style=\"color:#a6e22e\"\u003eout\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eprintln\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;上个季度的时间范围: \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(lastQuarter.\u003cspan style=\"color:#a6e22e\"\u003egetStart\u003c/span\u003e())\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34; - \u0026#34;\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e+\u003c/span\u003eDateUtilsTemp.\u003cspan style=\"color:#a6e22e\"\u003eformat\u003c/span\u003e(lastQuarter.\u003cspan style=\"color:#a6e22e\"\u003egetEnd\u003c/span\u003e()));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t}\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003eDateRange.java\u003c/p\u003e","title":"Java获取时间范围-当前季度,上个季度,昨天,当前月,上个月"},{"content":"问题:\nJersey在接收客户端提交的json数据时提示400 (Bad Request), 服务端没有任何提示.\n场景:\n客户端\nURL:\nPOST http://127.0.0.1:8080/itart-blog/api/blog/ 400 (Bad Request) json:\n{id:\u0026#34;c4089f719e7c2d25af80756be6421ca9\u0026#34;, blogTitle: \u0026#39;IT Art Test\u0026#39;, blogContent:\u0026#34;Test Content\u0026#34;, \u0026#34;category\u0026#34;: \u0026#34;Blog Category\u0026#34;} 注意: “category”: “Blog Category”\n服务端:\nBlogResource.java\n@Component @Path(\u0026#34;blog\u0026#34;) public class BlogResource{ @POST @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public Response insert(BlogBean blog) throws IOException { ResponseBuilder reponse = Response.ok(); return reponse.build(); } } public class BlogBean{ private String blogTitle; private String blogContent; private String id; ... 分析: 客户端提交的Json中有一个字段:”category”, BlogBean中不存在这个属性名. Jersey要求Json字段必须和后台接收对象的属性完全匹配, Json的字段个数可以少于后台对象属性个数, 但是不能多于, 如果Json有字段在后台对象属性中找不到, 就会报400 (Bad Request)\n解决方案: 在BlogBean中增加@JsonIgnoreProperties(ignoreUnknown = true).\nimport com.fasterxml.jackson.annotation.JsonIgnoreProperties; @JsonIgnoreProperties(ignoreUnknown = true) public class BlogBean{ private String blogTitle; private String blogContent; private String id; ... ","permalink":"/blogs/2015/java/jersey/jersey-json-400.html","summary":"\u003cp\u003e问题:\u003c/p\u003e\n\u003cp\u003eJersey在接收客户端提交的json数据时提示\u003cstrong\u003e400 (Bad Request)\u003c/strong\u003e, 服务端没有任何提示.\u003c/p\u003e\n\u003cp\u003e\u003cimg alt=\"01a1fe68-1d4e-7497-b2d2-5bfc1684efdd\" loading=\"lazy\" src=\"/blogs/2015/java/jersey/jersey-json-400/2021_10_07_16_28_53_error.png\"\u003e\u003c/p\u003e\n\u003cp\u003e场景:\u003c/p\u003e\n\u003cp\u003e客户端\u003c/p\u003e\n\u003cp\u003eURL:\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003ePOST http://127.0.0.1:8080/itart-blog/api/blog/ 400 (Bad Request)\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003ejson:\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003e{id:\u0026#34;c4089f719e7c2d25af80756be6421ca9\u0026#34;, blogTitle: \u0026#39;IT Art Test\u0026#39;, blogContent:\u0026#34;Test Content\u0026#34;, \u0026#34;category\u0026#34;: \u0026#34;Blog Category\u0026#34;}\n\u003c/code\u003e\u003c/pre\u003e\u003cp\u003e\u003cstrong\u003e注意: “category”: “Blog Category”\u003c/strong\u003e\u003c/p\u003e","title":"Jersey接收Json报400(Bad Request)"},{"content":"项目中有的时候需要生成一个这样的PDF表格:\nPDFTest.java\npackage com.ehi.rc.util.export; import java.awt.Color; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import com.lowagie.text.Chunk; import com.lowagie.text.Document; import com.lowagie.text.DocumentException; import com.lowagie.text.Font; import com.lowagie.text.FontFactory; import com.lowagie.text.PageSize; import com.lowagie.text.Phrase; import com.lowagie.text.pdf.PdfPTable; import com.lowagie.text.pdf.PdfWriter; public class PDFTest { Font boldFont = FontFactory .getFont(FontFactory.HELVETICA, 10, Font.BOLD, Color.BLACK); Font normalFont = FontFactory .getFont(FontFactory.HELVETICA, 10, Font.NORMAL, Color.RED); public byte[] generatePDF() { // init Document doc = new Document(PageSize.A4.rotate(), 10f, 10f, 10f, 10f); ByteArrayOutputStream output = new ByteArrayOutputStream(); try { PdfWriter.getInstance(doc, output); doc.open(); // create pdf table PdfPTable pdftable = new PdfPTable(2); Phrase phrase = new Phrase(); phrase.add(new Chunk(\u0026#34;Blod red Font\u0026#34;, boldFont)); phrase.add(\u0026#34; : \u0026#34;); phrase.add(new Chunk(\u0026#34;Normal blank Font\u0026#34;, normalFont)); pdftable.addCell(phrase); pdftable.addCell(\u0026#34;Another cell\u0026#34;); phrase = new Phrase(); phrase.add(new Chunk(\u0026#34;Blod red Font\u0026#34;, boldFont)); phrase.add(\u0026#34; : \u0026#34;); phrase.add(new Chunk(\u0026#34;Normal blank Font\u0026#34;, normalFont)); pdftable.addCell(phrase); pdftable.addCell(\u0026#34;Another cell\u0026#34;); doc.add(pdftable); } catch (DocumentException e) { throw new RuntimeException(e); } finally { if (doc.isOpen()) { doc.close(); } } return output.toByteArray(); } public static void main(String[] args) throws IOException { File file = new File(\u0026#34;D://test.pdf\u0026#34;); FileOutputStream out = new FileOutputStream(file); out.write(new PDFTest().generatePDF()); } } ","permalink":"/blogs/2015/java/itext/itext-pdf-table-style.html","summary":"\u003cp\u003e项目中有的时候需要生成一个这样的PDF表格:\u003c/p\u003e\n\u003cp\u003e\u003cimg alt=\"01a1fe68-1d3f-7728-8532-fcf9a37ad5f2\" loading=\"lazy\" src=\"/blogs/2015/java/itext/itext-pdf-table-style/example.png\"\u003e\u003c/p\u003e\n\u003cp\u003ePDFTest.java\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-java\" data-lang=\"java\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003epackage\u003c/span\u003e com.ehi.rc.util.export;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.awt.Color;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.io.ByteArrayOutputStream;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.io.File;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.io.FileOutputStream;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.io.IOException;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.Chunk;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.Document;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.DocumentException;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.Font;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.FontFactory;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.PageSize;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.Phrase;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.pdf.PdfPTable;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e com.lowagie.text.pdf.PdfWriter;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003eclass\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003ePDFTest\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    Font boldFont \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e FontFactory\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            .\u003cspan style=\"color:#a6e22e\"\u003egetFont\u003c/span\u003e(FontFactory.\u003cspan style=\"color:#a6e22e\"\u003eHELVETICA\u003c/span\u003e, 10, Font.\u003cspan style=\"color:#a6e22e\"\u003eBOLD\u003c/span\u003e, Color.\u003cspan style=\"color:#a6e22e\"\u003eBLACK\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    Font normalFont \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e FontFactory\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            .\u003cspan style=\"color:#a6e22e\"\u003egetFont\u003c/span\u003e(FontFactory.\u003cspan style=\"color:#a6e22e\"\u003eHELVETICA\u003c/span\u003e, 10, Font.\u003cspan style=\"color:#a6e22e\"\u003eNORMAL\u003c/span\u003e, Color.\u003cspan style=\"color:#a6e22e\"\u003eRED\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003ebyte\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003egeneratePDF\u003c/span\u003e() {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#75715e\"\u003e// init\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        Document doc \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e Document(PageSize.\u003cspan style=\"color:#a6e22e\"\u003eA4\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003erotate\u003c/span\u003e(), 10f, 10f, 10f, 10f);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        ByteArrayOutputStream output \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e ByteArrayOutputStream();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003etry\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            PdfWriter.\u003cspan style=\"color:#a6e22e\"\u003egetInstance\u003c/span\u003e(doc, output);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            doc.\u003cspan style=\"color:#a6e22e\"\u003eopen\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#75715e\"\u003e// create pdf table\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            PdfPTable pdftable \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e PdfPTable(2);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            Phrase phrase \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e Phrase();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            phrase.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e Chunk(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Blod red Font\u0026#34;\u003c/span\u003e, boldFont));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            phrase.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34; : \u0026#34;\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            phrase.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e Chunk(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Normal blank Font\u0026#34;\u003c/span\u003e, normalFont));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e           \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            pdftable.\u003cspan style=\"color:#a6e22e\"\u003eaddCell\u003c/span\u003e(phrase);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            pdftable.\u003cspan style=\"color:#a6e22e\"\u003eaddCell\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Another cell\u0026#34;\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            phrase \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e Phrase();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            phrase.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e Chunk(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Blod red Font\u0026#34;\u003c/span\u003e, boldFont));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            phrase.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34; : \u0026#34;\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            phrase.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e Chunk(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Normal blank Font\u0026#34;\u003c/span\u003e, normalFont));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e           \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            pdftable.\u003cspan style=\"color:#a6e22e\"\u003eaddCell\u003c/span\u003e(phrase);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            pdftable.\u003cspan style=\"color:#a6e22e\"\u003eaddCell\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Another cell\u0026#34;\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            doc.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(pdftable);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        } \u003cspan style=\"color:#66d9ef\"\u003ecatch\u003c/span\u003e (DocumentException e) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#66d9ef\"\u003ethrow\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e RuntimeException(e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        } \u003cspan style=\"color:#66d9ef\"\u003efinally\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#66d9ef\"\u003eif\u003c/span\u003e (doc.\u003cspan style=\"color:#a6e22e\"\u003eisOpen\u003c/span\u003e()) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                doc.\u003cspan style=\"color:#a6e22e\"\u003eclose\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e output.\u003cspan style=\"color:#a6e22e\"\u003etoByteArray\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003evoid\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003emain\u003c/span\u003e(String\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e args) \u003cspan style=\"color:#66d9ef\"\u003ethrows\u003c/span\u003e IOException {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        File file \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e File(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;D://test.pdf\u0026#34;\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        FileOutputStream out \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e FileOutputStream(file);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        out.\u003cspan style=\"color:#a6e22e\"\u003ewrite\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e PDFTest().\u003cspan style=\"color:#a6e22e\"\u003egeneratePDF\u003c/span\u003e());\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e","title":"iText生成一个单元格中包含不同的样式的PDF表格"},{"content":"javascript中经常会使用到回调函数, 并且为了保证代码结构清晰整洁, 会将回调后需要执行的逻辑另外定义一个函数来执行, 例如:\n\u0026lt;!DOCTYPE html PUBLIC \u0026#34;-//W3C//DTD HTML 4.01 Transitional//EN\u0026#34; \u0026#34;http://www.w3.org/TR/html4/loose.dtd\u0026#34;\u0026gt; \u0026lt;html\u0026gt; \u0026lt;head\u0026gt; \u0026lt;meta http-equiv=\u0026#34;Content-Type\u0026#34; content=\u0026#34;text/html; charset=UTF-8\u0026#34;\u0026gt; \u0026lt;title\u0026gt;IT Art\u0026lt;/title\u0026gt; \u0026lt;/head\u0026gt; \u0026lt;body\u0026gt; \u0026lt;div id=\u0026#34;timePanel\u0026#34;\u0026gt;3秒后自动隐藏\u0026lt;/div\u0026gt; \u0026lt;script type=\u0026#34;text/javascript\u0026#34;\u0026gt; setTimeout(function(){ var timePanel = document.getElementById(\u0026#34;timePanel\u0026#34;); timePanel.style.display = \u0026#39;None\u0026#39;; }, 3000); \u0026lt;/script\u0026gt; \u0026lt;/body\u0026gt; \u0026lt;/html\u0026gt; 可以看到, 如果setTimeout 中直接使用匿名回调时, 当有很多的逻辑判断代码时, 会导致代码嵌套过多, 不容易阅读和维护, 所以我们经常这么做:\n\u0026lt;!DOCTYPE html PUBLIC \u0026#34;-//W3C//DTD HTML 4.01 Transitional//EN\u0026#34; \u0026#34;http://www.w3.org/TR/html4/loose.dtd\u0026#34;\u0026gt; \u0026lt;html\u0026gt; \u0026lt;head\u0026gt; \u0026lt;meta http-equiv=\u0026#34;Content-Type\u0026#34; content=\u0026#34;text/html; charset=UTF-8\u0026#34;\u0026gt; \u0026lt;title\u0026gt;IT Art\u0026lt;/title\u0026gt; \u0026lt;/head\u0026gt; \u0026lt;body\u0026gt; \u0026lt;div id=\u0026#34;timePanel\u0026#34;\u0026gt;3秒后自动隐藏\u0026lt;/div\u0026gt; \u0026lt;script type=\u0026#34;text/javascript\u0026#34;\u0026gt; var timeOutCallBack = function(){ var timePanel = document.getElementById(\u0026#34;timePanel\u0026#34;); timePanel.style.display = \u0026#39;None\u0026#39;; }; setTimeout(timeOutCallBack, 3000); \u0026lt;/script\u0026gt; \u0026lt;/body\u0026gt; \u0026lt;/html\u0026gt; 这里比较容易犯的一个错误就是:\nsetTimeout(timeOutCallBack, 3000);\n如果不小心的话, 很容易写成这样:\nsetTimeout(timeOutCallBack(), 3000);\n增加了一个括号, 就会导致timeOutCallBack在执行到setTimeout 这一行后就直接被运行, 不会延迟3秒.\n","permalink":"/blogs/2015/frontend/javascript/javascript-callback.html","summary":"\u003cp\u003ejavascript中经常会使用到回调函数, 并且为了保证代码结构清晰整洁, 会将回调后需要执行的逻辑另外定义一个函数来执行, 例如:\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-html\" data-lang=\"html\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e\u0026lt;!DOCTYPE html PUBLIC \u0026#34;-//W3C//DTD HTML 4.01 Transitional//EN\u0026#34; \u0026#34;http://www.w3.org/TR/html4/loose.dtd\u0026#34;\u0026gt;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;\u003cspan style=\"color:#f92672\"\u003ehtml\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;\u003cspan style=\"color:#f92672\"\u003ehead\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;\u003cspan style=\"color:#f92672\"\u003emeta\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003ehttp-equiv\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;Content-Type\u0026#34;\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003econtent\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;text/html; charset=UTF-8\u0026#34;\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;\u003cspan style=\"color:#f92672\"\u003etitle\u003c/span\u003e\u0026gt;IT Art\u0026lt;/\u003cspan style=\"color:#f92672\"\u003etitle\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;/\u003cspan style=\"color:#f92672\"\u003ehead\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;\u003cspan style=\"color:#f92672\"\u003ebody\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u0026lt;\u003cspan style=\"color:#f92672\"\u003ediv\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eid\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;timePanel\u0026#34;\u003c/span\u003e\u0026gt;3秒后自动隐藏\u0026lt;/\u003cspan style=\"color:#f92672\"\u003ediv\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u0026lt;\u003cspan style=\"color:#f92672\"\u003escript\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003etype\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;text/javascript\u0026#34;\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\u003cspan style=\"color:#a6e22e\"\u003esetTimeout\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003efunction\u003c/span\u003e(){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\t\u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003etimePanel\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e document.\u003cspan style=\"color:#a6e22e\"\u003egetElementById\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;timePanel\u0026#34;\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t\t\u003cspan style=\"color:#a6e22e\"\u003etimePanel\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003estyle\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003edisplay\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;None\u0026#39;\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\t}, \u003cspan style=\"color:#ae81ff\"\u003e3000\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\t\u0026lt;/\u003cspan style=\"color:#f92672\"\u003escript\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;/\u003cspan style=\"color:#f92672\"\u003ebody\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u0026lt;/\u003cspan style=\"color:#f92672\"\u003ehtml\u003c/span\u003e\u0026gt;\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e可以看到, 如果setTimeout 中直接使用匿名回调时, 当有很多的逻辑判断代码时, 会导致代码嵌套过多, 不容易阅读和维护, 所以我们经常这么做:\u003c/p\u003e","title":"Javascript 使用回调函数注意事项"},{"content":"JavaScript 中的 \u0026amp;\u0026amp; 和 || 除了用来判断两个布尔变量是否都true或false的作用外, 还有一些特殊用法.\n|| 可以用在当一个对象是否为空时设置默认值的情况下, 一般情况下我们是这样实现这个功能的:\nfunction xx(option){ var default =\u0026#34;init\u0026#34;; var value = default; if(option){ value = option; } alert(value); } 或\nfunction xx(option){ var default =\u0026#34;init\u0026#34;; var value = option? option:\u0026#34;init\u0026#34;; alert(value); } 现在还有一种简洁的方法:\nfunction xx(option){ var default =\u0026#34;init\u0026#34;; var value = option||\u0026#34;init\u0026#34; alert(value); } 注解: value = option||\u0026ldquo;init\u0026rdquo;\n当option为true时, 即option有值, value就等于option.\n当option为false时, 即option 为null 或undefined 时, value 为\u0026quot;init\u0026quot;\n\u0026amp;\u0026amp; 可以用在当一个对象是true, 就返回另外一个值, 只在为false时返回本身, 它的作用和 || 相反 var value = option||\u0026ldquo;init\u0026rdquo; 当option为true时, 即option有值, value就等于\u0026quot;init\u0026quot;. 当option为false时, 即option 为null 或undefined 时, value 为option\n","permalink":"/blogs/2015/frontend/javascript/javascript-improve-if.html","summary":"\u003cp\u003eJavaScript 中的 \u0026amp;\u0026amp; 和 || 除了用来判断两个布尔变量是否都true或false的作用外, 还有一些特殊用法.\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e\n\u003cp\u003e|| 可以用在当一个对象是否为空时设置默认值的情况下, 一般情况下我们是这样实现这个功能的:\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-javascript\" data-lang=\"javascript\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003efunction\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003eoption\u003c/span\u003e){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003edefault\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;init\u0026#34;\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003evalue\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003edefault\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#66d9ef\"\u003eif\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003eoption\u003c/span\u003e){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#a6e22e\"\u003evalue\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e  \u003cspan style=\"color:#a6e22e\"\u003eoption\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#a6e22e\"\u003ealert\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003evalue\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e或\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-javascript\" data-lang=\"javascript\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003efunction\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003eoption\u003c/span\u003e){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003edefault\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;init\u0026#34;\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003evalue\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eoption\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e?\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eoption\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e:\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;init\u0026#34;\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#a6e22e\"\u003ealert\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003evalue\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e现在还有一种简洁的方法:\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-javascript\" data-lang=\"javascript\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003efunction\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003exx\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003eoption\u003c/span\u003e){\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003edefault\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;init\u0026#34;\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#66d9ef\"\u003evar\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003evalue\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eoption\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e||\u003c/span\u003e\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;init\u0026#34;\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e  \u003cspan style=\"color:#a6e22e\"\u003ealert\u003c/span\u003e(\u003cspan style=\"color:#a6e22e\"\u003evalue\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e注解: value = option||\u0026ldquo;init\u0026rdquo;\u003c/p\u003e\n\u003cp\u003e当option为true时, 即option有值, value就等于option.\u003c/p\u003e\n\u003cp\u003e当option为false时, 即option 为null 或undefined 时, value 为\u0026quot;init\u0026quot;\u003c/p\u003e\n\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e\u0026amp;\u0026amp; 可以用在当一个对象是true, 就返回另外一个值, 只在为false时返回本身,  它的作用和 || 相反\nvar value = option||\u0026ldquo;init\u0026rdquo;\n当option为true时, 即option有值, value就等于\u0026quot;init\u0026quot;.\n当option为false时, 即option 为null 或undefined 时, value 为option\u003c/p\u003e\n\u003c/li\u003e\n\u003c/ol\u003e","title":"JavaScript减少IF的方法 - \u0026\u0026(与)和||(或)的特殊用法"},{"content":" 上下文描述: 异常代码\n@Insert(\u0026#34;insert into sys_user(user_id, user_Name, PASSWORD, UPDATED_WHEN) values(#{userId},#{userName},#{password},#{updatedWhen})\u0026#34;) public void insert(User user); 测试代码\n@Test @Transactional public void testInsert() { User user = new User(); user.setUserId(6); user.setPassword(\u0026#34;test12113\u0026#34;); userService.insert(user); } 异常信息\norg.springframework.dao.InvalidDataAccessApiUsageException: Error setting null for parameter #2 with JdbcType OTHER . Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. Cause: java.sql.SQLFeatureNotSupportedException: The data type \u0026#39;OTHER\u0026#39; is not supported. ; SQL []; The data type \u0026#39;OTHER\u0026#39; is not supported.; nested exception is java.sql.SQLFeatureNotSupportedException: The data type \u0026#39;OTHER\u0026#39; is not supported. at org.springframework.jdbc.support.SQLExceptionSubclassTranslator.doTranslate(SQLExceptionSubclassTranslator.java:94) at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:73) at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:81) at org.mybatis.spring.MyBatisExceptionTranslator.translateExceptionIfPossible(MyBatisExceptionTranslator.java:73) at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:371) at $Proxy18.insert(Unknown Source) at org.mybatis.spring.SqlSessionTemplate.insert(SqlSessionTemplate.java:240) at org.apache.ibatis.binding.MapperMethod.execute(MapperMethod.java:51) at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:52) at $Proxy23.insertByProvider(Unknown Source) at top.itart.portal.system.service.UserService.insertByProvider(UserService.java:25) at top.itart.portal.system.service.UserService$$FastClassBySpringCGLIB$$5f581865.invoke(\u0026lt;generated\u0026gt;) at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99) at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:267) at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653) at top.itart.portal.system.service.UserService$$EnhancerBySpringCGLIB$$518bd406.insertByProvider(\u0026lt;generated\u0026gt;) at top.itart.portal.system.service.UserServiceTest.testInsertByProvider(UserServiceTest.java:41) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17) at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:73) at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:82) at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:73) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:217) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:83) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61) at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:68) at org.junit.runners.ParentRunner.run(ParentRunner.java:363) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:163) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197) Caused by: java.sql.SQLFeatureNotSupportedException: The data type \u0026#39;OTHER\u0026#39; is not supported. at org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source) at org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source) at org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source) at org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source) at org.apache.derby.impl.jdbc.Util.checkForSupportedDataType(Unknown Source) at org.apache.derby.impl.jdbc.EmbedPreparedStatement.setNull(Unknown Source) at org.apache.commons.dbcp.DelegatingPreparedStatement.setNull(DelegatingPreparedStatement.java:108) at org.apache.commons.dbcp.DelegatingPreparedStatement.setNull(DelegatingPreparedStatement.java:108) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at org.apache.ibatis.logging.jdbc.PreparedStatementLogger.invoke(PreparedStatementLogger.java:70) at $Proxy29.setNull(Unknown Source) at org.apache.ibatis.type.BaseTypeHandler.setParameter(BaseTypeHandler.java:43) at org.apache.ibatis.scripting.defaults.DefaultParameterHandler.setParameters(DefaultParameterHandler.java:81) at org.apache.ibatis.executor.statement.PreparedStatementHandler.parameterize(PreparedStatementHandler.java:80) at org.apache.ibatis.executor.statement.RoutingStatementHandler.parameterize(RoutingStatementHandler.java:61) at org.apache.ibatis.executor.SimpleExecutor.prepareStatement(SimpleExecutor.java:74) at org.apache.ibatis.executor.SimpleExecutor.doUpdate(SimpleExecutor.java:47) at org.apache.ibatis.executor.BaseExecutor.update(BaseExecutor.java:105) at org.apache.ibatis.executor.CachingExecutor.update(CachingExecutor.java:71) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at org.apache.ibatis.plugin.Invocation.proceed(Invocation.java:49) at top.itart.common.interceptor.UpdatePlugin.intercept(UpdatePlugin.java:40) at org.apache.ibatis.plugin.Plugin.invoke(Plugin.java:60) at $Proxy26.update(Unknown Source) at org.apache.ibatis.session.defaults.DefaultSqlSession.update(DefaultSqlSession.java:152) at org.apache.ibatis.session.defaults.DefaultSqlSession.insert(DefaultSqlSession.java:141) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:601) at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:358) ... 48 more Caused by: ERROR 0A000: The data type \u0026#39;OTHER\u0026#39; is not supported. at org.apache.derby.iapi.error.StandardException.newException(Unknown Source) at org.apache.derby.impl.jdbc.SQLExceptionFactory.wrapArgsForTransportAcrossDRDA(Unknown Source) ... 85 more 分析: 测试数据uer对象中userName值为null, 并且没有指定jdbcType时会出现异常, 文档http://mybatis.github.io/mybatis-3/sqlmap-xml.html 中指明:\nNOTE The JDBC Type is required by JDBC for all nullable columns, if null is passed as a value. You can investigate this yourself by reading the JavaDocs for thePreparedStatement.setNull() method.\n解决方案: 每个需要设置值的字段都指定jdbcType\n@Insert(\u0026#34;insert into sys_user(user_id, user_Name, PASSWORD, UPDATED_WHEN) values(#{userId, jdbcType=VARCHAR},#{userName, jdbcType=VARCHAR},#{password, jdbcType=VARCHAR},#{updatedWhen, jdbcType=DATE})\u0026#34;) public void insert(User user); ","permalink":"/blogs/2015/java/mybatis/mybatis-other-not-support.html","summary":"\u003col\u003e\n\u003cli\u003e上下文描述:\u003c/li\u003e\n\u003c/ol\u003e\n\u003cp\u003e异常代码\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-java\" data-lang=\"java\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#a6e22e\"\u003e@Insert\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;insert into sys_user(user_id, user_Name, PASSWORD, UPDATED_WHEN) values(#{userId},#{userName},#{password},#{updatedWhen})\u0026#34;\u003c/span\u003e)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e     \u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003evoid\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003einsert\u003c/span\u003e(User user);\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e测试代码\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-java\" data-lang=\"java\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#a6e22e\"\u003e@Test\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#a6e22e\"\u003e@Transactional\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003evoid\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003etestInsert\u003c/span\u003e() {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    User user \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e User();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    user.\u003cspan style=\"color:#a6e22e\"\u003esetUserId\u003c/span\u003e(6);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    user.\u003cspan style=\"color:#a6e22e\"\u003esetPassword\u003c/span\u003e(\u003cspan style=\"color:#e6db74\"\u003e\u0026#34;test12113\u0026#34;\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    userService.\u003cspan style=\"color:#a6e22e\"\u003einsert\u003c/span\u003e(user);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cp\u003e异常信息\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003eorg.springframework.dao.InvalidDataAccessApiUsageException: Error setting null for parameter #2 with JdbcType OTHER . Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. Cause: java.sql.SQLFeatureNotSupportedException: The data type \u0026#39;OTHER\u0026#39; is not supported.\n; SQL []; The data type \u0026#39;OTHER\u0026#39; is not supported.; nested exception is java.sql.SQLFeatureNotSupportedException: The data type \u0026#39;OTHER\u0026#39; is not supported.\n\tat org.springframework.jdbc.support.SQLExceptionSubclassTranslator.doTranslate(SQLExceptionSubclassTranslator.java:94)\n\tat org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:73)\n\tat org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:81)\n\tat org.mybatis.spring.MyBatisExceptionTranslator.translateExceptionIfPossible(MyBatisExceptionTranslator.java:73)\n\tat org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:371)\n\tat $Proxy18.insert(Unknown Source)\n\tat org.mybatis.spring.SqlSessionTemplate.insert(SqlSessionTemplate.java:240)\n\tat org.apache.ibatis.binding.MapperMethod.execute(MapperMethod.java:51)\n\tat org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:52)\n\tat $Proxy23.insertByProvider(Unknown Source)\n\tat top.itart.portal.system.service.UserService.insertByProvider(UserService.java:25)\n\tat top.itart.portal.system.service.UserService$$FastClassBySpringCGLIB$$5f581865.invoke(\u0026lt;generated\u0026gt;)\n\tat org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)\n\tat org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717)\n\tat org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)\n\tat org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)\n\tat org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:267)\n\tat org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)\n\tat org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)\n\tat org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)\n\tat org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)\n\tat org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)\n\tat top.itart.portal.system.service.UserService$$EnhancerBySpringCGLIB$$518bd406.insertByProvider(\u0026lt;generated\u0026gt;)\n\tat top.itart.portal.system.service.UserServiceTest.testInsertByProvider(UserServiceTest.java:41)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:601)\n\tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\n\tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\n\tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)\n\tat org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)\n\tat org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:73)\n\tat org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:82)\n\tat org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:73)\n\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\n\tat org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:217)\n\tat org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:83)\n\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\n\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\n\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\n\tat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\n\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\n\tat org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)\n\tat org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:68)\n\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\n\tat org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:163)\n\tat org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)\n\tat org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)\n\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)\n\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)\n\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)\n\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)\nCaused by: java.sql.SQLFeatureNotSupportedException: The data type \u0026#39;OTHER\u0026#39; is not supported.\n\tat org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.Util.checkForSupportedDataType(Unknown Source)\n\tat org.apache.derby.impl.jdbc.EmbedPreparedStatement.setNull(Unknown Source)\n\tat org.apache.commons.dbcp.DelegatingPreparedStatement.setNull(DelegatingPreparedStatement.java:108)\n\tat org.apache.commons.dbcp.DelegatingPreparedStatement.setNull(DelegatingPreparedStatement.java:108)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:601)\n\tat org.apache.ibatis.logging.jdbc.PreparedStatementLogger.invoke(PreparedStatementLogger.java:70)\n\tat $Proxy29.setNull(Unknown Source)\n\tat org.apache.ibatis.type.BaseTypeHandler.setParameter(BaseTypeHandler.java:43)\n\tat org.apache.ibatis.scripting.defaults.DefaultParameterHandler.setParameters(DefaultParameterHandler.java:81)\n\tat org.apache.ibatis.executor.statement.PreparedStatementHandler.parameterize(PreparedStatementHandler.java:80)\n\tat org.apache.ibatis.executor.statement.RoutingStatementHandler.parameterize(RoutingStatementHandler.java:61)\n\tat org.apache.ibatis.executor.SimpleExecutor.prepareStatement(SimpleExecutor.java:74)\n\tat org.apache.ibatis.executor.SimpleExecutor.doUpdate(SimpleExecutor.java:47)\n\tat org.apache.ibatis.executor.BaseExecutor.update(BaseExecutor.java:105)\n\tat org.apache.ibatis.executor.CachingExecutor.update(CachingExecutor.java:71)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:601)\n\tat org.apache.ibatis.plugin.Invocation.proceed(Invocation.java:49)\n\tat top.itart.common.interceptor.UpdatePlugin.intercept(UpdatePlugin.java:40)\n\tat org.apache.ibatis.plugin.Plugin.invoke(Plugin.java:60)\n\tat $Proxy26.update(Unknown Source)\n\tat org.apache.ibatis.session.defaults.DefaultSqlSession.update(DefaultSqlSession.java:152)\n\tat org.apache.ibatis.session.defaults.DefaultSqlSession.insert(DefaultSqlSession.java:141)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:601)\n\tat org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:358)\n\t... 48 more\nCaused by: ERROR 0A000: The data type \u0026#39;OTHER\u0026#39; is not supported.\n\tat org.apache.derby.iapi.error.StandardException.newException(Unknown Source)\n\tat org.apache.derby.impl.jdbc.SQLExceptionFactory.wrapArgsForTransportAcrossDRDA(Unknown Source)\n\t... 85 more\n\u003c/code\u003e\u003c/pre\u003e\u003cul\u003e\n\u003cli\u003e\u003cstrong\u003e分析:\u003c/strong\u003e\u003c/li\u003e\n\u003c/ul\u003e\n\u003cp\u003e测试数据uer对象中userName值为null, 并且没有指定jdbcType时会出现异常, 文档http://mybatis.github.io/mybatis-3/sqlmap-xml.html 中指明:\u003c/p\u003e","title":"mybatis-3.2.8 新增数据为null时, 报The data type 'OTHER' is not support"},{"content":"将json字符串按照key-value的格式转化为Map,保留原有的层次结构.\n引入json-lib相关联的jar包\ncommons-beanutils-1.8.3.jar commons-collections-3.2.1.jar commons-lang-2.6.jar commons-logging-1.1.1.jar ezmorph-1.0.6.jar json-lib-2.4-jdk15.jar 递归解析:\npackage top.itart; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import net.sf.json.JSONObject; public class Json { public static void main(String[] args) { String json = \u0026#34;{\u0026#39;user\u0026#39;:{\u0026#39;name\u0026#39;:\u0026#39;Jacy\u0026#39;,\u0026#39;age\u0026#39;:\u0026#39;100\u0026#39;}, \u0026#39;blog\u0026#39;:{\u0026#39;blog1\u0026#39;:\u0026#39;itart.cn\u0026#39;,\u0026#39;blog2\u0026#39;:\u0026#39;itart.top\u0026#39;}}\u0026#34;; Map\u0026lt;String, Object\u0026gt; map = convertToMap(JSONObject.fromObject(json)); System.out.println(map); } private static Map\u0026lt;String, Object\u0026gt; convertToMap(JSONObject jsonObject) { HashMap\u0026lt;String, Object\u0026gt; data = new HashMap\u0026lt;String, Object\u0026gt;(); Iterator\u0026lt;?\u0026gt; it = jsonObject.keys(); while (it.hasNext()) { String key = String.valueOf(it.next()); Object value = jsonObject.get(key); if (value instanceof JSONObject) { data.put(key, convertToMap((JSONObject) value)); } else { data.put(key, value); } } return data; } } ","permalink":"/blogs/2015/java/json-to-map.html","summary":"\u003cp\u003e将json字符串按照key-value的格式转化为Map,保留原有的层次结构.\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e\n\u003cp\u003e引入json-lib相关联的jar包\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003ecommons-beanutils-1.8.3.jar\ncommons-collections-3.2.1.jar\ncommons-lang-2.6.jar\ncommons-logging-1.1.1.jar\nezmorph-1.0.6.jar\njson-lib-2.4-jdk15.jar\n\u003c/code\u003e\u003c/pre\u003e\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e递归解析:\u003c/p\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-java\" data-lang=\"java\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003epackage\u003c/span\u003e top.itart;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.util.HashMap;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.util.Iterator;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.util.Map;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e net.sf.json.JSONObject;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003eclass\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eJson\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003evoid\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003emain\u003c/span\u003e(String\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e args) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        String json \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#e6db74\"\u003e\u0026#34;{\u0026#39;user\u0026#39;:{\u0026#39;name\u0026#39;:\u0026#39;Jacy\u0026#39;,\u0026#39;age\u0026#39;:\u0026#39;100\u0026#39;}, \u0026#39;blog\u0026#39;:{\u0026#39;blog1\u0026#39;:\u0026#39;itart.cn\u0026#39;,\u0026#39;blog2\u0026#39;:\u0026#39;itart.top\u0026#39;}}\u0026#34;\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        Map\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003eString, Object\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e map \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e convertToMap(JSONObject.\u003cspan style=\"color:#a6e22e\"\u003efromObject\u003c/span\u003e(json));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        System.\u003cspan style=\"color:#a6e22e\"\u003eout\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eprintln\u003c/span\u003e(map);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003eprivate\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e Map\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003eString, Object\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003econvertToMap\u003c/span\u003e(JSONObject jsonObject)\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        HashMap\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003eString, Object\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e data \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e HashMap\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003eString, Object\u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        Iterator\u003cspan style=\"color:#f92672\"\u003e\u0026lt;?\u0026gt;\u003c/span\u003e it \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e jsonObject.\u003cspan style=\"color:#a6e22e\"\u003ekeys\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003ewhile\u003c/span\u003e (it.\u003cspan style=\"color:#a6e22e\"\u003ehasNext\u003c/span\u003e())\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            String key \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e String.\u003cspan style=\"color:#a6e22e\"\u003evalueOf\u003c/span\u003e(it.\u003cspan style=\"color:#a6e22e\"\u003enext\u003c/span\u003e());\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            Object value \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e jsonObject.\u003cspan style=\"color:#a6e22e\"\u003eget\u003c/span\u003e(key);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#66d9ef\"\u003eif\u003c/span\u003e (value \u003cspan style=\"color:#66d9ef\"\u003einstanceof\u003c/span\u003e JSONObject) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                data.\u003cspan style=\"color:#a6e22e\"\u003eput\u003c/span\u003e(key, convertToMap((JSONObject) value));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            } \u003cspan style=\"color:#66d9ef\"\u003eelse\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                data.\u003cspan style=\"color:#a6e22e\"\u003eput\u003c/span\u003e(key, value);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e data;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003c/li\u003e\n\u003c/ol\u003e","title":"Json 转化为Map"},{"content":"现象:\nData Tables在IE上使用时报异常Error Unable to get value of the property \u0026lsquo;style\u0026rsquo; object is null or undefined, Chrome上使用正常. 原因:\n在定义aoColumns 数组时, 在最后一个项后面多加了一个逗号.\n","permalink":"/blogs/2014/frontend/javascript/error-style-object-null-undefined.html","summary":"\u003cp\u003e\u003cstrong\u003e现象:\u003c/strong\u003e\u003c/p\u003e\n\u003cp\u003eData Tables在IE上使用时报异常Error Unable to get value of the property \u0026lsquo;style\u0026rsquo; object is null or undefined, Chrome上使用正常.\n\u003cimg alt=\"01a1fe68-1d03-7572-8435-302c4920827e\" loading=\"lazy\" src=\"/blogs/2014/frontend/javascript/error-style-object-null-undefined/error.png\"\u003e\u003c/p\u003e\n\u003cp\u003e\u003cstrong\u003e原因:\u003c/strong\u003e\u003c/p\u003e\n\u003cp\u003e在定义aoColumns 数组时, 在最后一个项后面多加了一个逗号.\u003c/p\u003e","title":"Error Unable to get value of the property 'style' object is null or undefined"},{"content":"在使用junit 4 测试spring4代码时, 事物始终无法回滚, 即使已经在方法中增加了@Transactiona 和 @Rollback(true)标签, 但是每次执行后数据还是插入到数据库中. 异常代码:\n@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration ({\u0026#34;classpath*:applicationContext*.xml\u0026#34;}) public class SysUserServiceTest extends AbstractJUnit4SpringContextTests { @Autowired private SysUserService sysUserService; @Test @Transactional @Rollback(true) public void testInsert() { SysUser user = new SysUser(); user.setUserId(11); user.setName(\u0026#34;dan\u0026#34;); sysUserService.insert(user); } } 分析:\n测试代码继承了AbstractJUnit4SpringContextTests , 在AbstractJUnit4SpringContextTests 中已经存在事务,并且默认事务是自动提交,它覆盖了后来在方法中配置的事务, 另外就是在测试类已经使用了@RunWith, 所以测试类无需再继承AbstractJUnit4SpringContextTests\n解决:\n@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration ({\u0026#34;classpath*:applicationContext*.xml\u0026#34;}) public class SysUserServiceTest { @Autowired private SysUserService sysUserService; @Test @Transactional @Rollback(true) public void testInsert() { SysUser user = new SysUser(); user.setUserId(19); user.setName(\u0026#34;dan\u0026#34;); sysUserService.insert(user); } } ","permalink":"/blogs/2014/java/junit/spring4-junit4-rollback.html","summary":"\u003cp\u003e在使用junit 4 测试spring4代码时, 事物始终无法回滚, 即使已经在方法中增加了@Transactiona 和 @Rollback(true)标签, 但是每次执行后数据还是插入到数据库中.\n异常代码:\u003c/p\u003e","title":"spring4 + junit4 事物无法回滚"},{"content":"从指定集合中获取元素组合成不同的字符串.\n组合生成类（Combination.java) import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * @author hymanz 506600909@qq.com */ public class Combination { private char[] base; public Combination(char[] base) { this.base = base; } public List\u0026lt;char[]\u0026gt; getCombinations(int length) { List\u0026lt;char[]\u0026gt; list = new ArrayList\u0026lt;char[]\u0026gt;(); list.add(new char[length]); return compose(0, list); } private List\u0026lt;char[]\u0026gt; compose(int index, List\u0026lt;char[]\u0026gt; list) { if (index \u0026gt;= list.get(0).length) { return list; } for (int i = 0, size = list.size(); i \u0026lt; size; i++) { char[] item = list.get(i); for (int j = 0; j \u0026lt; base.length; j++) { if (j \u0026gt; 0) { item = copy(item); list.add(item); } item[index] = base[j]; } } return compose(++index, list); } private char[] copy(char[] item) { return Arrays.copyOf(item, item.length); } } 调用方式 public class Main { public static void main(String[] args) { char[] base = {\u0026#39;0\u0026#39;, \u0026#39;1\u0026#39;, \u0026#39;2\u0026#39;, \u0026#39;3\u0026#39;, \u0026#39;4\u0026#39;, \u0026#39;5\u0026#39;, \u0026#39;6\u0026#39;, \u0026#39;7\u0026#39;, \u0026#39;8\u0026#39;, \u0026#39;9\u0026#39;}; Combination combination = new Combination(base); List\u0026lt;char[]\u0026gt; result = combination.getCombinations(3); for (char[] cs : result) { System.out.println( new String(cs)); } } } ","permalink":"/blogs/2014/java/java-number-compose.html","summary":"\u003cp\u003e从指定集合中获取元素组合成不同的字符串.\u003c/p\u003e\n\u003cul\u003e\n\u003cli\u003e\u003cstrong\u003e组合生成类（Combination.java)\u003c/strong\u003e\u003c/li\u003e\n\u003c/ul\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-java\" data-lang=\"java\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.util.ArrayList;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.util.Arrays;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#f92672\"\u003eimport\u003c/span\u003e java.util.List;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e/**\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e * @author hymanz 506600909@qq.com\n\u003c/span\u003e\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#75715e\"\u003e */\u003c/span\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003eclass\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eCombination\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003eprivate\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e base;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eCombination\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e base) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003ethis\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003ebase\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e base;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e List\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003e\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u0026gt;\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003egetCombinations\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e length) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        List\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003e\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u0026gt;\u003c/span\u003e list \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e ArrayList\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003e\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u0026gt;\u003c/span\u003e();\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        list.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[\u003c/span\u003elength\u003cspan style=\"color:#f92672\"\u003e]\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e compose(0, list);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003eprivate\u003c/span\u003e List\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003e\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u0026gt;\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003ecompose\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e index, List\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003e\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u0026gt;\u003c/span\u003e list) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003eif\u003c/span\u003e (index \u003cspan style=\"color:#f92672\"\u003e\u0026gt;=\u003c/span\u003e list.\u003cspan style=\"color:#a6e22e\"\u003eget\u003c/span\u003e(0).\u003cspan style=\"color:#a6e22e\"\u003elength\u003c/span\u003e) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e list;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003efor\u003c/span\u003e (\u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e i \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e 0, size \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e list.\u003cspan style=\"color:#a6e22e\"\u003esize\u003c/span\u003e(); i \u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003e size; i\u003cspan style=\"color:#f92672\"\u003e++\u003c/span\u003e) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e item \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e list.\u003cspan style=\"color:#a6e22e\"\u003eget\u003c/span\u003e(i);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            \u003cspan style=\"color:#66d9ef\"\u003efor\u003c/span\u003e (\u003cspan style=\"color:#66d9ef\"\u003eint\u003c/span\u003e j \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e 0; j \u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003e base.\u003cspan style=\"color:#a6e22e\"\u003elength\u003c/span\u003e; j\u003cspan style=\"color:#f92672\"\u003e++\u003c/span\u003e) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                \u003cspan style=\"color:#66d9ef\"\u003eif\u003c/span\u003e (j \u003cspan style=\"color:#f92672\"\u003e\u0026gt;\u003c/span\u003e 0) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                    item \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e copy(item);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                    list.\u003cspan style=\"color:#a6e22e\"\u003eadd\u003c/span\u003e(item);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e                item\u003cspan style=\"color:#f92672\"\u003e[\u003c/span\u003eindex\u003cspan style=\"color:#f92672\"\u003e]\u003c/span\u003e \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e base\u003cspan style=\"color:#f92672\"\u003e[\u003c/span\u003ej\u003cspan style=\"color:#f92672\"\u003e]\u003c/span\u003e;\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e compose(\u003cspan style=\"color:#f92672\"\u003e++\u003c/span\u003eindex, list);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003eprivate\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003ecopy\u003c/span\u003e(\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e item) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003ereturn\u003c/span\u003e Arrays.\u003cspan style=\"color:#a6e22e\"\u003ecopyOf\u003c/span\u003e(item, item.\u003cspan style=\"color:#a6e22e\"\u003elength\u003c/span\u003e);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e\u003cul\u003e\n\u003cli\u003e\u003cstrong\u003e调用方式\u003c/strong\u003e\u003c/li\u003e\n\u003c/ul\u003e\n\u003cdiv class=\"highlight\"\u003e\u003cpre tabindex=\"0\" style=\"color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;\"\u003e\u003ccode class=\"language-java\" data-lang=\"java\"\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e\u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003eclass\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003eMain\u003c/span\u003e {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    \u003cspan style=\"color:#66d9ef\"\u003epublic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003estatic\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003evoid\u003c/span\u003e \u003cspan style=\"color:#a6e22e\"\u003emain\u003c/span\u003e(String\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e args) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e base \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e {\u003cspan style=\"color:#e6db74\"\u003e\u0026#39;0\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;1\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;2\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;3\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;4\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;5\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;6\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;7\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;8\u0026#39;\u003c/span\u003e, \u003cspan style=\"color:#e6db74\"\u003e\u0026#39;9\u0026#39;\u003c/span\u003e};\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        Combination combination \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e Combination(base);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        List\u003cspan style=\"color:#f92672\"\u003e\u0026lt;\u003c/span\u003e\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u0026gt;\u003c/span\u003e result \u003cspan style=\"color:#f92672\"\u003e=\u003c/span\u003e combination.\u003cspan style=\"color:#a6e22e\"\u003egetCombinations\u003c/span\u003e(3);\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        \u003cspan style=\"color:#66d9ef\"\u003efor\u003c/span\u003e (\u003cspan style=\"color:#66d9ef\"\u003echar\u003c/span\u003e\u003cspan style=\"color:#f92672\"\u003e[]\u003c/span\u003e cs : result) {\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e            System.\u003cspan style=\"color:#a6e22e\"\u003eout\u003c/span\u003e.\u003cspan style=\"color:#a6e22e\"\u003eprintln\u003c/span\u003e( \u003cspan style=\"color:#66d9ef\"\u003enew\u003c/span\u003e String(cs));\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e        }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e    }\n\u003c/span\u003e\u003c/span\u003e\u003cspan style=\"display:flex;\"\u003e\u003cspan\u003e}\n\u003c/span\u003e\u003c/span\u003e\u003c/code\u003e\u003c/pre\u003e\u003c/div\u003e","title":"java 字符数字组合算法"},{"content":"在MyEclipse中使用模板可以大大提高我们的编程效率，在Eclipse或MyEclipse中默认使用的是Alt+/调出模板，如果调不出模板的话，可能是快捷键存在冲突，可以通过如下方法设置 Window-\u0026gt;Preferences-\u0026gt;General-\u0026gt;Keys 打开如下界面（我用的版本是MyEclipse 8.0M1)\n在界面中找到Content Assist,可以看到默认绑定到Alt+/，可以通过下面的Binding:重新设置绑定键，建议使用不常用的，可以在Binding里单击列排序，可看到设定的键有没有重复，当设定好后点击OK确定，这步就完成了 下面进行模板的定义 选择Window-\u0026gt;Preferences-\u0026gt;Java-\u0026gt;Editor-\u0026gt;Templates进入如下界面\n在这里可以看到系统已定义好的模板，输入模板名后按Alt+/或是前面设定好的热键即可根据模板替换文本，如系统自带有sysout模板，如下\n那么我们在写java文件时就可以输入sysout然后打入Alt+/或是前面设定好的热键，就可以替换成Pattern里的文本，另外界面里还有个设置Automatically insert的地方，如果选中将其设置为on，那么在使用模板替换时就不会出现提示对话框，直接替换，若该状态不是on，在执行模板替换时会出现询问的提示 如果觉得这些不够用，我们也可以自己定义模板，选择旁边的New\u0026hellip;即可，如下图\n建了一个mytmp的模板，定义了五行文本，这里通过“Insert Variable\u0026hellip;”插入了几个变量，它们分别代表不同的含义 ${enclosing_package} 表示当前文件的包名 ${enclosing_type} 表示当前类名 ${enclosing_method} 表示当前的方法名 ${cursor} 表示光标的位置 另外，在“Insert Variable\u0026hellip;”里还有很多可选择的东东，大家看下英文的变量名就能应该能理解的 此时，当我们在编写java文件时，输入mytmp后按Alt+/或是前面设定好的热键，就可以替换为上面定义的五行文本，这样的操作真是太帅了 其实它自带模板的已经很多了，定义好热键及个性化的模板，可以大大加快我们写代码的速度，高效哇！！！ MyEclipse真是个好东东，看来还有很多值得研究的东西，把这点东东记录在这里，供还在钻研的朋友们参考一下\n","permalink":"/blogs/2010/java/eclipse/myeclipse-templates.html","summary":"\u003cp\u003e在MyEclipse中使用模板可以大大提高我们的编程效率，在Eclipse或MyEclipse中默认使用的是Alt+/调出模板，如果调不出模板的话，可能是快捷键存在冲突，可以通过如下方法设置 Window-\u0026gt;Preferences-\u0026gt;General-\u0026gt;Keys 打开如下界面（我用的版本是MyEclipse 8.0M1)\u003c/p\u003e","title":"在MyEclipse中使用模板"},{"content":"首先按以下步骤进入要修改的位置\nWindow\u0026ndash;\u0026gt;Preferences\u0026ndash;\u0026gt;Java\u0026ndash;\u0026gt;Code Style\u0026ndash;\u0026gt;Code Templates\n点击Comments\n找到Types 然后双击填入以下几个东西即可，然后在新建类的时候在Generate comments前面√即可以\n/** * @author 作者的名字 E-mail: 写自己的Email * @version 创建时间：${date} ${time} / 如果我们在团队中写项目 有的时候需要改一个方法里面的东西，这里我们就可以加注释，知道是哪个人写的或者修改的,万一出现错误，容易找到创建方法或者修改方法的团队成员来进行改正\n点击Comments\n找到Methods 然后双击填入以下几个东西即可：\n/** * @author 作者的名字 E-mail: 写自己的Email * @version 创建时间：${date} ${time} * ${tags} / ","permalink":"/blogs/2010/java/eclipse/myeclipse-templates-comment.html","summary":"\u003cp\u003e首先按以下步骤进入要修改的位置\u003c/p\u003e\n\u003cp\u003eWindow\u0026ndash;\u0026gt;Preferences\u0026ndash;\u0026gt;Java\u0026ndash;\u0026gt;Code Style\u0026ndash;\u0026gt;Code Templates\u003c/p\u003e\n\u003cp\u003e点击Comments\u003c/p\u003e\n\u003col\u003e\n\u003cli\u003e\n\u003cp\u003e找到Types 然后双击填入以下几个东西即可，然后在新建类的时候在Generate comments前面√即可以\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003e/**\n* @author 作者的名字  E-mail: 写自己的Email\n* @version 创建时间：${date}  ${time}\n/\n\u003c/code\u003e\u003c/pre\u003e\u003c/li\u003e\n\u003cli\u003e\n\u003cp\u003e如果我们在团队中写项目 有的时候需要改一个方法里面的东西，这里我们就可以加注释，知道是哪个人写的或者修改的,万一出现错误，容易找到创建方法或者修改方法的团队成员来进行改正\u003c/p\u003e\n\u003cp\u003e点击Comments\u003c/p\u003e\n\u003cp\u003e找到Methods 然后双击填入以下几个东西即可：\u003c/p\u003e\n\u003cpre tabindex=\"0\"\u003e\u003ccode\u003e/**\n* @author 作者的名字  E-mail: 写自己的Email\n* @version 创建时间：${date}  ${time}\n* ${tags}\n/\n\u003c/code\u003e\u003c/pre\u003e\u003c/li\u003e\n\u003c/ol\u003e","title":"MyEclipse中修改注释模板"},{"content":"最近为了给自己多加些资本，开始系统的学习Struts2，在学习的过程中，发现问题，这些问题虽然对struts2的高手来说都是低级问题，但是我想对初学者来说还是比较容易碰上的，现在我碰到的问题整合起来，和大家一起分享：\n在struts.xml中配置的自定义拦截器interceptor无效，经过查找资料，发现是因为我用的是struts-2.1.8.1，和struts-2.0不同，他的注解的jar包是独立出来的，为struts2-convention-plugin-2.1.8.1.jar，只要这个jar包导入工程后，会默认拦截器的配置是采用注解，删除这个jar包后，struts.xml配置的自定义拦截器就可以生效了，具体2.1版本要如何让注解和struts.xml同时生效，暂时没找到方法。\n时间控件出现\u0026quot;dojo未定义\u0026quot;，在页面没有显示时间控件，在页面上加入 \u0026lt;s:head theme=\u0026ldquo;ajax\u0026rdquo;/\u0026gt; 就OK了。另外额外发现struts-2.1时间控件标签已经改变，时间控件标签单独声明。\n2.0版本\n\u0026lt;%@ page contentType=\u0026#34;text/html; charset=UTF-8\u0026#34; %\u0026gt; \u0026lt;%@ taglib prefix=\u0026#34;s\u0026#34; uri=\u0026#34;/struts-tags\u0026#34;%\u0026gt; 2.1版本\n\u0026lt;%@ page contentType=\u0026#34;text/html; charset=UTF-8\u0026#34; %\u0026gt; \u0026lt;%@ taglib prefix=\u0026#34;s\u0026#34; uri=\u0026#34;/struts-tags\u0026#34;%\u0026gt; \u0026lt;%@ taglib prefix=\u0026#34;sx\u0026#34; uri=\u0026#34;/struts-dojo-tags\u0026#34; %\u0026gt; 3、visitor校验器的没起作用，也不报错。仔仔细细检查过文件内容，没发现一点问题，最后发现原来验证pojo文件放错位置了，如果验证的是User.class，验证文件User-xxx-validation.xml要和User.class文件在同一个目录中。也就是要放到你的POJO文件相同的目录路径下，不然的话Visitor校验器就不会起作用。\n","permalink":"/blogs/2010/java/struts2/struct2-note.html","summary":"\u003cp\u003e最近为了给自己多加些资本，开始系统的学习Struts2，在学习的过程中，发现问题，这些问题虽然对struts2的高手来说都是低级问题，但是我想对初学者来说还是比较容易碰上的，现在我碰到的问题整合起来，和大家一起分享：\u003c/p\u003e","title":"struts2学习笔记"}]