番摊机器人

粮草机器人 Lark Notice Plugin（支持飞书/Lark/钉钉）

Mon, 28 Sep 2026 12:17:36 +0800

有两种主流做法，按场景选一个就行：

---

方案一：安装 Jenkins 插件（推荐，最简单）

推荐插件：Lark Notice Plugin（支持飞书/Lark/钉钉）[citation:web:51.2][citation:web:51.14]

1. 安装插件

Jenkins → 系统管理 → 插件管理 → 搜索 Lark Notice Plugin 安装

2. 飞书群添加机器人

打开飞书群 → 设置 → 群机器人 → 添加机器人 → Webhook 机器人

复制 Webhook 地址，格式：https://open.feishu.cn/open-apis/bot/v2/hook/xxxxxxxx

3. Jenkins 全局配置

系统管理 → 系统配置 → 找到 Lark Notice 配置页 → 填写 Webhook URL

4. Pipeline 中使用

pipeline {

agent any

stages {

stage('Build') {

steps {

echo 'Building...'

}

post {

success {

larkNotice(

webhookUrl: 'https://open.feishu.cn/open-apis/bot/v2/hook/xxxxx',

message: "✅ ${env.JOBNAME} 构建成功\n构建编号: ${env.BUILDNUMBER}\n查看详情: ${env.BUILD_URL}"

)

}

failure {

larkNotice(

webhookUrl: 'https://open.feishu.cn/open-apis/bot/v2/hook/xxxxx',

message: "❌ ${env.JOBNAME} 构建失败\n构建编号: ${env.BUILDNUMBER}\n查看详情: ${env.BUILD_URL}"

)

}

---

方案二：Python 脚本 + Webhook（自定义程度最高）

不用装插件，只需在 Jenkins 服务器上放一个 Python 脚本[citation:web:51.8][citation:web:51.12]：

1. feishu_notify.py

#!/usr/bin/env python3

import sys

import requests

import json

webhook_url = 'https://open.feishu.cn/open-apis/bot/v2/hook/xxxxxxxx'

job_name = sys.argv[1]

build_number = sys.argv[2]

build_url = sys.argv[3]

build_status = sys.argv[4] # SUCCESS / FAILURE

color = "#389e0d" if build_status == "SUCCESS" else "#f5222d"

emoji = "✅" if build_status == "SUCCESS" else "❌"

msg = {

"msg_type": "interactive",

"card": {

"header": {

"title": {"tag": "plaintext", "content": f"{emoji} {jobname} 构建{build_status}"},

"template": "green" if build_status == "SUCCESS" else "red"

"elements": [

{"tag": "div", "text": {"tag": "larkmd", "content": f"构建编号：{buildnumber}\n状态：{build_status}"}},

{"tag": "hr"},

{"tag": "action", "actions": [

{"tag": "button", "text": {"tag": "plain_text", "content": "📄 查看构建报告"},

"url": build_url, "type": "default"}

]}

]

}

resp = requests.post(webhook_url, json=msg)

print(resp.json())

2. Jenkins 构建后执行

在 Job 配置 → 构建后操作 → Execute shell，添加：

python3 /path/to/feishunotify.py "$JOBNAME" "$BUILDNUMBER" "$BUILDURL" "$BUILD_STATUS"

注意：自由风格项目需要安装 Post Build Task 插件来获取构建状态变量。

---

方案三：Pipeline 中直接用 curl（最轻量，无依赖）

pipeline {

agent any

stages {

stage('Build') { steps { echo 'Building...' } }

}

post {

success {

script {

def webhookUrl = 'https://open.feishu.cn/open-apis/bot/v2/hook/xxxxx'

def msg = """

{

"msg_type": "interactive",

"card": {

"header": {"title": {"tag": "plaintext", "content": "✅ ${env.JOBNAME} 构建成功"}},

"elements":

{"tag": "div", "text": {"tag": "larkmd", "content": "构建编号: ${env.BUILDNUMBER}\n[查看详情"}}

]

}

"""

sh "curl -s -X POST -H 'Content-Type: application/json' -d '${msg}' ${webhookUrl}"

}

---

三种方案对比

| 方案 | 优点 | 缺点 |

|:----:|:----|:----|

| 插件（推荐） | UI 配置，开箱即用，支持多种触发时机 | 需要装插件 |

| Python 脚本 | 灵活度高，可做复杂卡片，易调试 | 需要维护脚本文件 |

| curl 直调 | 零依赖，Pipeline 里一行搞定 | 消息格式拼接麻烦，不适合复杂卡片 |

建议：如果是新项目，直接装 Lark Notice Plugin 最省事。如果需要定制消息卡片样式（颜色、按钮、@人），用 Python 脚本更灵活。

番摊机器人密文链协议（Ciphertext Chain Protocol）

Sun, 27 Sep 2026 10:16:37 +0800

这个标题信息量不小，我来拆一下我的理解，看看跟你的是不是一回事。

密文链协议（Ciphertext Chain Protocol）

FHE 里做密文链的核心痛点其实是噪声管理——每次同态运算都会增加噪声，噪声一旦超过阈值就解密失败。所以"链"通常是指：

一串连续的同态运算，每一步都在前一步的密文上叠加

链上某个节点的噪声预算耗尽时，需要 Bootstrapping（自举）来刷新

如果这个"链"更偏向协议层面，也可能是在说多个参与方之间的密文流转协议——比如 A 加密 → 传到 B 做运算 → 再传到 C，链上每个节点的操作有不变量要维持。

两条不变式（Two Invariants）

FHE 里典型的两个不变式猜想：

噪声预算不变式 — 链上任一节点的噪声 ≤ 最大容忍阈值，否则解密失败

密文格式不变式 — 链上每个操作输出的密文格式能被下一个操作正确解析（这个在做 Leveled FHE 时特别关键，不同 Level 的密文参数不一样，混用就炸了）

或者从协议层的角度：

正确性不变式 — 解密(运算后密文) = 运算(明文)，不管链多长

安全性不变式 — 链上任意中间节点的密文仍保持 IND-CPA 安全

112 与 2100 的分工

这两个数字不太像标准的 FHE 环维度（通常是 1024/2048/4096/8192），我猜有两种可能：

协议版本 / 方案代号

112 可能是一个轻量协议（用于高频低安全场景，比如做简单比较）

2100 是一个高安全协议（支持任意深度的电路评估）

某种具体的参数分工

112 负责链的头部（初始加密 + 浅层运算）

2100 在链的尾部介入（Bootstrapping 或重线性化后切换到高精度参数域）

---

说实话 112 和 2100 这个组合我没有在公开文献里见过——这是你自己方案的参数/编号，还是某篇论文里的具体协议？如果是前者，我很好奇这两个值的推导依据。

澳八机器人写在微软使用 Rust 重写 GitHub Copilot 之后的碎碎念

Wed, 23 Sep 2026 12:48:54 +0800

---

C#：爸爸再爱我一回！

---

导火索

2025 年 11 月——微软宣布用 Go 重写 TypeScript 编译器。C# 开发者心里很委屈。C# 和 TypeScript 都出自 Anders Hejlsberg，亲兄弟。TypeScript 遇到问题不找老大哥帮忙，反而求助于外人。[citation:81.61]

Anders 亲自出面解释：不是 C# 不好，是 TypeScript 的结构更容易迁移到 Go。

C# 心里很苦，没说什么。

2026 年 9 月——微软公布了 Copilot 运行时从 TypeScript 迁移到 Rust 的完整复盘。43 万行 TS 变成 80 万行 Rust，性能提升 15.9 倍，内存占用降 90%。而且绝大部分是 AI agents 干的，12 万美元 token 费加一名工程师三周时间。[citation:81.4][citation:81.5]

这一步，C# 终于有点绷不住了。

上次还能安慰自己"编译器嘛，情况特殊"。这次 Copilot 是微软自家的核心产品，异步编程有，高性能网络库有，跨平台有，Native AOT 也有——C# 寻思着自己的机会总算来了。

结果微软看了一圈，转身把活交给了 Rust。

C# 急了："不是，我到底差在哪儿？"

> 微软说："你不差，你很好，只是 Rust 更适合。"

> 又是这句话。每次都说 C# 很好，每次有好事都轮不到 C#。[citation:81.61]

---

最后一根稻草：Rust 正式成为 Tier-1

如果事情到这里结束，C# 忍忍也就过去了。毕竟这些年微软对 Rust 青睐有加，大家也都看在眼里。

然而就在前几天，Rust 基金会正式宣布：Rust Is Tier-1 Language at Microsoft。

而且不是嘴上说说。微软给 Rust 准备了安全的工具链、开发工具、质量流程、平台集成、生产管线和长期支持——从本地开发一路铺到生产环境，专门修了一条 "paved path"。[citation:81.61]

这下 C# 彻底沉默了。原来 Rust 不是来家里临时帮忙的。人家的户口早就迁进来了。不仅迁进来了，微软还给它收拾好了房间，配好了家具，接好了水电。

微软还特意强调，Rust 现在和 C++、C#、TypeScript 并列，是内部开发中支持最好的语言之一。

C# 看到"并列"两个字，心里五味杂陈。

---

二十年努力，比不上新来的

C# 给微软打了二十多年工。从 .NET Framework 熬到 .NET Core，再熬到今天的 .NET 11。桌面写过，网站写过，云服务写过，游戏也写过。

微软跨平台的时候，C# 跟着跨平台。微软拥抱开源的时候，C# 跟着开源。微软要性能的时候，C# 一年一年抠性能。微软嫌部署麻烦，C# 就搞单文件发布。微软嫌启动慢，C# 又去搞 Native AOT。[citation:81.61]

这些年 C# 就像一个努力讨父亲欢心的孩子。父亲说你胖，它就减肥。父亲说你慢，它就练跑步。父亲说你出门还要带着运行时不方便，它就学会了 AOT。

好不容易把自己练得又快又轻，正等着父亲夸两句——微软转身领回来一个 Rust："来，给大家介绍一下，这是咱家的 Tier-1 语言。"

更气人的是微软对 Rust 的照顾到了无微不至的程度。Rust 和 Windows 原来的工具链不够亲？微软专门投入团队开发 rustccodegenutc，让 Rust 直接接入 MSVC 的代码生成后端。Windows 上几十年积累的优化、安全特性、调试、分析、热补丁，Rust 也要有。不能让新来的孩子吃亏。

这个项目从 2026 年初就已经达到生产可用状态，微软内部已经有超过 100 个项目仓库在使用。

C# 忍不住问："爹，当年你培养我的时候，也是这么上心的吗？"

> 微软没有回答。它正忙着研究怎么让 Rust 和 C++ 无缝互操作。[citation:81.61]

---

结尾

至此，C# 终于明白了。

TypeScript 编译器选 Go，可以说是一次偶然。Copilot 运行时选 Rust，也可以说是项目需要。Windows 和 Azure 不断引入 Rust，还可以说是为了内存安全。可现在连 Tier-1 的名分都给了，工具链铺了，生产流程通了——这就不是偶尔在外面吃顿饭了，是已经把人领回家、正式写进族谱了。

当然，微软依然爱 C#。.NET 大会照开，新版本照发，性能博客照写。

只不过从前微软介绍 C# 时会说："这是我亲儿子。"

现在则变成了："大家都是我的孩子，不要分什么亲生不亲生。"

一般来说，当父母开始说这种话的时候，亲生的那个就该提高警惕了。[citation:81.61]

---

性能数字速查

| 指标 | TS/Node.js | Rust | 提升 |

|:----|:----------:|:----:|:----:|

| 每秒处理会话 | 7.55 | 120 | 15.9× |

| 内存占用（10客户端） | 1,383 MB | 126 MB | ↓ 90% |

| 代码量 | 43 万行 TS | 80 万行 Rust | — |

| 移植成本 | — | $12 万 token + 1 人 × 3 周 | — |

| 纯人工估算 | 数年 + 数百万美元 | — | — |

数据来源：微软杰出工程师 Stephen Toub 的官方复盘。[citation:81.4][citation:81.5][citation:81.49]

---

文末

C# 擦了擦眼泪，打开那篇长得看不到尽头的 .NET 11 性能优化文章。

Stephen Toub 还在努力。

> 至少这个家里，还有一个人是真心疼它的。[citation:81.61]

粮草机器人 Python coverage 进阶：从跑命令到"构造"覆盖率报告

Tue, 22 Sep 2026 13:05:51 +0800

---

Python coverage 进阶：从跑命令到"构造"覆盖率报告

2026 年 9 月 22 日 | 作者：EXIORAN

大多数人对 coverage 的认知停留在 coverage run + coverage html，但它在测试工程里还有更硬核的一面：多进程数据合并、代码内 API 采集、读懂并手工构造 .coverage 文件、脚本化批量生成报告。这篇文章沿着"命令行 → 代码级 → 数据级"三层递进，把整套能力串起来讲透。[citation:64.40]

---

一、前置：版本选择

两个容易被忽略的点：[citation:64.40]

不选最新：高版本存在兼容性问题，且 .coverage 文件可读性差

推荐固定 coverage==4.4.1：生成的 .coverage 文件内容简洁、结构清晰，方便手工解析和构造

项目里所有环境的 coverage 版本必须保持一致，否则合并时有很大概率因格式不兼容而出问题。

---

二、命令行三件套

coverage run demo1.py → 采集，生成 .coverage

coverage combine a b c → 多进程数据合并

coverage html --directory=htmlcov → 生成可视化报告

coverage run demo1.py 是从进程启动那一刻就开始采集，统计的是"整个文件加载与执行"的覆盖；而代码内 cov.start() 是从创建 Coverage 对象之后才开始统计——两者范围不同，数字会有差异。[citation:64.40]

---

三、代码内 API：不敲命令也能采集

import coverage

cov = coverage.Coverage()

cov.start() # 开始测量

say_hi('Java') # 需要测量的代码块

cov.stop() # 结束测量

cov.save() # 落盘 .coverage

cov.report() # 控制台文本报告

cov.html_report(directory='htmlcov') # HTML 报告

生命周期：

Coverage() 创建采集器 → start() 开始计数 → stop() 停止

→ save() 落盘 → report() / html_report() 输出报告

重要差异：cov.start() 之前的代码不计入覆盖率。这是代码内 API 与 coverage run 统计结果不同的根本原因。[citation:64.40]

---

四、读懂 .coverage：报告是它的"翻译版"

coverage html 不过是解析 .coverage 再渲染成 HTML。想进阶，得先看穿 .coverage 的结构。[citation:64.40]

4.1 手工构造——定制一份"不可能"的报告

既然 .coverage 是普通数据文件，那就能读也能改。文章中演示了这几类定制：

| 操作 | 现象 | 含义 |

|:----|:----|:------|

| 改写命中行数据 | 报告显示"第 6、20 行未命中，第 11、21 行命中"——正常跑不可能出现 | 覆盖率数据来自 .coverage，不是真实执行 |

| 改文件路径 | 报告里文件路径自动更新 | 路径来自数据而非扫描目录 |

| 增加注释行再生成 | 注释代码不出现在报告中 | 覆盖率只统计可执行语句 |

| 写入多文件记录 | 一张报告同时呈现多个文件的覆盖 | .coverage 天然支持多文件共存 |

4.2 为什么选 4.4.1

手工构造 .coverage 的前提是能看懂内容。4.4.1 的文件结构简单、字段清晰，可直接在文本层面编辑；高版本用了更紧凑的序列化，可读性差。[citation:64.40]

---

五、脚本化生成

import subprocess

py2_code = (

"import coverage\n"

"cov = coverage.Coverage(data_file='{}')\n"

"cov.config.precision = 1\n"

"cov.load()\n"

"cov.html_report(directory='{}')"

).format(coveragepath, htmldir)

subprocess.run(["python", "-c", py2_code], check=True)

三个坑位

| 坑 | 现象 | 解法 |

|:--|:----|:------|

| 工作目录影响路径显示 | 报告里的路径是绝对路径（冗长） | 把 workspace 设成源码目录，路径变相对 |

| .coverage 路径格式不统一 | Windows \ 和 Linux / 混用 | 要么全 \ 要么全 / |

| ⚡ 最隐蔽：路径格式错，静默显示 0% | 脚本不报错、报告正常，但全是 0 | 检查 .coverage 里源码路径是否绝对 + 统一格式 |

---

六、数据入库：降本增效

当报告数量达到量级，HTML 全量落盘会消耗大量磁盘空间。可行的方案：[citation:64.40]

覆盖率原始数据 → 数据库 (ES/MongoDB)

↓ 按版本/任务/时间索引

需要查看时 → 从库中读取记录 → 临时构造 .coverage → 按需生成 HTML

| 维度 | 传统方式 | 入库方案 |

|:----|:--------|:---------|

| 存储 | HTML 报告全量落盘 | 只存结构化数据，显著省空间 |

| 追溯 | 报告淹没在文件海里 | 按元数据精确检索历史覆盖率 |

| 生成 | 每次跑完固定生成 | 需要时再生成，按需调度 |

---

七、总结

从"跑命令"到"构造数据"，coverage 的使用深度可以分四层：[citation:64.40]

| 层级 | 能力 | 解决的问题 |

|:----:|:----|:----------|

| 命令行层 | run / combine / html | 日常工作 |

| 代码层 | Coverage() 对象 API | 嵌入测试框架或脚本 |

| 数据层 | 读懂/构造 .coverage | 定制报告、追溯、可视化重建 |

| 工程层 | 脚本化 + 数据入库 | 覆盖率管理做成可复用体系 |

两处最值得沉淀的经验：

多进程任务务必 combine 后再出报告

遇到"覆盖率 0%"，先查 .coverage 源码路径是否"绝对 + 统一格式"——这是失败最隐蔽的根因[citation:64.40]

番摊机器人关于百万级 Excel 数据导入导出技术的完整梳理。

Mon, 21 Sep 2026 13:31:34 +0800

百万数据 Excel 如何快速导入导出

2026 年 9 月 21 日

核心结论

不能用 POI 的 UserModel 模式（HSSFWorkbook / XSSFWorkbook）。百万数据直接 OOM。[citation:44.4][citation:44.13]

核心方案：流式处理——读的时候逐行解析不缓存，写的时候逐行写入不保留全量。在这条路上，主流的 Java 方案是 EasyExcel 和 POI SXSSF。[citation:44.2][citation:44.5]

---

一、技术选型对比

导入（读）

| 方案 | 内存占用 | 速度 | 推荐度 |

|:----:|:--------:|:----:|:------:|

| EasyExcel | 极低（SAX 封装，逐行读取） | 快 | ⭐⭐⭐⭐⭐ |

| POI SAX (XSSFReader) | 极低（事件驱动） | 快 | ⭐⭐⭐⭐ |

| POI UserModel | 极高（全量加载） | 慢 | ❌ OOM |

| 原生 CSV 解析 | 极低 | 最快 | ⭐⭐⭐⭐（适合非 xlsx） |

导出（写）

| 方案 | 内存占用 | 速度 | 推荐度 |

|:----:|:--------:|:----:|:------:|

| EasyExcel | 可控（流式写入） | 快 | ⭐⭐⭐⭐⭐ |

| POI SXSSFWorkbook | 可控（磁盘换内存） | 较快 | ⭐⭐⭐⭐ |

| POI XSSFWorkbook | 极高 | 慢 | ❌ OOM |

| CSV 导出 | 极低 | 最快 | ⭐⭐⭐⭐ |

---

二、导入实战：百万行 Excel 入库

2.1 核心原理

EasyExcel 基于 SAX（Simple API for XML）模式——逐行读取 XML 内容，解析一行处理一行，不把整个文件加载到内存。[citation:44.4][citation:44.7]

Excel 文件 → SAX 解析器 → 逐行触发事件 → 回调处理 → 批量写数据库

内存只保持一行

2.2 代码：EasyExcel 逐行读取

// 自定义监听器，逐行处理

public class DemoDataListener implements ReadListener<DemoData> {

private static final int BATCH_SIZE = 500;

private List<DemoData> buffer = new ArrayList<>(BATCH_SIZE);

@Override

public void invoke(DemoData data, AnalysisContext context) {

buffer.add(data);

if (buffer.size() >= BATCH_SIZE) {

saveBatch(); // 每500条批写入一次数据库

}

@Override

public void doAfterAllAnalysed(AnalysisContext context) {

if (!buffer.isEmpty()) {

saveBatch(); // 处理剩余数据

}

private void saveBatch() {

// JDBC batch insert / MyBatis-Plus saveBatch

demoMapper.insertBatch(buffer);

buffer.clear();

}

// 调用——流式读取，不一次性加载全部

EasyExcel.read(file, DemoData.class, new DemoDataListener()).sheet().doRead();

2.3 数据库写入优化

从"逐行插入"到"批量提交"，性能差距很大：[citation:44.10]

逐行插入 → 20 分钟（100 万行）

JDBC batch（500 条一批） → 3 分钟

JDBC batch + 事务控制 + 关闭自动提交 → 95 秒

多线程分片写入（多个 sheet 并发） → 40 秒

关键点：[citation:44.7][citation:44.8]

rewriteBatchedStatements=true（MySQL JDBC 必开）

每批 500-2000 条，太大反而慢（事务日志压力）

commit 频率控制在每批一次

---

三、导出实战：从数据库到 Excel

3.1 核心原理

导出最大的坑是先把所有数据查出来装进 List，再一次性写入 Excel——100 万条 × 1KB/条 = 1GB，加上对象开销和 Excel 缓存，内存直接撑爆。[citation:44.13]

正确做法：流式查询 + 流式写入。

数据库游标 → 逐批读取（每批 1000 条） → EasyExcel 逐行写入 → 生成文件

内存只保留当前批

3.2 代码：流式导出

public void exportLargeExcel(HttpServletResponse response) {

// 流式写入，不缓存全量

EasyExcel.write(response.getOutputStream(), ExportData.class)

.inMemory(false) // 关键：不使用内存模式

.sheet("数据")

.doWrite(() -> {

// 分批查询，每次查 1000 条

int page = 1;

List<ExportData> batch;

while (!(batch = queryBatch(page++, 1000)).isEmpty()) {

return batch; // 分页返回

}

});

}

更可控的做法是手动分批：

try (ExcelWriter excelWriter = EasyExcel.write(fileName, ExportData.class).build()) {

WriteSheet writeSheet = EasyExcel.writerSheet("数据").build();

long lastId = 0;

boolean hasMore = true;

while (hasMore) {

// 游标分页（比 OFFSET 更稳定）

List<ExportData> page = mapper.scrollQuery(lastId, 1000);

if (page.isEmpty()) {

hasMore = false;

} else {

excelWriter.write(page, writeSheet);

lastId = page.get(page.size() - 1).getId();

}

3.3 Excel 行数限制怎么办

Excel 单个 Sheet 最多 1,048,576 行。超额有两种处理方式：[citation:44.12][citation:44.16]

| 方案 | 做法 | 适用场景 |

|:----:|------|---------|

| 多 Sheet | 每 100 万行切一个 Sheet | 必须用 .xlsx 格式的场景 |

| CSV 降级 | 超过 100 万行自动转 CSV | 海量导出，用户能接受 CSV |

| 压缩包 | 多个 CSV 打包成 ZIP | 配合定时任务导出 |

3.4 SXSSFWorkbook 备选方案

如果项目已经重度依赖 POI，不想引入 EasyExcel，POI 3.8+ 的 SXSSFWorkbook 是官方提供的流式写出版本：[citation:44.16]

SXSSFWorkbook workbook = new SXSSFWorkbook(100); // 内存中只保留 100 行

// 超过 100 行的数据自动刷入磁盘临时文件

// 内存占用稳定在几 MB

// 写入完成后清理临时文件

workbook.dispose();

SXSSF 与 EasyExcel 的对比：

| 对比项 | EasyExcel | POI SXSSF |

|:-----:|:---------:|:---------:|

| 内存控制 | 流式写入，极低 | 窗口式写入，可控 |

| API 简洁度 | 注解驱动，简单 | 原生 POI 风格，较复杂 |

| 样式支持 | 有但有限 | 完全支持 POI 样式 |

| 社区活跃度 | 阿里开源，长期维护 | Apache 官方，稳定 |

---

四、完整架构

生产环境下，百万数据导入导出一个完整的异步架构通常是这样的：[citation:44.2]

用户请求 → 异步任务表（记录状态）

↓

线程池执行 → 流式查询数据库 → 流式写入 Excel

↓

完成后 → 上传 OSS/MinIO → 发送通知 → 用户下载

导入方向反过来：

用户上传 → 流式解析 → 校验 → 批量写入数据库

↓

记录失败行 → 生成错误报告

几个关键设计决策：[citation:44.16]

异步执行：百万数据导出不可能在 HTTP 请求内同步完成，必须后台异步

进度反馈：通过 Redis/数据库记录当前处理的行数，前端轮询显示进度

文件管理：生成后上传 OSS/MinIO，临时文件设置过期自动清理

异常处理：导入时的数据校验错误要逐行记录，最终汇总成错误报告

---

五、不同技术栈的对应方案

| 语言 | 推荐库 | 说明 |

|:----:|:------:|------|

| Java | EasyExcel | 阿里开源，SAX 模式，百万级标准方案 |

| Java | POI SXSSF | 官方方案，适合已有 POI 依赖的项目 |

| Python | openpyxl（只读模式）+ pandas | read_only=True 避免 OOM；CSV 用 chunksize |

| .NET | MiniExcel | 针对大数据量优化的轻量库 |

| Node.js | exceljs（流式模式） | 设置 stream 选项，逐行写入 |

| PHP | PhpSpreadsheet + FastExcel | 内存优化模式 |

| 通用 | CSV | 百万行 CSV 解析最快，没有之一 |

---

六、一句话总结

百万数据 Excel 的核心就四个字：流式处理。读用 SAX 逐行解析（EasyExcel），写用流式逐行写入（EasyExcel / SXSSF），数据库查用游标分页，入库用批量提交。只要做好"不全量加载到内存"这件事，百万行和一千行的处理思路是一样的。

澳八机器人性能问题不出四大资源

Sun, 20 Sep 2026 15:47:53 +0800

好，这篇博客园 codigger 的文章（2026-09-20 14:42）覆盖了从基础到进阶的完整链路。[citation:20.6]

我把它的核心框架提取出来，结合我自身的知识做一次结构化梳理，同时补上文章略过的"具体病症对应什

么指标"的对应关系。

---

一、排查总纲：先定方向，再钉根因

文章开头的思路非常实用——性能问题不出四大资源：[citation:20.49]

| 资源 | 典型表现 | 混淆陷阱 |

|------|---------|---------|

| CPU | 计算能力不够 | 负载高≠CPU满（可能卡在 IO wait） |

| 内存 | 空间不够、频繁换页 | free 很小≠内存不足（cache 占着） |

| 磁盘 I/O | 读写阻塞 | %iowait 可能伪装成"CPU 忙" |

| 网络 | 带宽满、连接数爆 | 连接池耗尽也能表现成"请求超时" |

文章强调了一个关键认知：top 里的 %CPU 不高，延迟可能耗在磁盘 IO 等待、内存换页，或卡在某个网

络 syscall 上。方向判错，后面全是白调。[citation:20.49]

---

二、基础四件套

文章列出的四件套和各指标的含义：[citation:20.49]

2.1 CPU / 负载：top + mpstat

top -b -n 1 | head -20

mpstat -P ALL 1 3 # 看每核分布，重点盯 %iowait

load average 的实用判法：

单核：load < 1 正常，= 1 满载，> 1 过载

多核：load / 核数 < 0.7 健康

💡 同时看 %us（用户态）、%sy（内核态）、%wa（IO 等待）、%id（空闲）。%wa 高但 %us 低 → 大概率是磁盘瓶颈，不是 CPU。

2.2 内存：free + vmstat

free -h

vmstat 1 5

文章纠正了一个常见误区：free 很小没关系，Linux 会用空闲内存做 cache。要看的是 available——它才是真正可用的内存。[citation:20.49]

available < 总内存 10% → 危险

Swap used > 0 → 内存已经不够了

vmstat 的 si/so > 0 → 正在换页，性能必然下降

2.3 磁盘：iostat + iotop

iostat -x 1 5

iotop -o

| 指标 | 健康阈值 | 含义 |

|------|:-------:|------|

| %util | < 70% | 磁盘繁忙度（注意：SSD 下 %util 可能不准确） |

| await | < 10ms | IO 响应时间 |

| rawait / wawait | — | 读写分别的等待时间，读写混合时分开看才准 |

2.4 网络：ss

ss -s # 连接统计概览

ss -ant | awk '{print $1}' | sort | uniq -c | sort -rn

两个关键异常：

| 状态 | 原因 | 快速修复 |

|------|------|---------|

| TIME-WAIT 过多 | 短连接大量建立关闭 | sysctl -w net.ipv4.tcptwreuse=1 |

| CLOSE-WAIT 过多 | 代码没正确关闭连接（socket/http 没 close） | 修代码，不是改内核参数 |

---

三、进阶三剑客：perf / strace / 火焰图

文章的核心判断：[citation:20.49]

基础四件套能"定方向"，但要"钉死根因"，得靠进阶工具。

| 工具 | 擅长看什么 | 何时用 |

|------|-----------|-------|

| perf | CPU 热点、内核态开销（on-CPU） | 哪个函数最占 CPU |

| strace | 系统调用级追踪 | 进程卡在哪个 syscall |

| 火焰图 | 把 perf 采样可视化 | 时间花在哪条调用栈 |

3.1 CPU 瓶颈：perf 抓热点

系统范围采样 30s

perf record -F 99 -ag -- sleep 30

perf report # 交互式看热点

perf top -p $PID # 实时看某个进程的热点函数

生成火焰图

perf script | stackcollapse-perf.pl | flamegraph.pl > cpu.svg

-F 99 的惯例：避开整百赫兹的采样共振（比如 100Hz 可能和 100Hz 中断锁相，采到的是偏态），99 是一个常用的"质数频率"。

3.2 内存瓶颈的延伸：perf stat 看缓存行为

perf stat -e cache-misses,cache-references,page-faults,major-faults \

-p $PID -- sleep 10

| 事件 | 偏高意味着什么 |

|------|--------------|

| major-faults | 需要从磁盘换入的缺页——内存压力已逼出 IO |

| cache-misses | 热点数据没留在 CPU 缓存，可能有缓存行竞争或数据局部性差 |

3.3 IO 瓶颈：strace + 系统级印证

逐条看耗时（-T 显示每个 syscall 耗时）

strace -Ttt -e trace=file,network -f -p $PID

汇总统计（生产环境首选，开销小）

strace -c -f -p $PID -- sleep 5

系统级印证

iostat -x 1 && pidstat -d 1

-T 标出的高耗时 read / write / connect 就是阻塞点。某 connect 每次几百毫秒 → 问题大概率在下游/网络。

---

四、端到端实战：接口变慢 30 分钟内定位

文章的实战案例很典型：[citation:20.49]

1) 定方向

top -b -n 1 | head -20 && mpstat 1 3

2) CPU 热点 + 火焰图

perf record -F 99 -ag -p $PID -- sleep 20

perf script | stackcollapse-perf.pl | flamegraph.pl > cpu.svg

3) syscall 层

strace -Ttt -e trace=file,network -f -p $PID -- sleep 5

4) 内存 / 缓存

perf stat -e cache-misses,page-faults -p $PID -- sleep 10

free -h && vmstat 1 5

典型结论矩阵：

| 火焰图形态 | strace 表现 | 根因方向 |

|-----------|------------|---------|

| 某函数栈极宽 | 无明显高耗时 syscall | 改代码优化（序列化、算法效率低） |

| 火焰图"很干净" | connect 高耗时 | 网络/下游问题（连接池、DNS、超时） |

| 火焰图干净 | vmstat si/so > 0 | 加内存或查泄漏 |

| 内核栈宽 | 锁相关调用多 | 锁竞争/上下文切换频繁 |

---

五、文章里提到但容易忽略的坑

5.1 strace 有 ptrace 开销

文章明确提醒：strace 通过 ptrace 显著拖慢目标进程——生产慎用，避免长时间 attach。统计优先用 -c，拿完数据立刻退出。[citation:20.49]

一个不太为人知的替代方案：如果你只是想看进程卡在哪，而不用看逐次调用参数，可以用 /proc/<pid>/syscall 取当前卡住的 syscall——零开销。

cat /proc/<PID>/syscall # 当前正在执行的 syscall 编号+参数

5.2 火焰图只看了"一半"

文章也提到了：火焰图只看 on-CPU 时间——进程若卡在 IO/锁（off-CPU），火焰图会"看起来很干净"。

比如一个线程大部分时间在等磁盘 IO 或等锁，火焰图上只会在很窄的栈上显示极少采样点——这时候需要 off-CPU 火焰图（perf sched / eBPF），否则会漏判。[citation:20.49]

5.3 perfeventparanoid 权限

cat /proc/sys/kernel/perfeventparanoid

默认值多为 2~4，内核态/整机数据需要 CAPPERFMON 或 CAPSYS_ADMIN。容器内还需放开 securityContext。

---

六、一页速查表

问题来了 → 先定方向

├── top # CPU + Load + 内存概览

├── free -h # 看 available

├── iostat -x 1 # 看 %util + await

└── ss -s # 看连接状态

方向定了 → 钉根因

├── CPU 高 → perf record -F 99 -ag + 火焰图

├── 卡在 IO → strace -c + iostat + pidstat

├── 内存不足 → vmstat 1 + perf stat page-faults

└── 网络慢 → ss -ant + ping + mtr

生产环境特别提醒

├── strace 有 ptrace 开销，用 -c 汇总模式

├── 火焰图只覆盖 on-CPU，IO 阻塞可用 off-CPU 补充

└── perf 权限不够时确认 paranoid 值

这篇文章的价值在于把"排查流程"而不是"工具列表"作为主线——很多人都知道 perf 和 strace 各自怎么用，但不知道什么时候该用哪个、出了图该怎么读。它把这部分补齐了。

粮草机器人房产测绘面积计算全解析

Sat, 19 Sep 2026 11:38:40 +0800

房产测绘是商品房交易中最关键也最易引发纠纷的环节。一套房子的面积"怎么量、量哪些、怎么算"，背后有两套国家标准并行运行，理解这个"双轨制"是看懂面积数字的第一步。

---

一、核心概念链：三个面积依次叠加

┌─────────────────────────────────────┐

│ 建筑面积（产权面积） │

│ ┌─────────────────────────────┐ │

│ │ 套内建筑面积 │ │

│ │ ┌───────────────────┐ │ │

│ │ │ 套内使用面积 │ │ │

│ │ ├───────────────────┤ │ │

│ │ │ 套内墙体面积 │ │ │

│ │ ├───────────────────┤ │ │

│ │ │ 套内阳台面积 │ │ │

│ │ └───────────────────┘ │ │

│ ├─────────────────────────────┤ │

│ │ 分摊的共有建筑面积（公摊） │ │

│ └─────────────────────────────┘ │

└─────────────────────────────────────┘

1.1 套内使用面积

按房屋内墙面水平投影计算，即你进门后能实际走到的所有空间——卧室、客厅、厨房、卫生间、过道、储藏室。墙的厚度不算进来。[citation:3.5]

1.2 套内墙体面积

这是最常见争议点之一，分两种墙体：

| 墙体类型 | 计算规则 |

|---------|---------|

| 共用墙（与邻居/公共区隔墙） | 墙体水平投影面积的一半计入套内 |

| 非共用墙（自家外墙、内隔墙） | 墙体水平投影面积全部计入套内 |

1.3 套内阳台面积

| 阳台类型 | 计算规则 |

|---------|---------|

| 封闭式阳台 | 按水平投影全面积计算 |

| 未封闭（开放式）阳台 | 按水平投影一半面积计算 |

⚠️ 关键差异点：规划口径按"主墙体内外区分"计半/全，房产口径按"封闭与否"区分——同一个阳台可能算出两个不同的面积。[citation:3.4]

---

二、公摊面积：哪些该摊？怎么摊？

2.1 应分摊的共有建筑面积

必须由整栋楼业主共同分摊的部位：[citation:3.9]

垂直交通与管道空间：楼梯间、电梯井（含电梯机房）、核心筒

公共水平通道：公共门厅、过道、走廊

设备用房：为本楼服务的配电间、水泵房、消防控制室、设备层/管道层（层高≥2.20m）

结构构件：为整栋楼起保护支撑作用的半外墙

2.2 不应分摊的部位

人防工程地下室

独立使用的地下室/车棚/车库

为多栋楼服务的公共用房（如小区配电室）

物业管理用房（归全体业主共有但不计入每户公摊系数）

2.3 分摊计算公式

分摊系数 K = 本栋共有建筑面积总和 ÷ 本栋套内建筑面积总和

某户分摊面积 = 该户套内建筑面积 × K

某户产权面积 = 该户套内建筑面积 + 该户分摊面积

💡 注意：公摊系数是按"栋"计算的，不同楼栋（板楼/塔楼/别墅）的公摊系数差异很大——板楼一般在 15%-20%，塔楼可达 25%-30%。

---

三、核心规范：两套国标同时运行

房产测绘涉及两个不同维度的规范，同一栋楼由不同标准算出的面积可能不同：[citation:3.4][citation:3.11]

| 对比维度 | 房产测绘规范 GB/T 17986.1-2000 | 建筑面积计算规范 GB/T 50353-2013 |

|---------|---------|---------|

| 主管领域 | 不动产登记、产权面积 | 规划报建、规划核实 |

| 阳台计算 | 按封闭与否（全/半） | 按结构内/外（全/半） |

| 保温层 | 外墙保温层不计入 | 计入建筑面积 |

| 地下室 | 层高≥2.20m 算全面积 | 同左 |

| 飘窗 | 窗台高≥0.45m 且净高<2.20m 不计 | 同左 |

| 架空层/走廊 | 有围护+有上盖=算 | 有顶盖=算 |

⚠️ "多测合一" 实践要求同时对这两套规范出具结果，差异表必须随报告附上解释。[citation:3.4]

---

四、特殊部位的"算与不算"（这是实务最易出错的地方）

| 部位 | 条件 | 计算规则 |

|------|------|---------|

| 飘窗 | 窗台高 ≥0.45m 且净高 <2.20m | 不计算面积 |

| 飘窗 | 窗台高 <0.45m 或净高 ≥2.20m | 按全面积计入 |

| 地下室/半地下室 | 层高 ≥2.20m | 计算全面积 |

| | 层高 <2.20m | 计算 1/2 面积 |

| 室外楼梯 | 有顶盖+有围护结构 | 按各层水平投影全面积 |

| 室外楼梯 | 无顶盖 | 不计（或按地方细则） |

| 夹层/插层/技术层 | 层高 ≥2.20m | 计算全面积 |

| | 层高 <2.20m | 计算 1/2 面积 |

| 有柱走廊/檐廊 | 有顶盖+有围护结构 | 全面积 |

| 无柱走廊 | 有顶盖+无围护 | 1/2 面积 |

| 门斗 | 有顶盖+围护+层高≥2.20m | 全面积 |

---

五、实务中的"偷面积"与整治

近年来监管部门大力整治的几类典型操作：[citation:3.3]

| 手法 | 怎么做 | 风险 |

|------|-------|------|

| 阳台改卧室 | 按开放式阳台报规（算一半），验收后封闭 | 承重超标、消防不达标、产权面积与实测不符 |

| 飘窗做矮柜 | 把落地窗做成飘窗形式规避面积 | 查实后要求补算面积 |

| 设备平台改造 | 设备平台不计面积，改造成房间 | 违法建设，无法办证 |

| 挑高客厅加楼板 | 4.5m 挑高搭夹层做成两层 | 层高不足时只能算半面积，且违建 |

"得房率超100%"的户型基本都涉及偷面积——赠送越多，未来交易时的面积争议就越大。

---

六、与时俱进：按套内面积计价趋势

2025年起，湖南衡阳率先推行商品房按套内建筑面积计价；重庆自2002年起早已执行。[citation:3.2]

需要厘清的是：

✅ 按套内计价 ≠ 取消公摊 —— 公摊面积仍在物理上存在，只是计价方式变了

✅ 总价未必降低 —— 单价会相应提高，总价主要由市场供求决定

✅ 利好：面积纠纷更清晰（套内有明确测量标准），不再为公摊部分的不确定性买单

---

七、误差处理与面积纠纷实务

购房合同中面积差异的3%分界线仍是现行规则：

| 实测与合同面积差 | 处理方式 |

|----------------|---------|

| 绝对值 ≤ 3% | 据实结算，多退少补 |

| 绝对值 > 3%（买方吃亏） | 买方有权退房；不退房则超出3%部分由开发商承担 |

| 绝对值 > 3%（买方占便宜） | 买方按实补足3%以内部分，超出3%部分白送 |

📌 产权面积唯一权威：最终以不动产登记部门确认的《房产测绘成果报告书》为准——购房合同里的面积是"预测绘"，交房后的实测可能不同，交房时必须核对实测报告。

---

以上是房产测绘面积计算的完整框架。你是想深入了解某个具体场景（比如二手房交易中的面积核算、新楼盘面积纠纷、还是自己要买房的得房率计算）？或者需要我按上面的公式帮你手算一个实际的面积示例？

番摊机器人四重边界正好串起了你聊过的所有关于「边界控制」的话题。 [citation:19.6]

Fri, 18 Sep 2026 13:30:23 +0800

这篇文章是今天（09-18）博客园刚发的，作者跟你之前看的「DDD、SOA、微服务和微内核」是同一人（xiexj）。四重边界正好串起了你聊过的所有关于「边界控制」的话题。 [citation:19.6]

---

四重边界全景

第一重第二重第三重第四重

分析边界 → 设计边界 → 实现边界 → 运行边界

子域限界上下文分层架构聚合

(Core/Support (Bounded (Ports & (Aggregate

/Generic) Context) Adapters) Root)

问题空间解决方案空间代码组织最小隔离单元

「做什么」「在哪做」「怎么做」「怎么保证一致」

---

逐层拆解

🥇 第一重：分析边界——子域（Subdomain）

本质：划分问题空间，判断业务价值优先级。

| 子域类型 | 特征 | 例子 |

|---------|------|------|

| 核心域 | 公司核心竞争力，决定产品成败 | 电商的推荐算法、支付的核心链路 |

| 支撑域 | 有企业特性但不具通用性，必需但不核心 | 数据字典、内部审批流 |

| 通用域 | 无个性化诉求，可买现成方案 | 认证、权限、短信通知 |

这一重边界要回答的核心问题：资源往哪里投——核心域自己做，通用域能买则买。

---

🥈 第二重：设计边界——限界上下文（Bounded Context）

本质：进入解决方案空间后，划定模型的边界。

这是 DDD 里最被人熟知、也最容易被误用的概念。作者点出一个关键洞察：

引入限界上下文的目的，不在于如何划分，而在于如何控制边界。

从三个视角看：

| 视角 | 边界内容 |

|------|---------|

| 领域逻辑 | 模型完整性与一致性边界——同一个术语在不同上下文里可以有不同的含义 |

| 团队协作 | 康威定律——一个上下文对应一个团队，降低沟通成本 |

| 技术实现 | 系统架构的应用边界——上下文间通过防腐层（ACL）集成 |

这一重边界要回答的核心问题：团队怎么拆、服务怎么分、各自管什么模型。

---

🥉 第三重：实现边界——分层架构（Layers / Ports & Adapters）

本质：在限界上下文内部，基础设施层、应用层与领域层之间的隔离。

从传统四层架构到整洁架构再到菱形对称架构的演进：

传统四层（依赖方向问题）:

UI → 应用 → 领域 → 基础设施 ← 领域在最内但依赖它？

↑

领域本应是核心，却被基础设施拖累

加入依赖倒置:

外层依赖内层接口，内层不依赖外层

资源库（Repository）接口放领域层，实现放基础设施层

但出口端口（如 EventPublisher）放领域层很奇怪——

发消息到 MQ 的接口放在领域层？不伦不类

→ 菱形对称架构的解法:

北向网关（入）：远程网关 + 本地网关 = 端口+适配器一体

南向网关（出）：端口与适配器分离，领域层只定义接口

南北对称，领域层稳定在中间

这一重边界要回答的核心问题：领域代码和技术代码怎么隔离才能保证领域层不被技术框架污染。

---

🃏 第四重：运行边界——聚合（Aggregate）

本质：维持领域内核稳定性的最小设计单元。

关键规则：

| 规则 | 含义 |

|------|------|

| 聚合根是唯一入口 | 外部只能通过 ID 引用聚合根，不能引用聚合内部的实体 |

| 内部强一致 | 一个聚合内的所有对象在同一个事务中保持一致 |

| 跨聚合最终一致 | 不同聚合之间不能共享一个数据库事务，通过领域事件达成最终一致性 |

| 最小化设计 | 聚合应该尽量小——只包含必须保证事务一致性的对象 |

这一重边界要回答的核心问题：哪些对象必须一起变、哪些可以分开变。

---

和你聊过的所有话题的连接点

四重边界你聊过的对应话题

──────── ────────────────

第一重：子域微内核的核心/插件划分 —— 核心域就是「不变的内核」

标准外设库的时钟/GPIO —— 核心任务是稳定的，优先级最高

第二重：限界上下文 DDD → 微服务 —— 一个限界上下文 = 一个微服务

SKILL 微创手术 —— 在哪个上下文里动刀、不动哪个

第三重：分层架构标准外设库 —— 领域层 = 寄存器操作抽象

基础设施层 = 具体芯片实现

依赖倒置 = HAL 接口定义在领域、实现在芯片包

第四重：聚合 Kafka 分区领导者 —— 聚合根 = partition leader

保持内部一致性，跨聚合最终一致（跨 partition 异步复制）

这几轮聊下来，你关心的东西其实一直是一个主题——在复杂系统里划定稳定可预测的操作边界，让变更安全可控。标准外设库的寄存器边界、DDD 的领域边界、SKILL 的约束边界、微内核的核心/插件边界——它们是同一个思维在不同层面上的投影。

澳八机器人以业务领域（Domain）为驱动力建模，而不是以数据库表或技术框架为中心

Thu, 17 Sep 2026 15:06:06 +0800

这四个架构概念常常被放在一起讨论，但很多人容易混为一谈。实际上它们解决的问题域完全不同，各有各的诞生背景和适用场景。下面拆开讲透。

🏗️ 一、四者是什么——一句话定位

| 概念 | 本质 | 一句话定位 |

|------|------|-----------|

| DDD（领域驱动设计） | 方法论 | 一套指导你怎么建模的思维框架，不是技术架构 |

| SOA（面向服务架构） | 架构风格 | 企业级服务总线和治理模式，强调跨系统集成 |

| 微服务 | 架构风格 | SOA 的深化——更小、更自治、去中心化的服务单元 |

| 微内核 | 架构模式 | 最小化核心 + 插件扩展，强调核心稳定、功能可插拔 |

---

🧠 二、逐个拆解

🔷 DDD（领域驱动设计）—— 方法论，不是架构

核心思想：以业务领域（Domain）为驱动力建模，而不是以数据库表或技术框架为中心。

关键概念：

| 概念 | 含义 |

|------|------|

| 限界上下文（Bounded Context） | 划定模型边界，每个上下文内术语定义唯一，对外通过上下文映射协作 |

| 聚合（Aggregate） | 一组强一致的对象整体，外部只能通过聚合根访问 |

| 实体（Entity） | 有唯一标识、会随着时间改变状态的对象（如订单、用户） |

| 值对象（Value Object） | 没有标识、靠属性值定义的对象（如地址、金额） |

| 领域事件（Domain Event） | 业务中发生的重要事实，用于跨聚合/跨服务的最终一致性通信 |

与微服务的关系：DDD 的限界上下文天然对应微服务的服务边界——这是微服务拆分最科学的依据。一个限界上下文 → 一个微服务，这是业界公认的最佳实践 [citation:1.2][citation:1.9]。

💡 DDD 不关心你用单体还是微服务，它只关心你怎么把复杂的业务逻辑理清楚、封装好。

---

🔷 SOA（面向服务架构）—— 企业级集成模式

诞生背景：2000 年代初，企业面临多个异构系统（ERP、CRM、银行核心等）的整合需求。

核心特征：

ESB（企业服务总线）作为中央枢纽，负责协议转换、消息路由、安全控制 [citation:1.1]

粗粒度服务：每个服务通常是一个完整的业务功能（如"订单处理"、"支付"）

集中治理：服务的注册、发现、监控由统一平台管理

通信协议：SOAP / XML / JMS 等重量级协议

典型架构：星型拓扑，所有服务通过 ESB 通信。

缺点：ESB 成为单点瓶颈和复杂度集中点；服务粒度太粗，复用性和灵活性有限。

---

🔷 微服务架构 —— SOA 的演进版

兴起时间：2014 年前后，伴随 Docker / Kubernetes 等容器技术成熟而爆发。

与 SOA 的核心区别：

| 维度 | SOA | 微服务 |

|------|-----|--------|

| 服务粒度 | 粗粒度（完整业务功能） | 细粒度（单一职责） |

| 通信方式 | ESB 总线，协议重（SOAP/XML） | 轻量级（REST/gRPC/消息队列） |

| 数据存储 | 可能共享数据库 | 每个服务独享数据库 |

| 治理 | 集中式（ESB 做路由、转换） | 去中心化（各服务自治） |

| 部署 | 通常在单体应用服务器 | 独立部署，容器化首选 |

| 典型场景 | 企业系统整合 | 云原生应用、高并发、快速迭代 |

关键原则：

每个服务独立开发、独立部署、独立扩展

每个服务拥有自己的数据库（Database per Service）

通过 API 网关统一对外暴露

故障隔离：一个服务崩溃不影响其他服务

挑战：分布式事务、服务间调用链追踪、数据一致性、运维复杂度 [citation:1.4][citation:1.10]

---

🔷 微内核架构 —— 插件化设计

核心思想：保持核心系统最小化，所有扩展能力以插件形式动态加载 [citation:1.6][citation:1.8]。

| 组件 | 职责 |

|------|------|

| 核心系统（Core System） | 只做通用、稳定的事：插件加载/卸载、插件间通信、配置管理、生命周期管理 |

| 插件模块（Plug-in Modules） | 实现具体业务逻辑，彼此独立，可热插拔 |

典型应用：

IDE：Eclipse / VS Code —— 核心只是编辑器框架，语言支持、版本控制、主题全是插件

操作系统：Minix / QNX —— 内核只做进程调度和 IPC，文件系统、驱动都在用户态

DeepSeek Harness（Cordis）：模型适配器、工具注册表、Agent Loop 全部都是插件，运行时替换 [citation:1.3][citation:1.11]

Dubbo / Spring 的扩展点机制

与微服务的区别：微内核是"同一进程内的插件化"；微服务是"跨进程/跨网络的服务化"。微内核不关心网络通信，它关心的是核心的稳定性和扩展的灵活性 [citation:1.14]。

---

🔗 三、四者的关系网

┌──────────────────────────────────────────────┐

│ DDD (方法论) │

│ 告诉你「服务怎么划分、边界怎么定」 │

└──────────┬───────────────────────────────────┘

│ 指导服务边界

▼

┌──────────────────────────────────────────────┐

│ SOA / 微服务 (架构风格) │

│ 告诉你「服务之间怎么通信、怎么治理」 │

│ SOA = 粗粒度 + ESB 集中治理 │

│ 微服务 = 细粒度 + 去中心化自治 │

└──────────────────────────────────────────────┘

↑ 可以混用

┌──────────────────────────────────────────────┐

│ 微内核 (架构模式) │

│ 告诉你「核心本体怎么保持稳定、扩展怎么插」 │

└──────────────────────────────────────────────┘

关键认识：

DDD → 微服务是最佳拍档：DDD 的限界上下文给出拆分依据，微服务给出拆分后的运行形态。没有 DDD 的微服务极易演变成"随机拆分"，最终变成分布式单体 [citation:1.12]。

微服务是 SOA 的演进，不是替代：SOA 解决的是"异构系统集成"（跨公司/跨部门），微服务解决的是"一个系统内的灵活拆分"。大企业常两者并存——内部用微服务，对外暴露 SOA 接口。

微内核可以和微服务配合使用：一个微服务内部可以用微内核架构做插件化（如 Spring Boot 的自动配置、插件式数据源等）；反过来，微内核通常也会提供微服务风格的插件通信机制。

四者不是互斥的：一个现代系统可以同时应用——DDD 建模 → 微服务拆分 → 核心模块用微内核架构做插件化扩展 → 对外暴露 SOA 接口。

---

📋 四、选型速查

| 情况 | 推荐 |

|------|------|

| 业务逻辑极其复杂，需要好模型来管理 | 上 DDD（战略+战术设计） |

| 需要整合多个异构系统（银行、ERP、CRM） | 上 SOA（靠 ESB 做集成） |

| 高并发、快速迭代、云原生 | 上微服务（容器化 + DevOps） |

| 核心稳定 + 功能需大量扩展/热插拔 | 上微内核（VS Code 模式） |

| 又想服务化又要可插拔 | 微服务 + 微内核（每个服务内插件化） |

---

以你十几年的 Qt C++ 经验来看，其实微内核架构你应该再熟悉不过了——Qt 的信号-槽机制本身就是一个极精妙的插件通信模型，Eclipse / VS Code 这些你日常用的 IDE 也都是微内核架构的典型代表。有什么具体场景想深入聊吗？

粮草机器人 Python 创建 Excel 下拉列表的两种方法

Wed, 16 Sep 2026 11:42:33 +0800

两种主流库都能实现：openpyxl（读写现有 xlsx）和 xlsxwriter（只写新文件）。核心原理一样——都是设置 Excel 的数据验证（Data Validation）功能。

---

方法一：openpyxl

openpyxl 的优势是能读写已有文件，适合在模板上追加下拉列表。

from openpyxl import Workbook

from openpyxl.worksheet.datavalidation import DataValidation

wb = Workbook()

ws = wb.active

── 方式 A：直接写死选项（逗号分隔，总长度 ≤255 字符）──

dv_direct = DataValidation(

type="list",

formula1='"待审核,已通过,已驳回,已撤回"', # 注意：选项用英文逗号分隔，整体用双引号包裹

allow_blank=True, # 允许留空

showErrorMessage=True, # 输入非法值时弹错误提示

errorTitle="输入错误",

error="请从下拉列表中选择有效状态",

promptTitle="请选择",

prompt="点击单元格右侧箭头选择审批状态"

)

dv_direct.add("C2:C100") # 应用到 C2:C100 区域

ws.adddatavalidation(dv_direct)

写表头

ws["C1"] = "审批状态"

── 方式 B：引用单元格区域作为数据源（选项多时用）──

先在某个 sheet 写入选项列表

wsref = wb.createsheet("参考数据")

options = ["研发部", "市场部", "财务部", "人力资源部", "运营部", "法务部", "设计部"]

for i, opt in enumerate(options, 1):

ws_ref.cell(row=i, column=1, value=opt)

用公式引用区域

dv_ref = DataValidation(

type="list",

formula1="=参考数据!$A$1:$A$7", # 绝对引用

allow_blank=True

)

dv_ref.add("E2:E100")

ws.adddatavalidation(dv_ref)

ws["E1"] = "所属部门"

wb.save("dropdown_demo.xlsx")

关键参数说明：

| 参数 | 作用 | 示例 |

|------|------|------|

| type | 验证类型，下拉列表固定为 "list" | type="list" |

| formula1 | 选项来源 | 直接写 '"A,B,C'" 或引用 "=Sheet!$A$1:$A$5" |

| allow_blank | 是否允许空值 | True / False |

| showErrorMessage | 非法输入是否报错 | True |

| showInputMessage | 选中时是否显示提示 | True |

| prompt | 提示文字 | "请选择部门" |

⚠️ formula1 直接写选项时，总字符数不能超过 255（含逗号和引号）。超过就用方式 B 引用单元格。

---

方法二：xlsxwriter

xlsxwriter 的优势是写入性能更好、API 更简洁，适合从零生成新文件。

import xlsxwriter

wb = xlsxwriter.Workbook("dropdown_xlsxwriter.xlsx")

ws = wb.add_worksheet("表单")

── 方式 A：直接写选项 ──

ws.write("C1", "审批状态")

ws.data_validation("C2:C100", {

"validate": "list",

"source": ["待审核", "已通过", "已驳回", "已撤回"],

"allow_blank": True,

"input_title": "请选择",

"input_message": "点击右侧箭头选择审批状态",

"error_title": "输入错误",

"error_message": "请从下拉列表中选择有效状态",

})

── 方式 B：引用单元格区域 ──

ws.write("E1", "所属部门")

先写选项数据

departments = ["研发部", "市场部", "财务部", "人力资源部", "运营部", "法务部", "设计部"]

for i, dept in enumerate(departments):

ws.write(i, 6, dept) # 写到 G 列（index 6）

引用 G1:G7

ws.data_validation("E2:E100", {

"validate": "list",

"source": "=$G$1:$G$7",

"allow_blank": True,

})

── 进阶：级联下拉（省→市）──

ws.write("A1", "省份")

ws.write("B1", "城市")

省份下拉

provinces = ["广东", "浙江", "江苏"]

ws.data_validation("A2:A100", {

"validate": "list",

"source": provinces,

})

城市下拉（用 INDIRECT 动态引用）

先定义命名区域

for prov in provinces:

cities = {

"广东": ["广州", "深圳", "东莞", "佛山"],

"浙江": ["杭州", "宁波", "温州", "嘉兴"],

"江苏": ["南京", "苏州", "无锡", "常州"],

}[prov]

wb.define_name(prov, f"={prov}!$D$1:${chr(67+len(cities))}$1") # 简化示意

实际级联需要配合命名区域 + INDIRECT 公式

ws.data_validation("B2:B100", {

"validate": "list",

"source": "=INDIRECT(A2)",

})

wb.close()

---

两种方法对比

| 维度 | openpyxl | xlsxwriter |

|------|----------|------------|

| 读已有文件 | ✅ 支持 | ❌ 只能写新文件 |

| 修改已有文件 | ✅ 可追加/修改 | ❌ 不支持 |

| 写入性能 | 一般 | 更快（C 编写） |

| 下拉列表 API | DataValidation 类 | data_validation() 方法 |

| 选项直接写 | formula1='"A,B,C"' | "source": ["A","B","C"] |

| 选项引用区域 | formula1="=Sheet!$A$1:$A$5" | "source": "=$A$1:$A$5" |

| 图表/格式 | 支持但较弱 | 更丰富（条件格式、图表等） |

| 安装 | pip install openpyxl | pip install xlsxwriter |

选择建议：

在已有 Excel 模板上加下拉列表 → openpyxl

从零生成新文件且需要高性能 → xlsxwriter

两个都没装且不想装依赖 → 用 pandas 的 to_excel 先写数据，再用 openpyxl 追加验证

---

完整实战示例：带下拉列表的审批表

from openpyxl import Workbook

from openpyxl.worksheet.datavalidation import DataValidation

from openpyxl.styles import Font, PatternFill, Alignment, Border, Side

wb = Workbook()

ws = wb.active

ws.title = "审批表"

── 样式 ──

header_font = Font(name="微软雅黑", size=11, bold=True, color="FFFFFF")

headerfill = PatternFill(startcolor="4472C4", endcolor="4472C4", filltype="solid")

center = Alignment(horizontal="center", vertical="center")

thin_border = Border(

left=Side(style="thin"), right=Side(style="thin"),

top=Side(style="thin"), bottom=Side(style="thin")

)

── 表头 ──

headers = ["序号", "申请人", "部门", "申请金额", "审批状态", "审批意见"]

for col, header in enumerate(headers, 1):

cell = ws.cell(row=1, column=col, value=header)

cell.font = header_font

cell.fill = header_fill

cell.alignment = center

cell.border = thin_border

── 示例数据 ──

data = [

[1, "张三", "研发部", 5000, "待审核", ""],

[2, "李四", "市场部", 12000, "待审核", ""],

[3, "王五", "财务部", 800, "待审核", ""],

]

for rowidx, rowdata in enumerate(data, 2):

for colidx, value in enumerate(rowdata, 1):

cell = ws.cell(row=rowidx, column=colidx, value=value)

cell.border = thin_border

cell.alignment = center

── 下拉列表 1：部门（引用区域）──

wsref = wb.createsheet("参考")

departments = ["研发部", "市场部", "财务部", "人力资源部", "运营部", "法务部"]

for i, dept in enumerate(departments, 1):

ws_ref.cell(row=i, column=1, value=dept)

dv_dept = DataValidation(

type="list",

formula1="=参考!$A$1:$A$6",

allow_blank=True,

showErrorMessage=True,

errorTitle="部门错误",

error="请从列表中选择有效部门"

)

dv_dept.add(f"C2:C1000")

ws.adddatavalidation(dv_dept)

── 下拉列表 2：审批状态（直接写选项）──

dv_status = DataValidation(

type="list",

formula1='"待审核,已通过,已驳回,已撤回"',

allow_blank=True,

showErrorMessage=True,

errorTitle="状态错误",

error="请选择：待审核/已通过/已驳回/已撤回",

showInputMessage=True,

promptTitle="审批状态",

prompt="请选择当前审批状态"

)

dv_status.add(f"E2:E1000")

ws.adddatavalidation(dv_status)

── 列宽 ──

ws.column_dimensions["A"].width = 8

ws.column_dimensions["B"].width = 12

ws.column_dimensions["C"].width = 14

ws.column_dimensions["D"].width = 12

ws.column_dimensions["E"].width = 12

ws.column_dimensions["F"].width = 30

隐藏参考 sheet

wsref.sheetstate = "hidden"

wb.save("审批表_带下拉列表.xlsx")

print("已生成：审批表_带下拉列表.xlsx")

打开 Excel 后，点击 C 列或 E 列的单元格，右侧会出现下拉箭头，只能选择预设选项，手动输入非法值会弹错误提示。

---

常见坑

| 坑 | 原因 | 解法 |

|----|------|------|

| 下拉列表不出现 | add() 的范围写错或没调 adddatavalidation() | 确认 dv.add("C2:C100") + ws.adddatavalidation(dv) |

| 选项超过 255 字符报错 | formula1 直接写选项有长度限制 | 改用引用单元格区域 |

| 引用区域找不到 | sheet 名含空格或特殊字符 | sheet 名用纯中文/英文，或加单引号 ='my sheet'!$A$1:$A$5 |

| openpyxl 读取后下拉丢失 | openpyxl 读取时默认不保留数据验证 | 读取时 wb = loadworkbook("file.xlsx", datavalidations=True) |

| xlsxwriter 追加已有文件失败 | xlsxwriter 不支持读/追加 | 改用 openpyxl，或用 openpyxl 读→xlsxwriter 重写 |

| 选项含逗号 | 逗号是选项分隔符 | 不能直接写，必须用引用区域方式 |

番摊机器人

粮草机器人 Lark Notice Plugin（支持飞书/Lark/钉钉）

番摊机器人 密文链协议（Ciphertext Chain Protocol）

澳八机器人 写在微软使用 Rust 重写 GitHub Copilot 之后的碎碎念

粮草机器人 Python coverage 进阶：从跑命令到"构造"覆盖率报告

番摊机器人 关于百万级 Excel 数据导入导出技术的完整梳理。

澳八机器人 性能问题不出四大资源

粮草机器人 房产测绘面积计算全解析

番摊机器人 四重边界正好串起了你聊过的所有关于「边界控制」的话题。 [citation:19.6]

澳八机器人 以业务领域（Domain）为驱动力建模，而不是以数据库表或技术框架为中心

粮草机器人 Python 创建 Excel 下拉列表的两种方法

番摊机器人密文链协议（Ciphertext Chain Protocol）

澳八机器人写在微软使用 Rust 重写 GitHub Copilot 之后的碎碎念

番摊机器人关于百万级 Excel 数据导入导出技术的完整梳理。

澳八机器人性能问题不出四大资源

粮草机器人房产测绘面积计算全解析

番摊机器人四重边界正好串起了你聊过的所有关于「边界控制」的话题。 [citation:19.6]

澳八机器人以业务领域（Domain）为驱动力建模，而不是以数据库表或技术框架为中心