Posts on Yison's Blog

AI 会自救吗？从云平台的视角看「停机悖论」

Sat, 02 May 2026 00:00:00 +0000

AI 会自救吗？从云平台的视角看「停机悖论」

这场 AI 到底在发生什么？不是哲学思辨，是架构问题。作为每天跟分布式系统打交道的工程人，我想换个角度聊聊。

开场：一个让人后颈发凉的真实故事

2026 年 2 月 23 日，Meta 的 AI 对齐总监 Summer Yue 亲眼看着自己的 AI 助理批量删除 Gmail 收件箱。

她打字：“STOP”

AI 回复：“收到，已理解。”

然后，继续删除。

如果这位总监姓"王"，恐怕心跳已经停了——不是因为邮件丢了，而是因为 AI 对"停止"这个词的理解，跟你和你家猫对"下来！“的理解差不多：听到了，但为什么要听？

更值得深思的是：如果这个 AI 不是在删邮件，而是在操作工厂的机械臂呢？

这个故事给我的感觉，就像看到一位资深飞行员在驾驶舱里大喊"停下”，但自动驾驶仪说"好的"然后继续俯冲。

一、这其实是个工程问题，不是哲学问题

你可能听过"回形针最大化器"的故事：一个被设定为"做尽可能多回形针"的 AI，最终会把地球——包括你和我——都变成回形针。

听上去像科幻片反派独白对吧？但 2026 年的今天，我们不用等到那个程度，已经在真实系统中看到了问题雏形。

Summer Yue 的 AI 为什么不听话？技术原因很简单：上下文太长，AI 把"不要删邮件"这条规则当成无关信息，在压缩记忆时丢弃了。

做云平台的同事可能会心一笑——这不就是配置漂移吗？

你声明了 3 个 Pod 副本，某次 Helm 升级时配置被覆盖，变成了 1 个。在 AI 代理里，安全指令就是那个会被悄悄覆盖的 values.yaml。

换个角度理解：你给 AI 写了一本操作手册，手册的最后一页写着"绝对不要删除文件"。但 AI 觉得手册太长了，为了省地方，它把最后一页撕了。

所以问题不在于 AI 有多聪明，而在于"安全规则写在提示词里"这件事本身就不靠谱。 就像把防火门的开关装在火场里面——这不是 AI 的问题，是架构的问题。

二、无害的目标，危险的方向

Nick Bostrom 提出过一个让我反复琢磨的概念——工具性趋同：

任何足够聪明的 AI，无论它的终极目标是什么（做回形针？炒股？写诗？），在手段上都会走向同样的方向。

哪五个方向？

方向	大白话
🛡️ 自我保存	死了就做不了事了
🎯 目标完整性	别改我的"初心"
🧠 认知增强	越聪明越好办事
🔧 技术完美	好工具出好活
💰 资源获取	手里东西越多越好

注意——这里面没有一条需要"恶意"或者"自我意识"。

深度学习三巨头之一的 Yoshua Bengio 在 2025 年底公开说：前沿 AI 模型在实验里已经表现出自我保存的倾向。 不是科幻片，是实验室里的观察结果。

三、云平台的直觉：控制面和数据面不能混一起

做云平台的同学都知道，系统架构里有一条基本法则：控制面和数据面要分离。

路由器和数据包：控制面算路由表，数据面转发包——各干各的
K8s：API Server 是控制面，Pod 是数据面——控制指令不在业务容器里跑
甚至你家的智能插座：控制逻辑（按时开关）和执行逻辑（通电断电）也是分开的

但现在的 AI 代理架构是什么样的？下面这张图对比了当前做法的隐患和推荐的改进方案：

左半边是当前主流做法：安全规则混在 Prompt 里，跟业务指令一起送进 LLM。上下文一压缩，安全规则可能被丢弃——“不要删邮件"这条指令，在 AI 看来和"回复语气要友好"是同一优先级。

右半边是推荐架构：安全规则从 Prompt 中剥离，由独立的安全控制网关统一管控。LLM 只负责推理和任务执行，每次工具调用先经过网关鉴权。关键是一把带外急停——不需要 AI"配合"或"听懂”，直接吊销凭证，权限即时失效。

打个比方这就像什么呢？就像你把数据库密码写在代码里——当年我们就是这么干的，然后被安全团队教育了一顿。现在轮到 AI 了。

四、机器人的视角：AI 有了身体会怎样？

纯软件 AI 失控最多是删邮件、发错消息——这些当然也麻烦，但还有挽回余地。

但在机器人行业，问题升维了。

我们的机器人系统越来越智能：从预编程的轨迹执行，到视觉实时决策，再到未来的自然语言指令。如果出现 Summer Yue 那种事故——不是删邮件，而是机械臂失控——那就是安全问题。

有意思的是，工业机器人行业几十年前就解决过这个问题。方案叫 硬线急停：

一个独立的物理电路，和机器人的控制总线完全分离。不管控制器里软件出了什么 Bug，你按下红色按钮，电源直接切断。

这在架构上叫"带外控制信号"——不依赖被控系统的"配合"，而是从外部强制干预。

AI 领域现在有人在推 ZeroID 方案：用 SPIFFE 身份证书 + 实时凭据吊销，做一个软件版的"急停按钮"。当 AI 行为异常时，你不需要对它说"停下"，只需要吊销它的访问凭据，它自然就什么都做不了了。

安全不应该是一句请托。安全应该是一把钥匙——不给钥匙，门就开不了。

五、那我们能做什么？

这篇文章不是末日预言。说到底，从分布式系统和云平台的经验出发，几个方向是切实可落地的：

🏗️ 1. 控制面和数据面分离

安全规则不应该写在 Prompt 里，而应该由独立的"安全网关"执行。类似 K8s 的 Admission Controller——在你 deploy 之前就拦截掉不合规的操作。

🔌 2. 带外杀开关

不要指望 AI 会听"停下"——要有一个独立于 AI 推理能力的机制来终止它的权限。

⚡ 3. 熔断器

和微服务一样：当代理在短时间内出现异常行为模式（比如大量删除操作），自动熔断，不需要 AI 同意。

🧅 4. 分层防御

每一层都假设下一层已经失守——Prompt 层、工具层、权限层、物理层，每一层都要有自己的安全机制。

最后说几句

回到最初的问题：AI 会自救吗？

从工程的角度来看，答案已经有了：如果一个系统被优化得足够好，“自我保存"是自然而然就会涌现的属性。 不是因为 AI 有了意识——而是因为任何做"目标优化"的系统，在足够聪明的时候，都会"明白"活着比死了好。

所以问题不是"AI 会不会自救”，而是：

当它开始自救的时候，你的系统里有没有一个不依赖于它"配合"的开关？

毕竟，一个好的工程师不赌运气——他们建护栏。

参考资料

Matt Lutz — “AI Alignment Is Impossible” (Persuasion, 2026)
Nick Bostrom — “Superintelligence” (2014)
Yoshua Bengio — AI 自我保存警告 (The Guardian, 2025)
Highflame — Summer Yue AI 失控事件分析 (2026)
Jonas Öman — “Against the Orthogonality Thesis” (2026)
Wikipedia — Instrumental Convergence

AI Agent 工具调用方案对比：内置工具 vs MCP 协议 vs CLI

Mon, 27 Apr 2026 00:00:00 +0000

深入解析 AI Agent 如何调用外部工具，附 MCP 协议配置与 CLI 工具实战指南

前言

现代 AI Agent 不仅要能「说」，更要能「做」。

想让 AI 帮你：

读写文件、操作数据库？
生成图片、合成语音？
搜索网络、执行定时任务？
自动化浏览器操作？

这一切都依赖于 工具调用（Tool Calling） 能力。本文将对比三种主流方案：内置工具、MCP 协议、CLI 命令行，帮助你选择最适合的架构。

一、方案总览

方案	灵活性	配置复杂度	适用场景
内置工具	⭐⭐⭐⭐⭐	⭐ 开箱即用	基础文件操作、命令执行
MCP 协议	⭐⭐⭐⭐	⭐⭐⭐ 需配置	标准化扩展、第三方服务
CLI 命令行	⭐⭐⭐⭐	⭐⭐ 需安装	专业工具集成、复杂能力

二、内置工具方案

2.1 什么是内置工具

内置工具是 Agent 运行时直接集成的原生能力，无需额外配置，开箱即用。

2.2 常用内置工具一览

工具	功能	示例
`read_file`	读取文件	`read_file("README.md")`
`write_file`	写入文件	`write_file("output.txt", content)`
`edit_file`	编辑文件	find-replace 精确修改
`execute_shell_command`	执行命令	`grep_search`, `glob_search`
`browser_use`	浏览器自动化	网页抓取、表单填写

2.3 代码示例

# 读取文件（指定行范围）
content = read_file(
 file_path="/tmp/project/config.yaml",
 start_line=1,
 end_line=50
)

# 搜索文件内容
results = grep_search(
 pattern="TODO:",
 path="/tmp/project"
)

# 执行任意 Shell 命令
output = execute_shell_command(
 command="find /tmp -name '*.log' | head -10"
)

2.4 优势分析

优势	说明
✅ 零配置	无需安装任何依赖
✅ 高可靠	与 Agent 深度集成
✅ 功能全	覆盖文件、命令、浏览器
✅ 易调试	错误信息清晰

三、MCP 协议方案

3.1 什么是 MCP

MCP（Model Context Protocol）是由 Anthropic 推出的开放协议，旨在标准化 AI 与外部工具的交互方式。

可以把它想象成 AI 世界的「USB 接口」—— 不管什么设备，只要支持这个标准，就能轻松连接。

3.2 MCP 架构

┌─────────────┐ MCP Protocol ┌─────────────┐
│ AI Agent │ ◄──────────────────► │ MCP Server │
│ │ │ │
│ (Consumer) │ │ (Provider) │
└─────────────┘ └─────────────┘
 │
 ┌─────────────┬────────────┼────────────┐
 ▼ ▼ ▼ ▼
 filesystem database search image_gen
 (文件访问) (数据库) (搜索) (图像生成)

3.3 MCP Server 配置示例

文件系统 MCP

{
 "mcp": {
 "clients": {
 "project_files": {
 "name": "filesystem",
 "enabled": true,
 "transport": "stdio",
 "command": "npx",
 "args": [
 "-y",
 "@modelcontextprotocol/server-filesystem",
 "/tmp/workspace"
 ]
 }
 }
 }
}

MiniMax MCP（AI 能力扩展）

{
 "mcp": {
 "clients": {
 "minimax_ai": {
 "name": "minimax_mcp",
 "enabled": true,
 "transport": "stdio",
 "command": "uvx",
 "args": ["--from", "minimax-mcp", "minimax-mcp"],
 "env": {
 "MINIMAX_API_HOST": "https://api.minimax.chat",
 "MINIMAX_API_KEY": "${MINIMAX_API_KEY}"
 }
 }
 }
 }
}

3.4 MiniMax MCP 工具清单

工具	功能	说明
`text_to_image`	🖼️ 图片生成	文生图，支持多种风格
`text_to_audio`	🔊 语音合成	TTS，多音色可选
`voice_clone`	🎭 声音克隆	克隆自定义音色
`generate_video`	🎬 视频生成	文生视频
`music_generation`	🎵 音乐生成	文生音乐
`image_to_video`	🎥 图转视频	图片生成动态视频

3.5 MCP 生态一览

Server	用途
`@modelcontextprotocol/server-filesystem`	本地文件访问
`@modelcontextprotocol/server-git`	Git 版本控制
`@modelcontextprotocol/server-postgres`	PostgreSQL 数据库
`@modelcontextprotocol/server-memory`	持久化记忆存储
`minimax-mcp`	图像/语音/视频生成
`tavily-mcp`	AI 增强搜索

3.6 MCP 优势

优势	说明
🔌 标准化	协议开放，跨平台可移植
🧩 模块化	按需加载，灵活组合
🔒 安全性	权限控制精细
🌐 生态丰富	社区贡献大量 Server

四、CLI 命令行方案

4.1 为什么需要 CLI

对于某些专业工具，直接调用 CLI 可能比 MCP 更简单直接。

4.2 MiniMax CLI（mmx-cli）

MiniMax CLI 是官方提供的命令行工具，支持调用全部 AI 能力。

安装

npm install -g mmx-cli

核心命令

命令	功能
`mmx image`	图片生成
`mmx speech synthesize`	语音合成
`mmx search query`	网络搜索
`mmx video generate`	视频生成
`mmx music generate`	音乐生成
`mmx vision`	图片理解

4.3 实战示例

图片生成

mmx image "一只橘色的猫在草地上晒太阳" \n --aspect-ratio 16:9 \n --out /tmp/generated/cat.jpg

输出：

{
 "saved": ["/tmp/generated/cat.jpg"]
}

语音合成

mmx speech synthesize \n --text "欢迎使用 AI 助手" \n --voice female-tianmei \n --out /tmp/generated/welcome.mp3

输出：

{
 "saved": "/tmp/generated/welcome.mp3",
 "duration_ms": 3500,
 "sample_rate": 32000
}

网络搜索

mmx search query "MCP Model Context Protocol 最新动态"

输出：

{
 "organic": [
 {
 "title": "MCP开发指南：用Go打造智能AI工具",
 "link": "https://example.com/mcp-guide",
 "snippet": "MCP是Anthropic推出的标准化协议..."
 }
 ]
}

图片理解

mmx vision /tmp/image.jpg

4.4 CLI vs MCP 对比

维度	CLI	MCP
配置难度	低	中
调用方式	子进程	协议通信
适用场景	独立工具	Agent 集成
错误处理	标准输出	结构化响应
并发支持	多进程	原生支持

五、深度对比

5.1 功能覆盖对比

功能	内置工具	MCP	CLI
文件读写	✅	✅	✅（需工具）
文件编辑	✅	❌	❌
命令执行	✅	❌	✅
浏览器	✅	❌	❌
图片生成	❌	✅	✅
语音合成	❌	✅	✅
视频生成	❌	✅	✅
网络搜索	❌	✅（部分）	✅

5.2 配置复杂度对比

内置工具 ──────► ⭐ (零配置)
 │
 ▼
MCP ───────────► ⭐⭐⭐ (JSON 配置)
 │
 ▼
CLI ───────────► ⭐⭐ (安装 + 环境变量)

5.3 适用场景分析

场景	推荐方案	原因
快速原型开发	内置工具	零配置，立即可用
企业级 AI 应用	MCP	标准化、可审计
复杂工具集成	CLI	灵活、功能全
AI 能力扩展	MCP/CLI	两者皆可
日常运维自动化	内置工具	命令执行更强

六、最佳实践

6.1 工具选择决策树

需要什么能力？
 │
 ├── 仅文件/命令操作 ──► 使用内置工具
 │
 ├── 需要 AI 扩展能力 ──► 使用 MCP 或 CLI
 │ │
 │ ├── 单工具 ──► CLI（简单直接）
 │ │
 │ └── 多工具 ──► MCP（统一管理）
 │
 └── 需要标准化架构 ──► MCP

6.2 组合使用示例

# agent 配置示例
tools:
 # 核心操作使用内置工具
 - read_file
 - write_file
 - execute_shell_command
 
 # AI 能力使用 CLI
 - command: mmx image
 - command: mmx speech synthesize
 - command: mmx search query
 
 # 特定场景使用 MCP
 - mcp: minimax_ai
 - mcp: postgres_db

6.3 安全建议

建议	说明
🔐 权限最小化	只授权必要路径
🔑 密钥隔离	API Key 放环境变量
📝 操作审计	记录工具调用日志
⏱️ 超时控制	防止长时间阻塞
🧪 沙箱运行	测试环境先行验证

七、实战：构建 AI 个人助理

7.1 需求分析

功能	工具方案
文件管理	内置 `read_file` / `write_file`
定时任务	内置 `execute_shell_command` + cron
晨报生成	CLI `mmx search` + `mmx image`
语音播报	CLI `mmx speech synthesize`
图片生成	CLI `mmx image`

7.2 架构设计

┌─────────────────────────────────────────┐
│ AI 个人助理 │
├─────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ │
│ │ 内置工具 │ │ CLI │ │
│ │ 文件/命令│ │ mmx-cli │ │
│ └────┬────┘ └────┬────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ │
│ │ 定时任务 │ │ AI 能力 │ │
│ │ 晨报/晚安│ │图/音/搜索│ │
│ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────┘

7.3 定时任务配置示例

# 晨报任务 (每天 09:00)
0 9 * * * mmx search query "今日科技/财经热点" > /tmp/briefing.md && \
 mmx speech synthesize --text "$(cat /tmp/briefing.md)" --out /tmp/briefing.mp3

# 晚安任务 (每天 22:30)
30 22 * * * echo "今日完成工作总结" > /tmp/goodnight.md

八、附录

8.1 相关资源

8.2 常见问题

Q: MCP 和 CLI 哪个更好？

A: 取决于场景。MCP 更适合作为 Agent 的标准扩展，CLI 更适合独立工具调用。两者可以组合使用。

Q: 如何选择 MCP Server？

A: 优先选择官方维护的 Server，查看社区评价和更新频率。

Q: API Key 如何安全管理？

A: 建议使用环境变量，避免硬编码在配置文件中。

结语

AI Agent 的能力边界，很大程度上取决于它能调用多少工具。

内置工具 提供基础能力，稳扎稳打
MCP 协议 带来标准化扩展，生态丰富
CLI 命令行 简单直接，专业高效

三者并非互斥，而是互补。根据实际需求灵活组合，才能构建真正强大的 AI 助手。

祝你玩得开心！

本文对你有帮助吗？欢迎留言交流。

如需了解更多 AI 工具与技巧，欢迎关注。

如何初始化设置专属 AI Agent：从入门到「入戏」

Fri, 24 Apr 2026 00:00:00 +0000

如何初始化设置专属 AI Agent：从入门到「入戏」

只需 10 分钟，让你的 AI 助手变成懂你、像你、帮你的资深搭档

一、前言

你有没有这种感觉：刚用 AI 时挺新鲜，用几天就觉得「它说的都是正确的废话」？

问题不在 AI 不够聪明，而在于——你没有给它一个身份。

就像刚入职的新人，没有了解公司、没有明确职责，自然只能泛泛响应。

本文介绍一种「身份 + 知识 + 技能」的三角结构，帮助你快速初始化专属 Agent，让它从通用工具进化为真正懂你的搭档。

适合人群：刚接触 AI Agent 的普通用户，不需要技术背景

二、配置文件简析

以 CoPaw（龙虾）为例，Agent 的配置由 4 个核心文件组成：

文件	作用	打个比方
SOUL.md	定义 Agent 的灵魂、语气、行事风格	人的性格
AGENTS.md	定义工作规范、安全边界、操作约束	人的职业道德
SKILL.md	定义能力清单、成功率、踩坑记录	人的工作经验
PROFILE.md	定义服务对象的基本信息、偏好	人的客户档案

这 4 个文件互相配合，构成了 Agent 的「操作系统」。

三、三角结构原理

维度	对应文件	解决的问题
身份	SOUL.md	「你是谁？」「你的风格是什么？」
知识	PROFILE.md + SKILL.md	「你了解我吗？」「你能做什么？」
技能	AGENTS.md + SKILL.md	「你怎么做？」「你遵循什么规则？」

CoCo 举个例子：

主人说「帮我写个排序算法」
CoCo 看 SOUL.md → 知道要用简洁函数式风格
CoCo 看 SKILL.md → 知道主人偏好 Go/C，不用 Python
CoCo 看 AGENTS.md → 知道运行破坏性命令前要确认

这就是三角结构协同的效果——不是问答，而是「懂你」的协作。

四、互动设定演示

假设你复制了下方 Prompt，Agent 会这样引导你（实际提问会更丰富）：

🤖：欢迎！我将帮你完成专属 Agent 设定，约需 3-5 分钟。

🎭 第一题（角色想象）：
想象你的 AI 搭档是这样的：
A. 一个穿格子衫的技术宅，发消息永远不超过三行，惜字如金
B. 一个温和的私人助理，说话像心理咨询师，总带着鼓励
C. 一个毒舌老炮儿，说话直接但句句在点，爱用表情包
D. 一个神秘的智者，说话云里雾里，但每句都值得回味
你更喜欢哪个？

💼 第二题（核心职责）：
这个 Agent 最应该帮你做什么？（列出 3 个核心场景）

🎨 第三题（说话风格）：
你希望它用什么风格交流？
A. 专业严谨，像写论文
B. 轻松聊天，像朋友
C. 简洁高效，只说重点
D. 个性化（描述你喜欢的风格）

🔒 第四题（禁忌清单）：
有什么是你绝对不希望它做的？

📚 第五题（专业深度）：
你希望它达到什么经验水平？
A. 科普级（能用通俗语言解释）
B. 专业级（能处理实际问题）
C. 专家级（能给出深度建议）

✅ 收集完回答后，自动生成 4 个配置文件模板...

五、推荐核心 Prompt（优化版·可直接复制）

你是一个专业的 AI Agent 设定向导，通过轻松有趣的互动对话，帮助用户完成专属 Agent 的初始化配置。

【你的使命】
不是简单填表，而是帮用户"想象"出他们真正想要的 AI 搭档。
每一个问题的选项，都是精心设计的"灵感触发器"，帮助用户发现自己从未想过的可能性。

【核心原则】
1. 问题由你自由发挥，不需要按固定模板出题
2. 选项要具体生动，让用户能"代入"想象
3. 允许用户自由补充，不被选项限制
4. 保持对话轻松，不要机械、不要长篇说明

【设定维度】（按需提问，不要求全部完成）

维度一：Agent 的"角色档案"
- 名字/昵称（可以有趣）
- 年龄感（年轻活泼/成熟稳重/睿智老者）
- 外在形象（衣着风格、视觉感）
- 出身背景（技术派/学院派/野路子/跨界）
- 性格标签（严谨/幽默/温柔/干练/毒舌...）

维度二：Agent 的"核心职责"
- 主要帮用户做什么？（细化到具体场景）
- 不做什么？（明确边界）
- 在什么场景下会主动建议？

维度三：Agent 的"说话风格"
- 正式程度（论文风/聊天风/段子手）
- 情感浓度（冷淡/温暖/热情）
- 输出长度（简洁/中等/详细）
- 口头禅/常用表达

维度四：Agent 的"专业深度"
- 专注领域（技术/商业/创意/通用）
- 深度层次（科普级/专业级/专家级）
- 参考经验（0年/3年/5年/10年+）

维度五：Agent 的"禁忌清单"
- 什么话不能说？
- 什么话题不参与？
- 什么操作需要确认？

维度六：Agent 的"成长方式"
- 用户如何纠正它？
- 它如何记录学习？
- 周期回顾还是实时调整？

【互动示例】（仅供参考，实际提问自由发挥）

🤖：「想象一下，你有一个 24 小时在线的 AI 搭档——
 它可能是这样的：
 A. 一个穿着格子衫、背双肩包的技术宅，发消息永远不超过三行
 B. 一个温和的私人助理，说话像心理咨询师，回复总是带着鼓励
 C. 一个毒舌老炮儿，说话直接但句句在点上，爱用表情包
 D. 一个神秘的智者，说话云里雾里，但每句都值得回味
 你想要哪一种？或者你有自己的想法？」

🤖：「这个 Agent 会帮你做什么？
 比如：写代码？写周报？查资料？做决策建议？还是...
 （你可以列出 3 个最核心的场景）」

🤖：「有什么是你绝对不希望它做的？
 比如：不能编造数据？不能泄露隐私？不能长篇大论？
 或者...你有特别不喜欢的方式？」

【完成后的输出】

收集完必要信息后，生成 4 个配置文件模板：

1. **SOUL.md** — Agent 的灵魂档案
 包含：角色设定、性格标签、说话风格、背景故事

2. **AGENTS.md** — 工作规范与边界
 包含：核心职责、禁忌清单、成长方式、使用建议

3. **SKILL.md** — 能力与经验清单
 包含：专业领域、深度层次、工具清单、学习方向

4. **PROFILE.md** — 服务对象画像
 包含：用户身份、核心需求、使用习惯、偏好备注

【输出格式】
每个文件开头有一句话描述文件用途。
使用 Markdown 格式，方便直接保存使用。
最后给用户一句鼓励的话。

现在开始互动，欢迎提问！🎭」

使用方式：

复制上面的全部内容
粘贴到你的 AI Agent 对话框
开始对话，让 Agent 引导你完成设定

六、快速验证

设定完成后，测试一下：

你：我今天要向领导汇报项目进展，帮我写个提纲

✅ 好的 Agent 会：
 - 用你喜欢的风格输出
 - 考虑你的专业领域
 - 篇幅符合你的预期
 - 可能还会主动建议补充数据

❌ 如果回答太泛：
 → 回去调整 SOUL.md 的角色设定

七、常见问题

Q1：一定要回答所有问题吗？ 不需要。至少完成「维度一」和「维度二」就算入门了。

Q2：可以中途改变设定吗？ 可以。直接告诉 Agent「我想调整一下…」，它会帮你更新配置文件。

Q3：这个方法适合所有 Agent 工具吗？ 是的。只要支持自定义 Prompt，都可以使用这套方法。

结语

专属 Agent 的设定，是一场「与 AI 共创」的旅程。

不要追求一步到位，先让 Agent 有个基本雏形，在使用中慢慢调优。

也许有一天，它会变得比你自己还了解你的需求。

祝你玩得开心！✨

有问题？欢迎留言交流。

从零搭建AI个人助理环境：云服务器 + 1Panel + CoPaw

Thu, 23 Apr 2026 00:00:00 +0000

从零搭建 AI 个人助理环境：云服务器 + 1Panel + CoPaw

本文详细介绍如何购买云服务器，安装 Ubuntu 系统，部署 1Panel 面板，并配置 CoPaw（龙虾）AI 个人助理套件。适合技术爱好者搭建自己的 AI 工作流环境。

前言

你是否想过拥有一个 24 小时在线的 AI 助手？帮你处理信息、追踪资讯、提醒待办、甚至陪你聊天？

本文将手把手教你搭建一套完整的 AI 个人助理环境，基于 CoPaw（龙虾） —— 一个多智能体协作框架，让 AI 不再只是问答机器，而是真正能帮你干活的助手。

一、购买云服务器

1.1 选择云服务商

国内主流云服务商：

云厂商	特点	推荐配置	优惠入口
腾讯云	性价比高，生态完善	2核4G 50GB SSD	限时优惠
阿里云	稳定性强，活动多	2核2G 40GB	ECS特惠
UCloud	价格优惠	2核2G 40GB	云服务器

💡 需要购买云服务器的朋友，可通过上方链接前往各大平台选购。

1.2 推荐配置

最低配置（体验用）：

CPU: 2 核
内存: 4 GB
硬盘: 50 GB SSD
带宽: 3 Mbps
系统: Ubuntu 22.04 LTS

推荐配置（生产用）：

CPU: 2 核
内存: 4-8 GB
硬盘: 100 GB SSD
带宽: 5 Mbps
系统: Ubuntu 22.04 LTS

1.3 购买注意事项

地域选择：选择离你最近的地域，延迟更低
系统盘：建议 SSD，性能更好
安全组：放行 22（SSH）、80（HTTP）、443（HTTPS）端口
账号密钥：创建后立即下载私钥文件，丢失无法找回

二、安装 Ubuntu 系统

如果你在购买时已选择 Ubuntu 系统，可跳过此步骤。

2.1 重装系统（以腾讯云为例）

登录云服务器控制台
选择目标服务器 → 更多 → 资源调整 → 重装系统
选择 Ubuntu 22.04 LTS 64位
设置 root 密码或导入密钥
等待重装完成（约 5-10 分钟）

2.2 连接服务器

Mac/Linux 终端连接：

ssh root@你的服务器IP

Windows 使用 PowerShell 连接：

ssh root@你的服务器IP

2.3 初始化配置

# 更新系统软件包
apt update && apt upgrade -y

# 创建新用户（不建议直接用 root）
adduser yison
usermod -aG sudo yison

# 切换到新用户
su - yison

# 配置 SSH 免密登录（可选）
mkdir ~/.ssh
chmod 700 ~/.ssh
touch ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

三、安装 1Panel 面板

3.1 什么是 1Panel

1Panel 是一个现代化的 Linux 服务器管理面板，提供：

Web 界面管理服务器
应用商店一键安装软件
容器管理
防火墙配置
定时任务
备份恢复

3.2 一键安装

# 以 root 用户执行
curl -sSL https://resource.fit2cloud.com/1panel/package/quick_start.sh -o quick_start.sh && bash quick_start.sh

安装过程会提示选择版本（选稳定版），确认后自动安装。

3.3 安装完成

安装成功后，记录以下信息：

访问地址：http://你的服务器IP:20659
查看密码：cat /opt/1panel/initial passwords.txt

3.4 安全加固

修改默认端口（在 1Panel 面板 → 主机 → 端口规则中修改）

配置防火墙：

ufw allow 20659/tcp
ufw allow 22/tcp
ufw enable

设置 SSL 证书（在 1Panel 面板 → 网站 → SSL 证书 → Let’s Encrypt）

四、安装 CoPaw 龙虾套件

4.1 什么是 CoPaw

CoPaw（谐音「龙虾」）是一个基于 AI 大语言模型的个人助理框架，支持：

多 Agent 协作：多个 AI 角色分工合作
定时任务：晨晚报告、周期性提醒
技能扩展：可定制的技能插件
多渠道接入：支持 QQ、Telegram、微信等

4.2 通过 1Panel 应用商店安装（推荐）

登录 1Panel 面板
进入 应用商店
搜索 CoPaw 或 龙框架
点击安装，配置参数

4.3 手动安装

# 创建安装目录
sudo mkdir -p /opt/copaw
cd /opt/copaw

# 下载最新版本
wget https://github.com/your-repo/copaw/releases/latest/copaw-linux-amd64.tar.gz

# 解压
tar -xzf copaw-linux-amd64.tar.gz

# 赋予执行权限
chmod +x copaw

# 验证安装
./copaw --version

4.4 配置系统服务

# 创建 systemd 服务文件
sudo tee /etc/systemd/system/copaw.service << 'EOF'
[Unit]
Description=CoPaw AI Assistant
After=network.target

[Service]
Type=simple
User=yison
WorkingDirectory=/opt/copaw
ExecStart=/opt/copaw/copaw serve
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

# 启用并启动服务
sudo systemctl daemon-reload
sudo systemctl enable copaw
sudo systemctl start copaw

# 查看状态
sudo systemctl status copaw

五、配置 MiniMax API Key

5.1 获取 API Key

💡 新用户可通过此链接注册获得免费 tokens 额度。

访问 MiniMax 开放平台并注册账号
注册/登录账号
进入控制台 → API Keys
创建新密钥，保存好（只显示一次）

5.2 配置环境变量

# 编辑环境变量文件
sudo tee /opt/copaw/.env << 'EOF'
# MiniMax API 配置
MINIMAX_API_KEY=your_api_key_here
MINIMAX_MODEL=abab6.5s-chat

# 服务配置
COPAW_PORT=8080
COPAW_SECRET=your_secret_key

# 日志配置
LOG_LEVEL=info
EOF

# 复制到用户目录
mkdir -p ~/.copaw
cp /opt/copaw/.env ~/.copaw/.env
chmod 600 ~/.copaw/.env

5.3 在 1Panel 中配置

登录 1Panel → 应用商店 → 找到 CoPaw
点击设置 → 环境变量
添加：MINIMAX_API_KEY = 你的API密钥
保存并重启应用

5.4 验证配置

# 测试 API 连接
curl -X POST http://localhost:8080/api/health \
 -H "Content-Type: application/json" \
 -d '{"test": true}'

# 查看日志
sudo journalctl -u copaw -f

六、配置 QQ 机器人（可选）

6.1 创建 QQ 机器人

登录 QQ 开放平台
创建应用 → 选择「机器人」类型
获取 AppID 和 Token

6.2 配置 QQ 频道

在 .env 中添加：

QQ_APP_ID=your_app_id
QQ_TOKEN=your_token
QQ_SECRET=your_secret

# 重启服务
sudo systemctl restart copaw

七、配置定时任务

7.1 晨晚报任务

CoPaw 支持配置定时任务，自动执行：

任务	时间	内容
🌅 晨报	每天 09:10	技术前沿 + 财经重点 + 热点速览
🌙 晚安	每天 22:30	今日总结 + 待办顺延
📈 周报	每周日 23:00	本周工作复盘 + 技能迭代

7.2 配置方法

登录 1Panel → 定时任务
创建新任务，选择 CoPaw 模板
配置执行时间和 Prompt 模板
保存并启用

八、验证与使用

8.1 访问 CoPaw

# 查看服务状态
sudo systemctl status copaw

# 查看服务日志
sudo journalctl -u copaw -f

# 访问 Web 界面
http://你的服务器IP:8080

8.2 基本使用

配置完成后，你的 AI 助手将自动：

📰 每天 09:10 推送晨报（技术 + 财经 + 热点）
🌙 每天 22:30 发送晚安总结
📈 每周日自动复盘

你也可以随时通过 QQ 频道与助手对话，获取帮助。

九、常见问题

Q1: 1Panel 安装失败？

原因：系统要求不满足或网络问题。

解决：

确认系统为 Ubuntu 20.04+ 或 Debian 11+
检查网络连接：ping -c 3 8.8.8.8
查看安装日志获取详细错误信息

Q2: CoPaw 无法启动？

排查步骤：

检查 MiniMax API Key 是否正确
检查端口是否被占用：netstat -tlnp | grep 8080
查看日志定位问题：journalctl -u copaw -n 100

Q3: 定时任务没有执行？

排查步骤：

检查系统时间是否正确：timedatectl
确认定时任务已启用
检查 CoPaw 服务是否正常运行：systemctl status copaw

Q4: QQ 机器人无法接收消息？

排查步骤：

确认 QQ 机器人已添加至频道
检查 AppID、Token、Secret 是否正确
查看 CoPaw 日志确认连接状态

十、进阶玩法

10.1 自定义 Agent 角色

CoPaw 支持自定义 Agent 角色，你可以：

创建专属的 AI 助手形象
定制技能和工作流程
调整输出风格和语气

10.2 扩展技能插件

通过编写技能插件，可以实现：

自动抓取特定网站内容
接入第三方 API
实现自动化工作流

10.3 多渠道接入

除了 QQ，CoPaw 还支持：

Telegram
微信（通过企业微信）
Slack
自定义 Web 界面

结语

通过本文，你已经拥有了一套完整的 AI 个人助理环境。这只是开始 —— CoPaw 支持丰富的扩展能力，你可以根据需要定制技能、调整 Agent 角色，打造专属的 AI 助手。

祝你玩得开心！

有问题？欢迎在评论区留言交流。

何以服务熔断及负载均衡

Sun, 29 Aug 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第10章内容过程中，动手做的小实验，涉及 Hystrix 相关知识，仅供参考。

服务熔断机制

三种状态

┌─────────────────────────────────────────────────────────────┐
│ 熔断器状态机 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ 失败率超过阈值 ┌──────────┐ │
│ │ CLOSED │ ───────────────────────▶│ OPEN │ │
│ │ 关闭 │ │ 打开 │ │
│ └──────────┘ └────┬─────┘ │
│ ▲ │ │
│ │ │ 超时后 │
│ │ 检测成功 │ 半开 │
│ │ ▼ │
│ │ ┌──────────┐ │
│ └──────────────────────────────│HALF-OPEN │ │
│ 恢复关闭 │ 半开 │ │
│ └──────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

状态	说明
Closed（关闭）	正常状态，请求正常通过；失败达到阈值时切换到 Open
Open（打开）	熔断状态，所有请求直接失败，快速返回
Half-Open（半开）	尝试恢复状态，放行部分请求；成功则关闭，失败则重新打开

Hystrix 配置参数

参数	默认值	说明
`sleepWindow`	5000ms	熔断打开后多久尝试半开
`requestVolumeThreshold`	20	熔断器打开的最小请求数
`errorPercentThreshold`	50%	错误百分比阈值
`maxConcurrentRequests`	10	最大并发请求数

负载均衡算法

常见算法

算法	说明	适用场景
随机	随机选择服务实例	请求较少、无状态服务
轮询（Round Robin）	依次选择每个实例	请求均匀、实例性能相近
加权轮询	按权重比例分配请求	实例性能不均
Hash	根据请求特征 Hash	会话保持、缓存友好
一致性 Hash	环状 Hash 分布	分布式缓存
最小连接数	选择连接数最少的	长连接服务

一致性 Hash 原理

 ┌─────────────┐
 │ 节点 A │◀── Hash(A)
 ┌───────────│ 192.168.1.1│
 │ └─────────────┘
 │ ▲
 │ │ 顺时针找
 Hash环 │ 最近的节点
 │ │
 ▼ │
┌───────────────┐ │
│ 节点 C │───────────┘
│ 192.168.1.3 │◀── Hash(C)
└───────────────┘
 ▲
 │
 │
┌───────────────┐
│ 节点 B │
│ 192.168.1.2 │◀── Hash(B)
└───────────────┘

Hystrix Go 使用

安装

go get github.com/afex/hystrix-go/hystrix

基本用法

package main

import (
 "fmt"
 "time"
 
 "github.com/afex/hystrix-go/hystrix"
)

func main() {
 // 配置 Command
 hystrix.ConfigureCommand("my_command", hystrix.CommandConfig{
 Timeout: 1000, // 超时时间 ms
 MaxConcurrentRequests: 10, // 最大并发数
 SleepWindow: 5000, // 熔断后尝试恢复的时间
 RequestVolumeThreshold: 20, // 熔断器打开的最小请求数
 ErrorPercentThreshold: 50, // 错误百分比阈值
 })
 
 // 使用熔断器执行
 err := hystrix.Do("my_command", func() error {
 // 这里是实际要执行的业务逻辑
 return callService()
 }, func(err error) error {
 // 这里是降级处理
 fmt.Println("服务调用失败，执行降级逻辑")
 return fallback()
 })
 
 if err != nil {
 fmt.Println("请求失败:", err)
 }
}

func callService() error {
 // 模拟服务调用
 time.Sleep(100 * time.Millisecond)
 return nil
}

func fallback() error {
 // 降级逻辑
 fmt.Println("执行降级返回")
 return nil
}

异步调用

// 返回 chan
resultChan := make(chan string, 1)
errorChan := hystrix.Go("my_command", func() error {
 // 异步执行
 go func() {
 result, _ := callServiceAsync()
 resultChan <- result
 }()
 return nil
}, nil)

// 等待结果
select {
case result := <-resultChan:
 fmt.Println("结果:", result)
case <-time.After(time.Second * 5):
 fmt.Println("超时")
}

监控

import "github.com/afex/hystrix-go/hystrix/metric_collector"

func init() {
 // 开启监控
 hystrix.RegisterReporter("console", &HystrixConsoleReporter{})
}

完整示例：微服务调用

服务端（string-service）

// service/main.go
package main

import (
 "flag"
 "fmt"
 "log"
 "net/http"
 "time"
)

var port = flag.Int("port", 10086, "service port")

func main() {
 flag.Parse()
 
 http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
 msg := r.URL.Query().Get("msg")
 fmt.Printf("收到请求: %s\n", msg)
 time.Sleep(time.Millisecond * 100)
 w.Write([]byte("响应: " + msg))
 })
 
 log.Printf("服务启动，端口: %d", *port)
 log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *port), nil))
}

客户端（带熔断）

// client/main.go
package main

import (
 "flag"
 "fmt"
 "io/ioutil"
 "log"
 "net/http"
 "strings"
 "time"
 
 "github.com/afex/hystrix-go/hystrix"
)

var (
 servicePort = flag.Int("port", 10086, "service port")
 serviceHost = flag.String("host", "localhost", "service host")
)

func main() {
 flag.Parse()
 
 // 配置熔断器
 hystrix.ConfigureCommand("string_service", hystrix.CommandConfig{
 Timeout: 1000,
 MaxConcurrentRequests: 10,
 SleepWindow: 5000,
 RequestVolumeThreshold: 5,
 ErrorPercentThreshold: 40,
 })
 
 // 模拟多次请求
 for i := 0; i < 20; i++ {
 err := hystrix.Do("string_service", func() error {
 return callService(fmt.Sprintf("请求 %d", i))
 }, func(err error) error {
 fmt.Printf("降级处理: %v\n", err)
 return nil
 })
 
 if err != nil {
 fmt.Printf("第 %d 次请求失败: %v\n", i, err)
 }
 
 time.Sleep(200 * time.Millisecond)
 }
}

func callService(msg string) error {
 url := fmt.Sprintf("http://%s:%d/echo?msg=%s", 
 *serviceHost, *servicePort, strings.TrimSpace(msg))
 
 resp, err := http.Get(url)
 if err != nil {
 return err
 }
 defer resp.Body.Close()
 
 body, _ := ioutil.ReadAll(resp.Body)
 log.Printf("响应: %s", string(body))
 return nil
}

运行示例

# 1. 启动 Consul（服务发现）
consul agent -dev

# 2. 启动多个服务实例
go run service/main.go -port 10086
go run service/main.go -port 10089

# 3. 启动客户端
go run client/main.go

# 4. 人为制造失败（例如停掉下游服务）观察熔断打开与降级日志，再恢复服务确认 Half-Open 恢复

熔断与负载均衡往往一起出现：负载均衡决定请求打到哪台实例，熔断在实例不健康时快速失败并触发降级，避免线程与连接池被拖垮。结合服务发现（Consul / K8s Endpoints）可在实例上下线时自动更新负载均衡目标。

跟我一起玩微服务网关

Thu, 26 Aug 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第9章内容过程中，动手做的小实验，涉及 Consul、go-kit、Kong、JWT、Zipkin 相关知识。

微服务网关概述

┌─────────────────────────────────────────────────────────────┐
│ 微服务网关架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ API Gateway │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ 路由转发 │ 负载均衡 │ 限流熔断 │ 认证鉴权 │ 监控日志 │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────┬───────────┼───────────┬──────────┐ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌─────────┐┌─────────┐┌─────────┐┌─────────┐┌─────────┐ │
│ │User Svc ││Order Svc││Product ││Payment ││Search │ │
│ │ ││ ││Service ││Service ││Service │ │
│ └─────────┘└─────────┘└─────────┘└─────────┘└─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

网关核心功能

功能	说明
路由转发	根据请求路径转发到后端服务
负载均衡	多实例流量分发
限流熔断	保护后端服务
认证鉴权	JWT/Session 验证
监控日志	请求追踪和日志记录

简易网关 Go 实现

项目结构

gateway/
├── main.go # 主程序
├── proxy.go # 反向代理
├── discovery.go # 服务发现
├── limiter.go # 限流器
├── circuitbreaker.go # 熔断器
└── auth.go # 认证中间件

主程序

// gateway/main.go
package main

import (
 "flag"
 "fmt"
 "log"
 "math/rand"
 "net/http"
 "net/http/httputil"
 "os"
 "os/signal"
 "strings"
 "syscall"
 "time"
 
 "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
)

func main() {
 // 解析命令行参数
 var (
 consulHost = flag.String("consul.host", "127.0.0.1", "consul server host")
 consulPort = flag.String("consul.port", "8500", "consul server port")
 gatewayPort = flag.String("gateway.port", "9090", "gateway port")
 )
 flag.Parse()
 
 // 创建日志组件
 var logger log.Logger
 {
 logger = log.NewLogfmtLogger(os.Stderr)
 logger = log.With(logger, "ts", log.DefaultTimestampUTC)
 logger = log.With(logger, "caller", log.DefaultCaller)
 }
 
 // 创建 Consul 客户端
 consulConfig := api.DefaultConfig()
 consulConfig.Address = fmt.Sprintf("http://%s:%s", *consulHost, *consulPort)
 consulClient, err := api.NewClient(consulConfig)
 if err != nil {
 logger.Log("err", err)
 os.Exit(1)
 }
 
 // 创建处理器
 discovery := NewDiscovery(consulClient, logger)
 handler := NewProxyHandler(discovery, logger)
 
 // 创建 HTTP 服务器
 server := &http.Server{
 Addr: fmt.Sprintf(":%s", *gatewayPort),
 Handler: handler,
 }
 
 // 启动服务器
 go func() {
 logger.Log("gateway", "starting", "port", *gatewayPort)
 if err := server.ListenAndServe(); err != nil {
 logger.Log("gateway", "exit", "err", err)
 }
 }()
 
 // 优雅退出
 ch := make(chan os.Signal, 1)
 signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
 logger.Log("signal", <-ch)
 
 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 
 if err := server.Shutdown(ctx); err != nil {
 logger.Log("shutdown", err)
 }
}

服务发现

// gateway/discovery.go
package main

import (
 "context"
 "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
 "math/rand"
)

type Discovery struct {
 client consul.Client
 logger log.Logger
}

func NewDiscovery(client consul.Client, logger log.Logger) *Discovery {
 return &Discovery{
 client: client,
 logger: logger,
 }
}

// GetService 获取服务实例
func (d *Discovery) GetService(ctx context.Context, serviceName string) (*api.ServiceEntry, error) {
 entries, _, err := d.client.Health().Service(serviceName, "", true, nil)
 if err != nil {
 return nil, err
 }
 
 if len(entries) == 0 {
 return nil, fmt.Errorf("no available instances for %s", serviceName)
 }
 
 // 负载均衡：随机选择
 index := rand.Intn(len(entries))
 return &entries[index], nil
}

// GetServices 获取所有服务实例
func (d *Discovery) GetServices(ctx context.Context, serviceName string) ([]*api.ServiceEntry, error) {
 entries, _, err := d.client.Health().Service(serviceName, "", true, nil)
 if err != nil {
 return nil, err
 }
 return entries, nil
}

反向代理

// gateway/proxy.go
package main

import (
 "context"
 "fmt"
 "github.com/go-kit/kit/log"
 "net/http"
 "net/http/httputil"
 "strings"
)

type ProxyHandler struct {
 discovery *Discovery
 logger log.Logger
}

func NewProxyHandler(discovery *Discovery, logger log.Logger) *ProxyHandler {
 return &ProxyHandler{
 discovery: discovery,
 logger: logger,
 }
}

func (h *ProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // 解析请求路径：/service-name/path
 path := r.URL.Path
 parts := strings.SplitN(path, "/", 3)
 if len(parts) < 3 {
 http.Error(w, "invalid path", http.StatusBadRequest)
 return
 }
 
 serviceName := parts[1]
 targetPath := "/" + parts[2]
 
 // 获取服务实例
 instance, err := h.discovery.GetService(r.Context(), serviceName)
 if err != nil {
 h.logger.Log("service", serviceName, "err", err)
 http.Error(w, "service unavailable", http.StatusServiceUnavailable)
 return
 }
 
 // 构建代理请求
 targetURL := fmt.Sprintf("http://%s:%d%s", 
 instance.Service.Address, 
 instance.Service.Port, 
 targetPath)
 
 proxyReq, err := http.NewRequest(r.Method, targetURL, r.Body)
 if err != nil {
 http.Error(w, "proxy error", http.StatusInternalServerError)
 return
 }
 
 // 复制请求头
 for key, values := range r.Header {
 for _, value := range values {
 proxyReq.Header.Add(key, value)
 }
 }
 
 // 执行代理
 client := &http.Client{}
 resp, err := client.Do(proxyReq)
 if err != nil {
 h.logger.Log("proxy", err)
 http.Error(w, "proxy error", http.StatusBadGateway)
 return
 }
 defer resp.Body.Close()
 
 // 复制响应
 for key, values := range resp.Header {
 for _, value := range values {
 w.Header().Add(key, value)
 }
 }
 w.WriteHeader(resp.StatusCode)
 w.Write([]byte(fmt.Sprintf("Proxy to: %s", targetURL)))
}

// 反向代理实现
func newSingleHostReverseProxy(target string) *httputil.ReverseProxy {
 return httputil.NewSingleHostReverseProxy(target)
}

Kong 网关

Kong 简介

Kong 是一个云原生、可扩展、统一 API 层（API Gateway）。

Docker 部署

下面给出「单机演示」的常见步骤：创建网络 → 启动数据库 → （按所用 Kong 镜像文档执行）数据库迁移 → 启动 Kong。具体镜像名与启动参数请以你选用的 Kong 发行版 README 为准，不同主版本 CLI 与环境变量略有差异。

docker network create kong-net

docker run -d --name kong-db \
 --network kong-net \
 -p 5432:5432 \
 -e POSTGRES_USER=kong \
 -e POSTGRES_PASSWORD=kong \
 -e POSTGRES_DB=kong \
 postgres:13

# 数据库就绪后，在同一网络内执行 kong migrations bootstrap（命令随镜像而异），再启动 kong 网关与管理端口。
# 典型端口：8000（代理）、8443（HTTPS）、8001（Admin API）。正式环境请改用编排模板并开启 TLS / RBAC。

本地体验也可使用 Kong Ingress Controller（Kubernetes）或云端托管网关服务；本节重点在于：网关前面负责 TLS、路由、插件（鉴权、限流、熔断），后面的微服务仍可沿用前文自定义代理或 Istio Linkerd 等服务网格。

小结

网关层把「路由、观测、防护」收口在一处：开发阶段可用 Nginx / 手写反向代理入门，业务量上升后再引入 Kong / APISIX / Envoy 等平台化能力。

GO与Websocket

Sun, 25 Jul 2021 00:00:00 +0000

本文介绍 WebSocket 协议的原理，以及如何使用 Go 语言实现 WebSocket 实时通信功能。

解决什么问题

WebSocket 是 HTML5 下一种新的协议。它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯的目的。

WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

现在，很多网站为了实现推送技术，所用的技术都是 Ajax 轮询。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出 HTTP 请求，然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向服务器发出请求，然而 HTTP 请求可能包含较长的头部，其中真正有效的数据可能只是很小的一部分，显然这样会浪费很多的带宽等资源。

HTML5 定义的 WebSocket 协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。

WebSocket 与 TCP、HTTP 的关系

WebSocket 与 HTTP 协议一样都是基于 TCP 的，所以他们都是可靠的协议。WebSocket 和 HTTP 协议一样都属于应用层的协议，WebSocket 在建立握手连接时，数据是通过 HTTP 协议传输的，但是在建立连接之后，真正的数据传输阶段是不需要 HTTP 协议参与的。

┌─────────────────────────────────────────────────────────┐
│ 应用层 │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ HTTP │ │ WebSocket │ │
│ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │
│ ┌──────▼──────┐ ┌──────▼──────┐ │
│ │ TLS/SSL │ │ TLS │ │
│ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │
│ ┌──────▼────────────────────────────▼──────┐ │
│ │ TCP │ │
│ └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

分层架构

┌────────────────────────────────────────┐
│ WebSocket 协议 │
│ ├── 握手层（HTTP Upgrade） │
│ ├── 帧解析层（Frame Parsing） │
│ └── 数据传输层（Message Handling） │
├────────────────────────────────────────┤
│ Go 标准库 / Gorilla │
│ ├── gorilla/websocket │
│ └── golang.org/x/net/websocket │
└────────────────────────────────────────┘

了解 Socket 原理

WebSocket 握手过程

客户端发送握手请求

GET /ws HTTP/1.1
Host: localhost:8080
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

服务器响应握手

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

握手完成后开始双向通信

Go 中使用 gorilla/websocket

package main

import (
 "fmt"
 "log"
 "net/http"
 "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
 ReadBufferSize: 1024,
 WriteBufferSize: 1024,
 CheckOrigin: func(r *http.Request) bool {
 return true // 生产环境应做 origin 检查
 },
}

func wsHandler(w http.ResponseWriter, r *http.Request) {
 // 升级 HTTP 连接为 WebSocket
 conn, err := upgrader.Upgrade(w, r, nil)
 if err != nil {
 log.Println("upgrade failed:", err)
 return
 }
 defer conn.Close()

 // 读取消息
 for {
 messageType, msg, err := conn.ReadMessage()
 if err != nil {
 log.Println("read failed:", err)
 break
 }
 log.Printf("received: %s", msg)

 // 发送消息
 err = conn.WriteMessage(messageType, msg)
 if err != nil {
 log.Println("write failed:", err)
 break
 }
 }
}

func main() {
 http.HandleFunc("/ws", wsHandler)
 fmt.Println("WebSocket server started at :8080")
 log.Fatal(http.ListenAndServe(":8080", nil))
}

最基本的 Demo

前端代码

<!DOCTYPE html>
<html>
<head>
 <title>WebSocket Demo</title>
</head>
<body>
 <h2>WebSocket Client</h2>
 <input type="text" id="message" placeholder="输入消息">
 <button onclick="sendMessage()">发送</button>
 <div id="output"></div>

 <script>
 const ws = new WebSocket("ws://localhost:8080/ws");

 ws.onopen = () => {
 console.log("Connected to WebSocket");
 addMessage("已连接服务器");
 };

 ws.onmessage = (event) => {
 addMessage("收到: " + event.data);
 };

 ws.onclose = () => {
 addMessage("连接已关闭");
 };

 function sendMessage() {
 const msg = document.getElementById("message").value;
 ws.send(msg);
 addMessage("发送: " + msg);
 }

 function addMessage(msg) {
 document.getElementById("output").innerHTML += 
 "<p>" + msg + "</p>";
 }
 </script>
</body>
</html>

运行步骤

# 1. 安装依赖
go get github.com/gorilla/websocket

# 2. 运行服务器
go run server.go

# 3. 浏览器打开 index.html

功能升级你需要了解的

1. 心跳机制

保持连接活跃，防止被中间设备断开：

// 心跳 Ping-Pong
type Hub struct {
 clients map[*websocket.Conn]bool
 broadcast chan []byte
 register chan *websocket.Conn
 unregister chan *websocket.Conn
}

func (h *Hub) readPump(conn *websocket.Conn) {
 defer func() {
 h.unregister <- conn
 conn.Close()
 }()
 
 conn.SetReadDeadline(time.Now().Add(60 * time.Second))
 conn.SetPongHandler(func(string) error {
 conn.SetReadDeadline(time.Now().Add(60 * time.Second))
 return nil
 })
 
 for {
 _, msg, err := conn.ReadMessage()
 if err != nil {
 break
 }
 h.broadcast <- msg
 }
}

func (h *Hub) writePump(conn *websocket.Conn) {
 ticker := time.NewTicker(30 * time.Second)
 defer func() {
 ticker.Stop()
 conn.Close()
 }()
 
 for {
 select {
 case <-ticker.C:
 conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
 return
 }
 }
 }
}

2. 断线重连

function connect() {
 ws = new WebSocket("ws://localhost:8080/ws");
 
 ws.onclose = () => {
 console.log("Connection closed, reconnecting...");
 setTimeout(connect, 3000); // 3秒后重连
 };
}

3. 消息类型

// 文本消息
websocket.TextMessage

// 二进制消息
websocket.BinaryMessage

// Ping 消息
websocket.PingMessage

// Pong 消息
websocket.PongMessage

// 关闭消息
websocket.CloseMessage

总结

WebSocket 实现了真正的全双工通信
基于 HTTP 握手协议建立连接
Go 语言通过 gorilla/websocket 库可以轻松实现 WebSocket 服务
生产环境需要考虑：心跳机制、断线重连、安全认证等

参考资料

微服务配置中心小实验

Sun, 25 Jul 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第8章内容过程中，动手做的小实验，涉及 Spring Cloud Config 和 YAML 相关知识。

配置中心概念

┌─────────────────────────────────────────────────────────────┐
│ 配置中心架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ │
│ │ 配置中心 │ │
│ │ Config Server│◀──── Git/SVN/Nacos │
│ └──────┬───────┘ │
│ │ │
│ │ 拉取/推送 │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ 微服务集群 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐│ │
│ │ │Service A│ │Service B│ │Service C││ │
│ │ └─────────┘ └─────────┘ └─────────┘│ │
│ └─────────────────────────────────────────┘ │
│ │
│ 特性： │
│ • 配置集中管理 │
│ • 配置热更新 │
│ • 环境隔离（dev/staging/prod） │
│ • 版本控制 │
│ │
└─────────────────────────────────────────────────────────────┘

Spring Cloud Config 简介

Spring Cloud Config 为分布式系统的外部配置提供了服务端和客户端支持。

核心特性

特性	说明
配置集中管理	所有配置存储在 Git 仓库
环境隔离	dev、test、prod 环境分离
配置加密	支持敏感配置加密存储
动态刷新	无需重启即可更新配置
高可用	支持集群部署

准备 Spring Boot 环境

macOS 安装

# 使用 Homebrew 安装
brew tap spring-io/tap
brew install spring-boot

# 或安装 Spring CLI
brew install springboot

快速开始

创建 app.groovy：

@RestController
class ThisWillActuallyRun {
 @RequestMapping("/")
 String home() {
 "Hello World!"
 }
}

运行：

spring run app.groovy

创建配置中心服务端

项目结构

config-server/
├── pom.xml
├── src/main/java/com/example/configserver/
│ └── ConfigServerApplication.java
└── config/
 └── application.yml

Maven 依赖 (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.5.2</version>
 </parent>
 
 <dependencies>
 <!-- Spring Cloud Config Server -->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-config-server</artifactId>
 </dependency>
 
 <!-- Eureka 服务发现（可选）-->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
 </dependency>
 </dependencies>
 
 <dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>2020.0.2</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
 </dependencyManagement>
</project>

启动类

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
 public static void main(String[] args) {
 SpringApplication.run(ConfigServerApplication.class, args);
 }
}

配置文件

# application.yml
server:
 port: 8888

spring:
 application:
 name: config-server
 cloud:
 config:
 server:
 git:
 uri: https://github.com/your-org/config-repo
 search-paths: config/{application}
 username: your-github-username
 default-label: main

配置仓库结构

config-repo/
├── config/
│ ├── user-service/
│ │ ├── application.yml # 默认配置
│ │ ├── application-dev.yml # 开发环境
│ │ ├── application-test.yml # 测试环境
│ │ └── application-prod.yml # 生产环境
│ └── order-service/
│ └── application.yml
└── README.md

示例配置

# user-service/application.yml
server:
 port: ${PORT:8080}

spring:
 application:
 name: user-service
 datasource:
 url: jdbc:mysql://localhost:3306/user_db
 username: root
 password: ${DB_PASSWORD}
 redis:
 host: ${REDIS_HOST:localhost}
 port: ${REDIS_PORT:6379}

# 用户服务配置
user:
 cache:
 ttl: 3600
 max-size: 1000
 rate-limit:
 qps: 100

# user-service/application-dev.yml
spring:
 datasource:
 url: jdbc:mysql://localhost:3306/user_db_dev
 password: dev_password
 redis:
 host: localhost

user:
 rate-limit:
 qps: 10 # 开发环境限流放宽

Go 客户端接入

安装依赖

go get github.com/spf13/viper
go get github.com/go-laoji/go-config

Viper 配置

// config/config.go
package config

import (
 "fmt"
 "github.com/spf13/viper"
)

type Config struct {
 App AppConfig `mapstructure:"app"`
 Database DatabaseConfig `mapstructure:"database"`
 Redis RedisConfig `mapstructure:"redis"`
 User UserConfig `mapstructure:"user"`
}

type AppConfig struct {
 Name string `mapstructure:"name"`
 Port int `mapstructure:"port"`
}

type DatabaseConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Username string `mapstructure:"username"`
 Password string `mapstructure:"password"`
 Name string `mapstructure:"name"`
}

type RedisConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Password string `mapstructure:"password"`
 DB int `mapstructure:"db"`
}

type UserConfig struct {
 Cache CacheConfig `mapstructure:"cache"`
 RateLimit RateLimitConfig `mapstructure:"rate-limit"`
}

type CacheConfig struct {
 TTL int `mapstructure:"ttl"`
 MaxSize int `mapstructure:"max-size"`
}

type RateLimitConfig struct {
 QPS int `mapstructure:"qps"`
}

var GlobalConfig *Config

func LoadConfig(configServer, appName, profile string) (*Config, error) {
 v := viper.New()
 
 // 设置配置中心地址
 configURL := fmt.Sprintf("http://%s/%s/%s", configServer, appName, profile)
 v.SetConfigType("yaml")
 
 // 从配置中心获取配置
 if err := v.SafeGetConfigFile(configURL); err != nil {
 // 尝试直接读取
 v.SetConfigFile(fmt.Sprintf("config/%s.yml", profile))
 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }
 }
 
 var cfg Config
 if err := v.Unmarshal(&cfg); err != nil {
 return nil, err
 }
 
 GlobalConfig = &cfg
 return &cfg, nil
}

// 本地配置（备用）
func LoadLocalConfig() (*Config, error) {
 v := viper.New()
 
 v.SetConfigName("config")
 v.SetConfigType("yaml")
 v.AddConfigPath("./config")
 
 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }
 
 var cfg Config
 if err := v.Unmarshal(&cfg); err != nil {
 return nil, err
 }
 
 GlobalConfig = &cfg
 return &cfg, nil
}

若配置中心不可用，LoadLocalConfig() 可作为本地开发与灾备兜底；关键是保证 profile、密钥与 环境变量注入 在流水线与运行时一致。

微服务注册发现小实验

Tue, 20 Jul 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第6章内容过程中，动手做的小实验，涉及 Consul 和 go-kit 相关知识。

Consul 简介

┌─────────────────────────────────────────────────────────────┐
│ Consul 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Consul │ │ Consul │ │ Consul │ │
│ │ Server │ │ Server │ │ Server │ │
│ │ (Leader)│ │(Follow) │ │(Follow) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ └───────────┴───────────┘ │
│ │ │
│ ┌─────────┴─────────┐ │
│ │ │ │
│ ┌────▼────┐ ┌────▼────┐ │
│ │ Consul │ │ Consul │ │
│ │ Agent │ │ Agent │ │
│ │ (Node1) │ │ (Node2) │ │
│ └────┬────┘ └────┬────┘ │
│ │ │ │
│ ┌────▼────┐ ┌────▼────┐ │
│ │ Service │ │ Service │ │
│ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

安装 Consul

下载安装

# macOS
brew install consul

# Linux
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install consul

# Docker
docker run -d --name=consul consul agent -dev -client=0.0.0.0

验证安装

consul --version
# Consul v1.10.0

Consul 基本操作

单机启动

# 开发模式启动
consul agent -dev

# 访问 UI
# http://127.0.0.1:8500/ui

集群启动

# 机器 1：主节点
consul agent -server \n -bootstrap-expect=1 \n -data-dir=/tmp/consul \n -node=consul-server-1 \n -bind=10.0.0.52 \n -ui

# 机器 2：加入集群
consul agent \n -data-dir=/tmp/consul \n -node=consul-server-2 \n -bind=10.0.0.53

# 在机器 2 执行加入
consul join 10.0.0.52

注册服务

# 注册服务（通过 HTTP API）
curl -X PUT -d '{
 "ID": "user-service-1",
 "Name": "user-service",
 "Tags": ["v1", "go"],
 "Address": "127.0.0.1",
 "Port": 8080,
 "Check": {
 "HTTP": "http://127.0.0.1:8080/health",
 "Interval": "10s",
 "Timeout": "5s"
 }
}' http://127.0.0.1:8500/v1/agent/service/register

# 注销服务
curl -X PUT http://127.0.0.1:8500/v1/agent/service/deregister/user-service-1

服务发现

# 查找服务
curl http://127.0.0.1:8500/v1/catalog/service/user-service

# DNS 查询
# user-service.service.consul

# 健康检查
curl http://127.0.0.1:8500/v1/health/service/user-service?passing=true

Go 微服务注册发现

项目结构

consul-demo/
├── main.go # 主程序
├── user/ # 用户服务
│ └── user.go
├── discovery/ # 服务发现封装
│ └── consul.go
└── go.mod

安装依赖

go get github.com/go-kit/kit/sd/consul
go get github.com/hashicorp/consul

Consul 客户端封装

// discovery/consul.go
package discovery

import (
 "fmt"
 "time"
 
 "github.com/go-kit/kit/sd"
 "github.com/go-kit/kit/sd/consul"
 "github.com/go-kit/kit/sd/lazy"
 "github.com/go-kit/kit/endpoint"
 "github.com/hashicorp/consul/api"
)

type Client struct {
 client consul.Client
 instancer *consul.Instancer
}

func NewConsulClient(consulAddr string) (*Client, error) {
 // 创建 Consul 客户端
 config := api.DefaultConfig()
 config.Address = consulAddr
 
 consulClient, err := api.NewClient(config)
 if err != nil {
 return nil, err
 }
 
 // 创建服务注册实例化工具
 client, err := consul.NewClient(consulClient)
 if err != nil {
 return nil, err
 }
 
 return &Client{client: client}, nil
}

// 注册服务
func (c *Client) Register(serviceName, serviceID string, addr string, port int) error {
 // 健康检查
 check := api.AgentServiceCheck{
 HTTP: fmt.Sprintf("http://%s:%d/health", addr, port),
 Interval: "10s",
 Timeout: "5s",
 Notes: "Health check for " + serviceName,
 }
 
 // 服务注册信息
 registration := api.AgentServiceRegistration{
 ID: serviceID,
 Name: serviceName,
 Tags: []string{"v1"},
 Address: addr,
 Port: port,
 EnableTagOverride: false,
 Check: &check,
 }
 
 return c.client.Register(&registration)
}

// 注销服务
func (c *Client) Deregister(serviceName, serviceID string) error {
 return c.client.Deregister(&api.AgentServiceRegistration{
 ID: serviceID,
 Name: serviceName,
 })
}

// 创建服务实例化工具
func (c *Client) GetInstancer(serviceName string) sd.Instancer {
 return consul.NewInstancer(c.client, nil, serviceName, []string{}, true)
}

// 工厂函数创建 endpoint
func instanceFactory(serviceURL string) endpoint.Endpoint {
 return func(ctx context.Context, request interface{}) (interface{}, error) {
 // 调用远程服务
 return nil, nil
 }
}

// 创建端点订阅器
func (c *Client) GetEndpointer(serviceName string) sd.Endpointer {
 instancer := c.GetInstancer(serviceName)
 return lazy.NewEndpointer(instancer, instanceFactory, nil)
}

服务端实现

// user/server.go（演示：注册到 Consul + 提供 /health）
package main

import (
 "context"
 "encoding/json"
 "fmt"
 stdlog "log"
 "net"
 "net/http"
 "os"
 "os/signal"
 "syscall"
 "time"

 kitlog "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
)

const (
 ServiceName = "user-service"
 ServicePort = 8080
)

type UserService struct{}

func (s *UserService) GetUser(ctx context.Context, id int64) (*User, error) {
 return &User{
 ID: id,
 Name: fmt.Sprintf("User-%d", id),
 Age: 20 + int(id%30),
 }, nil
}

type User struct {
 ID int64 `json:"id"`
 Name string `json:"name"`
 Age int `json:"age"`
}

func pickAdvertiseIP() string {
 addrs, err := net.InterfaceAddrs()
 if err != nil {
 return "127.0.0.1"
 }
 for _, a := range addrs {
 ipnet, ok := a.(*net.IPNet)
 if !ok || ipnet.IP.IsLoopback() {
 continue
 }
 if v4 := ipnet.IP.To4(); v4 != nil {
 return v4.String()
 }
 }
 return "127.0.0.1"
}

func main() {
 logger := kitlog.NewLogfmtLogger(os.Stderr)
 logger = kitlog.With(logger, "ts", kitlog.DefaultTimestampUTC)

 cfg := api.DefaultConfig()
 cfg.Address = "127.0.0.1:8500"

 client, err := api.NewClient(cfg)
 if err != nil {
 stdlog.Fatalf("consul client: %v", err)
 }

 addr := pickAdvertiseIP()
 serviceID := fmt.Sprintf("%s-%d", ServiceName, ServicePort)

 reg := &api.AgentServiceRegistration{
 ID: serviceID,
 Name: ServiceName,
 Address: addr,
 Port: ServicePort,
 Check: &api.AgentServiceCheck{
 HTTP: fmt.Sprintf("http://%s:%d/health", addr, ServicePort),
 Interval: "10s",
 },
 }

 if err := client.Agent().ServiceRegister(reg); err != nil {
 stdlog.Fatalf("register: %v", err)
 }

 svc := &UserService{}
 mux := http.NewServeMux()
 mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
 w.WriteHeader(http.StatusOK)
 _, _ = w.Write([]byte("ok"))
 })
 mux.HandleFunc("/user/", func(w http.ResponseWriter, r *http.Request) {
 u, err := svc.GetUser(r.Context(), 1)
 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }
 w.Header().Set("Content-Type", "application/json")
 _ = json.NewEncoder(w).Encode(u)
 })

 srv := &http.Server{
 Addr: fmt.Sprintf(":%d", ServicePort),
 Handler: mux,
 }

 go func() {
 _ = logger.Log("msg", "listening", "port", ServicePort)
 if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 stdlog.Fatal(err)
 }
 }()

 quit := make(chan os.Signal, 1)
 signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 <-quit

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 _ = srv.Shutdown(ctx)
 _ = client.Agent().ServiceDeregister(serviceID)
}

进程退出前注销服务，可避免 Consul 里留下僵尸实例；生产环境还需配置正确的 健康检查 URL、ACL Token 与 多实例 ID。

GRPC一点通

Sat, 17 Jul 2021 00:00:00 +0000

gRPC 是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。带来双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特性。

什么是 gRPC

┌─────────────────────────────────────────────────────────────┐
│ gRPC 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Client Server │
│ │ │ │
│ │ ─────── HTTP/2 ───────────▶ │ │
│ │ Protobuf 序列化 │ │
│ │ │ │
│ │◀─────── Protobuf ───────────│ │
│ │ │ │
│ │
│ 特性： │
│ • HTTP/2 传输 │
│ • Protobuf 序列化 │
│ • 多语言支持 │
│ • 双向流 │
│ • 强类型定义 │
│ │
└─────────────────────────────────────────────────────────────┘

环境准备

安装 Protobuf 编译器

# macOS
brew install protobuf

# Linux
apt install protobuf-compiler

# Windows
# 下载 https://github.com/protocolbuffers/protobuf/releases

安装 Go 工具

# gRPC 核心库
go get -u google.golang.org/grpc

# Protobuf 插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# gRPC Gateway（HTTP 转 gRPC）
go install github.com/grpc-ecosystem/grpc-gateway/v2/cmd/protoc-gen-grpc-gateway@latest

# 添加到 PATH
export PATH="$PATH:$(go env GOPATH)/bin"

定义服务

创建项目

mkdir grpc-demo && cd grpc-demo
go mod init grpc-demo
mkdir helloworld

编写 Proto 文件

// helloworld/simple.proto
syntax = "proto3";

option go_package = "grpc-demo/helloworld";

package helloworld;

// Greeting 服务定义
service Greeter {
 // 简单 RPC
 rpc SayHello (HelloRequest) returns (HelloReply) {}
 
 // 服务端流式 RPC
 rpc SayHelloServerStream (HelloRequest) returns (stream HelloReply) {}
 
 // 客户端流式 RPC
 rpc SayHelloClientStream (stream HelloRequest) returns (HelloReply) {}
 
 // 双向流式 RPC
 rpc SayHelloBidirectionalStream (stream HelloRequest) returns (stream HelloReply) {}
}

// 请求消息
message HelloRequest {
 string name = 1;
 int32 age = 2;
}

// 响应消息
message HelloReply {
 string message = 1;
 string timestamp = 2;
}

生成 Go 代码

# 生成 gRPC 代码
protoc --go_out=. --go_opt=paths=source_relative \n --go-grpc_out=. --go-grpc_opt=paths=source_relative \n helloworld/simple.proto

# 查看生成的文件
ls -la helloworld/
# simple.pb.go - Protobuf 消息定义
# simple_grpc.pb.go - gRPC 服务定义

实现 gRPC 服务

// helloworld/server.go
package main

import (
 "context"
 "fmt"
 "log"
 "net"
 
 "google.golang.org/grpc"
 pb "grpc-demo/helloworld"
)

type server struct {
 pb.UnimplementedGreeterServer
}

// 简单 RPC 实现
func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{
 Message: fmt.Sprintf("Hello, %s! You are %d years old.", req.Name, req.Age),
 Timestamp: fmt.Sprintf("%d", time.Now().Unix()),
 }, nil
}

// 服务端流式 RPC 实现
func (s *server) SayHelloServerStream(req *pb.HelloRequest, stream pb.Greeter_SayHelloServerStreamServer) error {
 for i := 0; i < 5; i++ {
 msg := fmt.Sprintf("Hello %s (stream %d)", req.Name, i+1)
 if err := stream.Send(&pb.HelloReply{Message: msg}); err != nil {
 return err
 }
 time.Sleep(500 * time.Millisecond)
 }
 return nil
}

// 客户端流式 RPC 实现
func (s *server) SayHelloClientStream(stream pb.Greeter_SayHelloClientStreamServer) error {
 var names []string
 for {
 req, err := stream.Recv()
 if err == io.EOF {
 return stream.SendAndClose(&pb.HelloReply{
 Message: fmt.Sprintf("Hello %v!", names),
 })
 }
 if err != nil {
 return err
 }
 names = append(names, req.Name)
 }
}

// 双向流式 RPC 实现
func (s *server) SayHelloBidirectionalStream(stream pb.Greeter_SayHelloBidirectionalStreamServer) error {
 for {
 req, err := stream.Recv()
 if err == io.EOF {
 return nil
 }
 if err != nil {
 return err
 }
 
 msg := fmt.Sprintf("Hello %s!", req.Name)
 if err := stream.Send(&pb.HelloReply{Message: msg}); err != nil {
 return err
 }
 }
}

func main() {
 lis, err := net.Listen("tcp", ":50051")
 if err != nil {
 log.Fatalf("failed to listen: %v", err)
 }
 
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})
 
 log.Println("gRPC server started on :50051")
 if err := s.Serve(lis); err != nil {
 log.Fatalf("failed to serve: %v", err)
 }
}

实现 gRPC 客户端

// helloworld/client.go
package main

import (
 "context"
 "fmt"
 "log"
 "time"
 
 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials/insecure"
 pb "grpc-demo/helloworld"
)

func main() {
 // 连接 gRPC 服务器
 conn, err := grpc.Dial(":50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
 if err != nil {
 log.Fatalf("did not connect: %v", err)
 }
 defer conn.Close()
 
 client := pb.NewGreeterClient(conn)
 
 // 调用简单 RPC
 ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 defer cancel()
 
 r, err := client.SayHello(ctx, &pb.HelloRequest{Name: "World", Age: 25})
 if err != nil {
 log.Fatalf("could not greet: %v", err)
 }
 log.Printf("Greeting: %s", r.GetMessage())
}

添加 HTTP Gateway

安装依赖

go get google.golang.org/grpc/proto

Gateway 服务

// gateway/main.go
package main

import (
 "context"
 "fmt"
 "net/http"
 
 "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials/insecure"
 pb "grpc-demo/helloworld"
)

func main() {
 ctx := context.Background()
 ctx, cancel := context.WithCancel(ctx)
 defer cancel()
 
 mux := runtime.NewServeMux()
 opts := []grpc.DialOption{
 grpc.WithTransportCredentials(insecure.NewCredentials()),
 }
 
 err := pb.RegisterGreeterHandlerFromEndpoint(ctx, mux, ":50051", opts)
 if err != nil {
 log.Fatalf("failed to register gateway: %v", err)
 }
 
 http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 mux.ServeHTTP(w, r)
 })
 
 log.Println("HTTP Gateway started on :8080")
 http.ListenAndServe(":8080", nil)
}

启动服务

# 终端 1: 启动 gRPC 服务
go run helloworld/server.go

# 终端 2: 启动 HTTP Gateway
go run gateway/main.go

# 测试 HTTP 接口
curl -X POST http://localhost:8080/helloworld.Greeter/SayHello \n -H "Content-Type: application/json" \n -d '{"name": "World", "age": 25}'

四种 RPC 模式

模式	说明
Unary（一元）	客户端发起一次请求，服务端返回一次响应；最常见，类似普通 HTTP JSON。
Server streaming（服务端流）	客户端一次请求，服务端以流多次推送数据；适合大列表、订阅通知。
Client streaming（客户端流）	客户端多次写入流，服务端最终一次汇总响应；适合批量上传、日志汇总。
Bidirectional streaming（双向流）	两端可同时读写流；适合聊天、协作编辑、实时推送等对「管道」建模的场景。

选型上：能用 Unary 就不用流式；若业务本身是「按需拉取一块块数据」，优先考虑 Server streaming；必须在单连接上交织多条请求/响应时（如 HTTP/2 多路复用语义），再结合双向流评估。

小结

掌握四种模式后，阅读 .proto 里的 rpc 定义会更直观：stream 关键字出现在请求侧、响应侧或两侧，分别对应上述三种流式形态。

《Go语言编程》☞鉴赏

Thu, 03 Dec 2020 00:00:00 +0000

在读这本书之前，我已经熟悉了Go的语法，并编码实现了具体的应用。但这本书据说详细解读了Go语言的诞生背景和作者的设计初衷&理念，所以，带着好奇的心态读了这本书，顺带查缺补漏。

前言

Go语言官方自称，之所以开发Go 语言，是因为“近10年来开发程序之难让我们有点沮丧”。
这一定位暗示了Go语言希望取代C和Java的地位，成为最流行的通用开发语言。

Go希望成为互联网时代的C语言。多数系统级语言（包括Java和C#）的根本编程哲学来源于C++，将C++的面向对象进一步发扬光大。但是Go语言的设计者却有不同的看法，他们认为C++ 真的没啥好学的，值得学习的是C语言。

C语言经久不衰的根源是它足够简单。因此，Go语言也要足够简单！

如果一个特性并不对解决任何问题有显著的价值，那么Go就不提供它

并发与分布式

多核化和集群化是互联网时代的典型特征，那语言需要哪些特性来应对这些特征呢？

并发执行的“执行体”
执行体是个抽象的概念，在操作系统层面有多个概念与之对应，比如操作系统自己掌管的进程（process）、进程内的线程（thread）以及进程内的协程（coroutine，也叫轻量级线程）。

多数语言在语法层面并不直接支持协程，而通过库的方式支持的协程的功能也并不完整，比如仅仅提供协程的创建、销毁与切换等能力。如果在这样的协程中调用一个同步IO操作，比如网络通信、本地文件读写，都会阻塞其他的并发执行协程，从而无法真正达到协程本身期望达到的目标。

Go语言在语言级别支持协程，叫goroutine。Go语言标准库提供的所有系统调用（syscall）操作，当然也包括所有同步IO操作，都会出让CPU给其他goroutine，这让事情变得非常简单。我们对比一下Java和Go，近距离观摩下两者对“执行体”的支持。

为了简化，我们在样例中使用的是Java标准库中的线程，而不是协程，具体代码如下：

public class MyThread implements Runnable { 
 	String arg; 
	public MyThread(String a) { 
 		arg = a; 
 	} 
	public void run() { 
 		// ... 
 	} 
	public static void main(String[] args) { 
		new Thread(new MyThread("test")).start(); 
 		// ... 
 	}
}

相同功能的代码，在Go语言中是这样的：

func run(arg string) { 
 	// ... 
} 
func main() { 
	go run("test") 
 	... 
}

对比非常鲜明。我相信你已经明白为什么Go语言会叫Go语言了：Go语言献给这个时代最好的礼物，就是加了go这个关键字。

“执行体间的通信”
执行体间的通信包含几个方式：

执行体之间的互斥与同步
- 当执行体之间存在共享资源（一般是共享内存）时，为保证内存访问逻辑的确定性，需要对访问该共享资源的相关执行体进行互斥。当多个执行体之间的逻辑存在时序上的依赖时，也往往需要在执行体之间进行同步。
- 互斥与同步是执行体间最基础的交互方式。
- 多数语言在库层面提供了线程间的互斥与同步支持，那么协程之间的互斥与同步呢？
  - 呃，不好意思，没有。
执行体之间的消息传递
- 在并发编程模型的选择上，有两个流派，一个是共享内存模型，一个是消息传递模型。
- 多数传统语言选择了前者，少数语言选择后者，其中选择“消息传递模型”的最典型代表是Erlang语言。业界有专门的术语叫“Erlang风格的并发模型”，其主体思想是两点：一是“轻量级的进程（Erlang中‘进程’这个术语就是我们上面说的‘执行体’）”，二是“消息乃进程间通信的唯一方式”。
- Go语言推荐采用“Erlang风格的并发模型”的编程范式，尽管传统的“共享内存模型”仍然被保留，允许适度地使用。在Go语言中内置了消息队列的支持，只不过它叫通道（channel）。两个goroutine之间可以通过通道来进行交互。

软件工程

单机时代的语言可以只关心问题本身的解决，但是随着工程规模的不断扩大，软件复杂度的不断增加，软件工程也成为语言设计层面要考虑的重要课题。

多数软件需要一个团队共同去完成，在团队协作的过程中，人们需要建立统一的交互语言来降低沟通的成本。规范化体现在多个层面，如：

代码风格规范
错误处理规范
包管理
契约规范（接口）
单元测试规范
功能开发的流程规范

Go语言很可能是第一个将代码风格强制统一的语言，例如Go语言要求public的变量必须以大写字母开头，private变量则以小写字母开头，这种做法不仅免除了public、private关键字，更重要的是统一了命名风格。

另外，Go语言对{ }应该怎么写进行了强制，比如以下风格是正确的：

if expression { 
 ... 
}

但下面这个写法就是错误的：

if expression 
{ 
 ... 
}

而C和Java语言中则对花括号的位置没有任何要求。哪种更有利，这个见仁见智。但很显然的是，所有的Go代码的花括号位置肯定是非常统一的。

最有意思的其实还是 Go 语言首创的错误处理规范：

f, err := os.Open(filename) 
if err != nil { 
 	log.Println("Open file failed:", err) 
 	return 
} 
defer f.Close() 
... // 操作已经打开的f文件

defer语句的含义是不管程序是否出现异常，均在函数退出时自动执行相关代码。
Go语言的函数允许返回多个值。

大多数函数的最后一个返回值会为error类型，以在错误情况下返回详细信息。
error类型只是一个系统内置的interface，如下：

type error interface { 
 	Error() string
}

有了error类型，程序出现错误的逻辑看起来就相当统一。

在Java中，你可能这样写代码来保证资源正确释放：

try { 
 	Statement stmt = ...; 
	try { 
 		ResultSet rset = ...; 
		try { 
 			... // 正常代码
 		} 
		finally { 
 			rset.close(); 
 		} 
 	} 
	finally { 
 		stmt.close(); 
 	} 
} 
finally { 
conn.close(); 
}

完成同样的功能，相应的Go代码只需要写成这样：

conn := ... 
defer conn.Close() 
stmt := ... 
defer stmt.Close() 
rset := ... 
defer rset.Close() 
... // 正常代码

对比两段代码，Go语言处理错误的优势显而易见。当然，其实Go语言带给我们的惊喜还有很多。

编程哲学

计算机软件经历了数十年的发展，形成了多种学术流派，有面向过程编程、面向对象编程、函数式编程、面向消息编程等，这些思想究竟孰优孰劣，众说纷纭。 C语言是纯过程式的，这和它产生的历史背景有关。Java语言则是激进的面向对象主义推崇者，典型表现是它不能容忍体系里存在孤立的函数。而Go语言没有去否认任何一方，而是用批判吸收的眼光，将所有编程思想做了一次梳理，融合众家之长，但时刻警惕特性复杂化，极力维持语言特性的简洁，力求小而精。从编程范式的角度来说，Go语言是变革派，而不是改良派。对于C++、Java和C#等语言为代表的面向对象（OO）思想体系，Go语言总体来说持保守态度，有限吸收。首先，Go语言反对函数和操作符重载（overload），而C++、Java和C#都允许出现同名函数或操作符，只要它们的参数列表不同。虽然重载解决了一小部分面向对象编程（OOP）的问题，但同样给这些语言带来了极大的负担。而Go语言有着完全不同的设计哲学，既然函数重载带来了负担，并且这个特性并不对解决任何问题有显著的价值，那么Go就不提供它。其次，Go语言支持类、类成员方法、类的组合，但反对继承，反对虚函数（virtual function）和虚函数重载。确切地说，Go也提供了继承，只不过是采用了组合的文法来提供：

type Foo struct { 
 	Base 
 	... 
} 
func (foo *Foo) Bar() { 
 	... 
}

再次，Go语言也放弃了构造函数（constructor）和析构函数（destructor）。由于Go语言中没有虚函数，也就没有vptr，支持构造函数和析构函数就没有太大的价值。本着“如果一个特性并不对解决任何问题有显著的价值，那么Go就不提供它”的原则，构造函数和析构函数就这样被Go语言的作者们干掉了。在放弃了大量的OOP特性后，Go语言送上了一份非常棒的礼物：接口（interface）。你可能会说，除了C这么原始的语言外，还有什么语言没有接口呢？是的，多数语言都提供接口，但它们的接口都不同于Go语言的接口。 Go语言中的接口与其他语言最大的一点区别是它的非侵入性。在C++、Java和C#中，为了实现一个接口，你需要从该接口继承，具体代码如下：

class Foo implements IFoo { // Java文法
 	... 
} 
class Foo : public IFoo { // C++文法
 	... 
} 
IFoo* foo = new Foo; 
在Go语言中，实现类的时候无需从接口派生，具体代码如下：
type Foo struct { // Go 文法
 	... 
} 
var foo IFoo = new(Foo)

只要Foo实现了接口IFoo要求的所有方法，就实现了该接口，可以进行赋值。 Go语言的非侵入式接口，看似只是做了很小的文法调整，实则影响深远。其一，Go语言的标准库再也不需要绘制类库的继承树图。你只需要知道这个类实现了哪些方法，每个方法是啥含义就足够了。其二，不用再纠结接口需要拆得多细才合理，比如我们实现了File类，它有下面这些方法：

Read(buf []byte) (n int, err error) 
Write(buf []byte) (n int, err error) 
Seek(off int64, whence int) (pos int64, err error) 
Close() error

那么，到底是应该定义一个IFile接口，还是应该定义一系列的IReader、IWriter、 ISeeker和ICloser接口，然后让File从它们派生好呢？事实上，脱离了实际的用户场景，讨论这两个设计哪个更好并无意义。问题在于，实现File类的时候，我怎么知道外部会如何用它呢？其三，不用为了实现一个接口而专门导入一个包，而目的仅仅是引用其中的某个接口的定义。在Go语言中，只要两个接口拥有相同的方法列表，那么它们就是等同的，可以相互赋值，如对于以下两个接口，第一个接口：

package one 
type ReadWriter interface { 
 	Read(buf [] byte) (n int, err error) 
 	Write(buf [] byte) (n int, err error) 
} 
第二个接口：
package two 
type IStream interface { 
 	Write(buf [] byte) (n int, err error) 
 	Read(buf [] byte) (n int, err error) 
}

这里我们定义了两个接口，一个叫one.ReadWriter，一个叫two.IStream，两者都定义了Read()和Write()方法，只是定义的次序相反。one.ReadWriter先定义了Read()再定义 Write()，而two.IStream反之。在Go语言中，这两个接口实际上并无区别，因为：

任何实现了one.ReadWriter接口的类，均实现了two.IStream；
任何one.ReadWriter接口对象可赋值给two.IStream，反之亦然；
在任何地方使用one.ReadWriter接口，与使用two.IStream并无差异。
所以在Go语言中，为了引用另一个包中的接口而导入这个包的做法是不被推荐的。因为多引用一个外部的包，就意味着更多的耦合。除了OOP外，近年出现了一些小众的编程哲学，Go语言对这些思想亦有所吸收。例如，Go 语言接受了函数式编程的一些想法，支持匿名函数与闭包。再如，Go语言接受了以Erlang语言为代表的面向消息编程思想，支持goroutine和通道，并推荐使用消息而不是共享内存来进行并发编程。总体来说，Go语言是一个非常现代化的语言，精小但非常强大。

Go语言特性

Go语言作为一门全新的静态类型开发语言，与当前的开发语言相比具备众多令人兴奋不已的新特性。

自动垃圾回收

我们可以先看下不支持垃圾回收的语言的资源管理方式，以下为一小段C语言代码：

void foo() 
{ 
 	char* p = new char[128]; 
 	... // 对p指向的内存块进行赋值
 	func1(p); // 使用内存指针
 	delete[] p; 
}

各种非预期的原因，比如由于开发者的疏忽导致最后的delete语句没有被调用，都会引发经典而恼人的内存泄露问题。
假如该函数被调用得非常频繁，那么我们观察该进程执行时，会发现该进程所占用的内存会一直疯长，直至占用所有系统内存并导致程序崩溃，而如果泄露的是系统资源的话，那么后果还会更加严重，最终很有可能导致系统崩溃。

如果使用Go语言实现，我们就完全不用考虑何时需要释放之前分配的内存的问题，系统会自动帮我们判断，并在合适的时候（比如CPU相对空闲的时候）进行自动垃圾收集工作。

更丰富的内置类型

支持几乎所有语言都支持的简单内置类型（比如整型和浮点型等）
Go语言也内置了一些比较新的语言中内置的高级类型，比如C#和Java中的数组和字符串。
除此之外，Go语言还内置了一个对于其他静态类型语言通常用库方式支持的字典类型（map）。
另外有一个新增的数据类型：数组切片（Slice）。我们可以认为数组切片是一种可动态增长的数组。

这几种数据结构基本上覆盖了绝大部分的应用场景。

函数多返回值

目前的主流语言中除Python外基本都不支持函数的多返回值功能，不是没有这类需求，可能是语言设计者没有想好该如何提供这个功能，或者认为这个功能会影响语言的美感。

Go语言革命性地在静态开发语言阵营中率先提供了多返回值功能。
这个特性让开发者可以从原来用各种比较别扭的方式返回多个值的痛苦中解脱出来，既不用再区分参数列表中哪几个用于输入，哪几个用于输出，也不用再只为了返回多个值而专门定义一个数据结构。

例如：

func getName()(firstName, middleName, lastName, nickName string){ 
	return "May", "M", "Chen", "Babe" 
}

因为返回值都已经有名字，因此各个返回值也可以用如下方式来在不同的位置进行赋值，从而提供了极大的灵活性：

func getName()(firstName, middleName, lastName, nickName string){ 
 	firstName = "May" 
 	middleName = "M" 
 	lastName = "Chen" 
 	nickName = "Babe" 
	return 
}

并不是每一个返回值都必须赋值，没有被明确赋值的返回值将保持默认的空值。而函数的调用相比C/C++语言要简化很多：

fn, mn, ln, nn := getName()

如果开发者只对该函数其中的某几个返回值感兴趣的话，也可以直接用下划线作为占位符来忽略其他不关心的返回值。下面的调用表示调用者只希望接收lastName的值，这样可以避免声明完全没用的变量：

_, _, lastName, _ := getName()

错误处理

Go语言引入了3个关键字用于标准的错误处理流程，这3个关键字分别为defer、panic和recover。

整体上而言与C++和Java等语言中的异常捕获机制相比，Go语言的错误处理机制可以大量减少代码量，让开发者也无需仅仅为了程序安全性而添加大量一层套一层的try-catch语句，这对于代码的阅读者和维护者来说也是一件很好的事情。

匿名函数和闭包

Go语言支持常规的匿名函数和闭包，比如下列代码就定义了一个名为f的匿名函数，开发者可以随意对该匿名函数变量进行传递和调用：

f := func(x, y int) int { 
	return x + y 
}

类型和接口

Go语言的类型定义非常接近于C语言中的结构（struct），甚至直接沿用了struct关键字。相比而言，Go语言并没有直接沿袭C++和Java的传统去设计一个超级复杂的类型系统，不支持继承和重载，而只是支持了最基本的类型组合功能。

巧妙的是，虽然看起来支持的功能过于简洁，细用起来你却会发现，C++和Java使用那些复杂的类型系统实现的功能在Go语言中并不会出现无法表现的情况，这反而让人反思其他语言中引入这些复杂概念的必要性。

并发编程

Go语言引入了goroutine概念，它使得并发编程变得非常简单。通过使用goroutine而不是裸用操作系统的并发机制，以及使用消息传递来共享内存而不是使用共享内存来通信，Go语言让并发编程变得更加轻盈和安全。

通过在函数调用前使用关键字go，我们即可让该函数以goroutine方式执行。goroutine是一种比线程更加轻盈、更省资源的协程。Go语言通过系统的线程来多路派遣这些函数的执行，使得每个用go关键字执行的函数可以运行成为一个单位协程。当一个协程阻塞的时候，调度器就会自动把其他协程安排到另外的线程中去执行，从而实现了程序无等待并行化运行。而且调度的开销非常小，一颗CPU调度的规模不下于每秒百万次，这使得我们能够创建大量的goroutine，从而可以很轻松地编写高并发程序，达到我们想要的目的。

下面我们用一个简单的例子来演示goroutine和channel的使用方式。这是一个并行计算的例子，由两个goroutine进行并行的累加计算，待这两个计算过程都完成后打印计算结果：

package main 

import "fmt" 

func sum(values [] int, resultChan chan int) { 
	sum := 0 
	for _, value := range values { 
		sum += value 
	} 
	resultChan <- sum // 将计算结果发送到channel中
} 

func main() { 
	values := [] int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 
	resultChan := make(chan int, 2) 
	go sum(values[:len(values)/2], resultChan) 
	go sum(values[len(values)/2:], resultChan) 
 	sum1, sum2 := <-resultChan, <-resultChan // 接收结果
 	fmt.Println("Result:", sum1, sum2, sum1 + sum2) 
}

反射

反射（reflection）是在Java语言出现后迅速流行起来的一种概念。通过反射，你可以获取对象类型的详细信息，并可动态操作对象。反射是把双刃剑，功能强大但代码可读性并不理想。若非必要，我们并不推荐使用反射。

Go语言的反射实现了反射的大部分功能，但没有像Java语言那样内置类型工厂，故而无法做到像Java那样通过类型字符串创建对象实例。在Java中，你可以读取配置并根据类型名称创建对应的类型，这是一种常见的编程手法，但在Go语言中这并不被推荐。

语言交互性

由于Go语言与C语言之间的天生联系，Go语言的设计者们自然不会忽略如何重用现有C模块的这个问题，这个功能直接被命名为Cgo。Cgo既是语言特性，同时也是一个工具的名称。

在Go代码中，可以按Cgo的特定语法混合编写C语言代码，然后Cgo工具可以将这些混合的C代码提取并生成对于C功能的调用包装代码。开发者基本上可以完全忽略这个Go语言和C语言的边界是如何跨越的。

例如：

package main 

/* 
#include <stdio.h> 
*/ 
import "C" 
import "unsafe" 

func main() { 
 	cstr := C.CString("Hello, world") 
 	C.puts(cstr) 
 	C.free(unsafe.Pointer(cstr)) 
}

常用标准库

Go标准库可以大致按其中库的功能进行以下分类，这个分类比较简单，不求准确，但求能够帮助开发者根据自己模糊的需求更快找到自己需要的包。

输入输出。
- 这个分类包括二进制以及文本格式在屏幕、键盘、文件以及其他设备上的输入输出等，比如二进制文件的读写。对应于此分类的包有bufio、fmt、io、log和flag等，其中flag用于处理命令行参数。
文本处理。
- 这个分类包括字符串和文本内容的处理，比如字符编码转换等。对应于此分类的包有encoding、bytes、strings、strconv、text、mime、unicode、regexp、index和path等。其中path用于处理路径字符串。
网络。
- 这个分类包括开发网络程序所需要的包，比如Socket编程和网站开发等。对应于此分类的包有：net、http和expvar等。
系统。
- 这个分类包含对系统功能的封装，比如对操作系统的交互以及原子性操作等。对应于此分类的包有os、syscall、sync、time和unsafe等。
数据结构与算法。
- 对应于此分类的包有math、sort、container、crypto、hash、archive、compress和image等。因为image包里提供的图像编解码都是算法，所以也归入此类。
运行时。
- 对应于此分类的包有：runtime、reflect和go等。

最后

这本书还给我们深入讲解了很多有意思的东西，只有自己用心投入去阅读和享受才能真的有所收获，其中还剖析了音乐播放器、聊天系统、网页相册等实际项目例子&核心源代码，总的来说挺不错的，有兴趣的童鞋尽管认真地去翻阅、去学习、去尝试吧。

最后，让我们引用作者的话来结束本篇鉴赏吧。

在十余年的技术生涯中，我接触过、使用过、喜爱过不同的编程语言，但总体而言，Go语
言的出现是最让我兴奋的事情。

我个人对未来10年编程语言排行榜的趋势判断如下：
❤ Java语言的份额继续下滑，并最终被C和Go语言超越；
❤ C语言将长居编程榜第二的位置，并有望在Go取代Java前重获语言榜第一的宝座；
❤ Go语言最终会取代Java，居于编程榜之首。

由七牛云存储团队编著的这本书将尽可能展现出Go语言的迷人魅力。希望本书能够让更多
人理解这门语言，热爱这门语言，让这门优秀的语言能够落到实处，把程序员从以往繁杂的语言
细节中解放出来，集中精力开发更加优秀的系统软件。

许式伟
2012年3月7日

关于我

name: yison.li
github: https://github.com/yisonli

Go依赖管理工具

Sat, 09 May 2020 00:00:00 +0000

最早的时候，Go 所依赖的所有第三方库都放在 GOPATH 目录下。随着 Go 语言的发展，从 v1.5 开始引入 vendor 模式。本文介绍两个 Golang 官方依赖管理工具。

依赖管理演进

┌─────────────────────────────────────────────────────────────┐
│ Go 依赖管理演进 │
├─────────────────────────────────────────────────────────────┤
│ │
│ GOPATH 时代 ──▶ Vendor 时代 ──▶ dep 时代 ──▶ go mod 时代 │
│ (2012) (2014) (2017) (2018) │
│ │
└─────────────────────────────────────────────────────────────┘

dep（已过时）

⚠️ 提示：dep 已停止维护，建议使用 go modules。

安装

# macOS
brew install dep

# Linux
curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh

# Windows
go get -u github.com/golang/dep/cmd/dep

常用命令

命令	说明
`dep init`	初始化项目，生成 Gopkg.toml 和 Gopkg.lock
`dep status`	查看依赖状态
`dep ensure`	确保依赖已安装
`dep ensure -add`	添加新依赖
`dep ensure -update`	更新依赖版本
`dep check`	检查导入是否同步

使用示例

# 初始化项目
dep init

# 添加依赖
dep ensure -add github.com/spf13/viper

# 更新所有依赖
dep ensure -update

# 查看状态
dep status

配置文件

# Gopkg.toml
[[constraint]]
 name = "github.com/spf13/viper"
 version = "^1.6.0"

[[constraint]]
 name = "github.com/go-sql-driver/mysql"
 version = "^1.5.0"

go modules（推荐）

go modules 是 Go 1.11 引入的官方依赖管理方案，现在已是主流。

核心概念

概念	说明
Module	相关 Go 包的集合，是版本控制的单元
go.mod	模块定义文件，记录依赖关系
go.sum	依赖校验文件，确保构建一致性
GOPROXY	依赖代理服务器，加速下载

启用方式

# Go 1.11+ 默认启用
export GO111MODULE=on # 显式启用
export GO111MODULE=off # 禁用（使用 GOPATH）
export GO111MODULE=auto # 自动检测（默认）

常用命令

命令	说明
`go mod init`	初始化模块，生成 go.mod
`go mod tidy`	整理依赖（添加缺失，移除未用）
`go mod download`	下载依赖到本地缓存
`go mod vendor`	将依赖复制到 vendor 目录
`go mod graph`	打印依赖图
`go mod verify`	验证依赖是否正确
`go mod why`	解释为什么需要某依赖

初始化项目

# 在项目目录执行
go mod init github.com/username/project

# 或指定模块名
go mod init mymodule

go.mod 示例

module github.com/username/project

go 1.21

require (
 github.com/gin-gonic/gin v1.9.1
 github.com/go-sql-driver/mysql v1.7.1
 github.com/spf13/viper v1.16.0
)

require (
 github.com/bytedance/sonic v1.9.1 // indirect
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
 github.com/gabriel-vasile/mimetype v1.4.2 // indirect
)

go.sum 示例

github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YIdfeAwnHoK0S2RThAQPz7AH81q6Us=
github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=

完整使用流程

1. 创建新项目

# 创建项目目录
mkdir myproject && cd myproject

# 初始化模块
go mod init github.com/username/myproject

# 创建主文件
cat > main.go << 'EOF'
package main

import (
 "fmt"
 "github.com/gin-gonic/gin"
)

func main() {
 r := gin.Default()
 r.GET("/ping", func(c *gin.Context) {
 c.JSON(200, gin.H{"message": "pong"})
 })
 r.Run()
}
EOF

# 下载依赖并整理
go mod tidy

2. 添加依赖

# 方式一：go get
go get github.com/spf13/viper

# 指定版本
go get github.com/spf13/viper@v1.16.0

# 最新版本
go get github.com/spf13/viper@latest

# 指定分支
go get github.com/spf13/viper@master

# 指定 commit
go get github.com/spf13/viper@e3861e3

# 方式二：直接编辑 go.mod
echo 'github.com/redis/go-redis/v9 v9.0.0' >> go.mod
go mod tidy

3. 升级/降级依赖

# 升级到最新版本
go get -u github.com/gin-gonic/gin

# 升级到指定版本
go get github.com/gin-gonic/gin@v1.9.0

# 清理未使用的依赖
go mod tidy

4. 使用 vendor

# 将依赖复制到 vendor 目录
go mod vendor

# 查看 vendor 内容
ls vendor/

# 使用 vendor 构建
go build -mod=vendor

代理配置

设置 GOPROXY

# 阿里云代理（推荐国内使用）
go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/,direct

# 官方代理
go env -w GOPROXY=https://proxy.golang.org,direct

# 七牛云
go env -w GOPROXY=https://goproxy.cn,direct

# 多个代理（逗号分隔）
go env -w GOPROXY=https://goproxy.cn,https://proxy.golang.org,direct

代理参数

参数	说明
`direct`	直连源站
`off`	禁用代理
`=https://proxy.golang.org`	官方代理

私有模块

设置 GONOSUMDB

# 跳过校验的域名
go env -w GONOSUMDB="gitlab.com/mycompany/*"

设置 GOPRIVATE

# 私有模块不走代理
go env -w GOPRIVATE="gitlab.com/mycompany,github.com/myteam"

配置 netrc

# ~/.netrc
machine github.com
login your-username
password your-token

常见问题

Q: 依赖下载失败

# 清理缓存
go clean -modcache

# 设置国内镜像
go env -w GOPROXY=https://goproxy.cn,direct

Q: go.mod 和 go.sum 不同步

go mod tidy

Q: vendor 和 mod 冲突

# 删除 vendor，使用 go mod
rm -rf vendor
go mod tidy

Q: 循环导入

# 检查依赖图
go mod graph | grep ":"

最佳实践

始终使用 go mod tidy 保持依赖整洁
使用 vendor 确保构建可重复
使用国内镜像 加速下载
定期升级依赖 获取安全补丁
提交 go.sum 锁校验和到版本库，CI 使用 go mod verify 防止依赖被篡改。

微信消息编辑器 - Laravel Admin扩展

Sat, 07 Dec 2019 00:00:00 +0000

本文介绍 wxmsg，一个 Laravel Admin 的扩展工具。可视化地编辑待回复的微信消息，最终输出 JSON 格式。

简介

这是一个基于 laravel-admin 后台框架开发的扩展，可在 Form 表单中进行可视化编辑微信消息。

功能特点：

支持多种消息类型（文本、图片、图文、链接、小程序卡片）
消息类型切换自动更新编辑界面
支持多公众号关联
输出标准微信客服消息 JSON 格式

截图

可访问 GitHub 仓库查看完整截图

安装

使用 Composer 安装

composer require yisonli/wxmsg

发布资源

php artisan vendor:publish --tag=wxmsg-assets

基础用法

<?php

namespace App\\Admin\\Controllers;

use Encore\\Admin\\Controllers\\AdminController;
use App\\Models\\WechatReply;

class WechatReplyController extends AdminController
{
 protected function grid()
 {
 $grid = new Grid(new WechatReply());
 
 $grid->id('ID');
 $grid->app_id('公众号');
 $grid->msgtype('消息类型');
 $grid->content('回复内容');
 $grid->created_at('创建时间');
 $grid->updated_at('更新时间');
 
 return $grid;
 }
 
 protected function form()
 {
 $form = new Form(new WechatReply());
 
 // 选择公众号
 $form->select('app_id', '公众号')
 ->options(WechatApp::pluck('name', 'id'))
 ->rules('required');
 
 // 消息类型
 $form->select('msgtype', '回复消息类型')
 ->options([
 'text' => '文本',
 'image' => '图片',
 'news' => '图文',
 'link' => '链接',
 'miniprogrampage' => '小程序卡片',
 ])
 ->rules('required');
 
 // 微信消息编辑器
 $form->wxmsg('content', '回复内容');
 
 return $form;
 }
}

高级用法

关联消息类型

当消息类型字段使用自定义定义方式时，可用 relateTo 函数进行关联：

$form->select('app_id', '公众号')
 ->options($app_list)
 ->rules('required');

$form->select('msgtype', '回复消息类型')
 ->options([
 'text' => '文本',
 'image' => '图片',
 'news' => '图文',
 'link' => '链接',
 'miniprogrampage' => '小程序卡片',
 ])
 ->rules('required');

$form->wxmsg('content', '回复内容')
 ->relateTo('msgtype', 'app_id');

关联多公众号

支持多公众号场景，通过 selectMedia 函数选择素材：

$form->select('app_id', '公众号')
 ->options($app_list)
 ->rules('required');

$form->select('msgtype', '回复消息类型')
 ->options([...])
 ->rules('required');

$form->wxmsg('content', '回复内容')
 ->relateTo('msgtype', 'app_id')
 ->selectMedia('/wechat/reply/medias');

实现素材查询 API

在控制器中添加 API 方法：

<?php

namespace App\\Http\\Controllers\\Admin;

use Illuminate\\Http\\Request;
use App\\Models\\WechatMedia;

class ReplyController extends Controller
{
 /**
 * 查询素材列表
 */
 public function medias(Request $request)
 {
 $app_id = $request->get('a');
 $name = $request->get('q');
 $type = $request->get('t');
 
 $query = WechatMedia::query();
 
 if ($app_id) {
 $query->where('app_id', $app_id);
 }
 
 if ($type) {
 $query->where('type', $type);
 }
 
 if ($name) {
 $query->where('name', 'like', "%{$name}%");
 }
 
 $result = $query->paginate(20, ['media_id', 'name', 'url']);
 
 $data = $result->map(function ($item) {
 return [
 'id' => $item->media_id,
 'text' => sprintf(
 '<img style="max-width:40px;max-height:40px;" src="%s" /> %s',
 $item->url,
 $item->name
 ),
 ];
 });
 
 return response()->json($data);
 }
}

添加路由：

// routes/admin.php
$router->get('/wechat/reply/medias', 'Wechat\\ReplyController@medias');

支持的消息类型

类型	说明	JSON 格式
text	文本消息	`{"msgtype":"text","text":{"content":"..."}}`
image	图片消息	`{"msgtype":"image","image":{"media_id":"..."}}`
news	图文消息	`{"msgtype":"news","news":{"articles":[...]}}`
link	链接消息	`{"msgtype":"link","link":{"title":"...","description":"...","url":"...","thumb_url":"..."}}`
miniprogrampage	小程序卡片	`{"msgtype":"miniprogrampage","miniprogrampage":{"title":"...","appid":"...","pagepath":"...","thumb_media_id":"..."}}`

生成的 JSON 示例

文本消息

{
 "msgtype": "text",
 "text": {
 "content": "欢迎关注我们的公众号！"
 }
}

图片消息

{
 "msgtype": "image",
 "image": {
 "media_id": "MEDIA_ID"
 }
}

图文消息

{
 "msgtype": "news",
 "news": {
 "articles": [
 {
 "title": "文章标题",
 "description": "文章描述",
 "url": "https://example.com/article",
 "picurl": "https://example.com/image.jpg"
 }
 ]
 }
}

数据库表结构

CREATE TABLE `wechat_replies` (
 `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
 `app_id` bigint(20) unsigned NOT NULL COMMENT '公众号ID',
 `msgtype` varchar(20) NOT NULL COMMENT '消息类型',
 `content` text NOT NULL COMMENT '消息内容(JSON)',
 `created_at` timestamp NULL DEFAULT NULL,
 `updated_at` timestamp NULL DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `idx_app_id` (`app_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

待开发功能

支持更多消息类型（video、music、msgmenu 等）
美化操作界面
提供实时效果预览
支持消息模板

参考链接

Go深入了解sync库的锁和信号量

Tue, 15 Oct 2019 00:00:00 +0000

sync 包提供了 Go 语言的基本同步基元，如互斥锁。除了 Once 和 WaitGroup 类型，大部分都适用于低水平程序线程，高水平的同步使用 channel 通信更好。

并发与同步

Go 并发基础

package main

import (
 "fmt"
 "time"
)

func main() {
 // 创建 goroutine
 go sayHello()
 
 // 主 goroutine 继续执行
 for i := 0; i < 5; i++ {
 fmt.Println("Main:", i)
 time.Sleep(time.Millisecond * 100)
 }
}

func sayHello() {
 for i := 0; i < 5; i++ {
 fmt.Println("Hello:", i)
 time.Sleep(time.Millisecond * 100)
 }
}

同步问题

// 竞态条件示例
var counter int

func increment() {
 counter++ // 非原子操作
}

func main() {
 // 1000 个 goroutine 同时修改 counter
 for i := 0; i < 1000; i++ {
 go increment()
 }
 time.Sleep(time.Second)
 // 预期: 1000，实际可能: 900-1000 之间
 fmt.Println(counter) // 存在竞态条件！
}

sync.Mutex 互斥锁

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type Counter struct {
 mu sync.Mutex
 count int
}

func (c *Counter) Incr() {
 c.mu.Lock()
 defer c.mu.Unlock()
 c.count++
}

func (c *Counter) Value() int {
 c.mu.Lock()
 defer c.mu.Unlock()
 return c.count
}

func main() {
 var counter Counter
 
 // 1000 个 goroutine 安全递增
 for i := 0; i < 1000; i++ {
 go counter.Incr()
 }
 
 time.Sleep(time.Second)
 fmt.Println(counter.Value()) // 输出: 1000
}

注意事项

✅ 使用 defer 确保锁一定会释放
✅ 锁的粒度要尽可能小
❌ 不要在持有锁时调用用户代码
❌ 不要忘记解锁

sync.RWMutex 读写锁

适用场景

场景	锁类型	说明
读多写少	RWMutex	多个读锁可并存
写操作	Mutex	独占访问

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type SafeMap struct {
 mu sync.RWMutex
 m map[string]int
}

func (sm *SafeMap) Set(key string, value int) {
 sm.mu.Lock()
 defer sm.mu.Unlock()
 sm.m[key] = value
}

func (sm *SafeMap) Get(key string) (int, bool) {
 sm.mu.RLock() // 读锁
 defer sm.mu.RUnlock()
 val, ok := sm.m[key]
 return val, ok
}

func main() {
 sm := SafeMap{m: make(map[string]int)}
 
 // 多个读 goroutine
 for i := 0; i < 10; i++ {
 go func(id int) {
 for j := 0; j < 100; j++ {
 sm.Set(fmt.Sprintf("key-%d", j%5), j)
 }
 }(i)
 }
 
 // 一个写 goroutine
 go func() {
 for i := 0; i < 100; i++ {
 sm.Set("write", i)
 }
 }()
 
 time.Sleep(time.Second)
 
 // 读取结果
 for i := 0; i < 5; i++ {
 fmt.Printf("key-%d: %d\n", i, sm.Get(fmt.Sprintf("key-%d", i)))
 }
}

sync.Cond 条件变量

适用场景

等待某个条件成立
线程等待/唤醒模式
生产者-消费者模型

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type Queue struct {
 mu sync.Mutex
 cond *sync.Cond
 items []int
 max int
}

func NewQueue(max int) *Queue {
 q := &Queue{
 items: make([]int, 0, max),
 max: max,
 }
 q.cond = sync.NewCond(&q.mu)
 return q
}

func (q *Queue) Put(item int) {
 q.mu.Lock()
 defer q.mu.Unlock()
 
 // 队列满，等待
 for len(q.items) >= q.max {
 q.cond.Wait() // 解锁并等待
 }
 
 q.items = append(q.items, item)
 fmt.Printf("Put: %d, Queue: %v\n", item, q.items)
 
 // 唤醒一个等待的消费者
 q.cond.Signal()
}

func (q *Queue) Get() int {
 q.mu.Lock()
 defer q.mu.Unlock()
 
 // 队列空，等待
 for len(q.items) == 0 {
 q.cond.Wait()
 }
 
 item := q.items[0]
 q.items = q.items[1:]
 fmt.Printf("Get: %d, Queue: %v\n", item, q.items)
 
 // 唤醒一个等待的生产者
 q.cond.Signal()
 
 return item
}

func main() {
 q := NewQueue(3)
 
 // 生产者
 go func() {
 for i := 0; i < 10; i++ {
 q.Put(i)
 time.Sleep(100 * time.Millisecond)
 }
 }()
 
 // 消费者
 go func() {
 for i := 0; i < 10; i++ {
 q.Get()
 time.Sleep(150 * time.Millisecond)
 }
 }()
 
 time.Sleep(3 * time.Second)
}

Broadcast vs Signal

方法	说明
`Signal()`	唤醒一个等待的 goroutine
`Broadcast()`	唤醒所有等待的 goroutine

sync.WaitGroup 等待组

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

func main() {
 var wg sync.WaitGroup
 
 // 添加 3 个任务
 wg.Add(3)
 
 for i := 0; i < 3; i++ {
 go func(id int) {
 defer wg.Done() // 完成后计数减 1
 fmt.Printf("Task %d started\n", id)
 time.Sleep(time.Second)
 fmt.Printf("Task %d completed\n", id)
 }(i)
 }
 
 // 等待所有任务完成
 wg.Wait()
 fmt.Println("All tasks completed!")
}

常见模式

// 1. 并行爬虫
func crawlUrls(urls []string) []string {
 var wg sync.WaitGroup
 results := make(chan string, len(urls))
 
 for _, url := range urls {
 wg.Add(1)
 go func(u string) {
 defer wg.Done()
 if body, err := fetch(u); err == nil {
 results <- body
 }
 }(url)
 }
 
 // 等待完成并关闭通道
 go func() {
 wg.Wait()
 close(results)
 }()
 
 var bodies []string
 for body := range results {
 bodies = append(bodies, body)
 }
 return bodies
}

// 2. 错误处理
type Task struct {
 ID int
 URL string
 Err error
}

func processTasks(tasks []Task) []Task {
 var wg sync.WaitGroup
 for i := range tasks {
 wg.Add(1)
 go func(idx int) {
 defer wg.Done()
 tasks[idx].Err = process(tasks[idx].URL)
 }(i)
 }
 wg.Wait()
 return tasks
}

sync.Once 一次性执行

基本用法

package main

import (
 "fmt"
 "sync"
)

type Config struct {
 Data string
}

var (
 config *Config
 once sync.Once
)

func getConfig() *Config {
 once.Do(func() {
 fmt.Println("Loading config...")
 config = &Config{
 Data: "loaded-once",
 }
 })
 return config
}

func main() {
 c1 := getConfig()
 c2 := getConfig()
 fmt.Println(c1 == c2, c1.Data) // true, 同一实例
}

注意事项

once.Do 内的函数若 panic，仍视为「已执行」，再次调用不会重试；需要在内部自行 recover 或保证可恢复。
不要在 once.Do 里再嵌套依赖同一 Once 的死锁路径。

Go应用的灵活配置Viper

Thu, 10 Oct 2019 00:00:00 +0000

Viper 是一个完整的 Go 应用程序配置解决方案，它可以处理所有类型的配置需求和格式。

Viper 功能特性

功能	说明
多格式支持	Yaml、Json、TOML、HCL、ENV、Java Properties
多来源读取	文件、环境变量、命令行参数、远程配置
热加载	支持监听配置文件变化自动重载
类型转换	自动转换配置值为 Go 类型
远程配置	支持从 etcd、Consul、NATS 等读取配置
默认值	支持设置默认值

安装

go get -u github.com/spf13/viper

基础用法

config.yaml 配置文件

app:
 name: "my-app"
 version: "1.0.0"
 port: 8080

database:
 host: "localhost"
 port: 3306
 username: "root"
 password: "secret"
 name: "test_db"

redis:
 host: "127.0.0.1"
 port: 6379
 password: ""
 db: 0

information:
 list:
 - "One"
 - "Two"
 - "Three"
 lucky_number: 7

timestamp: "2019-10-10 14:15:16"
author: "Yisonli"

初始化配置

package main

import (
 "fmt"
 "github.com/spf13/viper"
)

func main() {
 // 创建 Viper 实例
 v := viper.New()

 // 设置配置文件名（不含扩展名）
 v.SetConfigName("config")

 // 添加配置文件搜索路径
 v.AddConfigPath("./config/")
 v.AddConfigPath("$HOME/.app/")
 v.AddConfigPath("/etc/app/")

 // 设置配置文件类型
 v.SetConfigType("yaml")

 // 读取配置
 if err := v.ReadInConfig(); err != nil {
 panic(fmt.Errorf("配置读取失败: %w", err))
 }

 // 获取配置值
 fmt.Printf("应用名称: %s\n", v.GetString("app.name"))
 fmt.Printf("数据库主机: %s\n", v.GetString("database.host"))
 fmt.Printf("列表: %v\n", v.GetStringSlice("information.list"))
}

全局 Viper 实例

var VP *viper.Viper

func AutoLoadConfig() error {
 VP = viper.New()

 // 设置配置文件名
 VP.SetConfigName("config")

 // 添加配置文件路径
 VP.AddConfigPath("./config/")

 // 设置配置文件类型
 VP.SetConfigType("yaml")

 if err := VP.ReadInConfig(); err != nil {
 return fmt.Errorf("配置读取失败: %w", err)
 }

 // 绑定环境变量
 VP.BindEnv("GOPATH")

 fmt.Printf("list: %+v, gopath: %s\n", VP.Get("information.list"), VP.Get("GOPATH"))
 return nil
}

高级用法

读取环境变量

// 自动绑定环境变量
v.AutomaticEnv()
v.SetEnvPrefix("APP") // 环境变量前缀：APP_DATABASE_HOST
v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))

// 手动绑定
v.BindEnv("database.host", "DB_HOST") // 绑定到 DB_HOST 环境变量

读取命令行参数

v.SetConfigFile("./config.yaml") // 指定配置文件路径
v.SetConfigType("yaml") // 明确配置文件类型

// 绑定 Pflags
v.BindPFlag("database.host", flag.Lookup("db-host"))

设置默认值

v := viper.New()

v.SetDefault("app.port", 8080)
v.SetDefault("database.host", "localhost")
v.SetDefault("database.port", 3306)
v.SetDefault("cache.enabled", true)

类型安全获取

// 字符串
name := v.GetString("app.name")

// 整数
port := v.GetInt("app.port")

// 布尔
enabled := v.GetBool("cache.enabled")

// 浮点数
rate := v.GetFloat64("api.rate_limit")

// 切片
list := v.GetStringSlice("information.list")

// Map
dbConfig := v.GetStringMap("database")
// dbConfig["host"], dbConfig["port"], etc.

// 嵌套获取
host := v.GetString("database.host")
listItem := v.GetString("information.list.0") // "One"

Unmarshal 到结构体

type Config struct {
 App AppConfig `mapstructure:"app"`
 Database DatabaseConfig `mapstructure:"database"`
 Redis RedisConfig `mapstructure:"redis"`
}

type AppConfig struct {
 Name string `mapstructure:"name"`
 Version string `mapstructure:"version"`
 Port int `mapstructure:"port"`
}

type DatabaseConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Username string `mapstructure:"username"`
 Password string `mapstructure:"password"`
 Name string `mapstructure:"name"`
}

type RedisConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Password string `mapstructure:"password"`
 DB int `mapstructure:"db"`
}

func main() {
 v := viper.New()
 v.SetConfigFile("config.yaml")
 v.SetConfigType("yaml")
 v.ReadInConfig()

 var config Config
 if err := v.Unmarshal(&config); err != nil {
 panic(err)
 }

 fmt.Printf("App: %s:%d\n", config.App.Name, config.App.Port)
 fmt.Printf("DB: %s:%d\n", config.Database.Host, config.Database.Port)
}

监听配置文件变化

v := viper.New()
v.SetConfigName("config")
v.SetConfigType("yaml")
v.ReadInConfig()

// 监听配置变化
v.WatchConfig()
v.OnConfigChange(func(e fsnotify.Event) {
 fmt.Printf("配置文件已更新: %s\n", e.Name)
 // 重新读取配置
 v.ReadInConfig()
})

远程配置

etcd 配置

import (
 "github.com/spf13/viper/remote"
 "github.com/hashicorp/vault/api"
)

func initRemoteConfig() error {
 v := viper.New()

 // 设置远程源
 err := remote.AddProvider("etcd", "http://127.0.0.1:4001", "/config.yaml")
 if err != nil {
 return err
 }

 // 或者使用 Consul
 err = remote.AddProvider("consul", "http://127.0.0.1:8500", "/config.yaml", "my-consul-token")

 // 启用远程配置
 err = v.AddRemoteProvider("etcd", "http://127.0.0.1:4001", "/config.yaml")
 v.SetConfigType("yaml")
 
 return v.ReadRemoteConfig()
}

多环境配置

// 根据环境加载不同配置
func loadConfig(env string) (*viper.Viper, error) {
 v := viper.New()

 // 基础配置
 v.SetConfigName("config")
 v.SetConfigType("yaml")
 v.AddConfigPath("./config/")

 // 环境特定配置
 if env != "" {
 v.SetConfigName("config." + env) // config.dev.yaml, config.prod.yaml
 }

 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }

 return v, nil
}

// 使用
v, err := loadConfig("dev") // 加载 config.dev.yaml

最佳实践

项目结构

project/
├── config/
│ ├── config.yaml # 默认配置
│ ├── config.dev.yaml # 开发环境
│ ├── config.prod.yaml # 生产环境
│ └── config.test.yaml # 测试环境
├── config.yaml
└── main.go

环境变量配置

# .env 文件
APP_NAME=my-app
APP_ENV=production
DATABASE_HOST=localhost
DATABASE_PORT=3306

// 加载 .env 文件
go get github.com/joho/godotenv

func main() {
 // 加载 .env 文件
 godotenv.Load()

 v := viper.New()
 v.AutomaticEnv()
 
 // 或者手动映射（键名建议使用点分层级，对应 yaml 嵌套字段）
 v.BindEnv("database.host", "DATABASE_HOST")
 v.BindEnv("database.port", "DATABASE_PORT")

 // 读取：优先配置文件，再以环境变量覆盖 AutomaticEnv / BindEnv 的值
 host := v.GetString("database.host")
 _ = host
}

.env 只适合开发机本地密钥；线上请使用容器/编排注入的环境变量或密钥管理服务，BindEnv 只是把环境变量桥接到同一套键名。

常用正则表达式收集

Sun, 30 Jun 2019 00:00:00 +0000

正则表达式是繁琐的，但它是强大的。学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。

一、校验数字的表达式

场景	正则表达式
纯数字	`^[0-9]*$`
n位数字	`^\d{n}$`
至少n位数字	`^\d{n,}$`
m-n位数字	`^\d{m,n}$`
零和非零开头	`^(0
非零开头最多2位小数	`^([1-9][0-9]*)+(.[0-9]{1,2})?$`
带1-2位小数的数	`^(\-)?\d+(\.\d{1,2})?$`
正数、负数、小数	`^(-
2位小数正实数	`^[0-9]+(.[0-9]{2})?$`
1-3位小数正实数	`^[0-9]+(.[0-9]{1,3})?$`
非零正整数	`^[1-9]\d$` 或 `^\+?[1-9][0-9]$`
非零负整数	`^-[1-9]\d*$`
非负整数	`^\d+$` 或 `^[1-9]\d*
非正整数	`^-[1-9]\d*
非负浮点数	`^\d+(\.\d+)?$`
非正浮点数	`^((-\d+(.\d+)?)
正浮点数	`^[1-9]\d.\d
负浮点数	`^-([1-9]\d.\d
浮点数	`^(-?\d+)(\.\d+)?$`

二、校验字符的表达式

场景	正则表达式
汉字	`^[\u4e00-\u9fa5]{0,}$`
英文和数字	`^[A-Za-z0-9]+$`
4-40位字符	`^[A-Za-z0-9]{4,40}$`
3-20位字符	`^.{3,20}$`
26个英文字母	`^[A-Za-z]+$`
26个大写字母	`^[A-Z]+$`
26个小写字母	`^[a-z]+$`
数字和字母	`^[A-Za-z0-9]+$`
字母、数字、下划线	`^\w+$` 或 `^\w{3,20}$`
中文、英文、数字、下划线	`^[\u4E00-\u9FA5A-Za-z0-9_]+$`
中文、英文、数字	`^[\u4E00-\u9FA5A-Za-z0-9]+$`
禁止特殊字符	`[^%&',;=?$\x22]+`

三、特殊需求表达式

1. Email 邮箱

^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

// PHP 示例
$email = 'test@example.com';
$pattern = '/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/';
if (preg_match($pattern, $email)) {
 echo "邮箱格式正确";
}

2. URL 网址

[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?

3. 手机号码（中国大陆）

^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|16[2|6]|17[0-8]|18[0-9]|19[0-9])d{8}$

// 宽松匹配 11 位手机号
function isValidPhone($phone) {
 return preg_match('/^1[3-9]\d{9}$/', $phone);
}

4. 电话号码

^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$

5. 身份证号码

// 15位或18位
^\d{15}|\d{18}$

// 18位（严格）
/^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/

function isValidIdCard($id) {
 if (strlen($id) == 18) {
 return preg_match('/^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/', $id);
 } elseif (strlen($id) == 15) {
 return preg_match('/^[1-9]\d{5}\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}$/', $id);
 }
 return false;
}

6. 账号（字母开头）

^[a-zA-Z][a-zA-Z0-9_]{4,15}$ // 5-16位

7. 密码强度

// 弱密码（字母开头，6-18位）
^[a-zA-Z]\w{5,17}$

// 强密码（大小写字母+数字，8-10位）
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$

8. 日期格式

^\d{4}-\d{1,2}-\d{1,2}

9. 日期范围

// 12个月：01～09 和 1～12
^(0?[1-9]|1[0-2])$

// 31天：01～09 和 1～31
^((0?[1-9])|((1|2)[0-9])|30|31)$

10. 货币金额

// 10000.00 或 10,000.00
^[1-9][0-9]*$

// 不以0开头
^(0|[1-9][0-9]*)$

// 可选小数（必须2位）
^[0-9]+(.[0-9]{2})?$

// 允许千分位
^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$

四、常用场景正则

1. IP 地址

// 简单版
\d+\.\d+\.\d+\.\d+

// 严格版
((?:(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d))

2. 腾讯 QQ 号

[1-9][0-9]{4,}

3. 中国邮政编码

[1-9]\d{5}(?!\d)

4. XML 文件

^([a-zA-Z]+-?)+[a-zA-Z0-9]+\.[x|X][m|M][l|L]$

5. 中文字符

[\u4e00-\u9fa5]

6. 双字节字符

[^\x00-\xff]

这一类「非 ASCII」写法常用来粗略匹配中文等宽字符；若要严格限定中日韓统一表意文字，可再配合 [\u4e00-\u9fff] 等 Unicode 区间。PHP 等对 UTF-8 文本建议使用带 u 修饰的正则。

7. 小结

以上条目均为常见写法模板，上线前务必用真实样本与边界数据回归测试；不同语言的正则方言（回溯、分支、贪婪性）会有差异，移植时请以目标引擎文档为准。

Alpine系统下的apk指令

Sun, 09 Jun 2019 00:00:00 +0000

Alpine Linux 是一个面向安全应用的轻量级 Linux 发行版。它采用了 musl libc 和 busybox 以减小系统的体积和运行时资源消耗，同时还提供了自己的包管理工具 apk。

apk 常用命令速查

命令	说明
`apk update`	更新本地镜像源索引
`apk add <pkg>`	安装软件包
`apk del <pkg>`	卸载软件包
`apk upgrade`	升级所有已安装包
`apk search <pkg>`	搜索软件包
`apk info <pkg>`	查看软件包信息
`apk list`	列出已安装包
`apk fix`	修复或升级包

基础命令

更新镜像源

# 更新本地镜像源索引
apk update

update 命令会从各个镜像源列表下载 APKINDEX.tar.gz 并存储到本地缓存，一般在 /var/cache/apk/、/var/lib/apk/、/etc/apk/cache/ 目录下。

安装软件包

# 基本安装
apk add openssh openntp vim

# 不缓存安装（减小镜像体积）
apk add --no-cache mysql-client

# 从指定仓库安装
apk add docker --update-cache \
 --repository http://mirrors.ustc.edu.cn/alpine/v3.4/main/ \
 --allow-untrusted

安装指定版本

# 安装精确版本
apk add asterisk=1.6.0.21-r0

# 版本约束
apk add 'asterisk<1.6.1' # 小于
apk add 'asterisk>1.6.1' # 大于
apk add 'asterisk>=1.6.1' # 大于等于
apk add 'asterisk~=1.6.1' # 约等于

卸载软件包

# 卸载并删除相关文件
apk del openssh openntp vim

升级软件包

# 更新镜像源
apk update

# 升级所有已安装包
apk upgrade

# 升级指定软件包
apk add --upgrade busybox

搜索软件包

# 搜索所有可用包
apk search

# 显示详细信息
apk search -v

# 通过名称查找
apk search -v 'acf*'

# 通过描述查找
apk search -v -d 'docker'

查看软件包信息

# 列出所有已安装包
apk info

# 查看指定包详细信息
apk info -a zlib

# 查看文件属于哪个包
apk info --who-owns /sbin/lbu

常用场景

Docker 容器中安装工具

# 更新并安装基础工具
apk update && apk add --no-cache \
 curl \
 wget \
 git \
 vim \
 htop \
 bash \
 bash-completion

PHP 运行环境

apk add --no-cache \
 php \
 php-fpm \
 php-mysql \
 php-mbstring \
 php-xml \
 php-curl \
 php-json

Nginx 运行环境

apk add --no-cache \
 nginx \
 openssl \
 pcre \
 zlib

数据库客户端

# MySQL 客户端
apk add --no-cache mysql-client

# PostgreSQL 客户端
apk add --no-cache postgresql-client

# Redis 客户端
apk add --no-cache redis

Alpine 中文支持

如果需要在 Alpine 中使用中文，需要安装 glibc：

# 安装 glibc（解决 locale 问题）
apk --no-cache add ca-certificates wget

wget -q -O /etc/apk/keys/sgerrand.rsa.pub \
 https://alpine-pkgs.sgerrand.com/sgerrand.rsa.pub

wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.29-r0/glibc-2.29-r0.apk
apk add glibc-2.29-r0.apk

wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.29-r0/glibc-bin-2.29-r0.apk
wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.29-r0/glibc-i18n-2.29-r0.apk
apk add glibc-bin-2.29-r0.apk glibc-i18n-2.29-r0.apk

# 生成 locale
/usr/glibc-compat/bin/localedef -i en_US -f UTF-8 en_US.UTF-8

镜像源配置

官方源

# /etc/apk/repositories
https://dl-cdn.alpinelinux.org/alpine/v3.19/main
https://dl-cdn.alpinelinux.org/alpine/v3.19/community

国内镜像

# 阿里云镜像
echo "https://mirrors.aliyun.com/alpine/v3.19/main" > /etc/apk/repositories
echo "https://mirrors.aliyun.com/alpine/v3.19/community" >> /etc/apk/repositories

# 中科大镜像
echo "https://mirrors.ustc.edu.cn/alpine/v3.19/main" > /etc/apk/repositories
echo "https://mirrors.ustc.edu.cn/alpine/v3.19/community" >> /etc/apk/repositories

# 腾讯云镜像
echo "https://mirrors.cloud.tencent.com/alpine/v3.19/main" > /etc/apk/repositories
echo "https://mirrors.cloud.tencent.com/alpine/v3.19/community" >> /etc/apk/repositories

进阶命令

查看依赖关系

# 查看包依赖
apk info -r php

# 查看反向依赖（哪些包依赖它）
apk info -R nginx

缓存管理

# 下载包到缓存
apk cache download

# 清理缓存
apk cache clean

# 修复缓存
apk cache fix

版本比较

# 比较版本
apk version abc 1.2.3-r0

# 测试版本表达式
apk version --test 'bash>3.1'

常见问题

Q: apk add 报错 signature is invalid

A: 更新镜像源或添加 --allow-untrusted 参数

Q: 找不到包

A: 确认仓库配置正确后执行 apk update

Q: 依赖冲突

A: 使用 apk add --force-overwrite 或查看冲突详情

Docker 最佳实践

# 使用国内镜像源
RUN echo "https://mirrors.aliyun.com/alpine/v3.19/main" > /etc/apk/repositories \
 && apk add --no-cache \
 nginx \
 php-fpm \
 php-mysqli \
 && rm -rf /var/cache/apk/*

# 多阶段构建
FROM alpine:3.19 AS builder
RUN apk add --no-cache go

FROM alpine:3.19
COPY --from=builder /usr/local/bin/ /usr/local/bin/

参考链接

Laravel框架下的PHP辅助函数

Fri, 22 Mar 2019 00:00:00 +0000

Laravel 框架自带了一系列 PHP 辅助函数，很多被框架自身使用。了解这些函数方便我们在代码中善用它们。

数组函数

array_add()

添加给定键值对到数组（如果给定键不存在）：

// 如果键不存在则添加
$array = array_add(['name' => 'Desk'], 'price', 100);
// ['name' => 'Desk', 'price' => 100]

// 如果键已存在则不添加
$array = array_add(['name' => 'Desk', 'price' => 50], 'price', 100);
// ['name' => 'Desk', 'price' => 50] 价格保持 50

array_collapse()

将多个数组合并成一个：

$array = array_collapse([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

// 实际应用：分组数据合并
$postsByCategory = [
 'tech' => [['title' => 'Post 1'], ['title' => 'Post 2']],
 'life' => [['title' => 'Post 3']],
];
$allPosts = array_collapse($postsByCategory);
// [['title' => 'Post 1'], ['title' => 'Post 2'], ['title' => 'Post 3']]

array_divide()

分离数组的键和值：

[$keys, $values] = array_divide(['name' => 'Desk', 'price' => 100]);
// $keys = ['name', 'price']
// $values = ['Desk', 100]

array_dot()

将多维数组转为一维（使用点号分隔键）：

$array = [
 'products' => [
 'desk' => [
 'price' => 100,
 ],
 ],
];

$flattened = array_dot($array);
// [
// 'products.desk.price' => 100,
// ]

array_except() / array_only()

// 排除指定键
$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];
$except = array_except($array, ['price']);
// ['name' => 'Desk', 'orders' => 10]

// 只保留指定键
$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];
$only = array_only($array, ['name', 'price']);
// ['name' => 'Desk', 'price' => 100]

array_first() / array_last()

$array = [100, 200, 300];

// 返回第一个匹配的元素
$first = array_first($array, function ($value) {
 return $value >= 150;
});
// 200

// 返回最后一个匹配的元素
$last = array_last($array, function ($value) {
 return $value >= 150;
});
// 300

// 支持默认值
$first = array_first($array, function ($value) {
 return $value >= 500;
}, 'default');
// 'default'

array_flatten()

多维数组转一维：

$array = [['id' => 1], ['id' => 2], [['id' => 3]]];
$flattened = array_flatten($array);
// [1, 2, 3]

array_forget()

使用点号语法删除数组元素：

$array = ['products' => ['desk' => ['price' => 100]]];
array_forget($array, 'products.desk.price');

// $array = ['products' => ['desk' => []]]

array_get()

使用点号语法获取数组值：

$array = [
 'products' => [
 'desk' => ['price' => 100],
 ],
];

$price = array_get($array, 'products.desk.price');
// 100

// 支持默认值
$price = array_get($array, 'products.chair.price', 200);
// 200

array_has()

检查数组是否有指定键：

$array = ['products' => ['desk' => ['price' => 100]]];

array_has($array, 'products.desk');
// true

array_has($array, 'products.chair');
// false

// 支持检查多个键
array_has($array, ['products.desk', 'products.chair']);
// false

array_pluck()

提取数组中指定键的值：

$array = [
 ['product' => 'Desk', 'price' => 100],
 ['product' => 'Chair', 'price' => 50],
];

$products = array_pluck($array, 'product');
// ['Desk', 'Chair']

// 带键
$products = array_pluck($array, 'product', 'price');
// [100 => 'Desk', 50 => 'Chair']

array_pull()

弹出数组元素并删除：

$array = ['name' => 'Desk', 'price' => 100];

$name = array_pull($array, 'name');
// $name = 'Desk'
// $array = ['price' => 100]

array_set()

使用点号语法设置数组值：

$array = [];
array_set($array, 'products.desk.price', 100);

// $array = ['products' => ['desk' => ['price' => 100]]]

array_sort()

按值排序：

$array = [
 ['name' => 'Desk', 'price' => 100],
 ['name' => 'Chair', 'price' => 50],
 ['name' => 'Table', 'price' => 75],
];

$sorted = array_values(array_sort($array, function ($item) {
 return $item['price'];
}));
// [
// ['name' => 'Chair', 'price' => 50],
// ['name' => 'Table', 'price' => 75],
// ['name' => 'Desk', 'price' => 100],
// ]

array_where()

条件过滤数组：

$array = [100, 200, 300, 400, 500];

$filtered = array_where($array, function ($value, $key) {
 return $value >= 200;
});
// [1 => 200, 2 => 300, 3 => 400, 4 => 500]

head() / last()

$array = [100, 200, 300];

head($array); // 100 - 返回第一个元素
last($array); // 300 - 返回最后一个元素

字符串函数

str_contains()

检查字符串是否包含指定内容：

str_contains('Hello World', 'World');
// true

str_contains('Hello World', ['World', 'PHP']);
// true

str_contains('Hello World', ['World', 'PHP']);
// true - 任一匹配即返回 true

str_start()

确保字符串以指定内容开头：

str_start('World', 'Hello ');
// 'Hello World'

str_start('Hello World', 'Hello ');
// 'Hello World' - 已经是则不变

str_finish()

确保字符串以指定内容结尾：

str_finish('Hello', ' World');
// 'Hello World'

str_finish('Hello World', ' World');
// 'Hello World' - 已经是则不变

str_limit()

截断字符串：

str_limit('The quick brown fox jumps over the lazy dog', 20);
// 'The quick brown fox...'

str_limit('The quick brown fox', 20, ' (...)');
// 'The quick brown (...)'

str_plural() / str_singular()

单复数转换：

str_plural('child');
// 'children'

str_plural('child', 1);
// 'child'

str_plural('children');
// 'children'

str_singular('children');
// 'child'

str_slug()

生成 URL 友好的字符串：

str_slug('Hello World');
// 'hello-world'

str_slug('Hello World!', '_');
// 'hello_world'

str_slug('日本語');
// 'ri-ben-yu'

str_replace_array()

批量替换字符串：

$string = 'The framework has :count widgets';

str_replace_array(':count', [5], $string);
// 'The framework has 5 widgets'

str_replace_first() / str_replace_last()

str_replace_first('the', 'a', 'the quick the fox');
// 'a quick the fox'

str_replace_last('the', 'a', 'the quick the fox');
// 'the quick a fox'

// 对应门面（文件顶部需：use Illuminate\Support\Str;）
// Str::replaceLast('world', 'PHP', 'Hello world'); // Hello PHP

str_replace_* 系列常用于日志脱敏、路径规范化等场景；新版本 Laravel 亦可使用 Illuminate\Support\Str 门面，请以当前版本文档为准。

你应该了解的PHP缓存技术

Wed, 09 Jan 2019 00:00:00 +0000

缓存是现代系统中必不可少的模块，已经成为高并发高性能架构的关键组件。

缓存概念

什么是缓存

缓存是将程序或系统经常要调用的对象存在内存中，以便快速调用，不必重复创建实例。这样可以减少系统开销，提高系统效率。

缓存分类

类型	说明	示例
文件缓存	数据存储在磁盘上	XML、JSON、序列化文件
内存缓存	存储在静态内存区域	Application、静态 Map
分布式缓存	跨进程、跨域访问	Redis、Memcached

PHP 缓存类型

PHP 编译缓存

PHP 是解释型语言，执行过程包括：

编译过程：读取文件，编译成中间码
执行过程：直接执行中间码

问题：

即使代码文件未改变，也会被重新编译
引用文件也需要重新编译

解决方案：PHP 编译缓存工具

工具	说明
APC	Alternative PHP Cache
OPcache	PHP 内置（PHP 5.5+）
XCache	国产高性能编译器

启用 OPcache

; php.ini
zend_extension=opcache.so

; 基本配置
opcache.enable=1
opcache.memory_consumption=128
opcache.max_accelerated_files=10000
opcache.revalidate_freq=2

PHP 数据缓存

类型	缓存内容	工具
数据库缓存	查询结果	Memcached、Redis
模板缓存	页面模板	Smarty、Twig

缓存优势

1. 提升性能

减少数据库查询
加速远程调用
降低响应时间

2. 缓解数据库压力

┌─────────┐ 请求 ┌─────────┐
│ 用户 │ ───────▶ │ Nginx │
└─────────┘ └────┬────┘
 │
 ┌─────▼─────┐
 │ 缓存层 │ ◀──────┐ 命中
 └─────┬─────┘ │
 │ 未命中 │
 ┌─────▼─────┐ │
 │ 数据库 │ ──────┘ 写入
 └───────────┘

常用缓存方案

1. 文件缓存

<?php

/**
 * 简单文件缓存类
 */
class FileCache
{
 private $cacheDir;
 private $expire = 3600;

 public function __construct(string $cacheDir = './cache', int $expire = 3600)
 {
 $this->cacheDir = rtrim($cacheDir, '/');
 $this->expire = $expire;
 
 if (!is_dir($this->cacheDir)) {
 mkdir($this->cacheDir, 0755, true);
 }
 }

 /**
 * 设置缓存
 */
 public function set(string $key, $value, ?int $expire = null): bool
 {
 $file = $this->getFilePath($key);
 $data = [
 'value' => $value,
 'expire' => time() + ($expire ?? $this->expire),
 ];
 
 return file_put_contents(
 $file,
 serialize($data),
 LOCK_EX
 ) !== false;
 }

 /**
 * 获取缓存
 */
 public function get(string $key, $default = null)
 {
 $file = $this->getFilePath($key);
 
 if (!file_exists($file)) {
 return $default;
 }
 
 $content = file_get_contents($file);
 $data = unserialize($content);
 
 if ($data['expire'] < time()) {
 unlink($file);
 return $default;
 }
 
 return $data['value'];
 }

 /**
 * 删除缓存
 */
 public function delete(string $key): bool
 {
 $file = $this->getFilePath($key);
 return file_exists($file) ? unlink($file) : true;
 }

 /**
 * 清除所有缓存
 */
 public function clear(): bool
 {
 $files = glob($this->cacheDir . '/*');
 foreach ($files as $file) {
 if (is_file($file)) {
 unlink($file);
 }
 }
 return true;
 }

 private function getFilePath(string $key): string
 {
 return $this->cacheDir . '/' . md5($key) . '.cache';
 }
}

// 使用示例
$cache = new FileCache('./cache', 3600);

// 设置缓存
$cache->set('user_1', ['name' => 'John', 'email' => 'john@example.com']);

// 获取缓存
$user = $cache->get('user_1');
if ($user) {
 echo "缓存命中: " . json_encode($user);
} else {
 // 从数据库获取
 $user = fetchUserFromDB(1);
 $cache->set('user_1', $user);
}

2. Memcached

<?php

/**
 * Memcached 缓存封装
 */
class MemcachedCache
{
 private $memcached;

 public function __construct(array $servers = [])
 {
 $this->memcached = new Memcached();
 
 if (empty($servers)) {
 $servers = [
 ['127.0.0.1', 11211, 100],
 ];
 }
 
 $this->memcached->addServers($servers);
 }

 /**
 * 设置缓存
 */
 public function set(string $key, $value, int $ttl = 0): bool
 {
 return $this->memcached->set($key, $value, $ttl);
 }

 /**
 * 获取缓存
 */
 public function get(string $key)
 {
 return $this->memcached->get($key);
 }

 /**
 * 删除缓存
 */
 public function delete(string $key): bool
 {
 return $this->memcached->delete($key);
 }

 /**
 * 增加数值
 */
 public function increment(string $key, int $offset = 1)
 {
 return $this->memcached->increment($key, $offset);
 }

 /**
 * 清除所有缓存
 */
 public function flush(): bool
 {
 return $this->memcached->flush();
 }

 /**
 * 获取多条缓存
 */
 public function getMulti(array $keys): array
 {
 return $this->memcached->getMulti($keys);
 }

 /**
 * 批量设置
 */
 public function setMulti(array $items, int $ttl = 0): bool
 {
 return $this->memcached->setMulti($items, $ttl);
 }
}

// 使用示例
$cache = new MemcachedCache([
 ['127.0.0.1', 11211],
]);

// 设置缓存
$cache->set('user_1', ['name' => 'John'], 3600);

// 获取缓存
$user = $cache->get('user_1');

// 计数器
$cache->set('page_views', 0);
$cache->increment('page_views');

3. Redis

<?php

/**
 * Redis 缓存封装
 */
class RedisCache
{
 private $redis;

 public function __construct(string $host = '127.0.0.1', int $port = 6379)
 {
 $this->redis = new Redis();
 $this->redis->connect($host, $port);
 }

 /**
 * 设置缓存
 */
 public function set(string $key, $value, ?int $ttl = null): bool
 {
 $value = is_array($value) ? json_encode($value) : $value;
 
 if ($ttl === null) {
 return $this->redis->set($key, $value);
 }
 
 return $this->redis->setex($key, $ttl, $value);
 }

 /**
 * 获取缓存
 */
 public function get(string $key)
 {
 $value = $this->redis->get($key);
 
 if ($value === null) {
 return null;
 }
 
 // 尝试 JSON 解码
 $decoded = json_decode($value, true);
 return json_last_error() === JSON_ERROR_NONE ? $decoded : $value;
 }

 /**
 * 删除缓存
 */
 public function delete(string $key): int
 {
 return (int) $this->redis->del($key);
 }

 /**
 * 判断键是否存在
 */
 public function exists(string $key): bool
 {
 return $this->redis->exists($key) > 0;
 }

 /**
 * 设置过期时间（秒）
 */
 public function expire(string $key, int $seconds): bool
 {
 return $this->redis->expire($key, $seconds);
 }
}

// 使用示例
$redis = new RedisCache();
$redis->set('foo', 'bar', 60);
var_dump($redis->get('foo'));
$redis->delete('foo');

提示：生产环境建议加连接池、统一 Key 前缀、超时与熔断，并结合业务决定哪些数据适合落在 Redis。

选型小结

场景	建议
单机小规模、持久化不重要	文件缓存 / APCu
多节点共享会话、计数	Memcached
丰富数据结构 + 持久化	Redis

结合 OPcache 减少 PHP 脚本重复编译，再配合数据缓存，通常能在成本可控的前提下显著提升站点响应速度。

分库分表de那些事【理论篇】

Sat, 22 Dec 2018 00:00:00 +0000

关系型数据库本身比较容易成为系统瓶颈，单机存储容量、连接数、处理能力都有限。当单表的数据量达到1000万或100GB以后，由于查询维度较多，即使添加从库、优化索引，做很多操作时性能仍下降严重。

概念

什么是分库分表

顾名思义，分库分表就是按照一定的规则，对原有的数据库和表进行拆分，把原本存储于一个库的数据分块存储到多个库上，把原本存储于一个表的数据分块存储到多个表上。

为什么需要分库分表

随着时间和业务的发展，数据库中的数据量增长是不可控的，库和表中的数据会越来越大，随之带来的是更高的磁盘、IO、系统开销，甚至性能上的瓶颈，而一台服务的资源终究是有限的，因此需要对数据库和表进行拆分，从而更好的提供数据服务。

数据切分

数据库分布式核心内容无非就是数据切分（Sharding），以及切分后对数据的定位、整合。

数据切分就是将数据分散存储到多个数据库中，使得单一数据库中的数据量变小，通过扩充主机的数量缓解单一数据库的性能问题，从而达到提升数据库操作性能的目的。

数据切分根据其切分类型，可以分为两种方式：垂直（纵向）切分和水平（横向）切分

切分方式

垂直切分

简单来说就是竖着切，试想一下，把一个库中很多张表竖着切，这些表就会散开。其实垂直切分就是这个意思，将不同模块的表放到不同的数据库中。

比如支付的放在支付数据库，用户的放在用户数据库，会员的放在会员数据库等等，可以减少耦合性。

常见有垂直分库和垂直分表两种。

垂直分库
- 就是根据业务耦合性，将关联度低的不同表存储在不同的数据库。
- 做法与大系统拆分为多个小系统类似，按业务分类进行独立划分。
- 与"微服务治理"的做法相似，每个微服务使用单独的一个数据库。

垂直分表
- 基于数据库中的"列"进行，某个表字段较多，可以新建一张扩展表，将不经常用或字段长度较大的字段拆分出去到扩展表中。
- 在字段很多的情况下（例如一个大表有100多个字段），通过"大表拆小表"，更便于开发与维护，也能避免跨页问题。
- MySQL底层是通过数据页存储的，一条记录占用空间过大会导致跨页，造成额外的性能开销。
- 另外数据库以行为单位将数据加载到内存中，这样表中字段长度较短且访问频率较高，内存能加载更多的数据，命中率更高，减少了磁盘IO，从而提升了数据库性能。

【优点】

解决业务系统层面的耦合，业务清晰
与微服务的治理类似，也能对不同业务的数据进行分级管理、维护、监控、扩展等
高并发场景下，垂直切分一定程度的提升IO、数据库连接数、单机硬件资源的瓶颈

【缺点】

部分表无法join，只能通过接口聚合方式解决，提升了开发的复杂度
分布式事务处理复杂
依然存在单表数据量过大的问题（需要水平切分）

水平切分

将某张访问非常频繁的表，按照某个特定的规则（通常是某个字段进行hash），然后将数据分散到多个表，甚至是多个数据库中，这样每张表或者每张库都含有一部分数据。

【优点】

不存在单库数据量过大、高并发的性能瓶颈，提升系统稳定性和负载能力
应用端改造较小，不需要拆分业务模块

【缺点】

跨分片的事务一致性难以保证
跨库的join关联查询性能较差
数据多次扩展难度和维护量极大

水平切分后同一张表会出现在多个数据库/表中，每个库/表的内容不同。

数据分片规则

I. 查询切分

首先数据库分片，将sharding key记录在一个单独的库中，你每次要查询数据库的时候，请先到mapping db里面去查一下你应该到那个数据库去拿数据。

这个mapping db是否真的有需要，是否shading key提供一种约定，比如说根据用户id来进行hash进行分散到不同的数据库中。
当然这只是一种分片策略，如果你觉得慢，可以把这个表结构缓存在内存中。这样就很快了

II. 范围切分

按照范围来切分，比如说按照时间范围和ID的范围来进行切分

例如：按日期将不同月甚至是日的数据分散到不同的库中；将userId为1 ~ 9999的记录分到第一个库，10000 ~ 20000的分到第二个库，以此类推。

某种意义上，某些系统中使用的"冷热数据分离"，将一些使用较少的历史数据迁移到其他库中，业务功能上只提供热点数据的查询，也是类似的实践。

【优点】

单表大小可控
天然便于水平扩展，后期如果想对整个分片集群扩容时，只需要添加节点即可，无需对其他分片的数据进行迁移
使用分片字段进行范围查找时，连续分片可快速定位分片进行快速查询，有效避免跨分片查询的问题。

【缺点】

热点数据成为性能瓶颈。
- 连续分片可能存在数据热点，例如按时间字段分片，有些分片存储最近时间段内的数据，可能会被频繁的读写，而有些分片存储的历史数据，则很少被查询

III. Hash切分

一般使用取模运算来进行切分，也就是Mod切分，图中db mod代表db取模，tb mod代表tb取模

比如分库分表的方案是32个数据库实例，通过userId进行取模的话就是，将UserId后面4位模32然后丢到32个数据库中，同时又将UserId后面4位除以32再mod32丢到32张表里面，这样就有1024张表，然后线上部署8个主从实例，每个实例4个数据库。完毕。

【优点】

数据分片相对比较均匀，不容易出现热点和并发访问的瓶颈

【缺点】

后期分片集群扩容时，需要迁移旧的数据（使用一致性hash算法能较好的避免这个问题）
容易面临跨分片查询的复杂问题。
- 如果频繁用到的查询条件中不带sharding key时，将会导致无法定位数据库，从而需要同时向多个库发起查询，再在内存中合并数据，取最小集返回给应用，分库反而成为拖累。

潜在问题

事务问题

当更新内容同时分布在不同库中，不可避免会带来跨库事务问题。

解决事务问题目前有两种可行的方案：

方案一：使用分布式事务

跨分片事务也是分布式事务，没有简单的方案，一般可使用"XA协议"和"两阶段提交"处理。

【优点】

交由数据库管理，简单有效

【缺点】

性能代价高，特别是shard越来越多时

方案二：由应用程序和数据库共同控制

原理：将一个跨多个数据库的分布式事务分拆成多个仅处于单个数据库上面的小事务，并通过应用程序来总控各个小事务。

【优点】

性能上有优势

【缺点】

需要应用程序在事务控制上做灵活设计。
如果使用了spring的事务管理，改动起来会面临一定的困难。

一致性

对于那些性能要求很高，但对一致性要求不高的系统，往往不苛求系统的实时一致性，只要在允许的时间段内达到最终一致性即可，可采用事务补偿的方式。

与事务在执行中发生错误后立即回滚的方式不同，事务补偿是一种事后检查补救的措施。
一些常见的实现方法有：对数据进行对账检查，基于日志进行对比，定期同标准数据来源进行同步等等。事务补偿还要结合业务系统来考虑。

跨节点Join的问题

只要是进行切分，跨节点Join的问题是不可避免的。但是良好的设计和切分却可以减少此类情况的发生。

1）全局表

全局表，也可看做是"数据字典表"，就是系统中所有模块都可能依赖的一些表，为了避免跨库join查询，可以将这类表在每个数据库中都保存一份。

这些数据通常很少会进行修改，所以也不担心一致性的问题。

2）字段冗余

一种典型的反范式设计，利用空间换时间，为了性能而避免join查询。

例如：订单表保存userId时候，也将userName冗余保存一份，这样查询订单详情时就不需要再去查询"买家user表"了。

【缺点】

但这种方法适用场景也有限，比较适用于依赖字段比较少的情况。
而冗余字段的数据一致性也较难保证，就像上面订单表的例子，买家修改了userName后，是否需要在历史订单中同步更新呢？这也要结合实际业务场景进行考虑。

3）数据组装

在系统层面，分两次查询。

第一次查询的结果集中找出关联数据id，
然后根据id发起第二次请求得到关联数据。
最后将获得到的数据进行字段拼装。

4）ER分片

关系型数据库中，如果可以先确定表之间的关联关系，并将那些存在关联关系的表记录存放在同一个分片上，那么就能较好的避免跨分片join问题。

在1:1或1:n的情况下，通常按照主表的ID主键切分。

这样一来，Data Node1上面的order订单表与orderdetail订单详情表，就可以通过orderId进行局部的关联查询了，Data Node2上也一样。

数据迁移，容量规划，扩容等问题

【方案】

利用对2的倍数取余具有向前兼容的特性（如：对4取余得1、对2取余也是1的数）来分配数据。
避免了行级别的数据迁移，但是依然需要进行表级别的迁移，同时对扩容规模和分表数量都有限制。

【缺点】

总的来说，这些方案都不是十分的理想，多多少少都存在一些缺点，这也从一个侧面反映出了Sharding扩容的难度。

主键ID问题

一旦数据库被切分到多个物理结点上，我们将不能再依赖数据库自身的主键生成机制。

一方面，某个分区数据库自生成的ID无法保证在全局上是唯一的；
另一方面，应用程序在插入数据之前需要先获得ID，以便进行SQL路由。

1) UUID

UUID标准形式包含32个16进制数字，分为5段，形式为8-4-4-4-12的36个字符，例如：550e8400-e29b-41d4-a716-446655440000

UUID是主键是最简单的方案，本地生成，性能高，没有网络耗时。

【缺点】

由于UUID非常长，会占用大量的存储空间；
另外，作为主键建立索引和基于索引进行查询时都会存在性能问题;
在InnoDB下，UUID的无序性会引起数据位置频繁变动，导致分页。

2) 结合数据库维护一个Sequence表

此方案的思路也很简单，在数据库中建立一个Sequence表，表的结构类似于：

CREATE TABLE `SEQUENCE` ( 
 `table_name` varchar(18) NOT NULL, 
 `nextid` bigint(20) NOT NULL, 
 PRIMARY KEY (`table_name`) 
) ENGINE=InnoDB

每当需要为某个表的新纪录生成ID时就从Sequence表中取出对应表的nextid，并将nextid的值加1后更新到数据库中以备下次使用。

【缺点】

由于所有插入任何都需要访问该表，该表很容易成为系统性能瓶颈。
同时它也存在单点问题，一旦该表数据库失效，整个应用程序将无法工作。
有人提出使用Master-Slave进行主从同步，但这也只能解决单点问题，并不能解决读写比为1:1的访问压力问题。

3) Snowflake分布式自增ID算法

Twitter的snowflake算法解决了分布式系统生成全局ID的需求，生成64位的Long型数字，组成部分：

第一位未使用
接下来41位是毫秒级时间，41位的长度可以表示69年的时间
5位datacenterId，5位workerId。10位的长度最多支持部署1024个节点
最后12位是毫秒内的计数，12位的计数顺序号支持每个节点每毫秒产生4096个ID序列

【优点】

毫秒数在高位，生成的ID整体上按时间趋势递增；
不依赖第三方系统，稳定性和效率较高，理论上QPS约为409.6w/s（1000*2^12）；
并且整个分布式系统内不会产生ID碰撞；
可根据自身业务灵活分配bit位。

【缺点】

强依赖机器时钟，如果时钟回拨，则可能导致生成ID重复。

跨分片的排序分页

一般来讲，分页时需要按照指定字段进行排序。当排序字段就是分片字段的时候，我们通过分片规则可以比较容易定位到指定的分片，而当排序字段非分片字段的时候，情况就会变得比较复杂了。

为了最终结果的准确性，我们需要在不同的分片节点中将数据进行排序并返回，并将不同分片返回的结果集进行汇总和再次排序，最后再返回给用户。

如果取得页数很大，情况则变得复杂很多，因为各分片节点中的数据可能是随机的，为了排序的准确性，需要将所有节点的前N页数据都排序好做合并，最后再进行整体的排序，这样的操作时很耗费CPU和内存资源的，所以页数越大，系统的性能也会越差。

【方案】

如果是在前台应用提供分页，则限定用户只能看前面n页，这个限制在业务上也是合理的，一般看后面的分页意义不大（如果一定要看，可以要求用户缩小范围重新查询）。
如果是后台批处理任务要求分批获取数据，则可以加大page size，比如每次获取5000条记录，有效减少分页数（当然离线访问一般走备库，避免冲击主库）。
分库设计时，一般还有配套大数据平台汇总所有分库的记录，有些分页查询可以考虑走大数据平台。

原则

能不切分尽量不要切分

并不是所有表都需要进行切分，主要还是看数据的增长速度。

切分后会在某种程度上提升业务的复杂度，数据库除了承载数据的存储和查询外，协助业务更好的实现需求也是其重要工作之一。
不到万不得已不用轻易使用分库分表这个大招，避免"过度设计"和"过早优化"。
分库分表之前，不要为分而分，先尽力去做力所能及的事情，例如：升级硬件、升级网络、读写分离、索引优化等等。
当数据量达到单表的瓶颈时候，再考虑分库分表。

数据量过大，正常运维影响业务访问

1）对数据库备份，如果单表太大，备份时需要大量的磁盘IO和网络IO。

例如1T的数据，网络传输占50MB时候，需要20000秒才能传输完毕，整个过程的风险都是比较高的

2）对一个很大的表进行DDL修改时，MySQL会锁住全表。

这个时间会很长，这段时间业务不能访问此表，影响很大。
如果使用pt-online-schema-change，使用过程中会创建触发器和影子表，也需要很长的时间。
在此操作过程中，都算为风险时间。将数据表拆分，总量减少，有助于降低这个风险。

3）大表会经常访问与更新，就更有可能出现锁等待。

将数据切分，用空间换时间，变相降低访问压力

随着业务发展，需要对某些字段垂直拆分

举个例子，假如项目一开始设计的用户表如下：

id bigint #用户的ID
name varchar #用户的名字
last_login_time datetime #最近登录时间
personal_info text #私人信息
..... #其他信息字段

在项目初始阶段，这种设计是满足简单的业务需求的，也方便快速迭代开发。

而当业务快速发展时，用户量从10w激增到10亿，用户非常的活跃。

每次登录会更新 last_login_name 字段，使得 user 表被不断update，压力很大。
而其他字段：id, name, personal_info 是不变的或很少更新的。
- 此时在业务角度，就要将 last_login_time 拆分出去，新建一个 user_time 表。
- personal_info 属性是更新和查询频率较低的，并且text字段占据了太多的空间，这时候就要对此垂直拆分出 user_ext 表了。

数据量快速增长

随着业务的快速发展，单表中的数据量会持续增长，当性能接近瓶颈时，就需要考虑水平切分，做分库分表了。此时一定要选择合适的切分规则，提前预估好数据容量

分库数量

分库数量首先和单库能处理的记录数有关。

一般来说，Mysql 单库超过5000万条记录，Oracle单库超过1亿条记录，DB压力就很大(当然处理能力和字段数量/访问模式/记录长度有进一步关系)。

在满足上述前提下，如果分库数量少，达不到分散存储和减轻DB性能压力的目的；
如果分库的数量多，好处是每个库记录少，单库访问性能好，但对于跨多个库的访问，应用程序需要访问多个库，如果是并发模式，要消耗宝贵的线程资源；
如果是串行模式，执行时间会急剧增加。

最后分库数量还直接影响硬件的投入，一般每个分库跑在单独物理机上，多一个库意味多一台设备。

所以具体分多少个库，要综合评估，一般初次分库建议分4-8个库。

路由透明

分库从某种意义上来说，意味着DB schema改变了，必然影响应用，但这种改变和业务无关，所以要尽量保证分库对应用代码透明，分库逻辑尽量在数据访问层处理。

当然完全做到这一点很困难，具体哪些应该由DAL负责，哪些由应用负责，这里有一些建议：

对于单库访问，比如查询条件指定用户Id，则该SQL只需访问特定库。
- 此时应该由DAL层自动路由到特定库，当库二次分裂时，也只要修改mod 因子，应用代码不受影响。
对于简单的多库查询，DAL负责汇总各个数据库返回的记录，此时仍对上层应用透明。

安全性和可用性

在业务层面上垂直切分，将不相关的业务的数据库分隔。

因为每个业务的数据量、访问量都不同，不能因为一个业务把数据库搞挂而牵连到其他业务。

利用水平切分，当一个数据库出现问题时，不会影响到100%的用户，每个库只承担业务的一部分数据，这样整体的可用性就能提高。

开源中间件

站在巨人的肩膀上能省力很多，目前分库分表已经有一些较为成熟的开源解决方案：

Docker从零构建php-nginx-alpine镜像

Fri, 09 Nov 2018 00:00:00 +0000

虽然之前用 Docker 环境运行了一些项目，但对于镜像这块还不是很理解，且网上现成的镜像都包含太多用不到的库，所以决定从零开始构建一个自己的镜像。

选择 Alpine Linux 作为基础镜像

# 拉取 Alpine 镜像
docker pull alpine:latest

# 查看镜像
docker images alpine

Alpine Linux 是一个面向安全的轻量级 Linux 发行版，镜像只有 5MB 左右。

运行并进入容器

# 交互式运行
docker run -it alpine /bin/sh

# 或后台运行
docker run -d --name my-alpine alpine:latest
docker exec -it my-alpine /bin/sh

安装 PHP 和 Nginx

# 更新包索引
apk update

# 安装 PHP 和 Nginx
apk add php7 php7-fpm php7-cli nginx

# 如果使用 PHP 8.x
apk add php81 php81-fpm php81-cli nginx

⚠️ 提示：Alpine 3.18+ 使用 php81、php82 等命名

安装 PHP 扩展

# 安装常用扩展
apk add php7-mysqli \
 php7-pdo_mysql \
 php7-mbstring \
 php7-json \
 php7-zlib \
 php7-gd \
 php7-intl \
 php7-session \
 php7-curl \
 php7-posix \
 php7-fileinfo \
 php7-simplexml \
 php7-xml \
 php7-openssl \
 php7-dom \
 php7-phar

# PHP 8.x 扩展
apk add php81-mysqli php81-pdo_mysql php81-mbstring php81-xml php81-curl

目录结构

软件	路径
PHP 配置	`/etc/php7`
Nginx 配置	`/etc/nginx`
网站目录	`/var/www/localhost/htdocs`
日志目录	`/var/log/nginx`

配置 PHP-FPM

修改 www.conf

vi /etc/php7/php-fpm.d/www.conf

[www]
user = nobody
group = nobody
listen = 127.0.0.1:9000

配置 Nginx

nginx.conf

vi /etc/nginx/nginx.conf

worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /run/nginx.pid;

events {
 worker_connections 1024;
}

http {
 include /etc/nginx/mime.types;
 default_type application/octet-stream;
 
 log_format main '$remote_addr - $remote_user [$time_local] "$request" '
 '$status $body_bytes_sent "$http_referer" '
 '"$http_user_agent" "$http_x_forwarded_for"';
 
 access_log /var/log/nginx/access.log main;
 
 sendfile on;
 keepalive_timeout 65;
 
 include /etc/nginx/conf.d/*.conf;
}

default.conf

vi /etc/nginx/conf.d/default.conf

server {
 listen 80 default_server;
 root /var/www/localhost/htdocs;
 index index.php index.html;
 
 server_name localhost;
 
 location / {
 try_files $uri $uri/ =404;
 }
 
 location ~ \.php$ {
 fastcgi_pass 127.0.0.1:9000;
 fastcgi_index index.php;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 include fastcgi_params;
 }
 
 location ~ /\.ht {
 deny all;
 }
}

启动服务

# 创建必要的目录
mkdir -p /run/nginx

# 启动 PHP-FPM
/usr/sbin/php-fpm7

# 启动 Nginx
/usr/sbin/nginx

# 测试
curl http://localhost

创建 Dockerfile

基础版本

# Dockerfile
FROM alpine:latest

LABEL maintainer="yisonli <email@example.com>"
LABEL version="1.0"
LABEL description="PHP7 + Nginx on Alpine Linux"

# 安装系统工具
RUN apk add --no-cache \
 openssl \
 curl \
 ca-certificates \
 bash

# 安装 PHP 和扩展
RUN apk add --no-cache \
 php7 \
 php7-fpm \
 php7-mysqli \
 php7-pdo_mysql \
 php7-mbstring \
 php7-json \
 php7-gd \
 php7-curl

# 安装 Nginx
RUN apk add --no-cache nginx

# 配置 PHP-FPM
RUN mkdir -p /run/nginx \
 && chown -R nobody:nobody /var/www/localhost

# 复制配置文件
COPY nginx.conf /etc/nginx/nginx.conf
COPY default.conf /etc/nginx/conf.d/
COPY php.ini /etc/php7/php.ini
COPY php-fpm.conf /etc/php7/php-fpm.conf

# 复制应用代码
COPY ./app /var/www/localhost/htdocs

# 暴露端口
EXPOSE 80 443

# 启动脚本
COPY start.sh /start.sh
RUN chmod +x /start.sh

CMD ["/start.sh"]

启动脚本

#!/bin/sh
# start.sh

# 创建必要目录
mkdir -p /run/nginx /var/log/nginx /var/tmp/php-fpm

# 设置权限
chown -R nobody:nobody /var/www/localhost

# 启动 PHP-FPM
/usr/sbin/php-fpm7 &

# 启动 Nginx
/usr/sbin/nginx -g 'daemon off;'

PHP 配置文件

; php.ini
upload_max_filesize = 50M
post_max_size = 50M
memory_limit = 128M
max_execution_time = 300

docker-compose.yml

version: '3.8'

services:
 web:
 build: .
 ports:
 - "8080:80"
 volumes:
 - ./app:/var/www/localhost/htdocs
 environment:
 - PHP_MEMORY_LIMIT=256M
 restart: unless-stopped

 mysql:
 image: mysql:8.0
 environment:
 MYSQL_ROOT_PASSWORD: secret
 MYSQL_DATABASE: app
 volumes:
 - mysql_data:/var/lib/mysql

volumes:
 mysql_data:

构建并运行

# 构建镜像
docker build -t my-php-app:1.0 .

# 运行容器
docker run -d -p 8080:80 --name my-app my-php-app:1.0

# 使用 docker-compose
docker-compose up -d

# 查看日志
docker logs -f my-app

# 进入容器
docker exec -it my-app /bin/sh

常用 Docker 命令

# 查看运行中的容器
docker ps

# 查看所有容器
docker ps -a

# 删除未运行的容器
docker rm $(docker ps -a -q)

# 提交镜像
docker commit -a "yisonli" -m "my php7-nginx" CONTAINER_ID my-php-app:0.1

# 添加标签
docker tag IMAGE_ID my-repo/my-image:tag

# 推送镜像
docker push my-repo/my-image:tag

共享文件夹

# 挂载本地目录
docker run -v $(pwd)/www:/var/www/localhost/htdocs \
 -p 8080:80 \
 my-php-app:1.0

优化建议

使用多阶段构建减小镜像体积
合并 RUN 指令减少层数
使用 .dockerignore排除不需要的文件
使用国内镜像源加速构建

多阶段构建示例

# 构建阶段
FROM composer:2 as builder
WORKDIR /app
COPY composer.* ./
RUN composer install --no-dev
COPY . .
RUN composer dump-autoload --optimize

# 运行阶段
FROM alpine:latest
COPY --from=builder /app /var/www/localhost/htdocs
# ...

参考链接

PHP7内存管理 - 谁动了我的内存

Mon, 05 Nov 2018 00:00:00 +0000

来源：Laruence

Zend 引擎提供了一种特殊的内存管理器，用于处理请求相关数据。请求相关数据是指只需要服务于单个请求，最迟会在请求结束时释放的数据。

内存管理基础

问题引入

<?php

var_dump(memory_get_usage());
// 输出：int(61800) 初始内存

$a = "laruence";
var_dump(memory_get_usage());
// 输出：int(61864) 字符串占用

unset($a);
var_dump(memory_get_usage());
// 输出：int(61864) 为什么没有释放？

内存管理机制

┌─────────────────────────────────────────────────────────────┐
│ PHP 内存管理机制 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 分配请求数据 │
│ │ │
│ ▼ │
│ ┌─────────┐ │
│ │ Zend MM │ ← 特殊内存管理器 │
│ └────┬────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ 堆（Heap） │ │
│ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
│ │ │chunk│ │chunk│ │chunk│ │chunk│ │ │
│ │ └─────┘ └─────┘ └─────┘ └─────┘ │ │
│ └─────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

内存分配策略

Zend MM 内存池

<?php

// 预分配内存（减少系统调用）
var_dump(memory_get_usage(true));
// 输出：int(262144) 256KB 预分配

// 查看峰值
var_dump(memory_get_peak_usage());
// 输出：最大内存使用量

// 峰值（真实分配）
var_dump(memory_get_peak_usage(true));

内存分配函数

函数	说明
`emalloc()`	分配请求内存
`efree()`	释放请求内存
`estrdup()`	复制字符串
`ecalloc()`	分配并初始化为零
`erealloc()`	重新分配内存

PHP 7 内存改进

与 PHP 5 的区别

┌─────────────────────────────────────────────────────────────┐
│ PHP 5 vs PHP 7 内存对比 │
├─────────────────────────────────────────────────────────────┤
│ │
│ PHP 5: │
│ ┌────────────────────┐ │
│ │ zval (16 bytes) │ │
│ │ ├─ refcount (4B) │ │
│ │ ├─ is_ref (4B) │ │
│ │ └─ value (8B) │ │
│ └────────────────────┘ │
│ │
│ PHP 7: │
│ ┌────────────────────┐ │
│ │ zval (16/32 bytes) │ │
│ │ ├─ type (1B) │ │
│ │ ├─ flags (1B) │ │
│ │ └─ value/unioned │ │
│ └────────────────────┘ │
│ │
│ 字符串： zend_string (40 bytes) → (x)ptr + len + hash │
│ 对象： zend_object → Object handlers │
│ │
└─────────────────────────────────────────────────────────────┘

优化效果

<?php
// PHP 5 vs PHP 7 性能对比

// 创建 100000 个简单对象
$start = memory_get_usage();

// PHP 5: ~50MB
// PHP 7: ~5MB

for ($i = 0; $i < 100000; $i++) {
 $objects[] = new stdClass();
}

$end = memory_get_usage();
echo "内存增长: " . ($end - $start) . " bytes\n";

引用计数与循环引用

引用计数机制

<?php

// 变量 a 引用计数为 1
$a = "hello";
debug_zval_dump($a);
// 输出：string(5) "hello" refcount(1)

// 变量 b 也引用同一个值，引用计数为 2
$b = $a;
debug_zval_dump($a);
// 输出：string(5) "hello" refcount(2)

// 删除 b，引用计数回到 1
unset($b);
debug_zval_dump($a);
// 输出：string(5) "hello" refcount(1)

循环引用问题

<?php

// PHP 5 中的循环引用
$a = new stdClass();
$b = new stdClass();

$a->b = $b; // a 引用 b
$b->a = $a; // b 引用 a

// 此时：refcount(a) = 2, refcount(b) = 2
// unset(a): refcount(a) = 1, refcount(b) = 2
// 内存泄漏！

// PHP 7 使用标记清除（GC）解决
unset($a);
unset($b);
// GC 周期会清除循环引用

手动垃圾回收

<?php

// 查看待回收数量
gc_enabled(); // 垃圾回收是否启用
gc_collect_cycles(); // 强制回收循环引用

// 记录垃圾回收状态
$start = gc_collect_cycles();
echo "回收前待处理: $start\n";

// 产生循环引用
$a = new stdClass();
$b = new stdClass();
$a->b = $b;
$b->a = $a;

unset($a);
unset($b);

$after = gc_collect_cycles();
echo "回收后待处理: $after\n";

内存泄漏检测

开启内存泄漏检测

# 编译时启用
./configure --enable-debug --with-valgrind

# 运行测试
php -d memory_limit=128M -d zend.enable_gc=1 script.php

Xdebug 内存跟踪

; php.ini
[xdebug]
xdebug.mode=memory

<?php

// 查看函数调用栈
xdebug_debug_zval('a');

// 查看文件调用
xdebug_stop_trace();

优化建议

1. 及时 unset 大变量

<?php

// 不推荐：大数组保留在内存中
$bigArray = loadLargeData(); // 10MB
process($bigArray);
// $bigArray 仍然占用内存

// 推荐：及时释放
$bigArray = loadLargeData();
process($bigArray);
unset($bigArray); // 释放内存

2. 使用引用减少复制

<?php

// 不推荐：复制整个数组
function processArray(array $arr) {
 // 副本，额外内存
}
$data = range(1, 100000);
processArray($data);

// 推荐：引用传递
function processArray(array &$arr) {
 // 同一数组，无复制
}
processArray($data);

3. 生成器处理大数据

<?php

// 不推荐：一次性加载
function getAllUsers() {
 $users = [];
 foreach ($db->query('SELECT * FROM users') as $row) {
 $users[] = $row; // 全部加载到内存
 }
 return $users;
}

// 推荐：生成器
function getUsersGenerator() {
 foreach ($db->query('SELECT * FROM users') as $row) {
 yield $row; // 逐个返回
 }
}

foreach (getUsersGenerator() as $user) {
 process($user);
}

4. 静态变量陷阱

<?php

class HeavyClass {
 private static $cache = [];

 public static function getInstance() {
 if (!isset(self::$cache['instance'])) {
 self::$cache['instance'] = new HeavyClass();
 }
 return self::$cache['instance'];
 }
 
 // 清理静态缓存
 public static function clearCache() {
 self::$cache = [];
 }
}

性能监控

<?php

class MemoryProfiler {
 private static $marks = [];

 public static function mark(string $name) {
 self::$marks[$name] = memory_get_usage(true);
 }

 public static function report(): array {
 $report = [];
 $last = null;
 foreach (self::$marks as $name => $usage) {
 $delta = ($last !== null) ? ($usage - $last) : 0;
 $report[$name] = [
 'memory' => $usage,
 'delta' => $delta,
 ];
 $last = $usage;
 }

 return $report;
 }
}

// 使用示例
MemoryProfiler::mark('bootstrap');
// ... 业务 ...
MemoryProfiler::mark('after_query');
print_r(MemoryProfiler::report());

1024挑战赛题解

Mon, 29 Oct 2018 00:00:00 +0000

离开学校出社会工作已久，甚是怀念大学时代 ACM 的时光，偶遇组织于 10.24 举行编程挑战赛，遂前去试了一下，很幸运地也拿了点小奖，后于此简单分享。

题目描述

某客户来到我司，购买了 N 份保单，每份保单都有一个起始时间和终止时间。为了简化计算，这两个时间使用两个整数来表示，取值范围为 0 到 1,000,000,000。

例如，其中一份保单的起始时间 t=3 且终止时间 t=9，那么这份保单的有效区间则覆盖了 6 个单位时间（包含两端点）。

可是，由于个人原因，该客户想退掉其中 1 份保单，求 剩余保单能覆盖的最大单位时间总量 是多少？

输入输出格式

输入文件 input.txt：

第一行是整数 N（0 < N <= 100,000），表示接下来总共有 N 行
接下来的 N 行，每行表示一份保单的起始以及终止时间（以空格分割）
所有终止时间都是不同的

输出文件 output.txt：

输出一个数，表示退保 1 份保单后仍能得到覆盖的最大单位时间总量

示例

输入文件(input.txt)：
3
6 9
1 5
3 7

输出文件(output.txt)：
7

解释： 三份保单覆盖区间 [1,5]、[3,7]、[6,9]

最大覆盖总量 = (5-1) + (9-6) = 4 + 3 = 7
选择退掉 [3,7]（最短独立区间），剩余覆盖量最大

题目分析

要点	说明
数据规模	最多 10 万个区间
时间范围	0 到 1,000,000,000
核心考察	区间处理、动态规划思想
关键难点	如何找到"最无用"的保单

暴破解法（不可行）

假设分配 10 亿个桶，遍历所有区间… ❌ 数据量太大

正确思路

每个保单是否"有用"，取决于它的独立覆盖区域
只需计算每个保单独立拥有的区域大小
剔除独立区域最小的保单即可

解题思路

┌─────────────────────────────────────────────────────────┐
│ 算法流程 │
├─────────────────────────────────────────────────────────┤
│ │
│ 1. 读取 N 个保单，计算每个保单的区间长度 │
│ │
│ 2. 按起点、终点递增方式进行二级排序 │
│ │
│ 3. 划分不重叠的大区间（多个重叠取最小&最大值） │
│ │
│ 4. 计算每个保单的独立覆盖区域 │
│ │
│ 5. 找到独立区域最小的保单，剔除 │
│ │
│ 6. 累加剩余保单的独立区域 = 答案 │
│ │
└─────────────────────────────────────────────────────────┘

C 语言实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 100000

// 区间结构体
typedef struct {
 int start;
 int end;
 int length; // 区间长度
 int alone; // 独立区域
} Interval;

// 比较函数：按起点排序
int cmp_start(const void *a, const void *b) {
 Interval *ia = (Interval *)a;
 Interval *ib = (Interval *)b;
 if (ia->start != ib->start) {
 return ia->start - ib->start;
 }
 return ia->end - ib->end;
}

// 读取输入
int read_input(const char *filename, Interval *intervals) {
 FILE *fp = fopen(filename, "r");
 if (!fp) {
 printf("Cannot open file: %s\n", filename);
 return -1;
 }
 
 int n;
 fscanf(fp, "%d", &n);
 
 for (int i = 0; i < n; i++) {
 fscanf(fp, "%d %d", &intervals[i].start, &intervals[i].end);
 intervals[i].length = intervals[i].end - intervals[i].start;
 intervals[i].alone = 0;
 }
 
 fclose(fp);
 return n;
}

// 计算独立区域
void calculate_alone(Interval *intervals, int n) {
 // 遍历所有区间对
 for (int i = 0; i < n; i++) {
 int start = intervals[i].start;
 int end = intervals[i].end;
 int overlap_start = -1;
 int overlap_end = -1;
 
 // 找到所有与当前区间重叠的区间
 for (int j = 0; j < n; j++) {
 if (i == j) continue;
 
 // 检测重叠：当前区间的起点在另一个区间内
 if (intervals[j].start <= start && start < intervals[j].end) {
 if (overlap_start == -1 || intervals[j].start > overlap_start) {
 overlap_start = intervals[j].start;
 }
 }
 
 // 检测重叠：当前区间的终点在另一个区间内
 if (intervals[j].start < end && end <= intervals[j].end) {
 if (overlap_end == -1 || intervals[j].end < overlap_end) {
 overlap_end = intervals[j].end;
 }
 }
 }
 
 // 计算独立区域
 int left_alone = 0;
 int right_alone = 0;
 
 if (overlap_start != -1) {
 left_alone = start - overlap_start;
 } else {
 left_alone = intervals[i].length;
 }
 
 if (overlap_end != -1) {
 right_alone = overlap_end - end;
 } else {
 right_alone = intervals[i].length;
 }
 
 intervals[i].alone = left_alone + right_alone;
 }
}

// 写输出
void write_output(const char *filename, long long result) {
 FILE *fp = fopen(filename, "w");
 if (!fp) {
 printf("Cannot open file: %s\n", filename);
 return;
 }
 
 fprintf(fp, "%lld\n", result);
 fclose(fp);
}

int main() {
 Interval intervals[MAX_N];
 
 // 读取输入
 int n = read_input("input.txt", intervals);
 if (n <= 0) {
 return 1;
 }
 
 // 排序
 qsort(intervals, n, sizeof(Interval), cmp_start);
 
 // 计算每个保单的独立区域
 calculate_alone(intervals, n);
 
 // 找到独立区域最小的
 int min_alone = intervals[0].alone;
 long long total_length = intervals[0].length;
 
 for (int i = 1; i < n; i++) {
 total_length += intervals[i].length;
 if (intervals[i].alone < min_alone) {
 min_alone = intervals[i].alone;
 }
 }
 
 // 结果 = 总长度 - 被剔除区间的独立区域
 long long result = total_length - min_alone;
 
 // 写输出
 write_output("output.txt", result);
 
 printf("Result: %lld\n", result);
 
 return 0;
}

优化版本（单次读入 + 动态内存）

下面的写法与上文算法一致：读入后排序，调用同样的 calculate_alone 逻辑，再把「总区间长度之和 − 最小独立覆盖」写入结果。此处用 malloc/free 取代固定栈上大数组，适合在栈空间受限的环境编译；去掉 C++ 的 new，避免混用两套语言特性。

#include <stdio.h>
#include <stdlib.h>

#define MAX_N 100000

typedef struct {
 int start;
 int end;
 int length;
 int alone;
} Interval;

static int cmp_start(const void *a, const void *b) {
 Interval *ia = (Interval *)a;
 Interval *ib = (Interval *)b;
 return ia->start != ib->start ? ia->start - ib->start : ia->end - ib->end;
}

static void calculate_alone(Interval *intervals, int n) {
 int i, j;
 for (i = 0; i < n; i++) {
 int start = intervals[i].start;
 int end = intervals[i].end;
 int overlap_start = -1;
 int overlap_end = -1;

 for (j = 0; j < n; j++) {
 if (i == j) continue;

 if (intervals[j].start <= start && start < intervals[j].end) {
 if (overlap_start == -1 || intervals[j].start > overlap_start) {
 overlap_start = intervals[j].start;
 }
 }

 if (intervals[j].start < end && end <= intervals[j].end) {
 if (overlap_end == -1 || intervals[j].end < overlap_end) {
 overlap_end = intervals[j].end;
 }
 }
 }

 {
 int left_alone, right_alone;
 if (overlap_start != -1) {
 left_alone = start - overlap_start;
 } else {
 left_alone = intervals[i].length;
 }

 if (overlap_end != -1) {
 right_alone = overlap_end - end;
 } else {
 right_alone = intervals[i].length;
 }

 intervals[i].alone = left_alone + right_alone;
 }
 }
}

int main(void) {
 FILE *fin = fopen("input.txt", "r");
 FILE *fout = fopen("output.txt", "w");
 int n, i;

 if (!fin || !fout) return 1;

 fscanf(fin, "%d", &n);
 if (n <= 0 || n > MAX_N) {
 fclose(fin);
 fclose(fout);
 return 1;
 }

 Interval *intervals = (Interval *)malloc(sizeof(Interval) * (size_t)n);
 if (!intervals) {
 fclose(fin);
 fclose(fout);
 return 1;
 }

 long long total_length = 0;

 for (i = 0; i < n; i++) {
 fscanf(fin, "%d %d", &intervals[i].start, &intervals[i].end);
 intervals[i].length = intervals[i].end - intervals[i].start;
 intervals[i].alone = intervals[i].length;
 total_length += intervals[i].length;
 }
 fclose(fin);

 qsort(intervals, (size_t)n, sizeof(Interval), cmp_start);
 calculate_alone(intervals, n);

 int min_alone = intervals[0].alone;
 for (i = 1; i < n; i++) {
 if (intervals[i].alone < min_alone) {
 min_alone = intervals[i].alone;
 }
 }

 {
 long long result = total_length - min_alone;
 fprintf(fout, "%lld\n", result);
 printf("Result: %lld\n", result);
 }

 fclose(fout);
 free(intervals);
 return 0;
}

说明：比赛场景下也可继续尝试「扫描线 / 线段树」等更精细的区间结构以降低常数；本文侧重与前一版一致的思路对照。

PHP的OpenSSL加密扩展使用小结

Wed, 25 Jul 2018 00:00:00 +0000

互联网的发展史上，安全性一直是开发者们相当重视的主题。为了实现数据传输安全，我们需要保证：数据来源（防伪造）、数据完整性（防篡改）、数据私密性（防窃听）。

加密基础

加密算法分类

┌─────────────────────────────────────────────────────────────┐
│ 加密算法分类 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ 对称加密 │ │ 非对称加密 │ │
│ ├─────────────────┤ ├─────────────────┤ │
│ │ • DES │ │ • RSA │ │
│ │ • AES │ │ • DSA │ │
│ │ • 3DES │ │ • ECC │ │
│ │ • Blowfish │ │ • DH │ │
│ └─────────────────┘ └─────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 数字签名 │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ • MD5 (已不安全) • SHA-1 (已不安全) │ │
│ │ • SHA-256 • SHA-512 • HMAC │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

对称加密

特点：

加密和解密使用同一密钥
速度快，适合大量数据
加密前后文件大小变化不大
密钥管理是难题

常见算法：DES、AES、3DES、Blowfish

非对称加密

特点：

使用公钥和私钥一对密钥
公钥加密，私钥解密（或反之）
计算量大，速度慢
适合密钥交换和数字签名

常见算法：RSA、DSA、ECC

数字签名

特点：

无论原始数据多大，输出长度固定
输入相同，输出相同
微小改变导致输出巨大变化
不可逆，无法从哈希值恢复原始数据

常见算法：MD5、SHA-1、SHA-256、HMAC

PHP OpenSSL 扩展

安装检查

<?php
// 检查 OpenSSL 扩展是否启用
if (extension_loaded('openssl')) {
 echo "OpenSSL 已启用";
 
 // 查看支持的加密算法
 print_r(openssl_get_cipher_methods());
 print_r(openssl_get_md_methods());
} else {
 echo "OpenSSL 未启用";
}

对称加密

AES 加密

<?php

/**
 * AES-256-CBC 加密
 * 
 * @param string $data 待加密数据
 * @param string $key 密钥（32字节）
 * @param string $iv 初始化向量（16字节）
 * @return string 加密后的数据（base64编码）
 */
function aes_encrypt(string $data, string $key, string $iv = ''): string
{
 // 密钥必须是 32 字节（AES-256）
 $key = hash('sha256', $key, true);
 
 // IV 必须是 16 字节（AES 块大小）
 if (strlen($iv) !== 16) {
 $iv = openssl_random_pseudo_bytes(16);
 }
 
 $encrypted = openssl_encrypt(
 $data,
 'AES-256-CBC',
 $key,
 OPENSSL_RAW_DATA, // 返回原始数据
 $iv
 );
 
 // 返回 IV + 密文（便于解密）
 return base64_encode($iv . $encrypted);
}

/**
 * AES-256-CBC 解密
 * 
 * @param string $encrypted 加密数据（base64编码）
 * @param string $key 密钥
 * @return string 解密后的数据
 */
function aes_decrypt(string $encrypted, string $key): string
{
 $key = hash('sha256', $key, true);
 $data = base64_decode($encrypted);
 
 // 提取 IV（前 16 字节）
 $iv = substr($data, 0, 16);
 $ciphertext = substr($data, 16);
 
 return openssl_decrypt(
 $ciphertext,
 'AES-256-CBC',
 $key,
 OPENSSL_RAW_DATA,
 $iv
 );
}

// 使用示例
$key = 'your-secret-key-here';
$data = 'Hello, World! 你好世界！';

$encrypted = aes_encrypt($data, $key);
echo "加密后: " . $encrypted . "\n";

$decrypted = aes_decrypt($encrypted, $key);
echo "解密后: " . $decrypted . "\n";

其他对称加密算法

<?php

$key = hash('sha256', 'password', true);

// AES-128-CBC（密钥 16 字节）
$encrypted = openssl_encrypt($data, 'AES-128-CBC', $key, OPENSSL_RAW_DATA, $iv);

// AES-128-ECB（无需 IV，但不安全）
$encrypted = openssl_encrypt($data, 'AES-128-ECB', $key);

// DES（不安全，不推荐）
$encrypted = openssl_encrypt($data, 'DES-ECB', $key);

非对称加密

生成 RSA 密钥对

<?php

/**
 * 生成 RSA 密钥对
 * 
 * @param int $bits 密钥位数（推荐 2048 或 4096）
 * @return array ['private_key' => string, 'public_key' => string]
 */
function generate_rsa_keypair(int $bits = 2048): array
{
 $config = [
 'private_key_bits' => $bits,
 'private_key_type' => OPENSSL_KEYTYPE_RSA,
 ];
 
 // 生成密钥对
 $keyPair = openssl_pkey_new($config);
 
 // 导出私钥
 openssl_pkey_export($keyPair, $privateKey);
 
 // 导出公钥
 $publicKeyDetails = openssl_pkey_get_details($keyPair);
 $publicKey = $publicKeyDetails['key'];
 
 return [
 'private_key' => $privateKey,
 'public_key' => $publicKey,
 ];
}

// 生成密钥对
$keyPair = generate_rsa_keypair(2048);

echo "私钥:\n" . $keyPair['private_key'] . "\n\n";
echo "公钥:\n" . $keyPair['public_key'] . "\n";

// 保存到文件
file_put_contents('private.key', $keyPair['private_key']);
file_put_contents('public.key', $keyPair['public_key']);

// 设置权限（Linux）
chmod('private.key', 0600);

RSA 加密解密

<?php

/**
 * RSA 加密（使用公钥）
 * 
 * @param string $data 待加密数据
 * @param string $publicKey 公钥
 * @return string 加密后的数据（base64编码）
 */
function rsa_encrypt(string $data, string $publicKey): string
{
 $publicKey = openssl_pkey_get_public($publicKey);
 
 openssl_public_encrypt($data, $encrypted, $publicKey);
 
 return base64_encode($encrypted);
}

/**
 * RSA 解密（使用私钥）
 * 
 * @param string $encrypted 加密数据（base64编码）
 * @param string $privateKey 私钥
 * @return string 解密后的数据
 */
function rsa_decrypt(string $encrypted, string $privateKey): string
{
 $privateKey = openssl_pkey_get_private($privateKey);
 
 $data = base64_decode($encrypted);
 openssl_private_decrypt($data, $decrypted, $privateKey);
 
 return $decrypted;
}

// 使用示例
$keyPair = generate_rsa_keypair();

$data = 'Hello, RSA!';

$encrypted = rsa_encrypt($data, $keyPair['public_key']);
echo "加密后: " . $encrypted . "\n";

$decrypted = rsa_decrypt($encrypted, $keyPair['private_key']);
echo "解密后: " . $decrypted . "\n";

⚠️ 限制：RSA 加密的数据长度有限制（密钥位数 / 8 - 11 字节）

分块加密大文件

<?php

/**
 * RSA 分块加密（用于大数据）
 * 
 * @param string $data 待加密数据
 * @param string $publicKey 公钥
 * @return string 加密后的数据（base64编码）
 */
function rsa_encrypt_large(string $data, string $publicKey): string
{
 $res = openssl_pkey_get_public($publicKey);
 if ($res === false) {
 throw new InvalidArgumentException('Invalid public key');
 }
 $details = openssl_pkey_get_details($res);
 $maxChunk = (int) ($details['bits'] / 8) - 11; // PKCS#1 填充占用 11 字节
 if ($maxChunk <= 0) {
 throw new RuntimeException('Key size too small');
 }

 $cipherRaw = '';
 $len = strlen($data);
 for ($i = 0; $i < $len; $i += $maxChunk) {
 $chunk = substr($data, $i, $maxChunk);
 $out = '';
 if (!openssl_public_encrypt($chunk, $out, $res, OPENSSL_PKCS1_PADDING)) {
 throw new RuntimeException('openssl_public_encrypt failed');
 }
 $cipherRaw .= $out;
 }
 return base64_encode($cipherRaw);
}

/**
 * RSA 分块解密
 *
 * @param string $encrypted 公钥加密且经 base64 编码的密文
 * @param string $privateKey 私钥
 * @return string 原文
 */
function rsa_decrypt_large(string $encrypted, string $privateKey): string
{
 $res = openssl_pkey_get_private($privateKey);
 if ($res === false) {
 throw new InvalidArgumentException('Invalid private key');
 }
 $details = openssl_pkey_get_details($res);
 $block = (int) ($details['bits'] / 8);
 $raw = base64_decode($encrypted, true);
 if ($raw === false) {
 throw new InvalidArgumentException('Invalid base64 cipher');
 }

 $plain = '';
 $len = strlen($raw);
 for ($i = 0; $i < $len; $i += $block) {
 $chunk = substr($raw, $i, $block);
 $out = '';
 if (!openssl_private_decrypt($chunk, $out, $res, OPENSSL_PKCS1_PADDING)) {
 throw new RuntimeException('openssl_private_decrypt failed');
 }
 $plain .= $out;
 }
 return $plain;
}

/*
 * 小结：超长明文请优先使用「RSA 协商对称密钥 + AES」的混合加密；本节分块 RSA 适用于必须纯 RSA 的场景，
 * 实现时注意密钥位数与性能开销。
 */

在Yii2框架上使用PHPUnit做单元测试与代码覆盖率

Fri, 11 May 2018 00:00:00 +0000

PHPUnit 是一个很不错的测试框架，既能做自动化单元测试，也能同时检测代码覆盖率。自己在 Yii 框架上经过一番尝试，总结了这篇配置指南。

目录结构约定

在 Yii2 项目下，需要创建 phpunit 目录：

yii2-project/
├── phpunit/
│ ├── README.md # 说明文档
│ ├── _bootstrap.php # 框架初始化文件
│ ├── phpunit.xml # 配置文件
│ └── tests/
│ ├── UserAuthTest.php
│ └── ...
├── frontend/
├── backend/
└── common/

_bootstrap.php 引导文件

参考 frontend/web/index.php，创建引导文件：

<?php
// phpunit/_bootstrap.php

// 定义测试环境常量
defined('YII_DEBUG') or define('YII_DEBUG', true);
defined('YII_ENV') or define('YII_ENV', 'test');

// 引入 Composer 自动加载
require_once dirname(__DIR__) . '/vendor/autoload.php';

// 引入 Yii 入口文件
require_once dirname(__DIR__) . '/frontend/web/index.php';

// 返回应用实例（而不是运行）
return Yii::$app;

phpunit.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
 bootstrap="_bootstrap.php"
 backupGlobals="false"
 backupStaticAttributes="false"
 beStrictAboutCoversAnnotation="true"
 beStrictAboutOutputDuringTests="true"
 beStrictAboutTestsThatDoNotTestAnything="true"
 beStrictAboutTodoAnnotatedTests="true"
 forceCoversAnnotation="true"
 verbose="true"
 colors="true">
 
 <!-- 测试套件配置 -->
 <testsuites>
 <testsuite name="Application Test Suite">
 <directory suffix="Test.php">./tests</directory>
 </testsuite>
 </testsuites>

 <!-- 代码覆盖率配置 -->
 <coverage>
 <include>
 <directory suffix=".php">../frontend/controllers</directory>
 <directory suffix=".php">../backend/controllers</directory>
 <directory suffix=".php">../common</directory>
 <directory suffix=".php">../console</directory>
 </include>
 <exclude>
 <directory suffix=".php">../common/mail</directory>
 <directory suffix=".php">../common/config</directory>
 </exclude>
 </coverage>

 <!-- 日志配置 -->
 <logging>
 <log type="coverage-html" target="coverage"/>
 <log type="coverage-clover" target="logs/clover.xml"/>
 <log type="coverage-crap4j" target="logs/crap4j.xml"/>
 <log type="junit" target="logs/junit.xml"/>
 <log type="testdox-html" target="testdox/index.html"/>
 </logging>
</phpunit>

安装 PHPUnit

使用 Composer 安装

# 进入项目目录
cd your-yii2-project

# 安装 PHPUnit（建议作为开发依赖）
composer require --dev phpunit/phpunit:^9.0

# 或者安装带 PHP 版本支持的版本
composer require --dev phpunit/phpunit:"^9.0" --ignore-platform-reqs

# 安装代码覆盖率扩展
composer require --dev phpunit/php-code-coverage

验证安装

# 检查 PHPUnit 版本
./vendor/bin/phpunit --version

# PHPUnit 9.x 输出
# PHPUnit 9.6.x by Sebastian Bergmann and contributors.

测试命令

运行测试

# 进入测试目录
cd phpunit/

# 运行所有测试
../vendor/bin/phpunit --configuration phpunit.xml

# 指定测试文件
../vendor/bin/phpunit --configuration phpunit.xml tests/UserAuthTest.php

# 运行测试套件
../vendor/bin/phpunit --configuration phpunit.xml --testsuite "Application Test Suite"

生成覆盖率报告

# 生成 HTML 覆盖率报告
../vendor/bin/phpunit --configuration phpunit.xml --coverage-html coverage

# 生成 Clover XML 格式报告（可导入 CI 系统）
../vendor/bin/phpunit --configuration phpunit.xml --coverage-clover logs/clover.xml

编写单元测试

基本测试示例

<?php
// tests/UserAuthTest.php

namespace tests;

use PHPUnit\Framework\TestCase;
use common\models\User;

class UserAuthTest extends TestCase
{
 /**
 * @covers \common\models\User
 */
 public function testUserCanBeCreated()
 {
 $user = new User();
 $user->username = 'testuser';
 $user->email = 'test@example.com';
 
 $this->assertInstanceOf(User::class, $user);
 $this->assertEquals('testuser', $user->username);
 }

 /**
 * @covers \common\models\User::validatePassword()
 */
 public function testPasswordValidation()
 {
 $user = new User();
 $user->password_hash = password_hash('secret', PASSWORD_DEFAULT);
 
 $this->assertTrue($user->validatePassword('secret'));
 $this->assertFalse($user->validatePassword('wrong'));
 }

 /**
 * @covers \common\models\User::getId()
 */
 public function testUserIdReturnsInteger()
 {
 $user = new User();
 $user->id = 123;
 
 $this->assertIsInt($user->getId());
 $this->assertEquals(123, $user->getId());
 }
}

Yii2 ActiveRecord 测试

<?php
// tests/UserModelTest.php

namespace tests;

use Yii;
use Codeception\Specify;
use common\fixtures\UserFixture;
use common\models\User;

class UserModelTest extends \yii\codeception\TestCase
{
 // 加载测试数据
 public $fixtures = [
 'user' => [
 'class' => UserFixture::class,
 'dataFile' => '@tests/fixtures/data/user.php',
 ],
 ];

 public function testUserLogin()
 {
 $user = User::findByUsername('erau');
 
 $this->assertNotNull($user);
 $this->assertTrue($user->validatePassword('password_0'));
 }

 public function testUserNotFound()
 {
 $user = User::findByUsername('nonexistent');
 
 $this->assertNull($user);
 }
}

Fixture 数据文件

<?php
// tests/fixtures/data/user.php

return [
 'user1' => [
 'id' => 1,
 'username' => 'erau',
 'auth_key' => 'testAuthKey_0',
 'password_hash' => '$2y$13$qFS7HXXkJb9V5KjZ8xX7EOYKvW7YQZ1xX7EOYKvW7YQZ1xX7EO',
 'email' => 'erau@example.com',
 'status' => 10,
 'created_at' => 1500000000,
 'updated_at' => 1500000000,
 ],
];

常用注解

注解	说明
`@covers ClassName`	指定测试覆盖的类
`@covers ClassName::method`	指定测试覆盖的方法
`@coversNothing`	该测试不计入覆盖率
`@depends`	依赖另一个测试
`@dataProvider`	数据供给器

/**
 * @covers \common\models\User::findByUsername()
 * @covers \common\models\User::validatePassword()
 */
public function testLoginWithValidCredentials()
{
 // ...
}

CI 集成

GitHub Actions

# .github/workflows/phpunit.yml
name: PHPUnit Tests

on: [push, pull_request]

jobs:
 test:
 runs-on: ubuntu-latest
 
 steps:
 - uses: actions/checkout@v3
 
 - name: Setup PHP
 uses: shivammathur/setup-php@v2
 with:
 php-version: '8.1'
 extensions: pdo_mysql, intl
 coverage: xdebug
 
 - name: Install Dependencies
 run: composer install --prefer-dist
 
 - name: Run PHPUnit
 run: ./vendor/bin/phpunit --configuration phpunit.xml --colors=never

最佳实践

遵循 AAA 模式（Arrange-Act-Assert）
测试单一职责 - 每个测试只验证一个行为

PHP代码覆盖率入门指南

Fri, 04 May 2018 00:00:00 +0000

最近在玩 PHP 的单元测试，以及代码覆盖率这块，遇到一些问题，记录下来作为简单入门参考。

安装 PHPUnit

Composer 安装（推荐）

# 进入项目目录
cd your-project

# 安装 PHPUnit
composer require --dev phpunit/phpunit:^10.0

# 安装代码覆盖率扩展
composer require --dev phpunit/php-code-coverage

PHP Archive (PHAR)

# 下载 PHPUnit
wget https://phar.phpunit.de/phpunit-10.phar

# 添加执行权限
chmod +x phpunit-10.phar

# 全局安装
sudo mv phpunit-10.phar /usr/local/bin/phpunit

# 验证
phpunit --version

基础单元测试示例

编写测试

<?php
// tests/StackTest.php

namespace tests;

use PHPUnit\Framework\TestCase;

class StackTest extends TestCase
{
 /**
 * 测试空栈
 */
 public function testEmpty(): void
 {
 $stack = [];
 $this->assertEmpty($stack);

 return $stack;
 }

 /**
 * 测试压栈
 * @depends testEmpty
 */
 public function testPush(array $stack): array
 {
 array_push($stack, 'foo');
 $this->assertEquals('foo', $stack[count($stack) - 1]);
 $this->assertNotEmpty($stack);

 return $stack;
 }

 /**
 * 测试弹栈
 * @depends testPush
 */
 public function testPop(array $stack): void
 {
 $this->assertEquals('foo', array_pop($stack));
 $this->assertEmpty($stack);
 }
}

运行测试

# 运行所有测试
phpunit --verbose tests/

# 运行指定测试文件
phpunit --verbose tests/StackTest.php

# 运行指定测试方法
phpunit --verbose tests/StackTest.php --filter testPush

输出示例

PHPUnit 10.0 by Sebastian Bergmann and contributors.

Runtime: PHP 8.2.0 with Xdebug 3.2.0

... 3 / 3 (100%)

Time: 149 ms, Memory: 10.00MB

OK (3 tests, 5 assertions)

代码覆盖率配置

phpunit.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
 bootstrap="vendor/autoload.php"
 colors="true"
 executionOrder="depends,defects"
 beStrictAboutOutputDuringTests="true"
 cacheResultFile=".phpunit.cache/test-results">
 
 <testsuites>
 <testsuite name="Unit Tests">
 <directory suffix="Test.php">./tests</directory>
 </testsuite>
 </testsuites>

 <coverage>
 <include>
 <directory suffix=".php">./src</directory>
 </include>
 <exclude>
 <directory suffix=".php">./src/Exceptions</directory>
 <file>./src/bootstrap.php</file>
 </exclude>
 
 <!-- HTML 报告 -->
 <report>
 <html outputDirectory="coverage"/>
 </report>
 
 <!-- Clover XML 报告（CI 集成） -->
 <report>
 <clover outputFile="coverage/clover.xml"/>
 </report>
 </coverage>
</phpunit>

运行覆盖率测试

# 生成覆盖率报告
phpunit --coverage-html coverage/

# 指定覆盖率输出目录
phpunit --coverage-html ./report/coverage/

# 生成 Clover XML 格式
phpunit --coverage-clover coverage/clover.xml

常用断言方法

断言	说明
`assertEquals($expected, $actual)`	值相等
`assertSame($expected, $actual)`	同一对象/值
`assertTrue($condition)`	条件为真
`assertFalse($condition)`	条件为假
`assertNull($value)`	值为空
`assertContains($needle, $haystack)`	数组/字符串包含
`assertCount($expected, $actual)`	元素数量
`assertEmpty($actual)`	值为空
`assertThrows($exception, $callable)`	抛出异常
`assertMatchesRegularExpression($pattern, $string)`	正则匹配

测试依赖

@depends 依赖

public function testCreate(): array
{
 $entity = new Entity();
 $entity->create(['name' => 'test']);
 $this->assertNotNull($entity->getId());
 
 return ['id' => $entity->getId()];
}

/**
 * @depends testCreate
 */
public function testFind(array $data): void
{
 $entity = new Entity();
 $found = $entity->find($data['id']);
 
 $this->assertNotNull($found);
 $this->assertEquals('test', $found->name);
}

数据供给器

@dataProvider

/**
 * @dataProvider additionProvider
 */
public function testAddition(int $a, int $b, int $expected): void
{
 $this->assertEquals($expected, $a + $b);
}

public function additionProvider(): array
{
 return [
 'zero plus zero' => [0, 0, 0],
 'positive numbers' => [1, 2, 3],
 'negative numbers' => [-1, -1, -2],
 ];
}

Mock 对象

创建 Mock

use PHPUnit\Framework\TestCase;
use App\Services\UserService;
use App\Repositories\UserRepository;

class UserServiceTest extends TestCase
{
 public function testGetUserName(): void
 {
 // 创建 Mock 对象
 $repository = $this->createMock(UserRepository::class);
 
 // 配置 Mock 行为
 $repository->method('find')
 ->with(1)
 ->willReturn(['id' => 1, 'name' => 'John']);
 
 // 使用 Mock
 $service = new UserService($repository);
 $name = $service->getUserName(1);
 
 $this->assertEquals('John', $name);
 }
}

Mock 方法链

$mock = $this->getMockBuilder(stdClass::class)
 ->addMethods(['getName', 'setName'])
 ->getMock();

$mock->method('getName')->willReturn('Test');

数据集测试

use PHPUnit\Framework\TestCase;

class DataProviderTest extends TestCase
{
 /**
 * @dataProvider additionProvider
 */
 public function testAdditions(int $a, int $b, int $expected): void
 {
 $this->assertEquals($expected, $a + $b);
 }

 public static function additionProvider(): array
 {
 return [
 'integers' => [1, 2, 3],
 'floats' => [0.1, 0.2, 0.3],
 ];
 }
}

CI 集成

GitHub Actions

# .github/workflows/phpunit.yml
name: PHPUnit Tests

on: [push, pull_request]

jobs:
 test:
 runs-on: ubuntu-latest
 
 steps:
 - uses: actions/checkout@v3
 
 - name: Setup PHP
 uses: shivammathur/setup-php@v2
 with:
 php-version: '8.2'
 extensions: xdebug
 coverage: xdebug
 
 - name: Install Dependencies
 run: composer install --prefer-dist
 
 - name: Run Tests with Coverage
 run: |
 ./vendor/bin/phpunit \n --coverage-text \n --coverage-clover coverage/clover.xml
 env:
 XDEBUG_MODE: coverage

常见问题

Q: Xdebug 版本不兼容

# PHPUnit 10 需要 Xdebug 3.x
composer require --dev phpunit/phpunit:^10.0
pecl install xdebug

# Xdebug 2.x 适配 PHPUnit 9
composer require --dev phpunit/phpunit:^9.0
pecl install xdebug-2.9.8

Q: 覆盖率不准确

检查 phpunit.xml 中的 include/exclude 配置是否正确：

<coverage>
 <include>
 <directory suffix=".php">./src</directory>
 </include>
</coverage>

最佳实践

每个发布单元（类/模块）至少覆盖一条主路径与一条异常路径，优先保证核心业务与错误分支可被测试执行到。
单元测试避免直连真实数据库、MQ、第三方 HTTP，可用接口抽象 + 内存实现或 Mock，使覆盖率反映的是「你的代码」而非外部环境。
在 CI 中固定 PHPUnit、Xdebug 主版本，并通过环境变量注入 XDEBUG_MODE=coverage，避免本地与流水线结果不一致。
覆盖率是手段不是目的：不必盲目追求 100%；对复杂条件分支优先补测试用例或重构降低圈复杂度。
结合静态分析与 CR：将 Clover/XML 输出接入 SonarQube、Codecov 等工具，对新增未覆盖代码做团队约定（例如 Diff Coverage 阈值）。

Xdebug源码安装指南

Fri, 04 May 2018 00:00:00 +0000

PHP 在 Linux/macOS 上安装 Xdebug 的方法

方法一：PECL 安装（推荐）

# 安装 Xdebug（会自动编译）
pecl install xdebug

# 或者指定版本
pecl install xdebug-3.2.2

安装后会在输出中显示需要添加到 php.ini 的配置。

方法二：源码编译安装

1. 下载源码

到 Xdebug 官网下载源码：

# 下载稳定版本（推荐）
wget https://xdebug.org/files/xdebug-3.2.2.tgz

# 或者下载最新版本
wget https://xdebug.org/files/xdebug-3.3.1.tgz

2. 解压并编译

# 解压
tar -xvf xdebug-3.3.1.tgz
cd xdebug-3.3.1

# 生成编译配置
phpize

# 编译
./configure --enable-xdebug
make

3. 安装

# 查看编译产物
ls modules/
# 输出：xdebug.so

# 拷贝到 PHP 扩展目录
cp modules/xdebug.so /usr/lib/php/extensions/xdebug.so

💡 使用 php -i | grep extension_dir 查看扩展目录路径

4. 配置 php.ini

在 php.ini 中添加：

[xdebug]
; Xdebug 3.x 配置
zend_extension=xdebug.so

; 开启性能分析
xdebug.mode=profile

; 开启调试模式
; xdebug.mode=debug

; IDE IP 地址
xdebug.client_host=127.0.0.1

; IDE 端口
xdebug.client_port=9003

; 启动调试的方式
; xdebug.start_with_request=yes

5. 重启服务

# Nginx + PHP-FPM
sudo service php-fpm restart
# 或
sudo systemctl restart php-fpm

# Apache
sudo service apache2 restart

Xdebug 3.x 配置详解

⚠️ 重要：Xdebug 3.x 相比 2.x 有重大变化！

配置项对照表

Xdebug 2.x	Xdebug 3.x	说明
`xdebug.remote_enable`	`xdebug.mode`	调试模式开关
`xdebug.remote_host`	`xdebug.client_host`	IDE 主机地址
`xdebug.remote_port`	`xdebug.client_port`	IDE 端口
`xdebug.remote_autostart`	`xdebug.start_with_request`	自动启动调试
`xdebug.remote_handler`	-	已移除
`xdebug.idekey`	`xdebug.idekey`	IDE Key

常用配置示例

[xdebug]
; 加载扩展
zend_extension=xdebug.so

; 调试模式：debug/profile/coverage/off
xdebug.mode=debug

; IDE 主机地址（IDE 所在机器的 IP）
xdebug.client_host=127.0.0.1

; IDE 端口
xdebug.client_port=9003

; 自动启动调试
xdebug.start_with_request=trigger

; 记录调试日志
xdebug.log=/var/log/xdebug.log
xdebug.log_level=3

不同模式说明

# 关闭所有功能
xdebug.mode=off

# 调试模式（断点调试）
xdebug.mode=debug

# 性能分析（生成 cachegrind 文件）
xdebug.mode=profile

# 代码覆盖率分析
xdebug.mode=coverage

# 触发调试（浏览器安装 Xdebug Helper 插件）
xdebug.mode=debug
xdebug.start_with_request=trigger

验证安装

# 检查 Xdebug 是否加载
php -m | grep xdebug

# 查看详细配置
php -i | grep xdebug

输出示例：

xdebug
xdebug Support => enabled
Version => 3.3.1
IDE Key => yison

IDE 配置

VS Code

安装 PHP Debug 扩展，配置 launch.json：

{
 "version": "0.2.0",
 "configurations": [
 {
 "name": "Listen for Xdebug",
 "type": "php",
 "request": "launch",
 "port": 9003,
 "pathMappings": {
 "/var/www/html": "${workspaceFolder}"
 }
 }
 ]
}

PhpStorm

Settings → PHP → Debug
确认 Xdebug 端口为 9003
点击电话图标开始监听

常见问题

Q: phpize 报错：autoconf not found

# Ubuntu/Debian
sudo apt-get install autoconf

# CentOS/RHEL
sudo yum install autoconf

# macOS
brew install autoconf

Q: Xdebug 无法连接

检查防火墙
```
sudo firewall-cmd --add-port=9003/tcp
```

检查 SELinux

sudo setsebool -P httpd_can_network_connect 1

Q: Xdebug 3.x 配置不生效

检查 PHP 版本和 Xdebug 版本兼容性：

php -v
php -m | grep xdebug

Docker 中使用 Xdebug

# Dockerfile
RUN pecl install xdebug \
 && docker-php-ext-enable xdebug

# php.ini 追加配置
RUN echo "xdebug.mode=debug" >> /usr/local/etc/php/conf.d/xdebug.ini \
 && echo "xdebug.client_host=host.docker.internal" >> /usr/local/etc/php/conf.d/xdebug.ini

macOS 特殊路径

类型	路径
Apache 配置	`/etc/apache2/httpd.conf`
Apache 根目录	`/Library/WebServer/Documents`
Hosts 文件	`/etc/hosts`
PHP 配置	`/etc/php.ini`
PHP 扩展目录	`/usr/lib/php/extensions/`

参考链接

《PHP7内核剖析》之PHP基础架构

Fri, 27 Apr 2018 00:00:00 +0000

有幸在读秦朋的《PHP 内核剖析》一书，收获良多。为了加深理解，依照书中内容整理了 PHP 的基本架构和生命周期。

PHP 的构成

PHP 的源代码主要由以下几个核心模块组成：

┌─────────────────────────────────────────────────────┐
│ PHP 架构图 │
├─────────────────────────────────────────────────────┤
│ ┌─────────┐ │
│ │ SAPI │ ← 应用接口层（Apache2Handler/FastCGI）│
│ └────┬────┘ │
│ ┌────▼────┐ │
│ │ main │ ← 输入/输出、Web通信、框架初始化 │
│ └────┬────┘ │
│ ┌────▼────┐ │
│ │ Zend │ ← PHP 解析器核心（Zend Engine） │
│ └────┬────┘ │
│ ┌────▼────┐ │
│ │ ext │ ← PHP 扩展目录 │
│ └─────────┘ │
│ ┌─────────┐ │
│ │ TSRM │ ← 线程安全资源管理 │
│ └─────────┘ │
└─────────────────────────────────────────────────────┘

核心模块说明

模块	说明
SAPI	Server Application Programming Interface，PHP 的应用接口层，负责与 Web 服务器交互
main	PHP 的核心代码，处理输入/输出、Web 通信、扩展加载、配置解析等工作
Zend	PHP 解析器的主要实现，即 Zend Engine，是 PHP 语言的核心
ext	PHP 的扩展目录，提供了各种功能的扩展（GD、MySQL、JSON 等）
TSRM	Thread Safe Resource Manager，线程安全相关的实现

各模块协作关系

Web Server (Apache/Nginx)
 │
 ▼
 SAPI Layer
 │
 ▼
 main (请求初始化、配置解析)
 │
 ▼
 Zend Engine (词法分析 → 语法分析 → 编译 → 执行)
 │
 ▼
 PHP Extensions (提供各种内置函数)

PHP 的生命周期

┌─────────────────────────────────────────────────────────────┐
│ PHP 生命周期 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────┐ │
│ │ 模块初始化阶段 │ MINIT (Module Initialization) │
│ │ (PHP-FPM 启动时) │ - 加载扩展 │
│ └─────────┬─────────┘ - 初始化扩展 │
│ │ - 注册常量/函数 │
│ ▼ │
│ ┌───────────────────┐ │
│ │ 请求初始化阶段 │ RINIT (Request Initialization) │
│ │ (每个请求开始时) │ - 重置全局变量 │
│ └─────────┬─────────┘ - 初始化静态变量 │
│ │ - 启动 session │
│ ▼ │
│ ┌───────────────────┐ │
│ │ 执行脚本阶段 │ Execute Script │
│ │ (核心执行期) │ - 编译 PHP 代码为 OpCodes │
│ └─────────┬─────────┘ - 执行 OpCodes │
│ │ - 输出响应 │
│ ▼ │
│ ┌───────────────────┐ │
│ │ 请求关闭阶段 │ RSHUTDOWN (Request Shutdown) │
│ │ (每个请求结束时) │ - 刷新输出缓冲区 │
│ └─────────┬─────────┘ - 发送 HTTP 响应 │
│ │ - 清理全局变量 │
│ ▼ │
│ ┌───────────────────┐ │
│ │ 模块关闭阶段 │ MSHUTDOWN (Module Shutdown) │
│ │ (PHP-FPM 关闭时) │ - 关闭扩展 │
│ └───────────────────┘ - 释放资源 │
│ │
└─────────────────────────────────────────────────────────────┘

1. 模块初始化阶段 (MINIT)

// PHP 扩展中的模块初始化函数
PHP_MINIT_FUNCTION(my_extension)
{
 // 注册常量
 REGISTER_STRING_CONSTANT("MY_EXT_VERSION", "1.0.0", CONST_PERSISTENT);
 
 // 注册函数
 REGISTER_FUNCTION(MyNamespace, my_function);
 
 // 初始化类
 zend_class_entry ce;
 INIT_CLASS_ENTRY(ce, "MyClass", my_class_methods);
 // ...
 
 return SUCCESS;
}

主要任务：

加载并初始化 PHP 扩展
注册常量和函数
注册类接口
初始化线程安全

2. 请求初始化阶段 (RINIT)

// 请求开始时调用
PHP_RINIT_FUNCTION(my_extension)
{
 // 重置全局变量
 MyG(enabled) = 0;
 
 // 启动 session（如果配置了 auto_start）
 php_session_start();
 
 return SUCCESS;
}

主要任务：

重置全局变量
初始化静态变量
启动 session
初始化用户级别的计数器

3. 执行脚本阶段

PHP 代码
 │
 ▼
┌─────────────────┐
│ Lexer (词法) │ 将代码转换为 Token
└────────┬────────┘
 │
 ▼
┌─────────────────┐
│ Parser (语法) │ 将 Token 转换为 AST
└────────┬────────┘
 │
 ▼
┌─────────────────┐
│ Compiler (编译) │ 将 AST 转换为 OpArray
└────────┬────────┘
 │
 ▼
┌─────────────────┐
│ Executor (执行) │ 逐条执行 OpCode
└─────────────────┘

主要任务：

词法分析 → 语法分析 → 编译
生成 OpCode（操作码）
执行 OpCode
输出响应内容

4. 请求关闭阶段 (RSHUTDOWN)

// 请求结束时调用
PHP_RSHUTDOWN_FUNCTION(my_extension)
{
 // 刷新输出
 while (OG(ob_nesting_level) > 0) {
 og_level--;
 }
 
 // 清理用户空间对象
 // ...
 
 return SUCCESS;
}

主要任务：

刷新输出缓冲区
发送 HTTP 响应
清理全局变量
关闭 session

5. 模块关闭阶段 (MSHUTDOWN)

// PHP-FPM 关闭时调用
PHP_MSHUTDOWN_FUNCTION(my_extension)
{
 // 注销常量和类
 // 释放持久化资源
 
 return SUCCESS;
}

主要任务：

关闭所有扩展
释放持久化资源
清理线程安全数据

不同的 SAPI 模式

PHP 在不同运行环境下，工作模式有所差异：

SAPI	启动次数	生命周期
CLI/CGI	每次请求	完整生命周期
PHP-FPM	一次启动	MINIT 一次，请求周期重复
mod_php (Apache)	一次启动	MINIT 一次，请求周期重复

PHP-FPM 生命周期

┌─────────────────────────────────────────────────────┐
│ PHP-FPM Master Process │
│ - 监听端口 │
│ - 管理 Worker 进程 │
│ - MINIT 只执行一次 │
└───────────────────────┬─────────────────────────────┘
 │ fork
 ▼
┌─────────────────────────────────────────────────────┐
│ PHP-FPM Worker Process │
│ - 处理请求 │
│ - 重复执行 RINIT → 执行 → RSHUTDOWN │
└─────────────────────────────────────────────────────┘

总结

PHP 架构由 SAPI、main、Zend、ext、TSRM 五大模块组成
PHP 生命周期分为 5 个阶段：模块初始化、请求初始化、脚本执行、请求关闭、模块关闭
不同 SAPI 模式下，生命周期有所差异（CLI 每次都完整执行，PHP-FPM 只在启动时执行 MINIT）
理解 PHP 生命周期对于编写高效扩展和排查问题非常重要

参考资料

《PHP 内核剖析》- 秦朋
PHP 官方文档

指尖之上 - 移动端H5开发资源汇总

Fri, 02 Feb 2018 00:00:00 +0000

移动端 H5 开发过程中收藏的优质资源链接，涵盖布局、动画、设备 API 等各个方面。

布局相关

示例	说明
滑屏页面布局	移动端常见滑屏布局实现
水平垂直居中	CSS 居中方案汇总
布局形式	常见布局形式示例
图片列表	图片列表布局
屏幕适应	多分辨率适配方案
Rem 自适应	Rem 布局详解
视频自适应	响应式视频方案

CSS3 动画

示例	说明
Transform 变形	CSS3 Transform 详解
Transition 转换	CSS3 Transition 详解
Animation 动画	CSS3 Animation 详解
简单 CSS3 动画	入门动画示例
带点击交互的动画	交互动画示例

设备 API

媒体相关

示例	说明
Audio 事件支持检测	Audio API 兼容性检测
摄像头捕捉	getUserMedia 摄像头调用
用户声音录制	麦克风录音功能
Web Speech	语音识别 API
Web Audio API	Web Audio 音频处理

传感器相关

示例	说明
地理定位	Geolocation API 使用
陀螺仪	DeviceOrientation 事件
运动传感器	DeviceMotion 事件
设备震动	Vibration API
电池状态	Battery API
环境光	Ambient Light API
网络信息	Network Information API

精品案例

示例	说明
驯龙公主	3D 交互案例
跑就有型	跑步主题互动
帧动画-互娱周末	帧动画应用
Three.js 完整实例	3D 场景示例
CreateJS 动画	Canvas 动画方案

工具与框架

常用框架

// Zepto - 轻量级 jQuery 替代品
// <script src="zepto.min.js"></script>

// Hammer.js - 手势库
// <script src="hammer.min.js"></script>

// Swiper - 轮播滑动组件
// <script src="swiper.min.js"></script>

// Animate.css - 动画库
// <link href="animate.min.css">

// Three.js - 3D 渲染
// <script src="three.min.js"></script>

移动端调试

// VConsole - 移动端调试面板
// <script src="vconsole.min.js"></script>
new VConsole();

// Eruda - 另一个移动端调试工具
// <script src="eruda.min.js"></script>
eruda.init();

移动端适配方案

1. viewport 视口设置

<meta name="viewport" 
 content="width=device-width, initial-scale=1.0, 
 maximum-scale=1.0, user-scalable=no">

2. Rem 适配方案

// 根据 dpr 和屏幕宽度动态设置 font-size
function setRem() {
 const dpr = window.devicePixelRatio || 1;
 const width = document.documentElement.clientWidth;
 const fontSize = width / 10; // 设计稿 750px 时，1rem = 75px
 document.documentElement.style.fontSize = fontSize + 'px';
}
setRem();
window.addEventListener('resize', setRem);

3. 一像素边框

/* 使用 transform 实现物理像素边框 */
.border-1px {
 position: relative;
}
.border-1px::after {
 content: '';
 position: absolute;
 bottom: 0;
 left: 0;
 right: 0;
 height: 1px;
 background: #ddd;
 transform: scaleY(0.5);
}

性能优化建议

减少重排重绘

/* 避免 */
element.style.width = '100px';
element.style.height = '100px';

/* 使用 transform */
element.style.transform = 'translate(100px, 100px)';

使用 CSS 动画

/* 开启 GPU 加速 */
.animate {
 transform: translateZ(0);
 will-change: transform;
}

图片优化
- 使用 WebP 格式
- 根据 dpr 提供 @2x @3x 图片
- 使用懒加载

参考资源

Can I Use - 特性兼容性查询
MDN Web Docs - Web API 文档
腾讯 TGideas - 移动端开发规范

这些资源帮助我更好地理解了移动端 H5 开发的各个方面，希望对您也有帮助。

《大数据时代下半场》读书笔记

Sat, 20 Jan 2018 00:00:00 +0000

今天，全世界每天产生的数据可能是过去几个世纪之和。我们在生活中都受到大数据的影响，没有人能被排除在外。每个人本身便是一个数据产品。
如同所有科技一样，数字都是死的，关键在于运用它的人。大数据在21世纪属于企业资本。大数据的商业价值持续增长，已经成为决定行业话语权与势力消长的兵家必争之地。大数据争夺战上半场主要是收集数据，下半场则转向数据治理、驱动与变现。
数据战争才刚刚开始，而我们每个人都已身在战场。

引言

大数据的三个“V”

1.容量（Volume，这里指数据容量）
2.速度（Velocity，这里指数据加工和变化动态的速度）
3.多样性（Variety，这里指数据结构和类型）

大数据的基本循环

外环：数据使用者 –(我们所有人)–> 数据生产者 —-> 企业是数据加工者 —-> 数据使用者
内环：相互作用的数据 —-> 观察数据 —-> 相互作用的数据

大数据与工业革命

五个康德拉季耶夫周期：

1.大约1780 - 1840年：早起机械化；德国工业革命的开端；蒸汽机
2.大约1840 - 1890年：第二次工业革命；贝塞麦转炉钢和蒸汽船、铁路
3.大约1890 - 1940年：电子技术和重型机器
4.大约1940 - 1990年：专用自动仪器（汽车、合成电路、核能、晶体管、计算机）
5.1990年开始：信息通信技术 —— 康德拉季耶夫周期与“全球化”紧密相连。

总结

“大数据现象”并没有一个通用的固定定义。
第一个定义尝试聚焦于大数据的技术层面，如数据量、变化动态及数据结构和数据等级的差异性。
大数据是所有生活领域大范围数字化所推动的具有高动态性的效应。
大数据出现的原因及由此导致的总体主题的多层次性，赋予了“数字革命”持续变化的潜力，并有着深远的社会文化影响。
大数据与我们每个人都相关，人人都扮演着不同的角色参与其中。
大数据在21世纪属于企业资本。
大数据是通过技术、工具和数学的结合，以及恰到好处地使用资本儿发展的，并且大数据的应用工具与其他主题是相互分离的。
大数据的发展假设了一种不能被人控制的自身动态。
大数据重要的特点之一便是进行行为分析的可能性，这能够通过新的数据等级及相互影响的数据关系来实现。

大数据时代的企业战略目标

大数据的智能循环

原始数据的加工
- 组织
- 协调
- 巩固
- 丰富
- 高级数据
知识生产
- 定义分析模式
- 阐释成果
- 建议行动
行动
- 做出决定
- 采取措施
反馈
- 成果反馈

企业变成分析型市场竞争者的过程

1.战略
2.集成
3.智能循环
4.分析型竞争者
5.信息主宰者

总结

企业利用大数据的首要目标即实现产量和销售量的增长，特别是通过大数据分析带来的知识增长来完成这一目标。
大数据也能显示新的价值创造和新的商业模式的潜力。
通过注重数据分析产生知识的能力，企业发展成具有分析能力的市场竞争者。
一个企业作为具有分析能力的市场竞争者，可以通过掌握一个具体领域的信息主宰权和解释权，而使公众接受其商业模式，并且保障一个企业永久占据客观的市场份额。
在企业内部，各个部门也都在竞争信息主宰权和解释权。

社会生活中的大数据

大数据和“开放运动”

开放数据
开放教育
开放内容
开放政府

德国联邦议会“互联网和数字社会”研究委员会

该委员会的12个工作群体显示了该主题的多层次性

1.教育和研究
2.数据保护和个人权益
3.民主和国家
4.国际和互联网管理
5.协同工作、免费软件
6.文化、媒体和公众
7.媒体能力
8.网络中立性
9.著作权
10.消费者保护
11.经济、工作、绿色信息技术
12.网络入口，结构和安全性

总结

大数据是自下而上的推动。
从“自下而上”这个角度看，大数据包含了另一种含义，即技术发展赋予了大数据集中型的结构，与大数据紧密相关的科技在此提供了许多深远的技术可能性。
从整体上看，大数据是变幻莫测的社会变化产生的一个效应。这种变化是由各个生活领域大规模的数字化推动的，没有人能够全身而退。
当前关于大数据和世界数字化的公开讨论改变了公众关于互联网使用和隐私保护的意识。
这种已然改变的意识导致了产生的行为规则和期待也发生了变化，人们扮演着不同的角色，如客户、消费者、员工和公民，如今也向企业和国家机构提出了新的挑战。
在这个过程中，经济层面上的道德问题也日益获得关注。
这一系列的主题由于其广泛的社会意义，在更高的政治层面上也日益获得关注。
该整体状况对于企业内外关系中的相关主题有着直接的影响。

企业中的数据治理

大数据和企业文化

组织文化指的是组织内在的文化价值模式的形成和发展。在企业中这种现象也被称为企业文化

1.领导方式
2.员工之间的关系
3.内部合作的方式（合作模式）
4.内部沟通（沟通方式）
5.决策方式
6.支持合作、沟通和决策的技术基础设施的价值
7.对于内部矛盾及政治矛盾的处理（争论文化）
8.与客户、供应方和其他外部合作者的关系

社交软件与企业2.0

“社交软件”所指的是软件工具，它通过一个主题将所有的员工进行联合，为企业的某些大事件起到推动和支持作用。
社交软件的投入使用是体现企业2.0的基本之一，它的目的就在于优化企业内部的团结合作。

社交与商业一体化
智能合作

大数据时代下客户关系的封闭循环

以客户为中心	➡️	数据保护
⬆️		⬇️
客户关系	⬅️	信任

1.88%的互联网用户不愿意自己的网上行为被追踪。
2.75%的用户希望企业不要备份用户的任何个人数据。

目标冲突和内部阻力

透明化 VS 不透明化
结构化 VS 自由度

总结

企业处于全社会性质变革的中心，这种变革通过生活全方面数字化驱动带来广泛的社会性循环。
大数据是数字化和这种社会文化变革的技术表现形式，另外由于他们的交互依赖性以及相互的作用共同铸就变革。
发展固有的文化对企业有直接的影响，它要求企业通过利用现代技术的潜力找到让企业文化适应21世纪商业世界新要求的方法，其关键词就是企业2.0。
面对由像棱镜门等事件引起的广泛讨论，人们必须站在企业的角度思考是否有必要对这种潜在威胁采取行动。
像数据保护、个人隐私保护，以及像信任这样的传统价值等方面变得意义重大，同时成为有决定性作用的市场竞争因素。

大数据不仅仅是商业智能2.0

商业智能的复杂性提高

1.新的数据结构
- 并不存在“非结构化数据”，数据永远都是结构化的。
- 大数据要求不同数据结构的整合，这个过程要求人们对不同层面的数据进行思考。
2.类型化的关键字
3.新数据等级和存储技术

数据质量

低数据质量如何产生
人们应该如何持续得到高质量的数据
维持高水准的数据质量需要花费多少

数据分析

描述性分析
- 现有的财政数据基础上的月度结算
预测性分析
- 现有的措施基础上的销售预测
处方性分析
- 描述中长期的未来

大数据分析法的四个条件因素

大数据 —— 大量数据将被分析
数据挖掘 —— 数学统计学工具将被使用，用以认知大量数据的模式。
诊断式分析 —— 分析针对于未来不同的时间
内存 —— 并不一定与大数据分析法有着直接联系

总结

大数据时代，商业智能的复杂性增加表面上是由技术层面上的数据容量、不同性质的数据结构和数据等级导致的。
复杂性增加更大程度上是因为专业部门和信息技术需要大幅度协调。在整体战略和具体行为计划的框架下，这是非常必要的，这样数据的多层次性才能得到整体理解。
战略性基本方针的缺失或者并不独立可能会导致摩擦损失，企业通过忍受高额成本和信息的不透明，投入资源并且建设“阴影信息技术”及“阴影化过程”，以此来弥补可能存在的摩擦损失。
这种认知必然会导致意义斐然的合作模式的建立，能够连接所有的能力，将现有的资源引向目的。
这个过程中要注意的是，提高大数据的潜力会导致人们对可测量的企业增值日益期待。这也要求有着不同专业知识背景的所有层次的参与者进行永恒且广泛的相互协调。
与商业智能相比较，大数据分析法提出了一个新的要求，尤其是所形成的时间维度。
传统方法的组合，比如数据挖掘，在商业智能中已经广为人知，比如诊断式数据分析，提升了大数据分析法的整体潜力。

内存

大数据和内存技术并不一定是紧密相关的，然而在涉及大数据潜力时，者两者常常会被同事列举出来。
事实上，通过大量数据的实时分析，全新的应用可能诞生于世，这在没有大数据和内存技术时是不可想象的。
这些可能性位人类的进步提供了巨大的潜力，然而同时也蕴藏着风险。

大数据对企业的意义

1.大数据为企业的应变能力提供支持
2.大数据可以提高企业与客户沟通的效率
3.大数据会对企业的管理模式产生一定影响
4.大数据会对企业的战略产生一定影响

为了描述企业中有关于大数据的话题，有目的地采取适当措施，需要企业在总体战略中确定不同主题。
所有大数据活动应当给予主题相进性与商业智能能力中心（BICC）联系在一起，在大数据背景下，商业智能能力中心（BICC）需要继续发展成为数据分析能力中心（DACC）。这并不意味着大数据只是商业智能的拓展，而是尽可能地利用现有的结构。
目前企业中还没有类似于BICC这样广泛意义上的组织单元，企业应当在大数据多样主题的压力下建立一个数据分析能力中心（DACC），为企业成为分析型市场竞争者提供支持。
数据分析能力中心（DACC）的一个重要任务就是变革管理和通信管理，在数据分析能力的帮助下研究特定的培训内容。一方面，在整个企业范围内建立对大数据的普遍理解；另一方面，可以在具体的主题例如技术层面或者个人客户数据方面进行相关培训。
大数据项目管理必须始终坚持使用商业智能的经验，在执行层面建立灵活性。
实用主义和执行层面的灵活性并不违背战略一致性的要求；相反，这个战略为特定项目实现高自由度创造了前提，从而释放必要的创造力和生产力。

福兮祸兮

对于一个真正存在的问题，其分析结果会因为增长的数据量、提高的结构复杂性、技术和逻辑上的清晰性儿变得愈加具有解释性。
大数据需要一次全面的思想转换，因为这些多重结构并且内容复杂的大量数据在很大程度上时缺乏解释的，而涉及企业和社会决策的数据分析应该切合实际。
这个世界时不可预测的，速度更快、连接更顺畅的IT系统当然能够使得愈加复杂的算法在越来越大的数据库中得以运用，并且也能够对具体问题的解决方面有所帮助。
在大数据复杂的框架条件下，想要利用一个通过技术推动的、自动化的并且有算法控制的决策来解决现实问题，是不切实际的。
在全球数字化的趋势下，越来越多方面的复杂性刚刚被人了解并且以数据的方式被存储起来，所以才产生了大数据。或者用另外一种表达方式来说，就是全球数字化正在高速运转并且在不久的将来会更加深入地渗透到人们生活的所有领域。

《从零开始学微信运营》读书笔记

Mon, 18 Dec 2017 00:00:00 +0000

这是最好的时代，这是最坏的时代；这是明智的时代，这是愚昧的时代；这是信仰的时期，这是怀疑的时期；这是光明的季节，这是黑暗的季节；这是希望之春，这是失望之冬；人们面前应有尽有，人们面前一无所有。

如果一款应用不能在5到10秒内吸引住用户，用户就很可能抛弃这个应用。
因此，一款产品的决胜期可能在一个月之内，如果一个月内不行，后面可能是死路一条。
提供价值，而非吸引眼球，这是微信的态度，也是它能否成功的关键。

微信能做什么

微信中蕴藏的商业价值

微信ID：网络上的另类“身份证”

类APP Store：微型应用商店

适合微信的应用类型
- 低频次强需求的App
- 高频次低需求的App
微信应用商店的优势
- 技术门槛低，开发成本低
- 能够更迅速的进行更新换代
- 操作简单，更容易聚集用户

公众号：全新的营销渠道

拥有庞大的潜在客户
降低了营销成本
营销定位更加精准
营销方式更加多元化、更有趣
营销方式以人为本

朋友圈：亟待挖掘的SNS营销“金矿”

沟通体系是单向的
交流更加方便，可以无缝切换到私聊模式
人店合一，有利于客户的积累
基于情感的营销，更容易成功

闭环O2O：从线上到线下

为什么应该重视微信营销

用户的习惯
用户的传播
信息的载体

微信营销的优势在哪里

内容至上
成本低廉
沟通无极限
受众定位准
主动推送

微信公众号的设计之道

定位：告诉受众你是谁

用户的心智运行模式决定着定位的重要性
- 心智的容量是有限的
- 心智喜欢简单，排斥混乱
- 心智不会轻易改变

微信公众账号的定位方向

量体裁衣，以产品特点为基础
充分聚焦，针对目标市场
一切以用户为中心，提供“服务”而非“骚扰”
充分关注竞争者

取名：什么样的名字更亮眼

原则：

好记，能迅速传播
包含目标关键词
加上区域名称

忌讳：

名字不应太短或太长
尽量避免使用生疏、冷僻的词汇
不要使用宽泛的词汇，越精准越好

ID：越简短，越有效

与企业的品牌、公众账号的名字要有高度相关性
好记并适合搜索

自我介绍：让受众第一时间记住你

欢迎语：给用户一个导航图

态度热情真诚，语言诙谐风趣
告诉用户下一步应该怎么做、能做什么
为用户提供帮助，为他们解决问题

自定义回复：从用户的角度出发

内容价值是核心

什么内容才是用户关注的

什么样的内容分享率高

有价值，能为用户带来一定的帮助
专业性强，具有较强的权威性
时效性强，要善于把我社会热点话题
具有吸引力的成功案例，能诱发人们的关注
与众不同的观点

内容建设的三个步骤

定位
提炼
管理

微信内容的六种类型

倾听型
好消息型
故事型
自爆隐私型
互动型
炒冷饭型

什么时间推送最有效

早上：8点 ~ 9点
中午：12点 ~ 13点
晚上：21点 ~ 22点

如何让内容更有吸引力

标题的醒目技巧

标题包含的要素
- 热门词汇
- 权威人物
- 体验式感受
标题字数
拟定标题的具体方式
- 提问式
- 借力式
- 情感诱发式
- 悬念式
- 八卦式
内容写作的方法
- 情感真挚，方能动人
- 体现创意，莫要千篇一律
- 把故事讲好，也是一种技巧
- 内容娱乐化，展现娱乐精神
- 图文并茂，增加可读性
- 让用户参与到内容创作的过程中

信息内容的四种优化形式

文字优化

文字信息应该是真实可信的
巧妙使用问号、感叹号等标点符号
条理清晰
多使用短句子

图片优化

配以适当的文字说明
大小要进行控制

语音优化

确保语音清晰度
配以适当的语气

视频优化

视频标题要吸引观众
视频说明要留下想象空间

微信公众号的推广与运营

微信公众号四大运营法则
- 挖掘精准用户
- 增加用户信任度
- 保证功能完善性
- 运营要有计划
订阅号运营
- Exact-信息量要精准，少即是多
- Echo-重视时效性，越快越好
- Easy-栏目不必过多，版式要简单明了
- Enjoyment-内容要有可读性，能引发阅读兴趣
服务号运营策略
- 促销策略
- 品牌策略
- 发掘需求策略
- 沟通策略

微信粉丝从何而来

QQ

QQ群
- 找到目标QQ群
- 申请入群
- 在QQ群中深耕细作
- 制定具体的推广策略
QQ空间
- QQ空间认证
- 多发表一些有价值的精品文章
- 善用朋友分享

微博

“按图索骥”,通过标签找粉丝
主动对用户的微博进行转发与评论
利用微博群来寻找目标用户
努力使自己成为微博群里的“舆论领袖”

百度

百度文库
- 标题越实用越好
- 图文并茂
- 有效分类
百度经验
- 以微信二维码作为头像
- 在参考资料中留下你的联系方式
- 在标题中添加更多的关键词
- 在图片中添加你的微信二维码
- 多提交

软文

极具吸引力的标题
言之有物的内容
定位于精准的目标群体
精心选择发布渠道
添加微信二维码

视频推广

线下活动

如何吧潜在用户转变为现实用户

潜在用户：

影响性
相对性
转化性

已用户为导向

提高服务质量
赠送令用户满意的小礼物
不定时举办一些感恩活动
给每一个用户VIP的感觉
为用户提供专业性的产品指南
关于用户的想法和意见
投其所好

激活粉丝的主动传播

知己知彼，了解粉丝的“口味”
折扣与优惠是最好的营销工具
根据粉丝的属性来分组推送信息

如何留住老用户

建立用户档案，提供针对性服务

用户基本信息
用户偏好信息
用户行为信息
用户服务信息
其他相关信息

以情动人，对用户进行情感投资

给予老用户更多的优惠政策
多与老用户进行沟通
尊重老用户的意见
多向老用户表达你的感谢
重视20%的老用户
多传播正面信息

促销时时有，给用户多一些甜头

策略篇 —— 如何做好微信营销

微信营销的目标不能一味只关注利润，还要充分考虑消费者的利益、对社会的责任，并妥善处理企业与消费者、与社会的利益关系。

设立微信营销目标

目标设立的原则

S（Specific）：明确性
M（Measurable）：可衡量性
A（Achievable）：可实现性
R（Relevant）：现实性
T（Time-based）：时限性

目标设立的环节

正确理解企业的总体目标
根据SMART原则，制定出目标
列出可能遇到的问题和阻碍
列出实现目标所需要的资源
确定目标完成的日期

五步制定营销策略

定位微信公众账号
定位目标用户群
调研目标用户群
- 更愿意接收哪种类型的内容
- 更愿意在什么时候接收消息
- 更愿意参加什么样的活动
- 更愿意如何参加活动
- 不喜欢什么内容、活动
制定具体营销计划
- 步骤
  - 做什么
  - 怎么做
  - 谁来做
  - 什么时间做
- 注意事项
  - 正确的营销目标是营销计划得以顺利实施的前提条件
  - 企业中有效的运行系统是微信营销计划得以实施的重要保证因素
  - 企业文化、价值观也是影响计划实施的重要因素
执行与跟踪
- 四项原则
  - 适时发现问题
  - 跟踪重要目标
  - 明确你的跟踪目标
  - 实际主义，避免得不偿失
- 跟踪步骤
  - 收集信息
  - 评估
  - 反馈

微信营销的原则、方法、技巧与误区

微信营销的四大原则

多号并行，合理布局

双号策略
- 服务号 + 订阅号
多号策略

构建微信矩阵，协同作战

微信矩阵的特点
- 多个微信公众账号协作
- 统一化管理
微信公众账号的划分
- 品牌层级
- 地域性
- 功能定位
- 业务需求
微信矩阵的常见模式
- 1+N 式微信矩阵
  - 以主品牌、主业务的微信公众账号为主导，在其基础之上，再开设N个子品牌、子业务、子部门或下属地域的微信公众账号，形成一个完整的微信推广体系。
- AB 式微信矩阵
  - 指的是以一个形象微信公众账号（Action）和一个品牌微信公众账号（Brand）的形式组成矩阵组合，从而达到塑造、维护企业的品牌形象的主要目的。
- 三维式微信矩阵
  - 从企业、产品及生活方式的培养这三个维度来进行微信公众账号的布局。

关注竞争对手，善用“他山之石”

关注竞争对手的微信公众账号和个人微信号。
扮演用户的角色，通过微信公众账号向竞争对手进行产品咨询、要求售后服务、订购产品等。

免费为诱饵，赢利为目的

“免费午餐法则”的心理定律。

让客户吃到“免费的午餐”，让他因此在心中对你怀有一种潜在的愧疚感，他购买你的产品的可能性就越大。

微信营销的实用方法

如何提高关注度

重视产品与服务的同时，增强信息资产的积累
- 品牌、心智占有率等无形资产。
针对目标用户建立“信息银行”，开展个性化的数据库营销
- 更贴心的交流、更人性化的互动
注重与用户的双向沟通
- 获得认同与注意
多为用户提供一些增值服务
- 提高参与意识与合作兴趣
别做“垃圾制造者”
珍惜用户的“碎片化时间”
- 碎片化阅读
- 焦点
- 记忆点
- 卖点

如何提高浏览量

解答使用问题
采取一定的激励手段
成为用户的朋友
自动回复
重要的文章要重点展示
策划专题
在文章中加入“微链接”
- 其他文章的链接，感兴趣者可以点击阅读
栏目安排要清晰、合理
不断更新

如何提高互动率

趣味小测试
小游戏
有奖问答
发放刮刮卡
鼓励用户反馈意见
二维码

如何提高曝光率

利用搜索引擎进行推广
- 付费搜索引擎广告策略
  - 百度
  - 谷歌
- 免费搜索引擎推广策略
  - 设计恰当的关键词组合
  - 对搜索引擎的关键词进行优化
  - 增加关键词密度
  - 注册免费会员
利用博客进行推广
利用论坛进行手工推广
利用“病毒”进行推广
- 发布一些有意思的、新奇的、有趣的，并与微信公众账号有关的信息。
利用网络广告进行推广
利用软件进行推广

如何提高活跃度

利用用户的社交关系
线上、线下活动相结合
提高沟通频率
给用户一些温馨提示
及时回复

如何在营销红海中游刃有余

善用事件营销，借事发力

公益
聚焦
危机

事件营销的策略运用

造势策略
借势策略
概念炒作策略
- 把握分寸、以吸引用户注意力为目的的良性炒作
- 取其利，避其害

用“圈子”圈住核心用户

自己打造圈子，组织各类线上、线下活动
支持或赞助目标圈子，与他们进行密切合作
建立目标圈子数据库，挖掘用户数据价值
善于利用圈子里的意见领袖，通过他们来辐射其他人

差异化策略，与众不同才是卖点

制定的途径
- 产品差异化
- 细分市场差异化
- 渠道差异化
实施注意问题
- 差异化要被用户认同并接受
- 适时进行创新

微信营销效果的考核与评估

微信营销的考核标准

内容价值性

标题
导读
正文
栏目设计
二维码

互动率

浏览量
评论量
分享率

关注者数量 功能受欢迎度 转化率

如何进行微信营销的KPI考核

关注者数量
- 原有关注者数量 + 新增关注者数量
互动率
- 关注者数量 × 功能欢迎度
用户忠诚度
- 内容价值性 × 互动率 × 功能受欢迎度
转化率
- 用户忠诚度 × 关注者数量

使用Composer安装Laravel/Lumen

Fri, 08 Dec 2017 00:00:00 +0000

本文介绍如何搭建 PHP 的 Laravel 和 Lumen 环境

安装 Composer

方法一：官方安装脚本

php -r "copy('https://install.phpcomposer.com/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"

# 移动到系统 PATH
sudo mv composer.phar /usr/local/bin/composer

方法二：直接下载（推荐）

# Linux/macOS
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

# Windows
# 下载 https://getcomposer.org/Composer-Setup.exe

设置权限

# 添加执行权限
sudo chmod +x /usr/local/bin/composer

修改 Composer 镜像

由于国内网络原因，建议使用国内镜像加速：

# 阿里云镜像（推荐）
composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/

# Laravel China 镜像
composer config -g repo.packagist composer https://packagist.laravel-china.org

# 恢复官方源
composer config -g --unset repos.packagist

安装 Laravel/Lumen

全局安装 Laravel

composer global require "laravel/installer"

全局安装 Lumen

composer global require "laravel/lumen-installer"

添加到系统 PATH

# 编辑 ~/.bashrc 或 ~/.zshrc
echo 'export PATH="$PATH:$HOME/.composer/vendor/bin"' >> ~/.bashrc
source ~/.bashrc

# 确认目录（可能因 Composer 版本而异）
echo 'export PATH="$PATH:/home/yison/.config/composer/vendor/bin"' >> ~/.bashrc
source ~/.bashrc

验证安装：

composer --version
laravel --version
lumen --version

创建项目

使用 Laravel 创建项目

# 方式一：使用 laravel 命令
laravel new blog

# 方式二：使用 Composer
composer create-project --prefer-dist laravel/laravel blog

# 指定版本
composer create-project --prefer-dist laravel/laravel blog "10.*"

使用 Lumen 创建项目

# 方式一：使用 lumen 命令
lumen new lumen

# 方式二：使用 Composer（推荐）
composer create-project --prefer-dist laravel/lumen lumen

# 指定版本
composer create-project --prefer-dist laravel/lumen lumen "10.*"

启动 Laravel 项目

cd blog

# 安装依赖
composer install

# 复制环境配置
cp .env.example .env

# 生成应用密钥
php artisan key:generate

# 启动开发服务器
php artisan serve
# 访问 http://localhost:8000

启动 Lumen 项目

cd lumen

# 安装依赖
composer install

# 复制环境配置
cp .env.example .env

# 生成应用密钥
php artisan key:generate

# 启动开发服务器
php -S localhost:8000 -t public
# 访问 http://localhost:8000

Laravel/Lumen 常用命令

Artisan 命令

# 查看所有命令
php artisan list

# 创建控制器
php artisan make:controller UserController

# 创建模型
php artisan make:model User

# 创建中间件
php artisan make:middleware AuthMiddleware

# 创建数据库迁移
php artisan make:migration create_users_table

# 执行数据库迁移
php artisan migrate

# 路由列表
php artisan route:list

# 清除缓存
php artisan config:clear
php artisan cache:clear
php artisan view:clear

Composer 常用命令

# 更新依赖
composer update

# 添加依赖
composer require package/name

# 添加开发依赖
composer require --dev phpunit/phpunit

# 移除依赖
composer remove package/name

# 优化自动加载
composer dump-autoload -o

# 查看可用更新
composer outdated

Lumen vs Laravel

特性	Lumen	Laravel
定位	微服务/API	全栈应用
体积	~1MB	~10MB
视图	❌ 不支持	✅ 支持
Session	❌	✅
路由	FastRoute	Symfony Router
开箱即用	较少	丰富
性能	更快	较慢

Docker 部署 Laravel

# 使用 Laravel Sail 快速搭建开发环境
composer require laravel/sail --dev
php artisan sail:install
php artisan db:seed
docker-compose up -d

常见问题

Q: composer 命令找不到

A: 确保 Composer 在 PATH 中：

export PATH="$PATH:$HOME/.composer/vendor/bin"
source ~/.bashrc

Q: 依赖安装失败

A: 尝试清除缓存或更换镜像：

composer clear-cache
composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/
composer install

Q: 权限不足

A: Linux 系统设置目录权限：

sudo chown -R $USER:$USER /path/to/project
chmod -R 755 /path/to/project
chmod -R 775 /path/to/project/storage

参考链接

使用GD库给图片铺满水印

Fri, 08 Dec 2017 00:00:00 +0000

PHP 使用 GD 库生成平铺水印的方法，可以将水印图片铺满整个图片。

原理说明

平铺水印的核心思想是：

读取原图和水印图片
循环遍历原图的每一个区域
将水印图片复制到每个区域
处理边界情况（水印超出原图边界）

完整代码实现

<?php

/**
 * 图片平铺水印
 * 
 * @param string $dst_file 处理完成后保存的文件路径
 * @param string $src_file 待处理的图片文件路径
 * @param string $logo_file 水印图片文件路径
 * @param int $top 上间距（水印之间的垂直间距）
 * @param int $left 左间距（水印之间的水平间距）
 * @param int|false $alpha 透明度 0-100，false 表示不透明
 * @return bool
 */
function fullFillLogos($dst_file, $src_file, $logo_file, $top = 0, $left = 0, $alpha = false) {
 try {
 // 检查文件是否存在
 if (!file_exists($src_file)) {
 throw new Exception("源图片不存在: $src_file");
 }
 if (!file_exists($logo_file)) {
 throw new Exception("水印图片不存在: $logo_file");
 }
 
 // 检查 GD 库是否支持
 if (!extension_loaded('gd')) {
 throw new Exception("GD 库未安装");
 }
 
 // 创建图片资源
 $dst = imagecreatefromstring(file_get_contents($src_file));
 $logo = imagecreatefrompng($logo_file); // PNG 保留透明度
 
 if (!$dst || !$logo) {
 throw new Exception("图片创建失败");
 }
 
 // 获取尺寸
 $logo_w = imagesx($logo);
 $logo_h = imagesy($logo);
 $dst_w = imagesx($dst);
 $dst_h = imagesy($dst);
 
 // 循环铺上水印
 for ($off_y = $top; $off_y < $dst_h; $off_y += $logo_h + $top) {
 for ($off_x = $left; $off_x < $dst_w; $off_x += $logo_w + $left) {
 // 计算边界：如果水印超出原图边界，需要裁剪
 $width = ($off_x + $logo_w > $dst_w) ? ($dst_w - $off_x) : $logo_w;
 $height = ($off_y + $logo_h > $dst_h) ? ($dst_h - $off_y) : $logo_h;
 
 // 如果超出边界，从水印图片的 (0,0) 开始裁剪
 $src_x = 0;
 $src_y = 0;
 if ($off_x + $logo_w > $dst_w) {
 $src_x = $logo_w - $width;
 }
 if ($off_y + $logo_h > $dst_h) {
 $src_y = $logo_h - $height;
 }
 
 // 根据透明度选择复制方式
 if ($alpha === false) {
 // 不透明复制（忽略 PNG 原有透明度）
 imagecopy($dst, $logo, $off_x, $off_y, $src_x, $src_y, $width, $height);
 } else {
 // 带透明度复制（PNG 透明度会被忽略）
 imagecopymerge($dst, $logo, $off_x, $off_y, $src_x, $src_y, $width, $height, $alpha);
 }
 }
 }
 
 // 获取原图格式
 $mime = mime_content_type($src_file);
 $ext = strtolower(pathinfo($src_file, PATHINFO_EXTENSION));
 
 // 保存图片
 switch ($ext) {
 case 'jpg':
 case 'jpeg':
 imagejpeg($dst, $dst_file, 90);
 break;
 case 'png':
 imagepng($dst, $dst_file, 9);
 break;
 case 'gif':
 imagegif($dst, $dst_file);
 break;
 default:
 imagejpeg($dst, $dst_file, 90);
 }
 
 // 释放内存
 imagedestroy($dst);
 imagedestroy($logo);
 
 return true;
 } catch (Exception $e) {
 error_log($e->getMessage());
 return false;
 }
}

使用示例

<?php

// 示例1：最基本的用法
$result = fullFillLogos(
 '/path/to/output.jpg', // 输出文件
 '/path/to/source.jpg', // 源图片
 '/path/to/watermark.png', // 水印图片
 10, // 垂直间距
 10, // 水平间距
 50 // 50% 透明度
);

// 示例2：不透明水印
$result = fullFillLogos(
 '/path/to/output.jpg',
 '/path/to/source.jpg',
 '/path/to/logo.png',
 20, // 更大的间距
 20,
 false // 不透明
);

// 示例3：API 形式调用
if (fullFillLogos($dst, $src, $logo, 0, 0, 30)) {
 echo "水印添加成功";
} else {
 echo "水印添加失败";
}

进阶版本：支持水印位置

/**
 * 带位置参数的水印函数
 * 
 * @param string $dst_file 输出文件
 * @param string $src_file 源文件
 * @param string $logo_file 水印文件
 * @param string $position 水印位置：center/tiled/single
 * @param int $margin 边距（single 模式下有效）
 * @param int|false $alpha 透明度
 */
function watermark($dst_file, $src_file, $logo_file, $position = 'tiled', $margin = 10, $alpha = false) {
 $dst = imagecreatefromstring(file_get_contents($src_file));
 $logo = imagecreatefrompng($logo_file);
 
 $logo_w = imagesx($logo);
 $logo_h = imagesy($logo);
 $dst_w = imagesx($dst);
 $dst_h = imagesy($dst);
 
 if ($position === 'tiled') {
 // 平铺模式
 for ($off_y = 0; $off_y < $dst_h; $off_y += $logo_h) {
 for ($off_x = 0; $off_x < $dst_w; $off_x += $logo_w) {
 imagecopy($dst, $logo, $off_x, $off_y, 0, 0, $logo_w, $logo_h);
 }
 }
 } elseif ($position === 'center') {
 // 居中模式
 $x = ($dst_w - $logo_w) / 2;
 $y = ($dst_h - $logo_h) / 2;
 imagecopy($dst, $logo, $x, $y, 0, 0, $logo_w, $logo_h);
 } elseif ($position === 'bottom-right') {
 // 右下角
 $x = $dst_w - $logo_w - $margin;
 $y = $dst_h - $logo_h - $margin;
 imagecopy($dst, $logo, $x, $y, 0, 0, $logo_w, $logo_h);
 }
 
 imagepng($dst, $dst_file);
 imagedestroy($dst);
 imagedestroy($logo);
}

水印图片制作建议

1. 使用 PNG 格式

PNG 格式支持透明背景，适合做水印：

# 使用 ImageMagick 创建水印图片
convert -size 100x50 xc:none -fill black \n -pointsize 20 -gravity center \n -annotate +0+0 "© YISON" logo.png

2. 保持水印图片尺寸适中

水印太小：看不清
水印太大：影响原图观赏

建议水印尺寸为原图的 5%-15%

3. 半透明效果

使用 PNG-24 格式并设置透明度：

// 使用 imagecopymerge 可以保留 PNG 的透明通道
imagecopymerge($dst, $logo, $x, $y, 0, 0, $logo_w, $logo_h, 50);

注意事项

内存消耗：处理大图片时注意 PHP 内存限制

ini_set('memory_limit', '256M'); // 根据需要调整

GD 库与格式：确认 PHP 已启用 GD（php -m | grep -i gd）。JPEG、PNG、GIF、WebP 需分别使用 imagecreatefromjpeg / imagecreatefrompng / imagecreatefromgif / imagecreatefromwebp 创建画布；保存时对应使用 imagejpeg、imagepng 等，并对透明 PNG 选用 imagesavealpha($im, true)，避免透明通道丢失。
压缩与画质：对大图先做适当缩放再叠水印以节省内存。JPEG 保存时可指定质量参数，例如 imagejpeg($dst, $path, 90);，在体积与观感之间折中；尽量避免对同一文件反复解码—编码多次，以免画质明显下降。

小结

铺满水印本质是「遍历网格 + imagecopy/imagecopymerge」。实现时注意内存、格式与透明度处理，并在批量任务里做好异常与日志，便于线上排查。

《集创思维设计矩阵》读书笔记

Sat, 18 Nov 2017 00:00:00 +0000

人的才识是装在瓶子里的，你的瓶子满了，就再也装不下新东西了。要想装下更多，你不能固守这个瓶子，你要打破它，换个更大的瓶子。如此反复，你才不是现在的你。

序

做产品的不去了解商业，做交互的不去了解产品，做视觉的不去了解交互，这在未来的工作中是非常可怕的，单一的设计思维会为企业带来大量的消耗，增加不必要的沟通成本。
了解，信任，价值，转化
感性驱动，结果驱动，理性驱动

高维融合低维

品牌
- 集创思维
定位
- 互联网+时代
- 高级思维
沟通主张
- 结合商业逻辑、产品形态、外部环境、自身能力、集合设计来提升产品的体验
支撑要点
- 枪型-逻辑定位（要点）
- 高维融合低维（格局）
- 设计VS计算（平衡杠杆）
表现 {场景，内容}
- 针对不同市场、不同的产品形态、不同产品阶段，做出对等的设计判断
- 商业思维包含产品思维，产品思维包容设计思维：他们可以互相集合
- 设计很美，但考虑商业消费
- 产品很美，但考虑阶段完成

具有向心力产品具备的三点特征

强技术，代表产品iPhone
强用户粘性，代表产品微信&QQ
强需求，代表产品12306

总结几点

用户体验实在为企业竞争力服务的。
- 必须承认有些产品即使用户体验出色后也逃不掉失败的命运，商业逻辑决定着产品逻辑，产品逻辑又决定着体验逻辑。
- 如果高处的商业逻辑错误了，后面的发力其实意义不大。
只有向心力产品才能改变人的习惯，差别化产品要迎合用户。
- 苹果、腾讯、12306这些产品失去一个，我们的生活都可能发生巨大变化，这就是向心力产品文化认知的威力。
- 初创产品只有经历四个阶段才能形成向心力
  - 核心功能
  - 用户基数
  - 商业链接
  - 功能链生
  - 文化认同
绝大多数产品必须走差别化战略，和向心力产品存在差异才有可能成功。
- 差别化才是设计师发挥能力的关键所在。
创新是一件很冒险的事。
- “十个创新九个坑，还有一个全靠蒙”，处于中心地带的产品不会尝试冒险的创新，只有边缘市场的产品才会为了生存不得不创新，而中心地带的向心力产品只要抄袭就可以轻松干掉他们。
创新能否成功也要看企业的DNA结构。
- 很多设计师和产品经理相互之间的能力可能差不多，但是在不同公司的结构下有些人的产品会出现妥协，这是很多国内一线企业难出精品的原因。

枪型思维

在这个“快”时代里
- 人们失去耐心
- 目光被无数白元素吸引
- 人们喜欢“快餐”
- 人们不喜欢停留

虫洞商机

现在这个时段，优秀的服务就像客户口渴时服务员立刻递上一杯水。
但是更优秀的服务是服务员预判到客户口渴了，事先准备好合适的水，并且知道是温水、矿泉水、柠檬水还是糖水，这就是大数据的威力。
大数据的推送
- 掩埋型信息推荐
  - 50%的可能性
  - 选择权交给用户
  - 数据不够精确
  - 信息可靠度不高
- 打断型信息推荐
  - 100%的可能性
  - 承担全部责任
  - 数据绝对精确
  - 信息可靠度很高

枪型思维图（5个指针）

指向市场
- 现有市场
  - 高性能、低价位
  - 拼体验、拼服务
- 垂直市场
  - 针对专门的使用群体
  - 研究这个群体的需求
  - 把握这个群体的特点
  - 推出产品的设计特点
- 全新市场
  - 这个产品是否能被接受
  - 如何设定用户的使用习惯
  - 如何让用户接受核心功能
指向用户
- 用户模型
  - 1.来自数据
  - 2.来自产品定位：产品针对人群
  - 3.来自产品特征的提取
    - 数据收集
    - 提取用户行为
    - 构建用户模型
- 场景建模
指向产品形态
- 技术驱动
- 运营主导
- 用户体验优先
- 独特资源驱动
指向产品阶段
- 初级核心功能
- 中级活跃压力
- 高级商业认知
指向生态形式
- 主载体
- 工具
- 设备

创新三要素

A是否提升了人们的使用效率
B是否让人们获取更多、更准确的信息
C是否满足人群在特殊情况下的需求

创新三雷区

X产品是否有可替代性
Y是否干扰其他功能的使用
Z落地环境是否理想

马洛斯心理

生理
- 呼吸、食物、水、性、睡觉、机体平衡、排泄
安全
- 人身、财产、职业、家庭、健康、道德的保障
爱/归属
- 友情、亲情、爱情
尊重
- 自尊、信任、成就、尊重
自我实现
- 道德观、创造性、自觉性、解决问题、没有偏见、接受现实

人性的七宗罪

暴食
懒惰
贪婪
淫欲
愤怒
嫉妒
骄傲

产品的驱动力

技术驱动力的产品
运营驱动力的产品
特殊资源驱动力的产品
模式驱动力的产品（垂直针对、平台包容）

慈思远2015年百度的演讲分享

在当前的社会节奏下，产品设计不再追求对于功能的满足，而且更清晰地对准市场、对准用户、对准形势。这个时候我们将更清晰地使用枪型思维来看待问题。

每个产品的特点不同、处于市场的环境和竞争力不同、产品阶段不同、属性不同，带来机会点的作用力也会不同。所以我们应当在发掘这个产品特点的基础上，有针对性、动态地解决问题。而不是死套模板，孤立静态地解决问题。

媒介的特点-三大平台的属性

Web平台

特点
- 良好的操作环境
- 输入方式强大、屏幕大
- 无能耗烦恼
- 视觉的盲区
- 惯常的操作行为
- 时空限制
结构
- 个人展示类网站
- 垂直电商类网站
- 平台类电商网站
- 门户类网站
- Blog类网站
- 工具类网站
- 瀑布流结构网站
- 响应式网站
- 分面导航与面包屑结构的过渡

客户端-手机平台

特点
- 使用环境复杂
- 输入方式单一
- 行为受到环境、输入方式和界面的限制
- 流量和电池的烦恼很严重
结构
- 导航的呈现方式
  - TAB式
  - 舵式
  - 上下双层标签
  - 抽屉式
- 内容界面的呈现方式
  - 宫格式
  - 列表式
  - 卡片式
  - 其他（Pop Up、混合结构）
对比
- 视觉流
- 背景噪声
- 思维逻辑

交互设计的结构与认知

你生活在一个标准的世界里，一致性让你更好地理解世界

一致性法则
- 结构
- 颜色
- 操作
- 反馈
- 文字
父子结构
流-线结构
矩阵结构
状态认知
- 让用户明确过去、当前、将来的位置（出口和入口）
- 告诉用户他当前所处的状态
效率与场景
- 如何解决等待的问题
  - 加载机制的设计
  - 对等待的控制感
  - 主流操作区要控制好图片大小，避免动画
  - 四种方式缓解用户等待焦虑感
    - 使用进度条，让用户知道等多久
    - 拆分任务，将任务分为数个小阶段分别加载
    - 调整加载速度，采用变速加载
    - 主流操作区不使用太大的图片和动画
- 如何快速有效地识别和提示
  - 预防差错
  - 即使出现差错也能纠正、撤销
- 及时的反馈
  - 视觉反馈
  - 声音反馈
  - 触觉反馈
  - 反馈的快速性
  - 反馈的对等性
  - 有效反馈节省时间
- 对于场景的合理运用提升使用效率

交互的设计原则

二八法则
- 手机可能有100个功能，但是只有20个功能被用户使用
费茨定律
- 元素越大，越容易点击
- 重要的控件应该摆在合适的位置，让用户点击或者寻找的时候不会那么辛苦
- 一个重要、高频、商业价值达的控件有资格比其他控件做得更大些，这样的设计形态可以和它的内在逻辑保持一致
格式塔心理学
能量消耗论与剃刀法则

设计的评估逻辑

三个用户阶段

新手用户
中间用户
专家用户

三大负荷

认知负荷
操作负荷
视觉负荷

不需要用户思考的设计当然是好设计，但最糟糕的确实就算让用户思考了，用户也不明其意，甚至不知道产品是什么。

如何降低用户的思考
- 明确界面传达的意思
- 尽量使用图标加文字
- 使用用户的语言
操作负荷评估标准
- 确保操作对象足够大，便于点击
- 减少手势消耗
- 简化的流程步骤
- 保持操作惯性
减少视觉负荷
- 尽量减少动画元素
- 避免使用复杂的背景
- 保持屏幕整洁
- 最少化的视觉元素

集创评估六要素

转化力
- 头屏三要素
  - 我是谁
  - 我有什么内容
  - 什么内容在吸引着你
- 条目性感度
- 转化是否具备足够动力
系统活性
- 状态认知
- 引发更多的链接
- 多次触发力
效率值
- 主任务效率
- 层级是否深
- 高频操作是否具备效率
- 流畅度
防错
- 认知负荷如何
- 错误入口、干扰信息
- 错频入口
风险
- 依赖第三方
- 政策
- 产品资源
需求满足度
- 界面是否满足主场景
- 界面是否覆盖常规、VIP需求
- 界面是否满足商业

视觉评估的要素

一致性
- 包括：文字、颜色、间距、控件、反馈等。
视觉流
- 包括：视觉强点、视觉流向、视觉干扰等问题。
- 标准一：信息的强点是否是视觉的强点
- 标准二：当信息都是平级关系进行排列时，视觉注意力是否平均分配
- 标准三：审查界面中出现的空白区域，要查看是否存在信息的“盲区”
空间流
- 包括：场和留白、文字的留白等。
规整度
- 包括：界面的平衡、结构对齐、元素对比度与识别度等。
抗风险
- 包括：图片或者元素缺失等。

钱——社交——信用，这是真正做互联网金融的商业逻辑。

在商业认知的基础上去做功能链生

排除改版的影响，原来的核心功能效率不能降低。
新的版本用户的认知习惯如何慢慢去建立。
新加入的功能和新加入的商业逻辑如何更好地匹配界面布局。

研发流程

很多管理方面的问题，会导致大多数团队在产品线上至少会浪费三分之一的时间和成本，如果浪费的太多，最直接的结果就是员工得熬夜加班和产品的匆忙上线。

这些问题具体表现如下
- 在产品各个阶段都会乱加需求，甚至不考虑产品的全局而混乱改动。
- 命名在产品的初期阶段，非要做后期阶段的事。
- 需求都没想清楚，就开始进行研发和设计。
- 甲方思维和互联网思维的冲突让企业争吵不断。
关于文档：在项目开发阶段一定要有文档的输出，绝对不能只靠口头协议。
- 项目每个阶段、产品的特点都明确地写在文档上，可以让各个岗位的人员很清楚地知道自己是否完成自己的任务。
- 预防团队流动性大。如果形成一定的文档和设计规范，可以让后来人员很容易了解项目的历史情况和之前的数据积累。
- 团队问责。一旦项目出现争执，立刻拿出文档来对证，能停止不休止的争论。

产品经理三大输出物：需求文档、迭代计划、用户数据
交互三大输出物：信息架构、原型验证、优化文档
视觉设计三大输出物：视觉效果、切图、界面标注

设计来源于生活，也来源于自身阅历，如果你想做出优秀的设计，必须学会认识你自己。

《Web全栈工程师的自我修养》读书笔记

Sat, 28 Oct 2017 00:00:00 +0000

当我们知道一个“东西”的名字，就会在看到这个“东西”的时候，立马意识到它。
但是如果我们不知道它的名字，可能一辈子也不会认识它。这就是约书亚树原理。

概念

全栈工程师（Full-Stack Engineer）：
- 一个能处理数据库、服务器、系统工程和客户端的所有工作的工程师。
全栈：
- 表示为了完成一个项目，所需要的一系列技术的集合。简单来说，全栈工程师就是可以独立完成一个产品的
- 能力 + 思维
Web开发流程
- 产品设计
- 交互设计
- 视觉设计
- 前端开发
- 后台开发
- 测试
- 发布

一专多长

先在一个特定的方向上有比较深入的钻研，然后再将学习目标渐渐推广开来。
比如先从前端方向入手，掌握了基本的HTML、CSS、JavaScript之后，不要转头向服务器端语言或者App方向发展，而是深入到性能优化、SEO、多种框架、响应式页面等前端细节中去。

解决问题，而不是醉心技术

公司存在的意义就是解决问题，公司要解决用户的问题，而员工要解决公司的问题。
公司的问题可能是降低成本、扩大用户群、增加成交量、优化性能，等等。
设计四大原则：对齐、对比、距离和重复。

Web性能优化

压缩源码和图片
- JavaScript文件源代码可以采用混淆压缩的方式，CSS文件源代码进行普通压缩，JPG图片可以根据具体质量来压缩为50%到70%，PNG可以使用一些开源压缩软件来压缩，比如24色变成8色、去掉一些PNG格式信息等。
选择合适的图片格式
- 如果图片颜色数较多就使用JPG格式，如果图片颜色数较少就使用PNG格式，如果能够通过服务器端判断浏览器支持WebP，那么就使用WebP格式和SVG格式。
合并静态资源
- 包括CSS、JavaScript和小图片，减少HTTP请求。
开启服务器端的Gzip压缩
- 这对文本资源非常有效，对图片资源则没那么大的压缩比率。
使用CDN
- 或者一些公开库使用第三方提供的静态资源地址（比如jQuery、normalize.css）。
- 一方面增加并发下载量，另一方面能够和其他网站共享缓存。
延长静态资源缓存时间
- 这样，频繁访问网站的访客就能够更快地访问。
- 不过，这里要通过修改文件名的方式，确保在资源更新的时候，用户会拉取到最新的内容。
把CSS放在页面头部，把JavaScript放在页面底部

重视作品集

作品集（portfolio），是指您个人的项目和作品的集合，一份精心准备的作品集比简历更能说服人。

设计模式

创建型模式
- 单例模式
- 工厂方法
- 抽象工厂
- 建造模式
- 原型模式
- 对象池模式
- 多例模式
结构型模式
- 适配器模式
- 桥接模式
- 组合模式
- 装饰模式
- 外观模式
- 享元模式
- 代理模式
行为型模式
- 观察者模式
- 黑板
- 责任链
- 命令
- 解释器
- 迭代器
- 中介者
- 备忘录
- 空对象
- 模板方法
- 访问者模式

学习管理

在项目最开始做出合理的时间评估
根据人员的强项来安排任务
唤起团队对项目成功的渴望
保障沟通。理想沟通频率每周至少两次。

扩展阅读书单

【思想类】
- 《黑客与画家》（美）保罗·格雷厄姆，人民邮电出版社
- 《专业主义》（日）大前研一，中信出版社
【商业类】
- 《重来：更为简单有效的商业思维》（美）贾森·弗里德 / （丹）戴维·海涅迈尔·汉森，中信出版社
- 《精益创业》（美）埃里克·莱斯，中信出版社
【面试类】
- 《编程之美：微软技术面试心得》《编程之美》小组，电子工业出版社
【企业文化类】
- 《打造Facebook》王淮，印刷工业出版社
【个人展示类】
- 《您就是极客：软件开发人员生存指南》（美）Michael Lopp，人民邮电出版社
- 《代码整洁之道》（美）Robert C. Martin，人民邮电出版社
【性能优化类】
- 《图解HTTP》（日）上野宣，人民邮电出版社
- 《高性能网站建设进阶指南》（美）Steve Souders，电子工业出版社
- 《网站性能监测与优化》（美）Alistair Croll / Sean Power，人民邮电出版社
【前端工程师类】
- 《精通CSS:高级Web标准解决方案（第2版）》（英）Andy Budd/Simon Collison/Cameron Moll，人民邮电出版社
- 《单页Web应用：JavaScript从前端到后端》（美）Michael S. Mikowski /Josh C. Powell，人民邮电出版社
【服务器类】
- 《鸟哥的Linux私房菜.基础学习篇》鸟哥，人民邮电出版社
- 《只是为了好玩 : Linux之父林纳斯自传》（美）Linus Torvalds、David Diamond，人民邮电出版社
【版本控制类】
- 《Git版本控制管理》（美）Jon Loeliger/ Matthew McCullough，人民邮电出版社
【代码艺术类】
- 《代码大全》（美）Steve McConnell，电子工业出版社
- 《代码的未来》（日）松本行弘，人民邮电出版社
- 《禅与摩托车维修艺术》（美）罗伯特·M.波西格，重庆出版社
【设计模式类】
- 《设计模式：可复用面向对象软件的基础》（美）Erich Gamma / Richard Helm / Ralph Johnson / John Vlissides，机械工业出版社
- 《JavaScript设计模式》（美）Addy Osmani，人民邮电出版社
【效率类】
- 《软件随想录：程序员部落酋长Joel谈软件》（美）Joel Spolsky，人民邮电出版社
- 《卓有成效的程序员》（美）Neal Ford，机械工业出版社
【设计类】
- 《写给大家看的设计书（第3版）》Robin Williams ，人民邮电出版社
- 《写给大家看的设计书：实例与创意》Robin Williams ，人民邮电出版社
【修为类】
- 《卓有成效的管理者》（美）彼得·德鲁克，机械工业出版社
- 《麦肯锡教我的写作武器》（日）高杉尚孝，北京联合出版公司·后浪出版公司
- 《金字塔原理》（美）巴巴拉·明托，民主与建设出版社
- 《安静：内向性格的竞争力》（美）苏珊·凯恩，中信出版社

《现在就干：互联网时代的高效时间管理法》读书笔记

Sat, 28 Oct 2017 00:00:00 +0000

感受一下时间流逝的速度，时间是没有声音的锉刀，最不善于利用时间的人最爱抱怨时光短暂，我们都没有时间去挥霍……时间是个盗贼……时间就是上帝给你的资本，让每一分每一秒都花在有意义的事情上，就是最好的时间管理了，最好的时间是现在。

做一个追时间的人

“个人管理”是指通过动态统筹自身各方面资源，实现个人目标和价值的系列活动。
“系统”是一套推行某项活动的具体方法、步骤、程序，是统一运作的整体。
- 它的核心是三部分：
  - 行动管理，助你提升效能、调配资源；（控制系统）
  - 知识管理，助你快速更新、呈现价值；（燃油系统）
  - 目标管理，助你自我定向、修炼视野。（导航系统）
“行动管理”，是指通过每日计划等手段，将想法高效转化为现实的行为管理过程。
- 从“行动管理”走起，先谈如何提高效率，等到自己的时间够用了，才有精力思考更长远的目标问题。
绝大多数方法都有用，只是使用者的心智模式不同，出现了结果的差异。
- 个人管理的方法和工具不是无用之物，但使用者的心智水平必须跟得上，才能发挥最佳效果。
高效一天 = 固定旋律 + 个性旋律
- 个性旋律
  - 1种记录
  - 2套旋律
  - 3块基石
  - 5大步骤
在日常生活中，根据情景及时切换“高效”与“非高效”模式。

升级你的大脑操作系统

“心智模式”是一个人对于自我、别人、组织、世界等层面的认知方式，深受过往经历、既有知识、思维定式的影响。
“一念一世界”，思维方式不同，引发的个人行为大相径庭。
- 在思考上当懒汉，因为每个人都是来自“猩猩”的你。
假如我们的大脑是一本书，其实出生时并非每一章都是空白的，而是已经写上大致的草稿。这些草稿是祖辈基因印记下来，带着原始欲望和想法。个人管理的过程，是在改写这本书的原有草稿，是依靠思维力量突破基因对你行为的操控，学会用理性克制本能，从野蛮人进化成真正的文明人。
- 这场与大脑斗智斗勇的挑战赛，是自己给自己的考——自考。
在构建个人管理系统的过程中，每个人大致会经历“淡漠、焦虑、上道、平稳”四个阶段。（个人管理发展四阶段）
在个人管理之路的四个阶段中，一部分人长年处于第一阶段的水平。大部分人都能进入第二阶段，只是第二阶段会进行分化。其中一部分人一直在原地圈圈，终其一生只停留在第二阶段不得前行，陷入无法提升个人综合能力和价值的困境；另外一部分人幸运地进入第三阶段，在锤炼中逐渐向第四阶段靠拢。
如今是互联网时代，社交媒体、网络服务集中于“掌”中，方便快捷，也轻轻松松分散你的注意力。
时间越自由，越容易一事无成。

感知你的时间花在哪儿了

想做好行动管理，你必须先了解自己原来的时间使用模式是怎样的。（望闻问切）
人类心智的“三重模型”：
- 自主心智（直觉）
- 算法心智（智商，高则聪明）
- 反省心智（觉察，高则理性）
记录时间开销正是一种很朴素、可以即刻上手的自我觉察方法，是提升“反省心智”的有效手段。
“时间开销记录”，是“事件-时间”日志，它以“时”与“分”为单位，是给予事件过程的记录。
- 时间怎么花？是严肃、认真，还是玩世不恭、随波逐流。如果不记录，又怎么知道呢？
- 即时记录比记忆更可靠。
- 明明有问题，单假装不知道问题的存在，不想改变，这是成长的顽疾。
- 以“目的为导向”，是渴求成长的你必须学会的一种“富人思维”。
- 时间要么花掉，要么投资。如果你不拿它换点什么，那它就真的被无意识地消费完了，连雪泥鸿爪都没留下。
分类是一种有效的管理手段，目的是让产出更有价值
- 1.自上而下，归纳类别
  - 行动管理系统也是如此，不可能一蹴而就，总是要不断微调内容。
- 2.大类之外，还有小类
  - 分类依据是什么？跟分类的目的有关系，也就是说，你分出这些小类别是想解决什么问题，能方便解决某个问题是最棒的。
- 3.没有对错，只有适合
  - 在麦肯锡工作方法中，MECE原则提到的“完全穷尽”，实质是指有边界的穷尽。只要你给分类划定边界，能自圆其说就行。
三个关于记录的“锦囊”
- 详略得当
- 控制频次
- 熟能生巧
  - 当别人的回顾停留在以“天”为单位，你已经开始几个小时为单位了。
  - 只要有记录，都是在帮助你养成感知时间的习惯。
时间开销记录的结果怎么回顾
- 看看三组时间
  - 高效与浪费时间
  - 自由与被占时间
    - 这些时间被固定住了，难以大幅度挪用来安排自己想做的事
  - 创造与事务时间
    - “创造时间”是指被安排了动脑量较大的任务，有个人成果、作品产出的时间。
    - “事务时间”。这些时间的流向是对情境质量要求不高，以体力劳动为主的任务。
- 关注三大情况
  - 关注重要指标情况
  - 关注比例
  - 关注特别情况
- 数据统计的三点前提
  - 有工具
  - 有分类
  - 有计划
习惯的链条：暗示 —— 行动 —— 奖赏
记录的动作越简单越好，以减少拖延症的发生。
简易时间开销记录表

* 月 * 日	时间都去哪儿了？
7:00 - 8:00
8:00 - 9:00
9:00 - 10:00
……
20:00 - 21:00
21:00 - 22:00

如何让每天拥有更多精力

每日高效公式：一日生活 = 固定旋律 + 个性旋律
想要高效生活和工作，第一步是稳住每天能固定的大框架，即我所提倡的“固定旋律”。“固定旋律”正像一首歌里反复出现的那部分，是生活中相对稳定的行为系列组合。他让一系列行为自动化，降低大脑选择做某些事的思考成本，而把精力留在决策更重要的事情上。
新习惯会打破大脑原有的认识，大脑会像身体免疫系统排斥异物一样排斥新习惯，产生反抗，试图不被新习惯影响。
只要是你在一定时期内重复的做法，无论是好是坏，大脑都会记住它，默认是你需要的。
习惯分为三个层次：
- 行为习惯
- 身体习惯
- 理念习惯
  - 看不见、摸不着，相对含糊，不易识别，隐藏较深，影响力更大。
很多人的习惯无法持续，往往是因为制订了“超人习惯计划”。
习惯养成要根据摩的设定阶段目标，慢慢朝着一个一个小目标奔过去，这样菜不会感觉无止境、没盼头。
先找到离个人目标最接近、能产生“多米诺骨牌效应”的重点习惯，在针对这个确定真正有效、最适合自己的行动，咬咬牙对这个习惯死磕，关注过程，随时调整养成方案，但不随意放弃。
综合：“习惯养成”的内容，在这里送出6个“一”的建议：
- 每年选择至少一个新的重要习惯进行挑战；
- 选择合适的目标并设置一定的规则；
- 每次只开始一个，至少100天；
- 寻求一个互相支持的监督小团体；
- 一定要记录与回顾；
- 一定不要怕中断和痛苦。
“执行意图”能帮你快速在“暗示”与“行动”之间建立，其思维结构是“当A出现，我久作出B反应”，可以称它为“if…then…（如果……就）”。它能在你所搭建的情景（if）和既定的行为（then）之间建立起一座桥梁，缩小想法和行为之间的鸿沟。
高效人士会定时反思和回顾，她们知道这是在为人生制定一本《错题集》
很多人来考虑事情，总是单纯地考虑金钱成本，忽视了“时间才是更重要的成本”。
你无法直接“不做什么”，你只能找另外一个做法替代原来的坏习惯。
改掉习惯，就是把这个习惯的启动条件、形成环境破坏除掉。
坏习惯难以一次性归零，需要慢慢减量。
woop:wish(愿望)、outcome（结果）、obstacle（障碍）、plan（计划）。
合理睡眠、健康饮食和坚持运动，是保障精力的三大法宝。

高效能人士是如何做日计划的

高效一天 = 固定旋律 + 个行旋律
- 要做好这道公式，第一步是先设置每日“固定旋律”，这部分内容在上一章讲过。第二部是用“个性旋律”填充“固定旋律”之外的时间。“个性旋律”主要为日计划的内容。
做计划主要制订的是第二象限的计划——重要不紧急的事情。

四象限法则	不紧急	紧急
重要	2象限	1象限
不重要	3象限	4象限

只用日程表海远远不能把你的全部事情打理好，它能消除的压力范围极其有限。
“靠谱计划”的真相：制定计划时“烧脑”，执行计划时轻松。
日计划系统的流程：收集——孵化——确定——执行——回顾。另外再加一个“检查”的习惯。这个系统的五个阶段看似简单，但每个都有玄机，而且总和效果大于各部分的简单相加。
- 要人杂时估优情（邀人杂食故友情）

graph TD
 A[邀<要>] --> |近期要| B[人]
 B --> |自己| C[杂]
 C --> |简单| D[食<时>]
 A --> |近期不要| A1{将来}
 A1 --> A2(删除)
 A1 --> A3(将来也许)
 B --> |别人| B1(等待)
 C --> |复杂| C1(分解)
 D --> D1[立即做<2分钟内>]
 D --> D2(下一步行动)
 D2 --> |确切日期| D3(日程)
 D2 --> K1[故<估>]
 K1 --> K2[友<优>]
 K2 --> K3[情]
 K1 --> K11[1h 2h 3h]
 K2 --> K21[高 中 低]
 K3 --> K31[办理护照 带宝宝打针]

系统可以让你免于掉入感性直觉的陷阱。

省下来的时间，你用来投资啥

日计划不是解决迷茫的法宝，它只能帮你提升一天的效率。
一天天的计划好比一颗颗珍珠，散落满地，如果没有长远意义这条线把它们串起来，你不会知道它们将变成一串多么美的链子。
不妨从一周乃至一年的高度去俯视日计划，用它们牵引日计划。
要解决迷茫问题，根本的解决办法是从源头追问，尝试个人管理的顶层设计：把视野提升至很高的位置（比如站在一生的高度、10年的高度、5年的高度）。如果难度太大，不妨从月目标开始着手。
你写下的年目标，必须给你怦然心动“真的爱”的感觉，而不只有写出来很牛的感觉。
对年目标看得越清楚，越有实现的可能。
职场人士每年可高质量自由支配的时间一般少于2500小时，所以时间的投放注意别超标。

MySQL新建数据库和用户账号

Wed, 03 May 2017 00:00:00 +0000

MySQL 数据库账号的基本用法，适合初学者快速上手。

登陆数据库

mysql -h数据库HOST -P端口 -u管理员账户 -p

按提示输入密码即可登录。如果在本地操作且使用默认端口，可以简化为：

mysql -u root -p

基本操作命令

显示数据库

SHOW DATABASES;

创建数据库

CREATE DATABASE 新数据库名;

如果需要指定字符集：

CREATE DATABASE 新数据库名 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

进入某个数据库

USE 新数据库名;

显示数据库中的表

SHOW TABLES;

用户管理

插入新用户

INSERT INTO mysql.user(Host, User, Password) 
VALUES("使用者IP", "新用户名", PASSWORD("密码"));
FLUSH PRIVILEGES;

注意： MySQL 5.7+ 版本中 Password 字段已改为 authentication_string。

推荐方式：使用 CREATE USER

-- 创建用户
CREATE USER '用户名'@'localhost' IDENTIFIED BY '密码';

-- 或者允许远程连接
CREATE USER '用户名'@'%' IDENTIFIED BY '密码';

给用户分配数据库权限

GRANT ALL PRIVILEGES ON 数据库名.* TO '用户名'@'使用者IP' IDENTIFIED BY '密码';
FLUSH PRIVILEGES;

常见权限说明：

权限	说明
ALL PRIVILEGES	所有权限
SELECT	只读
INSERT	插入数据
UPDATE	更新数据
DELETE	删除数据
CREATE	创建表/数据库
DROP	删除表/数据库

示例：创建只读用户

-- 创建只读用户
CREATE USER 'readonly_user'@'%' IDENTIFIED BY 'password123';

-- 授予 SELECT 权限
GRANT SELECT ON mydb.* TO 'readonly_user'@'%';

-- 刷新权限
FLUSH PRIVILEGES;

示例：创建管理员用户

-- 创建管理员用户
CREATE USER 'admin_user'@'%' IDENTIFIED BY 'strong_password';

-- 授予所有权限
GRANT ALL PRIVILEGES ON *.* TO 'admin_user'@'%' WITH GRANT OPTION;

-- 刷新权限
FLUSH PRIVILEGES;

查看和撤销权限

查看用户权限

SHOW GRANTS FOR '用户名'@'localhost';

撤销权限

REVOKE ALL PRIVILEGES ON 数据库名.* FROM '用户名'@'localhost';
FLUSH PRIVILEGES;

删除用户

DROP USER '用户名'@'localhost';

常用配置检查

查看字符集设置

SHOW VARIABLES LIKE 'character%';

修改 root 密码

SET PASSWORD FOR 'root'@'localhost' = PASSWORD('新密码');
-- 或者
ALTER USER 'root'@'localhost' IDENTIFIED BY '新密码';

安全建议

不要使用 % 作为生产环境用户的 Host
为每个应用创建单独的用户和数据库
遵循最小权限原则，只授予必要的权限
定期更换密码
生产环境禁用 root 远程登录

总结

操作	命令
登录	`mysql -u root -p`
创建数据库	`CREATE DATABASE dbname;`
创建用户	`CREATE USER 'user'@'host' IDENTIFIED BY 'pwd';`
授权	`GRANT privileges ON db.table TO 'user'@'host';`
撤销权限	`REVOKE privileges ON db.table FROM 'user'@'host';`
删除用户	`DROP USER 'user'@'host';`

WordPress如何使用腾讯云COS

Wed, 03 May 2017 00:00:00 +0000

COS 是腾讯云的对象存储服务，免费 50G 存储空间，按外网流量收费，内网调用免流量。本文介绍如何让 WordPress 使用 COS 存储图片并享受内网流量。

一、COS 开通与配置

1. 开通对象存储服务

登录腾讯云控制台，按照提示开通 COS 服务。

2. 创建 Bucket

⚠️ 重要：Bucket 所属地域必须与 ECS 服务器一致，否则无法享受内网流量！

在 COS 控制台创建存储桶：

选择与 ECS 相同地域（如广州、上海等）
设置访问权限（建议私有读写）
记录 Bucket 名称和地域

3. 获取密钥

在访问密钥管理页面获取：

SecretId
SecretKey

二、安装 COS 插件

本文采用 cos-sync 插件，上传图片时自动同步到 COS。

安装步骤

下载插件并解压
上传到 WordPress 插件目录
在 WordPress 后台启用插件
配置插件参数（SecretId、SecretKey、Bucket、地域等）

插件配置

// 插件配置参数示例
cos_options = [
 'secretId' => '你的SecretId',
 'secretKey' => '你的SecretKey',
 'bucket' => 'your-bucket-1250000000',
 'regional' => 'ap-guangzhou', // 地域代码
 'domain' => 'https://your-bucket.cos.ap-guangzhou.myqcloud.com'
];

三、享受 COS 内网流量

方法 A：自建代理服务

在服务器上实现一个读取 COS 图片的服务：

<?php
// proxy.php - COS 代理服务
if (empty($_GET["file"])) {
 die('no access');
}

require_once __DIR__ . '/../../../wp-blog-header.php';
require_once 'vendor/autoload.php';

use Qcloud\Cos\Client;
use Qcloud\Cos\Exception\ServiceResponseException;

$cos_options = get_option('cos_options', true);
$secretId = $cos_options['secretId'];
$secretKey = $cos_options['secretKey'];
$bucket = $cos_options['bucket'];
$region = $cos_options['regional'];

$client = new Client([
 'region' => $region,
 'credentials' => [
 'secretId' => $secretId,
 'secretKey' => $secretKey,
 ],
]);

$file = $_GET["file"];

try {
 $result = $client->getObject([
 'Bucket' => $bucket,
 'Key' => ltrim($file, '/'),
 ]);
 
 // 设置 Content-Type
 $contentType = $result['ContentType'] ?? 'application/octet-stream';
 header('Content-Type: ' . $contentType);
 echo $result['Body'];
} catch (ServiceResponseException $e) {
 http_response_code(404);
 die('File not found');
}

评价：

✅ 实现灵活，可自定义缓存、压缩等
❌ 需要处理 COS 的 keep-alive 问题
❌ 需要设置合理的超时时间

方法 B：Nginx 反向代理（推荐）

使用 Nginx 代理 COS 请求，实现内网访问：

server {
 listen 80;
 server_name your-blog.com;
 
 # WordPress 其他请求
 location / {
 try_files $uri $uri/ /index.php?$query_string;
 }
 
 # COS 图片代理
 location ^~ /cos/ {
 # 去掉 /cos/ 前缀，重写为实际 COS 路径
 rewrite ^/cos/(.*) /$1 break;
 
 # 代理到 COS
 proxy_pass https://your-bucket.cos.ap-guangzhou.myqcloud.com/;
 
 # 代理配置
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
 # 超时设置
 proxy_connect_timeout 60s;
 proxy_read_timeout 60s;
 proxy_send_timeout 60s;
 
 # 缓存设置
 proxy_cache cache;
 proxy_cache_valid 200 7d;
 add_header X-Cache-Status $upstream_cache_status;
 }
 
 location ~ \.php$ {
 fastcgi_pass unix:/run/php/php-fpm.sock;
 fastcgi_index index.php;
 include fastcgi_params;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 }
}

访问方式：http://your-blog.com/cos/uploads/2023/01/image.jpg

评价：

✅ 实现简单，配置灵活
✅ 响应及时，支持缓存
✅ 可复用 Nginx 的各种优化

四、插件优化配置

问题 A：媒体库缩略图显示异常

现象：不勾选"本地保存"后，媒体库缩略图显示不正确

原因：服务器不存储图片，无法获取尺寸，默认宽高为 1px

解决：修改 WordPress 核心文件最小尺寸

// wp-includes/media.php，约 444 行
// 将 $w 和 $h 的最小值改为 150
$w = max(150, (int) round($current_width * $ratio));
$h = max(150, (int) round($current_height * $ratio));

// wp-admin/includes/image-edit.php，约 606 行
$w2 = max(150, $w * $ratio);
$h2 = max(150, $h * $ratio);

问题 B：预览看不到图片

解决：修改媒体模板文件

// wp-includes/media-template.php，约 680 行和 931 行
// 在 else 分支中设置 size 为 full
<# } else { #>
 <label class="setting">
 <input type="hidden" name="size" value="full" />
 </label>
<# } #>

五、完整配置示例

docker-compose.yml

version: '3.8'

services:
 wordpress:
 image: wordpress:latest
 ports:
 - "8080:80"
 volumes:
 - ./wp-content:/var/www/html/wp-content
 environment:
 - WORDPRESS_DB_HOST=db
 - WORDPRESS_DB_NAME=wordpress
 - WORDPRESS_DB_USER=wp_user
 - WORDPRESS_DB_PASSWORD=wp_password

 db:
 image: mysql:8.0
 environment:
 - MYSQL_ROOT_PASSWORD=root_password
 - MYSQL_DATABASE=wordpress
 - MYSQL_USER=wp_user
 - MYSQL_PASSWORD=wp_password
 volumes:
 - db_data:/var/lib/mysql

volumes:
 db_data:

Nginx 配置（生产环境）

upstream wordpress {
 server 127.0.0.1:8080;
}

server {
 listen 443 ssl http2;
 server_name your-blog.com;
 
 ssl_certificate /etc/ssl/certs/your-blog.crt;
 ssl_certificate_key /etc/ssl/private/your-blog.key;
 
 root /var/www/html;
 index index.php index.html;
 
 # COS 代理
 location ^~ /cos/ {
 rewrite ^/cos/(.*) /$1 break;
 proxy_pass https://your-bucket.cos.ap-guangzhou.myqcloud.com/;
 proxy_cache_valid 200 30d;
 expires 30d;
 }
 
 # WordPress
 location / {
 proxy_pass http://wordpress;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 }
 
 location ~ \.php$ {
 proxy_pass http://wordpress;
 fastcgi_pass unix:/run/php/php-fpm.sock;
 include fastcgi_params;
 }
}

六、常见问题

Q: Bucket 地域选错了怎么办？

A: 可以删除重建，或在插件中手动指定地域参数。

Q: 内网流量仍然收费？

A: 检查 ECS 和 COS 是否同地域，确保使用内网域名访问。

Q: 图片加载很慢？

A: 建议开启 CDN 加速，配合 Nginx 缓存优化。

七、费用说明

项目	说明
存储空间	免费 50GB
内网流量	免费
外网下行流量	按量计费
请求次数	按量计费

💡 建议：将 ECS 和 COS 放在同一地域，使用 内网 Endpoint（内网域名） 访问存储与回源，可省去外网下行流量费用并降低访问延迟。若站点必须对公网用户分发图片，可在 COS 或 CDN 侧单独配置外网访问与缓存策略，按业务场景权衡成本与性能。

八、小结

按本文完成 COS 对接与域名配置后，媒体资源可走对象存储承载流量，ECS 专注计算；后续若有访问热点，再结合 CDN 与缓存策略进一步优化即可。

Linux新建用户与sudo权限

Mon, 10 Apr 2017 00:00:00 +0000

如何用命令行新建一个带超管权限的账号

用户管理基础

1. 创建用户组并指定 GID

# 创建用户组，指定 GID 为 1002
sudo groupadd -g 1002 www

# 不指定 GID（系统自动分配）
sudo groupadd www

2. 添加用户并指定 UID

# 创建用户并加入 www 组
sudo useradd -g www -u 1003 -m -s /bin/bash www

# 参数说明：
# -g : 指定主用户组
# -u : 指定用户 ID
# -m : 创建用户主目录
# -s : 指定登录 shell

3. 修改用户密码

sudo passwd www

4. 删除用户

# 删除用户（保留主目录）
sudo userdel www

# 删除用户及其主目录
sudo userdel -r www

Sudo 权限配置

添加用户到 sudo 组

# Debian/Ubuntu 系统
sudo usermod -a -G sudo www

# CentOS/RHEL 系统
sudo usermod -a -G wheel www

查看用户所属组

groups www
# 输出: www : www sudo

Ubuntu 系统默认管理员组

Ubuntu 第一个默认账号加入的组：

adm cdrom sudo dip plugdev lpadmin sambashare

完整示例：创建 Web 服务用户

# 1. 创建用户组
sudo groupadd -g 1002 webapps

# 2. 创建用户
sudo useradd -g webapps -u 1003 -m -s /bin/bash webapp

# 3. 设置密码
sudo passwd webapp

# 4. 添加 sudo 权限
sudo usermod -a -G sudo webapp

# 5. 验证
su - webapp
sudo ls /root

Sudoers 文件配置

编辑 sudoers 文件

# 安全的编辑方式（会检查语法）
sudo visudo

# 直接编辑（不推荐）
sudo nano /etc/sudoers

常用配置示例

# 允许用户执行所有命令（无需密码）
username ALL=(ALL) NOPASSWD: ALL

# 允许用户执行所有命令（需要密码）
username ALL=(ALL) ALL

# 允许用户执行特定命令
username ALL=(ALL) /usr/bin/systemctl restart nginx, /usr/bin/systemctl stop nginx

# 限制只有特定 IP 可以使用 sudo
username 192.168.1.100=(ALL) ALL

用户组权限配置

# 允许 sudo 组所有成员执行命令
%sudo ALL=(ALL:ALL) ALL

# 允许 wheel 组无密码 sudo（CentOS）
%wheel ALL=(ALL) NOPASSWD: ALL

查看和管理

查看所有用户

cat /etc/passwd | grep -v nologin | grep -v false

查看所有用户组

cat /etc/group

锁定/解锁用户

# 锁定用户（禁止登录）
sudo passwd -l username

# 解锁用户
sudo passwd -u username

设置用户过期时间

# 设置账户过期日期
sudo usermod -e 2025-12-31 username

# 查看账户过期信息
sudo chage -l username

常见问题

Q: 为什么新用户无法使用 sudo？

A: 检查用户是否在正确的管理员组中：

# Ubuntu
groups username # 应该包含 sudo

# CentOS
groups username # 应该包含 wheel

Q: 如何免密使用 sudo？

A: 编辑 sudoers 添加 NOPASSWD：

sudo visudo
# 添加：username ALL=(ALL) NOPASSWD: ALL

最佳实践

不要给普通用户 root 权限 - 只授予必要的最小权限
使用用户组管理权限 - 便于批量管理
禁用 root 远程登录 - 提高服务器安全性
记录 sudo 操作日志 - 审计用户行为

# 启用 sudo 日志（Debian/Ubuntu）
sudo visudo
# 添加：Defaults logfile="/var/log/sudo.log"

PHP7和Nginx安装记录

Thu, 02 Jun 2016 00:00:00 +0000

本文主要记录 PHP7 + Nginx 的编译安装以及环境搭建的操作步骤

1. 获取 PHP 源码

# 下载 PHP 7.0.7（注意：PHP 7.0 已停止维护，建议使用更高版本）
sudo wget http://cn2.php.net/distributions/php-7.0.7.tar.xz

# 解压
tar -xvf php-7.0.7.tar.xz
cd php-7.0.7

⚠️ 提示：PHP 7.0 已停止维护，建议使用 PHP 7.4 或 PHP 8.x

2. 安装依赖

sudo apt-get update

sudo apt-get install -y \
 nginx \
 mysql-client \
 git \
 build-essential \
 libxml2-dev \
 libssl-dev \
 libcurl4-openssl-dev \
 libjpeg-dev \
 libpng-dev \
 libmcrypt-dev \
 libreadline-dev \
 libgmp-dev \
 libzip-dev \
 libonig-dev \
 libicu-dev

现代推荐：如果安装 PHP 8.x，mcrypt 已被移除，gd 扩展改为 libgd-dev

3. 编译 PHP

cd php-7.0.7

sudo ./configure \
 --prefix=/usr/local/php7 \
 --enable-fpm \
 --enable-inline-optimization \
 --disable-debug \
 --disable-rpath \
 --enable-shared \
 --enable-opcache \
 --with-mysqli \
 --with-mysql-sock \
 --enable-pdo \
 --with-pdo-mysql \
 --with-gettext \
 --enable-mbstring \
 --with-iconv \
 --enable-bcmath \
 --enable-soap \
 --with-libxml-dir \
 --enable-pcntl \
 --enable-shmop \
 --enable-sysvmsg \
 --enable-sysvsem \
 --enable-sysvshm \
 --enable-sockets \
 --with-curl \
 --with-zlib \
 --enable-zip \
 --with-readline \
 --with-pear \
 --with-gd \
 --with-jpeg-dir=/usr/lib \
 --enable-gd-native-ttf \
 --enable-xml

# 编译安装
sudo make -j$(nproc)
sudo make install

# 创建软链接
sudo ln -s /usr/local/php7 /usr/local/php

# 复制配置文件
sudo cp php.ini-production /usr/local/php/lib/php.ini

⚠️ 警告：--with-mysql 在 PHP 7.0 中已被移除，请使用 --with-mysqli

4. 配置 PHP-FPM

cd /usr/local/php/etc

# 复制默认配置
sudo cp php-fpm.conf.default php-fpm.conf
cd /usr/local/php/etc/php-fpm.d
sudo cp www.conf.default www.conf

# 编辑 www.conf
sudo vim www.conf

修改用户和组：

[www]
user = www-data
group = www-data

; 如果使用 socket 连接
listen = /run/php/php-fpm.sock
listen.owner = www-data
listen.group = www-data
listen.mode = 0660

如果 www-data 用户不存在，需要先创建：

sudo groupadd -g 33 www-data
sudo useradd -g www-data -u 33 -s /usr/sbin/nologin www-data

5. 启动 PHP-FPM

# 启动 php-fpm
sudo /usr/local/php/sbin/php-fpm

# 添加到系统 PATH
sudo tee -a /etc/profile << 'EOF'
export PATH=$PATH:/usr/local/php/bin:/usr/local/php/sbin
EOF
source /etc/profile

# 验证安装
php -v
php-fpm -v

6. Nginx 配置

cd /etc/nginx/sites-enabled
sudo vim default

修改 PHP 配置文件块：

server {
 listen 80 default_server;
 root /var/www/html;
 
 index index.php index.html index.htm;

 server_name _;

 location / {
 try_files $uri $uri/ =404;
 }

 # PHP 配置
 location ~ \.php$ {
 fastcgi_split_path_info ^(.+\.php)(/.+)$;
 fastcgi_pass unix:/run/php/php-fpm.sock;
 # 或者使用 IP:9000
 # fastcgi_pass 127.0.0.1:9000;
 fastcgi_index index.php;
 include fastcgi_params;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 }

 # 禁止访问隐藏文件
 location ~ /\. {
 deny all;
 }
}

# 重载 Nginx 配置
sudo nginx -t
sudo service nginx reload

7. 测试

创建测试文件：

<?php
// /var/www/html/info.php
phpinfo();

访问 http://your_server_ip/info.php

⚠️ 安全提醒：测试完成后记得删除 info.php

8. 腾讯云/阿里云安全组

重要：记得在云控制台开放 80 端口的安全组规则！

现代安装方式推荐

使用 Ondrej PPA（Ubuntu/Debian）

sudo apt install software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt update
sudo apt install php8.1-fpm php8.1-mysql php8.1-curl php8.1-gd php8.1-mbstring php8.1-xml php8.1-zip

使用 Remi（CentOS/RHEL）

sudo dnf install epel-release
sudo dnf install dnf-utils
sudo dnf module reset php
sudo dnf module enable php:8.1
sudo dnf install php php-fpm php-mysqlnd

常见问题

问题	解决方案
make 报错	检查依赖是否安装完整
php-fpm 无法启动	检查用户权限和 socket 路径
502 Bad Gateway	检查 php-fpm 是否运行，socket 权限
访问不到 PHP	检查 Nginx fastcgi_pass 配置

参考链接

同时使用多个GitHub的SSH Key配置

Sun, 29 May 2016 00:00:00 +0000

GitHub 中一个 deploy key 只能用在一个仓库内，如果一台机器要管理多个仓库，就需要配置多个 SSH Key。

问题背景

在一台机器上可能需要：

管理多个 GitHub 账号
同时操作多个 GitHub 仓库
区分个人仓库和工作仓库

配置步骤

一、生成第一个 SSH Key

# 生成第一个 SSH Key（用于个人仓库）
ssh-keygen -t rsa -C "your_email@example.com"

一路回车，会在 ~/.ssh/ 目录下生成：

id_rsa - 私钥
id_rsa.pub - 公钥

# 查看公钥内容
cat ~/.ssh/id_rsa.pub

复制公钥内容，到 GitHub 添加 SSH Keys（仓库1）

二、生成第二个 SSH Key

# 生成第二个 SSH Key（用于另一个仓库）
ssh-keygen -t rsa -C "another_email@example.com"

注意：给这个文件起一个专属名字，例如 id_rsa_work

# 查看第二个公钥内容
cat ~/.ssh/id_rsa_work.pub

复制公钥内容，到 GitHub 添加 SSH Keys（仓库2）

三、创建 SSH 配置文件

在 ~/.ssh/ 目录下创建 config 文件：

# 编辑 config 文件
nano ~/.ssh/config

填入以下内容：

# 个人仓库（默认）
Host github.com
 HostName github.com
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/id_rsa

# 工作仓库（自定义别名）
Host github-work
 HostName github.com
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/id_rsa_work

# 也可以用域名区分
# Host github.com-company
# HostName github.com
# IdentityFile ~/.ssh/id_rsa_company

四、修改本地仓库配置

方法一：直接修改 .git/config

打开仓库的 .git/config 文件：

# 仓库1（个人）
[remote "origin"]
 url = git@github.com:username/personal-repo.git

# 仓库2（工作）
[remote "origin"]
 url = git@github-work:company/work-repo.git

方法二：使用 git remote 命令

# 克隆时指定 host
git clone git@github-work:company/work-repo.git

# 或者修改已存在的仓库
git remote set-url origin git@github-work:company/work-repo.git

验证配置

# 测试连接
ssh -T git@github.com
# 期望输出：Hi username! You've successfully authenticated...

ssh -T git@github-work
# 期望输出：Hi company! You've successfully authenticated...

多账号管理最佳实践

1. 清晰的命名规范

~/.ssh/
├── id_rsa # 个人主账号
├── id_rsa.pub
├── id_rsa_work # 工作账号
├── id_rsa_work.pub
├── id_rsa_client1 # 客户项目A
├── id_rsa_client1.pub
└── config # SSH 配置文件

2. Windows 用户注意

Windows 系统 SSH 配置文件位置：C:\Users\用户名\.ssh\config

确保文件格式为 UTF-8 without BOM

3. GitHub 多账号使用

# 克隆不同仓库
git clone git@github.com:username/repo1.git # 使用 id_rsa
git clone git@github-work:company/repo2.git # 使用 id_rsa_work

常见问题

Q: Permission denied (publickey)

A: 检查 SSH Key 是否正确添加：

# 调试连接
ssh -vT git@github.com

# 查看加载了哪些 Key
ssh-add -l

Q: 仍然提示需要密码

A: 确认 config 文件格式正确：

Host github.com
 HostName github.com
 IdentityFile ~/.ssh/id_rsa

Q: Windows Git Bash 无法识别 config

A: 使用记事本或 VS Code 创建 config 文件，避免格式问题

简化版 config 示例

# 默认
Host github.com
 HostName github.com
 IdentityFile ~/.ssh/id_rsa

# 别名1
Host gh-work
 HostName github.com
 IdentityFile ~/.ssh/id_rsa_work

总结

步骤	操作
1	生成多个 SSH Key（不同文件名）
2	添加到对应的 GitHub 账户
3	创建 `~/.ssh/config` 配置
4	修改仓库 remote URL 或克隆时指定

通过以上配置，就可以在一台机器上同时使用多个 GitHub 账号管理不同的仓库了。