Leanku 的博客

Markdown编辑工具推荐

Sun, 09 Aug 2026 00:00:00 +0000

Markdown 作为一种轻量级标记语言，因其简洁、易读、易写的特性，已成为文档撰写、学术写作、知识管理及技术博客的首选格式。市场上针对不同使用场景的编辑工具层出不穷，本文挑选了数款最具代表性的热门工具，从学术研究、知识管理到沉浸式写作进行深度解析。

1. Zettlr：专为学术研究与卡片盒笔记而生

如果你需要撰写学术论文、研究报告或处理大量参考文献，Zettlr 是一款不可多得的学术级 Markdown 编辑器。它在设计之初就融入了“卡片盒笔记法”（Zettelkasten），旨在无缝连接写作与文献管理。

官方地址：https://www.zettlr.com/
开源状态：完全开源（GPL-3.0 协议）
价格模式：完全免费
核心亮点：
- 深度文献集成：原生支持无缝对接 Zotero、JabRef 等文献管理工具，可直接插入 BibTeX 引用格式与生成脚注。
- 学术导出扩展：基于 Pandoc 引擎，支持将文档导出为 PDF、Word、EPUB 及 LaTeX 等多种格式，满足期刊排版要求。
- 自动化辅助：内置番茄钟、拼写检查以及自定义代码片段功能，大幅提升长时间写作的效率。
适用人群：学者、研究生、科技文章创作者及卡片盒笔记法实践者。

2. Obsidian：基于本地文件的网状知识库

Obsidian（黑曜石）不仅是一个 Markdown 编辑器，更是一个打造“第二大脑”的个人知识管理系统。它以双向链接（Bi-directional Links）和本地纯文本存储为核心理念。

官方地址：https://obsidian.md/
开源状态：闭源
价格模式：个人免费（商业使用需付费，另提供官方付费同步 Obsidian Sync 服务）
核心亮点：
- 关系图谱（Graph View）：以可视化图形展示笔记之间的双向链接关系，帮助发现潜在的思维交集与知识联系。
- 强大的插件生态：拥有极度活跃的社区，提供数千种插件（从 Kanban 画布、Dataview 数据库查询到 AI 联动），扩展性极强。
- 数据自主控制：所有文档均以纯文本 Markdown 格式保存在本地硬盘中，不受平台锁定限制，隐私安全性极高。
适用人群：构建知识体系的研究者、开发者、个人资料整理狂人及重度笔记用户。

3. Typora：极致无缝的“所见即所得”标杆

如果你追求极致纯粹的写作体验，不希望被左侧代码、右侧预览的分屏布局分散注意力，Typora 无疑是“所见即所得”（WYSIWYG）领域的行业标杆。

官方地址：https://typora.io/
开源状态：闭源
价格模式：买断制收费（买断约 $14.99，提供 15 天免费试用）
核心亮点：
- 实时无缝预览：输入 Markdown 语法后会自动渲染为最终视觉样式，既保持了排版的美观，又保留了纯文本的精简。
- 富文本增强支持：内置极佳的表格编辑交互，支持画图引擎（Mermaid）、LaTeX 数学公式渲染以及优雅的代码高亮。
- 高度自定义主题：支持加载不同的 CSS 主题，方便导出极具视觉美感的 PDF 或 HTML 文档。

OpenClaw +QQ机器人

Sat, 24 Jan 2026 00:01:01 +0800

OpenClaw +QQ机器人助手

OpenClaw 适用于任何操作系统的 AI 智能体 Gateway 网关，支持 WhatsApp、Telegram、Discord、iMessage 等。发送消息，随时随地获取智能体响应。通过插件可添加 Mattermost 等更多渠道。

1. 搭建 OpenClaw

可参考官方文档，按需选择适合的安装方式。

如果服务器上安装了1Panel,可以直接从应用商店安装

2. 接入 QQ

1. 申请 QQ 机器人

打开 QQ 开放平台，注册登录，然后创建 QQ 机器人。地址： https://q.qq.com
创建完成后，进入机器人的开发管理页面，找到 AppID 和 AppSecret，复制保存好，等会要用。
还要把你云服务器的公网 IP 添加到 IP 白名单里，然后保存。
在沙箱配置里给你的 QQ 账号（或者 QQ 群）添加访问机器人的权限：

2. 给 OpenClaw 绑定 QQ 机器人

安装 qqbot 插件 https://github.com/BytePioneer-AI/openclaw-china
- 远程登录到云服务器上，执行命令来安装 @openclaw-china/qqbot 插件。
- openclaw plugins install @openclaw-china/qqbot
- 安装插件成功后,配置QQ 机器人参数，用之前保存的 id 和 secret ：
```
1openclaw config set channels.qqbot.enabled true
2openclaw config set channels.qqbot.appId your-app-id
3openclaw config set channels.qqbot.clientSecret your-app-secret
4openclaw config set channels.qqbot.markdownSupport false
```
- 需要的话，还可以申请 Markdown 模板能力
- 重启网关服务 openclaw gateway restart

3. 访问Openclaw 的webUI页面

通常地址为 IP:18789 或者地址?token=你的token

LeanNav | 精选开发者导航

Thu, 01 Jan 2026 00:01:01 +0800

LeanNav | 精选开发者导航。nav.leanku.com

https://nav.leanku.com

LeanNav | 精选开发者导航。

一个简洁的精选开发者导航网站。

旨在整合高质量网站、工具等资源，分享给更多需要的人。

汇集全球优质编程资源、设计素材和实用工具，为开发者提供最高效的上网导航。

如果你感兴趣或者需要分享、建议、反馈…

请邮件联系我： support@leanku.com

闻言录｜字句成录，回响为闻。

Thu, 01 Jan 2026 00:01:01 +0800

闻言录｜字句成录，回响为闻。

https://www.wenyanlu.cn

闻言录｜字句成录，回响为闻。

一个以诗词、句子为核心的现代数字平台。

大道至简，极简设计。

换一句，多维度推荐
开放收藏、投稿功能
提供开放API
公开服务状态
AI集成完善中

如果你也喜欢或者有想法、建议、问题等

请邮件联系我： support@leanku.com

从零到一搭建个人AI知识库

Fri, 21 Nov 2025 00:01:01 +0800

从零到一搭建个人AI知识库

为什么要搭建个人AI知识库？

电脑里存了几百个文档，却怎么也找不到上周写的那份技术方案；收藏了无数篇优质文章，等到想用时却像大海捞针。在这个信息过载的时代，我们每个人都在知识管理的泥潭中挣扎。

AI知识库，正在改变这一切。想象一下：当你需要某个资料时，不用在十几个软件间来回切换，只需在一个搜索框里输入问题，AI就能立即从所有文档中精准定位，不仅给出答案，还会把相关内容整理好放在你面前。

本篇将介绍从零开始，一步步搭建一个属于自己的AI知识库。

一、理解核心概念：什么是RAG？

RAG（检索增强生成，Retrieval-Augmented Generation）

传统的AI大模型（如GPT）虽然知识渊博，但它们有一个致命缺陷：知识是固定的，且可能产生“幻觉”（编造出看似合理但完全错误的信息）

RAG的出现完美解决了这个问题。它的核心思想可以形象地理解为“给AI递小抄”——在回答问题前，先从外部知识库中检索出最相关的信息，然后将这些信息连同问题一起“喂”给AI，让它基于给定的材料进行回答。这就像一场开卷考试：AI不再是凭记忆瞎编，而是有参考资料可以查阅。

一个完整的RAG系统包含两个阶段：

阶段一：索引构建（离线） ——把文档“搬进”知识库

加载：读取PDF、Word、Markdown等各种格式的文档
切分：将长文档切成语义完整的小块
向量化：通过嵌入模型将文本块转换成高维数字向量
存储：将向量存入专门的向量数据库

阶段二：检索生成（在线） ——回答用户问题

用户提问 → 将问题也转换成向量
检索：在向量数据库中找最相似的Top K个文本块
增强：将检索结果与问题组合成提示词
生成：AI基于参考资料生成准确回答

这个流程听着复杂，但现在有大量开源工具帮你自动完成这一切。

二、选择工具链

搭建AI知识库，你不需要从零写代码。以下几类工具可以大幅降低门槛：

2.1 大模型（AI的大脑）

Ollama + DeepSeek：本地部署方案。Ollama是一个模型管理工具，设计思路类似于Docker，专门针对AI模型进行了优化。执行 ollama run deepseek-r1 就能自动下载并运行模型。数据完全留在本地，隐私无忧。
云API（DeepSeek API、OpenAI等）：无需本地显卡，按调用量付费，开箱即用。

对于个人知识库，推荐先从Ollama + DeepSeek入手——免费、隐私保护、够用。

2.2 向量数据库（知识的仓库）

向量数据库是RAG系统的核心存储组件。以下是主流选择：

数据库	特点	适合场景
Chroma	轻量级，Python原生，上手最快	快速原型、个人项目
Qdrant	性能优秀（5-8ms），单服务部署简单	中小规模生产项目
Milvus	性能最强（4-6ms），但需3个服务（etcd+MinIO）	大规模、企业级
PgVector	PostgreSQL扩展	已有PostgreSQL的项目

个人项目推荐从Chroma或Qdrant开始，资源占用低，部署简单。

2.3 一站式平台

如果你不想自己拼装各个组件，这些开源平台可以一站式搞定：

AnythingLLM：开箱即用，支持多种文档格式，可本地部署.
Dify：功能全面的开源LLM应用开发平台，支持可视化工作流
FastGPT：国产开源，知识库功能强大，高性能RAG框架
MaxKB：轻量级，知识库优先的垂直解决方案

三、动手搭建：两种路径

路径一：零代码/低代码

步骤1：安装Ollama并下载模型

# 安装Ollama（Mac/Linux）
curl -fsSL https://ollama.com/install.sh | sh

# 下载DeepSeek模型（7B版本，约4GB）
ollama pull deepseek-r1:7b

# 下载嵌入模型（用于向量化）
ollama pull nomic-embed-text

步骤2：安装AnythingLLM

从 anythingllm.com 下载对应系统的安装包并安装。

RAGFlow

Tue, 28 Oct 2025 00:01:01 +0800

RAGFlow

一、介绍

RAGFlow是一个完整的、开源的RAG（检索增强生成）系统。你可以把它看作一个已经搭建好的智能问答应用框架。

RAGFlow不是一个需要你从零编码的库，而是一个可以直接运行起来的服务。它内置了我们聊过的RAG的完整流程：上传文档 -> 自动解析 -> 切片 -> 调用Embedding模型生成向量 -> 存储 -> 检索 -> 调用大模型生成回答。

RAGFlow 官网

二、搭建一个智能问答系统

整体架构：

1你的文档 (PDF/Word/PPT) 
2 ↓
3[RAGFlow核心] 
4 ├─ 深度文档解析 → 保留表格/图片/格式
5 ├─ 智能分块 → 按语义切割文档
6 ├─ 向量化 → 调用Embedding模型
7 └─ 向量存储 → 存入数据库
8 ↓
9用户提问 → [检索引擎] → [你的微调模型] → 带引用的精准回答

2.1 部署RAGFlow

这里使用 Docker 方式环境要求：

CPU ≥ 4 cores (x86);
RAM ≥ 16 GB;
Disk ≥ 50 GB;
Docker ≥ 24.0.0 & Docker Compose ≥ v2.26.1.
gVisor: Required only if you intend to use the code executor (sandbox) feature of RAGFlow.

部署RAGFlow

向量数据库-Qdrant使用

Sat, 25 Oct 2025 00:01:01 +0800

向量数据库Qdrant使用

一、什么是向量数据库？

向量数据库是专门用于存储、管理和检索“向量嵌入（Embedding）”的数据库。

Embedding 的本质： 深度学习模型（如 OpenAI 的 text-embedding-3 或本地的 BGE 模型）能将文本、图片等转化为一串高维数值（向量）。在这个高维空间中，语义越接近的数据，其向量距离就越近。
核心功能： 与传统数据库通过 SQL WHERE 子句匹配关键词不同，向量数据库通过“最近邻搜索（ANN）”寻找语义上最相似的内容。它是实现 RAG（检索增强生成）技术的关键。

常见向量数据库

数据库	特点	适用场景
Milvus	超大规模、分布式	海量数据、互联网
Qdrant	易部署、性能高、支持过滤	企业级 AI 应用
Weaviate	GraphQL、模块丰富	AI 平台
Chroma	轻量级	本地开发、测试
Pinecone	SaaS 云服务	快速上线
pgvector	PostgreSQL 扩展	已有 PostgreSQL 项目

二、Qdrant介绍

2.1 什么是 Qdrant？

Qdrant 是一款使用 Rust 开发的开源向量数据库，专门用于高性能相似度搜索。

主要特点：

高性能 ANN 检索
HNSW 索引
REST API
gRPC
Payload 元数据过滤
多向量支持
Snapshot 备份
集群部署
Docker 支持

2.2 Qdrant 核心架构

 Client
 │
 REST API / gRPC
 │
 Collection
 │
 Point
 ┌──────────────┐
 │ Vector │
 │ Payload │
 └──────────────┘

Collection:类似 MySQL：Database
Point:类似 MySQL 一行数据
Vector： Embedding 后的数据
Payload：类似普通数据库字段

2.3 Qdrant 检索原理

Qdrant 默认采用 HNSW（Hierarchical Navigable Small World）索引。与传统全表扫描不同：

RAG

Fri, 24 Oct 2025 00:01:01 +0800

RAG技术（检索增强生成）

引言：当大模型遇上知识库

想象一下，你正在参加一场开卷考试。你的面前有两样东西：一个记忆力超群但知识停留在去年的天才同学（这就是大语言模型），以及一个可以随时查阅的最新版百科全书（这就是外部知识库）。你让这位同学回答问题，他既可以凭借自己的记忆作答，也可以随时翻阅百科全书获取最新、最准确的信息。

这个场景，就是 RAG（检索增强生成）最形象的比喻。

它不是要取代大模型，而是为大模型装上了一个可以实时更新的"知识图书馆"。

一、什么是 RAG？

1.1 官方定义

RAG 全称是 Retrieval-Augmented Generation，中文译为"检索增强生成"。它是一种将信息检索系统与大语言模型的生成能力相结合的技术架构。

核心思想很简单：在让大模型回答问题之前，先从一个知识库中检索出与问题最相关的信息，然后将这些信息作为"参考资料"连同原始问题一起交给模型，让它基于这些资料生成最终答案。

1.2 为什么要用 RAG？

传统的大语言模型存在三个先天性缺陷：

缺陷	表现	后果
知识截止日期	模型训练完成后，新发生的事件一概不知	问"今天的天气"、“最近的新闻”，模型只能道歉
幻觉问题	模型会"自信地胡说八道"	在金融、医疗等严肃场景无法直接使用
缺乏专业深度	对企业内部知识、专业领域知识不了解	无法回答基于私域数据的专业问题

RAG 的出现，一次性解决了这三个问题：

知识实时更新：只要更新知识库，模型就能"知道"
答案可追溯：每个回答都能找到对应的参考资料
低成本私有化：无需训练模型，只需构建知识库

1.3 RAG 的三步工作流程

一个标准的 RAG 流程包含三个核心步骤：

 1用户提问："去年的销售额是多少？"
 2 ↓
 3[第一步：检索]
 4 ↓
 5在向量数据库中搜索 → 找到"2023年财报.pdf"中的相关段落
 6 ↓
 7[第二步：增强]
 8 ↓
 9构建新的提示词：
10"基于以下资料回答问题：
11【资料】2023年公司财报显示，全年销售额为1.2亿元...
12问题：去年的销售额是多少？"
13 ↓
14[第三步：生成]
15 ↓
16大模型生成："根据公司财报，2023年的销售额为1.2亿元。"

二、RAG 的核心技术组件

要深入理解 RAG，需要认识它的三个核心技术组件：

模型微调

Fri, 24 Oct 2025 00:01:01 +0800

模型微调

一、模型微调到底是什么

简单来说，模型微调就是让一个已经博学多才的“通才”，通过针对性的“岗前培训”，变成精通某个领域的“专家”。

预训练模型（通才大厨）：就像一位精通全球菜系的米其林大厨，他掌握了所有的基础知识和烹饪技巧，但未必了解你餐厅的特色。
微调（岗前培训）：你想开一家川菜馆，于是让这位大厨用三个月时间，专门学习川菜的食材、调料和烹饪手法。
微调后的模型（川菜大师）：最终，他不仅保留了原有的厨艺基础，更能做出一手地道的麻婆豆腐，成为了川菜领域的专家。

这个过程直接调整模型的“大脑”（参数），让学到的技能内化为模型自身的能力。相比于RAG（它更像是让大厨在做菜时随时翻阅菜谱），微调后的模型在推理时速度更快，且能深度掌握某种特定的风格或知识。

二、核心技术：LoRA——四两拨千斤的微调利器

你可能会担心，重新训练一个包含几十亿甚至上千亿参数的大模型，得需要多强大的计算资源？这正是LoRA（低秩自适应）技术大显身手的地方。

它的核心思想非常巧妙，我们可以继续用“川菜大厨”的比喻来理解

全量微调：相当于让大厨忘掉过去的一些习惯，全身心地重新学习川菜的每一个步骤。效果最好，但成本极高，需要强大的算力支持。
LoRA微调：我们不动大厨已经固化的核心“厨艺”（预训练权重），而是给他一个轻量级的“川菜秘方贴纸”（低秩矩阵）。这张贴纸只记录了川菜的关键调整点，比如“多加花椒”、“牛油比例提升”。大厨在做川菜时，只需要在关键步骤上参考这张贴纸即可。

这样做的好处是巨大的：

显存占用低：可训练的参数通常只有不到1%，让在消费级显卡（如RTX 4090）上微调大模型成为可能。
训练速度快：大幅缩短了训练时间。
模型性能高：在绝大多数任务上，效果可以媲美全量微调。

QLoRA 则是LoRA的进阶版，它先把基础模型“压缩”（量化）到4位精度，再应用LoRA，进一步降低了硬件门槛。

三、具体如何实现

理解了原理，我们来看看如何上手。

你完全不需要从零开始写复杂的训练代码。这里有两条清晰的路径：

路径一：使用云端服务（最简单、快速上手）

这是最省心的方式，你只需要准备好数据，在云平台上点点鼠标，就能完成微调。例如华为云的ModelArts Studio，流程大致如下：

准备数据：整理好你的训练集（如客户问答对、特定风格的文本等）。
选择模型：在平台界面选择你想要微调的基础模型，例如盘古大模型。
配置任务：选择“微调”训练类型，并可以灵活选择“全量微调”或“LoRA微调” 。然后设置一些基本参数，如：
- 学习率：决定模型参数更新的幅度，通常设为很小的值如 2e-5 。
- 训练轮数：整个数据集被训练的遍数，通常设为 3 以避免过拟合。
- 数据批量大小：每次处理的数据量，根据你的资源情况设定。
启动训练：提交任务，等待训练完成。过程中可以观察损失值（Loss） 曲线，它应该呈下降趋势，代表模型在有效学习。
部署使用：训练完成后，平台会自动生成一个微调后的模型版本，你可以像调用普通API一样，通过PHP代码来使用这个专属模型。

路径二：使用本地开源工具（更灵活、适合动手实践）

如果你想在自己的电脑上体验整个过程，Ollama + Python是一个非常棒的组合，它让微调变得异常简单。步骤如下：

1. 安装Ollama

参考另一篇 Ollama搭建本地

我们选择一个轻量级模型，普通电脑也能流畅运行

1ollama pull llama2

2. 准备微调数据

微调的核心是数据。我们将创建一个非常简单的数据集，让模型学习用莎士比亚的风格回答问题。

2.1 创建项目目录在合适的位置新建一个文件夹：

1mkdir ollama-finetune-demo
2cd ollama-finetune-demo

2.2 创建Python虚拟环境

1# 创建虚拟环境
2python -m venv .venv
3
4# 激活虚拟环境
5# Windows:
6.venv\Scripts\activate
7# macOS/Linux:
8source .venv/bin/activate

2.3 安装必要的Python库

Embedding：理解语义的基础

Wed, 22 Oct 2025 00:01:01 +0800

Embedding：理解语义的基础

引言：当计算机学会了"理解"含义

在上一篇文章中，我们讨论了大语言模型的工作原理。但有一个根本问题还没解决：计算机是如何"理解"词语含义的？

计算机只能处理数字，它不认识"猫"，不认识"爱情"，更不懂"苹果"和"橘子"的相似性。但今天的AI不仅能理解这些概念，还能进行语义推理。这一切的基石就是 Embedding（嵌入）。

一、什么是Embedding？

1.1 从一个思想实验开始

想象你要向一个来自外星、不懂任何人类语言的外星人解释"苹果"这个词。你会怎么做？

你可以给他一个多维度的描述：

维度	描述
颜色	通常是红色或绿色
形状	圆形
大小	拳头大小
味道	甜或酸甜
口感	脆
用途	可以吃
…	…

如果把这些维度变成数字，就得到一个向量：

1苹果 = [红色: 0.9, 圆形: 0.8, 大小: 0.5, 甜度: 0.7, 脆度: 0.8, 可食用: 1.0, ...]

这就是Embedding的基本思想：用一个数字数组（向量）表示一个概念的含义。

1.2 正式定义

Embedding（嵌入） 是将离散的符号（词语、句子、图片等）映射到连续向量空间的技术。每个符号被表示为一个固定长度的实数向量。

关键特性：

语义相近的符号，向量距离也相近
向量之间可以进行数学运算
向量的维度（长度）通常在几十到几千之间

1.3 直观理解：语义空间地图

可以把Embedding想象成绘制了一张"语义空间地图"：

1 [国王]
2 ↑
3 男人
4 ↑
5[苹果] ← 水果 → [橘子] [王后]
6 ↑ /
7 女人 /
8 ↑ /
9 [女王]

在这张地图上：

AI Agent

Tue, 21 Oct 2025 00:01:01 +0800

AI Agent：从"回答问题"到"主动行动"的智能体

引言：当AI从"思考者"变成"行动派"

到目前为止，我们讨论的所有AI应用都有一个共同点：被动响应。你问一个问题，模型给出一个回答。就像一位知识渊博但从不主动行动的学者。

而 AI Agent（智能体） 将彻底改变这个模式。它不再是单纯的"问答机器人"，而是一个能够自主理解目标、规划步骤、调用工具、执行行动的智能系统。

用一个形象的比喻来理解AI的进化：

阶段	比喻	能力
基础LLM	刚毕业的大学生	知识丰富，但只会回答问题
RAG增强	配备了图书馆的大学生	能查阅资料，回答更准确
微调模型	经过专业培训的专家	在特定领域更精通
AI Agent	项目经理 + 执行团队	能接收任务，规划执行，调用资源，交付成果

一、什么是AI Agent？

1.1 核心定义

AI Agent（智能体） 是一个能够感知环境、自主决策、执行行动以达到特定目标的智能系统。它具备以下核心特征：

自主性：无需人工干预，自主运作
目标导向：所有行动都围绕达成目标
工具使用：能调用外部工具完成任务
记忆能力：记住历史，持续优化
规划能力：将复杂任务拆解为可执行的步骤

1.2 Agent vs 传统程序 vs LLM

对比维度	传统程序	大语言模型(LLM)	AI Agent
工作方式	按固定逻辑执行	按输入生成输出	自主规划并执行
灵活性	低，只能做预设的事	中，能处理多种问题	高，能适应新任务
工具使用	内置固定功能	无（需外部配合）	主动调用各种工具
记忆能力	有状态但有限	会话级记忆	长期记忆+经验积累
目标理解	执行指令	理解问题	理解意图并拆解

1.3 一个生动的例子

用户请求：“帮我安排下周去上海的商务行程，包括机票、酒店和会议预约。”

理解大模型工作原理

Tue, 21 Oct 2025 00:01:01 +0800

理解大模型工作原理

引言：当计算机学会了"说话"

想象一下，你正在和一个"人"对话，他能理解你的问题，能写出优美的诗句，能解释复杂的科学概念，甚至能帮你写代码。但这个"人"其实是一个运行在服务器上的软件程序。它如何做到的？

这就是大语言模型（Large Language Model, LLM）创造的奇迹。在本文中，我将用一个PHP开发者的视角，带你深入理解这个"数字大脑"的工作原理。

一、大模型是什么？

1.1 从一个形象的比喻开始

传统程序 vs 大模型

对比维度	传统程序	大语言模型
工作方式	按照程序员写的代码执行	根据海量数据"学习"出的规律工作
知识来源	程序员明确告诉它	从数万亿文本中自己"领悟"
灵活性	只能处理预设的场景	能应对从未见过的问题
类比	按照菜谱做菜的厨师	尝过百万道菜后自己创造新菜的大厨

1.2 从数字到智能：三个关键洞察

洞察一：词语可以用数字表示

就像我们可以用经纬度表示地球上的任何位置，我们也可以用一组数字（向量）表示一个词的含义：

1"国王" = [0.8, 0.3, -0.2, 0.5, ...]
2"王后" = [0.7, 0.4, -0.1, 0.6, ...]
3"苹果" = [0.1, 0.9, -0.8, -0.3, ...]

洞察二：词语之间的关系可以用数学计算

经典的"国王 - 男人 + 女人 = 王后"实验表明，这些数字向量之间可以进行数学运算，而且结果符合语义！

洞察三：上下文决定含义

“苹果"在"苹果很好吃"和"苹果发布了新手机"中含义不同。大模型需要理解这种差异。

二、大模型的核心架构

2.1 从神经元到神经网络

单个神经元（生物类比）：

1树突（接收信号） → 细胞体（处理信号） → 轴突（输出信号）

人工神经元（数学抽象）：

1输入 × 权重 + 偏置 → 激活函数 → 输出

2.2 神经网络层级

一个完整的神经网络由多个层级组成：

设计模式原则

Mon, 13 Oct 2025 21:46:01 +0800

设计模式原则

设计模式的原则是理解和使用设计模式的基石。这些原则是面向对象设计的核心指导思想，设计模式本身就是这些原则在特定场景下的具体体现。

最重要的设计原则是 SOLID 原则，此外还有一些其他关键原则。

一、 SOLID 原则

SOLID 原则是五个最常用、最经典的设计原则，由 Robert C. Martin 提出。

1. 单一职责原则

核心思想：一个类应该只有一个引起变化的原因。
详细解释：一个类只负责一项职责或功能。如果一個类承担的功能过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。
比喻：一家餐厅，厨师负责做饭，服务员负责点菜和上菜，清洁工负责打扫。如果他们职责混杂，效率就会低下。
违反示例：一个 UserService 类，既负责用户信息的增删改查，又负责将用户数据导出为PDF报表，还负责发送邮件通知。
修正：将 UserService 拆分为 UserService（用户业务逻辑）、UserReportGenerator（报表生成）和 EmailService（邮件服务）。

2. 开闭原则

核心思想：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。
详细解释：当需求发生变化时，我们应该通过添加新的代码来扩展功能，而不是修改已有的、已经工作正常的代码。这是最重要的原则，是很多设计模式的目标。
比喻：一台电脑，你可以扩展USB设备（鼠标、键盘、硬盘），而无需为了支持新设备而拆开主机修改主板。
违反示例：一个 AreaCalculator 类，有一个 calculate 方法，里面用 if-else 来判断是圆形还是矩形来计算面积。如果要增加三角形，就必须修改这个类的代码。
修正：定义一个 Shape 接口，包含 calculateArea 方法。让 Circle 和 Rectangle 类实现这个接口。AreaCalculator 只需遍历 Shape 列表调用其方法即可。要新增三角形，只需创建 Triangle 类实现 Shape，无需修改任何现有类。

3. 里氏替换原则

核心思想：所有引用基类的地方必须能透明地使用其子类的对象。
详细解释：子类必须能够完全替代它们的父类，而不产生任何错误或意外的行为。也就是说，子类只能在保持原有行为的基础上进行扩展，而不能覆盖或改变父类的核心行为。
比喻：你父亲会开车，你作为儿子继承了他，你也会开车（保持了父亲的行为），但你可能会开得更快或者还会修车（扩展），你绝不能把“开车”这个行为重定义为“游泳”。
违反示例： Rectangle 类有 setWidth 和 setHeight 方法。Square 类继承 Rectangle，并重写了 setWidth 和 setHeight，使其同时设置宽和高。那么，一个接收 Rectangle 参数并调整其宽高的函数，如果传入一个 Square 对象，就会得到错误的结果。
修正：重新考虑继承关系，或者让 Rectangle 和 Square 都实现一个 Shape 接口，而不是使用继承。

4. 接口隔离原则

核心思想：客户端不应该被迫依赖于它不使用的接口。
详细解释：将一个庞大的、臃肿的接口拆分成更小、更具体的接口，使得客户端只需要知道它们感兴趣的方法。这样可以避免实现类被迫实现一些它们根本用不到的方法。
比喻：一台多功能打印机，有打印、复印、传真功能。如果做一个全能接口，老式打印机（只能打印）实现这个接口时，复印和传真方法只能空着或抛异常。不如拆分成 Printer、Scanner、Faxer 三个接口。
违反示例：一个 Animal 接口，有 eat(), fly(), swim() 方法。Dog 类实现它时，fly() 方法只能空实现。
修正：将 Animal 拆分为 Eatable, Flyable, Swimmable 等更精细的接口。Dog 实现 Eatable 和 Swimmable 即可。

5. 依赖倒置原则

核心思想：
- 高层模块不应该依赖于低层模块，二者都应该依赖于抽象。
- 抽象不应该依赖于细节，细节应该依赖于抽象。
详细解释：要面向接口编程，而不是面向实现编程。这减少了类间的耦合性，提高了系统的稳定性。
比喻：你想读书（高层），你不应该直接依赖一本具体的纸质书（低层），而应该依赖于“书本”这个抽象概念。这样，无论是纸质书、电子书还是有声书，你都可以“读”。
违反示例： UserService 类内部直接 new 了一个 MySQLDatabase 对象。如果将来要换用 OracleDatabase，就必须修改 UserService 的代码。
修正：定义一个 Database 接口。UserService 的构造函数接收一个 Database 类型的参数。这样，UserService 依赖于抽象的 Database，而 MySQLDatabase 和 OracleDatabase 都实现这个接口。

其他重要原则

除了 SOLID，还有一些非常实用的原则。

MySQL 中主要的日志类型

Mon, 13 Oct 2025 20:30:01 +0800

MySQL 中主要的日志类型

MySQL 提供了多种日志类型，每种都有其特定的目的和格式。理解这些日志对于数据库管理、性能调优、数据恢复和故障排查至关重要。

下面我将详细介绍 MySQL 中主要的日志类型及其格式

总结概览

日志类型	主要目的	格式	是否默认开启
错误日志	记录 MySQL 启动、运行、停止时的错误、警告和提示信息。	文本格式	是
二进制日志	记录所有更改数据的语句，用于主从复制和数据恢复。	`STATEMENT`, `ROW`, `MIXED`	否 (8.0默认开启)
通用查询日志	记录所有到达 MySQL 的客户端连接和执行的语句。	文本格式 / CSV 格式	否
慢查询日志	记录执行时间超过指定阈值的查询，用于性能优化。	文本格式 / CSV 格式	否
重做日志	InnoDB 特有的，用于保证事务的持久性和崩溃恢复。	物理格式（二进制）	是
回滚日志	InnoDB 特有的，用于保证事务的原子性和 MVCC。	逻辑格式	是

详细解析

1. 错误日志

这是 DBA 首先需要查看的日志，当数据库出现任何异常时，它通常是排查问题的起点。

内容：启动/关闭信息、错误信息、警告信息、在复制环境中从服务器线程的启动信息等。
格式：纯文本格式，易于阅读。
配置参数：
- log_error：指定错误日志文件的位置。

示例内容：

12023-10-27T08:00:00.000000Z 0 \[Note\] Server started.
22023-10-27T08:01:23.456789Z 5 \[Warning\] Aborted connection 5 to db: 'test' user: 'root' host: 'localhost'

2. 二进制日志

这是最重要的日志之一，它记录了所有对数据库进行更改的 DDL 和 DML 语句（如 CREATE, ALTER, INSERT, UPDATE, DELETE），但不包括 SELECT 和 SHOW 这类不修改数据的操作。

微服务治理-API网关

Mon, 15 Sep 2025 20:46:01 +0800

微服务治理-API网关

API Gateway 是微服务系统的统一入口层，负责请求路由、协议转换、安全控制、流量治理与聚合编排，是连接外部世界与内部微服务体系的核心枢纽。

一、介绍（Introduction）

1.1 为什么需要 API Gateway？

在没有网关之前：

问题 1：客户端需要知道所有服务地址

前端 / App 直接耦合后端服务拓扑。

问题 2：安全无法统一控制

每个服务都要：鉴权权限限流黑名单…

问题 3：跨服务调用暴露内部结构

问题 4：接口碎片化

一个业务页面可能需要多个服务，前端要请求 4～10 次 API。

1.2 API Gateway 的作用

Client
 │
 ▼
API Gateway
 │
 ├── User Service
 ├── Order Service
 ├── Payment Service
 └── Inventory Service

网关成为： 唯一入口

1.3 API Gateway 解决什么问题？

1. 统一入口

如：所有请求：https://api.xxx.com/*

2. 路由转发

/api/user → user-service、 /api/order → order-service

3. 鉴权（Auth）

统一处理：

微服务治理-服务调用

Mon, 15 Sep 2025 20:46:01 +0800

微服务治理-服务调用

微服务拆分之后，服务之间不再是进程内方法调用，而是通过网络进行通信。服务调用（Service Communication）就是研究不同服务之间如何安全、高效、可靠地进行数据交换。

一、介绍

1.1 为什么需要服务调用？

在单体架构中：只掉调用方法，比如 $user = $this->userService->getUser(1);

只是一次普通的方法调用（Method Call）。

没有网络、没有序列化、没有超时、没有连接

而微服务以后：

已经变成：HTTP、TCP、gRPC

所有调用都变成：网络通信（Network Communication）

1.2 微服务调用有哪些方式？

主要有三种：

1. HTTP REST

优点：

简单
通用
调试方便

缺点：

JSON 较大
序列化效率较低

2. RPC

看起来像：本地方法。

实际上走的是网络。

3. gRPC

底层：

HTTP/2。

Protobuf。

速度：非常快。

1.3 怎么选择调用方式？

场景	推荐
对外 API	HTTP REST
内部服务调用	gRPC
旧系统兼容	HTTP
高频通信	gRPC

即：外部使用 HTTP。内部使用 gRPC。

二、原理

2.1 一次 HTTP 调用发生了什么？

业务代码
 │
 ▼
DNS / 服务发现
 │
 ▼
TCP 建立连接
 │
 ▼
发送 HTTP 请求
 │
 ▼
User Service
 │
 ▼
返回 JSON

如果没有连接池。

微服务治理-服务监控

Mon, 15 Sep 2025 20:46:01 +0800

微服务治理-服务监控

服务监控（Metrics Monitoring）用于对系统运行状态进行持续量化观测，通过指标数据（QPS、RT、错误率、资源使用率等）实现对微服务系统健康状况的实时评估与告警。

一、介绍

1.1 为什么需要监控？

链路追踪解决的是：“这一次请求为什么慢？”

但通常还需要知道：“整个系统现在健康吗？”

比如：系统很卡问题

你需要判断：

是 CPU 高了？
是数据库慢了？
是某个接口爆了？
还是流量暴涨？

1.3 监控解决什么问题？

一句话总结：

把系统运行状态数字化 + 可视化 + 可告警

核心能力：

实时状态
历史趋势
异常检测
自动告警
容量规划

1.4 三大核心指标类型

System Metrics（系统指标）
Application Metrics（应用指标）
Business Metrics（业务指标）

二、核心指标（Metrics）

2.1 系统指标（System Metrics）

关注机器层面：

CPU 使用率
内存使用率
磁盘 IO
网络流量

2.2 应用指标（Application Metrics）

关注服务本身：

QPS（每秒请求数）
RT（响应时间）
错误率（Error Rate）
并发连接数

2.3 业务指标（Business Metrics）

关注业务结果：

下单成功率
支付成功率
注册转化率
GMV

三、应用

Prometheus + Grafana + Alertmanager轻量级监控告警系统

微服务治理-负载均衡

Mon, 15 Sep 2025 20:46:01 +0800

微服务治理-负载均衡

一、介绍

1.1 什么是负载均衡

负载均衡（Load Balancing）是微服务治理中的核心能力之一，它负责在多个服务实例之间合理分配请求，提高系统吞吐能力、可用性和扩展能力

假设： User Service 只有一台服务器：10.0.0.5

随着后面业务越来越大增加服务器：10.0.0.5，10.0.0.6，10.0.0.7 …

现在应该调用哪一个？

于是出现：

负载均衡（Load Balancing）

它负责：

从多个可用实例中选择一个最合适的实例。

1.2 为什么需要负载均衡？

假设：10000 个请求全部发送：10.0.0.5 导致服务宕机

结果： 10.0.0.6, 10.0.0.7 却一直空闲

负载均衡能够平均分配

1.3 负载均衡解决什么问题？

主要包括

1.流量分摊

2.提高可用性

3.方便扩容

4. 支持灰度发布

二、原理

2.1 整个调用流程

Order Service

↓

Service Discovery

↓

Registry

↓

返回：

10.0.0.5

10.0.0.6

10.0.0.7

↓

Load Balance

↓

选择：

10.0.0.6

↓

HTTP

2.2 轮询（Round Robin）

特点：

简单
公平
实现容易

缺点：

不能反映机器性能差异。

2.3 随机

优点：

微服务治理-链路追踪

Mon, 15 Sep 2025 20:46:01 +0800

微服务治理-链路追踪

链路追踪（Distributed Tracing）是微服务可观测性（Observability）的核心能力之一，用于在分布式系统中还原一次请求的完整调用路径，并定位性能瓶颈与故障点。

一、介绍

1.1 为什么需要链路追踪？

在单体应用中：一次请求在同一个进程内完成，只需要

打日志
打断点
其他调试
即可定位问题。

但在微服务架构中：

Client
 ↓
API Gateway
 ↓
User Service
 ↓
Order Service
 ↓
Payment Service
 ↓
Inventory Service
 ↓
DB / MQ

一次请求变成：

跨进程 + 跨机器 + 跨网络

1.2 典型问题

问题1：不知道慢在哪里

比如：接口很慢

但系统里有：Gateway、User、、Order…

你无法判断：到底慢在谁？

问题2：日志分散

如： Gateway logs User logs Order logs Payment logs

每个服务都有日志,但它们之间没有关联关系。

问题3：无法串联一次请求

无法确认日志是不是同一个请求？

1.3 链路追踪要解决什么问题？

把一次请求在多个微服务中的完整路径“串起来”

核心能力：

请求路径可视化
性能瓶颈定位
服务依赖分析
故障快速定位

二、原理

2.1 核心概念

链路追踪有三个核心概念：

1.Trace（一次完整请求）

Trace = 一次完整请求生命周期

微服务治理-配置中心

Mon, 15 Sep 2025 20:46:01 +0800

微服务治理-服务发现

一、介绍

1.1 什么是配置中心

在单体应用时代，我们通常这样管理配置： .env文件

但是进入微服务以后。

现在：每个服务都有自己的配置

比如REDIS_HOST需要修改，几十个服务的.env都要修改

于是就需要：

配置中心（Configuration Center）

1.2 配置中心解决什么问题？

一句话总结：

统一管理所有配置。

二、原理

2.1 配置中心整体架构

典型架构：

 Config Center
 (Nacos / Apollo)

 ▲
 │
 Read Config│

 ┌────────┬─────────┼──────────┐

 ▼ ▼ ▼ ▼

Gateway User Order Payment

服务：启动

读取：配置。

运行：

监听：配置变化。

2.2 配置加载流程

User Service为例

启动
↓
读取配置中心
↓
下载配置
↓
缓存到本地
↓
程序启动

2.3 动态刷新

配置修改时：配置中心通知各个服务，自动刷新，无需重启

2.4 配置版本管理

如果修改错误：可以恢复上一版本

2.5 环境隔离

比如开发环境DEV、测试环境TEST、预发布UAT、生产环境PROD 配置分别管理

三、主流配置中心

产品	特点	是否支持动态刷新
Nacos	注册中心 + 配置中心	✅
Apollo	配置中心	✅
Consul KV	KV 存储 + 配置	✅
Etcd	KV 存储	✅

Nacos最常用

微服务治理-注册中心

Mon, 15 Sep 2025 20:46:01 +0800

微服务治理-注册中心

一、介绍

1.1 什么是注册中心

注册中心可以理解为：

整个微服务系统的“通讯录”或“服务目录”。

在单体应用中：

Web
 │
 ▼
Controller
 │
 ▼
Service
 │
 ▼
Repository

所有模块都运行在同一个进程中，方法之间直接调用： $user = $this->userService->getUser($id);

开发者无需关心：

服务在哪里？
IP 是多少？
端口是多少？

因为它们都在同一个应用中。

而在微服务架构中：

 User Service

 10.0.0.10

 │

Order Service ---------------- Product Service

10.0.0.11 10.0.0.12

现在 Order Service 想调用 User Service。

问题来了：Order Service 怎么知道 User Service 在哪里？

如果直接写 IP：虽然可以运行，但会产生很多问题。

1.2 为什么不能写死 IP？

假设：今天：User Service 10.0.0.10

后面因为扩容：User Service 10.0.0.20 或者增加服务器：10.0.0.xxx

那么：

所有调用 User Service 的项目：都要修改配置。

到底调用哪一个?

于是：

需要一个统一管理所有服务信息的地方。

连接池

Fri, 15 Aug 2025 20:46:01 +0800

连接池

一、概述

1.1 什么是连接池

连接池（Connection Pool）是：

预先创建一定数量的连接，并统一管理和复用这些连接，而不是每次请求都重新建立连接。

这里的"连接"不仅指数据库连接，还包括：

MySQL 连接
Redis 连接
HTTP 连接
gRPC 连接
Kafka 连接
RabbitMQ 连接

本质上，只要是建立成本较高、可以复用的连接，都适合使用连接池。

1.2 为什么需要连接池

假设没有连接池：

每个请求执行流程如下：

HTTP Request
 │
 ▼
创建 MySQL 连接
 │
 ▼
执行 SQL
 │
 ▼
关闭连接

如果系统每秒有 5000 个请求, 服务器的大量资源都会浪费在建立连接上，而不是执行业务。

1.3 建立一个连接到底需要做什么？

以 MySQL 为例：

Application
 │
 ▼
TCP 三次握手
 │
 ▼
SSL/TLS（可选）
 │
 ▼
MySQL 用户认证
 │
 ▼
权限校验
 │
 ▼
初始化 Session
 │
 ▼
返回连接对象

这整个过程远比执行一条简单 SQL 更耗时。

Drone CICD自动化部署指南

Sat, 09 Aug 2025 16:46:01 +0800

一、Drone核心优势与架构设计

1.1 为什么选择Drone

官方文档

Drone作为轻量级云原生CI/CD工具，相比Jenkins具有显著优势：

资源占用低：基于Docker容器化运行，单个Pipeline平均内存消耗<100MB
云原生支持：原生集成Kubernetes、Docker等云原生技术栈
配置即代码：完全通过.drone.yml定义流程，版本可控
高性能：测试显示并发构建能力比Jenkins高3-5倍16

1.2 企业级架构设计

1[Gitee/GitHub] → [Drone Server] → [Docker Runner] (开发环境)
2 ↘ [K8s Runner] (生产环境)
3 ↘ [SSH Runner] (特殊场景)

二、注册 OAuth 应用（Gitee为例）

登录 Gitee → 点击右上角头像 → 设置 → 第三方应用 → 创建应用
填写应用信息：
- 应用名称：Drone CI（自定义）
- 应用描述：Drone CI/CD 工具（自定义）
- 授权回调地址：http://你的服务器IP或域名/login（必须正确，否则无法登录）
- 应用主页：http://你的服务器IP或域名
- 权限选择：（最少权限原则）user_info，projects，pull_requests，hooks
提交后，记录生成的 Client ID 和 Client Secret（后续配置需要）

三、安装 Drone 服务器和 Runner

Drone 由两部分组成：

Drone Server：管理项目、接收仓库事件、协调任务
Drone Runner：执行流水线任务（编译、测试、部署等）

3.1 手动启动 Drone Server

 1docker run -d \
 2 --name drone-server \
 3 --restart always \
 4 -p 80:80 \  # 端口映射（生产环境建议加 HTTPS）
 5 -v /var/lib/drone:/data \  # 数据持久化
 6 -e DRONE_RPC_SECRET=your_agent_secret \  # 自定义密钥（与 Runner 保持一致）
 7 -e DRONE_GITEE_CLIENT_ID=你的Gitee Client ID \  # 替换为 Gitee 应用的 Client ID
 8 -e DRONE_GITEE_CLIENT_SECRET=你的Gitee Client Secret \  # 替换为 Gitee 应用的 Secret
 9 -e DRONE_GITEE_SERVER=https://gitee.com \  # Gitee 服务器地址（固定）
10 -e DRONE_SERVER_HOST=你的服务器IP或域名 \  # Drone 访问地址（如 drone.example.com）
11 -e DRONE_SERVER_PROTO=http \  # 协议（http 或 https）
12 -e DRONE_USER_CREATE=username:你的Gitee用户名,admin:true \  # 设置 Gitee 用户名作为管理员
13 drone/drone:2.16

DRONE_AGENT_SECRET 可以简单用命令生成openssl rand -hex 16 Drone Server 默认监听容器内的 80 端口（HTTP）和 443 端口（HTTPS，若配置证书），你可以通过 Docker 的端口映射映射（-p 参数）自定义宿主机的端口。

轻量级容器编排工具指南

Sat, 09 Aug 2025 16:46:01 +0800

轻量级容器编排工具指南

在 Docker 环境中，除了 K8s，还有多种轻量级方案可以实现服务自动重启、健康检查等功能，特别适合单机或中小规模部署。

一、简单方案

1.1 Docker 自身的重启策略（最基础方案）

Docker Engine 内置了容器重启策略，可直接在启动容器时配置，实现容器退出后自动重启。

常用重启策略：

--restart always：无论容器因何种原因退出（包括正常退出），总是自动重启。
--restart on-failure[:max-retries]：仅在容器以非 0 状态码退出时重启，可选最大重试次数（如on-failure:3最多重启 3 次）。
--restart unless-stopped：除非手动执行docker stop，否则始终重启（包括 Docker daemon 重启时）

示例：

1# 启动PHP容器，配置always重启策略
2docker run -d \
3 --name php-app \
4 --restart always \  # 核心：容器挂掉后自动重启
5 -p 80:80 \
6 -v /path/to/php/code:/var/www/html \
7 php:8.2-apache

优势： 零依赖，直接使用 Docker 原生功能，适合单机部署。

局限： 仅能监控容器本身是否存活，无法检测应用内部故障（如 PHP-FPM 假死但容器仍运行）。

1.2 ocker Compose（适合多容器应用）

如果项目依赖其他服务（如 MySQL、Redis），可使用docker-compose管理，通过配置restart参数实现自动重启，同时支持健康检查。

docker-compose.yml示例：

 1version: '3.8'
 2services:
 3 php-app:
 4 image: php:8.2-apache
 5 restart: always  # 容器退出后自动重启
 6 ports:
 7 - "80:80"
 8 volumes:
 9 - ./php-code:/var/www/html
10 depends_on:
11 - mysql
12 # 健康检查：检测PHP服务是否正常响应
13 healthcheck:
14 test: ["CMD", "curl", "-f", "http://localhost/health.php"] # 自定义健康检查接口
15 interval: 30s  # 每30秒检查一次
16 timeout: 10s  # 检查超时时间
17 retries: 3 # 连续3次失败视为不健康
18 start_period: 60s  # 启动后60秒内不检查
19
20 mysql:
21 image: mysql:8.0
22 restart: always
23 environment:
24 MYSQL_ROOT_PASSWORD: rootpass
25 MYSQL_DATABASE: phpapp

健康检查补充： 在 PHP 项目中创建health.php作为健康检查接口（返回 200 状态码表示正常）：

Kong+Konga+Consul

Fri, 01 Aug 2025 11:46:01 +0800

Kong+Konga+Consul 安装和使用

此处使用Docker安装方式

一、安装Kong

kong具体使用可参考另一篇文章：Kong API网关

为了确保 Kong、Konga 和 Consul 能够通信，Kong 和 Konga 也需要加入到同一个网络。如果你尚未创建网络，或者希望使用新的网络，可以创建一个：

1docker network create kong-net

1.1 安装 PostgreSQL (Kong 的数据库)

Kong 需要 PostgreSQL 来存储其配置数据

1docker run -d --name kong-database \
2 --network=kong-net \
3 -p 5432:5432 \
4 -e "POSTGRES_USER=kong" \
5 -e "POSTGRES_DB=kong" \
6 -e "POSTGRES_PASSWORD=kong" \
7 postgres:13

–network=kong-net: 确保数据库与 Kong、Consul 在同一网络。
-e 环境变量：设置数据库的用户名、数据库名和密码。
建议使用 PostgreSQL 9.6 或更高版本，这里使用了 13 版本。

1.2 初始化 Kong 数据库

运行一个临时容器来执行数据库迁移：

1docker run --rm \
2 --network=kong-net \
3 -e "KONG_DATABASE=postgres" \
4 -e "KONG_PG_HOST=kong-database" \
5 -e "KONG_PG_USER=kong" \
6 -e "KONG_PG_PASSWORD=kong" \
7 kong:3.6.1 kong migrations bootstrap

--rm: 容器退出后自动删除。

并发模型-线程模型

Fri, 11 Jul 2025 20:46:01 +0800

并发模型-线程模型

一、介绍

1.1 什么是线程

线程（Thread）是：

CPU 调度和执行任务的最小单位。

一个进程（Process）可以包含多个线程，这些线程共享进程的内存空间和资源，但拥有各自独立的执行栈和程序计数器。

例如：

操作系统
 │
 ▼
 Chrome（进程）
 │
 ┌────┴────┐
 │ │
 ▼ ▼
线程1 线程2

线程是真正执行代码的主体，而不是进程。

1.2 进程与线程的区别

对比项	进程（Process）	线程（Thread）
定义	资源分配的基本单位	CPU 调度的基本单位
是否独立内存	是	否（共享进程内存）
创建成本	高	较低
通信方式	IPC（管道、Socket、共享内存等）	共享变量、锁
崩溃影响	一般不影响其他进程	一个线程异常可能导致整个进程退出（视语言/运行时而定）

1.3 为什么需要线程

假设没有线程：

用户A请求
↓
执行3秒
↓
用户B开始执行

所有请求只能串行处理。

有线程以后：

线程1

处理用户A

线程2

处理用户B

线程3

处理用户C

CPU 可以调度多个线程并发执行，从而提高系统吞吐能力。

1.4 项目中的线程

PHP-FPM

HTTP Request
↓
PHP-FPM Worker（进程）
↓
执行 PHP 脚本
↓
请求结束

PHP-FPM 不是线程模型，而是多进程模型，每个 Worker 一次只处理一个请求。

并发模型-协程模型

Fri, 11 Jul 2025 20:46:01 +0800

并发模型-协程模型

一、介绍

1.1 什么是线程

协程（Coroutine）是一种：

运行在用户态、由程序自身调度的轻量级执行单元。

它不像线程那样由操作系统调度，而是由运行时（Runtime）负责调度。

例如：

操作系统
 │
 ▼
 Worker（线程）
 │
 ┌──┼───────────────┐
 │ │ │
 ▼ ▼ ▼
协程1 协程2 协程10000

可以看到：

一个线程
可以运行成千上万个协程

1.2 为什么会出现协程

先看传统线程。例如：

线程1

↓

查询 MySQL

↓

等待200ms

等待期间：

CPU：

空闲

线程：

阻塞

CPU 没有工作。

协程出现以后：

协程1

↓

等待 MySQL

↓

主动让出 CPU

↓

协程2 开始执行

↓

协程3 开始执行

CPU 一直在处理其它任务。

因此：

协程解决的是 IO 等待导致 CPU 空闲的问题。

1.3 协程不是线程

协程永远依附于线程。

没有线程：

协程无法运行。

二、原理

2.1 协程为什么快

假设：

高并发系统设计-服务降级

Fri, 11 Jul 2025 20:46:01 +0800

高并发系统设计-服务降级

一、概述

1.1 什么是服务降级

服务降级（Fallback）指的是：

当系统压力过大或依赖服务不可用时，主动返回一个“可接受的替代结果”，而不是让请求失败。

例如：

正常：
→ 查询实时商品详情

降级：
→ 返回缓存商品详情 / 静态数据

1.2 降级和熔断的区别

项目	熔断	降级
目的	防止故障扩散	保证可用性
触发	服务异常	系统压力 / 异常
行为	阻断调用	返回替代结果
是否对外可用	否	是

熔断 = 不调用

降级 = 换一种方式返回

1.3 为什么需要服务降级

在高并发系统中：

资源永远是有限的。

例如：

数据库：1000 QPS,

实际请求：10000 QPS

如果不做降级：请求全部打到数据库-》系统崩溃

1.4 企业典型应用场景

场景1：商品详情页

正常： → 实时库存 + 价格 + 推荐

降级： → 缓存商品 + 默认库存

场景2：推荐系统

推荐服务挂了

→ 返回热门商品

场景3：搜索系统

ES不可用

高并发系统设计-隔离

Fri, 11 Jul 2025 20:46:01 +0800

高并发系统设计-隔离

一、概述

1.1 什么是隔离

隔离（Bulkhead）源自船舶结构设计：

船体被分割成多个“水密舱”，即使某一舱进水，也不会导致整船沉没。

在分布式系统中对应为：

将不同业务流量或依赖资源隔离开，避免相互影响。

例如：

订单服务
支付服务
库存服务
推荐服务

如果没有隔离：

推荐服务慢查询
→ 占满线程池
→ 订单无法处理
→ 系统崩溃

1.2 为什么需要隔离

在高并发系统中，最危险的不是“单点失败”，而是：

资源被某一个模块耗尽

典型问题：

1. 线程池被占满

慢接口占用所有 worker → 新请求无法处理

2. 连接池被耗尽

某服务频繁调用DB → 连接池100个全部占满

3.某服务拖垮整个系统

推荐服务异常 → 影响订单服务 → 影响支付服务 → 全系统不可用

1.3 隔离的核心目标

隔离的本质是：

限制资源共享范围，防止“一个坏点影响全局”

目标：

防止资源争抢
防止链式崩溃
提高系统稳定性
控制故障范围

1.4 典型场景

场景1：电商系统

订单 / 支付 / 推荐 / 搜索

要求：

推荐挂了不能影响下单
搜索挂了不能影响支付

场景2：微服务调用

Service A → B → C → D

如果 D 崩溃：

高并发系统设计-缓存保护

Fri, 11 Jul 2025 20:46:01 +0800

高并发系统设计-缓存保护

一、概述

1.1 什么是缓存保护

缓存保护（Cache Protection）是指：

通过一系列缓存设计策略，避免缓存异常导致数据库被大量请求直接访问，从而保证系统稳定性。

典型架构：

 Client
 │
 ▼
 Gateway
 │
 ▼
 Application
 │
 ┌─────────┴─────────┐
 │ │
 ▼ ▼
 Local Cache Redis Cache
 │
 Cache Miss？
 │
 ▼
 MySQL

1.2 为什么需要缓存保护

Redis 可以承受几十万甚至百万级 QPS，而 MySQL 通常只能支撑几千 QPS。

例如：

Redis

100000 QPS
↓
MySQL

3000 QPS

如果 Redis 出现问题：

100000 请求
↓
全部进入 MySQL
↓
数据库连接耗尽
↓
整个系统崩溃

缓存的首要目标是保护数据库，其次才是提升访问性能。

1.3 企业缓存架构

企业通常采用：

 Client
 │
 ▼
 Application
 │
 ▼
 Local Cache(Caffeine)
 │
 ▼
 Redis Cluster
 │
 ▼
 MySQL

同时配合：

高并发系统设计-熔断

Fri, 11 Jul 2025 20:46:01 +0800

高并发系统设计-熔断

一、概述

1.1 什么是熔断

熔断（Circuit Breaker）的核心思想来自电路保险丝：

当电流过大时，保险丝会断开，保护整个电路。

在分布式系统中：

服务A → 服务B → 服务C → 数据库

如果服务C异常：

超时
报错
响应缓慢

那么如果不做控制：

A 等 BB 等 CC 卡住→ 线程全部阻塞→ 请求堆积→ 系统雪崩

熔断的作用就是：

当下游服务异常时，直接停止调用它，快速失败。

1.2 为什么需要熔断

在高并发系统中，最危险的问题不是“服务失败”，而是：

失败被放大并传播

例如：

数据库慢查询
 ↓
所有请求阻塞
 ↓
连接池耗尽
 ↓
Redis压力上升
 ↓
Gateway超时
 ↓
全链路崩溃

这就是：

级联故障（Cascade Failure）

1.3 熔断解决的问题

熔断解决三类问题：

1. 防止线程阻塞

避免请求一直等待下游：

请求 → 卡住 → 不释放资源

2.防止错误放大

错误不会扩散到上游系统：

错误服务 → 不再调用

1.4 企业典型场景

场景1：支付服务异常

订单服务 → 支付服务（异常）

不熔断：
→ 一直等待
→ 订单线程堆积

熔断后：
→ 直接返回“支付处理中”

场景2：库存服务不可用

库存服务挂了

熔断：
→ 不再调用库存
→ 返回“库存未知”

场景3：第三方接口超时

例如：

高并发系统设计-限流

Fri, 11 Jul 2025 20:46:01 +0800

高并发系统设计-限流

一、什么是限流

限流（Rate Limiting）是指限制单位时间内允许进入系统的请求数量。

简单来说，就是：

控制流量进入系统的速度，而不是等系统崩溃之后再处理。

例如：

某接口限制：1000 Request / Second

如果一秒钟来了：1500 Request

那么：1000正常处理，500拒绝访问

通常返回：HTTP 429 Too Many Requests

限流的本质就是：

宁可拒绝一部分请求，也不要让整个系统崩溃。

二、为什么需要限流

因为系统资源是有限的。

例如：

服务器配置：

CPU：8 Core
Memory：16GB
MySQL连接池：100
Redis连接池：200

这些资源都存在上限。

假设数据库最大只能处理： 5000 QPS

如果突然来了：30000 QPS

没有限流：30000全部访问MySQL->连接池耗尽->CPU100%->慢SQL->超时->…->系统崩溃

有了限流：30000->Gateway->允许5000->25000直接拒绝->系统稳定

虽然部分用户会收到"系统繁忙"的提示，但系统整体仍然保持可用。

这正是限流存在的意义

三、典型应用场景

限流几乎存在于所有互联网系统中。

1、登录接口

例如：POST /login

限制：每个IP 5次/分钟

防止：

暴力破解密码
恶意攻击
短时间大量登录

2、短信验证码

3、支付接口

4、秒杀系统

5、开放API

四、限流的位置

限流通常不是只有一层。

一般有四层。

第一层：CDN

例如： Cloudflare->限制恶意流量

主要抵御：

CC攻击
DDoS
Bot

第二层：Nginx / Gateway

例如： Client->Gateway->Application

nginx示例

高并发系统设计-重试

Fri, 11 Jul 2025 20:46:01 +0800

高并发系统设计-重试

一、概述

1.1 什么是重试

重试（Retry）是指：

当一次请求失败后，在满足条件的情况下再次发起请求，以提高成功率。

例如：

请求 → 失败 → 再请求 → 成功

1.2 为什么需要重试

在分布式系统中，失败是常态：

网络抖动
RPC短暂超时
Redis瞬时不可用
MySQL连接波动
依赖服务重启

例如：

请求支付服务 → 超时

但实际服务是正常的

如果不重试：用户支付失败

但如果允许重试：

第一次失败

第二次成功

1.3 重试解决的问题

重试主要解决：

1. 短暂故障

如：网络抖动服务瞬断连接超时

2.依赖服务不稳定

如：

第三方支付 / 短信 / API

3.提高成功率

1.4 重试的误区

错误做法：失败 → 立即重试 → 再失败 → 无限循环

正确做法是：可控重试 + 退避策略 + 最大次数限制

二、原理

2.1 重试的核心思想

重试本质是：

用时间换成功率

但前提是：

不能无限重试
不能立即重试
不能对所有错误重试

2.2 哪些情况可以重试

网络超时
连接失败
503 / 502
RPC短暂异常

不可重试

高并发系统稳定性设计

Fri, 11 Jul 2025 20:46:01 +0800

高并发系统稳定性设计

本文适用于 Web 应用、API 服务、微服务、分布式系统等高并发场景，重点介绍现代企业级系统如何通过限流、熔断、降级、重试、超时、隔离和缓存等技术保障系统的稳定运行。

一、什么是高并发

1.1 高并发的定义

高并发（High Concurrency）是指系统在单位时间内需要同时处理大量用户请求的能力。

例如：

电商平台双十一抢购
秒杀活动
支付系统
社交平台热点事件
游戏服务器
视频直播
AI 大模型接口

假设一个用户访问商品详情页面，请求流程如下：

Client
 │
 ▼
Nginx
 │
 ▼
PHP
 │
 ├── Redis
 ├── MySQL
 └── Elasticsearch

一个用户访问几乎不会产生压力。

但是如果同时有10000个用户->10000 HTTP Requests->Application

系统就需要在极短时间内完成：

HTTP 请求解析
身份认证
参数校验
Redis 查询
数据库访问
JSON 序列化
网络返回

如果系统设计不合理，就可能出现响应变慢、超时甚至崩溃。

1.2 高并发 ≠ 高性能

高性能（Performance）

高性能关注的是 单个请求处理速度。

例如：

接口耗时：50 ms

优化 SQL 后：20 ms

这属于性能优化。

常见优化包括：

SQL 优化
Redis 缓存
JVM / PHP Runtime 优化
协程
对象池
连接池

高并发（Concurrency）

高并发关注的是： 系统能够同时处理多少请求。

PHPUnit使用指南

Mon, 30 Jun 2025 23:46:01 +0800

PHPUnit 使用指南

一、介绍

PHPUnit 是 PHP 领域最流行的单元测试框架，它受到 JUnit 的启发，为 PHP 开发者提供了编写和运行单元测试的工具和方法。使用 PHPUnit 可以带来以下好处：

验证代码的正确性，确保函数和方法按预期工作
便于代码重构，修改后可以快速验证是否破坏了现有功能
帮助理解代码功能，测试用例本身就是一种文档
支持测试驱动开发 (TDD) 流程

二、安装 PHPUnit

1. 安装 PHPUnit（可以通过 `composer require --dev phpunit/phpunit` 安装）

2. 配置PhpStorm 运行 PHPUnit（Docker环境为例）

2.1. 配置 Docker 远程解释器

打开 PhpStorm，进入 File > Settings > Build, Execution, Deployment > Docker
在右侧选择 Docker for Windows（通常会自动检测）
点击 Apply 确认配置，确保连接成功（底部会显示 “Connection successful”）
进入 File > Settings > Languages & Frameworks > PHP
点击 CLI Interpreter 右侧的 … 按钮，点击左上角 + 号，选择 From Docker, Vagrant, VM, WSL, Remote…
选择 Docker 并找到你的 php 容器
选择容器中的 PHP 可执行文件路径（如 /usr/local/bin/php）
点击 OK 完成配置，PhpStorm 会自动检测 PHP 版本和扩展

2.2 配置 PHPUnit

进入 File > Settings > Languages & Frameworks > PHP > Test Frameworks

wrk 使用指南

Mon, 30 Jun 2025 23:46:01 +0800

wrk 使用指南

一、介绍

wrk 是一款现代化的 HTTP 基准测试工具，使用 C 语言编写，基于事件通知机制（如 epoll, kqueue），能够产生巨大的负载。相比 ab(apache benchmark)，wrk 具有以下优势：

支持多线程 + 协程模式，能更好地利用多核 CPU
支持 LuaJIT 脚本扩展，可自定义请求生成和结果处理
性能更高，单机可轻松产生数万 QPS
提供更详细的统计信息（延迟分布等）

二、安装 wrk

Linux 系统安装

 1# Ubuntu/Debian
 2sudo apt install wrk -y
 3
 4# CentOS/RHEL
 5sudo yum install wrk -y
 6
 7# 或从源码编译安装
 8git clone https://github.com/wg/wrk.git
 9cd wrk
10make
11sudo cp wrk /usr/local/bin/

macos

1brew install wrk

三、基础使用方法

1. 基本命令格式

1wrk <选项> <测试URL>

2. 常用选项说明

选项	说明	示例值
-t	使用的线程数	12 (建议设置为CPU核心数的2-4倍)
-c	保持打开的连接数	100
-d	测试持续时间	30s (30秒), 2m (2分钟)
-s	指定Lua脚本	post.lua
-H	添加HTTP头	“User-Agent: wrk”
–latency	打印延迟统计	无参数
–timeout	超时设置	10s

3. 基本测试示例

1# 简单测试：12线程，100连接，持续30秒
2wrk -t12 -c100 -d30s http://localhost:8080/
3
4# 带延迟统计的输出
5wrk -t12 -c100 -d30s --latency http://localhost:8080/api
6
7# 带自定义HTTP头
8wrk -t12 -c100 -d30s -H "Authorization: Bearer token123" http://localhost:8080/api

四、高级功能：使用 Lua 脚本

wrk 的强大之处在于支持通过 Lua 脚本自定义请求。

PHP8新特性：JIT

Sun, 22 Jun 2025 20:46:01 +0800

PHP8新特性：JIT（Just-In-Time）

一、JIT（Just-In-Time）编译技术概述

1.1 什么是JIT编译

JIT（Just-In-Time）编译是一种动态编译技术，它在程序运行时将字节码或中间代码编译为机器码执行，而不是预先编译（AOT，Ahead-Of-Time）或纯粹解释执行。PHP 8.0首次引入了JIT编译器，这是PHP性能演进史上的重要里程碑。

1.2 PHP执行模式的演进

解释执行模式（PHP 5.x及之前）：
- 每次请求都需要解析、编译和执行
- 无任何形式的持久化缓存
OPCache缓存模式（PHP 5.5+）：
- 缓存预编译的opcode
- 减少重复编译开销
- 但仍需解释执行opcode
JIT编译模式（PHP 8.0+）：
- 将热代码（频繁执行的代码）编译为机器码
- 直接执行机器码，绕过解释器

1.3 JIT带来的性能提升

根据官方基准测试，JIT在某些计算密集型工作负载上可带来：

数学运算：1.5-3倍提升
字符串处理：1.2-2倍提升
框架综合性能：10-30%提升

注意：JIT对I/O密集型应用（如纯数据库CRUD）提升有限

二、PHP JIT工作原理

2.1 PHP脚本执行流程

 1PHP源代码
 2 ↓
 3Zend编译器 (生成opcode)
 4 ↓
 5OPCache (缓存opcode)
 6 ↓
 7Zend VM解释执行
 8 ↓
 9JIT编译器 (追踪热代码)
10 ↓
11生成机器码
12 ↓
13直接执行机器码

2.2 JIT编译流程

代码追踪：
- 监控执行过程中的热代码（频繁执行的代码路径）
- 默认阈值：执行次数超过3次触发JIT编译
编译优化：
- 寄存器分配
- 循环优化
- 死代码消除
- 内联函数调用
机器码生成：
- 针对当前CPU架构生成优化后的机器码
- 支持x86和ARM架构
执行切换：
- 后续执行直接跳转到机器码
- 绕过Zend虚拟机解释器

2.3 JIT与OPCache的关系

协同工作：
- OPCache是JIT的基础
- JIT只编译OPCache中缓存的opcode
内存管理：
- JIT使用OPCache的共享内存存储机器码
- opcache.jit_buffer_size控制JIT内存池大小

三、PHP JIT配置与使用

3.1 启用JIT

在php.ini中配置：

PHP底层原理与性能优化深度解析

Sun, 22 Jun 2025 20:46:01 +0800

PHP底层原理与性能优化深度解析

一、PHP生命周期与SAPI

PHP的生命周期是一个复杂但有序的过程，理解它对于性能优化至关重要。

1.1 PHP生命周期概述

PHP的生命周期可以概括为以下几个阶段：

模块初始化阶段 (MINIT)
- 只在PHP启动时执行一次
- 注册常量、类、资源类型等
- 所有扩展的MINIT方法被调用
请求初始化阶段 (RINIT)
- 每个请求开始时执行
- 初始化脚本运行环境
- 所有扩展的RINIT方法被调用
脚本执行阶段
- 解析、编译、执行PHP脚本
- 生成响应内容
请求关闭阶段 (RSHUTDOWN)
- 每个请求结束时执行
- 清理请求级资源
- 所有扩展的RSHUTDOWN方法被调用
模块关闭阶段 (MSHUTDOWN)
- PHP关闭时执行一次
- 清理持久化资源
- 所有扩展的MSHUTDOWN方法被调用

1.2 SAPI (Server API)

SAPI是PHP与外部环境交互的接口层，常见的SAPI类型包括：

Web服务器集成：
- Apache (mod_php)
- Nginx (PHP-FPM)
- IIS
命令行接口：
- CLI (Command Line Interface)
- CGI
嵌入式PHP：
- 嵌入到其他应用程序中

不同的SAPI实现会影响PHP的生命周期。例如：

在mod_php中，PHP作为Apache模块运行，生命周期与Apache进程绑定
在PHP-FPM中，PHP作为独立的FastCGI进程运行，可以独立管理进程池

二、OPCache原理与优化

2.1 PHP脚本执行流程

传统PHP脚本执行流程：

词法分析 (Lexing) - 将源代码转换为token流
语法分析 (Parsing) - 将token流转换为抽象语法树(AST)
编译 (Compilation) - 将AST转换为opcodes
执行 (Execution) - 执行opcodes

每次请求都需要重复这些步骤，造成大量CPU资源浪费。

分布式锁详解

Wed, 11 Jun 2025 20:46:01 +0800

分布式锁详解

在高并发和分布式系统中，为保证资源的一致性和互斥访问，分布式锁是必不可少的技术手段。本文将系统地讲解分布式锁的概念、场景、实现原理、使用方式，并附 PHP 示例。

1. 什么是分布式锁

定义：

分布式锁（Distributed Lock）是用于在多台机器或多个服务实例中控制共享资源访问的机制。它保证在同一时间，只有一个客户端可以操作某个资源，从而避免并发冲突。

特点：

互斥性：同一时间只有一个客户端持有锁。
可重入性（可选）：同一客户端可以重复获取锁。
可靠性：锁过期或客户端异常可自动释放，避免死锁。
可扩展性：适用于分布式系统和微服务架构。

2. 分布式锁的应用场景

分布式锁在企业场景非常常见，典型使用场景包括：

库存扣减
- 秒杀或抢购场景，防止库存超卖。
订单号生成
- 保证全局唯一订单号。
任务调度
- 多实例系统中，保证任务只被单实例执行。
缓存更新
- 防止缓存击穿时，多实例同时重建缓存。
支付或转账操作
- 防止重复扣款或资金异常。

3. 分布式锁的实现原理

3.1 数据库锁

原理：
- 利用数据库唯一索引或事务机制创建锁记录。
示例：
```
1INSERT INTO locks(name, create_time) VALUES('order_123', NOW());
2-- 成功表示获得锁，失败表示锁已被占用
```
优缺点：
- 优点：简单易用，直接使用现有数据库。
- 缺点：高并发性能较差，数据库可能成为瓶颈。

3.2 Redis 锁

原理：
- 利用 Redis 的 SETNX 或 SET key value NX PX 原子操作。
- 设置锁过期时间，防止死锁。
- (RedLock红锁可以解决在 Redis 主从复制或哨兵模式下，使用单实例 Redis 锁可能遇到的锁失效问题。)
释放锁：
- 需要验证当前客户端持有锁，防止误删他人锁。
优点：

使用 MinIO 自建云存储

Mon, 19 May 2025 20:40:01 +0800

使用 MinIO 自建云存储

1. MinIO 是什么

定位：一款高性能、开源的对象存储（Object Storage）系统，完全兼容 AWS S3 API。
核心目标：提供轻量级、易部署的私有云存储方案，适用于云原生和大数据场景。
开源协议：GNU AGPL v3（商业版提供企业级支持）。

核心特性
1. 高性能:
  1. 速度优势：支持并行多线程上传/下载，单节点吞吐量可达 10-100 Gbps
  2. 低延迟: 采用 Golang 编写，优化内存管理，响应时间在毫秒级
2. S3 完全兼容
  1. 无缝迁移：所有 AWS S3 SDK、CLI 工具（如 awscli）可直接对接 MinIO。
  2. API 支持：覆盖 Put/Get/Object、分片上传、生命周期管理等全部 S3 操作
3. 分布式架构
  1. 纠删码（Erasure Code）：数据分片存储，允许节点故障自动恢复（如 4节点容忍2节点失效）。
  2. 多租户：支持为不同业务创建隔离的存储桶（Bucket）和访问策略。
4. 轻量易部署
  1. 单二进制文件：无需复杂依赖，Docker/Kubernetes 一键部署。
  2. 资源占用低：单节点运行仅需 ~200MB 内存，适合边缘计算和 IoT 设备。
适用场景
1. 私有云存储
  - 替代方案：替代阿里云 OSS、AWS S3，实现数据自主可控。
  - 用例：企业文档库、备份归档。
2. 大数据与 AI
  - 兼容性：直接对接 Hadoop HDFS、Spark、TensorFlow 的 S3 接口。
  - 用例：训练数据存储、模型版本管理。
3. 云原生应用
  - Kubernetes 集成：通过 CSI 驱动为容器提供持久化存储。
  - 用例：微服务应用的文件共享。
4. 边缘计算
  - 轻量级：在树莓派等设备上运行，就近处理数据。
  - 用例：物联网设备数据采集。

2. 部署 MinIO

方式一: docker部署

 1# 创建存储目录和配置文件
 2mkdir -p ~/minio/data ~/minio/config
 3
 4# 使用 Docker 启动 MinIO（单机版）
 5docker run -d \
 6-p 9000:9000 \  # API 端口
 7-p 9001:9001 \  # 控制台端口
 8-v ~/minio/data:/data \ # 持久化存储
 9-v ~/minio/config:/root/.minio \
10-e "MINIO_ROOT_USER=admin" \
11-e "MINIO_ROOT_PASSWORD=yourpassword" \
12--name minio \
13minio/minio server /data --console-address ":9001"

方式二: 原生二进制安装（推荐）
1. 下载和安装

Git项目多远程仓库同步方法

Sun, 18 May 2025 13:46:01 +0800

Git项目多远程仓库同步方法

同一个 Git 项目可以同时推送到多个远程仓库（如 Gogs 和 Gitee）。

1. 添加 Gitee 作为新的远程仓库

git remote add gitee <Gitee仓库的URL>

2. 验证远程仓库设置

1git remote -v

3. 推送到 Gitee

1git push gitee master # 推送 master 分支
2# 或推送所有分支：
3git push --all gitee

4.（可选）设置默认同时推送到两个仓库

修改 .git/config 文件，在 [remote “origin”] 部分添加多个 push URL：

[remote "origin"]
 url = https://gogs.example.com/yourname/yourrepo.git
 fetch = +refs/heads/*:refs/remotes/origin/*
 pushurl = https://gogs.example.com/yourname/yourrepo.git
 pushurl = https://gitee.com/yourname/yourrepo.git

这样 git push 会同时推送到两个仓库。

5. （可选）从 Gitee 拉取更新

1git pull gitee master

删除指定的远程仓库（如 gitee）

1git remote remove gitee

注意事项：

两个仓库的分支结构最好保持一致
如果两边都有新的提交，可能需要先合并再推送
大型项目首次推送到 Gitee 可能需要较长时间

这种方法可以让你保持代码在多个远程仓库同步，适用于需要备份或多平台协作的场景。

基于 Gogs + Jenkins + Harbor + Docker 的自动化部署方案

Sat, 17 May 2025 18:46:01 +0800

基于 Gogs + Jenkins + Harbor + Docker 的自动化部署方案

1. 系统架构总览

开发者提交代码 → Git仓库 → Jenkins触发构建 → Docker构建镜像 → 推送至Harbor → 
Kubernetes部署更新 → 监控反馈

2. 环境准备

2.1 硬件要求

最低配置：2核CPU/4GB内存/100GB存储
推荐配置：4核CPU/8GB内存/200GB SSD

3. 组件安装与配置

3.1 Gogs 安装

另外一篇Jenkins 使用

3.2 Jenkins 安装

另外一篇Gogs 使用

3.3 Harbor 安装

另外一篇Harbor 使用

4. 环境配置

下面以wordpress项目为例

wordpress/
├── app/ # 项目代码
├── docker # Docker 相关文件
| ├── Dockerfile 
| ├── entrypont.sh 
| └── nginx.conf 
| └── nginx-wordpress.conf 
├── Jenkinsfile # Jenkins Pipeline 定义
└── k8s/ # Kubernetes 部署文件
 ├── deployment.yaml # Deployment 配置
 ├── service.yaml # Service 配置
 └── ingress.yaml # Ingress 配置（可选）
 └── namespace.yaml # namespace 配置（可选）

4.1 JenkinsPipeline配置

安装必要插件

Kubernetes Continuous Deploy
Docker Pipeline
Gogs plugin
Harbor
Git

配置凭据: Manage Jenkins > Credentials

Git仓库访问凭据 ID如 gogs-credential
Harbor仓库凭据 ID如harbor-credential
Kubernetes集群凭据（/etc/rancher/k3s）ID如 k3s-kubeconfig

Jenkins 示例：

K3s使用指南

Mon, 12 May 2025 21:46:01 +0800

K3s使用指南+Rancher

1. K3s 简介

K3s 是一个轻量级的 Kubernetes 发行版，由 Rancher Labs（现在是 SUSE 旗下）开发。
它完全兼容 Kubernetes API，但设计上更轻便、易安装，适合边缘计算、物联网设备、单节点或资源有限环境。
K3s 把 Kubernetes 的很多组件做了简化，比如内置了 containerd，默认启用 flannel 网络，去掉了复杂的插件，安装非常简单。
主要目标是让 Kubernetes 快速部署、低资源占用，并且更适合国内和小型集群使用。

2. K3s 对比 kubeadm

特性/方面	K3s	kubeadm
定位	轻量级、开箱即用的 Kubernetes 发行版	官方工具，用于标准 Kubernetes 集群的快速部署和引导
安装复杂度	极简安装，单条命令搞定	需要多个步骤，配置复杂，适合有一定 Kubernetes 经验的用户
组件集成	集成了 `containerd`，默认内置 `flannel` 网络，默认关闭了部分复杂组件（如部分云插件、Helm等）	只负责初始化集群，组件和网络插件需要用户自行选择安装
资源占用	非常低，适合边缘设备、物联网、单机小集群	资源占用较大，适合生产多节点环境
多节点支持	支持多节点，但更适合轻量和小规模集群	原生支持多节点和大规模集群，灵活度高
适用场景	单机、开发测试、小型集群、资源受限环境	生产环境，多节点，企业级集群部署
网络插件	默认集成 Flannel，安装简单	用户需自行部署网络插件（Flannel、Calico、Weave等）
更新升级	版本更新简单，内置自动化升级工具	需要手动升级，过程复杂
集成工具和生态	内置 Traefik（可选关闭），轻量且默认功能有限	灵活，可按需安装 Ingress、Dashboard、Helm 等组件
社区和支持	Rancher 支持，社区活跃	CNCF 官方支持，社区广泛
官网文档	https://k3s.io	https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/

如果你是想快速搭建一个单机或轻量集群，或者资源有限，想要简单易用、快速上手，推荐用 K3s。

Kubernetes（k8s）单机环境部署

Sun, 11 May 2025 22:46:01 +0800

Kubernetes（k8s）单机环境部署

1. Kubernetes (K8s) 简介

此文适合新手快速上手，涵盖安装、配置、基本使用单机环境

2. 环境

系统要求

操作系统：Linux（Ubuntu/CentOS）或 macOS（开发环境）
内存：至少 2GB（推荐 4GB+）
CPU：2 核+
存储：20GB+ 可用空间

安装工具

Docker（K8s 依赖容器运行时）
kubectl（K8s 命令行工具）
Minikube（本地单节点 K8s，适合学习）

3. 前置配置

 1# 1.关闭 swap
 2sudo swapoff -a
 3sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
 4
 5# 2.加载内核模块
 6sudo modprobe overlay
 7sudo modprobe br_netfilter
 8
 9# 3.设置内核参数
10cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
11net.bridge.bridge-nf-call-ip6tables = 1
12net.bridge.bridge-nf-call-iptables = 1
13net.ipv4.ip_forward = 1
14EOF
15
16sudo sysctl --system

4.安装container runtime（推荐使用 containerd）

Kubernetes v1.24 开始，完全移除了 dockershim

使用Bark 实现IOS接收通知

Sun, 11 May 2025 20:46:01 +0800

Bark 实现IOS接收通知

1. Bark介绍

免费、轻量！简单调用接口即可给自己的iPhone发送推送。
依赖苹果APNs，及时、稳定、可靠
不会消耗设备的电量， 基于系统推送服务与推送扩展，APP本体并不需要运行。
隐私安全，可以通过一些方式确保包含作者本人在内的所有人都无法窃取你的隐私。

2. 安装

2.1 AppStore 下载Bark 允许通知权限

替换内容去请求给的地址即可接收通知，各参数可参考文档

2 也可自己部署服务端 bark-server

2.2 下载安装 bark-server

1# 下载二进制，不同系统注意更换版本
2wget https://github.com/Finb/bark-server/releases/download/v2.2.0/bark-server_linux_amd64
3
4chmod +x bark-server_linux_amd64
5
6./bark-server_linux_amd64 -addr 0.0.0.0:8080 -data ./bark-data

3. 使用 systemd服务单元文件来管理 bark-server 的运行

创建编辑一个服务单元文件

1vim /etc/systemd/system/bark-server.service

在文件中添加以下内容：

 1[Unit]
 2Description=Bark Server
 3After=network.target
 4
 5[Service]
 6ExecStart=/path/to/your/bark-server_linux_amd64 -addr 0.0.0.0:8080 -data /path/to/your/bark-data
 7Restart=always
 8User=your_username
 9Group=your_groupname
10
11[Install]
12WantedBy=multi-user.target

把 /path/to/your/bark-server_linux_amd64 和 /path/to/your/bark-data 替换成实际的文件路径，把 your_username 和 your_groupname 替换成实际的用户名和用户组名。

Gogs 使用指南

Sun, 11 May 2025 13:46:01 +0800

Gogs 使用

1. 什么是 Gogs?

Gogs 是一款极易搭建的自助 Git 服务。

Gogs 的目标是打造一个最简单、最快速和最轻松的方式搭建自助 Git 服务。使用 Go 语言开发使得 Gogs 能够通过独立的二进制分发，并且支持 Go 语言支持的 所有平台，包括 Linux、Mac OS X、Windows 以及 ARM 平台。

2. 安装 Linux-amd64系统为例

2.1 要求

数据库（选择以下一项）
- MySQL：版本 >= 5.7
- PostgreSQL
- TiDB
- 或者什么都不安装直接使用 SQLite3

2.2 下载安装

1# 下载二进制
2wget https://github.com/gogs/gogs/releases/download/v0.13.2/gogs_0.13.2_linux_amd64.tar.gz
3
4tar -xzvf gogs_0.13.2_linux_amd64.tar.gz gogs
5
6cd gogs
7
8./gogs web

2.3 使用 systemd服务单元文件来管理

创建编辑一个服务单元文件
```
1vim /etc/systemd/system/gogs.service
```

在文件中添加以下内容：

 1[Unit]
 2Description=Gogs Server
 3After=network.target
 4
 5[Service]
 6ExecStart=/path/gogs web
 7Restart=always
 8User=your_username
 9Group=your_groupname
10
11[Install]
12WantedBy=multi-user.target

把 /path 替换成实际的文件路径，把 your_username 和 your_groupname 替换成实际的用户名和用户组名。

SSH 使用指南

Sun, 11 May 2025 13:46:01 +0800

SSH 使用指南：从基础到服务器密钥登录

什么是 SSH？

SSH (Secure Shell) 是一种加密的网络协议，用于在不安全的网络中安全地进行远程登录和其他网络服务。它通过加密技术保护通信安全，防止信息泄露和中间人攻击，是系统管理员和开发人员管理远程服务器的必备工具。

基本 SSH 连接

最基本的 SSH 连接命令格式如下：

1ssh username@hostname

例如，要连接到 IP 为 192.168.1.100 的服务器，用户名为 admin：

1ssh admin@192.168.1.100

首次连接时会提示验证服务器指纹：

1The authenticity of host '192.168.1.100 (192.168.1.100)' can't be established.
2ECDSA key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
3Are you sure you want to continue connecting (yes/no)?

输入 yes 后，服务器指纹会被保存在本地 ~/.ssh/known_hosts 文件中，以后连接时会自动验证。

SSH 配置文件

SSH 客户端配置文件 ~/.ssh/config 可以简化连接命令。例如：

1Host myserver
2 HostName 192.168.1.100
3 User admin
4 Port 2222

配置后，只需输入 ssh myserver 即可连接。

Prometheus + Grafana + Alertmanager轻量级监控告警系统

Sun, 11 May 2025 00:00:00 +0000

Prometheus + Grafana + Alertmanager轻量级监控告警系统

一、工具简介与官网

工具	作用	官网文档地址
Prometheus	指标采集、存储与告警规则管理	prometheus.io/docs
Node Exporter	暴露服务器硬件/OS指标	github.com/prometheus/node_exporter
Alertmanager	告警聚合与通知发送	prometheus.io/docs/alerting
Grafana	数据可视化与仪表盘	grafana.com/docs

二、安装与配置

1. Prometheus 安装

1.1 下载与解压

1
2wget https://github.com/prometheus/prometheus/releases/download/v2.51.0/prometheus-2.51.0.linux-amd64.tar.gz
3tar xvf prometheus-2.51.0.linux-amd64.tar.gz
4cd prometheus-2.51.0.linux-amd64

1.2 配置监控目标

编辑 prometheus.yml：

 1global:
 2 scrape\_interval: 15s
 3 evaluation\_interval: 15s
 4
 5scrape\_configs:
 6 \- job\_name: "prometheus" \# 监控自身
 7 static\_configs:
 8 \- targets: \["localhost:9090"\]
 9 \- job\_name: "node" \# 监控服务器
10 static\_configs:
11 \- targets: \["<NODE\_IP>:9100"\] \# 替换为Node Exporter的IP

1.3 启动 Prometheus

1./prometheus \--config.file\=prometheus.yml

访问 http://<PROMETHEUS_IP>:9090 验证。

高并发技术体系

Sat, 10 May 2025 20:46:01 +0800

高并发技术体系概要

主要为基础理论知识

第一部分：高并发保护机制

限流熔断降级重试隔离缓存保护超时

第二部分：并发模型

线程模型协程模型事件驱动模型 Reactor模型

第三部分：资源池化

连接池线程池协程池对象池

第四部分：异步架构

MQ 事件驱动削峰填谷异步任务

第五部分：微服务治理

注册中心服务发现配置中心负载均衡服务调用 API Gateway 链路追踪服务监控日志系统

Git创建不继承内容的新分支

Sat, 10 May 2025 19:46:01 +0800

git filter-branch 清理误提交大文件

问题概述：

在当前项目中放有大文件（超过100M）package/grpc.tar.gz,进行了git add,commit 并push, push过程中出现了错误如：

remote: error: File package/grpc.tar.gz is 973.06 MB; this exceeds GitHub's file size limit of 100.00 MB

这个问题会导致后面的提交以及push出错

git filter-branch

用 git filter-branch 删除历史中所有的 grpc.tar.gz

git filter-branch --force --index-filter \
"git rm --cached --ignore-unmatch package/grpc.tar.gz" \
--prune-empty -- lite-AlmaLinux

💡 说明：这个命令会清理当前分支里所有 commit 中的 package/grpc.tar.gz

清理垃圾对象并压缩仓库大小

git reflog expire --expire=now --all
git gc --prune=now --aggressive

然后重新 push（第一次 push 分支）

git push --set-upstream origin lite-AlmaLinux

防止此类问题

优化 .gitignore，比如

# 忽略大文件
*.tar.gz

然后

git add .gitignore
git commit -m "update: ignore tar.gz files"
git push

Jenkins 使用

Fri, 09 May 2025 20:46:01 +0800

Jenkins 使用

1. 安装Jenkins

1sudo wget -O /etc/yum.repos.d/jenkins.repo \
2 https://pkg.jenkins.io/redhat/jenkins.repo
3sudo rpm --import https://pkg.jenkins.io/redhat/jenkins.io-2023.key
4sudo yum upgrade
5# Add required dependencies for the jenkins package
6sudo yum install fontconfig java-21-openjdk
7sudo yum install jenkins

2. 启动 Jenkins

sudo systemctl enable jenkins
sudo systemctl start jenkins
# 检查状态
sudo systemctl status jenkins

正常输出应显示 active (running)。

开放防火墙（如需）

1# 开放 8080 端口（Jenkins 默认端口）
2sudo firewall-cmd --permanent --add-port=8080/tcp
3sudo firewall-cmd --reload

3. 配置Jenkins

3.1 访问 Jenkins 并完成初始化

在浏览器访问：http://<服务器IP>:8080
获取初始管理员密码：
```
1sudo cat /var/lib/jenkins/secrets/initialAdminPassword
```
复制输出的密码粘贴到网页。
安装推荐插件：选择默认插件集（包括Git、Pipeline等常用工具）。

3.2 基础配置（中文支持+优化）

切换为中文界面
1. 进入 Manage Jenkins > Plugins>Available plugins，搜索 Locale 安装 “Localization: Chinese (Simplified)” 插件。
2. 进入Manage Jenkins > Appearance，默认语言设置为 zh_CN，勾选 “Ignore browser preference”。
配置全局工具（如Git、Maven）
1. 进入 Manage Jenkins > Global Tool Configuration：
  - Git：指定路径（默认 /usr/bin/git，或通过 which git 检查）。
  - Maven：自动安装或指定现有路径。
创建管理员账户：设置用户名、密码和邮箱（避免继续使用初始密码）。
1. - Manage Jenkins（管理 Jenkins） > Security > User > Create User
2. Manage Jenkins > Security 在 Authorization（授权策略）部分选择 Matrix-based security（矩阵权限）或 Role-Based Strategy（基于角色的权限）需要安装授权策略插件

3.3 创建第一个任务（示例：执行Shell命令）

点击新建任务 > 输入任务名（如 test-job）> 选择 Freestyle project。
在构建部分添加构建步骤：
```
1echo "Hello, Jenkins!"
2date
```
点击保存 > 立即构建，在控制台输出中查看结果。

Harbor 使用

Thu, 08 May 2025 13:46:01 +0800

Harbor 使用

1. 安装Harbor

此处使用官方离线安装包

1. 下载解压

 1# 安装编译依赖
 2# 安装 Docker
 3sudo yum install -y yum-utils
 4sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
 5sudo yum install -y docker-ce docker-ce-cli containerd.io
 6sudo systemctl enable --now docker
 7
 8# 安装 Docker Compose 页面下载的话注意版本比如 验证系统架构uname -m输出x86_64
 9sudo curl -L "https://github.com/docker/compose/releases/download/v2.23.3/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
10sudo chmod +x /usr/local/bin/docker-compose
11
12# 下载Harbor并解压 (我用的离线安装包包含所有依赖镜像)
13wget https://github.com/goharbor/harbor/releases/download/v2.12.3/harbor-offline-installer-v2.12.3.tgz
14tar -xzvf harbor-offline-installer-v2.12.3.tgz
15cd harbor

2. 生成自签名证书（IP方式）

如果使用http则不需要设置

Kubernetes学习指北

Thu, 01 May 2025 11:46:01 +0800

Kubernetes学习指北

一、大纲

1. 了解基础概念

概念	说明
Pod	最小的调度单位，一个 Pod 可以包含一个或多个容器
Node	Kubernetes 集群的工作节点
Deployment	管理 Pod 的副本和升级策略
Service	用于 Pod 间通信和对外暴露
ConfigMap / Secret	配置和敏感信息管理
Volume	数据卷，用于持久化数据
Namespace	命名空间，多租户环境的逻辑隔离
Ingress	对外 HTTP/HTTPS 流量管理
kube-apiserver、kube-scheduler、kube-controller-manager	Master 组件，负责调度、管理集群

2. 核心组件及职责（必须的核心组件）

kube-apiserver （API 服务器）
- 作用：
  - 集群的大脑入口
  - 负责接收请求（kubectl、Dashboard、其他服务），然后转给 etcd 或控制器
  - 所有组件（scheduler、controller、kubelet）都通过它通信。
- 像是办事大厅，所有人（开发、运维、调度器）都必须来这里递交申请。
kube-scheduler （调度器） * 作用：
- 负责给 Pod 找宿主机。
- 根据资源情况（CPU、内存）、约束（亲和性、污点）、策略来决定 Pod 放在哪个 Node 上。 * 像是一个派单员，根据司机（Node）的空闲情况，把订单（Pod）分配给合适的人。
kube-controller-manager （控制器管理器） * 作用：
- 内部包含很多控制器（controller），比如：
  - Deployment Controller：保证副本数量正确
  - Node Controller：监控节点状态。
  - Endpoint Controller：维护 Service → Pod 的映射。
- 核心任务是：对比实际状态和期望状态，不断修正。 * 像是一个巡检员，不停检查「理想状态」和「现实情况」是不是一致，如果发现差错，就赶紧修正。
kubelet （节点代理）
- 作用：
  - 跑在每个 Node 上的代理。
  - 负责和 kube-apiserver 交互，接收“要运行哪些 Pod”。
  - 调用底层容器运行时（containerd、CRI-O、Docker）来真正启动容器。
  - 还会汇报 Pod 和 Node 的运行状态。 * 像是工地上的施工队长，接到上级（apiserver）的命令，就去调度工人（containerd）建房子（Pod）。
etcd
- 作用：
  - 分布式键值存储，保存集群的所有状态（Pod、Service、配置等）

 * 像是 工地上的施工队长，接到上级（apiserver）的命令，就去调度工人（containerd）建房子（Pod）

容器运行时（Container Runtime，如 containerd、CRI-O、DockerShim）
- 作用：
  - kubelet 本身不会直接运行容器，它要依赖运行时。
  - 真正负责创建和运行容器的底层引擎。
- 常见的有
  - containerd（最主流，K8s 默认推荐）
  - CRI-O（轻量化，专门为 K8s 服务）
  - Docker（以前常用，但现在 K8s 不直接依赖它了，而是通过 containerd） * 比喻：工人，真正搬砖盖房子（运行容器）。

3. 网络插件（通常必须）

Flannel / Calico / Cilium / Weave 等
作用：
- Kubernetes 默认不带跨节点网络，需要 CNI 插件：
- 提供 Pod 跨节点通信的网络能力。
- 在多节点集群中必须（单节点集群不一定需要）

4. 常用工具

kubectl
- 集群客户端工具，用于执行命令、部署应用。
- 从严格意义上来说不是集群必须，但管理集群时必不可少。
kubeadm
- 安装和初始化 Kubernetes 的工具。
- kubeadm init 的时候会用静态 Pod 的方式自动在 control-plane 节点上拉取(apiserver、scheduler、controller-manager、etcd)这些镜像并启动
- 不是必须，也可以手动部署 K8s（kubeadm 只是简化安装）。

5. 环境搭建

方案 A：单机多节点学习（推荐）Kubernetes学习指北之单节点集群
方案 B：一键单机集群（开发学习） Kubernetes学习指北之单节点集群

6. 学习操作命令

安装 kubectl

常用命令：

1kubectl get nodes # 查看节点
2kubectl get pods # 查看 Pod
3kubectl get svc # 查看服务
4kubectl describe pod POD # 查看 Pod 详情
5kubectl logs POD # 查看容器日志
6kubectl apply -f file.yaml # 创建资源
7kubectl delete -f file.yaml # 删除资源

7. 部署简单应用

8. 进阶

ConfigMap / Secret / Volume：学习如何管理配置和数据

Kubernetes学习指北之Kubernetes kubectl

Thu, 01 May 2025 11:46:01 +0800

Kubernetes学习指北之Kubernetes kubectl

一、 kubectl 介绍

kubectl 是 Kubernetes 官方提供的命令行工具，用于与 Kubernetes 集群交互。
它可以管理资源对象（Pods、Deployments、Services 等）、调试问题、查看日志、扩缩容、发布更新等。
本质上，它通过 Kubernetes API 与集群通信。

组件关系示意：

1kubectl <---> kube-apiserver <---> etcd / kubelet / controller-manager / scheduler

二、安装与配置

1. 安装（Linux）：

1curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
2chmod +x kubectl
3sudo mv kubectl /usr/local/bin/
4kubectl version --client

2. 配置 kubeconfig

默认路径：~/.kube/config
查看当前配置：

1kubectl config view
2kubectl config current-context

切换 namespace：

1kubectl config set-context --current --namespace=demo

三、基础命令

1. 查看集群信息

1kubectl cluster-info # 控制面信息
2kubectl version # 客户端 & 服务端版本
3kubectl api-resources # 列出可用资源
4kubectl get namespaces # 查看命名空间

2. 查看节点

1kubectl get nodes
2kubectl describe node <node-name>

四、命名空间管理

1kubectl create namespace demo
2kubectl get namespaces
3kubectl delete namespace demo

使用 -n 指定命名空间：

1kubectl get pods -n demo
2kubectl apply -f deployment.yaml -n demo

设置默认 namespace：

1kubectl config set-context --current --namespace=demo

五、Pods、Deployment、Service 管理

1. 查看资源

1kubectl get pods
2kubectl get deployments
3kubectl get svc
4kubectl get all
5kubectl describe pod <pod-name>

2. 创建 / 更新 / 删除

1kubectl apply -f <file.yaml> # 创建或更新
2kubectl delete -f <file.yaml> # 删除

3.Pod 调试

1kubectl logs <pod-name>
2kubectl exec -it <pod-name> -- /bin/bash
3kubectl port-forward <pod-name> 8080:80

4. Deployment 滚动更新与回滚

1kubectl rollout status deployment/<name>
2kubectl rollout history deployment/<name>
3kubectl rollout undo deployment/<name>
4kubectl scale deployment/<name> --replicas=3

六、ConfigMap 和 Secret

1. ConfigMap

1kubectl create configmap my-config --from-literal=key=value
2kubectl apply -f configmap.yaml
3kubectl get configmap
4kubectl describe configmap my-config

2. Secret

1kubectl create secret generic my-secret \
2 --from-literal=username=admin \
3 --from-literal=password=123456
4kubectl get secret
5kubectl describe secret my-secret

Secret 可以在 Pod 中挂载为环境变量或文件：

1env:
2- name: DB_USER
3 valueFrom:
4 secretKeyRef:
5 name: my-secret
6 key: username

七、DaemonSet 与 StatefulSet

1kubectl get daemonset -n kube-system
2kubectl describe daemonset <name> -n <namespace>
3
4kubectl get statefulset
5kubectl describe statefulset <name>

八、标签和选择器

查看标签：

1kubectl get pods --show-labels

按标签选择：

1kubectl get pods -l app=nginx
2kubectl label pod <pod-name> env=dev
3kubectl annotate pod <pod-name> key=value

九、资源调试与事件

1kubectl get events
2kubectl describe pod <pod-name>
3kubectl top node
4kubectl top pod

十、批量与导出操作

批量操作：

1kubectl apply -f ./manifests
2kubectl delete -f ./manifests

导出资源：

1kubectl get deployment <name> -o yaml > deployment.yaml
2kubectl get all -n demo -o yaml > demo-all.yaml

十一、其他操作

端口转发

1kubectl port-forward deployment/nginx 8080:80

访问 Pod 内部网络

1kubectl exec -it <pod-name> -- ping <service-name>
2kubectl exec -it <pod-name> -- curl http://<service-name>:<port>

Debug Pod

1kubectl describe pod <pod-name>
2kubectl logs <pod-name>
3kubectl exec -it <pod-name> -- bash

十二、步骤总结

比如现在有laravel/k8s/文件结构：

Kubernetes学习指北之Kubernetes YAML

Thu, 01 May 2025 11:46:01 +0800

Kubernetes学习指北之Kubernetes YAML

一、 Kubernetes YAML 的基本结构

Kubernetes 资源对象通常是 YAML 文件。每个 YAML 对象至少包含三个字段：

1apiVersion: v1  # API 版本，不同资源使用的版本不同
2kind: Pod  # 资源类型，如 Pod、Deployment、Service、Secret、ConfigMap
3metadata: # 元数据
4 name: my-pod
5 namespace: default
6spec: # 具体配置
7 containers:
8 - name: nginx
9 image: nginx:1.25

二、常用字段详解

1. apiVersion

指定资源的 API 版本。
- 常见值：
  - v1：Pod、Service、ConfigMap、Secret
  - apps/v1：Deployment、StatefulSet、DaemonSet
  - batch/v1：Job、CronJob

2. kind

资源类型
- 常见类型：
  - Pod：最小的调度单位
  - Deployment：Pod 的管理控制器，可以做副本管理和滚动升级
  - Service：服务发现与负载均衡
  - ConfigMap / Secret：配置或敏感信息管理
  - Namespace：隔离资源的逻辑空间

3. metadata

资源的名字、标签、注解等。

常见字段：

1metadata:
2name: my-app
3namespace: default
4labels:
5 app: my-app
6annotations:
7 description: "Demo app"

4. spec

资源的核心配置
不同 kind 的 spec 完全不同，Pod、Deployment、Service 的 spec 都不一样。

三、 Pod 示例

 1apiVersion: v1
 2kind: Pod
 3metadata:
 4 name: nginx-pod
 5spec:
 6 containers:
 7 - name: nginx
 8 image: nginx:1.25
 9 ports:
10 - containerPort: 80

解释：

Kubernetes学习指北之单节点集群（Master）

Thu, 01 May 2025 11:46:01 +0800

Kubernetes学习指北之单节点集群（Master）

一、单节点集群（Single Node Cluster）说明

学习和开发利器，操作简单

特点

Master 节点和 Worker 节点在同一台机器上
- kube-apiserver、kube-scheduler、kube-controller-manager、kubelet 都在同一台机器
- Pod 也在同一台机器上运行
资源有限：所有容器共享同一台机器的 CPU、内存和存储
高可用性低：Master 节点宕机，整个集群不可用
网络简单：只需一个节点，Pod 网络配置相对简单

适用场景

学习和测试 Kubernetes 核心概念
开发环境部署微服务
练习 kubectl 命令、Deployment、Service 等

优点

配置简单，一条命令就能搭建
资源占用低，不需要多台虚拟机
部署快速，便于练手

缺点

不适合生产环境
没有高可用性
无法模拟真实多节点调度

二、准备环境和工具

这里我使用的CentOS7

做一些初始化

 1# 切换 root
 2sudo -i
 3
 4# 关闭防火墙（实验环境）
 5systemctl stop firewalld
 6systemctl disable firewalld
 7
 8# 关闭 selinux
 9setenforce 0
10sed -i 's/^SELINUX=enforcing$/SELINUX=disabled/' /etc/selinux/config
11
12# 关闭 swap
13swapoff -a
14sed -i '/swap/d' /etc/fstab
15
16# 调整内核参数（K8s 网络需要）
17cat <<EOF > /etc/sysctl.d/k8s.conf
18net.bridge.bridge-nf-call-ip6tables = 1
19net.bridge.bridge-nf-call-iptables = 1
20EOF
21sysctl --system

三、安装 Docker 或 Containerd

Kubernetes 需要一个容器运行时，这里推荐 containerd（更接近 K8s 原生）。

Kubernetes学习指北之多节点集群（Multi Node Cluster）

Thu, 01 May 2025 11:46:01 +0800

Kubernetes学习指北之多节点集群（Multi Node Cluster）

一、多节点集群（Multi Node Cluster）说明

真实生产环境的缩影，可以模拟调度、高可用、跨节点通信

特点

Master 节点负责管理集群
- 多个 Worker 节点运行实际应用 Pod
- Master 负责调度、管理和监控
高可用性可扩展
- 可以增加 Worker 节点提升容量
- Master 可做 HA（高可用）部署
真实调度场景
- Kubernetes 会根据资源和策略，将 Pod 调度到不同节点
网络复杂
- Pod 网络跨节点，需要 CNI 插件（Flannel、Calico 等）支持

适用场景

生产环境部署微服务
测试调度策略、Pod 分布、Service 负载均衡
实战演练集群管理和高可用

优点

模拟真实生产环境
可以横向扩展容器数量
Master 故障可配置高可用

缺点

配置复杂，需要多台虚拟机或服务器
网络和存储管理比单节点复杂
资源占用高

二、准备环境和工具

这里使用centos7环境说明

sudo -i 建议用root账号操作

每台节点都需要执行的操作，包括 master 和 worker：系统初始化、安装和配置容器运行时（containerd）、镜像源替换等操作

这里不再赘述，参照另一篇：Kubernetes学习指北之单节点集群

三、节点准备

在每台节点上安装：

 1# 安装 kubeadm、kubelet、kubectl
 2yum install -y kubelet kubeadm kubectl
 3
 4# 启动 kubelet
 5systemctl enable --now kubelet
 6
 7# 关闭 swap（K8s 要求）
 8swapoff -a
 9sed -i '/swap/d' /etc/fstab
10
11# 配置 sysctl
12cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
13net.bridge.bridge-nf-call-ip6tables = 1
14net.bridge.bridge-nf-call-iptables = 1
15EOF
16sysctl --system

四、初始化控制平面节点（master）

在master机器执行：

GitHub 项目版本管理规范

Fri, 11 Apr 2025 20:46:01 +0800

GitHub 项目版本管理规范

Git 标签（Tags）和发布（Releases）在 GitHub 项目中定义和管理版本，通常结合 Git 标签（Tags）、发布（Releases）和语义化版本（SemVer）来实现。以下是具体方法和最佳实践：

1. 使用 Git 标签（Tags）定义版本

（1）创建版本标签

1# 创建轻量标签
2git tag v1.0.0
3
4# 创建附注标签（推荐，包含提交信息和签名）
5git tag -a v1.0.0 -m "Release version 1.0.0"
6
7# 推送标签到 GitHub
8git push origin v1.0.0

（2）语义化版本（SemVer）

版本号格式：MAJOR.MINOR.PATCH

MAJOR：不兼容的 API 变更
MINOR：向后兼容的功能新增
PATCH：向后兼容的问题修复

示例：

v1.0.0：初始稳定版本
v1.2.3：第 1 个大版本，第 2 次功能更新，第 3 次补丁

2. 通过 GitHub Releases 管理版本

（1）手动创建 Release

进入 GitHub 仓库 → Releases → Draft a new release

PHP + Redis实现订单超时

Fri, 28 Mar 2025 22:33:45 +0800

PHP + Redis实现订单超时

针对秒杀场景下的订单超时未支付自动取消，这是一个典型需求。由于秒杀需要快速释放被占用的库存，所以超时机制的设计非常关键。

一、核心思路

订单创建时：记录超时时间（如 30 分钟），将订单 ID 推入 Redis 的 Sorted Set（有序集合），score 为超时时间戳。
定时轮询：启动一个 PHP 常驻进程，每隔 1-2 秒轮询 Sorted Set，取出已超时的订单 ID。
超时处理：更新 MySQL 订单状态为“已取消”，并恢复 Redis 中的秒杀库存（如果业务要求释放库存）。
无需额外组件：纯 Redis + PHP，不依赖 RabbitMQ 的延迟队列或 RocketMQ。

二、详细设计

1. 订单表增加字段

1ALTER TABLE orders ADD COLUMN status TINYINT DEFAULT 0 COMMENT '0-待支付 1-已支付 2-已取消 3-已超时';
2ALTER TABLE orders ADD COLUMN expire_time DATETIME COMMENT '订单超时时间';

2. 创建订单时：加入超时监控

在秒杀成功、订单写入 MySQL 后（或写入 Redis 队列时），同时将订单 ID 加入 Redis Sorted Set：

PHP 实现 Redis 高并发解决方案

Fri, 28 Mar 2025 22:33:45 +0800

PHP 实现 Redis 高并发解决方案

使用 PHP 实现 Redis 在缓存加速、分布式锁和队列场景中的应用。

首先确保已安装 PHP Redis 扩展

一、缓存加速实现

1. 基本缓存操作

 1<?php
 2$redis = new Redis();
 3$redis->connect('127.0.0.1', 6379);
 4
 5// 设置缓存
 6function setCache($key, $value, $expire = 3600) {
 7 global $redis;
 8 $serialized = serialize($value);
 9 return $redis->setex($key, $expire, $serialized);
10}
11
12// 获取缓存
13function getCache($key) {
14 global $redis;
15 $serialized = $redis->get($key);
16 return $serialized ? unserialize($serialized) : false;
17}
18
19// 删除缓存
20function deleteCache($key) {
21 global $redis;
22 return $redis->del($key);
23}
24
25// 示例：用户数据缓存
26function getUser($userId) {
27 $cacheKey = "user:{$userId}";
28 $user = getCache($cacheKey);
29 
30 if ($user === false) {
31 // 模拟数据库查询
32 $user = [
33 'id' => $userId,
34 'name' => 'User ' . $userId,
35 'email' => "user{$userId}@example.com"
36 ];
37 // 写入缓存，有效期1小时
38 setCache($cacheKey, $user, 3600);
39 }
40 
41 return $user;
42}
43
44// 使用示例
45$user = getUser(123);
46print_r($user);

2. 防止缓存穿透

 1function getProduct($productId) {
 2 global $redis;
 3 $cacheKey = "product:{$productId}";
 4 $product = getCache($cacheKey);
 5 
 6 if ($product === false) {
 7 // 使用互斥锁防止缓存击穿
 8 $lockKey = "lock:product:{$productId}";
 9 $locked = $redis->set($lockKey, 1, ['nx', 'ex' => 10]);
10 
11 if ($locked) {
12 try {
13 // 模拟数据库查询
14 $product = [
15 'id' => $productId,
16 'name' => 'Product ' . $productId,
17 'price' => rand(100, 1000)
18 ];
19 
20 if (empty($product)) {
21 // 缓存空对象防止穿透，有效期5分钟
22 setCache($cacheKey, [], 300);
23 } else {
24 setCache($cacheKey, $product, 3600);
25 }
26 } finally {
27 $redis->del($lockKey);
28 }
29 } else {
30 // 等待其他进程完成缓存设置
31 usleep(500000); // 等待500ms
32 return getProduct($productId); // 重试
33 }
34 }
35 
36 return $product ?: null;
37}

二、分布式锁实现

1. 基本分布式锁

 1class RedisLock {
 2 private $redis;
 3 private $lockKey;
 4 private $identifier;
 5 private $lockTimeout;
 6 
 7 public function __construct($redis, $lockKey, $lockTimeout = 10) {
 8 $this->redis = $redis;
 9 $this->lockKey = $lockKey;
10 $this->lockTimeout = $lockTimeout;
11 $this->identifier = uniqid();
12 }
13 
14 public function acquire($waitTimeout = 5) {
15 $end = microtime(true) + $waitTimeout;
16 
17 while (microtime(true) < $end) {
18 if ($this->redis->set(
19 $this->lockKey, 
20 $this->identifier, 
21 ['nx', 'ex' => $this->lockTimeout]
22 )) {
23 return true;
24 }
25 
26 usleep(10000); // 等待10ms
27 }
28 
29 return false;
30 }
31 
32 public function release() {
33 $script = '
34 if redis.call("get", KEYS[1]) == ARGV[1] then
35 return redis.call("del", KEYS[1])
36 else
37 return 0
38 end
39 ';
40 
41 return $this->redis->eval($script, [$this->lockKey, $this->identifier], 1);
42 }
43 
44 public function __destruct() {
45 $this->release();
46 }
47}
48
49// 使用示例
50$lock = new RedisLock($redis, 'lock:order:123');
51if ($lock->acquire()) {
52 try {
53 // 执行需要加锁的操作
54 echo "Lock acquired, doing critical section...\n";
55 sleep(2);
56 } finally {
57 $lock->release();
58 }
59} else {
60 echo "Failed to acquire lock\n";
61}

2. 可重入锁实现

 1class ReentrantRedisLock extends RedisLock {
 2 private $heldCount = 0;
 3 
 4 public function acquire($waitTimeout = 5) {
 5 // 检查是否已经持有锁
 6 if ($this->heldCount > 0) {
 7 $this->heldCount++;
 8 return true;
 9 }
10 
11 $acquired = parent::acquire($waitTimeout);
12 if ($acquired) {
13 $this->heldCount = 1;
14 }
15 return $acquired;
16 }
17 
18 public function release() {
19 if ($this->heldCount > 1) {
20 $this->heldCount--;
21 return true;
22 }
23 
24 $released = parent::release();
25 if ($released) {
26 $this->heldCount = 0;
27 }
28 return $released;
29 }
30}

三、队列实现

1. 简单队列

 1// 生产者
 2function enqueue($queueName, $data) {
 3 global $redis;
 4 return $redis->lPush($queueName, json_encode($data));
 5}
 6
 7// 消费者
 8function dequeue($queueName, $timeout = 30) {
 9 global $redis;
10 $result = $redis->brPop($queueName, $timeout);
11 return $result ? json_decode($result[1], true) : null;
12}
13
14// 示例
15enqueue('email_queue', [
16 'to' => 'user@example.com',
17 'subject' => 'Welcome',
18 'body' => 'Thank you for registering'
19]);
20
21$task = dequeue('email_queue');
22if ($task) {
23 // 处理任务
24 echo "Sending email to: {$task['to']}\n";
25}

2. 延迟队列

 1function enqueueDelayed($queueName, $data, $delaySeconds) {
 2 global $redis;
 3 $score = time() + $delaySeconds;
 4 return $redis->zAdd($queueName, $score, json_encode($data));
 5}
 6
 7function processDelayedQueue($queueName) {
 8 global $redis;
 9 $now = time();
10 $items = $redis->zRangeByScore($queueName, 0, $now);
11 
12 if (!empty($items)) {
13 // 使用事务移除已处理项
14 $redis->multi();
15 foreach ($items as $item) {
16 $redis->zRem($queueName, $item);
17 }
18 $redis->exec();
19 
20 return array_map(function($item) {
21 return json_decode($item, true);
22 }, $items);
23 }
24 
25 return [];
26}
27
28// 示例
29enqueueDelayed('reminder_queue', ['user_id' => 123, 'message' => 'Pay your bill'], 60);
30
31$tasks = processDelayedQueue('reminder_queue');
32foreach ($tasks as $task) {
33 echo "Sending reminder to user {$task['user_id']}: {$task['message']}\n";
34}

3. Pub/Sub 模式

 1// 发布者
 2function publishMessage($channel, $message) {
 3 global $redis;
 4 return $redis->publish($channel, json_encode($message));
 5}
 6
 7// 订阅者
 8function subscribe($channels, $callback) {
 9 global $redis;
10 $pubsub = $redis->pSubscribe($channels);
11 
12 try {
13 foreach ($pubsub as $message) {
14 if ($message->kind === 'message') {
15 $data = json_decode($message->payload, true);
16 call_user_func($callback, $message->channel, $data);
17 }
18 }
19 } catch (Exception $e) {
20 $redis->pUnsubscribe();
21 throw $e;
22 }
23}
24
25// 示例使用
26// 在一个进程中
27publishMessage('notifications', ['user_id' => 123, 'text' => 'New message']);
28
29// 在另一个进程中
30subscribe(['notifications'], function($channel, $message) {
31 echo "Received on {$channel}: ";
32 print_r($message);
33});

四、综合应用示例 - 秒杀系统

 1class SeckillService {
 2 private $redis;
 3 private $productKey;
 4 
 5 public function __construct($redis, $productId) {
 6 $this->redis = $redis;
 7 $this->productKey = "seckill:product:{$productId}";
 8 }
 9 
10 public function initInventory($inventory) {
11 // 设置商品库存
12 $this->redis->set($this->productKey, $inventory);
13 }
14 
15 public function seckill($userId) {
16 // 使用分布式锁
17 $lock = new RedisLock($this->redis, "lock:{$this->productKey}");
18 
19 if (!$lock->acquire(1)) {
20 return ['success' => false, 'message' => '系统繁忙'];
21 }
22 
23 try {
24 // 检查库存
25 $inventory = $this->redis->get($this->productKey);
26 if ($inventory <= 0) {
27 return ['success' => false, 'message' => '已售罄'];
28 }
29 
30 // 扣减库存
31 $this->redis->decr($this->productKey);
32 
33 // 记录订单 (实际应用中应该入队列异步处理)
34 $orderId = uniqid();
35 $this->redis->hSet("seckill:orders", $orderId, json_encode([
36 'user_id' => $userId,
37 'product_key' => $this->productKey,
38 'created_at' => time()
39 ]));
40 
41 return ['success' => true, 'order_id' => $orderId];
42 } finally {
43 $lock->release();
44 }
45 }
46}
47
48// 使用示例
49$redis = new Redis();
50$redis->connect('127.0.0.1', 6379);
51
52$seckill = new SeckillService($redis, 1001);
53$seckill->initInventory(100); // 初始化100件库存
54
55// 模拟并发请求
56for ($i = 0; $i < 5; $i++) {
57 $result = $seckill->seckill(rand(1000, 9999));
58 print_r($result);
59}

五、最佳实践建议

1. 连接管理：使用连接池或持久连接

1$redis = new Redis();
2$redis->pconnect('127.0.0.1', 6379);

2. 错误处理：添加重试机制

 1function redisRetry($callback, $maxRetries = 3) {
 2 $retries = 0;
 3 while ($retries < $maxRetries) {
 4 try {
 5 return $callback();
 6 } catch (RedisException $e) {
 7 $retries++;
 8 if ($retries >= $maxRetries) {
 9 throw $e;
10 }
11 usleep(100000 * $retries); // 指数退避
12 }
13 }
14}

3. 性能优化：使用管道(pipeline)

1$pipe = $redis->pipeline();
2$pipe->set('key1', 'value1');
3$pipe->set('key2', 'value2');
4$pipe->incr('counter');
5$pipe->expire('key1', 60);
6$results = $pipe->exec();

4. Lua脚本：保证原子性

1$script = '
2 local current = redis.call("GET", KEYS[1])
3 if current == ARGV[1] then
4 return redis.call("INCRBY", KEYS[1], ARGV[2])
5 else
6 return nil
7 end
8';
9$result = $redis->eval($script, ['counter', 'expected_value', 'increment'], 1);

内存溢出

Fri, 28 Mar 2025 22:33:45 +0800

内存溢出

一、什么是内存溢出

内存溢出（Memory Overflow / Out of Memory, OOM）指程序在申请内存时，没有足够的空间供其使用。在 PHP 中，通常表现为：

脚本超出 memory_limit 设置（默认 128M），抛出 Fatal error: Allowed memory size of X bytes exhausted
系统级 OOM：PHP 进程消耗了操作系统分配的所有内存，被内核强制杀死（常见于常驻进程如 Swoole、Workerman）

二、如何排查内存溢出？

1. 查看错误日志

PHP 错误日志中会直接记录内存耗尽的位置和当前内存使用量。
系统日志（/var/log/messages 或 journalctl -xe）可看到是否因 OOM Killer 杀死了进程。

2. 使用内存分析工具

Xdebug 的追踪功能
```
1xdebug.profiler_enable = 1
2xdebug.profiler_output_dir = /tmp
```
生成 cachegrind 文件，用 QCacheGrind 或 WebGrind 分析，查看哪个函数/行消耗了大量内存。

Xdebug 的垃圾回收统计

1xdebug_debug_zstd('your_var'); // 显示变量内存占用（需扩展）

使用 memory_get_usage() / memory_get_peak_usage()

在代码关键位置打印内存，定位峰值点：

1echo memory_get_usage() . " bytes\n";
2// 执行一段代码
3echo memory_get_peak_usage() . " bytes\n";

Valgrind（用于 CLI 或常驻进程）

线程安全

Fri, 28 Mar 2025 22:33:45 +0800

内存溢出

PHP本身（无论是PHP-FPM还是Swoole）并不支持多线程。

线程安全，在PHP的世界里通常指以下两种情况，我们需要分开讨论：

PHP解释器自身的线程安全：指PHP作为C语言编写的程序，当其被嵌入到多线程的Web服务器（如Apache的worker MPM）中时，多个线程能否安全地共用一个PHP解释器实例。
PHP应用代码的并发安全：指我们的业务代码在同时处理多个请求时，如何避免共享数据的冲突。这在Swoole这类常驻内存的进程中尤其重要。

下面分别介绍：

1. PHP解释器的线程安全（Zend线程安全，ZTS）

这是PHP源码编译时的一个选项（–enable-zts）。

问题背景：PHP有很多全局变量（例如存放已加载扩展列表的变量）。在单线程环境下没问题，但在多线程环境下，线程A修改这个全局变量时，线程B可能正在读取，导致崩溃。
解决方案（ZTS）：PHP通过TSRM（线程安全资源管理器） 为每个线程分配了一个独立的“全局变量副本”。线程A修改自己的副本，不会影响线程B。
- 对开发者的影响：
- PHP-FPM（Nginx+PHP-FPM）：使用的是多进程模型，一个进程只处理一个请求。进程间内存天然隔离，不存在线程安全问题，因此通常编译非线程安全（NTS） 版本，性能更高。
- Apache + worker MPM：Apache使用多线程模型，此时PHP必须编译为ZTS版本才能稳定运行。
- Swoole：Swoole本身是多进程模型。每个Worker进程是单线程的，事件循环和协程都在这个主线程中运行。因此，PHP的ZTS在Swoole环境下并非必需，Swoole官网也推荐使用NTS版本的PHP。

小结：对于绝大多数PHP开发者（使用PHP-FPM或Swoole），无需关心PHP底层的ZTS。你基本不会直接编写相关代码，这是扩展开发者和PHP本身需要解决的问题。

2. 应用代码的并发安全：Swoole常驻内存下的挑战

在传统的PHP-FPM中，每个请求结束后，所有变量都被销毁，下一个请求是“干净”的，所以不存在并发安全问题。

但在Swoole中，Worker进程常驻内存，多个协程或请求会并发地操作进程内的同一个全局变量、静态变量或资源（如Redis连接），这就会引发经典的竞态条件（Race Condition）。

典型问题场景：

1// 一个 Worker 进程内的全局计数器
2$globalCounter = 0;
3
4// 协程A 和 协程B 同时执行这段代码
5$globalCounter++; // 这不是原子操作！
6echo $globalCounter;

两个协程同时读取0，分别加1，然后写回。你期望输出2，但实际可能输出1。这就是并发问题。

如何保证Swoole下的并发安全？

Swoole提供了几种机制来解决这个问题：

方案一：使用原子计数器（Atomic）

Swoole提供的Swoole\Atomic是一个基于CPU原子操作的计数器，操作是线程/协程安全的。

1$atomic = new Swoole\Atomic(0);
2
3// 在任意协程中安全地增加
4$atomic->add(); // 无锁，高性能
5echo $atomic->get();

方案二：使用锁（Lock）

对于复杂的共享数据读写（不只是计数），可以使用各种锁。

协程锁（Swoole\Lock 或 Channel）：推荐，只在协程级别阻塞。

1$lock = new Swoole\Lock(Swoole\Lock::SPIN); // 自旋锁
2$lock->lock();
3// ... 操作共享数据，如读写一个数组 ...
4$lock->unlock();

文件锁：适用于跨进程的互斥。

方案三：利用协程的Channel

Channel可以看作一个协程安全的队列。你可以利用它来实现生产者-消费者模式，或者作为互斥令牌（一次只放一个令牌进去，谁拿到令牌谁执行）。

PHP + Redis秒杀场景

Fri, 28 Mar 2025 22:30:45 +0800

PHP + Redis秒杀场景

在电商秒杀等高并发场景中，Redis 凭借其内存操作和原子性特性，成为库存扣减的核心组件。

下面以 PHP + Redis 为例，给出一个企业级秒杀库存设计方案示例，重点解决超卖、热点 Key、重复下单和流量冲击等问题。

一、核心思路

预加载库存：秒杀活动开始前，将商品库存从 MySQL 同步到 Redis（使用 SET 或 HMSET）。
原子扣减：使用 Redis Lua 脚本（或 DECR + 校验）保证扣减与校验的原子性，杜绝超卖。
异步落库：扣减成功后，将用户 ID、商品 ID 推入消息队列（如 Redis Stream / List），后台进程消费并创建订单、扣减数据库库存。
限流 + 防重：通过令牌桶或滑动窗口限制用户访问频率，通过 Redis 记录用户抢购状态防止同一用户重复下单。

二、详细步骤与代码实现

1. 活动开始前：初始化库存

1// 假设商品ID=1001，秒杀库存=100
2$redis->set('seckill:stock:1001', 100);
3$redis->set('seckill:closed:1001', 0); // 0-未结束，1-已结束

2. 抢购接口核心：Lua 脚本原子扣减

 1$lua = <<<LUA
 2local stock_key = KEYS[1]
 3local user_key = KEYS[2] -- 用于记录已抢购用户
 4local user_id = ARGV[1]
 5local closed_key = KEYS[3]
 6
 7-- 检查活动是否已结束
 8if redis.call('get', closed_key) == '1' then
 9 return -2 -- 活动结束
10end
11
12-- 检查用户是否已抢购过（防重复）
13if redis.call('sismember', user_key, user_id) == 1 then
14 return -1 -- 重复抢购
15end
16
17-- 扣减库存
18local stock = redis.call('decr', stock_key)
19if stock < 0 then
20 -- 库存不足，回滚
21 redis.call('incr', stock_key)
22 return 0 -- 无库存
23end
24
25-- 记录用户
26redis.call('sadd', user_key, user_id)
27-- 返回当前剩余库存（正数代表成功，0代表刚好扣完）
28return stock
29LUA;
30
31$result = $redis->eval($lua, [
32 'seckill:stock:1001',
33 'seckill:users:1001',
34 'seckill:closed:1001',
35 $userId
36], 3); // 3个KEYS
37
38if ($result === -2) {
39 // 活动已结束
40} elseif ($result === -1) {
41 // 用户已抢过
42} elseif ($result === 0) {
43 // 库存不足
44} else {
45 // 扣减成功，剩余库存 $result
46 // 将成功信息推入消息队列（异步创建订单）
47 $redis->lpush('seckill:orders', json_encode([
48 'user_id' => $userId,
49 'goods_id' => 1001,
50 'stock' => $result
51 ]));
52}

3. 异步消费队列（如使用 Redis List + PHP 常驻进程）

 1// consumer.php 常驻进程（可用 Swoole / Supervisor 管理）
 2while (true) {
 3 $data = $redis->brpop('seckill:orders', 2); // 超时2秒
 4 if ($data) {
 5 $order = json_decode($data[1], true);
 6 // 开启MySQL事务
 7 $db->begin();
 8 try {
 9 // 再次检查数据库库存（防止Redis数据不一致）
10 $stock = $db->query("SELECT stock FROM goods WHERE id={$order['goods_id']} FOR UPDATE");
11 if ($stock > 0) {
12 $db->query("UPDATE goods SET stock = stock - 1 WHERE id={$order['goods_id']} AND stock>0");
13 // 创建订单...
14 $db->commit();
15 } else {
16 $db->rollback();
17 // 库存不足，需回滚Redis中的用户记录（补偿）
18 $redis->srem('seckill:users:1001', $order['user_id']);
19 $redis->incr('seckill:stock:1001');
20 }
21 } catch (Exception $e) {
22 $db->rollback();
23 // 记录异常，重试或人工介入
24 }
25 }
26}

4. 限流（防止刷单）

使用 Redis 的滑动窗口或令牌桶。示例：基于用户 IP 的 QPS 限制（每秒最多5次请求）

Mysql窗口函数

Thu, 20 Feb 2025 20:46:01 +0800

Mysql窗口函数

一、什么是窗口函数？

窗口函数是一种在查询结果的"窗口"上执行计算的函数，它不会像常规聚合函数那样将多行合并为一行，而是为每一行返回一个值，同时保持原始行数不变。

基本语法

1<窗口函数>(<参数>) OVER (
2[PARTITION BY <分区表达式>]
3[ORDER BY <排序表达式> [ASC | DESC]]
4[ROWS/RANGE <窗口范围>]
5)

‌<窗口函数>‌：可以是聚合函数（如SUM、AVG）或专用函数（如ROW_NUMBER、RANK）。‌‌
‌OVER()‌：必需子句，定义窗口框架。‌‌
‌PARTITION BY‌：可选，用于分组数据；若省略，窗口覆盖整个结果集。
‌ORDER BY‌：可选，指定窗口内行的排序顺序。‌‌
‌窗口范围‌：可选，默认ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW。‌‌

二、准备测试数据

 1-- 创建销售数据表
 2CREATE TABLE sales (
 3 sale_id INT PRIMARY KEY,
 4 salesperson VARCHAR(50),
 5 region VARCHAR(50),
 6 sale_date DATE,
 7 amount DECIMAL(10,2)
 8);
 9
10INSERT INTO sales VALUES
11(1, '张三', '北京', '2023-01-15', 5000),
12(2, '李四', '上海', '2023-01-16', 8000),
13(3, '王五', '北京', '2023-01-17', 6000),
14(4, '张三', '北京', '2023-02-01', 7000),
15(5, '李四', '上海', '2023-02-02', 9000),
16(6, '赵六', '广州', '2023-02-03', 4000),
17(7, '王五', '北京', '2023-02-04', 5500),
18(8, '张三', '北京', '2023-03-01', 8500);
19
20-- 创建员工薪资表
21CREATE TABLE employee_salary (
22 emp_id INT,
23 name VARCHAR(50),
24 department VARCHAR(50),
25 salary DECIMAL(10,2),
26 hire_date DATE
27);
28
29INSERT INTO employee_salary VALUES
30(1, '张三', '技术部', 15000, '2020-01-15'),
31(2, '李四', '技术部', 12000, '2021-03-20'),
32(3, '王五', '销售部', 8000, '2022-06-10'),
33(4, '赵六', '销售部', 7500, '2022-08-05'),
34(5, '钱七', '技术部', 13000, '2020-11-30'),
35(6, '孙八', '人事部', 9000, '2021-09-15'),
36(7, '周九', '技术部', 16000, '2019-05-20');

1. 排名函数

ROW_NUMBER()

1SELECT 
2 salesperson,
3 region,
4 amount,
5 ROW_NUMBER() OVER (PARTITION BY region ORDER BY amount DESC) as row_num
6FROM sales;

结果：为每个地区的销售按金额降序分配唯一序号

MyCat实现Mysql分库分表

Tue, 18 Feb 2025 20:33:45 +0800

Mysql分库分表和主从复制

MyCat 实现分库分表

MySQL 的分库分表解决方案通常依赖于中间件来实现水平扩展。常见的中间件有以下几种

MyCat
ShardingSphere
TDDL (Taobao Distributed Data Layer)
Cobar
Vitess

MyCat 是一款开源的数据库中间件，支持 MySQL 数据库的分库分表功能。

使用 MyCat 实现分库分表的过程包括多个步骤，涉及配置 MyCat 和数据库的分片策略，路由规则等。下面通过一个实际案例来详细解释 MyCat 的实现原理、方式和步骤。

案例背景

假设你有一个电商系统，包含一个 orders 表，记录用户的订单信息。随着数据量的增长，单一数据库难以满足性能需求，因此需要进行分库分表。

实现原理

MyCat 是一种数据库中间件，支持分库分表。它的原理是通过代理 MySQL 连接，将 SQL 请求转发到实际的数据库实例上。MyCat 会根据预定义的路由规则（如分片策略）来决定将查询请求路由到哪个数据库或表。

MyCat 的 分库分表原理如下：

分库：将数据按照某种规则分配到多个数据库实例中。例如，按用户的 ID 来分库。

分表：将一个大表拆分成多个小表，避免单表的数据过大导致查询性能下降。例如，可以按时间范围或数据量来分表。

实现方式

MyCat 的实现方式主要通过配置分片规则来实现分库分表。配置内容包括：

数据源配置：定义数据库实例。
分片规则配置：指定哪些字段用于分片，如何分片（按范围、按哈希等）。
路由规则配置：根据 SQL 查询的条件来路由请求到不同的数据库或表。

实现步骤

安装并启动 MyCat
1. 下载 MyCat 安装包并解压。
2. 配置 MyCat 启动脚本，启动 MyCat。
```
1cd MyCat
2./bin/start.sh
```
配置数据源在 MyCat 的配置文件 conf/context.xml 中，定义数据源。假设我们有两个 MySQL 实例 db1 和 db2，分别存储不同的 orders 表。

Linux grep命令

Mon, 17 Feb 2025 22:33:45 +0800

Linux grep命令

全拼:Global search REgular expression and Print out the line.

作用:文本搜索工具，根据用户指定的“模式（过滤条件)”对目标文本逐行进行匹配检查，打印匹配到的行.

模式:由正则表达式的元字符及文本字符所编写出的过滤条件﹔

grep的语法格式：

grep -option（参数） ‘word’（关键词） file（文本文件）；

grep常用参数： –color=auto 或者 –color：表示对匹配到的文本着色显示

-i：在搜索的时候忽略大小写

-n：显示结果所在行号

-c：统计匹配到的行数，注意，是匹配到的总行数，不是匹配到的次数

-o：只显示符合条件的字符串，但是不整行显示，每个符合条件的字符串单独显示一行

-v：输出不带关键字的行（反向查询，反向匹配）

-w：匹配整个单词，如果是字符串中包含这个单词，则不作匹配

-Ax：在输出的时候包含结果所在行之后的指定行数，这里指之后的x行，A：after

-Bx：在输出的时候包含结果所在行之前的指定行数，这里指之前的x行，B：before

-Cx：在输出的时候包含结果所在行之前和之后的指定行数，这里指之前和之后的x行，C：context

-e：实现多个选项的匹配，逻辑or关系

-q：静默模式，不输出任何信息，当我们只关心有没有匹配到，却不关心匹配到什么内容时，我们可以使用此命令，然后，使用”echo $?”查看是否匹配到，0表示匹配到，1表示没有匹配到。

-P：表示使用兼容perl的正则引擎。

-E：使用扩展正则表达式，而不是基本正则表达式，在使用”-E”选项时，相当于使用egrep。

示例

 1# 从test.txt文本文件中搜索包含”L”字符的行
 2grep "L" test.txt 
 3
 4# 输出以 I 开头的行(不区分大小写)
 5grep "^i" test.txt -i -n -o
 6
 7# 可以使用”--color”选项，高亮显示行中的关键字
 8grep "L" test.txt -i -n --color
 9
10# -B”选项，显示符合条件的行之前的行，"B"有before之意
11grep "L" test.txt -i -n --color -B2
12
13# "-A"有After之意，"-A"代表显示符合条件的行的同时，还要显示之后的行，"-A3"表示同时显示符合条件的行之后的3行。
14grep "L" test.txt -i -n --color -A2
15
16# "-C"选项表示在显示符合条件的行的同时，也会显示其前后的行
17grep "L" test.txt -i -n --color -C2
18
19# 利用grep判断文本中是否存在某个字符串在写脚本时，你可能只是想要利用grep判断文本中是否存在某个字符串，你只关心有没有匹配到，而不关心匹配到的内容，你只关心有，或者没有，这时，我们可以使用grep的静默模式，示例如下
20grep "L" test.txt -i -n --color -C2
21grep "L" test.txt -i -n --color -C2 -q
22echo $?
23
24# 使用”-c”选项即可只统计符合条件的总行数，而不会打印出行。 显示出文章中有多少行有a或b或c
25grep "^i" test.txt -i -n -o -c
26
27# 输出以.结尾的行
28grep "\.$" test.txt -n -o
29
30# 不不打印以.结尾的行
31grep "\.$" test.txt -n -v
32
33# ^$(代表空行的意思)组合符. 如：找出文件的空行, 以及行号
34grep "^$" test.txt -n
35
36# "."点表示任意一个字符, 有且只有一个, 不包含空行
37grep "." test.txt -n
38
39# "*"表示找出前一个字符0次或一次以上. 如：找出文件中i出现0次或多次的行和行号
40grep "i*" test.txt -n
41
42# ".*"表示所有内容, 包括空行
43grep ".*" test.txt -n -o
44
45# ^.*t符 (含义: 以任意内容开头, 直到t结束)
46grep "^.*t" test.txt -n -o
47
48# 中括号表达式,[abc]表示匹配中括号中任意一个字符 如：匹配abc字符中的任意一个,得到它的行数和行号
49grep "[abc]" test.txt -n -o
50
51# [^abc]或[^a-c]这样的命令, "^"符号在中括号中第一位表示排除, 就是排除字符a,b,c
52grep "[^abc]" test.txt -n
53
54# +号表示匹配前一个字符1一次或多次,必须使用grep -E扩展正则
55grep -E "a+" test.txt -n -o
56
57# ?符 匹配前一个字符0次或1次 如 找出文件中包含ji或者joi的行
58grep -E "jo?i" test.txt -n -o
59
60# 竖线|在正则中是或者的意思 ，如 找出文件中包含j或者i的行, 不区分大小写(-i)
61grep -E "j|i" test.txt -n -i
62
63# ()小括号 将一个或多个字符捆绑在一起, 当作一个整体进行处理
64grep -E "(ji)|(joi)" test.txt -n -i -o
65
66# {n,m}匹配次数
67# {n,m}:匹配前一个字符至少n次, 最多m次
68# {n,}: 匹配前一个字符至少n次, 没有上限
69# {,m}: 匹配前一个字符最多m次,可以没有
70# 重复前一个字符各种次数, 可以通过-o参数显示明确的匹配过程
71grep -E "a{1,3}" test.txt -o

Linux sed命令

Mon, 17 Feb 2025 22:33:45 +0800

Linux sed命令

全拼:Stream EDitor（流编辑器）

Linux sed 命令是利用脚本来处理文本文件，sed 可依照脚本的指令来处理、编辑文本文件。Sed 主要用来自动编辑一个或多个文件、简化对文件的反复操作、编写转换程序等。

sed 的运行模式

当处理数据时，Sed 从输入源一次读入一行，并将它保存到所谓的模式空间pattern space中。所有 Sed 的变换都发生在模式空间。变换都是由命令行上或外部 Sed 脚本文件提供的单字母命令来描述的。大多数 Sed 命令都可以由一个地址或一个地址范围作为前导来限制它们的作用范围。

sed的相关选项

-n, –quiet, –silent 取消自动打印模式空间

-e 脚本, –expression=脚本添加“脚本”到程序的运行列表

-f 脚本文件, –file=脚本文件添加“脚本文件”到程序的运行列表

–follow-symlinks 直接修改文件时跟随软链接

-i[扩展名], –in-place[=扩展名] 直接修改文件(如果指定扩展名就备份文件)

-l N, –line-length=N 指定“l”命令的换行期望长度

–posix 关闭所有 GNU 扩展

-r, –regexp-extended 在脚本中使用扩展正则表达式

-s, –separate 将输入文件视为各个独立的文件而不是一个长的连续输入

-u, –unbuffered 从输入文件读取最少的数据，更频繁的刷新输出

–help 打印帮助并退出

–version 输出版本信息并退出

-a ∶新增， a 的后面可以接字串，而这些字串会在新的一行出现(目前的下一行)～

-c ∶取代， c 的后面可以接字串，这些字串可以取代 n1,n2 之间的行！

-d ∶删除，因为是删除啊，所以 d 后面通常不接任何咚咚；

Linux 进程管理命令

Mon, 17 Feb 2025 22:33:45 +0800

Linux ps命令

ps 命令是 Process Status 的缩写，是一个命令行实用程序，用于显示或查看与Linux系统中运行的进程相关的信息。

命令原理：ps 是通过读取虚拟文件：/proc 拿到进程数据的，不需要给 ps 设置任何的权限就可以运行。

在Linux中，每个进程都有多个ID来关联它，包括：

Process ID (PID)，即进程ID

这是标识进程的任意数字。每个进程都有一个唯一的ID，但是在进程退出并且父进程检索了退出状态之后，进程ID将被释放，供新进程重用。
Parent Process ID (PPID)，即父进程ID

如果父进程在子进程退出之前退出，则子进程的PPID将更改为另一个进程。
Process Group ID (PGID)

这是进程组leader的PID。如果PID == PGID，则此进程是进程组领导。
Session ID (SID)

这是会话领导者的PID。如果PID == SID，则此进程为会话领导进程。

会话和进程组只是将一些相关的进程作为一个单元来对待的方法。一个进程组的所有成员总是属于同一个会话，但是一个会话可以有多个进程组。

通常，shell将是会话领导者，该shell执行的每个管道将是一个进程组。这是为了在shell退出时很容易杀死它的子进程。

grep -option（参数） ‘word’（关键词） file（文本文件）；

ps命令选项：

简单筛选

a ：选择所有进程（BSD-Style）。

-A ：选择所有进程，与 -e 等同（标准格式）。

-a ：选择除 session 领导者和没有与终端关联的进程之外的所有进程。

-d ：选择除了 session leader 的所有进程。

–deselect ：选择除满足指定条件之外的所有进程，即反选，与 -N 等同。

-e ：选择所有进程，与 -A 等同。

-N ：与 –deselect 等同。

单篇加密：保护你的私有内容

Mon, 10 Feb 2025 00:00:00 +0000

Period 主题内置单篇加密功能：正文加密后只显示密文，读者输入密码由浏览器端解密展示。适合私密内容、私人笔记等场景。

特性

真加密：构建产物与源码中均无明文，只有 AES-256-GCM 密文；
零依赖前端：解密用浏览器原生 Web Crypto，无第三方库；
算法：PBKDF2-SHA256（10 万次迭代）派生密钥 + AES-256-GCM 加密；
不影响 SEO：密文块自动加 data-pagefind-ignore，标题/描述照常索引；
不影响评论：Giscus 在正文外，加密与评论互不干扰。

快速开始（推荐：文章内标记 + 一键加密）

1. 在文章里直接写明文，用标记包裹

写作时，在需要加密的位置用 protect 标记包裹明文（Markdown 编辑器友好，所见即所得）：

1可见正文……
2
3{{% protect %}}
4这是要加密的明文内容，直接写在这里
5{{% /protect %}}
6
7可见正文……

2. 发布前原地加密

1cd themes/period
2node scripts/encrypt.mjs --lock content/post/xxx.md # 交互输入密码，原地替换为密文
3node scripts/encrypt.mjs --lock content/post/xxx.md 密码 # 或直接给密码
4node scripts/encrypt.mjs --lock content/post/ # 支持目录批量

执行后，文件里的明文标记被替换为密文 shortcode（提交到仓库的是密文，无明文）。

3. 修改已加密文章

1node scripts/encrypt.mjs --unlock content/post/xxx.md # 密文还原为明文标记，改完再 --lock

其他用法（命令行管道，简单场景）

1node scripts/encrypt.mjs "密码" < plain.txt > cipher.txt # 加密文本片段
2node scripts/encrypt.mjs --decrypt "密码" < cipher.txt # 解密验证

git pre-commit 钩子（可选，防明文泄漏）

将 themes/period/scripts/pre-commit.example 复制到 .git/hooks/pre-commit：提交时若检测到 content/ 下仍有未加密的明文标记，会阻止提交，提醒先跑 --lock。（本仓库的 .git/hooks/pre-commit 已启用。）

Chrome 插件开发实战：一键把当前页面存为 Markdown

Wed, 22 Jan 2025 00:00:00 +0800

从一行代码到 Chrome Web Store 上架。本文用一个具体例子走通 Chrome 插件开发完整流程：manifest.json、content script、popup 通信、文件下载、用户偏好存储、上架审核。

为什么要做这个插件

我经常在浏览器里看技术文章。看到好的想存到 Obsidian，复制粘贴格式全乱。打开"另存为"保存下来是带广告、导航栏、侧边栏的 HTML。想找一个干净的 Markdown 版本，要么没有，要么是闭源插件不敢装。

装个现成插件不放心。写个 userscript 分发麻烦。干脆自己写一个。

这是个"改造已有网站"的小工具，Chrome 插件是最合适的形态。如果你还不确定插件是不是解决你问题的最佳方案，可以先看《Chrome 插件开发》。

我们要做的版本

最终交付一个能本地转、能下载、能存用户偏好的插件：

点击工具栏图标，弹出一个 popup
popup 上一个按钮"保存为 Markdown"
点击后，把当前页面转成干净的 Markdown，触发下载
几个 checkbox 让用户自定义：是否包含图片、是否包含代码块、文件名格式

这个版本足够简单，又覆盖了插件开发的核心链路：content script、popup 通信、文件下载、用户偏好存储。

准备工作

需要：

Chrome 浏览器（任何最近版本都行）
一个空文件夹
一个文本编辑器

不需要：

Node.js
npm
任何前端框架
任何构建工具

整个项目就是几个静态文件，加一个第三方库。装一个依赖就要搭构建，搭构建就要讲 webpack / vite / TypeScript，整个文章会跑偏。

第三方库：Turndown.js

用来把 HTML 转成 Markdown。同类插件 80% 在用，成熟稳定。

下载地址：https://unpkg.com/turndown@7.2.0/dist/turndown.js

下载下来保存到 vendor/turndown.js（自己创建 vendor 目录）。

项目结构：

 1markdown-saver/
 2├── manifest.json
 3├── content.js
 4├── popup.html
 5├── popup.js
 6├── icons/
 7│ ├── icon16.png
 8│ ├── icon32.png
 9│ ├── icon48.png
10│ └── icon128.png
11└── vendor/
12 └── turndown.js

图标先随便找 4 张占位图（每个尺寸一张），后面会讲商店要求。

Period 主题简介与快速开始

Wed, 15 Jan 2025 00:00:00 +0000

Period 是把 Compete Themes 的 WordPress 博客主题复刻到 Hugo 的静态站点主题：深色页眉、浅灰背景、白色卡片，内容区上叠压住页眉下沿是它的标志性视觉。配色、字体、间距、断点均逐值移植自原版 v1.750 的 style.css，视觉相似度目标 ≥90%。

特性清单

特性具体内容

布局 1300px 最大宽度；≥900px 双栏（主栏 62.5% + 侧栏 34.375%），layout = "right"/"left" 切换

响应式 600 / 900 / 1100px 三档断点；移动端汉堡菜单 + 子菜单手风琴

零依赖 JS 菜单/搜索/返回顶部/代码复制均为原生脚本，无 jQuery

代码高亮 Hugo Chroma（Atom One Dark），行号 + 一键复制

SEO robots 索引控制、Open Graph、Twitter Cards、JSON-LD（Organization/BreadcrumbList/BlogPosting）

搜索 Pagefind 全文搜索（构建后 npx pagefind --site public）

评论 Giscus / Utterances（默认关闭，配置即用）

表单

Formspree / Netlify Forms（






 
 联系表单暂未启用，你可以在评论留言或者通过邮件与我交流。
 


Chrome 插件开发
Wed, 15 Jan 2025 00:00:00 +0800
从一个真实问题开始
我经常在浏览器里看技术文章。看到好的想存到 Obsidian，复制粘贴格式全乱。打开"另存为"保存下来是带广告、导航栏、侧边栏的 HTML。想找一个干净的 Markdown 版本，要么没有，要么是闭源插件不敢用。
于是我开始想：我能不能自己写一个？
这是个典型的"想动手"时刻。但真正动手之前，有几个更前置的问题需要想清楚：

Chrome 插件到底是什么？和 userscript、网页工具、PWA 差在哪？
我想做的这个事，到底该用哪种形态？
学 Chrome 插件的"投资回报"如何？是一次性投入还是持续折腾？

写这篇文章的目的，是在你打开 manifest.json 之前，帮你想清楚这三个问题。
插件是什么
先把"插件"这个词拆开看。
Chrome 插件（Chrome Extension），也叫浏览器扩展，本质上是一段运行在 Chrome 浏览器里的代码。它能访问一些普通网页拿不到的 API，比如读取当前标签页的 URL、修改请求头、在用户点击工具栏图标时弹出一个小页面。
可以把它理解为：

插件 = 对浏览器的扩展能力 + 对已有网站的增强能力

注意两个关键词：“对浏览器” 和 “对已有网站”。这两个词决定了插件能做什么、不能做什么。
对浏览器意味着插件能拿到浏览器层面的能力，比如：

操作标签页（关闭、新建、切换）
读取和修改浏览器历史
拦截和修改网络请求
在工具栏添加图标
监听键盘快捷键

对已有网站意味着插件的核心战场是"改造现有网站"，比如：

给维基百科加一个深色模式
给 GitHub 加一个一键复制文件链接的按钮
给掘金、知乎、CSDN 屏蔽某些干扰元素

插件能做什么、不能做什么
能做的：

改造已有网站（修改 DOM、注入脚本）
提供一个常驻工具栏入口（点击图标触发动作）
跨页面保存数据（用户的偏好、笔记、历史）
监听浏览器事件（标签页变化、下载事件）

不能做（或做起来很费劲）：

完全独立的产品（需要服务端配合的复杂功能）
移动端体验（Chrome 插件不适用于移动浏览器）
高性能要求的事（不适合跑复杂的计算任务）
跨浏览器一致体验（Firefox、Edge、Safari 各有差异）

什么时候该用插件
给几个真实场景，帮你判断。
适合用插件的场景：

改造已有网站：给某个你不喜欢的网站加功能或去干扰
跨页面工具：复制当前页面内容、抓取数据、自动填表
浏览器层的小工具：标签页管理、下载管理、截图、翻译
给开发者自己用：调试、API 测试、页面抓取

不适合用插件的场景：


视频内容处理工具分享之 VideoLingo
Sat, 11 Jan 2025 20:46:01 +0800
视频内容处理工具分享之 VideoLingo
VideoLingo 是目前处理视频技术内容最强的开源工具之一。它的核心优势在于不仅仅是“语音转文字”，它还会利用 AI（如 DeepSeek 或 GPT）对内容进行 NLP 断句（让文字像书一样好读）并生成总结。
一、安装方式：
1. 最简单“一键整合包”（适合 Windows 用户）
如果你不想折腾 Python 环境，可以寻找社区维护的一键整合包（如 GitHub 上的 VideoLingo-OneClick 项目）。


下载：从网盘或 GitHub Releases 下载解压包。


启动：双击 启动软件.exe 或 一键启动.bat。


配置：它会弹出一个网页界面。在左侧填入你的 LLM API Key（支持 DeepSeek、OpenAI 等，技术总结必须用到大模型）。


2. 标准安装
如果你想体验最新功能，建议通过源码安装：
1. 准备环境


安装 Python 3.10（必须是这个版本）。


安装 FFmpeg（参考上一个回答）。


如果你有 NVIDIA 显卡，建议安装 CUDA Toolkit 12.6 以获得加速。


2. 源码下载与安装 在终端（Terminal/CMD）中执行：
 1# 1. 克隆项目
 2git clone https://github.com/Huanshere/VideoLingo.git
 3cd VideoLingo
 4
 5# 2. 安装依赖（需要 python=3.10 建议使用 conda)
 6conda create -n videolingo python=3.10.0 -y
 7conda activate videolingo
 8
 9# 3. 运行安装脚本
10python install.py
3. 启动应用
1streamlit run st.py
3. docker安装
1# 拉取镜像
2docker pull rqlove/videolingo:latest
3
4# 启动容器（CPU 模式 去掉--gpus all）
5docker run -d -p 8501:8501 --name videolingo rqlove/videolingo:latest
在浏览器输入 http://localhost:8501


视频下载工具分享之 yt-dlp
Fri, 10 Jan 2025 20:46:01 +0800
视频下载工具分享之 yt-dlp
yt-dlp 是一个功能强大的开源命令行视频下载工具，它本身不需要像常规软件那样运行安装程序。
一、安装方式：
1. Windows 用户（最简单方法）


下载 exe 文件：前往 yt-dlp GitHub 释放页，找到并下载 yt-dlp.exe。


创建文件夹：建议在 C 盘或 D 盘根目录创建一个文件夹（如 D:\ytdlp），将下载好的 .exe 放进去。


安装 FFmpeg (重要依赖)：为了能下载高画质视频并自动合并音视频，你必须下载 FFmpeg。

在同一目录下放入 ffmpeg.exe。



添加到 PATH (可选但建议)：将该文件夹路径添加到系统的“环境变量”中，这样你就可以在任何地方的终端直接输入 yt-dlp 使用它了。


2. macOS 用户
推荐使用 Homebrew 快速安装：

打开终端（Terminal），输入：
1brew install yt-dlp ffmpeg


3. Linux 用户
大多数发行版可以直接通过包管理器安装：


Ubuntu/Debian: sudo apt install yt-dlp


Arch Linux: sudo pacman -S yt-dlp 或者直接下载二进制文件：
1sudo wget https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -O /usr/local/bin/yt-dlp
2sudo chmod a+rx /usr/local/bin/yt-dlp


4. 通用安装方式 (Python 用户)
如果你电脑里装了 Python，可以直接用 pip 安装：


安装与配置指南
Wed, 08 Jan 2025 00:00:00 +0000
安装
把主题放入 Hugo 站点的 themes/ 目录，然后在 config.toml 声明：
1theme = "period"
配置从模板开始最省事：把 config.toml.example 复制为 config.toml 再改。
核心参数速查
 1[params]
 2 tagline = "记录设计、代码与生活的个人博客。" # 页眉标语
 3 description = "站点描述" # 首页 meta/OG/JSON-LD
 4 author = "Leanku" # 默认作者（front matter 可覆盖）
 5 dateFormat = "2006年1月2日" # Go 时间布局
 6 layout = "right" # right | left —— 侧边栏位置
 7 fullPost = false # true = 列表页显示全文而非摘要
 8 excerptLength = 40 # 自动摘要字数（无 description 时生效）
 9 readMoreText = "阅读更多" # 摘要按钮文字
10 displayAuthor = true # 署名显示作者
11 displayDate = true # 署名显示日期
12 lastUpdated = true # 显示"最后更新于"
13 scrollToTop = true # 返回顶部按钮
14 logo = "" # logo 路径（static/ 下）；留空用文字标题
15 logoSize = 168 # logo 宽度 px
16 searchBar = true # 页眉搜索按钮
17 footerText = "版权说明" # 页脚 credit 条
18 googleFonts = true # 加载 Google Fonts（false = 离线系统字体）
19 fontFamily = "Roboto:300,300italic,400,700"
20 fontSubsets = "latin,latin-ext"
侧栏组件
1[params.sidebar]
2 recentPosts = 5 # 最近文章；0 = 不显示
3 categories = true # 分类列表（带计数）
4 tags = true # 标签云
5 archives = true # 按月归档（链接到 /archives/#2025-01）
6 [params.sidebar.about] # 关于组件（参考 laruence.com 紧凑样式）
7 name = "Leanku" # 加粗名字
8 image = "images/avatar.jpg" # 81×50 小头像（object-fit: cover）
9 text = "简介，支持 Markdown 链接"
导航菜单（含嵌套）
 1[menu]
 2 [[menu.main]]
 3 name = "主页"
 4 url = "/"
 5 weight = 1
 6 identifier = "home"
 7 # 嵌套子菜单：用 parent 指向父项 name
 8 [[menu.main]]
 9 name = "专题"
10 weight = 8
11 [[menu.main]]
12 name = "AI"
13 url = "/post/ai/"
14 parent = "专题"

weight 决定顺序；identifier 为 rss 时菜单自动加 fa-rss 图标；
当前页自动高亮（current-menu-item + aria-current="page"），以菜单 url 与页面地址精确匹配为准。

⚠️ TOML 陷阱（必读）
TOML 中一旦出现子表表头，其后的所有键都归属该子表，直到下一个表头：


内容写作指南：Front Matter 与排版
Fri, 20 Dec 2024 00:00:00 +0000
Front Matter 全字段
每篇文章开头用 --- 包裹的 YAML 就是 front matter。完整字段：
 1---
 2title: "文章标题" # 必填
 3date: 2025-01-15 # 必填：发布时间（决定排序与归档）
 4lastmod: 2025-01-20 # 可选：详情页显示"最后更新于"
 5description: "摘要，列表页显示" # 强烈建议手写（见"摘要"一节）
 6featured: "images/hero.jpg" # 特色图（static/ 下路径；也可用 Page Bundle）
 7slug: "my-post" # 可选：URL 末尾段（默认取文件名）
 8categories: ["技术"] # 分类（可多个）
 9tags: ["hugo", "写作"] # 标签（可多个）
10author: "Leanku" # 可选：覆盖站点默认作者
11sticky: true # 可选：列表页显示"精选"徽标
12draft: true # 草稿（hugo server -D 才显示）
13keywords: ["hugo", "主题"] # 可选：meta keywords（缺省用 tags）
14canonicalURL: "" # 可选：手动指定 canonical（转载声明用）
15robotsNoIndex: true # 可选：单篇屏蔽索引
16images: ["images/hero.jpg"] # 可选：OG/JSON-LD 图片列表（缺省取 featured）
17---
特色图：两种用法

	
			
					方式
					说明
					示例
			
	
	
			
					featured 参数
					指向 static/ 下路径
					featured: "images/covers/theme-intro.svg"
			
			
					Page Bundle
					文章目录 index.md + 图片
					content/post/xxx/index.md + hero.jpg，自动取包内第一张图
			
	

列表页特色图统一 2:1 比例裁切（object-fit: cover），建议源图 ≥ 1200×600；
本站示例用的是同比例的 SVG 封面，文字不会裁切。


GitHub 接入与 OAuth 2.0 授权全指南
Mon, 02 Dec 2024 00:00:00 +0000
接入 GitHub（第三方登录或调用 API）主要依赖 OAuth 2.0 授权协议。通过接入 GitHub，开发者可以实现“用 GitHub 账号一键登录平台”以及“获取用户公开信息、仓库数据”等功能。
1. 接入前的准备：创建 OAuth App
在开始写代码前，必须先在 GitHub 注册一个 OAuth Application。


登录 GitHub，点击右上角头像 -> Settings（设置）。


在左侧边栏最下方，点击 Developer settings（开发者设置）。


选择 OAuth Apps，点击 New OAuth App（或 Register a new application）。


填写应用信息：


Application name：应用名称（如 MyApp）。


Homepage URL：应用主页地址（本地测试可填 http://localhost:3000）。


Authorization callback URL：核心字段，授权成功后的回调地址（如 http://localhost:3000/api/v1/auth/callback/github）。




点击 Register application 完成注册。


注册完成后，系统会生成：


Client ID：应用的公开唯一标识。


Client Secret：密钥，点击 Generate a new client secret 生成（切记妥善保管，严禁暴露在前端）。





官方参考文档：Creating an OAuth app - GitHub Docs

2. GitHub OAuth 2.0 核心交互流程
GitHub OAuth 2.0 采用标准的授权码模式（Authorization Code Grant）：


代码高亮与 Markdown 进阶排版
Mon, 02 Dec 2024 00:00:00 +0000
计算机专业术语对照
A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z
A

	
			
					Word
					Meaning
			
	
	
			
					Abstract Factory
					抽象工厂
			
			
					Abstract Factory Pattern
					抽象工厂模式
			
			
					abstraction layer
					抽象层
			
			
					access
					获取，存取
			
			
					access modifier
					访问修饰符
			
			
					acoustic coupler
					声音耦合器
			
			
					Active Directory
					活动目录
			
			
					Acyclic Dependencies Principle
					非循环依赖原则（ADP）
			
			
					acyclic digraph
					有向无环图
			
			
					Adapter
					适配器
			
			
					Adapter Pattern
					适配器模式
			
			
					Adaptive Code
					自适应代码
			
			
					Add Parameter
					添加参数
			
			
					ADSL
					Asymmetrical Dingital Subscriber Loop，非对称数字用户环线
			
			
					affinity
					绑定
			
			
					affinity group
					地缘组
			
			
					agent
					代理
			
			
					agent-based interface
					代理人界面
			
			
					Aggregate
					聚合
			
			
					Aggregate Root
					聚合根
			
			
					Agile
					敏捷方法论
			
			
					agile practice
					敏捷实践
			
			
					agile process
					敏捷流程
			
			
					agility
					敏捷性
			
			
					AI
					Artificial Intelligence，人工智能
			
			
					air waves
					无线电波
			
			
					algorithm
					算法
			
			
					Algorithm-of-Thought
					思维算法（AoT） ⁶
			
			
					analog
					模拟的
			
			
					animation
					动画
			
			
					annotation
					注解，注释
			
			
					answering machine
					电话应答机
			
			
					antenna
					天线
			
			
					anti-pattern
					反模式
			
			
					AoT
					思维算法（Algorithm-of-Thought） ⁶
			
			
					APM
					异步编程模型（Asynchronous Programming Model）
			
			
					Apocalyptic defect
					灾难缺陷
			
			
					application
					应用，应用程序，应用软件
			
			
					application life cycle
					应用程序生命周期
			
			
					application pool
					应用程序池
			
			
					Application Programming Interface
					应用程序编程接口（API），目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。
			
			
					Application Service
					应用服务
			
			
					arbitrary error
					任意错误
			
			
					architecture
					体系机构，结构
			
			
					architecture decay
					架构腐坏
			
			
					Architecture Style
					架构风格
			
			
					ARPA
					Advanced Research Projects Agency，（美国国防部）高级研究计划署
			
			
					ARPAnet
					ARPA 网
			
			
					Arrange-Act-Assert
					准备-执行-断言（AAA）
			
			
					artifact
					构建物⁴
			
			
					ASF
					Apache Software Foundation 的简写
			
			
					Aspect-Oriented Programming
					面向切面编程（AOP）
			
			
					aspect ratio
					屏幕高宽比
			
			
					assembly
					程序集
			
			
					associative array
					关联数组
			
			
					Asynchronous Programming Model
					异步编程模型（APM）
			
			
					ATM
					asynchronous transfer mode，异步传输模式
			
			
					atomic operation
					原子操作
			
			
					atomic transaction
					原子事务
			
			
					atomicity
					原子性
			
			
					attribute
					特性（C#）、属性（Java 等）
			
			
					augmented reality
					增强实现（AR）
			
			
					authentication
					身份验证
			
			
					authorization
					授权
			
			
					auto-generated properties
					自动生成的属性
			
			
					automated unit testing
					自动化单元测试
			
			
					automation
					自动化
			
			
					autonomous
					独立性
			
			
					auxiliary database
					辅助数据库
			
			
					availability
					可用性
			
			
					availability set
					可用性集
			
			
					AZs
					可用性区域（Availability Zones，亚马逊 AWS 中数据中心的叫法）⁴
			
	

B

	
			
					Word
					Meaning
			
	
	
			
					BaaS
					Battery as a Service，电池即服务（电池租用商业模式）
			
			
					Backend as a Service
					后端即服务（BaaS）
			
			
					backpane
					底板
			
			
					backward compatibility
					向后兼容性
			
			
					bandwidth
					带宽
			
			
					bar code
					条形码
			
			
					Base Class Library
					基类库（BCL）
			
			
					baseline
					准线
			
			
					baud
					波特
			
			
					BCL
					基类库（Base Class Library）
			
			
					bear
					熊
			
			
					behavior
					行为
			
			
					behavior preserving program transformations
					行为保留式程序转换¹
			
			
					Behavioral Design Patterns
					行为性设计模式
			
			
					Behavioral error
					行为错误
			
			
					BERT
					Bidirectional Encoder Representations from Transformers，谷歌公司的 LLM，对 NLP 研究产生了重大影响。该模型使用双向方法从一个词的左右两边捕捉上下文，使得各种任务的性能提高，如情感分析和命名实体识别。
			
			
					BFF
					为前端服务的后端（Backends For Frontends）⁴
			
			
					BFS
					广度优先搜索
			
			
					Big Ball of Mud
					大泥球（BBM）
			
			
					big data
					大数据
			
			
					Big Design Up Front
					大优先设计（BDUF）
			
			
					binary
					二进制的
			
			
					binochlar
					双目并用的
			
			
					bit
					比特
			
			
					Bit-field
					位域
			
			
					bitnik
					比特族
			
			
					blob
					BLOB
			
			
					block
					阻断
			
			
					block blob
					块 BLOB
			
			
					Blockchain as a Service
					区块链即服务（BaaS）
			
			
					bottleneck
					瓶颈
			
			
					bounded context
					边界上下文、界限上下文⁴
			
			
					box
					装箱
			
			
					bps
					bits per second，比特/秒
			
			
					Brainstorming
					头脑风暴（脑暴）
			
			
					BRD
					商业需求文档（Business Requirements Document）
			
			
					breakpoint
					断点
			
			
					Bridge
					桥接
			
			
					Bridge Pattern
					桥接模式
			
			
					broadcast
					（无线电或电视）广播
			
			
					Broken Hierarchy
					支离破碎的层次结构²
			
			
					Broken Modularization
					拆散的模块化²
			
			
					brownfield project
					行进中项目
			
			
					Browser Object Model
					浏览器对象模型（BOM）
			
			
					browser-server
					浏览器-服务器
			
			
					bug
					缺陷
			
			
					Builder Pattern
					建造者模式
			
			
					built-in
					内置的，内建的；嵌入的；内置
			
			
					bulkhead
					舱壁⁴
			
			
					business intelligence
					商业智能，将企业中现有的数据进行有效的整合，快速准确地提供报表并提出决策依据，帮助企业做出明智的业务经营决策。
			
			
					business layer
					业务层
			
			
					business logic layer
					业务逻辑层
			
			
					Business Requirements Document
					商业需求文档（BRD）
			
			
					busy (status)
					忙（状态）；繁忙（状态）
			
			
					byte
					字节
			
	

C

	
			
					Word
					Meaning
			
	
	
			
					cable
					电缆
			
			
					Cache/Caching
					缓存
			
			
					call stack
					调用堆栈
			
			
					callout box
					标注框
			
			
					camelCase
					camel 大小写
			
			
					canary releasing
					金丝雀发布⁴
			
			
					carbon copy
					复写本，副本；抄送（CC）
			
			
					carriage return
					回车
			
			
					Cascading Style Sheets
					层叠样式表（CSS）
			
			
					catastrophic failover
					灾难性故障转移⁴
			
			
					CD
					持续交付（Continuous Delivery）⁴
			
			
					CDC
					消费者驱动的契约（Customer-Driven Contract）⁴
			
			
					CDN
					内容分发网络（Content Delivery Network）
			
			
					cell
					单元
			
			
					cellular telephone
					移动电话
			
			
					Central Processing Unit
					中央处理器（CPU）
			
			
					certificate
					（数字）证书
			
			
					Certificate Authority
					证书认证机构
			
			
					Chain of Responsibility
					责任链
			
			
					Chain of Responsibility Pattern
					责任链模式
			
			
					Chain-of-Thought
					思维链（CoT） ⁶
			
			
					Chain-of-Thought-Self-Consistency
					思维链自洽性 ⁶
			
			
					Change Bidirectional Association to Unidirectional
					将双向关联改为单向关联¹
			
			
					Change Point
					修改点：需要往代码中引入修改的点
			
			
					Change Reference to Value
					将引用对象改为值对象¹
			
			
					Change Unidirectional Association to Bidirectional
					将单向关联改为双向关联¹
			
			
					Change Value to Reference
					将值对象改为引用对象¹
			
			
					channel
					信道，频道
			
			
					character
					字符
			
			
					Characterization test
					特征测试：描述软件某部分的当前行为的测试，当你修改代码时能够用来保持行为
			
			
					check in
					签入
			
			
					check out
					签出
			
			
					checksum
					校验和
			
			
					chip
					芯片
			
			
					choreography
					协同
			
			
					CI
					持续集成（Continuous Integration）⁴
			
			
					cipher
					密码
			
			
					claim
					声明
			
			
					class definition
					类定义
			
			
					Clean Object-oriented and Layered Architecture
					整洁面向对象分层架构（COLA）
			
			
					CLI
					公共语言基础结构（Common Language Infrastructure）
			
			
					client-server
					客户端-服务器
			
			
					clone
					克隆，复制
			
			
					cloud computing
					云计算
			
			
					cloud service
					云服务
			
			
					CLR
					公共语言运行时（Common Language Runtime）
			
			
					CLS
					公共语言规范（Common Language Specification）
			
			
					cluster
					集群
			
			
					clustered index
					聚集索引
			
			
					co-occurring smells
					同时出现的坏味²
			
			
					CoAP
					受限应用协议
			
			
					coaxial cable
					同轴电缆
			
			
					COBIT
					信息和相关技术的控制目标，Control Objectives for Information and Related Technology⁴
			
			
					CoC
					更改开销（Cost of Change）
			
			
					code smell
					代码味道
			
			
					COLA
					整洁面向对象分层架构，Clean Object-oriented and Layered Architecture
			
			
					Collapse Hierarchy
					折叠继承关系¹
			
			
					comcurrency
					并发
			
			
					command
					命令
			
			
					Command Pattern
					命令模式
			
			
					command prompt
					命令行提示
			
			
					Command/Query Responsibility Segregation
					命令/查询职责分离（CQRS）
			
			
					Command/Query Separation
					命令/查询分离（CQS）
			
			
					commingled bits
					混合的比特
			
			
					communication
					通信
			
			
					community
					社区
			
			
					committed
					已提交（的）
			
			
					Common Intermediate Language
					公共中间语言
			
			
					Common Language Infrastructure
					公共语言基础结构（CLI）
			
			
					Common Language Runtime
					公共语言运行时（CLR）
			
			
					Common Language Specification
					公共语言规范（CLS）
			
			
					Common Type System
					公共类型系统（CTS）
			
			
					common name
					通用名称
			
			
					compatibility
					兼容性
			
			
					Competing Consumer pattern
					消费者竞争模式⁴
			
			
					compile-time correctness checking
					编译时正确性检查
			
			
					Component Object Model
					组件对象模型（COM）
			
			
					Composability
					组合性
			
			
					composite formatting
					复合格式化
			
			
					Composite Pattern
					复合模式、组合模式
			
			
					concurrency conflicts
					并发冲突
			
			
					concurrency mode
					并发模式
			
			
					conditional compilation
					条件编译
			
			
					conditional compilation statement
					条件编译语句
			
			
					configuration
					配置，设置
			
			
					connection string
					连接字符串
			
			
					Consolidate Conditional Expression
					合并条件表达式¹
			
			
					Consolidate Duplicate Conditional Fragments
					合并重复的条件片段¹
			
			
					consistency
					一致性
			
			
					constructor
					构造函数
			
			
					container
					容器
			
			
					Container As A Service
					容器即服务（CaaS）⁴
			
			
					content
					内容
			
			
					context
					上下文
			
			
					context map, 上下文映射图
					上下文地图 ⁵
			
			
					Context Mapping
					上下文映射 ⁵
			
			
					contextual keyword
					上下文关键字
			
			
					continuous integration
					持续集成
			
			
					contribute
					贡献
			
			
					Contributor License Agreement
					贡献者许可协议
			
			
					convention
					约定
			
			
					covariance
					协变
			
			
					contravariance
					逆变
			
			
					convert
					转换
			
			
					Convert Procedural Design to Objects
					将过程化设计转化为对象设计¹
			
			
					cookie
					Cookie
			
			
					copy-on-write
					写时复制
			
			
					core
					内核；.NET Core 的简写（能且仅能与 .NET Framework 的简写 nfx 同时出现，作如 nfx/core，单独使用时应为全称 .NET Core）
			
			
					core domain
					核心领域
			
			
					corruption
					损毁
			
			
					Cosmetic issue
					外观上问题
			
			
					Cost of Change
					更改开销（CoC）
			
			
					CoT
					思维链（Chain-of-Thought）⁶
			
			
					COTS
					现成的商业软件（Commercial Off-The Shelf）⁴
			
			
					counterpoint
					对位⁴
			
			
					Coupling count
					耦合数：当一个方法被调用时传给它以及从它传出来的值的数目。如果该方法没有返回值，则耦合数就是它的参数数目。否则就是参数数目加 1。如果你想要在没有测试的情况下提取出一个消防法的话，计算一下它的耦合数是很有意义的。
			
			
					CPU
					中央处理器（Central Processing Unit）
			
			
					CQRS
					命令查询职责分离（Command-Query Responsibility Segregation）
			
			
					crash
					（程序）崩溃
			
			
					crash dump
					故障转储
			
			
					Creational Design Patterns
					创建性设计模式
			
			
					CRC
					类-职责-交互（class-responsibility-collaboration）⁴
			
			
					credential
					凭证⁴
			
			
					cririque
					评估
			
			
					CRM
					客户关系管理（Customer Relationship Management）
			
			
					Cross Domain
					跨域
			
			
					Cross-browser
					跨浏览器
			
			
					Cross-platform
					跨平台
			
			
					Cross-Functional Requirement
					跨功能需求（CFR）⁴
			
			
					CRT
					cathode ray tube，阴极射线管
			
			
					cruft
					残留
			
			
					cryptography
					密码术
			
			
					CTS
					公共类型系统（Common Type System）
			
			
					cursor
					光标
			
			
					Customizability
					可定制性
			
			
					cybraian
					电脑族
			
			
					cyberspace
					电脑空间
			
			
					cycle time
					周期时间
			
			
					cyclic digraph
					有向有环图
			
			
					Cyclic Hierarchy
					循环层次结构²
			
			
					Cyclically-dependent Modularization
					循环依赖式模块化²
			
			
					Cyclomatic complexity
					圈复杂度
			
	

D

	
			
					Word
					Meaning
			
	
	
			
					DaaS
					Data as a Service，数据即服务
			
			
					DAG
					有向无循环图
			
			
					dashboard
					仪表盘
			
			
					data access layer
					数据访问层
			
			
					Data Storage as a Service
					数据存储即服务（DaaS）
			
			
					data clumps
					数据泥团²
			
			
					Data Encryption Standard
					数据加密标准（DES）
			
			
					data layer
					数据层
			
			
					data integrity
					数据完整性
			
			
					data invariant
					数据不变式
			
			
					data mining
					数据挖掘
			
			
					data pump
					数据泵
			
			
					Data Transfer Object
					数据传输对象（DTO）
			
			
					declarative programming
					宣告式编程
			
			
					Decompose Conditional
					分解条件表达式¹
			
			
					Decorator Pattern
					修饰器模式（DP）、装饰模式
			
			
					Deep Hierarchy
					过深的层次结构²
			
			
					Default Literal
					默认常值
			
			
					Defensive Programming
					防御式编程
			
			
					Deficient Encapsulation
					不充分的封装²
			
			
					Definition of Done
					完成的定义（DoD）
			
			
					denial-of-service attacks
					拒绝服务攻击⁴
			
			
					dependency injection
					依赖注入（DI）
			
			
					dependency
					依赖
			
			
					dependency digraph
					依赖有向图
			
			
					deployment
					部署
			
			
					dequeue
					出列
			
			
					derives from
					继承
			
			
					design pattern
					设计模式
			
			
					Design Requirements Document
					交互设计说明文档（DRD）
			
			
					device
					设备
			
			
					DFS
					深度优先搜索
			
			
					DfT
					为可测试性而设计
			
			
					DI
					依赖注入（dependency injection）
			
			
					DIaaS
					Data intelligence as a Service，数据智能即服务（出自2022年6月29日，阿里常规线上新品牌发布会）
			
			
					diagnostics
					诊断
			
			
					directed graph
					有向图
			
			
					directive
					指令
			
			
					DiRT
					灾难恢复测试（Disaster Recovery Test）⁴
			
			
					discussion forum
					论坛
			
			
					disk
					磁盘
			
			
					distributed system
					分布式系统
			
			
					DLL
					动态链接库（Dynamic Link Library）
			
			
					DNS
					域名系统（Domain Name System）
			
			
					Document Object Model
					文档对象模型（DOM）
			
			
					domain-driven design
					领域驱动设计（DDD）
			
			
					Domain Event
					领域事件
			
			
					Domain Model
					领域模型
			
			
					Domain Name System
					域名系统（DNS）
			
			
					Domain Service
					领域服务
			
			
					Domain Specific Language
					领域特定语言（DSL）
			
			
					DRD
					交互设计说明文档（Design Requirements Document）
			
			
					DRY 原则
					不自我重复原则（Don’t Repeat Yourself），“不要重复你自己³”
			
			
					duck-typing
					鸭子类型
			
			
					duck test
					鸭子测试
			
			
					dummy function
					虚构函数
			
			
					dump
					转储
			
			
					Duplicate Abstraction
					重复的抽象²
			
			
					Duplicate Observed Data
					复制“被监视数据”¹
			
			
					durability
					持久性
			
			
					Dynamic Link Library
					动态链接库（DLL）
			
	

E

	
			
					Word
					Meaning
			
	
	
			
					EAP
					早期评估版本（Early Assessment Program）
			
			
					EAP
					基于事件的异步模式（Event-based Asynchronous Pattern）
			
			
					Early Assessment Program
					早期评估版本（EAP）
			
			
					effect sketch
					影响草图
			
			
					Egress
					流出
			
			
					elasticity
					弹性
			
			
					ELBs
					弹性负载均衡器（Elastic Load Balancers）⁴
			
			
					Element (XML)
					元素
			
			
					Elvis Operator
					埃尔维斯运算符
			
			
					Emergence
					涌现、创发、突现、呈展、演生，是一种现象。
			
			
					Encapsulate Collection
					封装集合¹
			
			
					Encapsulate Downset
					封装向下转型¹
			
			
					Encapsulate Field
					封装字段¹
			
			
					endpoint
					端点
			
			
					enqueue
					入列；加入队列
			
			
					Enterprise Resource Planning
					企业资源计划（ERP）
			
			
					entity
					实体
			
			
					Entity Tags
					实体标签（ETag）
			
			
					entourage anti-pattern
					随从反模式
			
			
					erosion
					侵蚀
			
			
					Event-based Asynchronous Pattern
					基于事件的异步模式（EAP）
			
			
					event data pump
					时间数据泵⁴
			
			
					event sourcing
					事件源
			
			
					Evolvability
					可进化性
			
			
					exception handling
					异常处理
			
			
					Exclusive OR
					异或（XOR）
			
			
					explanatory figures
					图示
			
			
					Extensible Markup Language
					可扩展标记语言（XML）
			
			
					Extensibility
					可扩展性
			
			
					extra large
					特大型
			
			
					extra small
					特小型
			
			
					Extract Class
					提炼类¹
			
			
					Extract Hierarchy
					提炼继承体系¹
			
			
					Extract Interface
					提炼接口¹
			
			
					Extract Method
					提炼函数¹
			
			
					Extract Subclass
					提炼子类¹
			
			
					Extract Superclass
					提炼超类¹
			
			
					eXtreme Programming
					极限编程（XP）
			
	

F

	
			
					Word
					Meaning
			
	
	
			
					Facade Pattern
					外观模式
			
			
					Factory Method Pattern
					工厂方法模式
			
			
					failover
					容错转移
			
			
					failure domain
					故障域
			
			
					fake object
					伪对象：在测试中伪装成一个类的合作者的对象
			
			
					fan-in
					扇入
			
			
					fan-out
					扇出
			
			
					fat client
					胖客户端
			
			
					FCL
					.NET Framework 类库（Framework Class Library）
			
			
					FDD
					软盘（Floppy Disk Drive）
			
			
					feature sketch
					特性草图
			
			
					feed
					聚合（资源聚合）
			
			
					fine-tuning
					微调
			
			
					first-party
					第一方
			
			
					Floopy Disk Drive
					软盘（FDD）
			
			
					Flyweight Pattern
					享元模式
			
			
					follow up
					跟进
			
			
					foreign key
					外键
			
			
					Form Template Method
					塑造模板函数¹
			
			
					format item
					格式项
			
			
					format string
					格式字符串
			
			
					forward
					转发
			
			
					FPP
					零售版（Full Packaged Product）
			
			
					Framework Class Library
					.NET Framework 类库（FCL）
			
			
					FRD
					功能需求文档（Functional Requirements Document）
			
			
					free
					免费
			
			
					free function
					自由函数：一个不属于任何类的函数。在 C 和其他过程式语言中，自由函数被简单地称为函数；在 C++ 中被称为非成员函数。在 Java 和 C# 中没有自由函数。
			
			
					Functional Requirements Document
					功能需求文档（FRD）
			
			
					full-duplex
					全双工
			
			
					Full Packaged Product
					零售版（FPP）
			
			
					Function Pointers
					函数指针
			
	

G

	
			
					Word
					Meaning
			
	
	
			
					Garbage Collection
					垃圾回收器（GC）
			
			
					gauge
					计量表⁴
			
			
					GC Heap
					垃圾回收堆
			
			
					GC root
					GC 根对象
			
			
					Generalization
					泛化
			
			
					Generalized Async
					通用异步
			
			
					Generalized Async Return
					通用异步返回（C# 7.0）
			
			
					generalizing specialist
					全科专家（敏捷开发术语）
			
			
					generator
					生成器
			
			
					Generic Attributes
					泛型特性
			
			
					Generic Math
					泛型数学
			
			
					Geo-Replication
					地域复制
			
			
					Geo Redundant
					地域冗余
			
			
					Global Assembly Cache
					全局程序集缓存（GAC）
			
			
					global state
					全局状态
			
			
					global using directives
					全局 Using 指令
			
			
					Goal Directed Design
					目标导向设计，旨在处理并满足用户目标和动机，包含产品目标和用户目标
			
			
					GoT
					思维图，思维图谱（Graph-of-Thought） ⁶
			
			
					GPT-3
					Generative Pre-trained Transformer 3，是 OpenAI 最注明的 LLM 之一 ⁶ ，拥有1750亿个参数。该模型在文本生成、翻译和其他任务中表现出显著的性能，在全球范围内引起了热烈的反响，目前 OpenAI 已经迭代到了更高版本。
			
			
					Graph-of-Thought
					思维图，思维图谱（GoT） ⁶
			
			
					Graphical User Interface
					图像用户界面设计（GUI），是一种结合计算机科学、美学、心理学、行为学、及各商业领域需求分析的人机系统工程，强调人、机、环境三者作为一个系统进行总体设计。
			
			
					GUI
					图像用户界面设计（Graphical User Interface）
			
	

H

	
			
					Word
					Meaning
			
	
	
			
					Hackable
					修改方便（根据《Web API 设计与开发》一书之翻译）
			
			
					HAL
					超文本应用程序语言（Hypertext Application Language）⁴
			
			
					handle
					句柄
			
			
					Hard Disk Drive
					硬盘（HDD）
			
			
					HATEOAS
					超媒体作为程序状态的引擎（Hypermedia As The Engine Of Application State）⁴
			
			
					HCI
					人机交互（Human-Computer Interaction），属于研究层面，是人与计算机之间传递、交换信息的媒介和对话接口，是计算机系统的重要组成部分。
			
			
					HDD
					硬盘（Hard Disk Drive）
			
			
					header
					头；标头；表头
			
			
					Hexagonal Architecture
					六边形架构⁴，由 Alistair Cockburn 提出
			
			
					HMAC
					基于哈希的小系列码（Hash-based Message Authentication）⁴
			
			
					Hide Delegate
					隐藏“委托关系”¹
			
			
					Hide Method
					隐藏函数¹
			
			
					High Avaliability
					高可用性
			
			
					High Fidelity Prototype
					高保真原型，细节都比较详细的原型
			
			
					high surrogate
					高位代理项
			
			
					Homogeneous
					同质化
			
			
					hook
					钩子
			
			
					hook point
					挂接点
			
			
					Horizontal Scale
					水平缩放
			
			
					Hosting
					宿主
			
			
					Hub-like Modularization
					轮毂式模块化²
			
			
					HUI
					手持设备用户界面，包括手机端和车载导航等（Handset User Interface）
			
			
					Human-Computer Interaction
					人机交互（HCI）
			
			
					Humane Registry
					人文注册表（由 Martin Fowler 提出）⁴
			
			
					Hybrid Cloud
					混合云
			
			
					hypertext-driven
					超文本驱动
			
			
					HyperText Markup Language
					超文本标记语言（HTML）
			
	

I

	
			
					Word
					Meaning
			
	
	
			
					IA
					信息架构（Information Architect）；
			
			
					Iaas
					设施即服务（Infrastructure as a Service）
			
			
					Idempotence
					幂等性
			
			
					Idempotent Operation
					幂等操作
			
			
					Identity Provider
					身份提供方
			
			
					IL
					中间语言（intermediate language）
			
			
					Illegitimate Injection
					非法注入
			
			
					IM
					即时通讯（Instant Messaging）
			
			
					image
					映像
			
			
					immersion approach
					沉浸法
			
			
					Imperative Abstraction
					命令式抽象²
			
			
					in-context learning
					上下文学习 ⁶
			
			
					Incomplete Abstraction
					不完整的抽象²
			
			
					index
					索引
			
			
					Information Architect
					信息架构（IA）
			
			
					Infrastructure as a Service
					设施即服务（Iaas）
			
			
					ingesting
					摄取
			
			
					ingress
					流入
			
			
					Inline Class
					将类内联化¹
			
			
					Inline Method
					内联函数¹
			
			
					Inline Temp
					内联临时变量¹
			
			
					input endpoint
					输入端点
			
			
					instance
					实例
			
			
					Instance InputEndpoint
					实例输入端点
			
			
					Instant Messaging
					即时通讯（IM）
			
			
					instantiation
					实例化
			
			
					instantiator
					实例化器
			
			
					instruction fine-tuning
					指令微调
			
			
					Insufficient Modularization
					不充分的模块化²
			
			
					Interaction-based testing
					基于交互的测试
			
			
					Intercept
					截取
			
			
					interception point
					拦截点：可以编写测试来感知某些条件的地方
			
			
					intermediate language
					中间语言（IL）
			
			
					Internal Endpoint
					内部端点
			
			
					Internet Information Service
					Internet 信息服务（IIS）
			
			
					Internet Protocol
					互联网协议（IP）
			
			
					Interpreter Pattern
					解释器模式
			
			
					interpolated strings
					内插字符串
			
			
					Introduce Assertion
					引入断言¹
			
			
					Introduce Explaining Variable
					引入解释性变量¹
			
			
					Introduce Foreign Method
					引入外加函数¹
			
			
					Introduce Local Extension
					引入本地扩展¹
			
			
					Introduce Null Object
					引入 Null 对象¹
			
			
					Introduce Parameter Object
					引入参数对象¹
			
			
					Intrusion Detection Systems
					入侵检测系统（IDS）⁴
			
			
					Intrusion Prevention Systems
					入侵预防系统（IPS）⁴
			
			
					Inversion of Control
					控制反转（IoC）
			
			
					Isolation
					隔离性
			
			
					isomorphism
					同构（数学领域专用术语）
			
			
					iterable
					可迭代的
			
			
					iteration
					迭代
			
			
					iterator
					迭代器
			
			
					Iterator Pattern
					迭代模式
			
			
					iterator protocol
					迭代器协议
			
	

J

	
			
					Word
					Meaning
			
	
	
			
					Job
					作业
			
			
					Job Description
					岗位描述（JD）
			
			
					JOSE
					JSON 对象签名和加密
			
			
					Json Web Token
					JSON Web 令牌⁴
			
			
					just-in-time compilation
					即时编译，JIT 编译
			
			
					JVM
					Java 虚拟机（Java Virtual Machine）
			
	

K

	
			
					Word
					Meaning
			
	
	
			
					Key
					密钥
			
			
					key-event notification
					键事件通知
			
			
					Key Opinion Leader
					关键意见领袖（KOL），俗称大 V
			
			
					Key Performance Indicator
					关键绩效考核指标（KPI）
			
			
					Key Space
					键空间
			
			
					key-space notification
					键空间通知
			
			
					Key-Value Pair
					键-值对
			
			
					KISS 原则
					保持简单原则（Keep It Simple Silly），“简单是一切之本³”
			
			
					KPI
					关键绩效考核指标（Key Performance Indicator）
			
	

L

	
			
					Word
					Meaning
			
	
	
			
					Language Integrated Query
					语言集成查询（LINQ）
			
			
					Large
					大型
			
			
					Large Language Model
					大型语言模型（LLM） ⁶
			
			
					Layered Architecture
					分层架构
			
			
					LDAP
					Lightweight Directory Access Protocol，轻型目录访问协议
			
			
					Leaky Encapsulation
					泄露的封装²
			
			
					Legacy system
					遗留系统
			
			
					license
					许可证
			
			
					lifetime
					生命周期
			
			
					Lightweight Directory Access Protocol
					轻量级目录访问协议（LDAP）⁴
			
			
					LINE of Business
					业务线（LOB）⁴
			
			
					link
					链接
			
			
					link seam
					连接期接缝：在连接期接缝处，可以通过连接到另一个库来替换行为。在编译型语言中可替换的东西包括产品库、DLL、程序集或 JAR 文件。其目的是为了解除依赖，或感知某些在测试期间可有能会发生的条件。
			
			
					linked resource
					链接的资源
			
			
					Liskov Substitution Principle
					里氏替换原则（LSP）
			
			
					literal
					字面量、文字常量、直接量
			
			
					living style guides
					活样式指导⁴
			
			
					LLM
					大型语言模型（Large Language Model） ⁶
			
			
					load-balancing
					负载平衡
			
			
					load balancer
					负载平衡器
			
			
					load factor
					负载因子
			
			
					load shedding
					减载⁴
			
			
					LOC
					代码行数
			
			
					Local Function
					局部函数
			
			
					lock-step release
					同步发布⁴
			
			
					log
					日志
			
			
					loop
					自循环
			
			
					loose coupling
					松散耦合
			
			
					Low Fidelity Prototype
					低保真原型，抽象原型视图
			
			
					low surrogate
					低位代理项
			
			
					LSUD
					大批你所不知道的开发人员（Large Set of Unknown Developers）
			
	

M

	
			
					Word
					Meaning
			
	
	
			
					Mainframe
					主机
			
			
					Maintainability
					可维护性
			
			
					managed code
					托管代码
			
			
					managed execution
					托管执行
			
			
					Man-In-The-Middle Attack
					中间人攻击（MITM 攻击）
			
			
					Management Key
					管理密钥
			
			
					manifest
					清单
			
			
					map
					映射
			
			
					Market Requirement Document
					市场需求文档（MRD）
			
			
					Massive Multiplayer Online Role-Playing Game
					大型多人在线角色扮演游戏（MMORPG）
			
			
					Massively Multiplayer Online Role-Playing Game
					大型多人在线角色扮演游戏（MMORPG）
			
			
					Mathematical Markup Language
					数学标记语言（MathML）
			
			
					Mean Time Between Failures
					平均故障时间间隔（MTBF）⁴
			
			
					Mean Time To Repair
					平均修复时间（MTTR）⁴
			
			
					Media Service
					媒体服务
			
			
					Mediator Pattern
					中介者模式
			
			
					Medium
					中型
			
			
					Memento Pattern
					备忘录模式
			
			
					Merge
					合并
			
			
					Metadata
					元数据
			
			
					metaprogramming
					元编程
			
			
					Middleware
					中间件
			
			
					mind map
					思维导图、脑图、心智图
			
			
					Minimum Marketable Feature
					最小可售特性（MMF）
			
			
					Minimum Viable Product
					最小化可行产品（MVP）
			
			
					Minimum Viable Release
					最小可行发布（MVR）
			
			
					Missing Abstraction
					缺失抽象²
			
			
					Missing Encapsulation
					缺失的封装²
			
			
					Missing Hierarchy
					缺失层次结构²
			
			
					Mixed Reality
					混合现实（MR）
			
			
					Mobile Service
					移动服务
			
			
					Mock Object
					模拟对象，仿对象：在内部对条件进行断言的伪对象
			
			
					Move Field
					搬移字段¹
			
			
					Move Method
					搬移函数¹
			
			
					MRD
					市场需求文档（Market Requirement Document）
			
			
					Multitenancy
					多租户
			
			
					Multifaced Abstraction
					多方面抽象²
			
			
					Multipath Hierarchy
					多路径层次结构²
			
			
					Multitier Architecture
					多层体系结构
			
			
					Multi-factor Authentication
					多重验证
			
	

N

	
			
					Word
					Meaning
			
	
	
			
					naming collisions
					命名冲突
			
			
					Namespace
					命名空间，名称空间
			
			
					native code
					本机代码
			
			
					NCC
					.NET Core 社区（.NET Core Community）/.NET 中国社区（.NET China Community）
			
			
					Near Field Communication
					近距离无线通信（NFC）
			
			
					network hops
					网络跳数
			
			
					NFC
					近距离无线通信（Near Field Communication）
			
			
					nfx
					.NET Framework（.NET 框架）
			
			
					Non-clustered Index
					非聚集索引
			
			
					non-managed code
					非托管代码
			
			
					non-optional
					非可选的
			
			
					non-transactional pipeline
					非事务型流水线
			
			
					node
					节点
			
			
					normalize
					规格化
			
			
					notification
					通知
			
			
					notification hub
					通知中心
			
			
					Null Object Pattern
					空对象模式
			
			
					null-coalescing
					空值合并
			
			
					Null coalescing operator
					空值合并运算符、空值结合运算符
			
			
					N-Tier
					N 层（结构）
			
	

O

	
			
					Word
					Meaning
			
	
	
			
					obfuscator
					混淆器
			
			
					Object Pool
					对象池
			
			
					Object Pool Pattern
					对象池模式
			
			
					Object/Relational Mapper
					对象/关系映射器（ORM，O/RM）
			
			
					object seam
					对象接缝：在对象连接处可以通过替换一个对象为另一个对象来“更替”行为。在面向对象语言中，通常通过子类化产品代码中的类并重写其方法来实现这一点。
			
			
					Objectives and Key Results
					目标与关键成果法（OKR）
			
			
					Observer Pattern
					观察者模式
			
			
					On-demand (media)
					点播（媒体）
			
			
					Once and Only Once
					一次且仅一次³(OAOO)
			
			
					One rule, one place
					一个规则，实现一次
			
			
					One-Size-Fits-All
					OSFA
			
			
					one-time token
					一次性令牌
			
			
					Onion Architecture
					洋葱架构，由 Jeffrey Palermo 提出
			
			
					Open Closed Principle
					开闭原则（OCP）
			
			
					Open System Interconnection
					开放式系统互联（OSI）
			
			
					Operating System
					操作系统（OS）
			
			
					Optical Character Recognition
					光学字符识别（OCR）
			
			
					Optimistic Concurrency
					乐观并发控制
			
			
					optimistic locking
					乐观锁
			
			
					orchestration
					编排
			
			
					Orchestration Layer
					策略编排层
			
			
					Ordering Principal
					良序原则
			
			
					OS
					操作系统（Operating System）
			
			
					OSGI
					开放服务网关协议（Open Source Gateway Initiative）⁴
			
			
					overriding
					重写
			
			
					Overview
					概览
			
			
					over-post
					过度提交
			
			
					OWASP
					开放式 Web 应用程序安全项目（Open Web Application Security Project）⁴
			
	

P

	
			
					Word
					Meaning
			
	
	
			
					P2P
					个人对个人（Person-to-Person）
			
			
					Paas
					平台即服务（Platform As A Service）
			
			
					packet sniffing
					分组嗅探
			
			
					Page Blob
					页 BLOB
			
			
					Parameterize Method
					令函数携带参数¹
			
			
					Partial Translate
					部分翻译（出自 Chrome 浏览器）
			
			
					partition
					分区
			
			
					Partition tolerance
					分区容忍性⁴
			
			
					PascalCase
					Pascal 大小写
			
			
					pass-through
					直托
			
			
					passive
					被动（的）
			
			
					pattern
					模式
			
			
					Pay as You Go
					即用即付
			
			
					PC
					个人计算机（Personal Computer）
			
			
					peek
					查看
			
			
					peering rules
					对等交互规则⁴
			
			
					Percent Encoding
					百分号编码
			
			
					performance
					性能
			
			
					performance counter
					性能计数器
			
			
					performance-oriented
					面向性能
			
			
					Person-to-Person
					个人对个人（P2P）
			
			
					Personal Computer
					个人计算机（PC）
			
			
					Pessimistic Concurrency
					悲观并发控制
			
			
					pessimistic locking
					悲观锁
			
			
					PHAME
					由 Booch 提出的对象模型的 4 个主要元素的设计规则的统称，即 Principle of Hierarchy, Abstraction, Modularization, and Encapsulation，层次结构、抽象、模块化与封装原则
			
			
					pinch point
					汇点：影响结构图中的隘口和交通要冲，在汇点编写测试的好处就是只需针对少数几个方法编写测试，就能达到探测大量其他方法的改动的目的。
			
			
					placeholder
					占位符
			
			
					Platform as a Service
					平台即服务（Paas）
			
			
					PMD
					项目管理文档（Program Managment Document）
			
			
					point of invocation of the method
					方法调用点
			
			
					Point-to-Site
					点到站点
			
			
					polling
					轮询
			
			
					polymorphism
					多态
			
			
					polyrot programming
					多语言编程
			
			
					Poor Man’s Dependency Injection
					穷人的依赖注入
			
			
					post-initialization
					后初始化
			
			
					postcondition
					后置条件
			
			
					PoT
					程序思维（Program-to-Thoughts） ⁶
			
			
					PRD
					产品需求文档（Product Requirements Document）
			
			
					pre-flight request
					事先请求
			
			
					pre-initialization
					预初始化
			
			
					pre-training
					预训练 ⁶
			
			
					Predicate Decorator
					谓词修饰器
			
			
					precondition
					前提，前置条件
			
			
					presentation layer
					表现层
			
			
					Preserve Whole Object
					保持对象完整¹
			
			
					primary database
					主数据库
			
			
					primary storage
					主存储
			
			
					primitive obsession
					基本类型偏执²
			
			
					principal
					主体⁴
			
			
					Private Class Data Pattern
					私有类数据模式
			
			
					private cloud
					私有云
			
			
					priority queue
					优先级队列
			
			
					probe
					探测器
			
			
					process
					进程
			
			
					producer
					生产者
			
			
					product backlog
					产品积压工作
			
			
					Product Owner
					产品负责人（PO）
			
			
					Product Requirements Document
					产品需求文档（PRD）
			
			
					production
					生产（环境）
			
			
					production load
					生产负载⁴
			
			
					Program Managment Document
					项目管理文档（PMD）
			
			
					Program-to-Thoughts
					程序思维（PoT） ⁶
			
			
					programming by difference
					差异式编程
			
			
					proof of concept
					概念验证
			
			
					proportional error rate
					错误率比例⁴
			
			
					protected variation
					防止变异
			
			
					protocol
					协议
			
			
					prototype
					原型
			
			
					Prototype Pattern
					原型模式
			
			
					proxy
					代理
			
			
					Proxy Pattern
					代理模式
			
			
					public cloud
					公有云
			
			
					Pull Up Constructor Body
					构造函数本体上移¹
			
			
					Pull Up Field
					字段上移¹
			
			
					Pull Up Method
					函数上移¹
			
			
					push
					推送
			
			
					Push Down Field
					字段下移¹
			
			
					Push Down Method
					函数下移¹
			
	

Q

	
			
					Word
					Meaning
			
	
	
			
					quality assurance
					质量保证（QA）
			
			
					Queue
					队列
			
			
					Quota
					配额
			
	

R

	
			
					Word
					Meaning
			
	
	
			
					Rack
					机架
			
			
					RAII
					Resource Acquisition Is Initialization，资源获取即初始化
			
			
					Rapid Application Development
					快速应用程序开发（RAD）
			
			
					RDBMS
					关系型数据库管理系统（Relational Database Management System）
			
			
					Reactive extensions
					响应式扩展（Rx）⁴
			
			
					Ready (status)
					就绪（状态）
			
			
					real-time
					即时、实时
			
			
					real-time discussions
					即时讨论、实时讨论
			
			
					Rebellious Hierarchy
					叛逆性层次结构²
			
			
					recursion
					递归
			
			
					Redundancy
					冗余
			
			
					Redundant
					冗余（的）
			
			
					Ref Return
					应用返回
			
			
					Ref Local
					局部引用
			
			
					Ref Property
					引用属性
			
			
					Ref-Safe-to-Escape
					引用安全逃逸
			
			
					Ref-Safe-to-Escape scope
					引用安全逃逸范围
			
			
					Refactor
					重构
			
			
					region
					地域
			
			
					reification
					具体化
			
			
					Reinforcement Learning
					强化学习，一种机器学习的方法，通过从外部获得激励来校正学习方向从而获得一种自适应的学习能力
			
			
					Reinforcement Learning from Human Feedback
					基于人工反馈的强化学习（RLHF）
			
			
					relay
					中继
			
			
					Relevancy
					适切性
			
			
					Reliability
					可靠性
			
			
					Relying Party
					依赖方
			
			
					Remove Assignments to Parameters
					移除对参数的赋值¹
			
			
					Remove Control Flag
					移除控制标记¹
			
			
					Remove Middle Man
					移除中间人¹
			
			
					Remove Parameter
					移除参数¹
			
			
					Remove Setting Method
					移除配置函数¹
			
			
					Rename Method
					函数改名¹
			
			
					Replace Array with Object
					以对象取代数组¹
			
			
					Replace Conditional with Polymorphism
					以多态取代条件表达式¹
			
			
					Replace Constructor with Factory Method
					以工厂函数取代构造函数¹
			
			
					Replace Data Value with Object
					以对象取代数据值¹
			
			
					Replace Delegation with Inheritance
					以继承取代委托¹
			
			
					Replace Error 　 Code with Exception
					以异常取代错误码¹
			
			
					Replace Exception with Test
					以测试取代异常¹
			
			
					Replace Inheritance with Delegation
					以委托取代继承¹
			
			
					Replace Magic Number with Symbolic Constant
					以字面常量取代魔法数¹
			
			
					Replace Method with Method Object
					以函数对象取代函数¹
			
			
					Replace Nested Conditional with Guard Clauses
					以卫语句取代嵌套条件表达式¹
			
			
					Replace Parameter with Explicit Methods
					以明确函数取代参数¹
			
			
					Replace Parameter with Methods
					以函数取代参数¹
			
			
					Replace Record with Data Class
					以数据类取代记录¹
			
			
					Replace Subclass with Fields
					以字段取代子类¹
			
			
					Replace Temp with Query
					以查询取代临时变量¹
			
			
					Replace Type Code with Class
					以类取代类型码¹
			
			
					Replace Type Code with State/Strategy
					以 State/Strategy 取代类型码¹
			
			
					Replace Type Code with Subclass
					以子类取代类型码¹
			
			
					reporting
					报表
			
			
					Repository
					存储库；仓储；仓库；资源库
			
			
					REpresentational State Transfer
					表述性状态转移、表征性状态传输、具象状态传输（REST）
			
			
					request pipeline
					请求管道
			
			
					Requirements Churn
					需求波动
			
			
					reserved
					专属
			
			
					resolution
					解析
			
			
					Resource Acquisition Is Initialization
					资源获取即初始化（RAII）
			
			
					Resource Release Is Destruction
					在构造时没有“获取”资源，但在析构时释放资源（RRID），一种 RAII 的特殊用法
			
			
					Resource-Oriented Architecture
					面向资源的架构(ROA)
			
			
					Response Group
					响应群
			
			
					Return on Investment
					投资回报（ROI）
			
			
					reverse proxy module
					反向代理模块
			
			
					retail
					零售版
			
			
					Rich Client
					丰富客户端
			
			
					Ripple Effect
					涟漪效应
			
			
					RLHF
					基于人工反馈的强化学习（Reinforcement Learning from Human Feedback）
			
			
					role
					角色
			
			
					Rolling Upgrade
					滚动升级
			
			
					round-robin
					轮流（分配）；轮叫
			
			
					round-tripping
					还原；回传；往返，往返切换
			
			
					router
					路由器
			
			
					row
					行
			
			
					RPC
					远程过程调用（Remote Procedure Call）⁴
			
			
					RRID
					Resource Release Is Destruction，在构造时没有“获取”资源，但在析构时释放资源，一种 RAII 的特殊用法
			
	

S

	
			
					Word
					Meaning
			
	
	
			
					Saas
					软件即服务（Software As A Service）
			
			
					Safe-to-Escape
					安全逃逸
			
			
					Safe-to-Escape scope
					安全逃逸范围
			
			
					salted password hashing
					加盐密码哈希⁴
			
			
					SAN
					存储区域网络（Storage Area Network）⁴
			
			
					SASL
					简单认证与安全层
			
			
					Scalability
					缩放性
			
			
					Scalable Vector Graphic
					可伸缩矢量图（SVG）
			
			
					Scale
					缩放
			
			
					Scale Out
					向外缩放
			
			
					Scale Up
					向上缩放
			
			
					scaling pattern
					扩展模式⁴
			
			
					Schema (database)
					架构（数据）
			
			
					Schema (xml)
					架构（xml）
			
			
					Scrum Master
					Scrum 主管（SM）
			
			
					SDK
					软件开发工具箱（Software Development Kits）
			
			
					seam
					接缝：程序中的一些特殊的点，可以让你无需做任何修改就能达到修改程序行为的目的。
			
			
					Search Engine
					搜索引擎（SE）
			
			
					Search Engine Marketing
					搜索引擎营销（SEM）
			
			
					Search Engine Optimization
					搜索引擎优化（SEO）
			
			
					secondary storage
					二级存储
			
			
					Secure Socket Layer
					安全套接层（SSL）
			
			
					Security
					安全（性）
			
			
					Security Development Lifecycle
					安全开发生命周期⁴
			
			
					Security Socket Layer
					安全套接层
			
			
					Security Token
					安全令牌
			
			
					Self Encapsulate Field
					自封装字段¹
			
			
					self-hosted
					自管理主机⁴
			
			
					Self-signed Certificate
					自签名证书
			
			
					Semantic Kernel
					语义核心 ⁶
			
			
					semantic monitoring
					语义监控⁴
			
			
					Semantic Versioning
					语义化版本控制
			
			
					Separate Domain from Presentation
					将领域和表述/显示分离¹
			
			
					Separate Query from Modifier
					将查询函数和修改函数分离¹
			
			
					Serializable
					可序列化
			
			
					Server Affinity
					服务器绑定
			
			
					Server Driven Content Negotiation
					服务器驱动的内容协商
			
			
					Server Side Render
					服务器渲染（SSR）
			
			
					Service Bus
					服务总线
			
			
					Service Contract
					服务合同
			
			
					Service Level Agreement
					服务水平协议（SLA）
			
			
					Service Provider
					服务提供方
			
			
					session jacking
					会话劫持
			
			
					Setting
					设置
			
			
					Shared
					共享；分享
			
			
					shared-memory data structure
					共享内存数据结构
			
			
					Short-circuit evaluation
					短路求值
			
			
					Sign in
					登录
			
			
					Sign out
					注销
			
			
					Signature
					签名
			
			
					Single Level of Abstraction Principle
					单一抽象层次原则（SLAP）
			
			
					Single responsibility principle
					单一职责原则（SRP）
			
			
					Single Page Application
					单页面应用（SPA）
			
			
					single point of failure
					单一故障点（SPOF）
			
			
					Singleton Pattern
					单例模式
			
			
					Site
					站点
			
			
					Site-to-Site
					站点到站点
			
			
					Skeleton-to-Thought
					思维框架（SoT） ⁶
			
			
					skip list
					跳跃表
			
			
					SLA
					服务水平协议、服务等级协议（Service Level Agreement）
			
			
					Small
					小型
			
			
					smart endpoint
					智能端点⁴
			
			
					snapshot
					快照
			
			
					SOA
					面向服务的架构（Service-Oriented Architecture）
			
			
					SoT
					思维框架（Skeleton-to-Thought） ⁶
			
			
					Software as a Service
					软件即服务（Saas）
			
			
					source lines of code
					源代码行数（SLOC）
			
			
					Speculative Hierarchy
					凭空想象的层次结构²
			
			
					Split Temporary Variable
					分解临时变量¹
			
			
					sprint
					冲刺（敏捷开发术语）
			
			
					sprint backlog
					冲刺积压工作
			
			
					SQL Database
					SQL 数据库
			
			
					SSKD
					少量你所知道的开发人员（Small Set of Known Developers）
			
			
					SSO
					单点登录（Single Sign-On）⁴
			
			
					stage
					阶段
			
			
					Staging
					过渡（环境）
			
			
					state indeterminism
					状态不确定性
			
			
					State-based testing
					基于状态的测试
			
			
					State Pattern
					状态模式
			
			
					Stateless
					无状态
			
			
					Sticky Session
					黏性会话
			
			
					Stickyness
					黏性；黏度
			
			
					story
					故事（敏捷开发术语）
			
			
					Storage
					存储
			
			
					Storage Account
					存储账户
			
			
					Strangler Application Pattern
					绞杀者模式⁴
			
			
					strategic development tools
					战略设计工具 ⁵，战略开发工具
			
			
					Strategy Pattern
					策略模式
			
			
					Stream
					流
			
			
					Structural Design Patterns
					结构性设计模式
			
			
					structure
					结构
			
			
					Structured Systems Analysis and Design Methodology
					结构化系统分析和设计方法（SSADM）
			
			
					Subnet
					子网
			
			
					Subordinate
					附属
			
			
					Sub-region
					子地域
			
			
					Subdomain
					子领域
			
			
					Subscription
					订阅
			
			
					Substitute Algorithm
					替换算法¹
			
			
					SW
					Apache SkyWalking 的简写
			
			
					symbol table
					符号表
			
			
					Synchronized Multimedia Integration Language
					同步多媒体集成语言（SMIL）
			
			
					syntactic sugar
					语法糖
			
			
					System Under Test
					测试目标系统（SUT）
			
	

T

	
			
					Word
					Meaning
			
	
	
			
					Table
					表
			
			
					tactical development tools
					战术实施工具 ⁵，战术开发工具
			
			
					TAP,
					基于任务的异步模式
			
			
					targeted testing
					目标测试
			
			
					Task-based Asynchronous Pattern
					基于任务的异步模式
			
			
					TCP
					传输控制协议（Transmission Control Protocol）
			
			
					TDD
					测试驱动开发（Test-Driven Development）
			
			
					Tease Apart Inheritance
					梳理并分解继承体系¹
			
			
					technical bankruptcy
					技术破产
			
			
					Technical Debt
					技术债务（TDBT）
			
			
					Template Method Pattern
					模板方法模式
			
			
					Tenant
					租户
			
			
					Terminus
					端点
			
			
					test doubles
					测试替身
			
			
					Test-Driven Development
					测试驱动开发（TDD）
			
			
					test harness
					测试用具
			
			
					the normalization of deviance
					异常正常化⁴
			
			
					Thin Client
					瘦客户端
			
			
					Thread
					线程
			
			
					Thread Environment Block
					线程环境块
			
			
					Thread Kernel Object
					线程内核对象
			
			
					Thread Pool
					线程池
			
			
					Thread Starvation
					线程饥荒
			
			
					Throttle
					节流；限速
			
			
					Timestamp
					时间戳
			
			
					Throughput
					吞吐量
			
			
					TNP
					交通网络提供者（Transportation Network Providers）
			
			
					TOFU
					首次使用时信任（Trust On First Use）
			
			
					Topic
					主题
			
			
					Topology
					拓扑结构
			
			
					Token
					令牌
			
			
					Top-level statements
					顶级语句
			
			
					ToT
					思维树（Tree-of-Thought）
			
			
					TPL
					任务并行库
			
			
					(Code) Tracing
					（代码）追踪
			
			
					Transaction
					事务
			
			
					Transaction Script
					事务脚本
			
			
					Transient Error
					瞬时错误
			
			
					Transparent Data Encryption
					透明数据加密⁴
			
			
					Transportation Network Providers
					交通网络提供者（TNP）
			
			
					Tree-of-Thought
					思维树（ToT） ⁶ 是一种通过将复杂问题分解为更易于解决的小问题，为 LLM 推理提供更结构化的提示框架
			
			
					Type Bloat
					类型膨胀
			
	

U

	
			
					Word
					Meaning
			
	
	
			
					UAT
					用户验收测试（User Acceptance Testing）⁴
			
			
					Ubiquitous Computing
					普存计算
			
			
					Ubiquitous Language
					统一语言
			
			
					UDDI
					通用描述、发现与集成服务（Universal Description, Discovery, and Integration）
			
			
					UI
					用户界面，包括视觉设计、交互设计和用户体验（User Interface）
			
			
					Uncommitted
					未提交（的）
			
			
					Update Domain
					更新域
			
			
					unbox
					拆箱
			
			
					under-post
					提交不足
			
			
					undirected graph
					无向图
			
			
					Unexploited Encapsulation
					未利用封装²
			
			
					Unfactored Hierarchy
					未归并的层次结构²
			
			
					Unified Modeling Language
					统一建模语言（UML）
			
			
					Uniform Interface
					统一接口
			
			
					Uniform Resource Locator
					统一资源定位符（URL）
			
			
					unit of work
					工作单元
			
			
					Unit test
					单元测试
			
			
					unit test coverage
					单元测试覆盖率
			
			
					unit-testing harnesses
					单元测试用例
			
			
					unmanaged code
					非托管代码
			
			
					Unmanaged Pointers
					非托管指针
			
			
					Unnecessary Abstract
					不必要的抽象²
			
			
					Unnecessary Hierarchy
					不必要的层次结构²
			
			
					unnecessary overhead
					不必要的开销
			
			
					Unutilized Abstraction
					未用的抽象²
			
			
					Usability Review
					可用性评估
			
			
					User Acceptance Test
					接受度测试（UAT）
			
			
					User Analysis
					用户分析
			
			
					User Datagram Protocol
					用户数据报协议（UDP）
			
			
					User Interface
					用户界面，包括视觉设计、交互设计和用户体验（UI）
			
			
					User Mode Stack
					用户模式栈
			
	

V

	
			
					Word
					Meaning
			
	
	
			
					Value Object
					值对象
			
			
					variant
					变体
			
			
					Variation Encapsulation Principle
					变化封装原则（VEP）
			
			
					versionable interaction contract
					可以进行版本控制的交互契约
			
			
					Vertical Scale
					垂直缩放
			
			
					VES
					虚拟执行系统（Visual Execution System）
			
			
					viscosity
					粘滞性
			
			
					VIP
					虚拟 IP（或不译）
			
			
					VIP Swap
					VIP 交换
			
			
					Virtual Execution System
					虚拟执行系统（VES）
			
			
					Virtual Network
					虚拟网络
			
			
					Virtual Machine
					虚拟机
			
			
					Virtual Private Network
					虚拟专用网络（VPN），在公用网络上建立专用网络，进行加密通讯，如网关通过对数据包的加密和数据包目标地址的转换实现远程访问。
			
			
					Virtual Reality
					虚拟现实（VR）
			
			
					viscosity
					粘稠性
			
			
					Visitor Pattern
					访问者模式
			
			
					VLO
					团体批量许可证；大量采购授权合约（Volume Licensing for Organizations）
			
			
					VOL
					团体批量许可证；大量采购授权合约（Volume Licensing for Organizations）
			
			
					Volume Licensing for Organizations
					团体批量许可证；大量采购授权合约（VOL 或 VLO）
			
			
					VPC
					虚拟私有云（Virtual Private Cloud）⁴
			
			
					VPN
					虚拟专用网络（Virtual Private Network）
			
	

W

	
			
					Word
					Meaning
			
	
	
			
					WCF
					Windows 通讯开发平台（Windows Comminication Foundation）
			
			
					Weak Generational Hypothesis
					弱分代假设
			
			
					Wearable Device
					可穿戴设备
			
			
					Web Role
					网站角色
			
			
					Web Scraping
					网络爬虫
			
			
					Web Service
					网络服务
			
			
					Web Service Definition Language
					Web 服务定义语言（WSDL）
			
			
					Web Sites
					网站
			
			
					Weighted Method per Class
					类累计圈复杂度（WMC）
			
			
					WF
					工作流（WIndows Workflow）
			
			
					Wide Hierarchy
					过宽的层次结构²
			
			
					Windows Comminication Foundation
					分布式通信（WCF）
			
			
					Windows Internet Name Service
					Windows Internet 命名服务（WINS）
			
			
					Windows Management Instrumentation
					Windows 管理规范（WMI）
			
			
					Windows Presentation Foundation
					富客户端表示（WPF）
			
			
					Windows Workflow
					工作流（WF）
			
			
					WINS
					Windows Internet 命名服务（Windows Internet Name Service）
			
			
					WINS Proxy
					WINS 代理
			
			
					WINS Resource
					WINS 资源
			
			
					wireless communication
					无线通讯
			
			
					WMI
					Windows 管理规范（Windows Management Instrumentation）
			
			
					Worker Role
					辅助角色
			
			
					Workflow
					工作流
			
			
					workgroup
					工作组
			
			
					World Wide Web Consortium
					万维网联盟（W3C）
			
			
					WPF
					富客户端表示（Windows Presentation Foundation）
			
			
					writebehind
					后写式
			
	

X

	
			
					Word
					Meaning
			
	
	
			
					X.509v3 certificate
					X.509 证书
			
			
					XaaS
					Everything as a Service，一切皆服务
			
			
					XML
					可扩展标记语言（Extensible Markup Language）
			
			
					XOR
					异或（Exclusive OR）
			
			
					XUL
					XML 用户界面语言（XML User Interface Language）
			
	

Y

	
			
					Word
					Meaning
			
	
	
			
					YAGNI
					原则，不需要原则（You Aren’t Gonna Need It），“你不会用到它³”
			
	

Z

	
			
					Word
					Meaning
			
	
	
			
					Zero-downtime Upgrade
					零停机升级
			
			
					zip disk
					压缩磁盘
			
			
					zone
					区域
			
			
					zone list
					区域列表
			
			
					zone transfer
					区域传送
			
	

注释
[1] 重构列表，摘自《重构》一书。


代码高亮与 Markdown 进阶排版
Mon, 02 Dec 2024 00:00:00 +0000
本主题内置 Hugo Chroma 代码高亮：Atom One Dark 深色配色、行号、长行横向滚动与一键复制。
代码块用法
三个反引号 + 语言名即可，语法高亮由 Chroma 自动完成：
1package main
2
3import "fmt"
4
5func main() {
6 // 支持 Go/Python/JS/TOML/Bash 等 100+ 语言
7 fmt.Println("Hello, Period!")
8}
需要高亮指定行时，用 highlight 短代码 + hl_lines（行号从 1 计）：
11func add(a, b int) int {
2 return a + b // ← 这一行会被背景高亮
3}
Bash 示例（注意行号会自动生成）：
1hugo server -D
2hugo --minify && npx pagefind --site public
每个代码块右上角有复制按钮（悬停高亮），点击即复制全文。
高亮配置
1[markup.highlight]
2 codeFences = true
3 noClasses = false # 使用 Chroma 类名（配合主题内置 chroma.css）
4 lineNos = true # 行号
5 lineNumbersInTable = false
6 style = "onedark" # 与 themes/period/assets/css/chroma.css 对应
7 tabWidth = 4
换配色风格：运行 hugo gen chromastyles --style=<风格名>（如 github、monokai、
friendly），把输出覆盖到 themes/period/assets/css/chroma.css，再同步修改
markup.highlight.style 即可；换成浅色风格时记得同步调整
themes/period/assets/scss/_base.scss 里 .highlight 块的深色适配（边框/复制按钮配色）。


自建网站分析工具：Umami 完全指南
Mon, 02 Dec 2024 00:00:00 +0000
在网站上线后，了解访客从何而来、关注哪些内容，是持续优化的基础。
但 Google Analytics 的复杂配置和隐私合规问题，让不少站长望而却步。如果你希望数据完全由自己掌控，又不想牺牲分析能力，Umami 是一个非常值得考虑的选择。
一、什么是 Umami？
Umami 是一个开源、轻量且注重隐私的网站分析工具，定位为 Google Analytics 的替代方案。它的核心特点可以用几个关键词概括：

开源免费，自托管：代码遵循 MIT 许可证，任何人都可以自由使用和修改。你可以将其部署在自己的服务器或云平台上，所有数据都存储在你控制的环境中，无需依赖任何第三方服务。
隐私友好，无需 Cookie：Umami 默认不使用 Cookie，也不收集个人身份信息（PII），符合 GDPR、CCPA 等隐私法规要求。这意味着你不用再为 Cookie 同意弹窗而烦恼。
轻量高效，不影响性能：前端跟踪脚本体积极小，通常小于 2KB，对网站加载速度的影响几乎可以忽略不计。
界面简洁，功能实用：仪表盘清晰展示实时访客数、页面浏览量（PV）、独立访客（UV）、流量来源、设备类型、热门页面等核心指标。

简单来说，Umami 回归了网站分析的本质——了解你的访客，而不打扰他们。
二、 Umami 的优势
相比于其他统计工具，Umami 的优势非常突出：

	
			
					特点
					具体说明
			
	
	
			
					数据所有权
					自托管部署，所有数据归你所有，不存在数据被第三方利用的风险。
			
			
					不限网站数量
					一个 Umami 实例可以同时监控无限个网站，甚至子域名和单个 URL。
			
			
					绕过广告拦截器
					因为统计脚本运行在你自己的域名下，可以有效避免被广告拦截器屏蔽。
			
			
					多账户与共享
					可以为团队或客户创建独立账号，也可以通过唯一 URL 公开分享统计数据。
			
			
					持续进化
					最新版本（v3.1.0）已加入会话回放（Session Replay）、自定义看板（Boards） 和 Core Web Vitals 性能监控等专业功能。
			
	

三、安装 Umami
对于大多数用户，使用 Docker Compose 是最快捷、最可靠的部署方式。它会帮你把 Umami 应用和 PostgreSQL 数据库一起搞定，维护起来也方便。
此处以Docker为例安装
3.1 前提

A server with Node.js version 18.18+.
A PostgreSQL database version v12.14+.

3.2 拉取项目源码或者手动创建docker-compose.yml
 1---
 2services:
 3 umami:
 4 image: ghcr.io/umami-software/umami:latest
 5 ports:
 6 - "3000:3000"
 7 environment:
 8 DATABASE_URL: postgresql://umami:umami@db:5432/umami
 9 APP_SECRET: replace-me-with-a-random-string
10 # Required for two-factor authentication, generate with: openssl rand -hex 32
11 TWO_FACTOR_ENCRYPTION_KEY: replace-me-with-a-64-character-hex-string
12 depends_on:
13 db:
14 condition: service_healthy
15 init: true
16 restart: always
17 healthcheck:
18 test: ["CMD-SHELL", "curl http://localhost:3000/api/heartbeat"]
19 interval: 5s
20 timeout: 5s
21 retries: 5
22 db:
23 image: postgres:15-alpine
24 environment:
25 POSTGRES_DB: umami
26 POSTGRES_USER: umami
27 POSTGRES_PASSWORD: umami
28 volumes:
29 - umami-db-data:/var/lib/postgresql/data
30 restart: always
31 healthcheck:
32 test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
33 interval: 5s
34 timeout: 5s
35 retries: 5
36volumes:
37 umami-db-data:
3.3 启动服务
1docker compose up -d
3.4 验证部署
在浏览器中访问 http://你的服务器IP:3000，如果看到 Umami 的登录页面，就说明部署成功了。默认的登录账号是 admin，密码是 umami


主题定制：设计令牌与样式
Fri, 15 Nov 2024 00:00:00 +0000
所有视觉属性都收敛在 themes/period/assets/scss/_variables.scss 这一个文件里——改颜色、
字号、间距、断点不需要碰任何规则文件。
设计令牌全量说明
 1// ---- Colors（对应设计文档 §1.2）----
 2$c-page: #EDEDED; // 页面背景
 3$c-text: #333333; // 正文 / 链接 / 标题
 4$c-text-hover: #757575; // 正文链接悬停
 5$c-header: #333333; // 页眉 / 页脚背景
 6$c-header-text: #FFFFFF; // 页眉 / 菜单文字
 7$c-header-text-hover: #D4D4D4; // tagline、页眉链接悬停
 8$c-credit: #242424; // credit 条 / 归档标题 / 菜单选中态
 9$c-card: #FFFFFF; // 卡片背景
10$c-card-shadow: rgba(58,58,58,0.2);
11$c-input-bg: #F7F7F7; // 输入框 / 代码背景
12$c-input-border: #D4D4D4; // 输入框描边
13$c-muted: #666666; // 次要文字
14
15// ---- Typography ----
16$font-family: "Roboto", "Open Sans", sans-serif;
17$font-light: 300; $font-regular: 400; $font-bold: 700;
18$fs-base: 16px;
19$lh-base: 1.5;
20
21// ---- Layout ----
22$max-width: 1300px; // 页面最大宽度
23$header-overlap: 5.25em; // 内容上叠压头高度（签名特征）
24$page-gutter: 5.5556%; // 页面左右留白
25$col-main: 62.5005%; $col-side: 34.375275%; $col-gap: 3.125025%;
26
27// ---- Breakpoints（对应原主题媒体查询）----
28$bp-600: 37.5em; // 600px
29$bp-900: 56.25em; // 900px
30$bp-1100: 68.75em; // 1100px
示例：改成墨绿页眉
1$c-header: #1F3A34;
保存即生效：extended Hugo 用 Pipes 自动编译（hugo server 下改完刷新即可）；
普通版 Hugo 用户需 npm run css 重新编译预编译 CSS。


评论、搜索与联系表单集成
Mon, 28 Oct 2024 00:00:00 +0000
原 WordPress 主题的评论、搜索、联系表单在 Hugo 中由第三方服务替代，全部通过
config.toml 开关控制，未启用时页面不含任何相关脚本（性能优先）。

	
			
					功能
					方案
					默认
			
	
	
			
					评论
					Giscus / Utterances
					关闭
			
			
					搜索
					Pagefind
					开启
			
			
					联系表单
					Formspree / Netlify Forms
					关闭
			
	

评论：Giscus（推荐）
一次性准备（GitHub 侧）

仓库设为公开；
Settings → General → Features → 开启 Discussions；
安装 giscus App：https://github.com/apps/giscus → Configure → 选择该仓库。

生成配置
打开 https://giscus.app/zh-CN，选择仓库与分类，复制生成的配置填入：
1[params.comments]
2 provider = "giscus"
3 repo = "你的用户名/你的仓库"
4 repoId = "R_kgDOxxxxxxx"
5 category = "Announcements"
6 categoryId = "DIC_kwDOxxxxxxx"
7 theme = "light" # 或 dark；勿用 preferred_color_scheme（SSR 缺陷）

排查：页面报 “giscus is not installed” → App 未安装/仓库非公开/Discussions 未开启；
控制台 MIME 报错 → theme 用了非法值。


关于rabbitmq的一些问题
Sun, 13 Oct 2024 20:46:01 +0800
关于rabbitmq的一些问题
一、RabbitMQ的完整工作流程
RabbitMQ 的核心是生产者将消息发送到交换机，交换机根据类型和路由键将消息路由到队列，消费者再从队列中获取消息。
核心组件：


Producer（生产者）： 发送消息的应用程序。


Consumer（消费者）： 接收消息的应用程序。


Message（消息）： 包含有效载荷（数据）和标签（元数据，如路由键）。


Exchange（交换机）： 接收生产者发送的消息，并根据特定规则（交换机类型、绑定、路由键）将消息路由到一个或多个队列。


Queue（队列）： 存储消息的缓冲区，等待消费者消费。


Binding（绑定）： 连接交换机和队列的规则。


完整流程：


建立连接：


生产者/消费者与 RabbitMQ Broker 建立一个 TCP 连接。


在连接上创建一个 Channel（信道），Channel 是轻量级的连接，避免了频繁创建/销毁 TCP 开开销。




生产者发送消息：


生产者将消息发送到指定的 Exchange。


发送消息时，必须指定一个 Routing Key（路由键）。




交换机路由消息：


Exchange 接收到消息后，根据自身的 类型 和 Binding 规则，决定将消息投递到哪些队列。


主要的交换机类型：


Direct： 精确匹配 Routing Key。消息只会被投递到 Binding Key 与 Routing Key 完全一致 的队列。


Fanout： 广播模式。将消息投递到所有绑定到该 Exchange 的队列，忽略 Routing Key。


Topic： 模式匹配。使用通配符（* 匹配一个词，# 匹配零个或多个词）来匹配 Routing Key 和 Binding Key。


SEO 优化与部署上线
Sat, 05 Oct 2024 00:00:00 +0000
内置 SEO 层（移植自 PaperMod 思路）
全部由 Hugo 模板实现，零插件：

	
			
					能力
					说明
			
	
	
			
					robots 索引控制
					生产构建 index, follow；hugo server 输出 noindex, nofollow；单篇 robotsNoIndex: true 屏蔽
			
			
					robots.txt
					主题自带模板：生产放行 + 指向 sitemap；开发环境 Disallow: /
			
			
					结构化数据
					首页 Organization（含 sameAs 社交链接）、全站 BreadcrumbList、文章 BlogPosting（headline/全文/作者/publisher）
			
			
					分享卡片
					Open Graph（og:image 自动取 featured/封面/正文首图）与 Twitter Cards（summary_large_image）
			
			
					元数据
					keywords（回退 tags）、author、canonical（支持 canonicalURL 覆盖）、四种站长验证 meta
			
			
					性能
					CSS 指纹 + preload + SRI、favicon 家族 + theme-color
			
	

关键开关：
 1[params.seo]
 2 enableOpenGraph = true
 3 enableTwitterCards = true
 4 enableSchema = true
 5 alwaysInclude = false # true = 开发环境也输出 OG/JSON-LD（调试用）
 6 [params.seo.verification]
 7 google = "" # Google Search Console 验证码
 8 bing = ""
 9 yandex = ""
10 naver = ""

默认仅在生产环境输出 OG/Twitter/JSON-LD，避免开发环境污染索引。
验证 meta 在 Google/Bing/Yandex/Naver 站长后台"添加站点"时获得，粘贴即生效。


Ollama
Sun, 01 Sep 2024 11:46:01 +0800
Ollama 简介
介绍

Ollama 是一个开源的大型语言模型（LLM）平台，旨在让用户能够轻松地在本地运行、管理和与大型语言模型进行交互。
Ollama 提供了一个简单的方式来加载和使用各种预训练的语言模型，支持文本生成、翻译、代码编写、问答等多种自然语言处理任务。
Ollama 的特点在于它不仅仅提供了现成的模型和工具集，还提供了方便的界面和 API，使得从文本生成、对话系统到语义分析等任务都能快速实现

安装要求

Ollama 支持多种操作系统，包括 macOS、Windows、Linux 以及通过 Docker 容器运行。
CPU：多核处理器（推荐 4 核或以上）
GPU：如果你计划运行大型模型或进行微调，推荐使用具有较高计算能力的 GPU（如 NVIDIA 的 CUDA 支持）
内存：至少 8GB RAM，运行较大模型时推荐 16GB 或更高。
存储：需要足够的硬盘空间来存储预训练模型，通常需要 10GB 至数百 GB 的空间，具体取决于模型的大小。
软件要求：确保系统上安装了最新版本的 Python（如果打算使用 Python SDK）。

下载安装ollama

https://ollama.com/download 下载
下载完成后进行安装

运行模型

https://ollama.com/search 查找模型
下载模型 如 ollama run deepseek-r1

使用docker安装UI页面
1docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v D:\open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
进入UI页面，注册本地账号，开始使用

访问 http://localhost:3000/

Ollama API
可参考文档


关于分布式
Tue, 11 Jun 2024 20:46:01 +0800
关于分布式
一、什么是分布式？
一个系统，各组件分别部署在不同服务器。彼此通过网络通信和协调的系统。

可以指多个不同组件分布在网络上互相协作
也可以一个组件的多个副本组成集群，互相协作如同一个组件，比如数据存储服务中心为了数据不丢失而采取的多个服务备份冗余
分布式最早出现的目的首先是解决单点问题，避免单点故障，然后解决了性能问题

二、分布式和微服务的区别？

微服务并不一定是分布式系统（微服务中多个服务不一定部署在不同服务器，单机部署情况则不算是分布式）
分布式一定不是微服务 （分布式祖耀侧重服务的部署方式，微服务则是针对应用的一种服务拆分的架构）

三、分布式CAP原则
在设计一个分布式项目的时候会遇到三个特性：

一致性（Consistency）：所有节点数据实时同步，读取始终返回最新值
可用性（Availability）：每个请求必须得到响应（无论数据是否最新），高可用
分区容错（Partition Tolerance）：分布式最基本也是必需要有的特性，系统在遇到某个节点或网络分区故障时，仍然能够对外提供服务

三者无法同时满足，最多只能实现其中两个，网络分区发生时，必须牺牲C或A

‌CP（牺牲可用性）‌：如ZooKeeper，确保数据强一致性但可能拒绝请求
‌AP（牺牲一致性）‌：如Eureka，保证服务可用但允许数据短暂不一致

三、 BASE理论
BASE理论是分布式系统设计原则，BASE 是指基本可用（Basically Available）、软状态（ Soft State）、最终一致性（ Eventual Consistency），核心思想是即使无法做到强一致性（CAP 的一致性就是强一致性），但应用可以采用适合的方式达到最终一致性。



基本可用（Basically Available）：分布式系统，在出现故障的时候，允许损失部分可用性。类似服务降级




软状态（Soft State）：允许系统存在中间状态，而该中间状态不会影响系统整体可用性。这里的中间状态就是 CAP 理论中的数据不一致。




最终一致性（Eventual Consistency）：系统中的所有数据副本经过一定时间后，最终能够达到一致的状态。



四、分布式事务及解决方案
分布式事务
本地事务依赖数据库本身提供的事务特性来实现， 但是在分布式环境下，可能会出现需要远程调用，比如：
1begin transaction；
2 //1.本地数据库操作：张三减少金额
3 //2.远程调用：让李四增加金额
4commit transation;
张三和李四的账户不在一个数据库中甚至不在一个应用系统里，实现转账事务需要通过远程调用，由于网络问题就会导致分布式事务问题。
分布式事务解决方案


2PC
2PC 即两阶段提交协议，是将整个事务流程分为两个阶段，准备阶段（Prepare phase）、提交阶段（commit phase），2 是指两个阶段，P 是指准备阶段，C 是指提交阶段。偏向数据库


TCC
TCC 是 Try、Conﬁrm、Cancel 三个词语的缩写，TCC 要求每个分支事务实现三个操作：预处理 Try、确认 Conﬁrm、撤销 Cancel。Try 操作做业务检查及资源预留，Conﬁrm 做业务确认操作，Cancel 实现一个与 Try 相反的操作即回滚操作。TM 首先发起所有的分支事务的 Try 操作，任何一个分支事务的Try操作执行失败，TM 将会发起所有分支事务的 Cancel 操作，若 Try 操作全部成功，TM 将会发起所有分支事务的 Conﬁrm 操作，其中 Conﬁrm/Cancel 操作若执行失败，TM 会进行重试。偏向代码


Mysql 简易安装
Sat, 11 May 2024 13:46:01 +0800
Mysql 简易安装
安装Mysql8.0(centos8为例)， 可参考 MySQL官方文档
 1# CentOS el8下载 MySQL YUM 仓库（替换为最新版本）
 2wget https://dev.mysql.com/get/mysql80-community-release-el8-6.noarch.rpm 
 3# el9 使用sudo yum install mysql84-community-release-el9-x86_64.noarch.rpm
 4sudo rpm -Uvh mysql80-community-release-el*.rpm
 5sudo yum makecache
 6# 安装 MySQL 社区版服务器
 7# el9 的话sudo yum install mysql84-community-release-el9-x86_64.noarch.rpm
 8
 9sudo yum install -y mysql-community-server
10# 可以通过手动编辑/etc/yum.repos.d/mysql-community.repo文件来选择发布系列。
11# **install时如果出现GPG 密钥问题**
12# sudo curl -o /etc/pki/rpm-gpg/RPM-GPG-KEY-mysql-2023 https://repo.mysql.com/RPM-GPG-KEY-mysql-2023
13# sudo chmod 644 /etc/pki/rpm-gpg/RPM-GPG-KEY-mysql-2023
14# sudo rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-mysql-2023
15# 重新执行 yum install -y mysql-community-server
16
17# 启动 MySQL 服务
18sudo systemctl start mysqld
19sudo systemctl enable mysqld
20sudo systemctl status mysqld
21
22#MySQL 首次启动会生成一个临时 root 密码：
23sudo grep 'temporary password' /var/log/mysqld.log
24
25# 运行安全配置向导：
26#按提示操作：1.输入临时密码。2.置新密码（需符合复杂度要求）。3.移除匿名用户、禁止远程 root 登录、删除测试数据库等。
27sudo mysql_secure_installation
28mysql -u root -p
简单配置


MySQL分库分表（无中间件）
Tue, 23 Apr 2024 20:46:01 +0800
MySQL分库分表（无中间件）
一、 分库分表方案设计
1. 垂直拆分 (按业务模块)
 1-- 原始单体数据库
 2CREATE DATABASE ecommerce;
 3USE ecommerce;
 4
 5-- 垂直拆分后的数据库
 6-- 用户库
 7CREATE DATABASE user_center;
 8USE user_center;
 9
10CREATE TABLE users (
11 user_id BIGINT PRIMARY KEY,
12 username VARCHAR(50) UNIQUE,
13 email VARCHAR(100) UNIQUE,
14 password VARCHAR(100),
15 mobile VARCHAR(20),
16 status TINYINT DEFAULT 1,
17 created_at DATETIME,
18 updated_at DATETIME
19);
20
21CREATE TABLE user_profiles (
22 user_id BIGINT PRIMARY KEY,
23 real_name VARCHAR(50),
24 avatar VARCHAR(200),
25 gender TINYINT,
26 birthday DATE,
27 bio TEXT
28);
29
30CREATE TABLE user_address (
31 address_id BIGINT PRIMARY KEY,
32 user_id BIGINT,
33 province VARCHAR(50),
34 city VARCHAR(50),
35 district VARCHAR(50),
36 detail VARCHAR(200),
37 is_default TINYINT DEFAULT 0,
38 INDEX idx_user_id (user_id)
39);
40
41-- 订单库
42CREATE DATABASE order_center;
43USE order_center;
44
45CREATE TABLE orders (
46 order_id BIGINT PRIMARY KEY,
47 user_id BIGINT,
48 total_amount DECIMAL(10,2),
49 status TINYINT,
50 payment_status TINYINT,
51 created_at DATETIME,
52 paid_at DATETIME
53);
54
55CREATE TABLE order_items (
56 item_id BIGINT PRIMARY KEY,
57 order_id BIGINT,
58 product_id BIGINT,
59 product_name VARCHAR(100),
60 price DECIMAL(10,2),
61 quantity INT,
62 INDEX idx_order_id (order_id)
63);
64
65-- 商品库
66CREATE DATABASE product_center;
67USE product_center;
68
69CREATE TABLE products (
70 product_id BIGINT PRIMARY KEY,
71 name VARCHAR(100),
72 category_id INT,
73 price DECIMAL(10,2),
74 stock INT,
75 status TINYINT,
76 created_at DATETIME
77);
78
79CREATE TABLE categories (
80 category_id INT PRIMARY KEY,
81 name VARCHAR(50),
82 parent_id INT
83);
2. 水平拆分 （按数据量）
用户表水平分表（10个分表）
 1-- 在 user_center 数据库中创建分表
 2USE user_center;
 3
 4-- 下面语句中的//为分隔符
 5DELIMITER //
 6CREATE PROCEDURE CreateUserShards()
 7BEGIN
 8 DECLARE i INT DEFAULT 0;
 9 WHILE i < 10 DO
10 SET @sql = CONCAT('
11 CREATE TABLE users_', i, ' (
12 user_id BIGINT PRIMARY KEY,
13 username VARCHAR(50) NOT NULL,
14 email VARCHAR(100),
15 password VARCHAR(100),
16 mobile VARCHAR(20),
17 status TINYINT DEFAULT 1,
18 created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
19 updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
20 UNIQUE KEY uk_username_', i, ' (username),
21 UNIQUE KEY uk_email_', i, ' (email),
22 INDEX idx_mobile_', i, ' (mobile),
23 INDEX idx_created_', i, ' (created_at)
24 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
25 ');
26 PREPARE stmt FROM @sql;
27 EXECUTE stmt;
28 DEALLOCATE PREPARE stmt;
29 SET i = i + 1;
30 END WHILE;
31END//
32DELIMITER ;
33
34CALL CreateUserShards();
订单表水平分表（按用户ID分表）
 1USE order_center;
 2
 3DELIMITER //
 4CREATE PROCEDURE CreateOrderShards()
 5BEGIN
 6 DECLARE i INT DEFAULT 0;
 7 WHILE i < 10 DO
 8 SET @sql = CONCAT('
 9 CREATE TABLE orders_', i, ' (
10 order_id BIGINT PRIMARY KEY,
11 user_id BIGINT NOT NULL,
12 total_amount DECIMAL(10,2),
13 status TINYINT DEFAULT 1,
14 payment_status TINYINT DEFAULT 0,
15 created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
16 paid_at DATETIME,
17 INDEX idx_user_id_', i, ' (user_id),
18 INDEX idx_created_', i, ' (created_at),
19 INDEX idx_status_', i, ' (status)
20 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
21 ');
22 PREPARE stmt FROM @sql;
23 EXECUTE stmt;
24 DEALLOCATE PREPARE stmt;
25 
26 -- 创建对应的订单项分表
27 SET @sql = CONCAT('
28 CREATE TABLE order_items_', i, ' (
29 item_id BIGINT PRIMARY KEY,
30 order_id BIGINT NOT NULL,
31 product_id BIGINT,
32 product_name VARCHAR(100),
33 price DECIMAL(10,2),
34 quantity INT,
35 INDEX idx_order_id_', i, ' (order_id),
36 INDEX idx_product_id_', i, ' (product_id)
37 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
38 ');
39 PREPARE stmt FROM @sql;
40 EXECUTE stmt;
41 DEALLOCATE PREPARE stmt;
42 
43 SET i = i + 1;
44 END WHILE;
45END//
46DELIMITER ;
47
48CALL CreateOrderShards();
二、程序中处理（PHP）
1. 基础配置类
 1<?php
 2// Config.php
 3class Config {
 4 private static $instance;
 5 private $config;
 6 
 7 private function __construct() {
 8 $this->config = [
 9 'databases' => [
10 'user_center' => [
11 'host' => 'localhost',
12 'port' => 3306,
13 'username' => 'root',
14 'password' => 'password',
15 'dbname' => 'user_center'
16 ],
17 'order_center' => [
18 'host' => 'localhost',
19 'port' => 3306,
20 'username' => 'root',
21 'password' => 'password',
22 'dbname' => 'order_center'
23 ],
24 'product_center' => [
25 'host' => 'localhost',
26 'port' => 3306,
27 'username' => 'root',
28 'password' => 'password',
29 'dbname' => 'product_center'
30 ]
31 ],
32 'shard' => [
33 'user' => 10, // 用户表10个分片
34 'order' => 10 // 订单表10个分片
35 ]
36 ];
37 }
38 
39 public static function getInstance() {
40 if (!self::$instance) {
41 self::$instance = new self();
42 }
43 return self::$instance;
44 }
45 
46 public function get($key) {
47 $keys = explode('.', $key);
48 $value = $this->config;
49 
50 foreach ($keys as $k) {
51 if (!isset($value[$k])) {
52 return null;
53 }
54 $value = $value[$k];
55 }
56 
57 return $value;
58 }
59}
2. 分片路由类
 1<?php
 2// ShardRouter.php
 3class ShardRouter {
 4 private $shardConfig;
 5 
 6 public function __construct() {
 7 $config = Config::getInstance();
 8 $this->shardConfig = $config->get('shard');
 9 }
10 
11 /**
12 * 根据用户ID计算分片
13 */
14 public function getUserShard($userId) {
15 return $userId % $this->shardConfig['user'];
16 }
17 
18 /**
19 * 根据订单ID计算分片（订单按用户ID分片）
20 */
21 public function getOrderShard($orderId) {
22 // 假设订单ID包含用户ID信息
23 $userId = $this->extractUserIdFromOrderId($orderId);
24 return $userId % $this->shardConfig['order'];
25 }
26 
27 /**
28 * 根据用户名计算分片（用于登录查询）
29 */
30 public function getShardByString($str, $type = 'user') {
31 $shardCount = $this->shardConfig[$type];
32 return crc32($str) % $shardCount;
33 }
34 
35 /**
36 * 生成分布式ID（雪花算法）
37 */
38 public function generateId($shardId = 0, $timestamp = null) {
39 $timestamp = $timestamp ?? (int)(microtime(true) * 1000);
40 $workerId = $shardId % 1024;
41 $sequence = mt_rand(0, 4095);
42 
43 return (($timestamp - 1577836800000) << 22) 
44 | ($workerId << 12) 
45 | $sequence;
46 }
47 
48 /**
49 * 从订单ID提取用户ID（根据业务规则）
50 */
51 private function extractUserIdFromOrderId($orderId) {
52 // 实际业务中需要根据ID生成规则来解析
53 // 这里简单返回订单ID的低位部分作为用户ID
54 return $orderId & 0x3FFFFFFF;
55 }
56 
57 /**
58 * 获取表名
59 */
60 public function getTableName($baseTable, $shardId) {
61 return $baseTable . '_' . $shardId;
62 }
63}
3. 数据库连接管理
 1<?php
 2// DatabaseManager.php
 3class DatabaseManager {
 4 private static $instance;
 5 private $connections = [];
 6 private $config;
 7 
 8 private function __construct() {
 9 $this->config = Config::getInstance();
10 }
11 
12 public static function getInstance() {
13 if (!self::$instance) {
14 self::$instance = new self();
15 }
16 return self::$instance;
17 }
18 
19 /**
20 * 获取数据库连接
21 */
22 public function getConnection($database, $shardId = null) {
23 $key = $database . ($shardId !== null ? '_' . $shardId : '');
24 
25 if (!isset($this->connections[$key])) {
26 $dbConfig = $this->config->get("databases.{$database}");
27 
28 if (!$dbConfig) {
29 throw new Exception("Database config not found: {$database}");
30 }
31 
32 try {
33 $dsn = "mysql:host={$dbConfig['host']};port={$dbConfig['port']};dbname={$dbConfig['dbname']};charset=utf8mb4";
34 
35 $this->connections[$key] = new PDO(
36 $dsn,
37 $dbConfig['username'],
38 $dbConfig['password'],
39 [
40 PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
41 PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
42 PDO::ATTR_EMULATE_PREPARES => false,
43 PDO::ATTR_PERSISTENT => false
44 ]
45 );
46 } catch (PDOException $e) {
47 throw new Exception("Database connection failed: " . $e->getMessage());
48 }
49 }
50 
51 return $this->connections[$key];
52 }
53 
54 /**
55 * 开始事务（单分片事务）
56 */
57 public function beginTransaction($database, $shardId = null) {
58 $connection = $this->getConnection($database, $shardId);
59 return $connection->beginTransaction();
60 }
61 
62 /**
63 * 提交事务
64 */
65 public function commit($database, $shardId = null) {
66 $connection = $this->getConnection($database, $shardId);
67 return $connection->commit();
68 }
69 
70 /**
71 * 回滚事务
72 */
73 public function rollback($database, $shardId = null) {
74 $connection = $this->getConnection($database, $shardId);
75 return $connection->rollback();
76 }
77}
4. 用户服务类示例（完整CRUD）
 1<?php
 2// UserService.php
 3class UserService {
 4 private $db;
 5 private $router;
 6 
 7 public function __construct() {
 8 $this->db = DatabaseManager::getInstance();
 9 $this->router = new ShardRouter();
 10 }
 11 
 12 /**
 13 * 创建用户（写入操作）
 14 */
 15 public function createUser($userData) {
 16 // 生成用户ID
 17 $userId = $this->router->generateId();
 18 $shardId = $this->router->getUserShard($userId);
 19 
 20 $tableName = $this->router->getTableName('users', $shardId);
 21 $connection = $this->db->getConnection('user_center', $shardId);
 22 
 23 try {
 24 // 开始事务
 25 $this->db->beginTransaction('user_center', $shardId);
 26 
 27 // 插入用户基础信息
 28 $sql = "INSERT INTO {$tableName} 
 29 (user_id, username, email, password, mobile, created_at) 
 30 VALUES (?, ?, ?, ?, ?, NOW())";
 31 
 32 $stmt = $connection->prepare($sql);
 33 $stmt->execute([
 34 $userId,
 35 $userData['username'],
 36 $userData['email'],
 37 password_hash($userData['password'], PASSWORD_DEFAULT),
 38 $userData['mobile'] ?? null
 39 ]);
 40 
 41 // 插入用户档案（垂直分库，但在同一个事务中）
 42 $this->createUserProfile($userId, $userData);
 43 
 44 // 提交事务
 45 $this->db->commit('user_center', $shardId);
 46 
 47 return $userId;
 48 
 49 } catch (Exception $e) {
 50 $this->db->rollback('user_center', $shardId);
 51 throw new Exception("创建用户失败: " . $e->getMessage());
 52 }
 53 }
 54 
 55 /**
 56 * 更新用户信息
 57 */
 58 public function updateUser($userId, $updateData) {
 59 $shardId = $this->router->getUserShard($userId);
 60 $tableName = $this->router->getTableName('users', $shardId);
 61 $connection = $this->db->getConnection('user_center', $shardId);
 62 
 63 $allowedFields = ['email', 'mobile', 'password'];
 64 $setParts = [];
 65 $params = [];
 66 
 67 foreach ($updateData as $field => $value) {
 68 if (in_array($field, $allowedFields)) {
 69 if ($field === 'password') {
 70 $value = password_hash($value, PASSWORD_DEFAULT);
 71 }
 72 $setParts[] = "{$field} = ?";
 73 $params[] = $value;
 74 }
 75 }
 76 
 77 if (empty($setParts)) {
 78 throw new Exception("没有有效的更新字段");
 79 }
 80 
 81 $params[] = $userId;
 82 
 83 $sql = "UPDATE {$tableName} SET " . implode(', ', $setParts) . " WHERE user_id = ?";
 84 $stmt = $connection->prepare($sql);
 85 
 86 return $stmt->execute($params);
 87 }
 88 
 89 /**
 90 * 根据用户ID查询（精确查询）
 91 */
 92 public function getUserById($userId) {
 93 $shardId = $this->router->getUserShard($userId);
 94 $tableName = $this->router->getTableName('users', $shardId);
 95 $connection = $this->db->getConnection('user_center', $shardId);
 96 
 97 $sql = "SELECT * FROM {$tableName} WHERE user_id = ?";
 98 $stmt = $connection->prepare($sql);
 99 $stmt->execute([$userId]);
100 
101 $user = $stmt->fetch();
102 if ($user) {
103 $user['profile'] = $this->getUserProfile($userId);
104 $user['addresses'] = $this->getUserAddresses($userId);
105 }
106 
107 return $user;
108 }
109 
110 /**
111 * 根据用户名查询（需要计算分片）
112 */
113 public function getUserByUsername($username) {
114 $shardId = $this->router->getShardByString($username, 'user');
115 $tableName = $this->router->getTableName('users', $shardId);
116 $connection = $this->db->getConnection('user_center', $shardId);
117 
118 $sql = "SELECT * FROM {$tableName} WHERE username = ?";
119 $stmt = $connection->prepare($sql);
120 $stmt->execute([$username]);
121 
122 return $stmt->fetch();
123 }
124 
125 /**
126 * 批量查询用户信息
127 */
128 public function getUsersByIds($userIds) {
129 $usersByShard = [];
130 
131 // 按分片分组用户ID
132 foreach ($userIds as $userId) {
133 $shardId = $this->router->getUserShard($userId);
134 $usersByShard[$shardId][] = $userId;
135 }
136 
137 $results = [];
138 foreach ($usersByShard as $shardId => $shardUserIds) {
139 $tableName = $this->router->getTableName('users', $shardId);
140 $connection = $this->db->getConnection('user_center', $shardId);
141 
142 $placeholders = str_repeat('?,', count($shardUserIds) - 1) . '?';
143 $sql = "SELECT * FROM {$tableName} WHERE user_id IN ({$placeholders})";
144 
145 $stmt = $connection->prepare($sql);
146 $stmt->execute($shardUserIds);
147 
148 $results = array_merge($results, $stmt->fetchAll());
149 }
150 
151 return $results;
152 }
153 
154 /**
155 * 复杂查询：按条件搜索用户（需要遍历分片）
156 */
157 public function searchUsers($conditions, $page = 1, $pageSize = 20) {
158 $allUsers = [];
159 $shardCount = Config::getInstance()->get('shard.user');
160 
161 for ($shardId = 0; $shardId < $shardCount; $shardId++) {
162 $tableName = $this->router->getTableName('users', $shardId);
163 $connection = $this->db->getConnection('user_center', $shardId);
164 
165 $where = [];
166 $params = [];
167 
168 if (!empty($conditions['username'])) {
169 $where[] = "username LIKE ?";
170 $params[] = $conditions['username'] . '%';
171 }
172 
173 if (!empty($conditions['email'])) {
174 $where[] = "email LIKE ?";
175 $params[] = $conditions['email'] . '%';
176 }
177 
178 if (!empty($conditions['mobile'])) {
179 $where[] = "mobile LIKE ?";
180 $params[] = $conditions['mobile'] . '%';
181 }
182 
183 $whereClause = $where ? "WHERE " . implode(' AND ', $where) : "";
184 $offset = ($page - 1) * $pageSize;
185 
186 $sql = "SELECT * FROM {$tableName} {$whereClause} LIMIT ? OFFSET ?";
187 $params[] = $pageSize;
188 $params[] = $offset;
189 
190 $stmt = $connection->prepare($sql);
191 $stmt->execute($params);
192 
193 $shardUsers = $stmt->fetchAll();
194 $allUsers = array_merge($allUsers, $shardUsers);
195 }
196 
197 // 在PHP中进行排序和分页
198 usort($allUsers, function($a, $b) {
199 return strcmp($b['created_at'], $a['created_at']);
200 });
201 
202 return array_slice($allUsers, 0, $pageSize);
203 }
204 
205 /**
206 * 删除用户
207 */
208 public function deleteUser($userId) {
209 $shardId = $this->router->getUserShard($userId);
210 $tableName = $this->router->getTableName('users', $shardId);
211 $connection = $this->db->getConnection('user_center', $shardId);
212 
213 try {
214 $this->db->beginTransaction('user_center', $shardId);
215 
216 // 删除用户基础信息
217 $sql = "DELETE FROM {$tableName} WHERE user_id = ?";
218 $stmt = $connection->prepare($sql);
219 $stmt->execute([$userId]);
220 
221 // 删除关联数据
222 $this->deleteUserProfile($userId);
223 $this->deleteUserAddresses($userId);
224 
225 $this->db->commit('user_center', $shardId);
226 return true;
227 
228 } catch (Exception $e) {
229 $this->db->rollback('user_center', $shardId);
230 throw new Exception("删除用户失败: " . $e->getMessage());
231 }
232 }
233 
234 // 用户档案相关方法
235 private function createUserProfile($userId, $userData) {
236 $connection = $this->db->getConnection('user_center');
237 
238 $sql = "INSERT INTO user_profiles 
239 (user_id, real_name, avatar, gender, birthday, bio) 
240 VALUES (?, ?, ?, ?, ?, ?)";
241 
242 $stmt = $connection->prepare($sql);
243 return $stmt->execute([
244 $userId,
245 $userData['real_name'] ?? '',
246 $userData['avatar'] ?? '',
247 $userData['gender'] ?? 0,
248 $userData['birthday'] ?? null,
249 $userData['bio'] ?? ''
250 ]);
251 }
252 
253 private function getUserProfile($userId) {
254 $connection = $this->db->getConnection('user_center');
255 
256 $sql = "SELECT * FROM user_profiles WHERE user_id = ?";
257 $stmt = $connection->prepare($sql);
258 $stmt->execute([$userId]);
259 
260 return $stmt->fetch();
261 }
262 
263 private function getUserAddresses($userId) {
264 $connection = $this->db->getConnection('user_center');
265 
266 $sql = "SELECT * FROM user_address WHERE user_id = ? ORDER BY is_default DESC";
267 $stmt = $connection->prepare($sql);
268 $stmt->execute([$userId]);
269 
270 return $stmt->fetchAll();
271 }
272 
273 private function deleteUserProfile($userId) {
274 $connection = $this->db->getConnection('user_center');
275 
276 $sql = "DELETE FROM user_profiles WHERE user_id = ?";
277 $stmt = $connection->prepare($sql);
278 return $stmt->execute([$userId]);
279 }
280 
281 private function deleteUserAddresses($userId) {
282 $connection = $this->db->getConnection('user_center');
283 
284 $sql = "DELETE FROM user_address WHERE user_id = ?";
285 $stmt = $connection->prepare($sql);
286 return $stmt->execute([$userId]);
287 }
288}
5. 订单服务类示例
 1<?php
 2// OrderService.php
 3class OrderService {
 4 private $db;
 5 private $router;
 6 
 7 public function __construct() {
 8 $this->db = DatabaseManager::getInstance();
 9 $this->router = new ShardRouter();
 10 }
 11 
 12 /**
 13 * 创建订单
 14 */
 15 public function createOrder($orderData) {
 16 $userId = $orderData['user_id'];
 17 $shardId = $this->router->getUserShard($userId);
 18 
 19 $orderId = $this->router->generateId($shardId);
 20 $orderTable = $this->router->getTableName('orders', $shardId);
 21 $itemTable = $this->router->getTableName('order_items', $shardId);
 22 $connection = $this->db->getConnection('order_center', $shardId);
 23 
 24 try {
 25 $this->db->beginTransaction('order_center', $shardId);
 26 
 27 // 插入订单主表
 28 $sql = "INSERT INTO {$orderTable} 
 29 (order_id, user_id, total_amount, status, payment_status, created_at) 
 30 VALUES (?, ?, ?, 1, 0, NOW())";
 31 
 32 $stmt = $connection->prepare($sql);
 33 $stmt->execute([
 34 $orderId,
 35 $userId,
 36 $orderData['total_amount']
 37 ]);
 38 
 39 // 插入订单项
 40 foreach ($orderData['items'] as $item) {
 41 $itemId = $this->router->generateId($shardId);
 42 
 43 $sql = "INSERT INTO {$itemTable} 
 44 (item_id, order_id, product_id, product_name, price, quantity) 
 45 VALUES (?, ?, ?, ?, ?, ?)";
 46 
 47 $stmt = $connection->prepare($sql);
 48 $stmt->execute([
 49 $itemId,
 50 $orderId,
 51 $item['product_id'],
 52 $item['product_name'],
 53 $item['price'],
 54 $item['quantity']
 55 ]);
 56 }
 57 
 58 $this->db->commit('order_center', $shardId);
 59 return $orderId;
 60 
 61 } catch (Exception $e) {
 62 $this->db->rollback('order_center', $shardId);
 63 throw new Exception("创建订单失败: " . $e->getMessage());
 64 }
 65 }
 66 
 67 /**
 68 * 更新订单状态
 69 */
 70 public function updateOrderStatus($orderId, $status) {
 71 $shardId = $this->router->getOrderShard($orderId);
 72 $tableName = $this->router->getTableName('orders', $shardId);
 73 $connection = $this->db->getConnection('order_center', $shardId);
 74 
 75 $sql = "UPDATE {$tableName} SET status = ?, updated_at = NOW() WHERE order_id = ?";
 76 $stmt = $connection->prepare($sql);
 77 
 78 return $stmt->execute([$status, $orderId]);
 79 }
 80 
 81 /**
 82 * 根据订单ID查询
 83 */
 84 public function getOrderById($orderId) {
 85 $shardId = $this->router->getOrderShard($orderId);
 86 $orderTable = $this->router->getTableName('orders', $shardId);
 87 $itemTable = $this->router->getTableName('order_items', $shardId);
 88 $connection = $this->db->getConnection('order_center', $shardId);
 89 
 90 // 查询订单基本信息
 91 $sql = "SELECT * FROM {$orderTable} WHERE order_id = ?";
 92 $stmt = $connection->prepare($sql);
 93 $stmt->execute([$orderId]);
 94 
 95 $order = $stmt->fetch();
 96 if ($order) {
 97 // 查询订单项
 98 $sql = "SELECT * FROM {$itemTable} WHERE order_id = ?";
 99 $stmt = $connection->prepare($sql);
100 $stmt->execute([$orderId]);
101 $order['items'] = $stmt->fetchAll();
102 }
103 
104 return $order;
105 }
106 
107 /**
108 * 查询用户订单列表
109 */
110 public function getUserOrders($userId, $page = 1, $pageSize = 20) {
111 $shardId = $this->router->getUserShard($userId);
112 $tableName = $this->router->getTableName('orders', $shardId);
113 $connection = $this->db->getConnection('order_center', $shardId);
114 
115 $offset = ($page - 1) * $pageSize;
116 
117 $sql = "SELECT * FROM {$tableName} 
118 WHERE user_id = ? 
119 ORDER BY created_at DESC 
120 LIMIT ? OFFSET ?";
121 
122 $stmt = $connection->prepare($sql);
123 $stmt->execute([$userId, $pageSize, $offset]);
124 
125 return $stmt->fetchAll();
126 }
127}
6. 使用示例
6.1 用户注册和订单创建
 1<?php
 2// register_and_order.php
 3require_once 'Config.php';
 4require_once 'ShardRouter.php';
 5require_once 'DatabaseManager.php';
 6require_once 'UserService.php';
 7require_once 'OrderService.php';
 8
 9try {
10 // 初始化服务
11 $userService = new UserService();
12 $orderService = new OrderService();
13 
14 // 1. 创建用户
15 $userData = [
16 'username' => 'zhangsan',
17 'email' => 'zhangsan@example.com',
18 'password' => '123456',
19 'mobile' => '13800138000',
20 'real_name' => '张三',
21 'avatar' => 'avatar.jpg'
22 ];
23 
24 $userId = $userService->createUser($userData);
25 echo "用户创建成功，ID: {$userId}\n";
26 
27 // 2. 为用户创建订单
28 $orderData = [
29 'user_id' => $userId,
30 'total_amount' => 299.00,
31 'items' => [
32 [
33 'product_id' => 1001,
34 'product_name' => 'iPhone 14',
35 'price' => 299.00,
36 'quantity' => 1
37 ]
38 ]
39 ];
40 
41 $orderId = $orderService->createOrder($orderData);
42 echo "订单创建成功，ID: {$orderId}\n";
43 
44 // 3. 查询用户信息
45 $user = $userService->getUserById($userId);
46 echo "用户信息: " . json_encode($user, JSON_UNESCAPED_UNICODE) . "\n";
47 
48 // 4. 查询订单信息
49 $order = $orderService->getOrderById($orderId);
50 echo "订单信息: " . json_encode($order, JSON_UNESCAPED_UNICODE) . "\n";
51 
52 // 5. 查询用户订单列表
53 $orders = $orderService->getUserOrders($userId);
54 echo "用户订单数量: " . count($orders) . "\n";
55 
56} catch (Exception $e) {
57 echo "操作失败: " . $e->getMessage() . "\n";
58}
6.2 批量操作示例
 1<?php
 2// batch_operations.php
 3require_once 'UserService.php';
 4
 5$userService = new UserService();
 6
 7// 批量查询用户信息
 8$userIds = [123456, 234567, 345678, 456789];
 9$users = $userService->getUsersByIds($userIds);
10echo "批量查询到 " . count($users) . " 个用户\n";
11
12// 复杂搜索
13$conditions = [
14 'username' => 'zhang',
15 'mobile' => '138'
16];
17$users = $userService->searchUsers($conditions, 1, 10);
18echo "搜索到 " . count($users) . " 个用户\n";
19
20// 更新用户信息
21$updateResult = $userService->updateUser(123456, [
22 'email' => 'new_email@example.com',
23 'mobile' => '13900139000'
24]);
25echo "更新结果: " . ($updateResult ? '成功' : '失败') . "\n";
三、 总结
写入操作：


先计算分片：根据分片键（如用户ID）计算目标分片


MySQL索引类型
Tue, 23 Apr 2024 20:46:01 +0800
MySQL索引类型
索引是帮助MySQL高效获取数据的数据结构，类似于书籍的目录，可以大大加快查询速度。
一、索引类型
1. B-Tree 索引（最常用）
特点

默认的索引类型
适用于全键值、键值范围或键值前缀查找
支持排序和分组

创建语法
 1-- 单列索引
 2CREATE INDEX idx_name ON table_name(column_name);
 3
 4-- 多列复合索引
 5CREATE INDEX idx_name ON table_name(col1, col2, col3);
 6
 7-- 创建表时指定
 8CREATE TABLE users (
 9 id INT PRIMARY KEY,
10 name VARCHAR(50),
11 email VARCHAR(100),
12 age INT,
13 INDEX idx_name (name),
14 INDEX idx_email_age (email, age)
15);
适用查询类型
 1-- 全值匹配
 2SELECT * FROM users WHERE name = 'John';
 3
 4-- 前缀匹配（最左前缀）
 5SELECT * FROM users WHERE name LIKE 'Joh%';
 6
 7-- 范围查询
 8SELECT * FROM users WHERE age BETWEEN 20 AND 30;
 9
10-- 精确匹配左列 + 范围匹配右列
11SELECT * FROM users WHERE email = 'john@example.com' AND age > 25;
12
13-- 排序
14SELECT * FROM users ORDER BY name;
15
16-- 分组
17SELECT COUNT(*), age FROM users GROUP BY age;
最左前缀原则示例
 1-- 复合索引: (last_name, first_name, age)
 2
 3-- 使用索引的情况
 4SELECT * FROM users WHERE last_name = 'Smith';
 5SELECT * FROM users WHERE last_name = 'Smith' AND first_name = 'John';
 6SELECT * FROM users WHERE last_name = 'Smith' AND first_name = 'John' AND age = 30;
 7SELECT * FROM users WHERE last_name = 'Smith' AND age > 25; -- 只使用last_name部分
 8
 9-- 不能使用索引的情况
10SELECT * FROM users WHERE first_name = 'John'; -- 跳过了last_name
11SELECT * FROM users WHERE age = 30; -- 跳过了前两列
2. 哈希索引
特点

基于哈希表实现
只能用于等值比较（=, IN）
不支持范围查询和排序
Memory存储引擎默认索引类型

创建语法
1-- 只能在MEMORY表上创建哈希索引
2CREATE TABLE memory_table (
3 id INT,
4 data VARCHAR(100),
5 INDEX USING HASH (id)
6) ENGINE=MEMORY;
7
8-- 或者
9CREATE INDEX idx_hash ON memory_table(id) USING HASH;
适用场景
1-- 等值查询（快速）
2SELECT * FROM memory_table WHERE id = 100;
3
4-- 不支持范围查询
5SELECT * FROM memory_table WHERE id > 100; -- 不会使用哈希索引
自适应哈希索引（InnoDB）
InnoDB会自动在内存中为频繁访问的索引页创建哈希索引，这是自动的，无需手动创建。


Mysql中的回表
Tue, 23 Apr 2024 20:46:01 +0800
MYSQL中的回（Back to Table）表说明
一、 基本概念
回表是指当使用非聚簇索引（二级索引）进行查询时，首先在索引中查找到所需数据的主键值，然后再根据这个主键值回到主键索引（聚簇索引）中查找完整数据行的过程。
二、核心原理
聚簇索引 vs 非聚簇索引
 1-- 创建测试表
 2CREATE TABLE user_info (
 3 id INT PRIMARY KEY, -- 主键，聚簇索引
 4 name VARCHAR(50), 
 5 email VARCHAR(100),
 6 age INT,
 7 created_at DATETIME,
 8 INDEX idx_email (email), -- 非聚簇索引（二级索引）
 9 INDEX idx_name_age (name, age) -- 复合非聚簇索引
10);
索引结构对比
聚簇索引（主键索引）结构：
1索引节点 -> 叶子节点包含完整数据行
2[id:1] -> [id:1, name:'张三', email:'zhang@xx.com', age:25, ...]
3[id:2] -> [id:2, name:'李四', email:'li@xx.com', age:30, ...]
非聚簇索引（二级索引）结构：
1索引节点 -> 叶子节点只包含索引列 + 主键值
2[email:'li@xx.com'] -> [主键id:2]
3[email:'zhang@xx.com'] -> [主键id:1]
三、 回表现象详解
示例1：基本的回表查询
1-- 这个查询会发生回表
2EXPLAIN SELECT * FROM user_info WHERE email = 'zhang@xx.com';
查询过程：

在 idx_email 索引中查找 email = ‘zhang@xx.com’
找到对应的主键值 id = 1
使用 id = 1 回到聚簇索引中查找完整数据行
返回所有列的数据

EXPLAIN 结果：
1type: ref
2key: idx_email
3Extra: Using index condition
示例2：覆盖索引避免回表
1-- 这个查询不会回表（覆盖索引）
2EXPLAIN SELECT id, email FROM user_info WHERE email = 'zhang@xx.com';
查询过程：

在 idx_email 索引中查找 email = ‘zhang@xx.com’
索引中已经包含所需的 id 和 email 列
直接返回结果，无需回表

EXPLAIN 结果：
1type: ref
2key: idx_email
3Extra: Using index ← 这个表示使用了覆盖索引
四、 实际案例演示
准备测试数据
 1-- 创建详细的测试表
 2CREATE TABLE employee (
 3 emp_id INT PRIMARY KEY AUTO_INCREMENT,
 4 emp_name VARCHAR(50) NOT NULL,
 5 department VARCHAR(50),
 6 salary DECIMAL(10,2),
 7 hire_date DATE,
 8 email VARCHAR(100),
 9 phone VARCHAR(20),
10 INDEX idx_department (department),
11 INDEX idx_email (email),
12 INDEX idx_hire_date (hire_date),
13 INDEX idx_department_salary (department, salary)
14);
15
16-- 插入测试数据
17INSERT INTO employee (emp_name, department, salary, hire_date, email, phone) VALUES
18('张三', '技术部', 15000, '2020-01-15', 'zhang@company.com', '13800138001'),
19('李四', '技术部', 12000, '2021-03-20', 'li@company.com', '13800138002'),
20('王五', '销售部', 8000, '2022-06-10', 'wang@company.com', '13800138003'),
21('赵六', '销售部', 7500, '2022-08-05', 'zhao@company.com', '13800138004'),
22('钱七', '人事部', 9000, '2021-09-15', 'qian@company.com', '13800138005');
案例1：明显的回表查询
1-- 查询1：会发生回表
2EXPLAIN SELECT * FROM employee WHERE department = '技术部';
执行过程分析：

使用 idx_department 索引找到所有 department = ‘技术部’ 的记录
获取对应的主键值 emp_id
用这些 emp_id 回表到聚簇索引查询完整数据
返回所有字段

案例2：避免回表的覆盖索引
1-- 查询2：覆盖索引，避免回表
2EXPLAIN SELECT emp_id, department FROM employee WHERE department = '技术部';
执行过程分析：

使用 idx_department 索引找到所有 department = ‘技术部’ 的记录
索引中已经包含 emp_id 和 department 字段
直接返回，无需回表

案例3：复合索引的回表情况
1-- 查询3：复合索引，但需要回表
2EXPLAIN SELECT emp_id, emp_name, department, salary 
3FROM employee 
4WHERE department = '技术部' AND salary > 10000;
执行过程分析：

使用 idx_department_salary 索引找到符合条件的记录
索引中包含 department, salary, emp_id
但是 emp_name 字段不在索引中，需要回表查询

五、 如何识别回表
使用 EXPLAIN 分析
1-- 查看执行计划判断是否回表
2EXPLAIN SELECT * FROM employee WHERE email = 'zhang@company.com';
3
4-- 重点关注 Extra 字段：
5-- "Using index": 覆盖索引，无回表 ✓
6-- "Using index condition": 使用索引，但需要回表
7-- "Using where": 可能回表
实际测试对比
 1-- 测试1：需要回表的查询
 2EXPLAIN 
 3SELECT emp_name, department, salary, email, phone 
 4FROM employee 
 5WHERE department = '技术部';
 6
 7-- 测试2：覆盖索引查询（无回表）
 8EXPLAIN 
 9SELECT emp_id, department 
10FROM employee 
11WHERE department = '技术部';
12
13-- 测试3：部分回表
14EXPLAIN 
15SELECT emp_id, department, emp_name 
16FROM employee 
17WHERE department = '技术部';
六、 回表的性能影响
性能测试对比
 1-- 创建大数据量表进行测试
 2CREATE TABLE large_table (
 3 id INT PRIMARY KEY AUTO_INCREMENT,
 4 data1 VARCHAR(100),
 5 data2 VARCHAR(100),
 6 data3 VARCHAR(100),
 7 index_col INT,
 8 INDEX idx_index_col (index_col)
 9);
10
11-- 插入10万条测试数据
12DELIMITER //
13CREATE PROCEDURE InsertTestData()
14BEGIN
15 DECLARE i INT DEFAULT 0;
16 WHILE i < 100000 DO
17 INSERT INTO large_table (data1, data2, data3, index_col) 
18 VALUES (CONCAT('data1_', i), CONCAT('data2_', i), CONCAT('data3_', i), i);
19 SET i = i + 1;
20 END WHILE;
21END//
22DELIMITER ;
23
24CALL InsertTestData();
性能对比查询
1-- 需要回表的查询（慢）
2SELECT * FROM large_table WHERE index_col BETWEEN 1000 AND 2000;
3
4-- 覆盖索引查询（快）
5SELECT id, index_col FROM large_table WHERE index_col BETWEEN 1000 AND 2000;
七、 如何避免回表
方法1：使用覆盖索引
1-- 创建覆盖索引
2CREATE INDEX idx_covering ON employee(department, salary, emp_name);
3
4-- 现在这个查询不会回表
5EXPLAIN 
6SELECT emp_id, department, salary, emp_name 
7FROM employee 
8WHERE department = '技术部' AND salary > 10000;
方法2：只查询需要的列
1-- 不好的写法：查询所有列
2SELECT * FROM employee WHERE email = 'zhang@company.com';
3
4-- 好的写法：只查询需要的列
5SELECT emp_id, emp_name, email FROM employee WHERE email = 'zhang@company.com';
6
7-- 更好的写法：创建覆盖索引
8CREATE INDEX idx_covering_email ON employee(email, emp_name);
9SELECT emp_name, email FROM employee WHERE email = 'zhang@company.com';
方法3：优化复合索引设计
1-- 根据查询需求设计覆盖索引
2-- 常见查询：按部门查询员工信息和薪资
3CREATE INDEX idx_dept_covering ON employee(department, salary, emp_name, hire_date);
4
5-- 现在这些查询都可以使用覆盖索引：
6SELECT emp_name, salary FROM employee WHERE department = '技术部';
7SELECT department, AVG(salary) FROM employee GROUP BY department;
8SELECT emp_name, hire_date FROM employee WHERE department = '销售部' ORDER BY hire_date;
八、实际业务场景优化
场景1：用户查询优化
 1-- 原始表结构
 2CREATE TABLE users (
 3 user_id INT PRIMARY KEY,
 4 username VARCHAR(50),
 5 email VARCHAR(100),
 6 phone VARCHAR(20),
 7 real_name VARCHAR(50),
 8 avatar_url VARCHAR(200),
 9 created_time DATETIME,
10 INDEX idx_email (email)
11);
12
13-- 问题：根据email查询用户信息需要回表
14SELECT * FROM users WHERE email = 'user@example.com';
15
16-- 优化：创建覆盖索引
17CREATE INDEX idx_email_covering ON users(email, username, avatar_url);
18
19-- 优化后的查询（页面展示常用字段）
20SELECT user_id, username, email, avatar_url 
21FROM users 
22WHERE email = 'user@example.com';
场景2：订单查询优化
 1-- 订单表
 2CREATE TABLE orders (
 3 order_id BIGINT PRIMARY KEY,
 4 user_id INT,
 5 amount DECIMAL(10,2),
 6 status VARCHAR(20),
 7 create_time DATETIME,
 8 update_time DATETIME,
 9 INDEX idx_user_status (user_id, status)
10);
11
12-- 常见查询：用户订单列表
13-- 需要回表的查询
14SELECT * FROM orders WHERE user_id = 123 AND status = 'completed';
15
16-- 优化为覆盖索引
17CREATE INDEX idx_user_status_covering ON orders(user_id, status, order_id, amount, create_time);
18
19-- 优化后的查询（列表页面需要的字段）
20SELECT order_id, amount, create_time 
21FROM orders 
22WHERE user_id = 123 AND status = 'completed';
总结
回表的关键点：

触发条件：使用二级索引且查询字段不全部在索引中
性能影响：额外的磁盘I/O，降低查询性能
识别方法：EXPLAIN查看执行计划，关注"Using index"
避免方法：


使用覆盖索引


Mysql中的事务及隔离级别
Tue, 23 Apr 2024 20:46:01 +0800
MySQL事务与隔离级别深度解析
一、 事务基础概念
1. 什么是事务
事务(Transaction)是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作。事务具有以下四个关键特性(ACID)：


原子性(Atomicity)：事务中的所有操作要么全部完成，要么全部不完成


一致性(Consistency)：事务执行前后，数据库从一个一致状态变到另一个一致状态


隔离性(Isolation)：多个事务并发执行时，一个事务的执行不应影响其他事务


持久性(Durability)：事务一旦提交，其结果就是永久性的


2. MySQL中的事务控制语句
1START TRANSACTION; -- 或 BEGIN
2-- 执行SQL操作
3COMMIT; -- 提交事务
4ROLLBACK; -- 回滚事务
二、事务隔离级别详解
1. 四种标准隔离级别
MySQL支持四种事务隔离级别，控制不同事务之间的可见性：

	
			
					隔离级别
					脏读
					不可重复读
					幻读
					说明
			
	
	
			
					READ UNCOMMITTED（读未提交）
					可能
					可能
					可能
					最低隔离级别
			
			
					READ COMMITTED（读已提交）
					不可能
					可能
					可能
					大多数数据库默认级别
			
			
					REPEATABLE READ（可重复读）
					不可能
					不可能
					可能
					MySQL默认级别
			
			
					SERIALIZABLE（序列化）
					不可能
					不可能
					不可能
					最高隔离级别
			
	

2. 并发问题说明


脏读(Dirty Read)：读取到其他事务未提交的数据


不可重复读(Non-repeatable Read)：同一事务内多次读取同一数据结果不同


幻读(Phantom Read)：同一事务内多次查询返回不同的行集合


3. 隔离级别设置与查看
1-- 设置当前会话隔离级别
2SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
3
4-- 设置全局隔离级别
5SET GLOBAL TRANSACTION ISOLATION LEVEL REPEATABLE READ;
6
7-- 查看当前隔离级别
8SELECT @@transaction_isolation;
三、各隔离级别实现机制
1. READ UNCOMMITTED
实现方式：不加锁，直接读取最新数据（包括其他事务未提交的）


Mysql中的锁
Tue, 23 Apr 2024 20:46:01 +0800
MYSQL中的锁
一、 MySQL锁概述
MySQL锁机制是数据库管理系统实现并发控制的核心技术，它通过在共享资源上实施访问限制，确保数据的一致性和完整性。作为PHP高级开发者，深入理解MySQL锁机制对于构建高性能、高并发的Web应用至关重要。
二、 MySQL锁分类体系
1. 按锁的粒度划分
1. 表级锁
特点

开销小，加锁快
锁定整个表
并发度低
使用场景

1-- 显式加表锁
2LOCK TABLES users READ; -- 共享锁
3LOCK TABLES users WRITE; -- 排他锁
4
5-- 操作完成后释放
6UNLOCK TABLES;
注意事项：

MyISAM引擎默认使用表锁
在InnoDB上应谨慎使用，会严重影响并发

2. 行级锁
特点

开销大，加锁慢
只锁定需要的行
并发度高
使用场景

1-- 共享锁(S锁)
2SELECT * FROM accounts WHERE id = 1 LOCK IN SHARE MODE;
3-- MySQL 8.0+推荐语法
4SELECT * FROM accounts WHERE id = 1 FOR SHARE;
5
6-- 排他锁(X锁)
7SELECT * FROM accounts WHERE id = 1 FOR UPDATE;
注意事项：


rabbitmq工作原理
Tue, 23 Apr 2024 20:46:01 +0800
rabbitmq工作原理
一、概念
AMQP协议
AMQP是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言等条件的限制。

AMQP协议是一种二进制协议，提供客户端应用与消息中间件之间异步、安全、高效地交互。

AMQP作为中间层服务，把消息生产和消费分割出来，当消息生产者出现异常，不影响消费者对消息的消费，当消费者异常时，生产者生产的消息可以存放到服务的内存或者磁盘，不以影响到消息的消费，同时，消息也可以基于路由的规则可以投递到指定的消费者消费。

AMQP基于模块化通过Exchange和Message Queue两个组件组合实现消息路由分发

生产者和消费者
生产者是生产消息的主体，消费者是消费消息的主体

数据集成与系统解耦、异步处理与事件驱动、流量削峰、事务消息与分布式事务的最终一致等

生产者生产一条消息丢给消息代理，消息代理根据投递规则将消息传送到消费者手上

交换机
交换机就像是消息代理的路由器，负责拿到一个消息之后，根据确定的规则（路由键）将他路由给一个或零个队列、交换机具备多种路由模式。

基于消息生产者和路由规则可以将消息投递到指定的Message Queue，交换机收到生产者投递的消息，基于路由规则及队列绑定关系匹配到投递对应的交换机或者队列进行分发，交换机不存储消息，只做转发

直连交换机：根据路由键完全匹配的投递到对应的队列。

扇形交换机：无视路由键，将消息进行拷贝，并路由到给绑定到它身上的所有队列，提供了一个广播的效果

主题交换机： 根据路由键按模式匹配的投递到对应的队列

交换机也具备自己的属性，可以定义自己的名字，是否持久化等选项

队列
消息的暂存地，至少有一个消费者订阅了队列的话，消息会立即发送给这些订阅的消费者。但是如果消息到达了无人的订阅队列，消息会在队列中等待，等待有了消费者便进行分发

Exchange和Message Queue之间存在绑定关系，消息到了Exchange后基于路由策略可以将消息投递到已绑定且符合路由策略的Message Queue。

消息队列会将消息存储到内存或者磁盘中，并将这些消息按照一定顺序转发给一个或多个消费者，每个消息队列都是独立隔离的，相互不影响。

消息队列具有不同的属性：私有，共享，持久化，临时，客户端定义或者服务端定义等，可以基于实际需求选择对应的类型

消息
消息是信息的载体，也是MAQP协议的一个实体，消息包含以下两部分
载荷：就是真正的信息，是你想要传输的任何内容，该部分内容对消息代理来说是透明的
元消息：包含路由键、内容类型、编码、是否持久化等等消息属性，会被消息代理所解析，消息代理根据消息的属性对这条消息进行投递，存储等。这部分被消息代理所关心，而消费者对其是不关心的

信道
网络信道，是建立在Connection连接之上的一种轻量级的连接。几乎所有的操作都在Chanel中进行，Channel是进行消息读写的通道，客户端可以建立对各Channel，每个Channel代表一个会话任务

如果把Connection比作一条光纤电缆的话，那么Channel信道就比作成光纤电缆中的其中一束光纤。一个Connection上可以创建任意数量的Channel。

大部分的业务操作是在Channel这个接口中完成的

队列声明 queueDeclare
交换机的声明 ExchangeDeclare
队列的绑定 queueBind
发布消息 basicPublish
消费消息 basicConsume

二、Rabbitmq 工作模式
2.1 简单模式
生产者p发送消息到队列，消费者c消费消息。（无交换机消息直接进入队列）
p->queue->c
2.2 工作模式
一个生产者p发送消息到队列，队列将消息分配给多个消费者c1,c2。（实现负载均衡，适合集群异步处理，典型场景：发送邮件、短信等）
p->queue|->c1
|->c2
2.3 订阅模式，每个队列的消息都是一样的
使用广播类型的交换机e, 生产者p把消息发送到交换机e，交换机e把消息发送到和交换机绑定的队列c4、c5(每个消费者接收相同的消息。典型应用场景：天气订阅，微博订阅等)
 |->c4
p->e->|
 |->c5
2.4 路由模式
使用Direct类型的交换机，生产者p发送消息到交换机e，交换机E根据路由键（如error发送到c1）匹配队列，消息仅发送到匹配的队列（与订阅模式的区别：按条件筛选发送）


RabbitMQ详解
Tue, 23 Apr 2024 20:46:01 +0800
RabbitMQ详解
一、为什么需要 RabbitMQ？
1.1 它能解决什么问题？
在分布式系统中，服务间的通信面临着诸多挑战。RabbitMQ 通过“生产者-消费者”模型，有效解决了以下痛点：
系统解耦
在紧耦合架构中，订单系统需要直接调用库存、支付、物流等多个服务。一旦某个服务接口变更，所有依赖方都需调整。通过 RabbitMQ，订单系统只需发送一条“订单创建”消息，其他服务订阅即可，服务之间无需直接关联。
异步通信
同步调用中，用户需要等待所有下游操作完成才能得到响应。例如，注册后发送邮件、短信、初始化数据等耗时操作，如果全部同步执行，用户体验会非常差。通过 RabbitMQ，主流程可立即返回，后台消费者异步处理这些非核心任务。
流量削峰
秒杀、大促场景下，瞬时请求可能高达数万 QPS，直接冲击数据库会导致系统崩溃。RabbitMQ 可以作为缓冲器，将突发请求暂存到队列中，后端服务按自身处理能力逐步消费，确保系统平稳运行。
1.2 举例：快递分拣中心
可以把 RabbitMQ 想象成一个快递分拣中心：

生产者：寄快递的人，把包裹交给分拣中心
交换机：分拣中心的分拣员，根据地址决定包裹去哪个区域
队列：小区快递柜，暂存等待领取的包裹
消费者：取快递的人，从快递柜取走包裹

寄件人无需等待收件人当场签收，分拣中心会负责精准投递，收件人按需取件——这就是异步解耦的本质。
二、核心架构与工作流程
2.1 核心组件
RabbitMQ 的架构围绕以下核心组件展开：

	
			
					组件
					作用
					类比
			
	
	
			
					生产者（Producer）
					创建并发送消息
					寄快递的人
			
			
					交换机（Exchange）
					接收消息，根据规则路由到队列
					快递分拣员
			
			
					绑定（Binding）
					建立交换机与队列的关联，指定路由规则
					分拣中心与快递柜的配送路线
			
			
					队列（Queue）
					存储消息的容器
					小区快递柜
			
			
					消费者（Consumer）
					从队列获取并处理消息
					取快递的人
			
			
					连接（Connection）
					与 RabbitMQ 服务器的 TCP 连接
					公路
			
			
					信道（Channel）
					复用连接的轻量级通信通道
					公路上的车道
			
	

关键概念：信道（Channel） 是理解 RabbitMQ 性能的关键。每次创建和关闭 TCP 连接的开销很大，信道则允许在一个 TCP 连接上并发进行多个通信，大幅提升效率。
2.2 消息流转全流程
一条消息从生产到消费，经历以下步骤：


Redis分布式锁
Tue, 23 Apr 2024 20:46:01 +0800
Redis分布式锁
一、 Redis锁基础概念
1. 为什么需要Redis锁
Redis锁是一种基于内存数据库Redis实现的分布式锁机制，主要解决分布式系统中的资源竞争问题。相比数据库锁，Redis锁具有以下优势

高性能：基于内存操作，响应速度快
原子性保证：Redis单线程模型天然支持原子操作
分布式支持：可跨多台服务器使用
丰富的数据结构：支持多种锁实现方式

2. 基本实现原理
最简单的Redis锁实现方式：
SET resource_name my_random_value NX PX 30000

NX：仅当key不存在时设置
PX：设置过期时间(毫秒)
my_random_value：唯一标识，用于安全释放锁

二、Redis锁的实现方式
1. SETNX实现（基本方式）
实现步骤：

尝试获取锁：SETNX lock_key 1
获取成功则设置过期时间：EXPIRE lock_key 30
执行业务逻辑
释放锁：DEL lock_key

问题： 非原子操作，SETNX和EXPIRE之间可能崩溃导致死锁
2. SET扩展参数实现（推荐）
Redis 2.6.12+版本支持扩展参数，可原子性完成设置
SET lock_key unique_value NX PX 30000
PHP实现示例：
 1$redis = new Redis();
 2$redis->connect('127.0.0.1', 6379);
 3
 4$lockKey = 'order_lock_123';
 5$uniqueId = uniqid();
 6$expire = 30000; // 30秒
 7
 8// 尝试获取锁
 9$acquired = $redis->set($lockKey, $uniqueId, ['NX', 'PX' => $expire]);
10
11if ($acquired) {
12 try {
13 // 执行业务逻辑
14 processOrder();
15 } finally {
16 // 使用Lua脚本保证原子性释放
17 $script = "
18 if redis.call('get', KEYS[1]) == ARGV[1] then
19 return redis.call('del', KEYS[1])
20 else
21 return 0
22 end
23 ";
24 $redis->eval($script, [$lockKey, $uniqueId], 1);
25 }
26} else {
27 // 获取锁失败
28 handleLockFailure();
29}
3. RedLock算法（分布式环境）
Redis官方推荐的分布式锁算法，适用于多Redis节点场景：


Redis高可用
Tue, 23 Apr 2024 20:46:01 +0800
Redis高可用
1. 事务机制和IO多路复用
1.1 事务
1.1.1 事务特点

事务提交前，先检查命令语法是否正确
提交后的命令一定会执行
有命令报错，也会执行完
不能回滚

1.1.2 命令

multi，告诉Redis服务器开启一个事务。只是开启而不是执行。
exec, 告诉Redis开始执行事务
discard，告诉Redis取消事务
watch，监视某一个键值对，它的作用是在事务执行之前如果监视的键值被修改，事务会被取消

1.2 IO多路复用
redis 是单线程，单线程只能在一个CPU内核上执行，假如是4核的，只会占用一个，其它三个不参与。 worker线程串行 read读->计算->write返回
在Redis6.0加入了io-threads， 主线程worker只进行计算，并行读取
io-threads 4
io-threads-do-reads yes
2. 持久化和过期淘汰策略
2.1 持久化
Redis是存储在内存中的， 服务器重启数据会丢失。持久化方案可以保存数据到磁盘文件，可以恢复到内存中。Redis提供的持久化方案有：

rdb：生成某一时刻的快照，保存到二进制文件中

优点：

容灾性好，方便备份
性能最大化，fork出一个子进程来操作，对主进程没有影响
数据较多时，相对于aof启动效率更高


缺点：

会造成数据丢失





aof：实时记录每一条写命令，追加到文件中，打开可以看到具体的操作记录

同步策略：appendfsync

everysec(默认),每秒同步一次
always，每次操作后都要同步一次
no,由操作系统调度进行同步


重写策略：

手动触发，执行bgrewiteaof命令
自动触发：auto-rewrite-percentage 100, auto-rewrite-min-size 64mb


优点

数据安全，不会造成数据的丢失


缺点

比rdb重启效率低；运行效率比rdb低




混合模式：上面两种方式的结合

触发方式有两种：

手动触发：

save命令，会让Redis处于阻塞的状态，直到rdb持久化完成，线上环境谨慎使用
bgsave命令,它会fork出一个子进程（有短暂阻塞），用来执行持久化，主进程继续响应客户端请求


自动触发：

配置文件修改（save n m），在n秒内,有m个key发生变化就会触发，执行命令最总执行的是bgsave



2.2 过期键删除策略
Redis设置key时，都会设置一个过期时间，Redis同时使用了两种过期删除策略，惰性过期和定时过期


NGINX负载均衡
Sat, 20 Apr 2024 20:46:01 +0800
NGINX负载均衡
Nginx是一个强大的开源Web服务器和反向代理服务器，它支持正向代理和反向代理功能。
正向代理
正向代理是客户端访问代理服务器去访问目标服务器，并且对目标服务器隐藏了客户端的真实信息（IP等信息）
正向代理的主要用途包括：

访问被限制的资源：当某些资源受到网络限制或访问限制时，可以使用正向代理绕过这些限制来获取资源。
提高访问速度：代理服务器可以缓存经常请求的资源，从而提高客户端访问资源的速度。
突破防火墙：正向代理可以帮助绕过企业或国家防火墙的限制，访问被封锁的网站或资源。

反向代理
反向代理是指代理服务器接收客户端的请求，然后反向代理将客户端的请求分发给一个或多个目标服务器，最后将响应返回给客户端，对于客户端隐藏了真实的服务端信息
反向代理的主要用途包括：

负载均衡：反向代理可以根据一定的算法将请求均匀地分发给后端的多台服务器，从而实现负载均衡，提高系统的并发处理能力和稳定性。
缓存静态资源：反向代理可以缓存经常请求的静态资源，减少后端服务器的负载，提高网站的访问速度。
安全性和可靠性：反向代理可以作为防火墙和安全设备，提供安全认证、访问控制、DDoS攻击防护等功能。

Nginx配置文件
#user nobody; 是用来指定 Nginx 进程运行的用户和用户组的配置项。 在 Linux 系统中，各个进程需要以某个用户的身份来运行，以限制权限并提高安全性
worker_processes 1;
 
events {
 worker_connections 1024;
}
 
http {
 include mime.types;
 default_type application/octet-stream;
 sendfile on;
 keepalive_timeout 65;
 
 server {
 listen 8080;
 server_name localhost;
 
 location / {
 root html;
 index index.html index.htm;
 }
 error_page 500 502 503 504 /50x.html;
 location = /50x.html {
 root html;
 }
 }
}
第一部分 全局块worker_processes:


Redis主从复制
Wed, 20 Mar 2024 20:46:01 +0800
Redis主从复制
一、什么是Redis主从复制
1. 从复制的架构：
Redis Replication是一种 master-slave 模式的复制机制，这种机制使得 slave 节点可以成为与 master 节点完全相同的副本，可以采用一主多从或者级联结构。
主从复制的配置要点：

配从库不配主，从库配置：slaveof 主库IP 主库端口
查看redis的配置信息：info replication

2. Redis为什么需要主从复制？
使用Redis主从复制的原因主要是单台Redis节点存在以下的局限性：

Redis虽然读写的速度都很快，单节点的Redis能够支撑QPS大概在5w左右，如果上千万的用户访问，Redis就承载不了，成为了高并发的瓶颈。
单节点的Redis不能保证高可用，当Redis因为某些原因意外宕机时，会导致缓存不可用
CPU的利用率上，单台Redis实例只能利用单个核心，这单个核心在面临海量数据的存取和管理工作时压力会非常大。

3. 主从复制的好处：

数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
故障恢复：如果master宕掉了，使用哨兵模式，可以提升一个 slave 作为新的 master，进而实现故障转移，实现高可用
负载均衡：可以轻易地实现横向扩展，实现读写分离，一个 master 用于写，多个 slave 用于分摊读的压力，从而实现高并发；

4. 主从复制的缺点：
由于所有的写操作都是先在Master上操作，然后同步更新到Slave上，所以从Master同步到Slave服务器有一定的延迟，当系统很繁忙的时候，延迟问题会更加严重，Slave机器数量的增加也会使这个问题更加严重
二、主从复制的原理
从总体上来说，Redis主从复制的策略就是：当主从服务器刚建立连接的时候，进行全量同步；全量复制结束后，进行增量复制。当然，如果有需要，slave 在任何时候都可以发起全量同步。
1、主从全量复制的流程：
Redis全量复制一般发生在Slave初始化阶段，这时Slave需要将Master上的所有数据都复制一份，具体步骤如下：

slave服务器连接到master服务器，便开始进行数据同步，发送psync命令（Redis2.8之前是sync命令）
master服务器收到psync命令之后，开始执行bgsave命令生成RDB快照文件并使用缓存区记录此后执行的所有写命令

如果master收到了多个slave并发连接请求，它只会进行一次持久化，而不是每个连接都执行一次，然后再把这一份持久化的数据发送给多个并发连接的slave。
如果RDB复制时间超过60秒（repl-timeout），那么slave服务器就会认为复制失败，可以适当调节大这个参数


master服务器bgsave执行完之后，就会向所有Slava服务器发送快照文件，并在发送期间继续在缓冲区内记录被执行的写命令
client-output-buffer-limit slave 256MB 64MB 60，如果在复制期间，内存缓冲区持续消耗超过64MB，或者一次性超过256MB，那么停止复制，复制失败
slave服务器收到RDB快照文件后，会将接收到的数据写入磁盘，然后清空所有旧数据，在从本地磁盘载入收到的快照到内存中，同时基于旧的数据版本对外提供服务。
master服务器发送完RDB快照文件之后，便开始向slave服务器发送缓冲区中的写命令
slave服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令；
如果slave node开启了AOF，那么会立即执行BGREWRITEAOF，重写AOF

2、增量复制：
Redis的增量复制是指在初始化的全量复制并开始正常工作之后，master服务器将发生的写操作同步到slave服务器的过程，增量复制的过程主要是master服务器每执行一个写命令就会向slave服务器发送相同的写命令，slave服务器接收并执行收到的写命令。
3、断点续传：


什么是断点续传：
当master-slave网络连接断掉后，slave重新连接master时，会触发全量复制，但是从2.8版本开始，slave与master能够在网络连接断开重连后，只从中断处继续进行复制，而不必重新同步，这就是所谓的断点续传。
 断电续传这个新特性使用psync命令，旧的实现中使用sync命令。Redis2.8版本可以检测出它所连接的服务器是否支持PSYNC命令，不支持的话使用SYNC命令。master服务器收到slave发送的psync命令后，会根据自身的情况做出对应的处理，可能是FULLRESYNC runid offset触发全量复制，也可能是CONTINUE触发增量复制
 命令格式：psync runid offset



工作原理：


Linux常用命令
Mon, 18 Mar 2024 20:46:01 +0800
Linux基本简介
Linux 是一个基于Linux 内核的开源类Unix 操作系统，Linus Torvalds于 1991 年 9 月 17 日首次发布的操作系统内核。Linux 通常打包为Linux 发行版。

Linux文件系统

Linux一切皆文件
只有一个顶级目录，不像windows分C盘、D盘、E盘


	
			
					Linux
					含义
					windows
			
	
	
			
					/bin
					所有用户可用的基本命令存放的位置
					windows没有固定的命令存放目录
			
			
					/sbin
					需要管理员权限才能使用的命令
					
			
			
					/boot
					linux系统启动的时候需要加载和使用的文件
					
			
			
					/dev
					外设连接linux后，对应的文件存放的位置
					类似Windows中的U盘，光盘的符号文件。
			
			
					/etc
					存放系统或者安装的程序的配置文件,注册服务等
					类似windows中的注册表，
			
			
					/home
					家目录，linux中每新建一个用户，会自动在home中为该用户分配一个文件夹
					类似windows中的"我的文档"，每个用户有自己的目录。
			
			
					/root
					root账户的家目录，仅供root账户使用
					类似windows中的Administrator账户的"我的文档"
			
			
					/lib
					linux的命令和系统启动，需要使用一些公共的依赖，放在lib中，类似我们开发的代码执行需要引入的jdk的jar
					
			
			
					/usr
					很多系统软件的默认安装路径
					类似windows中的C盘下的Program Files目录。
			
			
					/var
					系统和程序运行产生的日志文件和缓存文件放在这里
					
			
	

Linux常用命令
命令格式 ：命令 [-选项] [参数]
例 ： ls -la /etc

文件管理

	
			
					命令
					解释
					参数
					示例
			
	
	
			
					ls
					列出目录的内容
					-a 显示所有文件，包括隐藏文件; -l详细信息显示; -d 查看目录属性
					ls -la
			
			
					cd
					切换工作目录
					cd ..
					
			
			
					pwd
					显示当前路径
					
					
			
			
					cd
					切换工作目录
					
					cd ..
			
			
					mkdir
					创建目录
					-p 递归创建
					mkdir -p /tmp/zhang/test
			
			
					rmdir
					删除目录
					
					rmdir /tmp/zhang/test
			
			
					rm
					删除文件
					-r 删除目录; -f 强制执行
					rm -rf /tmp/zhang/test2
			
			
					cp
					拷贝文件
					-r 复制目录; -p 保留文件属性
					cp -r /tmp/zhang/test1 /root
			
			
					mv
					移动文件
					
					mv 文件A 文件B
			
			
					md5sum
					获取文件的md5指纹
					
					md5sum 文件名
			
	

文本内容(查看|处理)命令

	
			
					命令
					解释
					参数
					示例
			
	
	
			
					touch
					创建文件
					
					touch test
			
			
					cat
					显示文件内容
					-n 显示行号
					cat /etc/issue
			
			
					more
					分屏显示
					(空格) 或f 翻页; (Enter) 换行; q或Q 退出
					
			
			
					less
					分屏显示
					
					
			
			
					head
					取首n行
					-n 指定行数
					head -n 20 /etc/services
			
			
					tail
					取尾n行
					-n 指定行数; -f 动态显示文件末尾内容
					tail -n 18 /etc/services
			
	

文件搜索命令

	
			
					命令
					解释
					参数
					示例
			
	
	
			
					find
					查找文件
					[搜索范围] [匹配条件]
					find / -name “passwd”
			
			
					locate
					文件资料库查找
					
					locate inittab
			
			
					which
					查看命令位置
					
					which ls
			
			
					whereis
					查看命令位置
					
					
			
			
					grep
					文本搜索
					-i 不区分大小写; -v 排除指定字串
					grep mysql /root/install.log
			
	

文件链接

	
			
					命令
					解释
					参数
					示例
			
	
	
			
					ln
					文件链接
					-s 创建软链接
					ln /etc/issue /tmp/issue.hard
			
	

权限管理命令
用户组


MySQL优化常用方法
Sun, 17 Mar 2024 13:46:01 +0800
MySQL优化常用方法
1. EXPLAIN
EXPLAIN 查看SQL执行计划
主要字段说明：

type列，连接类型。一个好的SQL语句至少要达到range级别。杜绝出现all级别。
key列，使用到的索引名。如果没有选择索引，值是NULL。可以采取强制索引方式。
key_len列，索引长度。
rows列，扫描行数。该值是个预估值。
extra列，详细说明。注意，常见的不太友好的值，如下：Using filesort，Using temporary。

2. SQL语句中IN包含的值不应过多
MySQL对于IN做了相应的优化，即将IN中的常量全部存储在一个数组里面，而且这个数组是排好序的。但是如果数值较多，产生的消耗也是比较大的。再例如：select id from t where num in(1,2,3) 对于连续的数值，能用between就不要用in了；再或者使用连接来替换。
3. SELECT语句务必指明字段名称
SELECT*增加很多不必要的消耗（CPU、IO、内存、网络带宽）；增加了使用覆盖索引的可能性；当表结构发生改变时，前断也需要更新。所以要求直接在select后面接上字段名。
4. 当只需要一条数据的时候，使用limit 1
这是为了使EXPLAIN中type列达到const类型
5. 如果排序字段没有用到索引，就尽量少排序
6. 如果限制条件中其他字段没有索引，尽量少用or
or两边的字段中，如果有一个不是索引字段，而其他条件也不是索引字段，会造成该查询不走索引的情况。很多时候使用union all或者是union（必要的时候）的方式来代替“or”会得到更好的效果。
7. 尽量用union all代替union
nion和union all的差异主要是前者需要将结果集合并后再进行唯一性过滤操作，这就会涉及到排序，增加大量的CPU运算，加大资源消耗及延迟。当然，union all的前提条件是两个结果集没有重复数据。
8. 不使用ORDER BY RAND()
select id from dynamic order by rand() limit 1000;
上面的SQL语句，可优化为：
select id from dynamic t1 join (select rand() * (select max(id) from dynamic) as nid) t2 on t1.id > t2.nidlimit 1000;


PHP中的设计模式
Fri, 15 Mar 2024 13:46:01 +0800
PHP中的设计模式
介绍
设计模式：提供了一种广泛的可重用的方式来解决我们日常编程中常常遇见的问题。设计模式并不一定就是一个类库或者第三方框架，它们更多的表现为一种思想并且广泛地应用在系统中。它们也表现为一种模式或者模板，可以在多个不同的场景下用于解决问题。设计模式可以用于加速开发，并且将很多大的想法或者设计以一种简单地方式实现。当然，虽然设计模式在开发中很有作用，但是千万要避免在不适当的场景误用它们。

分类
按照目的分，目前常见的设计模式主要有23种，根据使用目标的不同可以分为以下三大类：
创建设计模式（Creational Patterns）(5种)：用于创建对象时的设计模式。更具体一点，初始化对象流程的设计模式。当程序日益复杂时，需要更加灵活地创建对象，同时减少创建时的依赖。而创建设计模式就是解决此问题的一类设计模式。

单例模式【Singleton】
工厂模式【Factory】
抽象工厂模式【AbstractFactory】
建造者模式【Builder】
原型模式【Prototype】

结构设计模式（Structural Patterns）(7种)：用于继承和接口时的设计模式。结构设计模式用于新类的函数方法设计，减少不必要的类定义，减少代码的冗余。

适配器模式【Adapter】
桥接模式【Bridge】
合成模式【Composite】
装饰器模式【Decorator】
门面模式【Facade】
代理模式【Proxy】
享元模式【Flyweight】

行为模式（Behavioral Patterns）(11种)：用于方法实现以及对应算法的设计模式，同时也是最复杂的设计模式。行为设计模式不仅仅用于定义类的函数行为，同时也用于不同类之间的协议、通信。

策略模式【Strategy】
模板方法模式【TemplateMethod】
观察者模式【Observer】
迭代器模式【Iterator】
责任链模式【ResponsibilityChain】
命令模式【Command】
备忘录模式【Memento】
状态模式【State】
访问者模式【Visitor】
中介者模式【Mediator】
解释器模式【Interpreter】

按照范围分为：类的设计模式，以及对象设计模式


类的设计模式(Class patterns)：用于类的具体实现的设计模式。包含了如何设计和定义类，以及父类和子类的设计模式。


对象设计模式(Object patterns): 用于对象的设计模式。与类的设计模式不同，对象设计模式主要用于运行期对象的状态改变、动态行为变更等。


设计模式原则
设计模式六大原则

开放封闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
里氏替换原则：所有引用基类的地方必须能透明地使用其子类的对象.
依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。
单一职责原则：不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。
接口隔离原则：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
迪米特法则：一个对象应该对其他对象保持最少的了解。

设计模式实现
1. Singleton(单例模式)
单例模式是最常见的模式之一，在Web应用的开发中，常常用于允许在运行时为某个特定的类创建仅有一个可访问的实例。
 1<?php
 2final class Mysql
 3{
 4 
 5 /**
 6 *
 7 * @var self[该属性用来保存实例]
 8 */
 9 private static $instance;
10 
11 /**
12 *
13 * @var mixed
14 */
15 public $mix;
16 
17 /**
18 * Return self instance[创建一个用来实例化对象的方法]
19 *
20 * @return self
21 */
22 public static function getInstance()
23 {
24 if (! (self::$instance instanceof self)) {
25 self::$instance = new self();
26 }
27 return self::$instance;
28 }
29 
30 /**
31 * 构造函数为private,防止创建对象
32 */
33 private function __construct()
34 {}
35 
36 /**
37 * 防止对象被复制
38 */
39 private function __clone()
40 {
41 trigger_error('Clone is not allowed !');
42 }
43}
44 
45// @test
46$firstMysql = Mysql::getInstance();
47$secondMysql = Mysql::getInstance();
48 
49$firstMysql->mix = 'ityangs_one';
50$secondMysql->mix = 'ityangs_two';
51 
52print_r($firstMysql->mix);
53// 输出： ityangs_two
54print_r($secondMysql->mix);
2. Factory(工厂模式)
工厂模式是另一种非常常用的模式，正如其名字所示：确实是对象实例的生产工厂。某些意义上，工厂模式提供了通用的方法有助于我们去获取对象，而不需要关心其具体的内在的实现。


Redis持久化及过期删除策略
Wed, 13 Mar 2024 13:46:01 +0800
Redis持久化及过期删除策略
Redis 持久化之RDB和AOF
RDB 详解
快照（snapshotting，RDB）
RDB 是 Redis 默认的持久化方案。在指定的时间间隔内，执行指定次数的写操作，则会将内存中的数据写入到磁盘中。即在指定目录下生成一个dump.rdb文件。Redis 重启会通过加载dump.rdb文件恢复数据
从配置文件了解RDB
打开 redis.conf 文件，找到 SNAPSHOTTING 对应内容


RDB核心规则配置（重点）
 save <seconds> <changes>
 #save ""
 save 900 1
 save 300 10
 save 60 10000
说明：save <指定时间间隔> <执行指定次数更新操作>，满足条件就将内存中的数据同步到硬盘中。官方出厂配置默认是 900秒内有1个更改，300秒内有10个更改以及60秒内有10000个更改，则将内存中的数据快照写入磁盘。
若不想用RDB方案，可以把 save “” 的注释打开，下面三个注释。


指定本地数据库文件名，一般采用默认的 dump.rdb
 dbfilename dump.rdb


指定本地数据库存放目录，一般也用默认配置
 dir ./


默认开启数据压缩
rdbcompression yes
解说：配置存储至本地数据库时是否压缩数据，默认为yes。Redis采用LZF压缩方式，但占用了一点CPU的时间。若关闭该选项，但会导致数据库文件变的巨大。建议开启。


触发RDB快照

在指定的时间间隔内，执行指定次数的写操作
执行save（阻塞， 只管保存快照，其他的等待） 或者是bgsave （异步）命令
执行flushall 命令，清空数据库所有数据，意义不大。
执行shutdown 命令，保证服务器正常关闭且不丢失任何数据，意义…也不大。
注意：

save备份过程：save备份是同步的，如果备份的数据量过大的话，服务器会暂停几百毫秒甚至是1秒
bgsave备份过程：bgsave备份会单独创建一个子进程，将备份的数据写入一个临时文件
RDB数据还原
找到备份临时文件的指令是 config get dir
指令执行成功以后将备份临时文件的目录拷贝到Redis的安装目录下
然后重新启动Redis服务就成功还原数据了


Redis分布式
Tue, 12 Mar 2024 20:46:01 +0800
Redis分布式
一、 Redis分布式概述
1. 什么是Redis分布式
Redis分布式是指将Redis数据分布到多个Redis节点上，通过集群方式提供更高性能、更大容量和更好可用性的解决方案。
1.2 为什么需要Redis分布式


数据量增长：单机内存容量有限


高并发需求：单机性能瓶颈


高可用性：避免单点故障


可扩展性：支持业务动态扩容


1.3 Redis分布式方案对比

	
			
					方案
					优点
					缺点
					使用场景
			
	
	
			
					主从复制
					部署简单，读写分离
					写操作单点，故障需手动切换
					读多写少，数据备份
			
			
					Redis Sentinel
					自动故障转移，高可用
					配置复杂，扩容不便
					生产环境高可用
			
			
					Redis Cluster
					数据分片，自动故障转移
					客户端兼容性要求，迁移复杂
					大数据量，高并发
			
	

二、 Redis分布式方案搭建
2.1 主从复制搭建
配置文件示例
主节点 (master.conf):
1port 6379
2daemonize yes
3pidfile /var/run/redis_6379.pid
4logfile "/var/log/redis_6379.log"
从节点 (slave.conf):
port 6380
daemonize yes
pidfile /var/run/redis_6380.pid
logfile "/var/log/redis_6380.log"
slaveof 127.0.0.1 6379
启动命令
1# 启动主节点
2redis-server master.conf
3
4# 启动从节点
5redis-server slave.conf
2.2 Redis Sentinel搭建
Sentinel配置文件


Redis中的Lua
Tue, 12 Mar 2024 20:46:01 +0800
Redis中的Lua
一. Redis中的Lua脚本的作用
Redis中的Lua脚本主要解决复杂操作的原子性和性能优化两大核心问题。它允许你在Redis服务器端直接执行自定义的逻辑，而不是把数据拉到客户端处理后再写回去。
核心作用
1. 保证原子性操作
Redis执行Lua脚本时，脚本中的所有命令会作为一个整体被执行，中间不会被其他命令插入。这完美解决了多命令组合操作时的并发安全问题。
经典场景：
实现分布式锁、库存扣减、限流计数器等。比如秒杀场景下，检查库存、扣减库存、记录订单这三个操作必须原子执行，用Lua脚本就能确保数据一致性。
2. 减少网络开销
将多个Redis命令合并到一个Lua脚本中，原本需要多次网络请求的操作变成一次请求完成。数据在Redis服务器本地处理，避免了大量数据在客户端和服务器之间来回传输。
3.扩展Redis指令集
你可以用Lua实现Redis原生不支持的复杂业务逻辑。比如自定义数据结构操作、复杂条件判断、循环处理等，让Redis变成一个具备计算能力的"小数据库"。
4. 提高代码复用率
脚本可以被缓存到Redis服务器，客户端通过SHA1摘要重复调用，无需每次都发送完整的脚本代码。多个应用可以共享同一套脚本逻辑
总结
Redis Lua脚本让你能把多个操作打包成一个原子性的、在服务器本地执行的任务，既保证了数据一致性，又提升了性能。特别适合秒杀、分布式锁、计数器、复杂条件更新等需要"读-改-写"原子操作的场景。
二、Lua安装
windows下载地址 ：https://luabinaries.sourceforge.net/
三 、 Lua在Redis中最常用、最经典的几个应用场景
1. 在Redis中操作Lua脚本的常用命令

	
			
					命令
					作用
					一句话解释
			
	
	
			
					EVAL
					执行给定的Lua脚本
					直接把脚本和参数传给Redis运行一次。
			
			
					SCRIPT LOAD
					将脚本缓存到Redis
					把脚本存到Redis里，会返回一个SHA1值作为“脚本ID”。
			
			
					EVALSHA
					根据SHA1值执行缓存的脚本
					拿着“脚本ID”去执行之前存好的脚本，省流量，效率更高。
			
			
					SCRIPT EXISTS
					检查脚本是否已缓存
					看看某个“脚本ID”对应的脚本还在不在Redis里。
			
			
					SCRIPT KILL
					终止正在运行的脚本
					如果脚本执行太久卡住了，可以用这个命令尝试杀掉它。
			
			
					SCRIPT FLUSH
					清空所有缓存的脚本
					一键清除Redis里缓存的所有脚本，操作要小心\-1。
			
	

2. 五大经典应用场景

分布式锁
这是Lua脚本在Redis中最经典的应用。获取锁和释放锁的多个步骤必须是一个原子操作，否则会出现并发问题。


获取锁：使用 SET NX PX 命令，一步到位地尝试设置一个带过期时间的键，保证只有一个客户端能拿到锁-8。
释放锁：释放锁时，需要先检查当前持有锁的客户端是否就是自己（通过一个唯一值比如UUID判断），然后再删除锁。这两个动作必须通过Lua脚本一起执行，才能避免误删别人的锁-2-8。

1-- 安全的释放锁脚本
2-- KEYS[1]: 锁的名称
3-- ARGV[1]: 客户端的唯一标识
4if redis.call("get", KEYS[1]) == ARGV[1] then
5 return redis.call("del", KEYS[1])
6else
7 return 0
8end

原子性计数器
单纯的INCR命令是原子的，但如果计数逻辑稍微复杂一点，比如要限制计数上限，就需要Lua了-2。


场景：限制某个用户每分钟只能调用某个接口100次。
实现：在Lua脚本里，你可以先GET当前的计数，判断是否超过阈值，没超过再用INCR增加。这整个“读-判断-写”的过程由Lua保证原子性，避免了在高并发下计数超限的风险。

-- 带阈值的原子计数器
-- KEYS[1]: 计数器键名
-- ARGV[1]: 递增步长
-- ARGV[2]: 最大阈值
local current = tonumber(redis.call('GET', KEYS[1]) or '0')
local new_value = current + tonumber(ARGV[1])

if new_value > tonumber(ARGV[2]) then
 return 0 -- 超过阈值，返回失败
else
 redis.call('SET', KEYS[1], new_value)
 return new_value
end

限流器

在“原子计数器”的基础上，可以轻松实现一个简单的时间窗口限流器。


Mysql主从复制原理及保证数据一致性
Tue, 12 Mar 2024 13:46:01 +0800
Mysql主从复制原理及保证数据一致性
提升数据库的并发能力
提在实际工作中，我们常常将Redis作为缓存与MySQL来配合使用，当有请求的时候，首先会从缓存中进行查找，如果存在就直接取出，如果不存在再访问数据库。这样就提升了读取的效率，也减少了对后端数据库的访问压力。
此外，对于一般数据库应用而言，都是读多写少的，当数据库读取数据压力较大时，我们可以从成本较小的方案开始优化，可以首先考虑优化SQL和索引，其次就是缓存策略，最后才是主从架构。
主从复制的作用

读写分离。 在读多写少的情况下，可以采用读写分离，主库当做写库，然后根据实际需要，选择使用多个读库，分散读的压力，提高并发性。
数据备份。 主从复制其实就相当于一种热备份的机制。
实现高可用。 数据备份其实就是一种冗余机制，当主服务器出现故障是时，可以切换到从服务器上，提高服务器可用性。

主从复制原理

实际上主从同步的原理就是基于binlog进行数据同步的。在主从复制过程中，会基于3个线程来操作，一个主库线程，两个从库线程。
二进制日志转储线程是一个主库线程。 当从库线程连接的时候，主库可以将二进制日志发送给从库，当主库读取事件的时候，会在Binlog上加锁，读取完成之后，再将锁释放掉。
从库I/O线程会连接到主库，向主库发送请求更新Binlog。 这时从库的I/O线程就可以读取到主库的二进制日志转储线程发送的Binlog更新部分，并且拷贝到本地的中继日志。
从库SQL线程会读取从库中的中继日志，并且执行日志中的事件，将从库中的数据与主库保持同步。

总结起来就是三步：
步骤1：Master将写操作记录到二进制日志（binlog），这些记录叫做二进制日志事件（binary log events）；
步骤2：Slave 将 Master 的 binary log events拷贝到它的中继日志（relay log）；
步骤3：Slave重做中继日志中的事件，将改变应用到自己的数据库中。
搭建
TODO 此处省略，待补充
如何解决数据一致性问题
进行主从同步的内容是二进制日志，它是一个文件，在进行网络传输的过程中就一定会存在主从延迟，这样就可能造成用户在从库上读取的数据不是最新的数据，也就是主从同步中的数据不一致性问题。
方案一、异步复制

异步模式就是客户端提交COMMIT之后不需要等从库返回任何结果，而是直接将结果返回给客户端，这样做的好处是不会影响主库写的效率。
但这样可能会存在主库宕机，而Binlog还没有同步到从库的情况，也就是此时的主库和从库数据不一致。
这时候从从库中选择一个作为新主，那么新主则可能缺少原来主服务器中已提交的事务。所以，这种复制模式下的数据一致性是最弱的。

方案二、半同步复制

半同步复制的原理是在客户端提交COMMIT之后不直接将结果返回给客户端，而是等待至少有一个从库接收到了Binlog，并且写入到中继日志中，再返回给客户端。
这样做的好处是提高了数据的一致性，当然相比于异步复制来说，至少多增加了一个网络连接的延迟，降低了主库写的效率。
在MySQL5.7版本中还增加了一个参数，可以对应答的从库数量进行设置，默认为1，也就是说只要有1个从库进行了响应，就可以返回给客户端。如果将这个参数调大，可以提升数据一致性的强度，但也会增加主库等待从库响应的时间。

方案三、组复制

异步复制和半同步复制都无法最终保证数据的一致性问题，半同步复制是通过判断从库响应的个数来决定是否返回给客户端，虽然数据一致性相比于异步复制有提升，但仍然无法满足对数据一致性要求高的场景。
组复制技术MGR很好地弥补了这两种复制模式的不足，它是MySQL在5.7.17版本中推出的一种新的数据复制技术，是基于Paxos协议的状态机复制。

原文链接：


PHP面向对象
Mon, 11 Mar 2024 13:46:01 +0800
PHP面向对象
面向对象程序设计实际上就是对现实世界的对象进行建模操作。面向对象程序设计的特征主要可以概括为封装、继承和多态
特性

封装
指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装
例如，计算机的主机是由内存条、硬盘、风扇等部件组成，生产厂家把这些部件用一个外壳封装起来组成主机，用户在使用该主机时，无需关心其内部的组成及工作原理
继承
指可以创建一个新的类，该类继承了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。
例如，已经描述了汽车模型这个类的属性和行为，如果需要描述一个小轿车类，只需让小轿车类继承汽车模型类，然后再描述小轿车类特有的属性和行为，而不必再重复描述一些在汽车模型类中已有的属性和行为
多态
程序中的多态是指一种行为对应着多种不同的实现。指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象的统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。
例如，在一般类中说明了一种求几何图形面积的行为，这种行为不具有具体含义，因为它并没有确定具体几何图形；在特殊类（如三角形、正方形、梯形）中都继承了一般类的求面积的行为，可以根据具体的几何图形重新定义求面积行为。
在 PHP 中，多态可以通过实现接口（interface）和使用抽象类（abstract class）来实现。

类与对象
在PHP中把具有相同属性和行为的对象看成同一类，把属于某个类的实例称为某个类的对象。例如学生小千与小锋是两个不同的对象，两者有共同的属性（如学号、成绩等），也有相同的行为（如选课、显示成绩等），因此两者同属于学生类

类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
对象 − 是类的实例。
成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性。
成员函数 − 定义在类的内部，可用于访问对象的数据。
继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
子类 − 一个类继承其他类称为子类，也可称为派生类。
多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

类定义

类使用 class 关键字后加上类名定义。
类名后的一对大括号({})内可以定义变量和方法。
类的变量使用 var 来声明, 变量也可以初始化值。
函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。

 1<?php
 2class Site {
 3 /* 成员变量 */
 4 var $url;
 5 var $title;
 6 
 7 /* 成员函数 */
 8 function setUrl($par){
 9 $this->url = $par;
10 }
11 
12 function getUrl(){
13 echo $this->url . PHP_EOL;
14 }
15 
16 function setTitle($par){
17 $this->title = $par;
18 }
19 
20 function getTitle(){
21 echo $this->title . PHP_EOL;
22 }
23}
24?>
变量 $this 代表自身的对象。


PHP魔术方法
Sun, 10 Mar 2024 13:46:01 +0800
PHP魔术方法
魔术方法是一种特殊的方法，当对对象执行某些操作时会覆盖 PHP 的默认操作。
PHP中把以两个下划线__开头的方法称为魔术方法(Magic methods)，这些方法在PHP中充当了举足轻重的作用。

__construct()，类的构造函数。

PHP 允许开发者在一个类中定义一个方法作为构造函数。具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。
__destruct()，类的析构函数。 析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。
__call()，在对象中调用一个不可访问方法时调用。
__callStatic()，用静态方式中调用一个不可访问方法时调用
__get()，获得一个类的成员变量时调用。 读取不可访问（protected 或 private）或不存在的属性的值时，__get() 会被调用
__set()，设置一个类的成员变量时调用。 在给不可访问（protected 或 private）或不存在的属性赋值时，__set() 会被调用。
__isset()，当对不可访问属性调用isset()或empty()时调用。 当对不可访问（protected 或 private）或不存在的属性调用 isset() 或 empty() 时，__isset() 会被调用。
__unset()，当对不可访问属性调用unset()时被调用。 当对不可访问（protected 或 private）或不存在的属性调用 unset() 时，__unset() 会被调用。
__sleep()，执行serialize()时，先会调用这个函数。 __sleep() 方法常用于提交未提交的数据，或类似的清理操作。
__wakeup()，执行unserialize()时，先会调用这个函数。 __wakeup() 经常用在反序列化操作中，例如重新建立数据库连接，或执行其它初始化操作。
__toString()，类被当成字符串时的回应方法
__invoke()，调用函数的方式调用一个对象时的回应方法
__set_state()，调用var_export()导出类时，此静态方法会被调用。
__clone()，当对象复制完成时调用
__autoload()，尝试加载未定义的类
__debugInfo()，打印所需调试信息

参考文章： PHP: 魔术方法 - Manual


Mysql的一些常见题
Tue, 20 Feb 2024 20:46:01 +0800
Mysql的一些常见题


请写出数据类型(int char varchar datetime text)的意思；请问 varchar 和 char有什么区别？
Int 整数char 定长字符 Varchar 变长字符 Datetime 日期时间型Text 文本型 Varchar与char的区别 char是固定长度的字符类型，分配多少空间，就占用多长空间。Varchar是可变长度的字符类型，内容有多大就占用多大的空间，能有效节省空间。由于varchar类型是可变的，所以在数据长度改变的时，服务器要进行额外的操作，所以效率比char类型低。


MyISAM和 InnoDB 的基本区别？索引结构如何实现？
A、MyISAM类型不支持事务，表锁，易产生碎片，要经常优化，读写速度较快，适合用于频繁查询的应用；

B、InnoDB类型支持事务，行锁，有崩溃恢复能力，读写速度比MyISAM慢，适合于插入和更新操作比较多的应用，空间占用大，不支持全文索引等。创建索引：alert table tablename add index 索引名 (字段名)


什么是事务？及其特性？
答：事务：是一系列的数据库操作，是数据库应用的基本逻辑单位。
事务特性：A、原子性：即不可分割性，事务要么全部被执行，要么就全部不被执行。B、一致性或可串性。事务的执行使得数据库从一种正确状态转换成另一种正确状态C、隔离性。在事务正确提交之前，不允许把该事务对数据的任何改变提供给任何其他事务，D、持久性。事务正确提交后，其结果将永久保存在数据库中，即使在事务提交后有了其他故障，事务的处理结果也会得到保存。
或者这样理解：事务就是被绑定在一起作为一个逻辑工作单元的SQL语句分组，如果任何一个语句操作失败那么整个操作就被失败，以后操作就会回滚到操作前状态，或者是上有个节点。为了确保要么执行，要么不执行，就可以使用事务。要将有组语句作为事务考虑，就需要通过ACID测试，即原子性，一致性，隔离性和持久性。


什么是锁？
答：数据库是一个多用户使用的共享资源。当多个用户并发地存取数据时，在数据库中就会产生多个事务同时存取同一数据的情况。若对并发操作不加控制就可能会读取和存储不正确的数据，破坏数据库的一致性。
加锁是实现数据库并发控制的一个非常重要的技术。当事务在对某个数据对象进行操作前，先向系统发出请求，对其加锁。加锁后事务就对该数据对象有了一定的控制，在该事务释放锁之前，其他的事务不能对此数据对象进行更新操作。
基本锁类型：锁包括行级锁和表级锁


索引的作用？和它的优点缺点是什么？
索引就一种特殊的查询表，数据库的搜索引擎可以利用它加速对数据的检索。它很类似与现实生活中书的目录，不需要查询整本书内容就可以找到想要的数据。索引可以是唯一的，创建索引允许指定单个列或者是多个列。缺点是它减慢了数据录入的速度，同时也增加了数据库的尺寸大小。


怎么防止sql注入？
1）过滤掉一些常见的数据库操作关键字：select,insert,update,delete,and,*等，或者通过系统函数：addslashes(需要被过滤的内容)来进行过滤。
2）在PHP配置文件中
Register_globals=off;设置为关闭状态 //作用将注册全局变量关闭。
比如：接收POST表单的值使用$_POST[‘user’],如果将register_globals=on;直接使用$user可以接收表单的值。
3）SQL语句书写的时候尽量不要省略小引号(tab键上面那个)和单引号
4）提高数据库命名技巧，对于一些重要的字段根据程序的特点命名，取不易被猜到的
5）对于常用的方法加以封装，避免直接暴漏SQL语句
6）开启PHP安全模式
Safe_mode=on;
7）打开magic_quotes_gpc来防止SQL注入
Magic_quotes_gpc=off;默认是关闭的，它打开后将自动把用户提交的sql语句的查询进行转换，把’转为'，这对防止sql注入有重大作用。
因此开启：magic_quotes_gpc=on;
8）控制错误信息
关闭错误提示信息，将错误信息写到系统日志。
9）使用mysqli或pdo预处理。


数据库优化策略？


合理的表设计。

依据三范式，设计表.

 三范式：1.原子性，每个字段都是不可在分的。


在1方式的基础上，表中每一列必须有唯一性，其他字段依赖主键。


在2方式的基础上，表中的每一列只与主键直接相关，而不是间接相关。


选择合适的字段。
I.尽量使用TYPEINT、SMALLINT、MEDIUM_INT代替INT的使用，一般索引，并且是字段递增，可以考虑设置为UNSIGNED.


 II.使用枚举代替字符串类型。
 III.将少null的使用，null很难优化，并且还占用额外的空间。


MySQL主从复制
Tue, 20 Feb 2024 20:46:01 +0800
MySQL 分库分表 + 主从复制
一、主从复制
1. 环境说明
1个master节点，2个slave节点

mysql-master
mysql-slave1
mysql-slave2

此处使用docker启动多个 MySQL 容器,为每个容器挂载配置文件
1docker run -d --name mysql-master -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 mysql:8.0
2docker run -d --name mysql-slave1 -e MYSQL_ROOT_PASSWORD=root -p 3307:3306 mysql:8.0
3docker run -d --name mysql-slave2 -e MYSQL_ROOT_PASSWORD=root -p 3308:3306 mysql:8.0
创建配置文件目录
1mkdir -p ~/mysql/master ~/mysql/slave1 ~/mysql/slave2
2. 修改配置
master的 my.cnf （~/mysql/master/my.cnf）
1[mysqld]
2server-id=1
3log_bin=mysql-bin
4binlog_format=ROW
5gtid_mode=ON
6enforce_gtid_consistency=ON
7log_slave_updates=ON
slave1 的 my.cnf（~/mysql/slave1/my.cnf）
1[mysqld]
2server-id=2
3relay_log_recovery=ON
4read_only=ON
5super_read_only=ON
6gtid_mode=ON
7enforce_gtid_consistency=ON
8log_slave_updates=ON
slave2 的 my.cnf（~/mysql/slave2/my.cnf）


PHP常见题
Tue, 20 Feb 2024 20:46:01 +0800
PHP常见题
1. 什么事面向对象？主要特征是什么？
面向对象是程序的一种设计方式，它利于提高程序的重用性，使程序结构更加清晰。主要特征：封装、继承、多态。
2. SESSION 与 COOKIE的区别是什么，请从协议，产生的原因与作用说明?
A、http无状态协议，不能区分用户是否是从同一个网站上来的，同一个用户请求不同的页面不能看做是同一个用户。
B、SESSION存储在服务器端，COOKIE保存在客户端。Session比较安全，cookie用某些手段可以修改，不安全。
Session依赖于cookie进行传递。禁用cookie后，session不能正常使用。
Session的缺点：保存在服务器端，每次读取都从服务器进行读取，对服务器有资源消耗。Session保存在服务器端的文件或数据库中，默认保存在文件中，文件路径由php配置文件的session.save_path指定。Session文件是公有的。
3. HTTP 状态中302、403、 500代码含义？
一二三四五原则:（即一：消息系列；二：成功系列；三：重定向系列；四：请求错误系列；五：服务器端错误系列。）

302:临时转移成功，请求的内容已转移到新位置

403:禁止访问

500:服务器内部错误 401：代表未授权。
4. 请写出数据类型(int char varchar datetime text)的意思；请问 varchar 和 char有什么区别？
Int 整数char 定长字符 Varchar 变长字符 Datetime 日期时间型Text 文本型 Varchar与char的区别 char是固定长度的字符类型，分配多少空间，就占用多长空间。Varchar是可变长度的字符类型，内容有多大就占用多大的空间，能有效节省空间。由于varchar类型是可变的，所以在数据长度改变的时，服务器要进行额外的操作，所以效率比char类型低。
5. MyISAM和 InnoDB 的基本区别？索引结构如何实现？
A、MyISAM类型不支持事务，表锁，易产生碎片，要经常优化，读写速度较快，适合用于频繁查询的应用；

B、InnoDB类型支持事务，行锁，有崩溃恢复能力，读写速度比MyISAM慢，适合于插入和更新操作比较多的应用，空间占用大，不支持全文索引等。创建索引：alert table tablename add index 索引名 (字段名)
6. isset() 和 empty() 区别
isset判断变量是否存在，可以传入多个变量，若其中一个变量不存在则返回假；empty判断变量是否为空为假，只可传一个变量，如果为空为假则返回真。
7. 请说明 PHP 中传值与传引用的区别。什么时候传值什么时候传引用？
按值传递：函数范围内对值的任何改变在函数外部都会被忽略按引用传递：函数范围内对值的任何改变在函数外部也能反映出这些修改优缺点：按值传递时，php必须复制值。特别是对于大型的字符串和对象来说，这将会是一个代价很大的操作。按引用传递则不需要复制值，对于性能提高很有好处。
8. 在PHP中error_reporting这个函数有什么作用？
设置PHP的报错级别并返回当前级别。
9. 现在编程中经常采取MVC三层结构，请问MVC分别指哪三层，有什么优点？
MVC三层分别指：业务模型、视图、控制器，由控制器层调用模型处理数据，然后将数据映射到视图层进行显示，优点是：①可以实现代码的重用性，避免产生代码冗余；②M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式
10. 在程序的开发中，如何提高程序的运行效率？
A、优化SQL语句，查询语句中尽量不使用select *，用哪个字段查哪个字段；少用子查询可用表连接代替；少用模糊查询；


Redis的一些常见题
Tue, 20 Feb 2024 20:46:01 +0800
Redis的一些常见题


redis数据类型及应用场景
见 Redis的五种数据类型及使用场景


redis持久化及过期策略
见 Redis持久化及过期删除策略


redis 常见问题及解决方案


缓存雪崩：同一时间大量缓存失效，导致请求直接查询数据库，数据库内存和CPU压力增加甚至宕机

解决：

热点数据永不过期或者分布到不同实例，降低单机故障问题

缓存时间添加随机数，防止大量缓存同时失效 

做二级缓存或者双缓存，A为原始缓存 短时效，B为备份缓存 ，长期有效。更新时候双写缓存


缓存穿透：缓存和数据库都没有数据，大量请求下，所有请求直接击穿到数据库，导致宕机。

解决：

布隆过滤器:长度为m的位向量或者位列表组成（仅包含0或1位值的列表）

使用多个不用的hash函数，产生多个索引值，填充对应多个位置的值为1

布隆过滤器可以检查值是 “可能在集合中” 还是 “绝对不在集合中”

可能误判但是基础过滤效率高

极端情况，当布隆过滤器没有空闲位置的时候每次查询返回true

空缓存（短时效）

业务层参数过滤


缓存击穿：数据库中有数据，但是缓存突然失效之后发生大量请求导致数据库压力增加甚至打垮宕机
解决：
热点数据永不过期

互斥锁：获取锁之后不管成功还是失败都要释放锁




Redis主从复制原理
Redis 在复制时底层采用的是 psync 命令完成的数据主从同步，同步主要分为：全量复制和增量复制两种

全量复制：顾名思义也就是一次性把主节点数据全部发送给从节点，所以这种情况下，当数据量比较大时，会对主节点和网络造成很大的开销。
部分复制：用于处理主从复制时因网络中断等原因造成数据丢失的场景。当从节点再次和主节点连接时，主节点会补发丢失的数据。因为是补发，所以在发送的数据量一定是小于全量的数据。

详细见 Redis的一些常见题 



Redis缓存和数据库数据一致性问题：

读数据

尝试查询缓存，存在缓存则直接返回数据
缓存不存在时则查询数据库，并保存到缓存（合适设置过期时间），返回数据


写数据

先更新缓存再更新数据库 或者 先删除缓存再更新数据库
先更新数据库再更新缓存 或者 先更新数据库再删除缓存
使用删除还是更新？

这里无非是删除还是更新Redis，直接删除的方式比较简单，在下一次查询时会生成缓存（更推荐）；更新缓存则相较复杂


先操作Redis还是先操作数据库？

先操作数据库 （推荐）

流程:先更新数据库，再删除缓存
问题：比如线程1执行写操作（修改数据库->删除缓存），线程2执行读操作（查询缓存->旧数据），就会出现旧数据返回，或者删除缓存失败也会返回旧数据


先操作缓存

流程：修改操作先删除缓存再修改数据库
问题： 比如线程1去执行写操作： （删除缓存->更新数据库）同时有线程2执行读操作（查询缓存（未查到缓存）->查数据库->保存到缓存）因为数据库更新有可能网络延迟等问题，这里保存到缓存的数据就是旧的数据，只有再过期之后才会读到新数据
解决方案： （延迟双删）在数据库更新之后再进行一次缓存删除（加适当延迟，比如延迟500ms），这时再有查询过来也会查询到数据库并保存到缓存。但是线程2在这个删除缓存500ms内请求仍然可能会出现一次获取到旧数据 （推荐方式）











ShardingSphere 使用指南
Tue, 20 Feb 2024 20:46:01 +0800
ShardingSphere 使用指南
一、介绍
Apache ShardingSphere 是一个开源的 分布式数据库中间件生态，支持 分库分表、读写分离、数据加密、影子库 等功能。它的定位是 数据库增强计算层，让你在不修改（或少量修改）应用代码的情况下，实现复杂的数据分片与治理。
核心组件：

ShardingSphere-JDBC：客户端 SDK，直接在应用中引入。
ShardingSphere-Proxy：中间件代理层，应用通过 MySQL 协议访问，无需修改业务代码。
ShardingSphere-Sidecar：面向 K8s 的云原生数据库 Mesh。

二、适用场景


分库分表：数据量过大，单表行数超过 1千万～1亿，单库容量超限时。


读写分离：主库写、从库读，提升查询性能。


柔性事务：分布式场景下保证一致性（支持 Seata、XA）。


数据加密：对敏感字段（手机号、身份证号）自动加密存储，解密查询。


影子库：A/B 测试或灰度发布。


三、 配置方式
以 ShardingSphere-Proxy 为例（最常用于 PHP 项目）。
3.1 部署 Proxy
1wget https://downloads.apache.org/shardingsphere/5.4.2/apache-shardingsphere-5.4.2-shardingsphere-proxy-bin.tar.gz
2tar -zxvf apache-shardingsphere-5.4.2-shardingsphere-proxy-bin.tar.gz
3cd apache-shardingsphere-5.4.2-shardingsphere-proxy-bin
配置文件路径：
1conf/server.yaml # 全局配置（身份认证、元数据）
2conf/config-sharding.yaml # 分库分表配置
3.2 示例配置（分库分表 + 读写分离）

server.yaml （全局配置）

1authentication:
2 users:
3 root:
4 password: root123  # 设置登录 ShardingSphere-Proxy 的账号和密码
5 authorizedSchemas: ds_sharding # 指定该用户可访问的逻辑库（schema）
6
7props:
8 sql-show: true # 开启 SQL 打印，方便调试时查看 Proxy 最终路由后的真实 SQL

config-sharding.yaml （分库分表 + 读写分离配置）

 1schemaName: ds_sharding  # 定义逻辑库名称，PHP / Java / MySQL 客户端连接时用这个库名
 2
 3# -----------------------------
 4# 数据源配置（物理数据库连接）
 5# -----------------------------
 6dataSources:
 7 ds0: # 数据源1（对应一个物理数据库）
 8 url: jdbc:mysql://127.0.0.1:3306/order_db0?serverTimezone=UTC&useSSL=false
 9 username: root
10 password: root
11 ds1: # 数据源2（对应另一个物理数据库）
12 url: jdbc:mysql://127.0.0.1:3306/order_db1?serverTimezone=UTC&useSSL=false
13 username: root
14 password: root
15
16# -----------------------------
17# 分片规则配置
18# -----------------------------
19rules:
20- !SHARDING
21 tables:
22 t_order: # 定义逻辑表名：t_order
23 actualDataNodes: ds$->{0..1}.t_order_$->{0..3} 
24 # 表示实际的数据节点： 
25 # - 数据库范围是 ds0、ds1（0..1）
26 # - 每个库里有 4 个分表（t_order_0, t_order_1, t_order_2, t_order_3）
27 # 最终生成的物理表结构：
28 # ds0.t_order_0 ~ ds0.t_order_3
29 # ds1.t_order_0 ~ ds1.t_order_3
30
31 tableStrategy: # 表级分片策略
32 standard: # 标准分片（根据单一分片键）
33 shardingColumn: order_id  # 分片字段（根据 order_id 来决定落在哪个分表）
34 shardingAlgorithmName: t_order_inline  # 使用下面定义的分片算法
35
36 shardingAlgorithms: # 定义分片算法
37 t_order_inline: # 算法名（和上面引用的保持一致）
38 type: INLINE  # 类型为 INLINE（内联表达式分片）
39 props:
40 algorithm-expression: t_order_$->{order_id % 4}
41 # 分片规则：根据 order_id 取模 4
42 # 比如 order_id=10001 → 10001%4=1 → 路由到 t_order_1
43
44# -----------------------------
45# （可选）读写分离配置
46# -----------------------------
47- !READWRITE_SPLITTING
48 dataSources:
49 pr_ds: # 定义一个逻辑数据源 pr_ds（Proxy 会将它当成读写分离的数据源）
50 staticStrategy:
51 writeDataSourceName: ds0  # 指定主库（写库），这里用 ds0
52 readDataSourceNames: [ds1]  # 指定从库（读库），这里用 ds1
53 loadBalancerName: round_robin  # 多个从库时的负载均衡策略（这里用轮询）
54
55 loadBalancers:
56 round_robin: # 定义负载均衡器
57 type: ROUND_ROBIN  # 类型：轮询
配置说明：


Logstash
Tue, 20 Feb 2024 17:01:01 +0800
Logstash
ALogstash 介绍
Logstash 是一个开源的日志收集、处理和转发工具，通常与 Elasticsearch 和 Kibana 一起组成 Elastic Stack，用于集中式日志管理和数据分析。它支持多种数据源、数据处理及输出目标，常用于日志的收集和处理。
1. 安装 Logstash
Logstash 支持多种操作系统，安装方式可以使用包管理工具、压缩包或 Docker。
a. 通过 apt 安装（以 Ubuntu 为例）
首先，添加 Elastic 的 APT 仓库：
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
sudo sh -c 'echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" > /etc/apt/sources.list.d/elastic-7.x.list'
然后，更新 APT 仓库并安装 Logstash：
udo apt-get update
sudo apt-get install logstash
b. 使用 .tar.gz 包安装
可以从官网（https://www.elastic.co/downloads/logstash）下载压缩包，解压并安装。
1tar -xvzf logstash-7.x.x.tar.gz
2cd logstash-7.x.x
2. 配置 Logstash
Logstash 的配置文件通常由 3 个部分组成：输入（input）、过滤器（filter） 和 输出（output）。


PHP常用函数整理
Sun, 18 Feb 2024 20:46:01 +0800
PHP常用函数整理
字符串


strlen() 获取字符串长度。（一个汉字长度为3个字符，一个英文字母长度为1个字符）



strpos() 在字符串内查找一个字符或一段指定的文本，返回第一次出现的位置或者false


stripos() 同上，但不区分大小写


strrpos() 同上上，返回最后一次出现的位置或false


strripos() 同上，但不区分大小写



explode() 字符串打散为数组


implode() 数组拼接成字符串


strtoupper() 把字符串转换为大写


strtolower() 把字符串转换为大写


ucfirst() 把单词的首字母转换成大写


lcfirst() 把单词的首字母转换为小写


ucwords() 把字符串中每个单词的首字母转换为大写



str_replace 子字符串替换


str_ireplace str_replace 的忽略大小写版本


strrev 反转字符串


trim 去除字符串首尾处的空白字符（或者其他字符）


rtrim 删除字符串末端的空白字符（或者其他字符）


substr 截取字符串的一部分，返回字符串的子串


substr 截取字符串的一部分（中文，需要安装扩展mbstring），返回字符串的子串


更多请参考官方文档
数组


array() 创建数组


count() 返回数组中元素的数量 sizeof() 同样效果


array_push() 将一个或多个单元压入数组的末尾（入栈）


array_pop() 弹出数组最后一个单元（出栈）


array_unshift() 在数组开头插入一个或多个单元


array_shift() 将数组开头的单元移出数组


shuffle() 打乱数组


reset — 将数组的内部指针指向第一个单元


end — 将数组的内部指针指向最后一个单元


current — 返回数组中的当前值


对进程、线程和协程的理解
Sun, 18 Feb 2024 20:46:01 +0800
对进程、线程和协程的理解
一、 进程
先来了解一下操作系统的进程：
操作系统对正在运行程序的抽象，这个就是进程（process）。

比如运行一个 web 浏览器，一个 text 文本，都是运行的一个一个进程。
有的人说：进程是程序运行资源的集合。进程是系统资源分配的最小单位等等。
从静态的角度来说，进程确实是运行程序的各种资源集合。
如果你进一步思考，进程里的各种资源都有哪些呢？


内存管理相关


文件系统


调度相关


信号处理


内核栈


进程各种状态


进程运行时统计信息


进程标识


等等。
可以看出，进程中的资源是相当多的。
从 Linux 操作系统对进程的定义也可以看出。
多进程：操作系统有多个程序运行，那么就有多个进程
二、 线程
《操作系统设计与实现》里说：
在传统操作系统中，每个进程中只存在一个地址空间和一个控制流（thread）。
然后，有些情况下，需要在相同地址空间中有多个控制流并行的运行，就像他们是单独的进程一样（只是他们共享相同的地址空间）。
这些控制流通常被称为线程（thread），有时也称为轻量级进程（lightweight process）。
尽管线程必须在进程中执行，但是线程和进程是可以分别对待处理的两个概念。进程用来集合资源，而线程是 CPU 调度的实体。
线程给进程模型增加的是，允许在同一个进程环境中有多个执行流，这些执行流在很大程度上相对独立。
也即是说，在进程中，程序执行的最小单位（执行流）是线程，可以把线程看作是进程里的一条执行流。
一个进程里可以有一条或多条线程。
为什么会有多线程
在一个应用程序执行过程中，应用程序里可能会有多种事件执行。
而有些事件执行一段时间后可能会被阻塞。如果把应用程序执行事件分解成多个并行运行的线程，即可以让程序设计变得简单，如果有阻塞的，
可以把这部分让出行换其他线程执行。
还有一个原因是：
线程比进程更轻量级。所以线程比进程更加容易创建，销毁。
第三个跟第一个有点关系，是关于性能的，若多线程都是 CPU 密集型的，那么不能获取性能上增强。如果有大量计算和大量 I/O 处理，那么
多线程就可以获取性能上的优势，因为允许多线程重叠执行。
多线程的缺点：

对于多线程来说，进程中的资源是共享的，所以会产生资源竞争。
当进程中的一个线程崩溃了，会导致这个进程里的其他线程也崩溃。所以有时多进程程序更好，一个进程崩溃不会导致其他进程也崩溃。

三、 进程和线程的区别
从上面进程和线程介绍知道，线程是程序执行流的最小单位，进程是操作系统分配资源的单位。
进程与进程之间关系：
进程与进程之间是相互独立的。
线程与进程关系：
线程是进程里的执行流，进程里的线程可以是一个，也可以是多个。
所有线程共享进程里一些资源，比如代码，数据，地址空间，信号处理，打开文件，全局变量等。
同时，线程也有自己的寄存器，程序计数器，堆栈，线程状态等
四、协程
协程是建立在线程之上，一般是语言级别的 ”多线程“ 模型，比线程更加的轻量级。有的叫它微线程。它是完全运行在用户态里。
协程是在线程之上在进行抽象，它需要线程来承载运行。一个线程可以有多个协程。


一些PHP基础的简单整理
Sun, 18 Feb 2024 20:46:01 +0800
一些PHP基础的简单整理
常量

关于常量定义

1<?php
2$a = 1;
3define("AAA".$a,"AAA");
4echo constant("AAA".$a);
define() 在运行时定义一个常量。

constant() 返回一个常量的值。当你不知道常量名，却需要获取常量的值时，constant() 就很有用了。也就是说，常量名储存在一个变量里，或者由函数返回时。
const不能在条件语句中定义常量。
const用于类成员变量的定义，define()不可用于类成员变量的定义，可用于全局变量。

const可在类中使用，define不能。


常量和变量的区别

常量前面没有且不能有$符号
常量可以不用理会变量的作用域，在任何地方定义和使用
常量一旦定义就不能重新定义或取消定义
常量的值只能是标量（字符串、整数、浮点数、布尔值），支持数组

获取所有常量

get_defined_constants()

get_defined_constants(true)

get_defined_constants(true)[‘user’]


魔术常量：它的值随着它在代码中的位置改变而变化

LINE 文件中的当前行号
FILE 文件的完整路径和文件名，包含根目录
DIR 文件所在目录
FUNCTION 该函数被定义时的名字，区分大小写
CLASS 该类被定义时的名字，区分大小写
NAMESPANCE 命名空间
METHOD 命名空间类名方法名
TRAIT 当前使用的trait的名字



包含文件

include和require的区别
include和require除了错误处理的方式不同，其他方面都是相同的。

require生成一个致命错误（E_COMPILE_ERROR），在错误发生后脚本停止运行

include生成一个警告（E_WARNING）,在错误发生后脚本继续运行

面向对象(OO)


概念

面向对象是一种编程思想和方法，它将程序中的数据和操作数据的方法封装在一起，形成“对象”，并通过对象之间的交互和消息传递来完成程序的功能。
面向对象编程（OOP）强调数据的封装、继承、多态和动态绑定等特性，使得程序具有更好的可扩展性、可维护性和可重用性。



OOP特性

封装：指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装
继承：指可以创建一个新的类该类继承（extends）了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的复用。
多态：指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。在PHP中多态可通过实现接口（interface）和使用抽象类（abstract class）来实现。



类的访问控制

public（公有）：公有的类成员可以在任何地方被调用。
protected（受保护）：受保护的类成员可以被其自身以及其子类和父类访问。
private（私有）：私有的类成员只能被其定义所在的类访问



构造方法 __construct

构造方法是一种特殊的方法，在创建一个新对象时，它会被自动调用
他可以用来 初始化 对象的属性或执行其他必要的操作
没有返回值



析构函数 __destruct

析构函数是一种特殊的方法，它在对象被销毁时自动调用
它可以用来执行一些清理操作，如释放资源或关闭连接
当对象不再被引用或脚本执行结束时，析构函数会被自动调用



final 关键字


PHP的 FPM 和 CLI
Sat, 17 Feb 2024 20:46:01 +0800
PHP的 FPM 和 CLI
PHP-FPM
PHP-FPM 即 PHP FastCGI 进程管理器。
要了解 PHP-FPM ，首先要看看 CGI 与 FastCGI 的关系。

CGI 的英文全名是 Common Gateway Interface，即通用网关接口，是 Web 服务器调用外部程序时所使用的一种服务端应用的规范。

早期的 Web 通信只是按照客户端请求将保存在 Web 服务器硬盘中的数据转发过去而已，这种情况下客户端每次获取的信息也是同样的内容（即静态请求，比如图片、样式文件、HTML文档），而随着 Web 的发展，Web 所能呈现的内容更加丰富，与用户的交互日益频繁，比如博客、论坛、电商网站、社交网络等。

这个时候仅仅通过静态资源已经无法满足 Web 通信的需求，所以引入 CGI 以便客户端请求能够触发 Web 服务器运行另一个外部程序，客户端所输入的数据也会传给这个外部程序，该程序运行结束后会将生成的 HTML 和其他数据通过 Web 服务器再返回给客户端（即动态请求，比如基于 PHP、Python、Java 实现的应用）。利用 CGI 可以针对用户请求动态返回给客户端各种各样动态变化的信息。

FastCGI 顾名思义，是 CGI 的升级版本，为了提升 CGI 的性能而生，CGI 针对每个 HTTP 请求都会 fork 一个新进程来进行处理（解析配置文件、初始化执行环境、处理请求），然后把这个进程处理完的结果通过 Web 服务器转发给用户，刚刚 fork 的新进程也随之退出，如果下次用户再请求动态资源，那么 Web 服务器又再次 fork 一个新进程，如此周而复始循环往复。
而 FastCGI 则会先 fork 一个 master 进程，解析配置文件，初始化执行环境，然后再 fork 多个 worker 进程（与 Nginx 有点像），当 HTTP 请求过来时，master 进程将其会传递给一个 worker 进程，然后立即可以接受下一个请求，这样就避免了重复的初始化操作，效率自然也就提高了。而且当 worker 进程不够用时，master 进程还可以根据配置预先启动几个 worker 进程等着；当空闲 worker 进程太多时，也会关掉一些，这样不仅提高了性能，还节约了系统资源。
这样一来，PHP-FPM 就好理解了，FastCGI 只是一个协议规范，需要每个语言具体去实现，PHP-FPM 就是 PHP 版本的 FastCGI 协议实现，有了它，就是实现 PHP 脚本与 Web 服务器（通常是 Nginx）之间的通信，同时它也是一个 PHP SAPI，从而构建起 PHP 解释器与 Web 服务器之间的桥梁。

PHP-FPM 负责管理一个进程池来处理来自 Web 服务器的 HTTP 动态请求，在 PHP-FPM 中，master 进程负责与 Web 服务器进行通信，接收 HTTP 请求，再将请求转发给 worker 进程进行处理，worker 进程主要负责动态执行 PHP 代码，处理完成后，将处理结果返回给 Web 服务器，再由 Web 服务器将结果发送给客户端。这就是 PHP-FPM 的基本工作原理。


Redis的数据类型及使用场景
Fri, 01 Sep 2023 20:46:01 +0800
Redis的数据类型及使用场景
一、基本数据类型
1.字符串（String）

string 是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。
string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如 jpg 图片或者序列化的对象。
string 类型是 Redis 最基本的数据类型，string 类型的值最大能存储 512MB。

常用命令：

SET key value 设置指定 key 的值。
GET key 获取指定 key 的值。

应用场景：
String 是最常用的一种数据类型，普通的 key/value 存储都可以归为此类，即可以完全实现目前 Memcached 的功能，并且效率更高。还可以享受 Redis 的定时持久化，操作日志及 Replication 等功能。除了提供与 Memcached 一样的 get、set、incr、decr 等操作外，Redis 还提供了下面一些操作：

获取字符串长度
往字符串 append 内容
设置和获取字符串的某一段内容
设置及获取字符串的某一位（bit）
批量设置一系列字符串的内容

使用场景：
常规 key-value 缓存应用。常规计数：微博数，粉丝数。
实现方式：
String 在 redis 内部存储默认就是一个字符串，被 redisObject 所引用，当遇到 incr,decr 等操作时会转成数值型进行计算，此时 redisObject 的 encoding 字段为 int


SQL语法速成
Fri, 01 Sep 2023 20:46:01 +0800
SQL语法速成
SQL 语法结构

子句 - 是语句和查询的组成成分。（在某些情况下，这些都是可选的。）
表达式 - 可以产生任何标量值，或由列和行的数据库表
谓词 - 给需要评估的 SQL 三值逻辑（3VL）（true/false/unknown）或布尔真值指定条件，并限制语句和查询的效果，或改变程序流程。
查询 - 基于特定条件检索数据。这是 SQL 的一个重要组成部分。
语句 - 可以持久地影响纲要和数据，也可以控制数据库事务、程序流程、连接、会话或诊断。

SQL 语法要点

SQL 语句不区分大小写，但是数据库表名、列名和值是否区分，依赖于具体的 DBMS 以及配置。
例如：SELECT 与 select 、Select 是相同的。
多条 SQL 语句必须以分号 ; 分隔。
处理 SQL 语句时，所有空格都被忽略。SQL 语句可以写成一行，也可以分写为多行。
SQL 支持三种注释
1## 注释1
2-- 注释2
3/* 注释3 */


增删改查，又称为 CRUD，数据库基本操作中的基本操作。
插入数据
INSERT INTO 语句用于向表中插入新记录。
插入完整的行
1INSERT INTO user VALUES (10, 'root', 'root', 'xxxx@163.com');
插入行的一部分
1INSERT INTO user(username, password, email)VALUES ('admin', 'admin', 'xxxx@163.com');
插入查询出来的数据


Kong API网关
Tue, 01 Aug 2023 11:46:01 +0800
Kong API网关
API网关特点

集合多个API，统一API入口
避免内部信息泄露
提供安全认证
支持混合通讯协议
降低微服务复杂度

常用的API网关有：NGINX，Zuul，Kong
Kong 介绍
kong是微服务中的一个网关组件，具有高可用和可扩展性，能提供易于使用的restful api来操作和配置API管理系统，同时它也可以通过负载均衡的功能把请求均匀的分发到各个服务器上，应对大量的请求。基于Nginx和OpenResty，是一个具有分布式、高性能、高并发、可伸缩…亚毫秒级延迟等特性和功能的微服务抽象层。
konga 是kong的UI界面

多用户管理
管理多个kong节点
使用快照备份，还原和迁移Kong节点
使用运行状态检查监控节点和API状态
数据库集成postgresSQL

Kong 流程图

Kong 安装
Kong下载安装
Konga下载安装
API操作 文档地址
示例:
负载均衡
# 添加负载均衡
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=demo-upstream" \
 'http://127.0.0.1:8001/upstreams'

#设置权重
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "target=127.0.0.1:8000" \
 -d "weight=100" \
 'http://127.0.0.1:8001/upstreams/demo-upstream/targets'

 curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "target=127.0.0.1:8080" \
 -d "weight=500" \
 'http://127.0.0.1:8001/upstreams/demo-upstream/targets'
添加Service
# 添加负载均衡
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=demo-service" \
 -d "host=demo-upstream" \
 'http://127.0.0.1:8001/services'
添加路由
# 添加负载均衡
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=demo-service-route" \
 -d "paths[]=/abc" \
 'http://127.0.0.1:8001/services/demo-service/routes'
Plugins 为路由添加basic-auth
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=basic-auth" \
 -d "config.hide_credentials=true" \
 'http://127.0.0.1:8001/routes/demo-service-route/plugins'

## 添加成功后需要添加CONSUMERS在Plugins添加basic auth
Plugins 为services添加jwt
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=jwt" \
 -d "config.hide_credentials=true" \
 'http://127.0.0.1:8001/services/demo-service/plugins'

## 添加成功后需要CONSUMERS配置jwt
Plugins 为services添加oauth2
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=oauth2" \
 -d "config.enable_authorization_code=true" \
 -d "config.enable_client_credentials=true" \
 -d "config.token_expiration=7200" \
 'http://127.0.0.1:8001/services/demo-service/plugins'

## 添加成功后需要CONSUMERS在Plugins添加auth2
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=test" \
 -d "config.client_id=true" \
 -d "config.client_secret=true" \
 -d "config.token_expiration=7200" \
 'http://127.0.0.1:8001/consumers/test/oauth2'

 ## 替换下面的client_id和client_secret获取Token 
 curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "grant_type=client_credentials" \
 -d "client_id=xxx" \
 -d "client_secret=xxx" \
 -d "config.token_expiration=7200" \
 'http://127.0.0.1:8443/abc/oauth2/token'
Plugins 为services添加限流
# 限制IP每分钟5次
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=rate-limiting" \
 -d "config.minute=5" \
 -d "config.limit_by=ip" \
 'http://127.0.0.1:8001/services/demo-service/plugins'
Plugins 为services添加黑白名单
# 限制127.0.0.1访问
curl -i -X POST \
 -H "Content-Type:application/x-www-form-urlencoded" \
 -d "name=ip-restriction" \
 -d "config.deny=127.0.0.1" \
 'http://127.0.0.1:8001/services/demo-service/plugins'



Konga
Tue, 01 Aug 2023 11:46:01 +0800
Konga
Konga的本质：Konga是一个图形化界面，它最终是通过调用你配置的 Kong Admin API 来修改Kong的配置的。
文档参考：遇到复杂场景时，最好的老师依然是Kong官方文档。
一、首次登录与初始化设置

访问Konga并注册：在浏览器中打开 http://<你的服务器IP>:1337。首次访问时，Konga会要求你注册一个管理员账户。填写用户名、邮箱和密码完成注册。
登录系统：注册成功后，Konga会自动跳转到登录页面，使用刚才注册的账号密码登录即可

二、 连接Konga与Kong网关

进入连接设置：登录成功后，你应该会看到"CONNECTIONS"或"Connections"界面。如果没有，请在左侧菜单或顶部导航栏中找到并点击 “Connections”。
填写Kong Admin API信息：

Connection name：为你这个Kong连接起个名字，比如"My-Kong"或"Production"。
Kong Admin URL：这是你Kong网关的Admin API地址。非常重要！ 格式通常是 http://:8001
如果你的Kong容器和Konga容器在同一个Docker网络（如 kong-net）中，你可以使用Kong的容器名和内部端口，例如：http://kong:8001。
如果你希望通过宿主机IP访问，可能需要使用宿主机的IP和映射给Kong Admin API的端口（例如 http://localhost:8001 或 http://<宿主机IP>:8001）。


激活连接：信息填写完毕后，点击 “Active” 或 “Connect” 等按钮来激活并测试连接。如果一切正常，Konga会提示连接成功。

三、 Konga核心功能与使用介绍
连接成功后，你就可以使用Konga来管理Kong了。Konga的核心功能围绕以下几个概念展开，理解它们之间的关系很重要：

	
			
					概念 (Concept)
					作用 (Role)
					类比 (Analogy)
					配置要点 (Key Configuration)
			
	
	
			
					Upstream
					负载均衡组：代表一个虚拟主机名，用于对后端多个Target进行负载均衡。
					球队的名称
					Name：为Upstream命名（如 my-api-upstream）。
			
			
					Target
					具体目标：代表一个物理服务（IP+Port），是Upstream组内的一个具体后端实例。必须先创建Upstream，才能添加Target。
					球队里的一个球员
					Target：后端服务的IP或主机名及端口（如 192.168.1.100:8080）。Weight：权重，流量分配比例。
			
			
					Service
					服务抽象：是上游服务的抽象，可以直接指向一个具体的URL，也可以关联一个Upstream来实现负载均衡。
					比赛的战术安排
					Name：服务名称。Protocol：协议（HTTP/HTTPS）。Host：可填写具体URL或关联的Upstream名称。Port：端口。Path：路径（可选）。
			
			
					Route
					路由规则：定义客户端请求的匹配规则（如路径、域名），将匹配的请求路由到指定的Service。
					根据球衣颜色决定把球传给谁
					Paths：匹配的请求路径（如 /api）。Hosts：匹配的域名（可选）。Service：选择该路由要关联的Service。
			
	

四、 创建服务 (Services) 和路由 (Routes)
这是最常用的功能，用于将外部请求转发到你的后端服务。


VirtualBox+Vagrant使用
Tue, 01 Aug 2023 11:46:01 +0800
VirtualBox+Vagrant使用
一、 介绍
1. VirtualBox简介
VirtualBox是一个开源的 虚拟机管理软件，由 Oracle 开发。它的核心功能是允许你在一台物理机上运行多个虚拟机，每个虚拟机都可以装不同的操作系统。
特点：


跨平台：支持 Windows、Linux、macOS 主机上安装。


支持多种客操作系统：常见的 Linux 发行版（CentOS、Ubuntu）、Windows Server、BSD 等。


虚拟化功能：


配置虚拟 CPU、内存、磁盘、网卡等。


支持桥接网络、NAT、仅主机网络等多种网络模式。




GUI + CLI 管理：既可以用图形界面管理虚拟机，也可以用命令行 VBoxManage 控制。


适合个人和开发使用：开源免费，功能较全。


2. Vagrant简介
Vagrant 是一个虚拟机 自动化管理工具，它本身不提供虚拟化功能，而是调用 VirtualBox、VMware、Hyper-V、Docker 等“虚拟化提供者”（provider）来创建和管理虚拟机。
特点：


开发环境自动化：

通过 Vagrantfile 描述一台（或多台）虚拟机的配置，比如操作系统镜像、CPU/内存、网络、共享目录等。


跨平台一致性：

不同开发者只要用相同的 Vagrantfile，就能快速得到一模一样的开发环境，避免“在我机器上没问题”。


支持多种 Provider：

默认支持 VirtualBox，也可以配合 VMware、Hyper-V、Libvirt、Docker。


Provisioning（自动化配置）：

可以在虚拟机启动时自动执行脚本（Shell、Ansible、Puppet、Chef）来安装软件和配置环境。


命令行简单：


vagrant init → 生成配置文件


vagrant up → 启动虚拟机


vagrant ssh → 进入虚拟机


vagrant halt → 关闭虚拟机


vagrant destroy → 删除虚拟机


PHP 8 新特性之枚举
Sun, 11 Jun 2023 13:46:01 +0800
PHP 8 新特性之枚举
枚举概览
枚举，或称 “Enum”，能够让开发者自定义类型为一系列可能的离散值中的一个。 在定义领域模型中很有用，它能够“隔离无效状态”（making invalid states unrepresentable）。
枚举以各种不同功能的形式出现在诸多语言中。 在 PHP 中， 枚举是一种特殊类型的对象。Enum 本身是一个类（Class）， 它的各种条目（case）是这个类的单例对象，意味着也是个有效对象 —— 包括类型的检测，能用对象的地方，也可以用它。
最常见的枚举例子是内置的 boolean 类型， 该枚举类型有两个有效值 true 和 false。 Enum 使开发者能够任意定义出用户自己的、足够健壮的枚举。


Enum 类似 class，它和 class、interface、trait 共享同样的命名空间。 也能用同样的方式自动加载。 一个 Enum 定义了一种新的类型，它有固定、数量有限、可能的合法值。
示例 #1 用注解实现接口的可选方法
1<?php
2
3// 通过传入参数：待搜索的注解类名，可返回指定的注解类， 而不需要再到反射类中迭代循环获取所有注解。
示例
 1<?php
 2
 3<?php
 4// 声明新的枚举类型 Suit，仅有四个有效的值： Suit::Hearts、Suit::Diamonds、 Suit::Clubs、Suit::Spades。
 5enum Suit
 6{
 7 case Hearts;
 8 case Diamonds;
 9 case Clubs;
10 case Spades;
11}
12
13// 变量可以赋值为以上有效值里的其中一个。 函数可以检测枚举类型，这种情况下只能传入类型的值。
14function pick_a_card(Suit $suit)
15{
16 /* ... */
17}
18
19$val = Suit::Diamonds;
20
21// OK
22pick_a_card($val);
23
24// OK
25pick_a_card(Suit::Clubs);
26?>
所有的case都有一个只读的属性 name，它大小写敏感，是case自身的名称


PHP 8 新特性之注解
Sun, 11 Jun 2023 13:46:01 +0800
PHP 8 新特性之注解功能
注解概览
注解功能提供了代码中的声明部分都可以添加结构化、机器可读的元数据的能力， 注解的目标可以是类、方法、函数、参数、属性、类常量。 通过 反射 API 可在运行时获取注解所定义的元数据。 因此注解可以成为直接嵌入代码的配置式语言。
通过注解的使用，在应用中实现功能、使用功能可以相互解耦。 某种程度上讲，它可以和接口（interface）与其实现（implementation）相比较。 但接口与实现是代码相关的，注解则与声明额外信息和配置相关。 接口可以通过类来实现，而注解也可以声明到方法、函数、参数、属性、类常量中。 因此它们比接口更灵活。
注解使用的一个简单例子：将接口（interface）的可选方法改用注解实现。 我们假设接口 ActionHandler 代表了应用的一个操作： 部分 action handler 的实现需要 setup，部分不需要。 我们可以使用注解，而不用要求所有类必须实现 ActionHandler 接口并实现 setUp() 方法。 因此带来一个好处——可以多次使用注解。
示例 #1 用注解实现接口的可选方法
 1<?php
 2interface ActionHandler
 3{
 4 public function execute();
 5}
 6
 7#[Attribute]
 8class SetUp {}
 9
10class CopyFile implements ActionHandler
11{
12 public string $fileName;
13 public string $targetDirectory;
14
15 #[SetUp]
16 public function fileExists()
17 {
18 if (!file_exists($this->fileName)) {
19 throw new RuntimeException("File does not exist");
20 }
21 }
22
23 #[SetUp]
24 public function targetDirectoryExists()
25 {
26 if (!file_exists($this->targetDirectory)) {
27 mkdir($this->targetDirectory);
28 } elseif (!is_dir($this->targetDirectory)) {
29 throw new RuntimeException("Target directory $this->targetDirectory is not a directory");
30 }
31 }
32
33 public function execute()
34 {
35 copy($this->fileName, $this->targetDirectory . '/' . basename($this->fileName));
36 }
37}
38
39function executeAction(ActionHandler $actionHandler)
40{
41 $reflection = new ReflectionObject($actionHandler);
42
43 foreach ($reflection->getMethods() as $method) {
44 $attributes = $method->getAttributes(SetUp::class);
45
46 if (count($attributes) > 0) {
47 $methodName = $method->getName();
48
49 $actionHandler->$methodName();
50 }
51 }
52
53 $actionHandler->execute();
54}
55
56$copyAction = new CopyFile();
57$copyAction->fileName = "/tmp/foo.jpg";
58$copyAction->targetDirectory = "/home/user";
59
60executeAction($copyAction);
注解语法
首先，注解声明总是以 #[ 开头，以 ] 结尾来包围。


Consul注册中心
Thu, 01 Jun 2023 11:46:01 +0800
Consul注册中心
CAP原理

一致性（Consistency） 所有节点在同一时间具有相同的数据
可用性（Availablility） 保证每个请求不管或者失败都有响应
分区容错（Partition tolerance） 系统中任意数据的丢失或失败不会影响系统的继续运作

Consul 介绍

方便部署
采用Raft算法实现，有服务发现，key/value存储，可以做配置中心使用。有健康检查，同事提供了web管理页面

Consul角色

-dev 开发环境下的启动命令，提供基本的服务
-client 客户端，无状态的，将http和dns请求转发到服务端集群
-server 服务端，保存配置信息，可以搭建高可用的集群

Consul 内部端口

	
			
					端口
					说明
			
	
	
			
					TCP/8300
					8300端口用于服务器节点。客户端通过该端口RPC协议调用服务端接口。
			
			
					TCP/UDP/8301
					8301端口用于单个数据中心所有节点之间的相互通信，即对LAN池信息的同步。它使得整个数据中心能够自动发现服务器地址，分布式检测节点故障，事件广播
			
			
					TCP/UDP/8302
					8302端口用于单个或多个数据中心之间的服务器节点的信息同步。即对WAN池信息的同步。它针对互联网的高延迟进行了优化，能够实现跨数据中心请求。
			
			
					8500
					8500端口基于HTTP协议，用于API接口或WEB UI访问。
			
			
					8600
					8600端口作为DNS服务器，它使得我们可以通过节点名查询节点的信息。
			
	

Consul 工作原理

Consul 安装
下载地址
或者docker安装
1docker run -d --name=consul -p 8500:8500 consul:1.15.4 agent -dev -client 0.0.0.0 -ui
安装完成后，命令行输入consul 检查 consul 是否可用
Consul支持web ui界面。UI可用于查看所有服务和节点，查看所有运行状况检查及其当前状态，以及读取和设置键/值数据。 用户界面自动支持多数据中心。要设置自带的UI，请使用-ui参数启动Consul代理：
consul agent -ui
UI可以在与HTTP API相同的端口上的/ui路径中使用。 默认情况下，这是http://localhost:8500/ui。
注册个服务
使用HTTP API 注册个服务，使用[接口API](https://www.consul.io/api/agent/service.html API)调用


网站流量统计
Tue, 30 May 2023 00:00:00 +0000
网站流量统计工具分享
1. Google Analytics

免费版功能很全，适合大部分网站
支持事件跟踪、用户分析、转化漏斗
需要按 GDPR 等法规配置隐私声明

2. Microsoft Clarity

完全免费
热图 + 会话回放，直观看到用户行为
与 GA 互补：GA 看数据，Clarity 看画面

如何选择

	
			
					工具
					强项
					适合场景
			
	
	
			
					Google Analytics
					数据指标、转化分析
					需要精细化数据分析的站点
			
			
					Microsoft Clarity
					热图、会话回放、免费
					想直观了解用户行为的个人博客
			
	

两者可以同时安装：GA 负责"量"，Clarity 负责"像"。本站点本身不做第三方统计，主题通过 extend_head.html 钩子预留了统计脚本注入位置（详见主题定制）。


Redis事务和锁
Sun, 28 May 2023 22:33:45 +0800
Redis事务

事务是指一个完整的动作，要么全部执行，要么什么也没有做。Redis 事务不是严格意义上的事务，只是用于帮助用户在一个步骤中执行多个命令。单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。
Redis 事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做。

Redis 的事务不是原子性，但是Redi执行每一个命令都是原子性的

举例：INCR在redis中是自增，即使多个客户端对同一个密钥发出INCR，也永远不会进入竞争状态。例如，客户机1读取“10”，客户机2同时读取“10”，两者都增加到11，并将新值设置为11，这样的情况永远不会发生。最终的值将始终是12。

这个案例是官网提出来的：https://redis.io/docs/data-types/tutorial/

事务一般都是为原子性而生，既然Redis事务没有原子性，那他存在的意义是什么？

redis事务的主要作用就是串联多个命令防止 别的命令插队。
官网介绍：https://redis.com.cn/redis-transaction.html
Redis事务 - 基本使用
Redis 在形式上看起来也差不多，MULTI、EXEC、DISCARD这三个指令构成了 redis 事务处理的基础：
MULTI：用来组装一个事务，从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，redis会将之前的命令依次执行。
EXEC：用来执行一个事务
DISCARD：用来取消一个事务
所有的指令在 exec 之前不执行，而是缓存在服务器的一个事务队列中，服务器一旦收到 exec 指令，才开执行整个事务队列，执行完毕后一次性返回所有指令的运行结果。因为 Redis 的单线程特性，不用担心自己在执行队列的时候被其它指令打搅，可以保证他们能得到的有顺序的执行。
取消事务，放弃执行事务块内的所有命令。
组队中某个命令出现了错误报告，执行时整个队列中所有的命令都会被取消。
命令组队的过程中没有问题，执行中出现了错误会导致部分成功部分失败。
悲观锁&乐观锁
悲观锁（Pessimistic Lock），顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人拿到这个数据就会block直到它拿到锁。传统的关系型数据库里面就用到了很多这种锁机制，比如行锁、表锁、读锁、写锁等，都是在做操作之前先上锁。
乐观锁（Optimistic Lock），顾名思义，就是很乐观，每次去那数据的时候都认为别人不会修改，所以不会上锁，但是在修改的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。redis就是使用这种check-and-set机制实现事务的。
watch监听
WATCH：在执行multi之前，先执行watch key1 [key2 …]，可以监视一个或者多个key，若在事务的exec命令之前这些key对应的值被其他命令所改动了，那么事务中所有命令都将被打断，即事务所有操作将被取消执行。
unwatch：取消 WATCH 命令对所有 key 的监视。如果在执行 WATCH 命令之后， EXEC 命令或 DISCARD 命令先被执行了的话，那么就不需要再执行UNWATCH 了。
简单示例秒杀场景
 1<?php
 2// 连接Redis
 3$redis = new Redis();
 4$redis->connect('127.0.0.1',6379);
 5
 6$redis->watch('sales');
 7$sales = $redis->get('sales');
 8$store = 10;
 9if($sales >= $store){
10 exit('结束');
11}
12// 事务
13$redis->multi();
14$redis->incr('sales');
15$res = $redis->exec();
16
17if($res){
18 // 库存更新...
19}
20?>



MFA
Fri, 12 May 2023 13:46:01 +0800
MFA
一、MFA 是什么
MFA（Multi-Factor Authentication，多因素认证） 是一种提高账户安全性的认证方式。
它要求用户在登录或进行敏感操作时提供 多种不同类别的验证因素，从而增强安全性。
通常 MFA 包含三类因素：

	
			
					因素类型
					描述
					示例
			
	
	
			
					知识因素（Something you know）
					用户知道的信息
					密码、PIN
			
			
					持有因素（Something you have）
					用户拥有的物品
					手机验证码（OTP）、硬件密钥
			
			
					固有因素（Something you are）
					用户自身的特征
					指纹、面部识别、虹膜识别
			
	

核心理念：仅凭密码不安全，增加第二甚至第三因素可以有效防止账号被盗。
二、常见应用场景


金融系统

登录网银或支付系统时，需要输入密码 + 手机短信验证码。


企业内部 SSO / VPN 登录

员工登录内部系统时，需要密码 + 动态令牌或硬件钥匙。


云服务 / SaaS 平台

如 GitHub、Google、AWS 等，用户可启用 MFA 提高账户安全。


敏感操作验证

修改密码、提现或支付等操作，需要额外的 MFA 验证。


三、MFA 的典型流程（以 TOTP 为例）


绑定 MFA

用户登录后扫描二维码绑定 MFA（生成密钥），服务器存储密钥。



生成动态验证码

用户通过 App（Google Authenticator、Authy）生成 6 位一次性验证码。



登录验证


OAuth 2.0
Fri, 12 May 2023 13:46:01 +0800
OAuth 2.0
一、OAuth2.0 是什么
OAuth 2.0 是一种开放标准的授权协议，用于在不暴露账号密码的情况下，让用户授权第三方应用访问其受保护的资源。

它主要解决的问题是：如何安全地委托访问权限。
核心概念：

	
			
					角色
					说明
			
	
	
			
					资源所有者（Resource Owner）
					用户或数据所有者
			
			
					客户端（Client）
					第三方应用，需要访问资源
			
			
					授权服务器（Authorization Server）
					颁发令牌的服务器，负责验证用户身份并授权
			
			
					资源服务器（Resource Server）
					存储用户受保护资源的服务器，验证令牌后提供数据
			
	

二、 常用场景


第三方登录（Social Login）

用户使用微信、GitHub、Google 登录你的站点，后端获取 Access Token 调用接口获取用户信息。


开放 API / 平台化

向合作伙伴提供 API，使用 OAuth 2.0 控制访问权限和作用域。


微服务内部接口调用

服务 A 调用服务 B 的接口，通过 Client Credentials 模式获取 Token，避免硬编码密码。


企业内部 SSO（单点登录）

多系统统一认证，用户在登录一次后，访问其他系统不需要重复登录。


前后端分离应用（SPA / Mobile App）

前端获取授权码，换取 Access Token，安全访问 API，密码不在前端传递。


三、OAuth 2.0 主要流程
以 授权码模式（Authorization Code Grant） 为例：


请求授权：客户端引导用户跳转到授权服务器，传入 client_id、redirect_uri、scope。


Brew 使用指南
Thu, 11 May 2023 20:46:01 +0800
Brew 使用指南
一、什么是 brew？
全程：Homebrew


macOS（或 Linux）软件包管理器。它可以让你轻松地安装、更新、卸载软件，解决软件依赖关系，你不再需要手动下载、拖拽安装或处理复杂的编译选项。


Homebrew 会将软件包安装到独立目录，并将其文件软链接至 /opt/homebrew 。


brew官网


二、安装 Homebrew
在终端（Terminal）中执行以下命令：
1/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
安装完成后，运行以下命令确保 Brew 工作正常：
1brew doctor
三、基础使用命令
1. 安装软件

安装命令行工具（Formula）：
1brew install <formula_name>
2# 示例：安装 wget, tree, node
3brew install wget tree node

安装图形界面应用（Cask）
1brew install --cask <cask_name>
2# 示例：安装 Chrome, VS Code, Spotify
3brew install --cask google-chrome visual-studio-code spotify


2. 查询软件

搜索软件（不确定完整包名时非常有用）：
1brew search <keyword>
2# 示例：搜索所有与 python 相关的包
3brew search python

查看已安装的软件列表：
1brew list # 列出所有通过 Formula 安装的命令行工具
2brew list --cask # 列出所有通过 Cask 安装的应用程序

查看某个软件的信息：
1brew info <formula_name>
2brew info --cask <cask_name>


3. 更新软件

更新 Homebrew 自身（获取最新的 Formula 和 Cask 列表）：

1brew update

检查哪些软件可以更新：
1brew outdated

更新所有软件：
1brew upgrade

更新指定软件：
1brew upgrade <formula_name>

更新 Cask 应用： 对于 Cask 应用，upgrade 命令同样有效。如果应用有自动更新功能（如 Chrome），则可能无需通过 Brew 更新。
1brew upgrade --cask <cask_name>


4. 卸载软件

卸载软件：
1brew uninstall <formula_name>
2brew uninstall --cask <cask_name>

清理旧版本和缓存： Homebrew 会保留旧版本和下载缓存，定期清理可以节省空间。

1brew cleanup # 清理所有旧版本软件的缓存
2brew cleanup <formula_name> # 清理指定软件的缓存
3brew cleanup -n # 查看哪些会被清理，但不实际执行（干跑）
四、 高级用法
1. 管理服务（Services）
Homebrew 可以像 systemd 一样管理一些后台服务（如 MySQL, Nginx, PostgreSQL）。


PHP 8 新特性
Thu, 11 May 2023 13:46:01 +0800
PHP 8 新特性
命名参数（8.0）
新增命名参数的功能:
在函数或方法调用时，可通过参数名来指定参数的值，而不仅仅依赖参数的位置
从 PHP 8.0.0 开始，函数参数列表可以包含一个尾部的逗号，这个逗号将被忽略。这在参数列表较长或包含较长的变量名的情况下特别有用，这样可以方便地垂直列出参数。
 1<?php
 2function takes_many_args(
 3 $first_arg,
 4 $second_arg,
 5 $again = 'a default string', // 在 8.0.0 之前，这个尾部的逗号是不允许的。
 6){
 7 // ...
 8}
 9z
10takes_many_args(1, 2); //按照参数顺序传参
11takes_many_args(first_arg:1, second_arg:2); //指定参数，不分顺序
12
13// 类也可以使用命名参数，假设Demo类构造函数有$first_arg，$second_arg,两个参数，有takes_many_args方法
14$demo = new Demo(first_arg:1, second_arg:2); 
15$demo->takes_many_args(first_arg:1, second_arg:2);
16
17// 不能用位置的参数和命名的参数一起
18// 可选参数必须在必选参数后面 例如上面的$again
19?>
注解（Attributes）（8.0）
新增注解的功能。
此篇单独介绍
构造器属性提升（Constructor Property Promotion）（8.0）
新增构造器属性提升功能 在构造函数中声明类的属性）。
构造器的参数也可以相应提升为类的属性。 构造器的参数赋值给类属性的行为很普遍，否则无法操作。 而构造器提升的功能则为这种场景提供了便利。
 1<?php
 2class Point {
 3 protected int $x;
 4 protected int $y;
 5
 6 public function __construct(int $x, int $y = 0) {
 7 $this->x = $x;
 8 $this->y = $y;
 9 }
10}
11
12// 两个参数都传入
13$p1 = new Point(4, 5);
14// 仅传入必填的参数。 $y 会默认取值 0。
15$p2 = new Point(4);
16// 使用命名参数（PHP 8.0 起）:
17$p3 = new Point(y: 5, x: 4);
18
19// 上面的例子可以用以下方式重写：
20class Point {
21 public function __construct(protected int $x, protected int $y = 0) {
22 }
23}
联合类型（8.0）
新增 联合类型。


Git提交日志规范指南
Sun, 02 Apr 2023 21:46:01 +0800
在软件开发流程中，Git已经成为版本控制的事实标准。每次提交代码都需要填写commit message，否则不允许提交。然而，在日常开发中，我们经常会看到各种各样模糊不清的提交信息，如“fix bug”、“更新代码”、“修改问题”等。这些不规范的commit message充斥在git history中，导致后续维护人员无法快速定位问题，有时甚至连提交者自己都不记得某次提交的目的。因此，我们需要一套统一的规范来管理和约束commit message。
规范概述
目前业界最知名的规范是Angular团队的commit message规范，它结构清晰、易于实施，已被广泛应用于开源项目和商业项目中。同时，许多IDE（如IntelliJ IDEA）也提供了相应的插件（如Git Commit Template）来辅助开发者遵循这一规范。
本文将以Angular规范为基础，详细介绍一套通用的Git commit message规范，并提供具体的操作示例。
Commit Message整体结构
规范的commit message包含三个部分：Header、Body和Footer。其格式如下：
<header>
<BLANK LINE>
<body>
<BLANK LINE>
<footer>
重要说明：

Header是必需的，包含type、scope和summary三个子元素
Body是必需的，用于详细描述提交内容
Footer是可选的，用于记录不兼容变更或关闭issue

关键规则：Header和Body之间必须有一个空行分隔，这是许多Git工具正确解析提交信息的前提。
整体结构示例
feat(用户认证): 增加短信验证码登录功能

为了提升用户登录体验，增加了通过手机号接收验证码进行登录的方式。
- 集成阿里云短信服务
- 新增验证码生成与校验逻辑
- 更新登录页面UI

Closes #245
Header详解
Header是commit message的“标题”，格式为：
<type>(<scope>): <summary>
其中，type和summary为必填项，scope为可选项。
Type：提交类别
Type用于说明本次提交的类别，必须使用以下标准化标识之一：

	
			
					Type
					说明
					使用场景
			
	
	
			
					feat
					新功能
					新增用户可见的功能特性
			
			
					fix
					修复bug
					修复线上或测试环境发现的缺陷
			
			
					docs
					文档更新
					仅修改文档，不涉及代码变更
			
			
					style
					代码格式
					不影响代码运行的格式调整（空格、缩进、分号等）
			
			
					refactor
					代码重构
					既不是新增功能，也不是修复bug的代码结构调整
			
			
					perf
					性能优化
					提升系统性能或用户体验的代码变更
			
			
					test
					测试相关
					新增或修改测试用例
			
			
					chore
					构建/工具变动
					构建流程、依赖管理、辅助工具等变更
			
			
					revert
					回滚提交
					撤销之前的某次提交
			
	

Type使用示例：


项目规范指南
Sat, 01 Apr 2023 21:46:01 +0800
项目规范指南
本规范适用于团队/开源项目的版本管理，目标是做到：规范化、可追踪、可溯源。
1. 版本管理 (Versioning)

遵循 语义化版本规范 (Semantic Versioning, SemVer 2.0.0)
MAJOR.MINOR.PATCH


MAJOR：主版本号，不兼容的 API 改动


MINOR：次版本号，新增功能（向下兼容）


PATCH：修订号，修复 bug（向下兼容）



先行版本号及版本编译信息可以加到“主版本号.次版本号.修订号”的后面，作为延伸。
预发布版本：1.0.0-alpha.1、2.0.0-rc.1

参考语义化版本规范：https://semver.org/lang/zh-CN/
2. LICENSE (MIT)
作用：MIT，明确版权
规范


项目必须包含 LICENSE 文件，放置于项目根目录。


推荐使用 MIT License（宽松、常用，几乎所有开源项目可接受）。


文件名统一：LICENSE（不要写成 LICENSE.txt 或 license.md）。


在 README.md 中需明确说明 License 类型。


示例
LICENSE 文件（MIT）：
1MIT License
2
3Copyright (c) 2025 Your Name
4
5Permission is hereby granted, free of charge, to any person obtaining a copy
6of this software and associated documentation files (the "Software"), to deal
7...
3. README.md
作用：项目介绍 + 使用 + License


PHP8新特性之match表达式
Tue, 14 Mar 2023 20:46:01 +0800
PHP8 alpha2发布了，最近引入了一个新的关键字：match, 这个关键字的作用跟switch有点类似。
虽然我一般对语法糖无感，但这个我觉得还是有点意思，match这个词也挺好看，那么它是干啥的呢？
在以前我们可能会经常使用switch做值转换类的工作，类似:
 1 switch ($input) {
 2     case "true":
 3         $result = 1;
 4     break;
 5     case "false":
 6         $result = 0;
 7     break;
 8     case "null":
 9         $result = NULL;
10     break;
11 }
(当然，有的同学会说，谁会这么写，用个数组转换不行么？ 拜托，这是举例啊，数组也只能数字键和整数啊，万一key是需要其他表达式呢，万一你要多个key对应一个值呢，对吧？)
那么如果使用match关键字呢，可以变成类似:
1$result = match($input) {
2         "true" => 1,
3         "false" => 0,
4         "null" => NULL,
5};
相比switch， match会直接返回值，可以直接赋值给$result了。
并且，类似switch的多个case一个block一样，match的多个条件也可以写在一起，比如:
1 $result = match($input) {
2     "true", "on" => 1,
3     "false", "off" => 0,
4     "null", "empty", "NaN" => NULL,
5};
需要注意的和switch不太一样的是，以前我们用switch可能会经常遇到这种诡异的问题:
1 $input = "2 person";
2 switch ($input) {
3     case 2:
4         echo "bad";
5     break;
6}
你会发现，bad竟然被输出了，这是因为switch使用了宽松比较(==)。match就不会有这个问题了, 它使用的是严格比较(===)，就是值和类型都要完全相等。
还有就是，当input并不能被match中的所有条件满足的时候，match会抛出一个UnhandledMatchError exception:
1 $input = "false";
2 $result = match($input) {
3         "true" => 1,
4 };
会得到:

Fatal error: Uncaught UnhandledMatchError: Unhandled match value of type string

这样就不用担心万一match条件没写全导致了不可预知的错误。
另外还是要说明，match是关键字，也就是从PHP8开始它不能出现在namespace或者类名中，如果你的项目中有用match作为类名的:


B+Tree
Sun, 12 Mar 2023 22:46:01 +0800
B+Tree
B+Tree 是一种平衡多路搜索树，广泛应用于数据库和文件系统等领域，其核心优势在于优化磁盘存储效率和查询性能.
MySQL的InnoDB存储引擎使用的索引结构就是 B+树，它是B树的一个重要变种。
1. 从B树到B+树


B树：一种自平衡的、多路的搜索树。它允许每个节点有多个子节点（多于两个，所以不是二叉树）。


B+树：在B树基础上优化而来的数据结构，是现代数据库系统中事实上的标准索引结构。


MySQL的InnoDB使用的正是 B+树。
2. 为什么数据库需要B+树？
要理解B+树，必须先理解它的设计目标。数据库的数据存储在磁盘上，磁盘I/O（读写磁盘）的速度比内存访问慢几个数量级。因此，数据库索引的核心目标是：最大限度地减少磁盘I/O次数。
B+树通过以下方式完美地实现了这一目标：


矮胖：与“瘦高”的二叉树相比，B+树每个节点可以存储非常多的键，这使得树的层级非常少（通常只有3-4层），从而保证在亿万级数据量下，查找任何一条记录最多只需要3-4次磁盘I/O。


顺序访问友好：B+树非常适合磁盘的预读特性，能够高效地进行范围查询。


3. B+树的详细结构
它由两种类型的节点组成：内部节点 和 叶子节点。
内部节点（非叶子节点）


作用：仅充当导航目录。


存储内容：只存储键值（索引列的值）和指向子节点的指针。


不存储：实际行的数据。


叶子节点


作用：存储实际的数据。


存储内容：


在 主键索引（聚簇索引） 中：叶子节点存储的就是完整的行数据。


在 辅助索引（二级索引） 中：叶子节点存储的是该索引的键值和对应的主键值。




关键特性：所有叶子节点通过指针相互连接，形成了一个有序的双向链表。这是B+树与B树的一个核心区别。


4. B+树的核心特性与优势（对比B树）

	
			
					特性
					B树
					B+树
					B+树的优势
			
	
	
			
					数据存储位置
					内部节点和叶子节点都存储数据。
					只有叶子节点存储数据，内部节点仅为索引。
					更“矮胖”的树。因为内部节点不存数据，所以一个节点能容纳的键更多，扇出（子节点数）更大，树高更低，I/O次数更少。
			
			
					叶子节点链接
					叶子节点之间没有链接。
					叶子节点通过双向链表连接。
					无敌的范围查询。要查询age BETWEEN 20 AND 30的所有记录，B+树只需找到20，然后顺着链表遍历即可。B树则需要不断地在树的中上层和下层之间来回跳跃，性能极差。
			
			
					扫描和全表遍历
					需要对整棵树进行复杂的中序遍历。
					只需遍历底层的链表即可获得所有数据，非常高效。
					对数据仓库、聚合查询等场景非常友好。
			
			
					查询稳定性
					由于数据可能在内部节点找到，查询时间不稳定。
					任何查询都必须走到叶子节点，查询时间非常稳定。
					保证了可预测的性能。
			
	

5. 在MySQL中的具体体现：聚簇索引
在MySQL InnoDB中，主键索引就是一颗B+树，并且这棵B+树的叶子节点直接存储了完整的行数据。这种索引组织表的方式被称为“聚簇索引”。


表数据文件本身就是按B+树结构组织的一个索引文件。


如果你没有定义主键，InnoDB会选择一个唯一的非空索引代替，如果没有这样的索引，它会隐式地定义一个主键。


辅助索引（二级索引） 也是一颗B+树，但它的叶子节点存储的是该索引列的值和对应记录的主键值。当通过二级索引查找数据时，需要先找到主键，再回到主键索引（聚簇索引）中查找完整数据，这个过程称为“回表”。


常用算法的PHP实现
Sun, 12 Mar 2023 22:46:01 +0800
常用算法的PHP实现
1. 快速排序 (Quick Sort)
 1<?php
 2function quickSort($arr) {
 3 if (count($arr) <= 1) {
 4 return $arr;
 5 }
 6 
 7 $pivot = $arr[0];
 8 $left = $right = [];
 9 
10 for ($i = 1; $i < count($arr); $i++) {
11 if ($arr[$i] < $pivot) {
12 $left[] = $arr[$i];
13 } else {
14 $right[] = $arr[$i];
15 }
16 }
17 
18 return array_merge(quickSort($left), [$pivot], quickSort($right));
19}
20
21// 测试
22$numbers = [64, 34, 25, 12, 22, 11, 90];
23echo "原始数组: " . implode(', ', $numbers) . "\n";
24echo "快速排序: " . implode(', ', quickSort($numbers)) . "\n";
25?>
2. 二分查找 (Binary Search)
 1<?php
 2function binarySearch($arr, $target) {
 3 $left = 0;
 4 $right = count($arr) - 1;
 5 
 6 while ($left <= $right) {
 7 $mid = floor(($left + $right) / 2);
 8 
 9 if ($arr[$mid] == $target) {
10 return $mid; // 找到目标，返回索引
11 }
12 
13 if ($arr[$mid] < $target) {
14 $left = $mid + 1;
15 } else {
16 $right = $mid - 1;
17 }
18 }
19 
20 return -1; // 未找到
21}
22
23// 测试（数组必须已排序）
24$sortedArray = [2, 5, 8, 12, 16, 23, 38, 45, 67];
25$target = 23;
26$result = binarySearch($sortedArray, $target);
27
28echo "在数组 [" . implode(', ', $sortedArray) . "] 中查找 $target\n";
29echo "结果索引: " . ($result !== -1 ? $result : "未找到") . "\n";
30?>
3. 斐波那契数列 (Fibonacci)
 1<?php
 2// 递归版本（简单但效率低）
 3function fibonacciRecursive($n) {
 4 if ($n <= 1) {
 5 return $n;
 6 }
 7 return fibonacciRecursive($n - 1) + fibonacciRecursive($n - 2);
 8}
 9
10// 动态规划版本（高效）
11function fibonacciDP($n) {
12 if ($n <= 1) {
13 return $n;
14 }
15 
16 $dp = [0, 1];
17 for ($i = 2; $i <= $n; $i++) {
18 $dp[$i] = $dp[$i - 1] + $dp[$i - 2];
19 }
20 
21 return $dp[$n];
22}
23
24// 测试
25$n = 10;
26echo "斐波那契数列前{$n}项:\n";
27for ($i = 0; $i < $n; $i++) {
28 echo fibonacciDP($i) . " ";
29}
30echo "\n";
31?>
4. 广度优先搜索 (BFS)
 1<?php
 2function bfs($graph, $start) {
 3 $visited = [];
 4 $queue = new SplQueue();
 5 
 6 $visited[$start] = true;
 7 $queue->enqueue($start);
 8 $result = [];
 9 
10 while (!$queue->isEmpty()) {
11 $vertex = $queue->dequeue();
12 $result[] = $vertex;
13 
14 foreach ($graph[$vertex] as $neighbor) {
15 if (!isset($visited[$neighbor])) {
16 $visited[$neighbor] = true;
17 $queue->enqueue($neighbor);
18 }
19 }
20 }
21 
22 return $result;
23}
24
25// 测试
26$graph = [
27 'A' => ['B', 'C'],
28 'B' => ['A', 'D', 'E'],
29 'C' => ['A', 'F'],
30 'D' => ['B'],
31 'E' => ['B', 'F'],
32 'F' => ['C', 'E']
33];
34
35echo "BFS遍历结果: " . implode(' -> ', bfs($graph, 'A')) . "\n";
36?>
5. 冒泡排序 (Bubble Sort)
 1<?php
 2function bubbleSort($arr) {
 3 $n = count($arr);
 4 
 5 for ($i = 0; $i < $n - 1; $i++) {
 6 $swapped = false;
 7 
 8 for ($j = 0; $j < $n - $i - 1; $j++) {
 9 if ($arr[$j] > $arr[$j + 1]) {
10 // 交换元素
11 $temp = $arr[$j];
12 $arr[$j] = $arr[$j + 1];
13 $arr[$j + 1] = $temp;
14 $swapped = true;
15 }
16 }
17 
18 // 如果没有交换，说明已经排序完成
19 if (!$swapped) {
20 break;
21 }
22 }
23 
24 return $arr;
25}
26
27// 测试
28$numbers = [64, 34, 25, 12, 22, 11, 90];
29echo "冒泡排序: " . implode(', ', bubbleSort($numbers)) . "\n";
30?>
6. 查找最大子数组和 (Kadane算法)
 1<?php
 2function maxSubArraySum($arr) {
 3 $maxSoFar = $arr[0];
 4 $maxEndingHere = $arr[0];
 5 
 6 for ($i = 1; $i < count($arr); $i++) {
 7 $maxEndingHere = max($arr[$i], $maxEndingHere + $arr[$i]);
 8 $maxSoFar = max($maxSoFar, $maxEndingHere);
 9 }
10 
11 return $maxSoFar;
12}
13
14// 测试
15$array = [-2, 1, -3, 4, -1, 2, 1, -5, 4];
16echo "数组: " . implode(', ', $array) . "\n";
17echo "最大子数组和: " . maxSubArraySum($array) . "\n"; // 输出: 6
18?>
7. 判断素数
 1<?php
 2function isPrime($n) {
 3 if ($n <= 1) return false;
 4 if ($n <= 3) return true;
 5 if ($n % 2 == 0 || $n % 3 == 0) return false;
 6 
 7 for ($i = 5; $i * $i <= $n; $i += 6) {
 8 if ($n % $i == 0 || $n % ($i + 2) == 0) {
 9 return false;
10 }
11 }
12 
13 return true;
14}
15
16// 测试
17$numbers = [2, 3, 4, 17, 25, 29];
18foreach ($numbers as $num) {
19 echo "$num 是" . (isPrime($num) ? "素数" : "非素数") . "\n";
20}
21?>



数据结构
Sun, 12 Mar 2023 22:46:01 +0800
数据结构
一、说明
数据结构是计算机科学中一个非常基础和核心的概念，它对于编程、算法设计和软件工程都至关重要。
简单来说，数据结构是一种在计算机中组织、管理和存储数据的方式，目的是为了实现高效地访问和修改。
可以把它想象成一个储物系统：


把一堆书随便堆在地上，这是一种“存储”，但找起来非常困难。


使用一个带标签的书架，把书分门别类地放好，找书、放书就高效得多。


这个“书架”以及“如何给书分类、摆放”的规则，就是一种“数据结构”。


为什么数据结构如此重要？
选择合适的数据结构可以极大地影响程序的性能和效率。一个精心选择的数据结构可以让操作（如搜索、插入、删除）变得非常快；而错误的选择则可能导致程序运行缓慢甚至崩溃。
二、 常见的数据结构分类和类型
数据结构主要可以分为两大类：线性结构和非线性结构。
一、 线性数据结构
元素按顺序排列，形成一条“线”。


数组：在内存中连续存储相同类型的元素。通过索引可以快速访问任意元素。


优点：随机访问速度快。


缺点：大小固定（在某些语言中），插入和删除元素效率低。




链表：由一系列节点组成，每个节点包含数据和指向下一个节点的指针。


优点：大小动态，插入和删除元素效率高。


缺点：不能随机访问，必须从头开始遍历。




栈：一种后进先出的结构，像一摞盘子。只能在顶部进行添加（压栈）和移除（弹栈）操作。

应用：函数调用栈、撤销操作、表达式求值。



队列：一种先进先出的结构，像排队一样。从队尾添加元素，从队首移除元素。


应用：任务调度、消息队列、广度优先搜索。


变种：双端队列、优先队列。




二、 非线性数据结构
元素之间不是简单的前后关系，可能存在多个连接。


树：一种分层结构，由节点和边组成。最顶端的节点叫根节点。


二叉树：每个节点最多有两个子节点。


二叉搜索树：左子树所有节点的值小于根节点，右子树所有节点的值大于根节点。这使得搜索非常高效。


应用：文件系统、数据库索引、决策树。




图：由顶点和连接顶点的边组成。可以表示任意复杂的关系网络。

应用：社交网络、地图导航、网络路由。



哈希表：通过一个哈希函数将键映射到一个位置来访问记录，以实现极快的查找速度。


优点：在平均情况下，插入、删除和查找的时间复杂度都是 O(1)。


应用：字典、集合、缓存。




三、核心操作与算法
对于每种数据结构，我们通常关心以下几个核心操作的效率：


访问


搜索


插入


删除


这些操作的效率通常用 大O表示法 来衡量，它描述了算法时间或空间复杂度随数据规模增长的趋势。
四、作用
数据结构是构建高效算法的基石。学习数据结构能帮助你：


写出更高效的代码：理解不同操作的代价。


解决复杂问题：很多复杂问题本质上就是数据组织和处理的问题。


更好地理解计算机系统：从内存管理到数据库，底层都离不开数据结构。




算法
Sun, 12 Mar 2023 22:46:01 +0800
算法
算法是计算机科学的核心基础之一，简单来说它是解决特定问题的一系列清晰指令。无论是简单的计算还是复杂的人工智能任务，都离不开算法。
1. 算法是什么？
你可以把算法想象成一个菜谱：


输入：食材（数据）


处理步骤：清晰的烹饪步骤（算法逻辑）


输出：一道菜肴（结果）


它的核心目标是用最优的方式（最快、最省资源）解决问题。
2. 算法的核心特性
一个“好”的算法通常具备以下特点：


正确性：必须能正确解决问题。


高效性：执行时间和占用空间要尽可能少。


明确性：每一步都必须清晰、无歧义。


有限性：必须在有限的步骤内结束。


3. 常见的算法类别与实例
算法种类繁多，以下是一些主要类别和经典例子：


排序算法


快速排序：采用“分治”思想，选择一个基准元素，将数组分成左右两部分，效率很高。


归并排序：也是“分治”思想，先将数组不断拆分，再合并排序，稳定且高效。


冒泡排序：反复交换相邻的逆序元素，简单但效率低。




搜索算法


二分查找：在已排序的数组中，每次比较都能排除一半的数据，效率极高（O(log n)）。


深度优先搜索和广度优先搜索：用于遍历或搜索树和图结构，是许多复杂算法的基础。




图算法


Dijkstra算法：用于寻找图中两点之间的最短路径。


A*搜索算法：在Dijkstra基础上加入了启发式函数，是路径规划和游戏AI的基石。




动态规划

用于解决具有重叠子问题和最优子结构的复杂问题（如斐波那契数列、背包问题），通过存储中间结果来避免重复计算。



机器学习算法（AI领域）


线性回归/逻辑回归：用于预测和分类。


决策树/随机森林：通过树形结构做决策。


支持向量机：寻找最佳分类边界。


神经网络：模仿人脑神经元，是深度学习的核心。




4. 如何衡量算法的好坏？—— “复杂度分析”
我们使用 “大O表示法” 来描述算法的效率，主要看：


时间复杂度：随着数据规模增大，算法运行时间的增长趋势。例如 O(1), O(log n), O(n), O(n²)。


空间复杂度：随着数据规模增大，算法占用内存空间的增长趋势。


5. 为什么算法如此重要？


效率：好的算法能处理海量数据，差的算法在大数据面前寸步难行。


性能：直接影响软件和应用的反应速度与用户体验。


解决问题的基础：是开发任何软件系统、进行科学计算和实现人工智能的基石。


面试核心：是国内外大型科技公司技术面试的必考内容。




记录一些句子
Sun, 12 Mar 2023 13:46:01 +0800
记录一些句子
你是否也曾被一句话深深触动？还记得吗？
生活
刀枪入库，马放南山。- 清代.钱彩.《说岳全传》
先去你的塞外,再回我的江南。 -金庸.《天龙八部》
小舟从此逝，江海寄余生。 - 《临江仙·夜饮东坡醒复醉》
行到水穷处，坐看云起时。 - 《终南别业》
道
上善若水，水利万物而不争。 - 《道德经》
朝闻道，夕死可矣。 ——《论语·里仁》
天下同归而殊途，一致而百虑。 ——《易经·系辞下》
大方无隅，大器晚成，大音希声，大象无形。 - 《道德经》
为天地立心，为生民立命，为往圣继绝学，为万世开太平。 - 《横渠语录》
相濡以沫，不如相忘于江湖。 - 《庄子》
苟日新，日日新，又日新。 - 《大学》
慎终如始，则无败事。 - 《道德经》
为者常成，行者常至。 - 《晏子春秋》

一念起天涯咫尺，一念灭咫尺天涯。


我步入丛林
Sun, 12 Mar 2023 13:46:01 +0800
我步入丛林，因为我希望生活的有意义，我希望活的深刻。汲取生命中所有的精华，把非生命的一切都击溃，以免让我在生命终结时，发现自己从来没有活过！
I went to the woods because I wanted to live deliberately. I wanted to live deep and suck out all the marrow of life!To put to rout allthat was not life, and not, when I had come to die, discover that I had not lived.
推荐电影《死亡诗社》
原文出自 《瓦尔登湖》-亨利·戴维·梭罗


docker删除none镜像
Sat, 11 Mar 2023 20:46:01 +0800
docker删除none镜像
1、使用git bash进入到docker文件夹
2、查询所有的none镜像
1docker images | grep none
3、查询所有的none镜像的id
1docker images | grep none | awk '{print $3}'
4、删除所有的none镜像
1docker images | grep none | awk '{print $3}' | xargs docker rmi
docker none镜像说明
一、有效的 none 镜像
Docker文件系统的组成，docker镜像是由很多 layers组成的，每个 layer之间有父子关系，所有的docker文件系统层默认都存储在/var/lib/docker/graph目录下，docker称之为图层数据库。
最后做一个总结< none>:< none> 镜像是一种中间镜像，我们可以使用docker images -a来看到，他们不会造成硬盘空间占用的问题（因为这是镜像的父层，必须存在的），但是会给我们的判断带来迷惑。
二、无效的 none 镜像
另一种类型的 < none>:< none> 镜像是dangling images ，这种类型会造成磁盘空间占用问题。
像Java和Golang这种编程语言都有一个内存区，这个内存区不会关联任何的代码。这些语言的垃圾回收系统优先回收这块区域的空间，将他返回给堆内存，所以这块内存区对于之后的内存分配是有用的
docker的悬挂(dangling)文件系统与上面的原理类似，他是没有被使用到的并且不会关联任何镜像，因此我们需要一种机制去清理这些悬空镜像。
我们在上文已经提到了有效的< none>镜像，他们是一种中间层，那无效的< none>镜像又是怎么出现的？这些 dangling镜像主要是我们触发 docker build 和 docker pull命令产生的。
使用下面的命令可以清理
1docker rmi $(docker images -f "dangling=true" -q)



php-msf-docker
Sat, 11 Mar 2023 11:46:01 +0800
php-msf-docker
基于centos:centos7.9.2009镜像制作的php开发环境镜像
主要包含：

PHP-8.1.14
redis-5.3.7
swoole-src-5.0.2
nginx-1.21.5
supervisor
sshd

GitHub地址 : https://hub.docker.com/r/leanku/php-msf-docker
DockerHub地址 : https://hub.docker.com/r/leanku/php-msf-docker
包含扩展
1bcmath,Core,ctype,curl,date,dom,exif,fileinfo,filter,ftp,gd,gettext,hash,iconv,intl,json,libxml,mbstring,mysqli,mysqlnd,openssl,pcntl,pcre,PDO,pdo_mysql,pdo_pgsql,pdo_sqlite,pgsql,Phar,posix,redis,Reflection,session,shmop,SimpleXML,soap,sockets,sodium,SPL,sqlite3,standard,sysvsem,tokenizer,xml,xmlreader,xmlwriter,xsl,zip,zlib,swoole

运行示例
docker run --privileged --restart=always -it -d \
--hostname=php-msf --name=php-msf-docker \
-p 22:22 -p 80:80 -p 3306:3306 -p 8000:8000 -p 9501:9501 \
-v /c/docker/www:/php-msf/data/www \
leanku/php-msf-docker

SSH
默认用户：super 密码：123456
1ssh super@127.0.0.1



行有余力，则以学文
Thu, 09 Mar 2023 21:04:48 +0800
子曰：弟子入则孝，出则弟，谨而信，泛爱众，而亲仁，行有余力，则以学文。
孔子说：“弟子们在父母跟前，就孝顺父母；出门在外，顺从师长，言行要谨慎，要诚实可信，寡言少语，要广泛地去爱众人，亲近那些有仁德的人。这样躬行实践之后，还有余力的话，就再去学习文献知识。”
《论语·学而篇》- 孔子


PHP位运算使用
Tue, 28 Feb 2023 22:33:45 +0800
PHP 位运算介绍

位运算符允许对整型数中指定的位进行求值和操作。 以下是官网的一个介绍。


	
			
					例子
					名称
					结果
			
	
	
			
					$a & $b
					And（按位与）
					将把 $a 和 $b 中都为 1 的位设为 1。
			
			
					$a | $b
					Or（按位或）
					将把 $a 和 $b 中任何一个为 1 的位设为 1。
			
			
					$a ^ $b
					Xor（按位异或）
					将把 $a 和 $b 中一个为 1 另一个为 0 的位设为 1。
			
			
					~ $a
					Not（按位取反）
					将 $a 中为 0 的位设为 1，反之亦然。
			
			
					$a « $b
					Shift left（左移）
					将 $a 中的位向左移动 $b 次（每一次移动都表示 “乘以 2”）。
			
			
					$a » $b
					Shift right（右移）
					将 $a 中的位向右移动 $b 次（每一次移动都表示 “除以 2”）。
			
			
					详情请点击这里了解。
					
					
			
	

平常开发需要用位运算吗？
位运算符都是针对整数的二进制数字形式而进行的。

我们都知道计算机中运算使用的是二进制，在我的电脑,整数有4个字节(byte),而1个字节有8位(bit)，一个整数有32位二进制来表示。


Git创建不继承内容的新分支
Sun, 26 Feb 2023 19:46:01 +0800
Git创建不继承内容的新分支方法
在 Git 中，想创建一个新的分支，并且不想要当前分支的任何内容（即希望新分支是完全干净的，不包含当前分支的修改或提交），可以按照以下步骤操作：
方法 1：基于远程默认分支（如 main/master）创建新分支
如果你希望新分支是基于远程仓库的默认分支（而不是当前分支），可以这样做：
```
# 1. 确保本地没有未提交的修改（否则会提示你提交或暂存）
git status
# 2. 拉取远程最新代码（确保本地默认分支是最新的）
git fetch origin

# 3. 基于远程默认分支（如 origin/main）创建新分支
git checkout -b 新分支名 origin/main

方法 2：基于某个提交或分支创建全新分支
如果你想基于某个特定的提交（而不是当前分支）创建新分支：
```
# 1. 先切换到目标分支或提交（例如切换到 main 分支）
git checkout main
# 2. 拉取最新代码（可选）
git pull origin main

# 3. 创建并切换到新分支
git checkout -b 新分支名

方法 3：强制创建孤立分支（完全无历史）
如果你想创建一个完全独立的新分支（不继承任何历史）：


在切换分支之前，确保你没有未提交的修改，否则 Git 可能会尝试携带这些修改到新分支：
git status

# 提交他们
git add .
git commit -m "暂存当前修改"

# 或者丢弃它们
git reset --hard # 强制丢弃所有未提交的修改


创建一个完全独立的新分支（不继承任何历史）


Git历史重置
Sun, 26 Feb 2023 00:00:00 +0000
Git历史重置
有时候需要克隆github的项目使用，自己进行修改需要提交到自己的代码仓库，但是会包含前仓库的大量提交历史，看起来不方便，就需要清理历史记录并重置为一个全新的提交
新项目（如git clone 的项目）
 1# 进入项目目录
 2cd template-repo-master
 3# 删除原有的.git目录（如果存在）初始化全新的Git仓库
 4rm -rf .git
 5git init
 6
 7git add .
 8git commit -m "Initial commit from template"
 9
10git remote add origin git@github.com:your-username/your-new-repo.git
11
12git push -u origin master --force
已经将代码推送到自己的远程仓库 清理历史记录并重置为一个全新的提交
 1# 1. 克隆你的远程仓库（可选）
 2git clone git@github.com:your-username/your-repo.git
 3cd your-repo
 4
 5# 2.创建孤立分支（全新的历史起点）
 6git checkout --orphan new-branch
 7
 8# 3. 添加所有文件到新分支
 9git add -A
10git commit -m "Initial commit (cleaned history)"
11
12#4. 删除旧的主分支
13git branch -D master # 或 main
14
15# 5. 重命名新分支为主分支
16git branch -m master # 或 main
17
18# 6. 强制推送到远程仓库
19git push -f origin master
20
21# 7. 更新远程仓库设置（如有必要）
22git branch --set-upstream-to=origin/master master
23
24# 检查提交历史应该只显示你的"Initial commit"
25git log --oneline



Git同时配置github和gitee
Sun, 26 Feb 2023 00:00:00 +0000
Git同时配置github和gitee
想要同时使用GitHub和Gitee，但是每次输入密码就会很麻烦。为此，本文将介绍 Git 同时配置 github和 gitee 的ssh key
1#查看git配置
2git config --global --list
3#没配置过的话先配置用户名和邮箱信息
4git config --global user.name “username”
5git config --global user.email “email”
6#默认没有.ssh目录，
7ssh-keygen -t rsa -C "xxxxxxx@xx.com"
8#在windows下会生成.ssh目录 [c盘/用户/用户名/.ssh]
1. 查看ssh文件
1cd ~/.ssh**  
2
3ls
2. 删除之前的.ssh
1 rm -rf id_rsa id_rsa.pub
3. 生成gitee和github 的 SSH Key
1ssh-keygen -t rsa -C "xxxxxxx@xx.com" -f "id_rsa_github"
2ssh-keygen -t rsa -C "xxxxxxx@xx.com" -f "id_rsa_gitee"
4. 查看SSH Key
1cat id_rsa_github.pub**
5. 拷贝 ssh-rsa 开头的 ssh key，然后到github上添加ssh key
6. 添加 config解决ssh冲突
 1vim config
 2
 3# 文件类容如下
 4# gitee
 5Host gitee.com
 6HostName gitee.com
 7PreferredAuthentications publickey
 8IdentityFile ~/.ssh/id_rsa_gitee
 9 
10# github
11Host github.com
12HostName github.com
13PreferredAuthentications publickey
14IdentityFile ~/.ssh/id_rsa_github
7. 测试是否配置成功
1ssh -T git@gitee.com 
2ssh -T git@github.com
3
4# 配置成功 正常会输出如下
5Hi leanku! You've successfully authenticated, but GitHub does not provide shell access.
8. 已经配置了 SSH 密钥，但在 git push 时仍然要求输入用户名和密码
检查远程 URL,如果显示 https://…，说明 Git 仍然在使用 HTTPS 方式。


MySQL 运维常用脚本
Fri, 03 Feb 2023 00:00:00 +0000
MySQL 运维常用脚本

1.导出整个数据库  
1
2#mysqldump -u 用户名 -p –default-character-set=latin1 数据库名 > 导出的文件名(数据库默认编码是latin1)   
3
4mysql dump -u wcnc -p smgp_apps_wcnc > wcnc.sql   
2.导出一个表  
1#mysqldump -u 用户名 -p 数据库名 表名> 导出的文件名 
2
3mysql dump -u wcnc -p smgp_apps_wcnc users> wcnc_users.sql
3.导出一个数据库结构  
1mysql dump -u wcnc -p -d –add-drop-table smgp_apps_wcnc >d:wcnc_db.sql
2
3#-d 没有数据 –add-drop-table 在每个create语句之前增加一个drop table
4.导入数据库  
 1#A:常用source 命令   
 2#进入mysql数据库控制台，   如
 3mysql -u root -p   
 4mysql>use databasename
 5#然后使用source命令，后面参数为脚本文件(如这里用到的.sql)
 6mysql>source wcnc_db.sql
 7#B:使用mysqldump命令
 8mysqldump -u username -p dbname < filename.sql
 9#C:使用mysql命令
10mysql -u username -p -D dbname < filename.sql
启动与退出  


Vim 常用命令
Wed, 01 Feb 2023 00:00:00 +0000
Vim介绍

Vim是一个类似于Vi的著名的功能强大、高度可定制的文本编辑器，在Vi的基础上改进和增加了很多特性。VIM是自由软件。Vim普遍被推崇为类Vi编辑器中最好的一个，事实上真正的劲敌来自Emacs的不同变体。1999 年Emacs被选为Linuxworld文本编辑分类的优胜者，Vim屈居第二。但在2000年2月Vim赢得了Slashdot Beanie的最佳开放源代码文本编辑器大奖，又将Emacs推至二线， 总的来看， Vim和Emacs在文本编辑方面都是非常优秀的。百度百科

使用
1vim a.php #
控制屏幕光标的移动，字符、字或行的删除，移动复制某区段，以其它任何模式按esc 即可进宪普通模式
i 在当前光标字符前插入 insert
a 在当前光标字符后插入 append
I 在当前行首插入 Insert
A 在当前行尾插入 Append
o 在下方开一新行，插入 open
O 在上方开一新行，插入 Open
r 替代字符，将当前字符替代为紧跟着输入的字符 replace
R 进入替代模式，将当前及之后的字符都替代为紧跟着输入的字符串，直到按 `` 返回 Normal 模式 Replace
gj 移动到屏幕折行后的下行
gk 移动到屏幕折行后的上行

命令模式是在普通模式下按 : 进入，用于搜索、保存退出等操作。
:w 保存
:w file 另存为文件
:q 退出
:q! 放弃修改退出
:wq 保存修改并退出

移动命令
Vim 的各种移动命令主要是在标准模式下
h 光标左移
j 光标下移
k 光标上移
l 光标右移
0 跳到行首，可以理解为无穷大的


10分钟带你了解什么是二进制
Tue, 31 Jan 2023 20:46:01 +0800
二进制

二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”。
百度百科


世界上有10种人：一种是懂得二进制的，另一种是不懂二进制的

上面这是流传在程序员之间很久的一个冷笑话。
是不是get不到梗的笑点？
没有关系，看完本文，你再来看这句话就会会心一笑。
回到过去
让我们假设你回到了初中，这时候你情窦初开。喜欢上了临街的小哥哥(小姐姐)，你们俩家的窗户面对面。放寒假的时候，你们约好了某天晚上八点偷偷溜出来约会。但是不能让父母知道，所以你们不能通过打电话方式来通知对方，今晚自己是否能顺利溜出来。为了不让对方白等，你们不得不约定一种新的通信方式。
这种新的通信方式要满足：
安静–不能让父母听到，能悄无声息自然是最好了
易懂–对方看到后能立马知道你要表达的信息
因为住的很近，可以从窗户相互看到对方家里，聪明的你立马想到可以用屋子里吊灯的灯光来进行通信。
你们约定到了八点钟
如果我屋子里的灯亮着，代表我可以顺利溜出去
如果我屋子里的灯不亮，代表我无法顺利溜出去
现在你们就可以用屋子里的灯开关，来表达两种状态
开：能出来
关：不能出来
你们可以悄无声息给对方传达信息，这太完美了！
新的问题
不过过了一段时间你们发现了新问题，有时候，8点钟恰好有事情，可能要推迟半小时才能溜出来。有时候，8点钟事情比较多，可能要推迟1小时才能出来。
现在你们有四种信息要传递

今晚8点钟准时出来
今晚不能出来
今晚8点30能出来
今晚9点能出来

但是一盏灯的开关只能表示两种状态，怎么办才好呢？
聪明的你立马想到，可以再加一盏灯啊！你把书桌上的台灯放到窗前
并且更新了之前的通信方式

台灯关着，吊灯关着–今晚没戏，出不来了
台灯关着，吊灯开着–今晚8点，不见不散
台灯开着，吊灯关着–推迟半小时，今晚八点半才能溜出来
台灯开着，吊灯开着–推迟1小时，今晚9点才能溜出来

哇哦，再一次用自己的聪明才智解决了这个问题。
现在你用两盏灯，来表达四种状态。
一些思考
让我们用符号来重新表述下

我们用数字0表示灯灭

数字1表示灯亮
一盏灯的情况

0 ==> 今晚八点准时出来
1 ==> 今晚八点不能出来

两盏灯的情况

0 0 ==> 今晚没戏，出不来了
0 1 ==> 今晚8点，不见不散
1 0 ==> 推迟半小时，今晚八点半才能溜出来
1 1 ==> 推迟1小时，今晚9点才能溜出来

让我们再来简化一下箭头右边，我们用数字0,1,2,3 分别来代表今晚约会的4种状态

0: 今晚没戏，出不来了
1: 今晚8点，不见不散
2: 推迟半小时，今晚八点半才能溜出来
3: 推迟1小时，今晚9点才能溜出来

现在我们可以把两边都用数字来简化了


PHP标准输入与输出
Wed, 11 Jan 2023 00:00:00 +0000
PHP标准输入与输出
一、PHP STDIN、STDOUT、STDERR简介:
STDIN、STDOUT、STDERR命令输入输出流，用于向控制台(linux shell终端、windows cmd终端)输入、输出内容，它们默认是已经打开的，可以直接对他们进行读写操作，它们只能在CLI(command-line interface，命令行界面)模式中使用，在Http模式时，它们是未定义的。
而他们的打开副本php://stdin、php://stdout、php://stderr 也无法输出内容到http浏览器，经测试：写入php://stderr的内容将会输入到默认站点的错误日志中，其它两种无任何效果。
STDIN/STDOUT/STDERR简介：原始流流打开副本描述STDINphp://stdin标准输入(standard input)，只读，用于从控制台输入内容；
STDOUTphp://stdout标准输出(standard output)，只写，用于向控制台输出正常信息；
STDERRphp://stderr错误输出(standard error)，只写，用于向控制台输出错误信息；
官方推荐使用常量 STDIN、 STDOUT 和 STDERR 来代替它们手动打开的副本封装器php://stdin、 php://stdout 和 php://stderr。
二、PHP STDIN用法：
PHP语言中"STDIN"用于从控制台读取内容，遇到此常量或者通过fopen()函数打开php://stdin脚本将会等待用户输入内容，直到用户按下回车键提交。
新建文件demo.php
 1<?php
 2
 3echo "请输入内容:";
 4$input = fgets(STDIN);
 5echo sprintf("输入的内容为: %s\n", $input);
 6
 7$handle = fopen('php://stdin', 'r');
 8echo "请输入: ";
 9$stdin = fread($handle, 10); //最多读取10个字符
10echo sprintf("输入为: %s\n", $stdin);
11fclose($handle);
12
13//php demo.php 运行代码，键盘输入123，输出结果如下
14
15//请输入内容:123
16//输入的内容为: 123
17
18//请输入: 456
19//输入为: 456


三、PHP STDOUT用法：
PHP语言中STDOUT用于向控制台输出标准信息；向此常量、或者向fopen()函数打开的php://stdout写入的内容将直接输出到控制台的标准输出；标准输出的内容可以用过">“或者"1>“重定向到指定地方，比如文件。
 1<?php
 2
 3fwrite(STDOUT, "STDOUT写入的正常输出；\n");
 4
 5$stdout = fopen("php://stdout", "w");
 6
 7fwrite($stdout, "php://stdout写入的正常输出；\n");
 8
 9fclose($stdout);
10
11// php demo.php >stdout.txt
12//stdout.txt文件类容如下
13//STDOUT写入的正常输出；
14//php://stdout写入的正常输出；
四、PHP STDERR用法：
PHP语言中"STDERR"用于向控制台输出错误信息；向常量、或者向fopen()函数打开的"php://stderr"写入的内容将直接输出到控制台的错误输出；错误输出的内容可以用过"2>“重定向到指定地方，比如文件；也可以使用"2>&1"将错误输出定向到标准输出，与标准输出合并。


服务端基础知识
Sat, 17 Dec 2022 21:46:01 +0800
OSI七层模型

	
			
					层
					作用
					注
			
	
	
			
					应用层
					为程序提供服务
					规范数据格式
			
			
					表示层
					数据格式转换，加密
					翻译
			
			
					会话层
					建立和管理会话
					没有指定协议
			
			
					传输层
					管理端到端之间的连接
					TCP协议、UDP协议
			
			
					网络层
					IP地址和路由
					IP地址、ARP协议
			
			
					数据链路层
					链路管理
					MAC地址、帧
			
			
					物理层
					提供传输环境
					网线、WiFi
			
	



TCP/IP四层模型

	
			
					层
					包含
			
	
	
			
					应用层
					应用层、表示层、会话层
			
			
					传输层
					传输层
			
			
					网络层
					网络层
			
			
					数据链路层
					数据链路层、物理层
			
			
					

					
			
	

ARP协议

地址解析协议，即ARP（Address Resolution Protocol），是根据IP地址获取物理地址的一个TCP/IP协议。主机发送信息时将包含目标IP地址的ARP请求广播到局域网络上的所有主机，并接收返回消息，以此确定目标的物理地址；收到返回消息后将该IP地址和物理地址存入本机ARP缓存中并保留一定时间，下次请求时直接查询ARP缓存以节约资源。地址解析协议是建立在网络中各个主机互相信任的基础上的，局域网络上的主机可以自主发送ARP应答消息，其他主机收到应答报文时不会检测该报文的真实性就会将其记入本机ARP缓存；由此攻击者就可以向某一主机发送伪ARP应答报文，使其发送的信息无法到达预期的主机或到达错误的主机，这就构成了一个ARP欺骗。ARP命令可用于查询本机ARP缓存中IP地址和MAC地址的对应关系、添加或删除静态对应关系等。相关协议有RARP、代理ARP。NDP用于在IPv6中代替地址解析协议。



TCP/UDP协议

TCP和UDP协议是TCP/IP协议的核心。 TCP 传输协议：TCP 协议是一TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；而UDP则不为IP提供可靠性、流控或差错恢复功能。一般来说，TCP对应的是可靠性要求高的应用，而UDP对应的则是可靠性要求低、传输经济的应用



TCP三次握手

所谓的“三次握手”：为了对每次发送的数据量进行跟踪与协商，确保数据段的发送和接收同步，根据所接收到的数据量而确认数据发送、接收完毕后何时撤消联系，并建立虚连接。
为了提供可靠的传送，TCP在发送新的数据之前，以特定的顺序将数据包的序号，并需要这些包传送给目标机之后的确认消息。TCP总是用来发送大批量的数据。当应用程序在收到数据后要做出确认时也要用到TCP。

过程
第一次握手：建立连接时，客户端发送syn包（seq=j）到服务器，并进入SYN_SENT状态，等待服务器确认；SYN：同步序列编号（Synchronize Sequence Numbers）。

第二次握手：服务器收到syn包，必须确认客户端的SYN（ack=j+1），同时自己也发送一个SYN包（seq=k），即SYN+ACK包，此时服务器进入SYN_RECV状态。

第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。

完成三次握手，客户端与服务器开始传送数据（可使用抓包工具tcpdump 命令 tcpdump -nn -i eth0 prot 80）



TCP四次挥手

对于一个已经建立的连接，TCP使用改进的四次挥手来释放连接（使用一个带有FIN附加标记的报文段）。TCP关闭连接的步骤如下： 

第一步，当主机A的应用程序通知TCP数据已经发送完毕时，TCP向主机B发送一个带有FIN附加标记的报文段（FIN表示英文finish）。 

第二步，主机B收到这个FIN报文段之后，并不立即用FIN报文段回复主机A，而是先向主机A发送一个确认序号ACK，同时通知自己相应的应用程序：对方要求关闭连接（先发送ACK的目的是为了防止在这段时间内，对方重传FIN报文段）。

第三步，主机B的应用程序告诉TCP：我要彻底的关闭连接，TCP向主机A送一个FIN报文段。

第四步，主机A收到这个FIN报文段后，向主机B发送一个ACK表示连接彻底释放。



# Carbon（nesbot/carbon）-- PHP 日期时间利器化
Tue, 15 Nov 2022 00:00:00 +0000
Carbon（nesbot/carbon）– PHP 日期时间利器化
一、Carbon介绍
Carbon 是 PHP 中最流行的 日期时间处理库，基于 PHP 原生的 DateTime 类封装，提供 链式操作、易读 API、时区支持 等强大功能。
特点：


链式调用，语义化强


支持日期时间加减、比较、格式化


支持中文等多语言友好显示


可与 Laravel、Hyperf 等框架无缝集成


官方文档：https://carbon.nesbot.com/docs/
安装：composer require nesbot/carbon
二、基本使用
2.1 获取当前时间
1$now = Carbon::now(); // 当前时间，默认系统时区
2echo $now; // 2023-09-28 15:30:12
3
4// 指定时区：
5$nowShanghai = Carbon::now('Asia/Shanghai');
2.2 日期创建
1$dt1 = Carbon::create(2023, 9, 28, 15, 30, 0); // 年, 月, 日, 时, 分, 秒
2$dt2 = Carbon::parse('2023-12-31 23:59:59');
3$dt3 = Carbon::today(); // 当天 0:00:00
4$dt4 = Carbon::tomorrow(); // 明天 0:00:00
5$dt5 = Carbon::yesterday(); // 昨天 0:00:00
2.3 日期格式化
1$now = Carbon::now();
2echo $now->toDateString(); // 2023-09-28
3echo $now->toTimeString(); // 15:30:12
4echo $now->toDateTimeString();// 2023-09-28 15:30:12
5echo $now->format('Y-m-d H:i'); // 自定义格式
2.4 日期加减操作
1$dt = Carbon::now();
2
3echo $dt->addDays(3); // 当前时间 +3天
4echo $dt->subHours(5); // 当前时间 -5小时
5echo $dt->addMonthsNoOverflow(1); // 避免月份溢出
2.5 日期比较
1$dt1 = Carbon::parse('2023-09-28');
2$dt2 = Carbon::parse('2023-10-01');
3
4if ($dt1->lt($dt2)) {
5 echo "dt1 小于 dt2";
6}
7
8echo $dt1->diffInDays($dt2); // 返回天数差
9echo $dt1->diffForHumans($dt2); // 语义化描述: "3 days before"
2.6 时区转换
1$dt = Carbon::now('UTC');
2$dtShanghai = $dt->copy()->setTimezone('Asia/Shanghai');
3echo $dtShanghai;
2.7 本地化输出
1Carbon::setLocale('zh'); // 设置中文
2
3$dt1 = Carbon::now();
4$dt2 = Carbon::parse('2025-10-01');
5
6echo $dt1->diffForHumans($dt2); // 输出: 3 天前 / 3 天后
2.8 链式操作
1$dt = Carbon::now()->addDays(5)->subHours(3)->format('Y-m-d H:i:s');
2echo $dt;
三、Carbon 高级使用技巧合集
3.1 时间区间判断
判断某个时间是否在区间内
1use Carbon\Carbon;
2
3$start = Carbon::parse('2023-09-01');
4$end = Carbon::parse('2023-09-30');
5$check = Carbon::parse('2023-09-15');
6
7if ($check->between($start, $end)) {
8 echo "时间在区间内";
9}
between($start, $end, $equal = true)


composer
Tue, 15 Nov 2022 00:00:00 +0000
composer

Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。

一、Composer 基础概念
Composer 是 PHP 的依赖管理工具，它通过定义项目所需的依赖包及版本，自动安装和管理这些依赖，确保项目在不同环境下都能稳定运行。其核心概念主要包括以下几个方面：
1.1 包（Package）
包是 Composer 管理的基本单元，它可以是一个 PHP 类库、框架组件，或是某个功能模块。比如用于 HTTP 请求处理的 Guzzle，以及知名的 PHP 框架 Laravel、Symfony 等，都可以看作是 Composer 包。这些包被发布在 Packagist 等包仓库中，方便开发者获取使用。
1.2 composer.json 与 composer.lock
composer.json是项目的依赖配置文件，开发者在其中定义项目所需的依赖包及其版本约束。例如，若要在项目中使用 PHPUnit 进行单元测试，可在composer.json添加 “phpunit/phpunit”: “^9.5” ，表示使用 PHPUnit 9.5 及以上版本，但低于 10.0 版本。
composer.lock则是锁定依赖包具体版本的文件。当执行composer install或composer update时，Composer 会将实际安装的依赖包版本记录在composer.lock中。下次在其他环境安装依赖时，该文件能确保安装的依赖包版本与之前完全一致，避免因版本差异导致项目出现兼容性问题 。
1.3 包仓库（Repository）
包仓库是存储 Composer 包的地方，默认情况下，Composer 使用 Packagist 作为官方包仓库，它汇聚了海量的 PHP 开源包。除了 Packagist，开发者还可以搭建私有包仓库，用于管理内部开发的私有包，或者使用其他公共仓库，拓展包的来源。
packagist仓库地址
二、安装composer
#下载安装脚本 － composer-setup.php － 到当前目录。
php -r "copy('https://install.phpcomposer.com/installer', 'composer-setup.php');"

#执行安装过程。
php composer-setup.php

#删除安装脚本。
php -r "unlink('composer-setup.php');"

#全局安装
sudo mv composer.phar /usr/local/bin/composer

#启用本镜像服务
composer config -g repo.packagist composer https://packagist.phpcomposer.com
三、 Composer常用命令与操作
3.1 初始化项目
在新建 PHP 项目时，首先需要初始化 Composer。在项目根目录下打开命令行，执行composer init命令，此时会进入交互式配置界面，系统会依次询问项目名称、描述、作者、许可证等信息。完成信息填写后，会在项目根目录生成composer.json文件。如果不想进行交互式配置，也可以使用composer init -n命令，采用默认配置快速生成composer.json文件。


Composer 自动加载原理
Tue, 15 Nov 2022 00:00:00 +0000
Composer 自动加载原理

Composer 的自动加载本质是 动态加载类文件，它实现了“按需加载”的机制，避免了手动 require 每个类文件。

一、Composer 自动加载的核心
PHP 提供了 spl_autoload_register() 函数：
1spl_autoload_register(function ($class) {
2 require 'src/' . str_replace('\\', '/', $class) . '.php';
3});

当你第一次使用一个类时，PHP 会调用这个函数。
$class 是你使用的类全名（包括命名空间）。
函数里通过规则找到对应文件并 require。

Composer 自动加载，就是在这个基础上做了 规范化管理。
二、Composer 生成的自动加载文件
安装依赖后，Composer 会生成：
1vendor/autoload.php
2vendor/composer/autoload_*.php

vendor/autoload.php：入口文件，只需 require 一次。
vendor/composer/autoload_psr4.php：记录 PSR-4 命名空间 → 文件路径映射。
vendor/composer/autoload_classmap.php：记录 类名 → 文件路径，用于 classmap 加速加载。
vendor/composer/autoload_files.php：记录需要立即加载的文件（如全局函数库）。

vendor/autoload.php 的核心逻辑：
1require __DIR__ . '/composer/autoload_real.php';
2return ComposerAutoloaderInit::getLoader();
ComposerAutoloaderInit::getLoader() 会：

初始化一个 ClassLoader 实例。
根据配置注册 PSR-4、PSR-0、classmap、files 自动加载函数到 PHP。
调用 spl_autoload_register() 注册这些函数。

三、PSR-4 自动加载机制
PSR-4 是 Composer 默认的推荐机制。
假设 composer.json 配置：


Guzzle
Tue, 15 Nov 2022 00:00:00 +0000
Guzzle HTTP 客户端全解析及 PHP 使用与优化
一、介绍
Guzzle 是 PHP 世界中最流行的 HTTP 客户端库之一，用于发送 HTTP/HTTPS 请求并处理响应。
它支持：


同步和异步请求


HTTP/2


中间件机制（类似 Laravel / Hyperf 的管道）


并发请求


请求重试、超时、连接池


Guzzle 常被用于调用第三方 API、微服务接口或爬取网页数据。
官方文档：https://docs.guzzlephp.org
二 、安装
1composer require guzzlehttp/guzzle
三、基本使用
3.1 同步 GET 请求
 1use GuzzleHttp\Client;
 2
 3$client = new Client([
 4 'base_uri' => 'https://api.example.com',
 5 'timeout' => 5.0, // 超时时间
 6]);
 7
 8$response = $client->get('/users/1');
 9
10echo $response->getStatusCode(); // 200
11echo $response->getBody(); // JSON 或 HTML
3.2 POST 请求与 JSON 数据
1$response = $client->post('/users', [
2 'json' => [
3 'name' => 'John',
4 'email' => 'john@example.com',
5 ],
6]);
7
8$data = json_decode($response->getBody(), true);
9print_r($data);
3.3 添加请求头
1$response = $client->get('/users', [
2 'headers' => [
3 'Authorization' => 'Bearer ' . $token,
4 'Accept' => 'application/json',
5 ],
6]);
四、异步请求与并发
Guzzle 支持异步请求，通过 Promises 机制提高并发性能。


Netlify部署静态网站
Sat, 22 Oct 2022 00:00:00 +0000
关于Netlify
在它的主页上可以看到它的宣传语：

用最快的方式构建最快的网站。

官方文档
为什么选择Netlify

内置 CI/CD 支持自动构建拉取代码仓库，每次提交的自动构建并发布预览


能够托管服务免费 CDN


能够绑定自定义域名


能够启用免费的TLS证书启用HTTPS


提供 Webhooks 和 API


通过内置应用程序添加动态功能

部署一个静态网站就非常简单，此处以GitHub仓库为例


静态网站push到GitHub仓库


进入netlify


登录 直接使用GitHub账号，授权


创建网站 点击New site from Git





选择仓库




选择分支（Branch to deploy）



4.3 打包命令 （Build command）诸如 npm run build，gulp build 之类；如果本身已是静态文件，不需打包编译，这一栏则不填


4.4 打包后目录 （Publish directory）诸如 public,dist，_site 之类；如果本身已是静态文件，这一栏则不填


4.5 deploy site



设置域名 netlify会随机生成了一个netlify下的域名，我们可以更改其前缀，并绑定到我们自己的域名下：
Site settings->Change site name 更换默认域名
Domain settings->Add custom domain添加域名，然后到域名服务商网站绑定的域名下添加一条CNAME解析，解析的主机记录即对应的netlify域名值（即 xx.netlify.com）

关于.netlify.toml自动部署参阅文档 https://docs.netlify.com/configure-builds/file-based-configuration/
更多操作后续更新。。。


Git版本升级
Fri, 21 Oct 2022 00:00:00 +0000
使用 Brew 对Mac系统Git进行版本升级
 1#安装最新的Git
 2➜ ~ brew install git
 3#改变默认Git指向
 4➜ ~ which git
 5#/usr/bin/git
 6➜ ~ git --version
 7#git version 2.24.1 (Apple Git-126)
 8➜ ~ brew link git --overwrite
 9#新开终端查看版本
10➜ ~ git version
11#git version 2.38.1
可以看到，我们的 git 版本已经升级到最新版了


Hello Hugo
Fri, 21 Oct 2022 00:00:00 +0000
Hugo 是用 Go 语言写的，支持多个平台 包括 Windows, Linux, FreeBSD 和 OS X (Darwin) for x64, i386 和 ARM architectures.
官方文档
为什么选择hugo

通过 Hugo 你可以快速搭建你的静态网站，比如博客系统、文档介绍、公司主页、产品介绍等等。相对于其他静态网站生成器来说，Hugo 具备如下特点：


极快的页面编译生成速度。（ ~1 ms 每页面）


完全跨平台支持，可以运行在 Mac OS X, Linux, Windows, 以及更多!


安装方便 Installation


本地调试 Usage 时通过 LiveReload 自动即时刷新页面。


完全的皮肤支持。


可以部署在任何的支持 HTTP 的服务器上。

一.安装
下载最新的 release 版本 Hugo Releases， Windows, Linux, FreeBSD 和 OS X (Darwin) for x64, i386 和 ARM architectures.
Windows安装时需要加入环境变量
Mac就比较方便直接执行：brew install hugo
安装成功之后的操作如下
 1#查看版本
 2hugo version
 3#创建站点 如在当前目录创建名为blog的站点
 4hugo new site blog
 5cd blog
 6#目录如下
 7 ▸ archetypes/
 8 ▸ doc/content/
 9 ▸ data/
10 ▸ layouts/
11 ▸ static/
12 config.toml
二.创建文章
1#创建文章
2hugo new post/first.md
3
4#新创建的文件会在 content/post/first.md
三.安装主题
找到心仪的主题，以PaperMod为例


Links
Mon, 01 Jan 0001 00:00:00 +0000
一些值得关注的站点与博客：


关于
Mon, 01 Jan 0001 00:00:00 +0000
Leanku，不知名开发者，苟且于互联网边缘。
这个博客始建于 2019 年，记录我在设计、代码与生活三个方向上的思考。2021 年初，我把博客从 WordPress 迁移到了 Hugo，并将 Period 主题移植成了你现在看到的这个 Hugo 主题。
旧主题Blog入口
关于这个主题
本站使用的主题是 Period Hugo Theme，参考 Compete Themes 的 Period WordPress 主题。
你可以通过本站的联系页面给我写信，或者直接在任意文章下留言。
一些小作品

闻言录
即玩微游
开发者导航
leanku/php-msf-docker
leanku/hugo-period
更多…

联系我

邮箱：support@leanku.com
留言：/contact/



 如果这里的内容对你有所帮助，欢迎请我喝杯咖啡。


归档
Mon, 01 Jan 0001 00:00:00 +0000
全部文章按月归档。


联系
Mon, 01 Jan 0001 00:00:00 +0000
欢迎给我写信！你的反馈、建议和批评对我都很有价值。
可以直接发邮件到 support@leanku.com，或者填写下面的表单（由 Formspree 提供服务）：





 
 联系表单暂未启用，你可以在评论留言或者通过邮件与我交流。
 



搜索
Mon, 01 Jan 0001 00:00:00 +0000
在下方输入关键词搜索全站文章。


赞助
Mon, 01 Jan 0001 00:00:00 +0000


感谢支持
渐入佳境，便是对彼此最好的祝福。

Leanku 的博客

Markdown编辑工具推荐

1. Zettlr：专为学术研究与卡片盒笔记而生

2. Obsidian：基于本地文件的网状知识库

3. Typora：极致无缝的“所见即所得”标杆

OpenClaw +QQ机器人

OpenClaw +QQ机器人助手

1. 搭建 OpenClaw

2. 接入 QQ

1. 申请 QQ 机器人

2. 给 OpenClaw 绑定 QQ 机器人

3. 访问Openclaw 的webUI页面

LeanNav | 精选开发者导航

LeanNav | 精选开发者导航。nav.leanku.com

闻言录｜字句成录，回响为闻。

闻言录｜字句成录，回响为闻。

从零到一搭建个人AI知识库

从零到一搭建个人AI知识库

一、理解核心概念：什么是RAG？

阶段一：索引构建（离线） ——把文档“搬进”知识库

阶段二：检索生成（在线） ——回答用户问题

二、选择工具链

2.1 大模型（AI的大脑）

2.2 向量数据库（知识的仓库）

2.3 一站式平台

三、动手搭建：两种路径

路径一：零代码/低代码

步骤1：安装Ollama并下载模型

步骤2：安装AnythingLLM

RAGFlow

RAGFlow

一、介绍

二、搭建一个智能问答系统

2.1 部署RAGFlow

向量数据库-Qdrant使用

向量数据库Qdrant使用

一、什么是向量数据库？

常见向量数据库

二、Qdrant介绍

2.1 什么是 Qdrant？

2.2 Qdrant 核心架构

2.3 Qdrant 检索原理

RAG

RAG技术 （检索增强生成）

引言：当大模型遇上知识库

一、什么是 RAG？

1.1 官方定义

1.2 为什么要用 RAG？

1.3 RAG 的三步工作流程

二、RAG 的核心技术组件

模型微调

模型微调

一、模型微调到底是什么

二、 核心技术：LoRA——四两拨千斤的微调利器

三、 具体如何实现

路径一：使用云端服务（最简单、快速上手）

路径二：使用本地开源工具（更灵活、适合动手实践）

1. 安装Ollama

2. 准备微调数据

Embedding：理解语义的基础

Embedding：理解语义的基础

引言：当计算机学会了"理解"含义

一、什么是Embedding？

1.1 从一个思想实验开始

1.2 正式定义

1.3 直观理解：语义空间地图

AI Agent

AI Agent：从"回答问题"到"主动行动"的智能体

引言：当AI从"思考者"变成"行动派"

一、什么是AI Agent？

1.1 核心定义

1.2 Agent vs 传统程序 vs LLM

1.3 一个生动的例子

理解大模型工作原理

理解大模型工作原理

引言：当计算机学会了"说话"

一、大模型是什么？

1.1 从一个形象的比喻开始

1.2 从数字到智能：三个关键洞察

洞察一：词语可以用数字表示

RAG技术（检索增强生成）

二、核心技术：LoRA——四两拨千斤的微调利器

三、具体如何实现