youki的笔记

初识 Kubernetes：从 Service 与 CoreDNS 理解服务发现

Wed, 27 May 2026 00:00:00 GMT

最近在 K8s 集群里部署多服务时，最让人意外的是服务之间居然可以不写 IP、不改代码地互相找到对方。这篇笔记拆解这套机制是怎么实现的：Service 如何当稳定的"门牌号"、CoreDNS 怎么当集群内的"黄页"、以及这套设计与单机 localhost 部署的本质区别。

1. 先理清 K8s 的几个基本对象

讲服务发现之前，先把几个会反复出现的对象过一遍，避免后面混在一起。

对象	一句话解释
Pod	K8s 调度的最小单位，里面跑着一个或多个容器。每个 Pod 有自己的 IP，但这个 IP 不稳定——重启就换。
Deployment	用来声明"我要跑 N 个相同的 Pod"，K8s 会自动维护这个数量（挂了会重启）。
Service	一组 Pod 的稳定访问入口。给它一个名字 + ClusterIP，后面所有 Pod 都通过这个名字访问它。
NodePort / Ingress	把 Service 暴露到集群外部的两种方式（前者用节点端口，后者用 HTTP 路由）。

记住一句话：Pod 是临时的，Service 是稳定的。 后面所有机制都围绕这个差异展开。

2. Service：一个虚拟的、稳定的"门牌号"

创建 Service 时，Kubernetes 会在集群内部为它分配一个固定的虚拟 IP（ClusterIP）。这个 IP 永远不会变——只要 Service 存在，它就在那里。

假设后端被部署成 3 份 Pod：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  replicas: 3   # 3 个相同的 Pod
  template:
    spec:
      containers:
        - name: backend
          image: my-backend:1.0

每个 Pod 启动后会被分到自己的随机 IP，比如 10.244.1.5、10.244.2.3、10.244.3.8。如果前端直接写这些 IP，任何一个 Pod 重启，IP 就变了，前端就找不到了。

解决办法是再创建一个 Service：

apiVersion: v1
kind: Service
metadata:
  name: backend
spec:
  selector:
    app: backend         # 选中上面那 3 个 Pod
  ports:
    - port: 80
      targetPort: 8080

K8s 会做两件事：

给这个 Service 分一个固定 ClusterIP（比如 10.96.100.1）。
在背后维护一个负载均衡器，把发往 10.96.100.1:80 的请求，均匀转发到那 3 个 Pod 上。

于是前端只需要记住 backend:80（或者 10.96.100.1:80）这一个地址，就能访问到后端的任意副本。后端 Pod 增减、重启、IP 变化，前端完全不感知。

3. CoreDNS：一个内置的"黄页"

让前端去记 10.96.100.1 这种纯数字地址不现实。Kubernetes 内建了一个 DNS 服务（CoreDNS），相当于集群内部的电话本：

创建一个叫 backend 的 Service 后，CoreDNS 会自动注册一条记录：backend → 10.96.100.1。
前端 Pod 里的应用发起 http://backend:80 请求时，容器里的 DNS 解析器会自动把 backend 翻译成 10.96.100.1，流量就精准抵达了后端的 Service。

前端 Pod 里的应用：GET http://backend:80/api
   ↓ DNS 解析
CoreDNS：backend → 10.96.100.1
   ↓ 流量转发
backend Service (10.96.100.1) → 负载均衡到某个后端 Pod

这就是"服务发现"的本质：调用方只需要知道服务名，不需要知道它有几个副本、IP 是什么、跑在哪台机器上。

4. 一个完整的调用链路

假设集群里有 3 个服务：数据库、后端、前端。完整通信过程是这样的：

# 1. 数据库
apiVersion: v1
kind: Service
metadata:
  name: db
spec:
  selector:
    app: mysql
  ports:
    - port: 3306

---
# 2. 后端（3 副本）
apiVersion: v1
kind: Service
metadata:
  name: backend
spec:
  selector:
    app: backend
  ports:
    - port: 80
      targetPort: 8080

---
# 3. 前端（NodePort 暴露给外部）
apiVersion: v1
kind: Service
metadata:
  name: frontend
spec:
  type: NodePort
  selector:
    app: frontend
  ports:
    - port: 80
      nodePort: 30080

后端代码里，数据库连接地址直接写成 db:3306，不用关心 MySQL 的 Pod IP：

# 后端代码示例
import mysql.connector
conn = mysql.connector.connect(
    host="db",       # 直接用 Service 名
    port=3306,
    user="app",
    password="xxx",
    database="app_db"
)

前端代码里，API 请求地址直接写成 backend:80，也不用关心后端有几个副本：

// 前端代码示例
fetch("http://backend:80/api/users")
  .then(res => res.json())
  .then(data => console.log(data));

用户从浏览器访问 http://Master节点IP:30080 时，完整的链路是：

用户浏览器
  ↓ http://MasterIP:30080
前端 Service (NodePort)
  ↓ 负载均衡到某个前端 Pod
前端 Pod 发起 GET http://backend:80/api
  ↓ CoreDNS 解析 backend → 10.96.100.1
后端 Service
  ↓ 负载均衡到某个后端 Pod
后端 Pod 连接 mysql -h db
  ↓ CoreDNS 解析 db → 10.96.x.x
数据库 Service
  ↓ 连上 MySQL Pod

整个过程中，没有一个地方出现了具体的 Pod IP 或节点 IP。 服务之间完全通过 Service 名称通信，K8s 自动处理负载均衡、高可用和故障恢复。

5. 和单机 `localhost` 部署的本质区别

单机上跑多服务时，连接地址通常是这样写的：

# 单机部署：写死 localhost
conn = mysql.connector.connect(
    host="localhost",  # 必须是本机
    port=3306,
    ...
)

要把后端拆到另一台机器上，要改的东西很多：IP 地址、端口、可能还有防火墙、配置中心……

维度	单机 `localhost` 方式	Kubernetes Service 方式
服务地址	固定写死 IP/端口	通过虚拟 IP + DNS 动态发现
扩展性	无法横向扩展（端口冲突）	随时增减副本，前端无感知
故障恢复	进程挂了就断了	副本自动重新调度，Service 自动转发到健康实例
部署灵活性	所有服务绑死在同一台机器	服务可以分布在集群的任何节点上
代码改动	迁移机器要改 IP/配置	一行不用改，Service 名不变即可

用一句话总结这个差异：

单机部署是"我告诉你地址"，Kubernetes 是"告诉我你叫什么，我帮你找到地址"。

后者让服务之间的通信变得松耦合、高可用，也更符合微服务架构的理念。

6. 写给自己的小结

这次在集群里做多服务部署实验，最关键的认知升级不是"我会写 yaml 了"，而是理解了"为什么 Pod IP 不重要"。

只要 Service 还在、名字没变，Pod 怎么重建、IP 怎么换、节点怎么调度，对调用方来说都是透明的。这种"调用方不关心被调用方物理位置"的设计，是分布式系统能横向扩展的基石。

K8s 把这套机制内化到了平台层——调用方一行代码不用改，平台就把寻址、负载均衡、故障恢复全做了。这在单台服务器上根本无法做到：单机部署时，进程地址是写死的、端口是冲突的、机器是绑死的，这套"靠名字找服务"的能力在单台服务器上根本无从发挥。

CLI Agent 实践指南：从 Claude Code 到通用方法论

Sat, 25 Apr 2026 00:00:00 GMT

这一两年里 CLI Agent 编程助手换了好几轮——从 Claude Code 到Codex ，中间还试过 Copilot CLI——但用久之后发现，三家的"骨架"几乎一样：plan 模式、文件注入、shell、压缩、恢复、回退、模型切换、权限管控。基本是通用的，差异只在命令名。

这篇以 Claude Code 为主线，对照 Codex CLI 和 GitHub Copilot CLI，把用得上的方法整理成 5 节：Plan 模式、命令、上下文管理、安全权限、实践经验。读完之后应该能在任何一个 CLI Agent 上快速上手。

0. 三家命令速查

先把骨架放在一起。下面的表格在三家之间通用，命令名差异不大。

能力	Claude Code	Codex CLI	Copilot CLI
进入 Plan 模式	`Shift+Tab` → `plan`	`Shift+Tab` → `Read-only`（Approval mode）	`Shift+Tab` 或 `/plan <描述>`
外置编辑器写计划	`Ctrl+G`	`Ctrl+G`（`$EDITOR`/`$VISUAL`）	`Ctrl+Y`（Markdown 编辑器）
注入文件	`@文件路径`	`@` + `Tab` 模糊搜索	`@路径` 或 `@图片.png`
会话内跑 shell	`!命令` + `Ctrl+B` 后台	`!命令`（受 Approval mode 约束）	通过 `shell(...)` 权限调用
清空上下文	`/clear`	`/clear`	`/clear` 或 `/new`
侧边问（不污染主历史）	`/btw`	—	—
摘要压缩	`/compact [focus...]`	API 层自动	`/compact`（手动）/ 默认自动
恢复会话	`/resume`、`claude -c`、`claude -r`	`codex resume` / `codex resume --last` / `codex resume <id>` / `codex exec resume`	`/session`
回退 checkpoint	`/rewind` + `Esc+Esc`	`Esc`×2 编辑上一条消息（=fork 入口）	`/session checkpoints` + `双 Esc`
切换模型	`/model` + `Alt+P` + `--effort`	`/model`	`/model`（含 Auto / Opus 4.5 / Sonnet 4.5 / GPT-5.2 Codex）
看上下文用量	`/statusline` 自定义	`/status`	`/context` + `/session files`
权限管理	`/permissions` + `settings.json`	`/permissions` 切 Approval mode + `config.toml`	`--allow-tool/--deny-tool/--available-tools`
跳过所有权限	`--dangerously-skip-permissions`	`--yolo`	`--yolo` / `--allow-all`
多仓库/多目录	`--add-dir`	`codex --cd` + `--add-dir`	`/add-dir` + `/list-dirs`
并行子代理	`claude agents` + agent teams	`codex agents` + `/fork`	`/fleet` + `/task`
会话存档位置	`~/.claude/projects/<project>/`	`~/.codex/sessions/`	`~/.copilot/session-state/{id}/`

后面所有方法论都围绕这张表展开。

1. Plan 模式：所有工作的起点

1.1 决策树：能用一句话描述 diff 吗？

能 → 不用进 Plan，直接让 Agent 改。例：修 typo、加日志、改变量名、调整一个 import。

不能（涉及多文件、跨模块、不熟悉的代码、不确定的方案）→ 必须进 Plan 模式让 Agent 先只读、不写。

Plan 模式的核心价值是把"问题理解"和"动手"在时间上分开——这两件事分得越开，返工率越低。

# Claude Code
Shift+Tab  # 在 default / acceptEdits / plan / auto / dontAsk / bypassPermissions 之间循环

# Codex
Shift+Tab  # 在 Read-only / Auto / Full Access 之间循环，选 Read-only = Plan 模式

# Copilot
Shift+Tab  # 或 /plan Implement password reset flow with email link

1.2 Plan 阶段的 3 个高阶玩法

1）用外置编辑器把计划当合同

三家都能在 Plan 阶段用外置编辑器写计划。意义在于：把"硬约束"直接写进计划文件里，让计划成为可审查的合同。

# Claude Code / Codex
Ctrl+G  # 打开 $EDITOR 编辑当前 plan

# Copilot
Ctrl+Y  # 在 Markdown 编辑器中打开 plan.md

典型约束写法：

## Plan: 实现密码重置流程

### 涉及文件
- src/api/auth.ts
- src/services/email.ts
- tests/auth/test_reset.py

### 约束（必须遵守）
- 保留向后兼容（旧的 /login 流程不能动）
- 先写测试再写实现
- 不要改数据库 schema
- 使用项目里现成的 token-manager.ts，不要引入 passport.js

### 验证
- `pytest tests/auth/ -k reset` 全部通过
- `mypy src/auth/` 无错误

写完之后保存退出，Agent 会按"合同"实现。

2）计划里显式列验证步骤

没写验收标准的计划 = 100% 会变成"看起来做完了"。

### 验证
1. Run `pytest tests/auth/ -k reset` and ensure all 3 new cases pass.
2. Run `mypy src/auth/` to confirm no type errors.
3. Open a PR with title "feat(auth): password reset flow".

Agent 擅长"对照 plan 自检"——前提是把验证步骤写进去。

1.3 三家 Plan 命令对照

步骤	Claude Code	Codex	Copilot
进 Plan	`Shift+Tab` → `plan`	`Shift+Tab` → `Read-only`	`Shift+Tab` 或 `/plan <描述>`
写计划	`Ctrl+G`	`Ctrl+G`	`Ctrl+Y`
让 Agent 继续	"Proceed with the plan"	"proceed" / "go"	"Proceed with the plan"
中止 Plan	再按 `Shift+Tab` 退出	切到 `Auto` 或 `Full Access`	再按 `Shift+Tab` 退出

2. 需要掌握的 7 个命令

按使用频率排序。这 7 个命令覆盖 90% 的日常使用，其余命令是"知道有就行，需要时查 /help"。

2.1 `@文件` / `@路径/` — 精准注入上下文

@src/api/auth.ts       # 单文件
@src/api/auth/         # 整个目录
@../docs/spec.md       # 项目外的文件

也可以直接拖进cli，都支持得不错

核心原则：让 Agent 按需读相关部分。

CLAUDE.md / AGENTS.md 里也支持 @docs/git-instructions.md 语法引用其他文件，最多 4 层引用。三家都有这个特性，行为一致。

2.2 `!命令` — 会话内跑 shell

! npm test              # Claude Code
! git status
! ls -la src/

# 进阶
! long-running-task     # 长任务
Ctrl+B                  # 转后台（Claude Code 特有），不阻塞主对话

上下文行为：输出会回到主对话——只在确实需要 Agent 看到结果时用；纯查看用 ! 更顺手。
粘贴以 ! 开头的内容会自动进入 shell 模式（Claude Code 行为）。

Codex 和 Copilot 都有 shell 工具，能用 !git diff、!cat file 直接验证。

2.3 `/clear` — 切任务时清空上下文

/clear                  # 清空 + 当前对话进 /resume 选择器
/clear feature-auth-work   # 给被清掉的对话打标签（Claude Code 特有）

使用节奏：每完成一个独立任务 → /clear。一次会话只做一件事。

官方原话警告过一种反模式——"kitchen sink session"：一个会话混入不相关任务，等要清理 context 时已经一团糟。

2.4 `/compact [focus...]` — 长会话摘要压缩

/compact                            # 压缩整个对话
/compact focus on the API design    # 带方向压缩

关键事实（Claude Code 文档原话）："Project-root CLAUDE.md survives compaction: after /compact, Claude re-reads it from disk and re-inject it." —— 项目根的 CLAUDE.md 不会因压缩丢失；但子目录的 CLAUDE.md 会丢失，直到下次读到该目录才重新加载。

何时用 /compact：

对话长了但任务没完 → /compact focus on X。
同一任务上修 Agent 同一错误超过 2 次 → 立刻 /clear（用更好的 prompt 重开，不要继续累积修正）。
Codex 隐式做了这件事，没有显式 /compact，但可以 /fork 派生新会话。

2.5 `/resume` — 恢复历史会话

# Claude Code
/resume                       # 打开选择器
/resume feature-auth          # 按名恢复
claude -c                     # 续当前目录下最近对话
claude -r <id>                # 按 ID 恢复

# Codex
codex resume
codex resume --last
codex resume <id>

# Copilot
/resume                       # 打开 ~/.copilot/session-state/ 选择器

配合 git worktree 的高阶用法：每个 worktree 一个 codex resume / claude -r <id> 会话。切分支 = 切会话，context 完全隔离。

2.6 `/rewind` / `/session` — 回退到 checkpoint

# Claude Code
/rewind          # 弹出检查点选择器
Esc+Esc          # 空输入时弹 rewind 菜单（含 "Summarize from here" / "Summarize up to here" 选项）

# Copilot
/session                  # 查看当前会话信息
/session checkpoints      # 列出所有检查点
/session checkpoints 3    # 查看第 3 个检查点内容
/session files            # 列出当前会话临时文件
双 Esc                     # 在 composer 为空时打开 rewind picker

# Codex
Esc × 2（composer 为空时）  # **编辑上一条用户消息** —— 这也是 fork / 分叉的入口

Copilot 警告："Rewinding cannot be undone. Once you roll back to a snapshot, all snapshots and session history after that point are permanently removed." —— 回退是不可逆的。

注意：/rewind 会同时回退 Agent 改的、手动改的、shell 命令产生的所有变更，包括之后新增的文件。回退前先 git status 确认工作区状态。

Codex 关键差异：Codex 没有 /rewind 概念，而是把"分叉"和"回退"合在一起——Esc×2 编辑上一条消息后，从那个时间点分叉新会话；不满意就丢，老会话仍在 /resume 里。

2.7 `/model` + `--effort` — 切模型与思考强度

# Claude Code
/model                # 打开选择器
Alt+P                 # 切换模型不丢失当前 prompt（更快的快捷键）
--effort low/medium/high/xhigh/max    # 调节思考强度

# Codex
/model
codex --model gpt-5.5

# Copilot
/model                # 含 Auto / Opus 4.5 / Sonnet 4.5 / GPT-5.2 Codex

核心技巧：让主模型去调度subagent，subagent可以指定使用不同的模型，节约用量

2.8 锦上添花

命令	哪家	用途
`/btw`	Claude Code	侧边问题，答案不进入主对话历史；纯提问用，访问不到工具——完美的"等下，X 那个 Y 是否考虑过"场景
`/statusline`	Claude Code	自定义状态栏持续追踪上下文用量
`/goal`	Claude Code	跨会话条件门控（评估器每轮重新检查）
`/diff`	Claude Code	交互式 diff 查看器，左右键切"当前 git diff"和"单 turn diff"，审 PR 前必看
`/code-review`	Claude Code	内置代码评审（在全新子代理中评审当前 diff）
`/recap`	Claude Code	按需生成会话摘要（默认自动每 3 turn 触发）
`/delegate`	Copilot	把当前会话转给 GitHub 云端 Copilot，云端代理会创建 PR
`/fleet`	Copilot	启动并行子代理加速大任务
`/task` / `/review`	Copilot	显式触发子代理（review 有 4 种预设：base branch / uncommitted / commit / custom）
`claude -p "..."`	Claude Code	非交互模式，配 `--output-format json` / `--output-format stream-json --verbose` 给 CI、pre-commit、脚本用
`codex exec "..."`	Codex	非交互执行；`codex exec resume --last "Fix race"` 续上次
`codex cloud exec --attempts 3 "..."`	Codex	云端 best-of-N（1-4 次并发尝试）
`codex features enable unified_exec`	Codex	启用新功能（如 `unified_exec` 执行模式、`shell_snapshot`）
`codex app-server --listen ws://...`	Codex	启动 App Server，远程 TUI 通过 WebSocket 连接
`claude agents` / `codex agents`	三家	打开多代理视图，监控并行后台会话
`claude -c`	Claude Code	续当前目录下最近对话（最快的工作流快捷方式）
`/add-dir`	Copilot / Codex	多仓库/多目录工作流，加额外目录进 Agent 可访问范围

3. 上下文管理：context window

Anthropic 官方："Most best practices are based on one constraint: Claude's context window fills up fast, and performance degrades as it fills."

所有"上下文最佳实践"都围绕"别浪费它"展开。

3.1 4 种"喂"上下文的姿势

从高到低：

@文件路径（最优）—— 引用文件，Agent 按需读相关部分。Claude Code 与 Copilot 支持 @path/to/file 完整路径；Codex 的 @ 触发的是模糊文件搜索（@ + Tab 选中），再 Enter 填入。
粘贴图片/截图/错误堆栈 —— OCR 不必，人类也读图。三家都支持拖放图片到 CLI 输入。
cat error.log | claude（管道输入） —— 适合一次性文本。
整文件复制（最差）—— 1000 行代码塞进 prompt，挤占 context。

Claude Code 特有技巧：/permissions 把常用文档域名（docs.example.com）加白名单，让 Agent 自己去拉。

通用技巧：gh CLI 是 GitHub 上下文最高效的获取方式——Anthropic 文档原话："Without gh, Claude can still use the GitHub API, but unauthenticated requests often hit rate limits."

3.2 3 个清理层次

触发场景	操作	效果
Agent 走偏了一点	`Esc+Esc` 局部回退 + 改 prompt 继续	撤回最近几轮（Codex 是 fork 入口）
想问个不相关的边角问题	`/btw`	侧边问，答案不进入主对话历史
对话长了但任务没完	`/compact focus on X`（Claude/Copilot）	保留当前任务，只压缩历史
任务完成要开始新任务	`/clear`	完全清空，原对话进 `/resume`

关键节奏：同一任务上修 Agent 同一错误超过 2 次 → 立刻 /clear 用更好的 prompt 重开。

官方原话："If you've corrected Claude more than twice on the same issue in one session, the context is cluttered with failed approaches."

干净会话 + 更好的 prompt 永远胜过"长会话 + 累积修正"。

3.3 4 层记忆文件 + 一键生成

把"每次都要说的事情"挪到磁盘，让 Agent 在每个新会话里"已经知道项目是谁搭的、约定是什么"——这是从"工具"到"协作者"的关键升级。

Claude Code 的一键生成：在项目根跑 /init —— Agent 分析项目结构自动生成 CLAUDE.md 起始模板。

加载顺序（从广到窄）：

作用域	Claude Code	Codex	Copilot
用户全局	`~/.claude/CLAUDE.md`	`~/.codex/AGENTS.md`	`~/.copilot/copilot-instructions.md`
用户全局覆盖	（local 后缀）	`~/.codex/AGENTS.override.md`	（`.override`）
项目共享	`./CLAUDE.md` 或 `./.claude/CLAUDE.md`	`./AGENTS.md`	`.github/copilot-instructions.md`
项目模块化	`./.claude/rules/*.md`（支持 `paths` frontmatter）	每层一个 AGENTS.md	`.github/instructions/*/.instructions.md`
项目个人	`./CLAUDE.local.md`（gitignore）	子目录 `AGENTS.override.md`	本机范围
团队组织	Managed policy 文件	`project_doc_fallback_filenames`	组织托管规则

Copilot 加载顺序的关键规则："Repository instructions always take precedence over user instructions"（仓库级指令始终优先于全局指令）。

加载行为：不是覆盖而是拼接（Anthropic 原话："All discovered files are concatenated into context rather than overriding each other"）。子目录的 CLAUDE.md 只在 Agent 读该子目录文件时才按需加载。

CLAUDE.md 里支持 @ 导入语法：可以在 CLAUDE.md 中写 See @README.md for project overview and @package.json for available npm commands.，Agent 会按需展开。最多 4 层引用。

大小上限：

Claude Code MEMORY.md 启动时只加载前 200 行 / 25KB（自动记忆机制）。
Codex 合并总大小上限是 project_doc_max_bytes = 32 KiB（默认）。
复杂规则不要写进 CLAUDE.md，改用 PreToolUse hook 强制约束。

3.4 跨会话：CLAUDE.md vs Auto memory vs Codex Memories

CLAUDE.md（人工写）—— 由开发者维护、每会话完整加载。应只放"普适指令"。

Auto memory（Claude Code v2.1.59+，Agent 自己学） —— Agent 自己记录 build commands、调试经验、架构笔记。存到 ~/.claude/projects/<project>/memory/，首次 200 行 / 25KB 启动时加载，详情文件按需读。默认开启，可用 /memory 命令切换。

Codex Memories / Chronicle（Codex 0.140+ 新增） —— 文档侧栏已列出 /codex/memories 和 /codex/memories/chronicle 入口，对应 OpenAI 的持久记忆子系统。Chronicle 给出"会话历史洞察"。

关键事实（Claude Code 文档原话）："Both are loaded at the start of every conversation. Claude treats them as context, not enforced configuration. To block an action regardless of what Claude decides, use a PreToolUse hook instead."

记忆文件只是上下文不是规则——要强制约束必须用 hook，不是写文档。

3.5 长任务的会话状态恢复

方案	适用	说明
A. worktree + 会话隔离	大功能 / 长期任务	每个 git worktree 一个 `codex resume` / `claude -r <id>` 会话。切分支 = 切会话，context 完全隔离
B. CLAUDE.md 写"怎么续"	中等任务	在指令文件里写"如果中断了，请先 `git log -5` 和 `git status` 再继续"——把"怎么续"作为冷启动指令
C. 连续 5 小时不清	强烈不推荐	后期 Agent 必然开始"忘记"早期约束、变笨、产出重复修复

4. 安全：deny 永远第一

永远不要让 Agent 默认拥有破坏性权限。"给它 1 个权限 = 让它能用到 1 个" 是错误模型；正确模型是"默认拒绝 + 显式白名单"。

4.1 三级危险模型

把工具按破坏半径分三档，配权限时心里有数：

等级	例子	配权策略
L1 只读	`Read`、`Grep`、`Glob`、`Bash(ls *)`、`Bash(git status)`	几乎无副作用，可以默认开
L2 局部写	`Edit`、`Write`、`Bash(npm test)`、`Bash(git commit *)`	影响工作区，需要按任务白名单
L3 系统级	`Bash(rm -rf )`、`Bash(curl )`、`Bash(git push )`、`Bash(sudo )`	必须显式拒绝或每次确认

4.2 deny 永远优先于 allow

这是 Claude Code / Codex 共同的关键规则（Anthropic 原话）："Rules are evaluated in order: deny, then ask, then allow. The first match in that order determines the outcome, and rule specificity does not change the order."

核心警告："提示中的指令或 CLAUDE.md 只能'影响 Claude 尝试做什么'，不能改变 Claude Code 实际允许的内容。"

也就是说，prompt 写"请不要 rm -rf"是无效的；必须在 settings.json 里 deny。

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git commit *)",
      "Bash(* --version)"
    ],
    "deny": [
      "Bash(git push *)",
      "Bash(rm -rf *)",
      "Bash(curl *)",
      "Bash(sudo *)"
    ]
  }
}

复合命令陷阱："Claude Code 识别 shell 操作符，因此 Bash(safe-cmd *) 不会授权执行 safe-cmd && other-cmd。" —— 不会被通配符绕过。

4.3 三家权限机制对照

维度	Claude Code	Codex	Copilot CLI
配置文件	`settings.json`（4 层优先级）	`~/.codex/config.toml`	CLI 启动参数 + `.github/copilot-instructions.md`
写规则语法	`permissions.allow/deny/ask`	Approval mode（Auto / Read-only / Full Access）+ `sandbox` 配置	`--allow-tool` / `--deny-tool` / `--available-tools` / `--excluded-tools`
工具模式匹配	`Bash(git:*)`（冒号）	基于前缀 + shell 元字符	`shell(git:*)`（冒号）
优先级	deny > ask > allow（按列表顺序）	Approval mode 是边界 + 是否提示	`--available-tools` 覆盖 `--excluded-tools`；`--deny-tool` 覆盖 `--allow-tool`
沙箱能力	OS 级 sandbox（`/sandbox`，仅 Bash）	`sandbox` 配置（结合 Approval mode）	仅基于规则的 allow/deny
推荐默认	`default` 模式 + 编辑过的 `settings.json`	Approval = `Auto`，按任务加白名单	`--available-tools='bash,edit,view,grep,glob' --allow-tool='shell(git:*)' --deny-tool='shell(git push)'`

4.4 Approval mode 三档

Codex 把审批做成了三档显式状态（通过 /permissions 切换，配置在 config.toml 的 approval_policy）：

Mode	能力	何时用
Auto（默认）	当前工作目录内读/写/执行；越界（目录外、网络）需确认	日常开发
Read-only	只浏览文件，不做修改，需先批准 plan	审 PR、看代码、咨询
Full Access	跨整台机器 + 网络，不再询问	可信仓库的自动化

Claude Code 有 OS 级 sandbox（/sandbox 启用，限制 Bash 文件系统和网络访问）。Copilot CLI 没有真沙箱，只能靠 --deny-tool 黑名单 + --available-tools 白名单缩小可选工具集。

Codex 的 4 层防御（配合使用）：

Approval mode（Auto / Read-only / Full Access）
sandbox 配置（文件系统和网络隔离）
config.toml 的 [permissions] 段（具体规则白/黑名单）
启动旗标 --yolo 完全绕过（最后手段）

4.5 `--yolo` / `--dangerously-skip-permissions` 是最后手段

工具	旗标	备注
Claude Code	`--dangerously-skip-permissions`（`bypassPermissions` 模式）	跳过权限提示，但强制 ask 规则仍然提示；针对根目录与家目录的删除仍会作为熔断机制
Codex	`--yolo` = `--dangerously-bypass-approvals-and-sandbox`	"在生产或共享环境使用 `--yolo`（除非处于专用沙箱 VM）"是被明令禁止的
Copilot CLI	`--yolo` / `--allow-all`	等同于同时启用 `--allow-all-tools`、`--allow-all-paths`、`--allow-all-urls`

官方一致警告："Only use this mode in isolated environments like containers or VMs"。

替代方案：别用 --yolo，用 --allowedTools "Edit,Bash(git commit *)" 显式限定权限范围——Anthropic 原话："The --allowedTools flag restricts what Claude can do, which matters when you're running unattended."

Claude Code 还有一个新选项：--permission-mode auto（Auto mode）—— 单独的分类器模型审核命令，拦截范围升级、未知基础设施、恶意驱动操作。比 bypassPermissions 更安全：只跳过"低风险"命令的提示，高风险仍询问。注意：Auto mode 在非交互 claude -p 模式下，若分类器反复阻止会中止（无用户兜底）。

5. 做 Agent 的产品经理

Agent 时代编程的本质是"做 Agent 的清晰操作员"。Simon Willison 的原话：

"The 'agentic' coding tools we have right now work like this: A skilled individual with both deep domain understanding and deep understanding of the capabilities of the agent..."

价值 = 领域知识 × 工具熟练度。下面 7 条心法按"反人性"程度排序。

5.1 提问要像产品需求文档

反例："修一下这个 bug"。

正例："登录在 session timeout 后失败，错误堆栈是 [粘贴]。先写一个失败测试复现，再修根因，不要只 suppress 错误。修改后跑 pytest tests/auth/test_session.py 全部用例验证。"

黄金模板：[症状] + [期望行为] + [验证标准] + [禁止做法]。

Anthropic 原话："Give Claude a way to verify its work. 'Looks done' is not a good signal."

给 Agent 配 4 种"验证门控"（按设置成本从低到高）

同一个 prompt 内 —— 在指令里直接要求"运行测试并迭代直到通过"。
/goal（Claude Code） —— 跨会话条件门控，评估器每轮重新检查。
Stop hook（Claude Code） —— 脚本执行检查，阻止 turn 结束直到条件满足（注意：连续 8 次阻止后 Claude Code 会强制结束 turn，避免死循环）。
Verification subagent（独立 context）—— 在新上下文中反驳/审阅结论，避免自评偏差。
Browser screenshot（Claude Code + Chrome）—— 截图对比设计稿，验证 UI 改动。

5.2 增量验证：每改 10 行看一次

不要 100 行一次性 commit。每次让 Agent 改完：

git diff 确认范围正确
用 /diff（Claude Code）看每 turn 的具体改动
让 Agent 跑测试
每次提交独立一个 commit（git add -p），便于回退和 review

反模式："把整个功能一次写完再 review"——一旦 review 出问题，不知道哪 50 行引入的。

5.3 任务拆分：一个会话 = 一件事

反模式：一个会话里做"加 OAuth + 修首页 bug + 重构 utils"，混完后清理 context 极痛苦。

正例：

会话 1 = "实现 password reset"
会话 2 = "加 metrics middleware"
用 git 分支隔离

官方警告："The kitchen sink session: One session with unrelated tasks. Use /clear between unrelated tasks."

5.4 两次失败就 `/clear` 重来

Anthropic 原话："If you've corrected Claude more than twice on the same issue in one session, the context is cluttered with failed approaches. Run /clear and start fresh with a more specific prompt that incorporates what you learned."

干净会话 + 更好的 prompt 永远胜过"长会话 + 累积修正"。

5.5 子代理是 context 的瑞士军刀

"Since context is your fundamental constraint, subagents are one of the most powerful tools available."

子代理在独立 context 中运行、返回摘要，主对话不被"读了 200 个文件"污染。

典型用法：

让 explore 子代理查 "auth 系统怎么管 token refresh" → 返回一段摘要。
让审查子代理用新 context 复审刚改的 diff —— 关键洞察："A reviewer running in a fresh subagent context sees only the diff and the criteria you give it, not the reasoning that produced the change, so it evaluates the result on its own terms."

这是对抗性验证的标准模式：让一个干净的 context 独立判断结果好坏。

Claude Code 的子代理体系（最完整）：

claude agents：内置多代理视图，监控并行后台会话
Agent teams（/agent-teams）：多 session 自动协调 + 共享任务列表
Code intelligence plugin：给 typed language 提供精确符号导航和自动错误检测
子代理配置在 .claude/agents/*.md，frontmatter 指定 tools 和 model

Codex 的子代理：

codex agents 视图
/fork 和 /side：在历史消息节点分叉/并行会话
Codex 关键差异："Codex only spawns subagents when you explicitly ask it to" —— 不像 Claude Code 那样按需自动派生，token 消耗更可控
子代理配置在 config.toml 的 [agents] 段

Copilot CLI 的子代理：

/fleet：把大任务分解为并行子任务由子代理执行
/delegate：把整个工作转移到 GitHub 云端 Copilot，云端代理会创建 PR
/task、/review：显式触发子代理（/review 有 4 种预设：base branch / uncommitted / commit / custom）
内置子代理（/review、/task、explore、/fleet）自动继承 provider 配置

Writer/Reviewer 模式（Claude Code 强调）：用全新上下文的 Reviewer 子代理审 Writer 子代理的产出，避免自评偏差。

5.6 测试是 Agent 时代的"免费午餐"

Simon Willison 原话："Good automated tests which the coding agent can run ... pytest ... 1500 tests ... Claude Code is great at selectively running just the relevant tests for a change, and running the full suite at the end."

关键技巧："detailed error messages! If a manual or automated test fails the more information you can return back to the model the better" —— 把 assertion 写详细，让 Agent 能"自己读错误自己修"。

差的 assertion：

assert user.is_authenticated()

好的 assertion（Agent 能直接定位问题）：

assert user.is_authenticated(), f"Expected authenticated user, got state={user.state}, session_age={user.session_age}s, token={user.token[:8]}..."

Copilot CLI 的 Plan 流程标准最后一步就是 "Run the tests and fix any failures"——把"跑测试"嵌进标准工作流。

5.7 给 Agent 一个工具齐全的开发环境

Simon Willison 的 HN 回复清单（值得全文照搬）：

好测试（pytest + 详细 assertion message）
开发服务器启动说明（让 Agent 用 Playwright / curl 交互式验证 UI 改动）
Lint + type check + formatter（Agent 会自己用）
GitHub issues 列表（把 issue URL 直接贴进 prompt，"having great results"）

反直觉点："I have extensive documentation in all of my projects, but I don't think it's particularly useful for coding agents. LLMs can read the code a lot faster than you to figure out how to use it."

文档对 Agent 没用，Agent 读代码比人快；文档的作用反而是"让 Agent 检查文档是否需要更新"。

5.8 5 条必避反模式

反模式	描述	修复
The kitchen sink session	一个会话混入不相关任务	任务间用 `/clear`
Correcting over and over	同一问题多次纠正	2 次失败就 `/clear` 改 prompt
The over-specified CLAUDE.md	规则太多淹没有效指令	严格剪枝（200 行内），复杂规则改 hook
The infinite exploration	"调查"无边界，Agent 读数百文件	缩小范围或用 subagent
The trust-then-verify gap	实现看起来合理但缺边缘场景	始终要求提供验证（测试 / 脚本 / 截图）

6. 参考

Claude Code: https://code.claude.com/docs/en/best-practices
Codex CLI: https://developers.openai.com/codex/cli/features + https://developers.openai.com/codex/cli/reference
Copilot CLI: https://docs.github.com/en/copilot/how-tos/copilot-cli/cli-best-practices
Simon Willison "Setting up a codebase for working with coding agents"（2025-10-25）: https://simonwillison.net/2025/Oct/25/coding-agent-tips/

VSCode + SSH + Docker 完整配置流程

Sat, 25 Apr 2026 00:00:00 GMT

以下是一份完整的、可复用的配置流程，从一台全新的 Linux 机器到 VSCode 免密管理 Docker，按顺序执行即可。

一、Linux 端准备

1.1 开启 SSH 服务

Kali Linux：

# 启动 SSH
sudo /etc/init.d/ssh start

# 开机自启
sudo systemctl enable ssh.service

Ubuntu/Debian：

# 安装并启动
sudo apt-get update
sudo apt-get install -y openssh-server
sudo service ssh start

1.2 查看 IP 地址

ip a

记下 inet 后面的局域网 IP（如 192.168.17.129）。

二、Windows 端准备

2.1 安装 VSCode 插件

打开 VSCode，安装以下扩展：

Remote - SSH
Docker

2.2 生成 SSH 密钥对

打开 PowerShell，执行：

ssh-keygen -t ed25519

保存路径：直接回车（默认 C:\Users\你的用户名\.ssh\id_ed25519）
密码：直接回车（不设密码，实现完全免密）

生成后确认文件存在：

ls $env:USERPROFILE\.ssh\

应看到：

id_ed25519 —— 私钥（留在 Windows）
id_ed25519.pub —— 公钥（放到 Linux）

三、配置免密登录（公私钥）

3.1 将公钥上传到 Linux

方法一：命令自动上传（推荐） 在 Windows PowerShell 执行（替换 IP 和用户名）：

type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh kali@192.168.17.129 "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys && chmod 700 ~/.ssh"

输入一次密码后，公钥即上传完成。

方法二：手动复制

用记事本打开 C:\Users\你的用户名\.ssh\id_ed25519.pub，复制全部内容
在 VSCode 连上的 Linux 终端中：
```
nano ~/.ssh/authorized_keys
```
粘贴 → Ctrl+O 回车保存 → Ctrl+X 退出

设置权限：

chmod 600 ~/.ssh/authorized_keys
chmod 700 ~/.ssh

3.2 配置 VSCode SSH 使用私钥

按 Ctrl+Shift+P → Remote-SSH: Open SSH Configuration File → 选择第一个。

添加或修改配置：

Host kali
    HostName 192.168.17.129
    User kali
    IdentityFile C:\Users\你的用户名\.ssh\id_ed25519

注意：IdentityFile 指向的是私钥（id_ed25519），不是 .pub。

3.3 修复 Windows 私钥权限（关键！）

在 PowerShell 执行：

cd $env:USERPROFILE\.ssh

# 移除继承权限，仅保留当前用户读取
icacls id_ed25519 /inheritance:r
icacls id_ed25519 /grant:r "$($env:USERNAME):(R)"

3.4 测试免密连接

在 PowerShell 测试：

ssh -i $env:USERPROFILE\.ssh\id_ed25519 kali@192.168.17.129

如果直接连上，说明配置成功。

然后在 VSCode 中：

点击左下角绿色 >< 图标
选择 Connect to Host... → kali
应直接连上，不再提示密码

四、Linux 端安装 Docker

4.1 安装 Docker

推荐方式（Ubuntu/Debian）：

wget -qO- https://get.docker.com/ | sh

Kali Linux（Docker 官方不支持 Kali，需手动）：

sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg lsb-release

# 添加 GPG key
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 使用 Debian 源（Kali 基于 Debian）
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian buster stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

4.2 验证安装

sudo docker run hello-world

看到 Hello from Docker! 即成功。

五、解决 Docker 权限问题

VSCode 连上后，Docker 插件可能提示无法访问 /var/run/docker.sock。

一劳永逸的解法：

在 Linux 终端执行：

# 将当前用户加入 docker 组
sudo usermod -aG docker $USER

# 重启 Docker 服务
sudo systemctl restart docker

然后断开 VSCode SSH 连接，重新连接（或重启 Linux）。

验证：

docker ps

不再提示权限错误即成功。

六、VSCode Docker 插件使用

连接成功后，左侧边栏出现 Docker 图标，常用功能：

功能	操作
拉取镜像	Images → 右键 `Pull` 或终端执行 `docker pull`
运行容器	镜像右键 → `Run`（后台）/ `Run Interactive`（带日志）
进入容器终端	容器右键 → `Attach Shell`
查看日志	容器右键 → `View Logs`
编辑容器文件	展开容器 `Files` 树，直接双击修改
端口转发	容器右键 → `Forward Port`，自动映射到 Windows 本地
浏览器打开	端口转发后，右键 `Open in Browser`

七、快速检查清单

每次复用或排查问题时，按以下顺序检查：

检查项	命令/操作
Linux SSH 是否运行	`sudo service ssh status`
Windows 私钥权限	`icacls C:\Users\用户名\.ssh\id_ed25519`（应只有当前用户）
Linux 公钥是否正确	`cat ~/.ssh/authorized_keys`
Linux .ssh 权限	`ls -la ~/.ssh`（700 + 600）
用户是否在 docker 组	`groups`（应看到 `docker`）
VSCode 配置路径	`IdentityFile` 指向私钥，不是 `.pub`

八、配置文件模板

Windows SSH 配置（C:\Users\用户名\.ssh\config）：

Host kali
    HostName 192.168.17.129
    User kali
    IdentityFile C:\Users\你的用户名\.ssh\id_ed25519
    ForwardAgent yes

Linux SSH 配置（/etc/ssh/sshd_config，可选加固）：

PubkeyAuthentication yes
PasswordAuthentication no    # 确认密钥可用后再开启，禁用密码登录

修改后重启 SSH：

sudo service ssh restart

按这个流程走，任何新的 Kali/Ubuntu/Debian 机器都可以在 5 分钟内配置好完整的远程 Docker 开发环境。

Word 排版技巧

Wed, 22 Apr 2026 00:00:00 GMT

本文整理 Word 排版中的实用技巧，包括图片题注、交叉引用、三线表制作等。

1. 图片排版

1.1 粘贴图片显示不全

问题：粘贴图片后只显示一行，图片无法完整显示。

解决方法：

选中图片所在段落
右键 → 段落
将行间距改为单倍行距或固定值（如 20 磅）

1.2 添加题注

给图片添加题注，方便引用和管理。

操作步骤：

右键图片 → 插入题注
点击新建标签，输入"图"
位置选择"所选项目下方"

设置编号格式：

点击编号按钮
勾选"包含章节号"
选择章节样式（如"标题 1"）
选择分隔符（如"-"或"."）

1.3 交叉引用

使用交叉引用，可以在图片增删后自动更新编号。

操作步骤：

光标定位到引用位置
引用 → 交叉引用
引用类型选择"图"
选择要引用的题注

1.4 修改题注样式

修改题注的字体、字号、对齐方式。

操作步骤：

开始 → 样式右下角展开
找到"题注"样式，右键 → 修改
设置字体（如宋体、五号）
设置对齐方式（如居中）

段落居中设置：

右键题注 → 段落
对齐方式选择"居中"

1.5 批量更新编号

当图片增删后，需要批量更新所有编号。

操作步骤：

Ctrl + A 全选文档
F9 更新域
所有题注编号自动更新

2. 三线表制作

学术论文中常用的三线表样式。

2.1 新建表格样式

操作步骤：

表格设计 → 新建表格样式
设置样式名称（如"三线表"）

设置边框：
- 顶线：1.5 磅，黑色
- 中间线：0.5 磅，黑色
- 底线：1.5 磅，黑色

应用范围选择"整张表格"
点击确定保存

2.2 应用样式

选中表格
表格设计 → 找到自定义的"三线表"样式
点击应用

3. PDF 编辑

如果需要编辑 PDF 文件，可以使用 Adobe Acrobat。

常用功能：

PDF 转 Word
合并/拆分 PDF
添加水印
表单填写

4. 总结

技巧速查表

技巧	操作
图片显示不全	段落 → 行间距改为单倍行距
添加题注	右键 → 插入题注 → 新建标签
自动编号	插入题注时勾选"包含章节号"
交叉引用	引用 → 交叉引用 → 选择题注
批量更新	Ctrl+A → F9
三线表	新建表格样式 → 设置顶线/底线 1.5 磅
PDF 编辑	使用 Adobe Acrobat

注意事项

题注样式修改后，所有题注会自动更新
交叉引用需要手动更新（F9）
三线表的中间线通常比顶底线细
建议在排版前先设置好样式，避免后期大量修改

Cloudflare 边缘应用：一个 IP 承载数千网站

Fri, 10 Apr 2026 00:00:00 GMT

参考讨论：XTLS/BBS#23

Cloudflare 一个 IP（如 104.16.x.x）能同时承载数千甚至上万个网站，背后是 CDN 的几项核心技术叠加：反向代理 + SNI/Host 路由、Anycast、边缘计算。

1. 反向代理（Reverse Proxy）+ SNI 路由

用户访问 site1.com ──┐
用户访问 site2.com ──┼──→ Cloudflare IP (104.16.x.x) ──→ 根据信息分发到不同源站
用户访问 site3.com ──┘

关键技术：SNI + Host 头双重路由。

第一步：TLS 握手（SNI 决定证书）

你的浏览器 → Cloudflare:443

Client Hello:
  - SNI: "site1.com"  ← 明文传输

Cloudflare 根据 SNI：
  - 找到 site1.com 的证书
  - 返回 site1.com 的 TLS 证书

第二步：HTTP 请求（Host 头决定源站）

HTTP GET / HTTP/1.1
Host: site1.com  ← 决定请求转发给哪个源服务器

结果： 同一个 IP，根据 SNI 和 Host 头的不同，可以服务无限个域名。

2. Anycast 技术（全球共享 IP）

这是 Cloudflare 的独特之处：

传统 DNS：
- site.com → 1.2.3.4（美国服务器）
- 中国用户访问慢

Cloudflare Anycast：
- 104.16.249.249 同时在全球广播：
  - 北京用户访问 → 被路由到北京机房
  - 纽约用户访问 → 被路由到纽约机房
  - 伦敦用户访问 → 被路由到伦敦机房

同一个 IP 地址，物理上对应全球数百个数据中心。

3. 边缘计算（Edge Computing）

对于 Workers/Pages：

用户请求 example.worker.dev
           ↓
到达最近的 Cloudflare 边缘节点
           ↓
不转发到源站，直接在边缘节点执行 JavaScript 代码
           ↓
返回结果

一个 IP 既是反向代理入口，又是代码执行环境。

4. 边缘应用为什么几乎不占资源

边缘应用（Worker）是 Serverless 无服务器架构，特点是：

不是一直开着一台服务器等请求
来一个请求，临时启动一段代码
执行完（通常几毫秒～几十毫秒）直接销毁
不请求时，完全不占资源

一个节点上可以同时跑几万个用户的边缘函数，资源是极度共享、极度轻量化的。对 Cloudflare 来说，这点算力几乎可以忽略不计。

5. 写 API、鉴权、查数据库会不会很耗资源？

并不会，而且架构是这样的：

边缘节点：只做轻逻辑（校验、路由、拼接、简单计算）
数据库：依然放在中心服务器 / 云数据库（比如阿里云、腾讯云、PlanetScale）
边缘节点 → 发请求 → 中心数据库拿数据

不是每个边缘节点都装数据库。只是用户到边缘近，边缘到数据库那一步是厂商优化过的内网专线，整体依然很快。

6. 对比传统后端

传统后端：买 1 台 / 3 台 / 10 台服务器，自己扛所有流量，崩了要自己重启扩容
边缘后端：厂商全球几百个节点自动兜底，流量再大也自动分配，不用管服务器数量

VMware Workstation 下载指南

Wed, 08 Apr 2026 00:00:00 GMT

背景

VMware 于 2023 年 11 月被 Broadcom 收购。2024 年 5 月起，VMware Workstation Pro 个人使用免费（商业用途仍需付费）。原 VMware Workstation Player 已合并进 Pro 版本。

下载步骤

访问 Broadcom 支持门户，注册并登录账号
进入产品页面，找到 VMware Workstation Pro
选择版本（当前最新为 17.6.x）和操作系统（Windows / Linux）
下载安装包

参考：Broadcom 官方说明

安装

运行下载的安装程序，按向导完成安装即可。建议使用默认安装路径，安装过程中勾选"增强型键盘驱动"以获得更好的输入体验。

配置中文界面

安装完成后如需切换为中文界面：

打开 VMware Workstation
菜单栏 → Edit → Preferences → Language
选择 简体中文，重启软件生效

详细图文教程参考：VMware 中文语言配置

注意事项

务必从 Broadcom 官网下载，避免第三方来源的恶意软件
仅限个人非商业用途免费，商业环境需购买许可

校园网 IP 切换原理

Thu, 02 Apr 2026 00:00:00 GMT

很多人会注意到一个现象：在校园网里隔一段时间查一下自己的公网 IP，会发现它在悄悄变化，但自己刷网页、登微信、打游戏却完全没有感知。这篇笔记拆解这背后的原理：NAT 出口为什么频繁换 IP，以及为什么用户感觉不到。

1. 校园网为什么用 NAT

校园网通常只有一个或少数几个公网 IP，但网内可能有成千上万台设备（手机、电脑、平板）。要把这么多设备接上互联网，靠的是 NAT（网络地址转换）：

每台设备拿到的是一个内网 IP（如 10.x.x.x、172.16.x.x、192.168.x.x），这些地址在公网上无法路由。
设备访问外网时，出口的 NAT 设备（路由器/网关）把源地址从内网 IP 改写成公网 IP，并记录一条"内网 IP+端口 ↔ 公网 IP+端口"的映射。
对端回包时，NAT 再根据映射表把目的地址翻译回内网 IP，送到对应设备。

也就是说，所有设备的流量对外都"伪装"成从那几个公网 IP 发出，对外呈现的公网 IP 是 NAT 出口决定的，而不是你的设备决定的。

2. 为什么校园网的公网 IP 会频繁切换

公网 IP 的频繁变化，通常由这几个机制叠加造成：

DHCP 短租约：出口公网 IP 本身可能也是向运营商 DHCP 租来的，租约一过期就可能续到另一个 IP。
多出口负载均衡：大型校园网往往接了多条运营商线路（电信、联通、教育网等），网关根据负载把流量分到不同出口，于是你看到的公网 IP 在不同出口之间跳。
故障/拥塞切换：某条出口线路抖动或拥塞时，网关会自动把流量切到健康线路，公网 IP 跟着变。

所以"公网 IP 变了"在校园网里是常态，而非异常。

3. 为什么已建立的连接不受影响

关键在于：NAT 设备对已经打开的应用、已经建立的 TCP 连接（比如正在刷的网页、登着的微信、打着的游戏），会保留这个会话的映射关系：

哪怕公网 IP 变了，已经建立的连接不会断，应用完全不受影响，用着和平时一模一样。
只有当发起全新的连接（比如新开一个 SSH、重新登录某个服务、新开浏览器标签页），才会使用新的公网 IP。

4. 为什么应用本身不关心源 IP

现在的所有互联网应用（微信、浏览器、视频软件等），只需要「网络通」，完全不依赖固定的源公网 IP：

源 IP 变了，应用不会报错、不会掉线，用户察觉不到任何异常。
只有需要「源 IP 白名单」的服务（比如服务器的安全组、企业 VPN、特定后台系统），才会因为源 IP 变了而被拦截——这就是在校园网里 SSH 突然连不上服务器的一个常见根因。

5. 链路切换是毫秒级的

校园网的负载均衡、故障切换都是毫秒级完成的，几乎感觉不到断网，自然也不会意识到 IP 变了。

小结：校园网公网 IP 频繁变化是 NAT + 多出口的正常行为；已建立的连接靠 NAT 映射表维持不断；普通应用不依赖固定源 IP 所以无感；只有依赖源 IP 白名单的服务（典型如 SSH 白名单、VPN）才会被影响。

虚拟机网络配置

Sat, 07 Mar 2026 00:00:00 GMT

一、为什么需要固定 IP？最稳妥的规划策略

VMware NAT 默认通过 DHCP 分配 IP，地址会浮动，多台虚拟机同时开机还可能撞 IP，导致 SSH 频繁断连。最彻底的解决办法是：设置静态 IP，并故意选在 DHCP 分配池之外。

以常见的 NAT 网段 192.168.17.0/24 为例，VMware 的 DHCP 通常分配 128-254 这个区间。因此安全可用的静态 IP 范围为 192.168.17.3 ~ 192.168.17.127。

规划示例：

宿主机：192.168.17.1（系统固定）
NAT 网关：192.168.17.2（系统固定）
虚拟机 A：192.168.17.10
虚拟机 B：192.168.17.11
……

这样无论 DHCP 怎么分配，都不会跟你手动的地址冲突。

本文示例均以目标 IP 192.168.17.10、网卡名 ens160 为例。请务必将命令中的 IP 和网卡名替换为你实际规划的值。 不确定网卡名？执行 ip addr 或 nmcli connection show 查看，常见名有 ens33、eth0 等。

二、前置检查：确保虚拟链路与 VMware 服务正常

很多“配置完不通”的问题，根源不在 Linux 配置，而在虚拟机硬件或 Windows 服务。正式配 IP 之前，先过一遍下面几点。

1. 虚拟机网卡硬件设置（所有方案通用）

关闭虚拟机（不是暂停），打开「虚拟机设置」→「网络适配器」。
必须勾选 ✅「已连接」、✅「启动时连接」。
确认网络连接方式为 「NAT 模式」。

2. 检查宿主机 VMware 核心服务

在 Windows 中 Win+R 输入 services.msc，找到下面两个服务：

VMware NAT Service
VMware DHCP Service

确保它们都是「正在运行」状态。如有异常，右键重新启动。
如果之前修改过虚拟网络编辑器（如恢复了默认设置），可能需要重启这两个服务甚至宿主机。

3. 启动虚拟机，快速确认网卡链路

ip addr show ens160   # 记得替换网卡名

如果输出中包含 state UP，说明链路已通，可以进入下一步。
如果始终是 state DOWN，回第一步重新确认 VMware 设置与服务。

三、方案 A：NetworkManager 正常时的推荐做法（nmcli 一键搞定）

大多数现代 Linux 发行版（CentOS 7+、Fedora、Ubuntu 等）默认使用 NetworkManager 管理网络。这种情况下 nmcli 是最安全、最不容易产生配置冲突的方式。

直接把下面命令里的 192.168.17.10 和 ens160 替换成你的实际值，整个复制执行即可：

CONN="ens160"  # 先确认网卡名

# 1. 绑定静态 IP 和子网掩码
sudo nmcli connection modify "$CONN" ipv4.addresses 192.168.17.10/24

# 2. 设置网关
sudo nmcli connection modify "$CONN" ipv4.gateway 192.168.17.2

# 3. 设置 DNS（推荐公共 DNS）
sudo nmcli connection modify "$CONN" ipv4.dns "8.8.8.8,114.114.114.114"

# 4. 改获取方式为手动
sudo nmcli connection modify "$CONN" ipv4.method manual

# 5. 可选：禁用 IPv6，避免其干扰连通性测试
sudo nmcli connection modify "$CONN" ipv6.method disabled

# 6. 重启网卡
sudo nmcli connection down "$CONN" && sudo nmcli connection up "$CONN"

执行后验证：

ip addr show ens160 | grep 192.168.17.10   # 确认 IP 已绑定
ping -c 3 baidu.com                        # 确认外网域名解析正常

此后即便重启虚拟机，IP 也不会变，MobaXterm 之类的工具直接用 192.168.17.10 连接即可。

四、方案 B：当 NetworkManager 罢工时（未托管、device not found）

有时候系统会出现以下症状：

nmcli device status 显示 ens160 为 unmanaged；
尝试 nmcli connection up 提示 No suitable device found；
修改 /etc/NetworkManager/... 的托管配置无效；
甚至 VMware 中「已连接」都勾不上，网卡始终 DOWN。

这就是典型的 NetworkManager 未托管 + 虚拟链路异常，二合一故障。此时最直接的办法是跳过 NetworkManager，用传统 network.service 接管。

⚠️ 兼容性警告
方案 B 依赖传统 network-scripts 包，在 CentOS 7.x 上适用。

如果你的系统是最小化安装，可能未包含此包，需先执行 sudo yum install network-scripts。

如果你使用的是 RHEL 9 / Rocky Linux 9 / CentOS Stream 9 及更新版本，该包已被官方移除，方案 B 不可用。请返回方案 A 排查 NM 的配置问题。

4.1 确保链路恢复（若仍 DOWN）

如果第一节的前置检查已通过，网卡已是 UP 状态可略过。否则先在虚拟机设置中确认「已连接」已勾，并重启 VMware NAT/DHCP 服务，直至 ip addr show 看到 state UP。

4.2 停用 NetworkManager，手动固定 IP

# 1. 彻底停用 NetworkManager
sudo systemctl stop NetworkManager
sudo systemctl disable NetworkManager

# 2. 临时配通 IP（立即生效）
sudo ip addr add 192.168.17.10/24 dev ens160
sudo ip link set ens160 up
sudo ip route add default via 192.168.17.2 dev ens160
echo -e "nameserver 8.8.8.8\nnameserver 114.114.114.114" | sudo tee /etc/resolv.conf

# 3. 排除 IPv6 干扰：若 ping 外网失败，先临时禁用 IPv6 再测
sudo sysctl -w net.ipv6.conf.ens160.disable_ipv6=1

现在测试 ping 192.168.17.2 和 ping baidu.com，应该都能通。

4.3 让配置永久生效（重启后 IP 依旧）

停止 NetworkManager 后，系统会转而使用传统 network 服务读取 /etc/sysconfig/network-scripts/ifcfg-* 文件。我们直接写入正确配置：

sudo tee /etc/sysconfig/network-scripts/ifcfg-ens160 <<'EOF'
TYPE=Ethernet
BOOTPROTO=static
NAME=ens160
DEVICE=ens160
ONBOOT=yes
IPADDR=192.168.17.10
PREFIX=24
GATEWAY=192.168.17.2
DNS1=8.8.8.8
DNS2=114.114.114.114
IPV6INIT=no
PEERDNS=no
EOF

关于 PEERDNS=no 的说明
加上此参数后，网络服务启动时不会自动修改 /etc/resolv.conf，DNS 将严格使用此文件中定义的 DNS1 和 DNS2。这能确保你手动设定的 DNS 不被其他服务覆盖。

然后启用并启动传统网络服务：

sudo systemctl enable network
sudo systemctl restart network

最后，如果之前禁用了 IPv6，可将其设为永久生效：

sudo sysctl -w net.ipv6.conf.ens160.disable_ipv6=1 | sudo tee -a /etc/sysctl.conf

至此，无论是否重启，虚拟机都会固定使用 192.168.17.10，且不会再被 NetworkManager 干扰。

五、快速验证清单

无论用哪个方案，最后都跑一遍：

ip addr show ens160          # 看到 192.168.17.10/24
ping 192.168.17.2 -c 2       # 网关通
ping www.baidu.com -c 4      # 外网域名解析通

全通则成功。然后就可以打开 MobaXterm，新建 SSH Session，Host 填入 192.168.17.10，享受稳定的连接。

六、故障速查表

现象	可能原因	快速处置
网卡始终 `DOWN`	虚拟机设置中未勾选「已连接」或 VMware 服务未运行	重启 VMware NAT/DHCP 服务，确认勾选已打
`nmcli` 报 `unmanaged`	NetworkManager 配置禁止管理该网卡	若系统版本支持，直接用方案 B；否则排查 NM 配置文件
`ping` 网关通但域名解析失败	DNS 配置错误或被覆盖	确认 `/etc/resolv.conf` 内容；使用方案 B 时检查 `ifcfg` 中 `PEERDNS` 设置
`ping` IP 通但域名不通	IPv6 路由异常，请求优先走了无响应的 IPv6	尝试 `ping -4 baidu.com` 确认，然后禁用 IPv6
重启后 IP 丢失	配置未持久化或 NM 重新接管	检查 `/etc/sysconfig/network-scripts/ifcfg-ens160` 是否存在且内容正确；若用方案 A，确保 `ipv4.method` 为 `manual`
多虚拟机互相抢 IP	静态 IP 落在了 DHCP 池内	将静态 IP 调整至 DHCP 池外（如 `3~127`）；除非所有虚拟机均已手工配置静态 IP，否则不要关闭 VMware DHCP 服务

让手机连上热点直接使用主机的 Clash

Sat, 07 Mar 2026 00:00:00 GMT

Windows 上实现透明网关/全局路由的方案，核心思路是：让 Windows 热点的上游不是物理网卡，而是 Clash 的 TUN 虚拟网卡。这样手机连上热点后无需任何代理设置，所有流量强制经过 TUN。

原理

Windows 自带热点的默认逻辑是：热点网卡 → 物理网卡（WiFi/以太网）→ 互联网。
我们要改成：热点网卡 → Clash TUN 虚拟网卡 → 互联网。

⚠️ 已知限制：Clash Verge Rev 的 TUN 与 Windows ICS（网络共享）存在兼容性冲突，部分版本下同时开启会导致本机和热点设备都无法上网。以下方案在 Clash Verge Rev 2.5.1上可行。

操作步骤

1. 先开启 Clash Verge 的 TUN 模式

打开 Clash Verge → 设置 → 开启 TUN 模式
确保已安装服务模式（Service Mode），TUN 网卡正常创建（设备管理器中能看到如 Meta Tunnel 或 Clash 字样的虚拟网卡）
确认电脑本机可以正常翻墙

2. 再开启 Windows 移动热点

设置 → 网络和 Internet → 移动热点 → 开启
记住热点名称和密码，此时先不要连接手机

3. 关键：在 TUN 网卡上配置 ICS 共享

按 Win + R，输入 ncpa.cpl 回车，打开网络连接面板：

找到 Clash 的 TUN 虚拟网卡（名称通常包含 Meta Tunnel、Clash、mihomo 或 Wintun）
右键 → 属性 → 切换到共享选项卡
勾选 "允许其他网络用户通过此计算机的 Internet 连接来连接"
在 "家庭网络连接" 下拉框中，选择刚才开启热点生成的网卡（通常叫 本地连接*、Microsoft Wi-Fi Direct Virtual Adapter 或 Local Area Connection）
确定保存

顺序很重要：必须是 先开 TUN → 再开热点 → 最后设置共享。如果反过来，Windows 的 ICS 会与 TUN 冲突。

4. 手机连接热点

手机直接连接电脑热点，不需要设置任何代理（不要填 IP 和端口）
打开浏览器测试，所有流量应已被 TUN 透明接管

Trap、中断与系统调用详解

Mon, 23 Feb 2026 00:00:00 GMT

陷入 (Trap)

陷入是由程序主动执行特定指令（如系统调用指令 int 0x80 或 syscall）触发的同步事件。它让CPU从用户态切换到内核态，执行内核代码。

特点：同步（由程序主动发起）、软件驱动。
目的：实现用户程序向操作系统请求服务（如读写文件、创建进程）。

特权指令 (Privileged Instruction)

特权指令是只能在内核态（最高权限）下执行的指令，如修改页表基址寄存器、开关中断等。如果在用户态执行这些指令，CPU会触发一个保护异常（属于中断的一种），阻止操作。

特点：权限限制。
目的：保护系统资源不被用户程序随意修改，保证系统安全。

区别总结

维度	中断	陷入	特权指令
本质	事件（Event）	事件（Event）	指令（Instruction）
触发源	硬件/异常	软件（程序）	程序（试图执行）
同步性	异步	同步	同步
作用	响应外部变化	请求系统服务	管理硬件资源

关系与交互

当用户程序需要执行特权操作（如读写磁盘）时，它不能直接执行特权指令，而是通过陷入（系统调用）进入内核，由内核代为执行。
如果用户程序非法执行特权指令，会触发一个中断（保护异常），导致程序被终止。

触发陷入（进入内核）只需要执行一条特定的指令（如 `int 0x80`, `syscall`）。但，这条指令只是一个“门铃”，按下门铃后，执行的是操作系统内核中预先写好的、功能完整且复杂的服务例程

这是一个经典的交互流程，以“写文件”这个系统调用为例：

// 用户程序
int main() {
    write(fd, buffer, size); // 1. 调用库函数
    // ...
}

发生的步骤：

库函数包装：write 是C库函数，它的核心工作是：
- 将系统调用号（标识是write）、参数（fd, buffer, size）放到约定好的寄存器或栈中。
- 执行一条 trap 指令（如 syscall）。
- 这条指令是用户态最后一条指令。
陷入与切换：CPU执行 syscall 指令，硬件自动完成：
- 切换到内核态。
- 保存用户程序现场（寄存器、程序计数器等）。
- 跳转到操作系统内核预先设定好的统一入口（系统调用处理程序）。
内核执行复杂逻辑：现在完全在内核态运行，操作系统开始工作：
- 分发：根据放在寄存器里的系统调用号，查表找到对应的服务函数，比如 sys_write。
- 执行核心服务：sys_write 是操作系统内核里一个复杂的函数，它可能要做：
  - 参数检查（缓冲区是否有效？文件描述符是否合法？）。
  - 从用户态缓冲区拷贝数据到内核（因为内核不能直接操作用户内存）。
  - 文件系统操作：找到文件的inode，检查权限。
  - 驱动交互：调用硬盘驱动程序，将数据写入缓存或直接写入磁盘。
  - 进程调度：如果需要等待IO，可能会挂起当前进程，切换到其他进程运行。
- 所有这些，都是在内核态执行的特权代码，功能可以非常复杂。
返回结果：内核函数执行完毕后：
- 将返回值（成功写入的字节数或错误码）放入约定寄存器。
- 执行一条特殊的返回指令（如 sysret 或 iret）。
- CPU硬件恢复用户态现场，跳回用户程序 syscall 指令之后继续执行。

所以，核心思想是： trap 指令只是一把钥匙，打开了通往内核的大门。门后是一个由操作系统构建的、拥有完整功能和最高权限的“新世界”。用户程序通过“钥匙”请求这个世界里的“居民”（内核函数）来为自己完成复杂的特权工作。

计算机组成原理笔记

Fri, 20 Feb 2026 00:00:00 GMT

1. 计算机系统概述

1.1 冯·诺依曼架构特点

核心思想：存储程序，即将程序和数据存储在存储器中，CPU 按地址依次取出并执行。

主要特点：

五大部件：运算器、控制器、存储器、输入设备、输出设备
以存储器为中心：早期冯·诺依曼机以运算器为中心，现代计算机以存储器为中心
指令和数据均用二进制表示
指令和数据存储在同一存储器中（区别于哈佛架构）

1.2 软件与硬件的逻辑等价性

三个级别的语言：

语言类型	特点	翻译工具
高级语言	接近自然语言，如 C、Python	编译程序（编译器）
汇编语言	用助记符表示指令	汇编程序（汇编器）
机器语言	二进制代码，CPU 直接执行	无需翻译

编译程序：将高级语言一次性全部翻译成汇编语言或机器语言
解释程序：将高级语言翻译成机器语言（翻译一句执行一句）
ISA（指令集体系结构）：定义一台计算机可以支持的指令，以及每条指令的作用

2. 数据表示与运算

2.1 原码、反码、补码

定点整数的编码方式：

编码方式	正数	负数	特点
原码	符号位0 + 真值绝对值	符号位1 + 真值绝对值	有+0和-0
反码	与原码相同	符号位不变，数值位取反	有+0和-0
补码	与原码相同	反码+1	只有一个0，范围更大

补码的优势：

消除正负零：原码和反码中+0和-0表示不同，补码中只有一个0
加减法统一：减法可以转化为加法运算
表示范围扩大：8位补码可表示 -128 ~ +127

符号扩展：

正数扩展：高位补0
负数扩展：高位补1

2.2 溢出判断

溢出检测方法：

单符号位法：操作数符号相同，结果符号相反则溢出
双符号位法：结果的两个符号位不同则溢出

3. CPU 组成与功能

3.1 运算器

部件	全称	功能
ACC	累加计数器	存放操作数、运算结果
MQ	乘商寄存器	乘法运算时存放乘数，除法时存放商
X	通用寄存器	存放操作数
ALU	算术逻辑单元	实现各种算术运算、逻辑运算

3.2 控制器

部件	全称	功能
PC	程序计数器	存放下一条指令的地址
IR	指令寄存器	存放当前正在执行的指令
CU	控制单元	分析指令，给出控制信号

重要说明：

PC 自动指向下一条指令的地址（取指后 PC+1）
IR 保存当前正在执行的指令
CU 是控制器的核心，负责分析指令并产生控制信号

4. 主存储器

4.1 基本组成

存储体：数据在存储体内按地址存储

关键寄存器：

MAR（主存地址寄存器）：用于存放要访问的存储单元的地址，位数反映存储单元的个数
MDR（主存数据寄存器）：用于暂存从存储体读出或写入的数据，位数 = 存储字长

基本概念：

概念	定义
存储单元	每个存储单元存放一串二进制代码
存储字	存储单元中二进制代码的组合
存储字长	存储单元中二进制代码的位数
存储元	存储二进制的电子元件，每个存储元可存 1bit

示例：

MAR = 4位 → 共有 2^4 = 16 个存储单元
MDR = 16位 → 每个存储单元可存放 16bit
1个字（word）= 16bit
1字节（Byte）= 8bit，1B = 1Byte，1b = 1bit

5. 指令系统

5.1 指令格式

指令由操作码和地址码组成：

字段	内容
操作码（OP）	指明指令的操作类型（如加法、传送）
地址码（Ad）	指明操作数的地址或下一条指令的地址

地址码的结构：

| 操作码 | 地址码1 | 地址码2 | 地址码3 | 地址码4 |

5.2 寻址方式

寻址方式	说明	优点	缺点
立即寻址	地址码即为操作数	速度快	地址码位数限制操作数范围
直接寻址	地址码给出操作数的内存地址	简单	地址码位数限制寻址范围
间接寻址	地址码给出的内存地址中存放的是操作数的地址	寻址范围大	访存次数多，速度慢
寄存器寻址	地址码给出寄存器编号	速度快	寄存器数量有限
寄存器间接寻址	地址码给出的寄存器中存放的是操作数的地址	寻址范围大	需要访存

6. CPU 工作过程

6.1 指令执行流程

指令执行的基本步骤：

取指周期：
- (PC) → MAR：将程序计数器的内容送到主存地址寄存器
- M(MAR) → MDR：从存储体读取指令到主存数据寄存器
- (MDR) → IR：将指令送到指令寄存器
- OP(IR) → CU：将操作码送到控制单元分析
执行周期（以取数指令为例）：
- Ad(IR) → MAR：将地址码送到主存地址寄存器
- M(MAR) → MDR：从存储体读取数据
- (MDR) → ACC：将数据送到累加器

6.2 取数指令详解

"取数"指令的执行（从主存指定地址处取数）：

取指周期（必经步骤）：
    (PC) → MAR
    M(MAR) → MDR
    (MDR) → IR
    (PC) + 1 → PC
    OP(IR) → CU

执行周期（不同指令具体步骤不同）：
    Ad(IR) → MAR
    M(MAR) → MDR
    (MDR) → ACC

取指周期：所有指令都必须经历的阶段
执行周期：根据指令类型不同，具体操作不同
PC+1：在取指周期结束时自动执行，指向下一条指令

6.3 乘法指令执行

乘法指令的执行过程：

取指周期：
    (PC) → MAR → MDR → IR → CU

执行周期：
    Ad(IR) → MAR → MDR → MQ    # 取乘数到MQ
    (ACC) × (MQ) → ACC          # 乘法运算
    结果存入主存单元

注意：乘法运算结果可能超出 ACC 的位数，需要 MQ 辅助存储。

6.4 指令周期

CPU 区分指令和数据的依据：指令周期的不同阶段

阶段	取出的内容	用途
取指周期	指令	送到 IR 分析
执行周期	数据	送到 ACC 或其他寄存器

指令周期的组成：

取指周期：从存储器取出指令
间址周期（可选）：如果指令使用间接寻址
执行周期：执行指令的操作
中断周期（可选）：处理中断请求

7. 总结

7.1 核心知识点

冯·诺依曼架构：存储程序，五大部件，以存储器为中心
CPU 组成：运算器（ACC、MQ、X、ALU）+ 控制器（PC、IR、CU）
存储系统：MAR（地址）、MDR（数据）、存储体
指令系统：操作码 + 地址码，多种寻址方式
指令周期：取指周期 → 执行周期，PC 自动+1

7.2 易错点

PC 存放下一条指令的地址，不是当前指令的地址
IR 保存当前正在执行的指令
MAR 的位数决定存储单元的个数
MDR 的位数等于存储字长
取指周期取出的是指令，执行周期取出的是数据

李宏毅机器学习笔记：线性模型与梯度下降

Sun, 28 Dec 2025 00:00:00 GMT

本文是李宏毅机器学习深度学习系列课程第一节课的笔记，从最简单的线性模型一路串到深度学习。

第一节课基本概念

1. 最简单的模型：线性模型

我们要预测的值记为 y，最简单的预测方式是假设它和某个特征 x 成线性关系：

y = b + w * x

b：偏置（bias）
w：权重（weight）
x：输入特征（下标 x_1 表示第一个特征）

2. Loss：衡量一组参数好不好

有了模型，还需要一个标准来评判当前的 w 和 b 好不好，这个标准就是 Loss（损失函数）。

label：正确的值（真实标签）。
计算误差的方式：把模型预测值和 label 做差，累加起来（例如 MAE：e = |ŷ - y|）。

Loss 越小，说明这组 w、b 越好。要找到最小的 Loss，就是找到最优的 w 和 b，方法是梯度下降（Gradient Descent）。

3. 梯度下降：怎么更新参数

梯度下降的核心思路：算出 Loss 对每个参数的梯度（偏导），然后让参数沿着梯度的反方向走一小步，Loss 就会下降一点。反复迭代，直到 Loss 不再明显下降。上图展示的就是这个"更新参数"的过程。

4. 用更复杂的模型拟合真实数据

线性模型（一条直线）往往不足以描述真实数据。结合真实情况，需要改进模型，让它具备表达非线性关系的能力。

这就引出了下面要讲的 linear model 的扩展。

5. Linear Model 的扩展：用蓝色折线拼出红色曲线

模型名仍叫 linear model，但思路变了：

核心想法是：用多段蓝色的折线（分段线性函数）组合起来，逼近任意形状的红色曲线。

这种蓝色折线段的数学名字叫 Hard Sigmoid——形状像一个拉长的 S。

6. Hard Sigmoid 与激活函数

Hard Sigmoid 可以用一个连续函数 Sigmoid 来近似：

于是每一小段蓝色曲线可以写成：

y = c / (1 + exp(-(b + w * x)))
    = c * sigmoid(b + w * x)

问：为什么这里 `c` 要转置？

公式里的 c（以及 b、w）在多个特征/多段曲线堆叠时会变成向量/矩阵，写成 c^T 是为了把行向量转置成列向量，方便和后面的未知向量做矩阵乘法、合并起来。

这一步是在合并未知向量：把多段曲线的参数统一写成一个矩阵运算 y = b + c^T * sigmoid(b + w * x)，形式更紧凑，也便于后续推广到多层网络。

7. 多段曲线堆叠：还是用梯度下降更新参数

把多个 Hard Sigmoid 加起来后，未知参数变多了（每段都有自己的 c、b、w），但更新方法不变——还是梯度下降，只是参数更多。

8. Batch 与 Epoch：分段处理数据

把一整份训练数据分成多段（batch）逐段计算并更新参数。相关的两个概念：

batch：一次取一小批样本算梯度、更新一次参数。
epoch：把所有训练样本都过一遍叫一个 epoch。

这个概念在 YOLO 等模型的训练里也会用到，是深度学习训练的通用约定。

9. 两种激活函数

除了 Sigmoid，还有另一种常用的激活函数。课程里对比了两种：

（Sigmoid 和 ReLU，后者在现代网络里更常用，因为计算简单、收敛快。）

10. 把结构叠多层：Neural Network → Deep Learning

上面这种"输入 → 一组激活函数 → 输出"的结构可以多次重复堆叠（layers）：

单个这种计算单元叫 neuron（神经元）。
把很多 neuron 组织起来就叫 neural network（神经网络）。
当层数很多时，换了个名字：Many layers means Deep → Deep Learning（深度学习）。

小结

这节课从 y = b + w*x 出发，一步步展示了：怎么用 Loss 衡量模型好坏、怎么用梯度下降找最优参数、怎么用 Hard Sigmoid/Sigmoid 把线性模型扩展成能拟合复杂曲线的模型，最后通过堆叠 layers 自然引出了神经网络和深度学习。后续课程会在这个基础上讲网络结构、反向传播和具体任务。

二叉树基础笔记

Tue, 16 Dec 2025 00:00:00 GMT

本文整理二叉树的存储方式和线索二叉树的核心知识点。

1. 二叉树的存储

1.1 顺序存储

顺序存储使用数组存放完全二叉树，通过下标表示结点关系。

编号规则（从 1 开始）：

结点	公式
左孩子	`2i`
右孩子	`2i + 1`
父亲	`⌊i/2⌋`

特点：适合完全二叉树，空间利用率高；非完全二叉树会浪费空间。

1.2 链式存储（二叉链表）

链式存储使用指针连接结点，每个结点包含：

data：数据域
lchild：左孩子指针
rchild：右孩子指针

重要规律：空指针个数 = 结点数 + 1

1.3 三叉链表

在二叉链表基础上增加 parent 指针，方便向上查找。

类型	指针	特点
二叉链表	lchild, rchild	只能向下查找
三叉链表	lchild, rchild, parent	可双向查找

2. 链式存储代码实现

2.1 C++ 写法

struct BTNode {
    char data;
    BTNode *lchild;
    BTNode *rchild;
};

2.2 C 语言写法（typedef）

使用 typedef 给结构体起别名，简化声明：

typedef struct BTNode {
    char data;
    struct BTNode *lchild, *rchild;
} BTNode;

// 使用时不需要加 struct 前缀
BTNode a, *d;
BTNode *b = (BTNode*)malloc(sizeof(BTNode));

3. 线索二叉树

3.1 为什么需要线索化

二叉链表中存在大量空指针（结点数+1 个），造成浪费。

线索化：利用空指针存储前驱/后继信息，提高遍历效率。

3.2 线索化规则

空指针	指向
左空指针	前驱结点
右空指针	后继结点

3.3 线索标志位

如何区分指针指向的是孩子还是线索？增加 ltag 和 rtag 标志位：

标志位	值	含义
ltag/rtag	0	指向左/右孩子
ltag/rtag	1	指向前驱/后继（线索）

结点结构：

typedef struct BTNode {
    char data;
    struct BTNode *lchild, *rchild;
    int ltag, rtag;  // 线索标志
} BTNode;

3.4 中序线索二叉树示例

对二叉树进行中序线索化后：

中序序列：B → D → A → C
空指针被利用为前驱/后继线索

4. 总结

存储方式	优点	缺点
顺序存储	访问简单，适合完全二叉树	非完全树浪费空间
二叉链表	灵活，节省空间	空指针浪费
三叉链表	可双向查找	多一个指针开销
线索二叉树	利用空指针，遍历高效	结构复杂

关键点：

空指针个数 = 结点数 + 1
线索化利用空指针存储前驱/后继
ltag/rtag 用于区分孩子和线索

链队列实现

Fri, 14 Nov 2025 00:00:00 GMT

队列是一种**先进先出（FIFO）**的线性数据结构，只允许在一端（队尾）插入、另一端（队头）删除。链队列用带头结点的单链表实现，相比顺序队列（循环数组）不会存在假溢出问题，空间按需分配。

数据结构定义

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

typedef char DataType;

typedef struct LQNode {
    DataType data;
    struct LQNode *next;
} LQNode, *LinkedQNode; // 链队列结点的类型

typedef struct {
    struct LQNode *front, *rear; // 头指针和尾指针
} LQueue, *LinkedQueue; // 将头、尾指针封装在一起的链队列

// [算法 3.21]    创建一个带头结点的空队列
void QueueInit(LinkedQueue *Q) {  //构造一个空队列 Q
    *Q = (LinkedQueue)malloc(sizeof(LQueue)); // 分配队列结构体空间
    if (!(*Q)) return; // 分配失败
    (*Q)->front = (LQNode*)malloc(sizeof(LQNode)); // 分配头结点
    if (!((*Q)->front)) {
        free(*Q);
        *Q = NULL;
        return;
    }
    (*Q)->front->next = NULL; // 头结点next置空
    (*Q)->rear = (*Q)->front; // front和rear都指向头结点，表示队列为空
}

// [算法 3.22]    入队列
bool QueueIn(LinkedQueue Q, DataType x) {  //插入元素 x 为 Q 的队尾元素
    if (!Q) return false;
    LQNode *node = (LQNode*)malloc(sizeof(LQNode)); // 新建结点
    if (!node) return false;
    node->data = x;
    node->next = NULL;
    Q->rear->next = node; // 原队尾结点next指向新结点
    Q->rear = node; // rear指向新结点
    return true;
}

// [算法 3.23]    出队列
bool QueueOut (LinkedQueue Q, DataType *x){  //若队列不空 ,则删除 Q 的队头元素
    if (!Q || Q->front == Q->rear) return false; // 队空
    LQNode *p = Q->front->next; // 队头元素
    *x = p->data; // 取数据
    Q->front->next = p->next; // 头结点next指向下一个结点
    if (Q->rear == p) Q->rear = Q->front; // 若出队后队空，rear回到头结点
    free(p);
    return true;
}

// [算法 3.24]    判断队列是否为空
bool QueueEmpty(LinkedQueue Q) {  //判断队列 Q 是否为空
    if (!Q) return true;            // 队列指针为空
    return Q->front == Q->rear;     // 头尾指针相遇即为空
}

//清空队列
void Empty(LinkedQueue Q)
{
    while (Q->front != Q->rear)
    {
        LQNode * p = Q->front->next;    //取得队列第一个元素指针
        Q->front->next = p->next;   //修改队头指针指向
        free(p);
        if(Q->front->next == NULL) //只有一个元素时 ,出队后队空 ,此时还要修改队尾指针
            Q->rear = Q->front;
    }
}

// 释放队列
void FreeQueue(LinkedQueue *Q) {
    if (*Q == NULL) return; // 如果队列为空，直接返回

    LQNode * current = (*Q)->front; // 从头节点开始
    LQNode * temp;

    while (current != NULL) {
        temp = current; // 保存当前节点
        current = current->next; // 移动到下一个节点
        free(temp); // 释放当前节点
    }

    free(*Q); // 最后释放队列结构体本身
    *Q = NULL; // 将队列指针设为NULL，防止悬挂指针
}

//获取队首元素
void GetQueue(LinkedQueue Q)
{
    if (Q->front == NULL)
    {
        printf("None\n");
        return;
    }
    else
       printf("%c\n", Q->front->next->data);

}

int main()
{
    DataType c,x;
    LinkedQueue Q = NULL;
    QueueInit(&Q);
    while (1)
    {
        scanf(" %c", &c);
        if (c == 'E')
        {
            scanf(" %c", &x);
            QueueIn(Q, x);
        }
        else if (c == 'C')
        {
            Empty(Q);
        }
        else if (c == 'G')
        {
            GetQueue(Q);
        }
        else if (c == 'D')
        {
            //dequeue(m);
            if(QueueOut(Q, &x))
             printf("%c\n", x);
          else
             printf("None\n");
        }
        else if (c == 'Q')
        {
            break;
        }
    }
    FreeQueue(&Q);
    return 0;
}

这里详细讲一下 (*Q)-> 的含义和作用：

二级指针解引用 `(*Q)->`

参数类型
QueueInit(LinkedQueue *Q) 里的 Q 是“指向队列指针的指针”。
也就是：LinkedQueue 是 LQueue *，LinkedQueue *Q 就是 LQueue **Q。
解引用
*Q 表示“取出 Q 指向的内容”，也就是实际的队列指针（LQueue *）。
例如：*Q = malloc(...)，就是让外部的队列指针指向新分配的队列结构体。
访问结构体成员
(*Q)->front 表示“队列的头指针”。
因为 *Q 是 LQueue *，所以用 -> 访问结构体成员。
为什么不用 Q->front
如果直接用 Q->front，那 Q 必须是 LQueue *，而不是 LQueue **。
但这里 Q 是指向指针的指针，所以要先解引用，再访问成员。

举例说明：

void QueueInit(LinkedQueue *Q) {
    *Q = (LinkedQueue)malloc(sizeof(LQueue)); // 分配队列结构体
    (*Q)->front = (*Q)->rear = (LQNode *)malloc(sizeof(LQNode)); // 分配头结点
    (*Q)->front->next = NULL; // 头结点next置空
}

*Q：拿到实际的队列指针
(*Q)->front：访问队列的头指针
(*Q)->rear：访问队列的尾指针

总结：(*Q)-> 是先解引用拿到队列指针，再用 -> 访问结构体成员。这样才能正确初始化和操作队列。

用指针返回出队值 `*x = p->data`

出队函数签名是 QueueOut(LinkedQueue Q, DataType *x)，其中 *x = p->data; 这一行不带 * 不行。

原因是：要把出队的元素值“带出来”给主程序用，必须用指针参数（DataType *x），在函数里通过 *x = p->data; 赋值。如果只用值参数（如 DataType x），函数内部的赋值不会影响主程序变量，主程序拿不到出队的值。这就是 C 语言“用指针返回结果”的常规做法——和 scanf("%d", &n) 传 &n 一个道理。

Git 使用指南

Fri, 14 Nov 2025 00:00:00 GMT

安装与配置

安装

Windows：git-scm.com 下载安装包，按向导完成
macOS：brew install git 或安装 Xcode Command Line Tools

用户信息配置

git config --global user.name "你的名字"
git config --global user.email "你的邮箱"

SSH Key 配置

# 生成密钥对
ssh-keygen -t ed25519 -C "你的邮箱"

# 查看公钥，复制到 GitHub/GitLab 的 SSH Keys 设置中
cat ~/.ssh/id_ed25519.pub

# 测试连接
ssh -T git@github.com

基础工作流

# 初始化仓库
git init

# 克隆远程仓库
git clone git@github.com:user/repo.git

# 查看状态
git status

# 添加到暂存区
git add .                # 所有文件
git add file.txt         # 指定文件

# 提交
git commit -m "提交说明"

# 推送到远程
git push origin main

# 拉取远程更新
git pull origin main

# 查看提交历史
git log --oneline

分支管理

# 查看分支
git branch

# 创建并切换分支
git checkout -b feature/xxx
# 或用新版命令
git switch -c feature/xxx

# 切换分支
git checkout main

# 合并分支（在 main 上合并 feature）
git merge feature/xxx

# 删除分支
git branch -d feature/xxx

解决合并冲突

合并时如果出现冲突，手动编辑冲突文件，保留需要的内容，然后：

git add .
git commit -m "解决合并冲突"

常用技巧

.gitignore

在仓库根目录创建 .gitignore 文件，列出不需要跟踪的文件：

# 依赖目录
node_modules/
__pycache__/

# 编辑器配置
.vscode/
.idea/

# 系统文件
.DS_Store
Thumbs.db

# 构建产物
dist/
build/

移除跟踪但保留本地文件

# 从 Git 跟踪中移除（不会删除本地文件）
git rm --cached .obsidian/app.json

# 或移除整个目录
git rm --cached -r .obsidian/

# 加入 .gitignore 防止再次跟踪
echo ".obsidian/" >> .gitignore
git add .gitignore
git commit -m "移除配置文件跟踪"

stash 暂存工作区

# 暂存当前修改
git stash

# 恢复暂存
git stash pop

# 查看暂存列表
git stash list

撤销操作

# 撤销工作区修改（未 add）
git checkout -- file.txt

# 撤销暂存（已 add 未 commit）
git reset HEAD file.txt

# 撤销最近一次提交（保留修改）
git reset --soft HEAD~1

图形化工具

PyCharm 集成：内置 Git 支持，VCS 菜单直接操作
VSCode 集成：左侧源代码管理面板，支持 diff、提交、推送

二进制表示与数制转换

Thu, 11 Sep 2025 00:00:00 GMT

本文整理二进制表示、数制转换以及原码/反码/补码/移码的核心知识点。

1. 数制基础

1.1 常用数制

数制	基数	数码	示例
二进制	2	0, 1	1101
八进制	8	0-7	15
十进制	10	0-9	13
十六进制	16	0-9, A-F	D

1.2 数制转换

十进制 → 二进制（除2取余法）

对整数部分除2取余，逆序排列：

示例：256 转二进制

除法	商	余数
256 ÷ 2	128	0
128 ÷ 2	64	0
64 ÷ 2	32	0
32 ÷ 2	16	0
16 ÷ 2	8	0
8 ÷ 2	4	0
4 ÷ 2	2	0
2 ÷ 2	1	0
1 ÷ 2	0	1

结果：100000000

二进制 → 十进制（按权展开）

将每一位乘以 2 的对应次幂，求和。

示例：

二进制	计算	十进制
0	0	0
11101100	128+64+32+8+4	236
11111111	128+64+32+16+8+4+2+1	255

二进制 ↔ 八进制（三位一组）

规则：

二进制 → 八进制：从右往左每三位一组，转为一位八进制，不足三位左边补零
八进制 → 二进制：每一位八进制转为三位二进制

示例：1110 0101 1101 转八进制

分组：111 001 011 101
转八进制：7  1  3  5
结果：7135

二进制 ↔ 十六进制（四位一组）

规则：

二进制 → 十六进制：从右往左每四位一组，转为一位十六进制
十六进制 → 二进制：每一位十六进制转为四位二进制

示例：1110 0101 1101 转十六进制

分组：1110 0101 1101
转十六进制：E  5  D
结果：E5D

2. 原码、反码、补码

2.1 原码

定义：最高位为符号位（0正1负），其余位为数值位。

示例（8位）：

十进制	原码
+1	00000001
-1	10000001
+127	01111111
-127	11111111

2.2 反码

定义：

正数：与原码相同
负数：符号位不变，数值位按位取反

示例：

十进制	原码	反码
+1	00000001	00000001
-1	10000001	11111110

2.3 补码

定义：

正数：与原码相同
负数：反码 + 1

示例：

十进制	原码	反码	补码
+1	00000001	00000001	00000001
-1	10000001	11111110	11111111

为什么计算机用补码？

加减法统一处理，无需区分符号
0 的表示唯一（原码有 +0 和 -0 两种）

2.4 移码

定义：补码的符号位取反。

用途：浮点数的阶码表示。

2.5 对比表格

编码	+0	-0	范围（8位）
原码	00000000	10000000	-127 ~ +127
反码	00000000	11111111	-127 ~ +127
补码	00000000	00000000（唯一）	-128 ~ +127
移码	10000000	10000000（唯一）	-127 ~ +128

3. 定点数表示

3.1 定点整数

小数点固定在最低位之后，表示整数。

3.2 定点小数

小数点固定在符号位之后，表示纯小数。

习题：已知 x = -53/64，用 8 位定点机器码表示原码。

解析：

计算 -53/64 的二进制：
- 53 = 32 + 16 + 4 + 1 = 110101
- 53/64 = 0.110101（二进制）
- -53/64 = -0.110101
8 位定点小数原码：
- 符号位：1（负数）
- 数值位：11010100（补零到 7 位）
- 结果：1.11010100

答案：A（1.11010100）

4. 总结

数制转换速查

转换	方法
十进制 → 二进制	除2取余，逆序排列
二进制 → 十进制	按权展开求和
二进制 → 八进制	三位一组
二进制 → 十六进制	四位一组

原反补移码对比

编码	正数	负数
原码	不变	符号位+数值位
反码	不变	符号位不变，数值位取反
补码	不变	反码+1
移码	补码符号位取反	补码符号位取反

关键点：

计算机内部使用补码存储整数
0 的补码表示唯一
定点小数原码要注意小数点位置

机器学习入门：从 ML 概述到 KNN 分类

Fri, 15 Aug 2025 00:00:00 GMT

人工智能、机器学习与深度学习的关系

人工智能（AI）
- 概念起源：1950年代
- 目标：创建能够达到人类智慧水平的机器
- 实现方式：有多种方法，机器学习是其中之一
机器学习（ML）
- 发展时间：1980年代开始兴起
- 地位：实现人工智能的一种重要方法
- 发展推动因素：数据量增长、硬件设施发展、算法进步
深度学习（DL）
- 发展时间：2010年左右开始热门
- 地位：机器学习的一个重要分支
- 包含算法：CNN、RNN等

关系总结：深度学习 ⊂ 机器学习 ⊂ 人工智能

机器学习基本概念

机器学习解决问题的基本流程

训练样本：N个已知样本数据
特征提取：从样本中提取有用属性
算法学习：使用算法学习特征规律
模型构建：形成可预测的模型
预测未知：对新数据进行预测

机器学习分类

监督学习：训练样本包含标签，应用：分类、回归问题
无监督学习：训练样本不包含标签，应用：聚类分析

鸢尾花分类项目实践

数据集

样本数量：150个
特征数量：4个（花萼长度、花萼宽度、花瓣长度、花瓣宽度）
分类类别：3种（山鸢尾、变色鸢尾、维吉尼亚鸢尾）

KNN 分类算法基础

scikit-learn 基础

数据格式要求：
- 特征X必须是数值矩阵（如150×4）
- 标签y必须是数值向量（如150个0/1/2）
数据预处理：

iris_data['Label'] = iris_data['Species'].map({
    'Iris-setosa': 0,
    'Iris-versicolor': 1,
    'Iris-virginica': 2
})

数据划分：

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=10)

KNN 算法原理

工作原理：
- 计算测试样本与所有训练样本的距离
- 找出距离最近的K个邻居
- 根据邻居的多数类别确定预测结果
K值影响：
- K=1：只考虑最近的一个样本（容易受噪声影响）
- K增大：决策边界更平滑（可能忽略局部特征）

scikit-learn 实现流程

from sklearn.neighbors import KNeighborsClassifier

# 创建模型（默认K=5）
knn = KNeighborsClassifier()

# 训练模型
knn.fit(X_train, y_train)

# 评估与预测
accuracy = knn.score(X_test, y_test)
y_pred = knn.predict(X_new)

KNN 算法深入与参数调优

相似性度量（距离计算）

明可夫斯基距离：distance = (∑|x_i - y_i|^p)^(1/p)
- p=2：欧式距离（默认）
- p=1：曼哈顿距离

KNeighborsClassifier(metric='minkowski', p=2)  # 欧式距离
KNeighborsClassifier(metric='minkowski', p=1)  # 曼哈顿距离

模型参数分类

超参数：需要人工预先设定（如K值、距离度量方式）
模型参数：通过训练数据自动学习得到（如线性回归系数）

KNN 优缺点

优点：

原理简单直观，易于实现
无需训练过程（惰性学习）
对数据分布没有假设

缺点：

计算量大（需计算与所有训练样本的距离）
对高维数据效果差（维度灾难）
需要合理选择K值和距离度量
对不平衡数据敏感

实践：不同 K 值的分类效果

from sklearn.neighbors import KNeighborsClassifier

k_values = [3, 5, 10]
selected_features = ['SepalLengthCm', 'SepalWidthCm']

for k in k_values:
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train[selected_features], y_train)
    accuracy = knn.score(X_test[selected_features], y_test)
    print(f'K={k}时准确率: {accuracy:.2%}')

实验结果（仅使用花萼长宽两个特征）：

K=3：准确率66%
K=5：准确率68%
K=10：准确率78%

关键知识点总结

距离度量选择：欧式距离适合大多数情况，曼哈顿距离对异常值更鲁棒
K值选择原则：一般取3-20之间的奇数（避免平票），通过交叉验证确定最优值
特征选择影响：不同特征组合会影响分类效果

CDMA 与 CSMA 协议笔记

Fri, 01 Aug 2025 00:00:00 GMT

1. 信道复用技术

1.1 码分复用 CDM

CDMA 原理：

每个站点被分配唯一的 m bit 码片序列（Chip Sequence）
码片序列相互正交：不同站点的码片内积为 0
发送数据时：发送 1 → 发送码片序列；发送 0 → 发送码片序列的反码

示例：

A 站码片序列：(-1, -1, +1, +1, -1, +1, +1, +1)
B 站码片序列：(-1, +1, -1, +1, +1, +1, -1, -1)
A 发送 1，B 发送 0，C 未发送
接收端收到的信号 = A 的码片 - B 的码片

1.2 CDMA 例题解析

判断方法：

将接收到的序列与各站点码片进行内积运算
结果为 +1：发送了比特 1
结果为 -1：发送了比特 0
结果为 0：未发送数据

计算示例：

收到的序列：(-1, +1, +3, -1, -3, -1, +3, +1)

与 A 站码片内积：
(-1)×(-1) + (+1)×(-1) + (+3)×(+1) + (-1)×(+1) + 
(-3)×(-1) + (-1)×(+1) + (+3)×(+1) + (+1)×(+1)
= 1 - 1 + 3 - 1 + 3 - 1 + 3 + 1 = 8 → 结果为 +1 → A 发送了 1

2. CSMA/CD 协议（有线以太网）

2.1 帧发送流程

发送流程：

封装成帧，重传计数器 c = 0
载波监听：信道空闲 96 比特时间？
- 是：发送帧的第一比特
- 否：继续监听
碰撞检测：边发送边监听
- 有碰撞：发送 32 或 48 比特干扰信号
- 无碰撞：继续发送下一比特
检测到碰撞后的处理：
- 发送干扰信号
- 等待随机时间 T
- 使用二进制指数退避算法计算退避时间
- c = c + 1
- 若 c < 15：返回重传
- 若 c ≥ 15：报告信道繁忙

2.2 帧接收流程

接收流程：

监听信道：信道活跃？
- 否：继续监听
- 是：开始接收帧
接收完成后检查：
- 帧太小（< 64 字节）→ 认为遭遇碰撞，丢弃
- 帧的目的 MAC 地址与本机相同或是广播地址？
- 使用 CRC 检查帧是否出现误码
校验正确 → 接收该帧；校验错误 → 丢弃

2.3 CSMA/CD 知识点总结

关键概念：

概念	说明
争用期	碰撞检测的最长时间 = 2τ（端到端往返时间）
最小帧长	64 字节（512 bit），保证能检测到碰撞
最大帧长	1518 字节（1500 数据 + 18 首尾）
二进制指数退避	第 k 次重传，从 {0, 1, ..., 2^k - 1} 随机选择等待时间

适用场景：

早期共享式以太网（集线器连接）
现在的交换式以太网已很少使用

2.4 CSMA/CD 考研真题

题目：在采用 CSMA/CD 协议的网络中，传输速率为 1Gbps，信号传播速率为 200000km/s，若最小帧长减少 800 比特，则最远的两个站点之间的距离至少需要如何变化？

解题思路：

最小帧长 = 争用期 × 数据传输速率
争用期 = 2 × 距离 / 传播速率
最小帧长减少 → 争用期减小 → 距离减小

3. CSMA/CA 协议（无线局域网）

3.1 退避算法时序

CSMA/CA 工作原理：

DIFS（DCF 帧间间隔）：发送前等待 DIFS 时间
退避算法：信道忙时，冻结退避计时器；信道空闲时，继续倒计时
发送帧：退避计时器归零后发送
等待确认：接收方收到帧后发送 ACK

与 CSMA/CD 的区别：

CSMA/CD：边发送边检测碰撞
CSMA/CA：发送前尽量避免碰撞（无线环境无法有效检测碰撞）

3.2 虚拟载波监听

RTS/CTS 机制：

发送方先发送 RTS（Request to Send）帧
接收方回应 CTS（Clear to Send）帧
RTS/CTS 帧中包含数据帧的持续时间
其他站点监听到 RTS/CTS 后，在该时间段内保持静默

作用：

解决隐藏站问题（A 和 C 都能与 B 通信，但 A 和 C 互相听不到）
减少碰撞概率

3.3 CSMA/CA 考研真题

题目：以下哪种协议用于无线局域网的碰撞避免？

答案：CSMA/CA

对比：

协议	适用场景	碰撞处理
CSMA/CD	有线以太网	检测碰撞后重传
CSMA/CA	无线局域网	发送前避免碰撞

3.4 介质访问控制总结

静态划分信道：

FDM（频分复用）
TDM（时分复用）
WDM（波分复用）
CDM（码分复用）

动态接入控制：

争用型：CSMA/CD、CSMA/CA（可能发生冲突）
受控型：令牌传递（不会发生冲突）

4. 总结

核心知识点

CDMA：码片序列正交，内积判断发送数据
CSMA/CD：边发送边检测碰撞，二进制指数退避
CSMA/CA：发送前避免碰撞，RTS/CTS 解决隐藏站
最小帧长：64 字节（争用期 × 传输速率）
适用场景：CSMA/CD 用于有线，CSMA/CA 用于无线

物理层与数据链路层笔记

Fri, 01 Aug 2025 00:00:00 GMT

1. 编码与调制

1.1 编码与调制概述

基本概念：

基带信号：数字设备产生的原始信号（如计算机输出的矩形波）
宽带信号：经过调制后的信号（适合远距离传输）

编码方式：

数字数据 → 数字信号：使用数字编码（如 NRZ、曼彻斯特编码）
数字数据 → 模拟信号：需要调制（ASK、FSK、PSK、QAM）
模拟数据 → 数字信号：需要采样、量化、编码（PCM）
模拟数据 → 模拟信号：可以使用调制放大

1.2 调制方式

基本调制方式：

调制方式	英文	原理	特点
调幅 AM	Amplitude Shift Keying	改变载波振幅	实现简单，抗干扰差
调频 FM	Frequency Shift Keying	改变载波频率	抗干扰好，带宽大
调相 PM	Phase Shift Keying	改变载波相位	抗干扰好，实现复杂

混合调制：

QAM（正交振幅调制）：结合调幅和调相
QAM-16：16 种状态，每个码元携带 4 bit
QAM-64：64 种状态，每个码元携带 6 bit

码元：

在使用时间域的波形表示数字信号时，代表不同离散数值的基本波形
一个码元可以携带多个 bit 的信息

2. 信道特性

2.1 奈氏准则（理想低通信道）

奈氏准则：

理想低通信道的最高码元传输速率 = 2W Baud
其中 W 是信道带宽（Hz）

含义：

在带宽为 W Hz 的理想低通信道中，码元传输速率为 2W Baud
每个码元可以携带 n bit 信息（n = log2(V)，V 为离散等级数）
最大数据传输速率 = 2W × log2(V) bps

示例：

信道带宽 W = 3000 Hz
最高码元传输速率 = 2 × 3000 = 6000 Baud
若使用 4 级量化（V = 4），则最高数据速率 = 6000 × log2(4) = 12000 bps

2.2 香农定理（有噪声信道）

香农定理：

信道的极限数据传输速率 = W × log2(1 + S/N) bps
其中 W 是带宽（Hz），S/N 是信噪比

信噪比：

通常用分贝（dB）表示：信噪比(dB) = 10 × log10(S/N)
例如：信噪比 30dB → S/N = 1000

含义：

信道带宽和信噪比决定了信道的极限传输速率
实际传输速率不可能超过这个极限值

示例：

信道带宽 W = 3000 Hz，信噪比 = 30dB（S/N = 1000）
极限数据速率 = 3000 × log2(1 + 1000) ≈ 3000 × 10 = 30000 bps

2.3 奈氏准则与香农定理的关系

准则	适用条件	决定因素
奈氏准则	理想无噪声信道	带宽 W
香农定理	有噪声信道	带宽 W + 信噪比 S/N

实际应用：

通常同时考虑两个准则
取两者中较小的值作为极限数据速率
若题目未指明信道类型，默认按低通信道处理

3. 常用编码方式

3.1 编码类型对比

编码	类型	特点
不归零编码 NRZ	非自同步	高电平=1，低电平=0；需要额外时钟同步
归零编码 RZ	自同步	每个码元中间跳变到零电平；编码效率低
反向不归零编码 NRZI	自同步	遇 1 翻转，遇 0 不变；USB 使用
差分曼彻斯特编码	自同步	位中间跳变=0，位开始跳变=1；局域网使用
曼彻斯特编码	自同步	位中间跳变：低→高=1，高→低=0；以太网使用

3.2 曼彻斯特编码详解

编码规则：

每个码元中间都有跳变（用于时钟同步）
高→低跳变：表示 1
低→高跳变：表示 0

优点：

自带时钟同步信号
抗干扰能力强

缺点：

编码效率只有 50%（每个码元只携带 1 bit）

4. 数据链路层

4.1 封装成帧

封装成帧：在数据链路层，将网络层交付的协议数据单元添加帧头和帧尾，形成帧。

帧的结构：

帧首部 | 数据部分 | 帧尾部

透明传输：

数据链路层对数据部分的内容没有任何限制
就像数据链路层不存在一样

字节填充（面向字节的物理链路）：

使用转义字符实现透明传输
数据中出现与定界符相同的字节时，在前面插入转义字符

比特填充（面向比特的物理链路）：

使用标志字段（01111110）作为帧定界符
数据中出现连续 5 个 1 时，自动插入一个 0

最大传送单元 MTU：

每一种链路层协议都规定了数据部分的最大长度
以太网的 MTU = 1500 字节

4.2 差错检测

XOR 运算：

数据链路层使用异或运算进行简单的差错检测
发送方：将数据按位异或，得到校验码
接收方：将数据和校验码一起异或，结果为 0 表示无差错

CRC（循环冗余校验）：

使用生成多项式进行模 2 除法
发送方：数据 + FCS（CRC 校验码）
接收方：用同样的生成多项式除，余数为 0 表示无差错

特点：

只能检测错误，不能纠正错误
检错能力强，实现简单
广泛应用于以太网、WiFi 等

5. 总结

核心知识点

编码调制：数字数据→数字信号用编码，数字数据→模拟信号用调制
奈氏准则：理想低通信道最高码元速率 = 2W Baud
香农定理：有噪声信道极限速率 = W × log2(1 + S/N)
曼彻斯特编码：位中间跳变表示 0/1，自带时钟同步
封装成帧：添加帧头帧尾，透明传输，MTU 限制
差错检测：CRC 校验，只能检错不能纠错

可靠传输协议笔记

Fri, 01 Aug 2025 00:00:00 GMT

1. 可靠传输基本概念

1.1 传输差错类型

使用差错检测技术（如 CRC），接收方可以检测出帧在传输过程中是否产生误码。

传输差错类型：

比特差错：数据中某些比特发生了翻转
分组丢失：数据包在网络中丢失
分组失序：数据包到达顺序与发送顺序不一致
分组重复：同一数据包被重复传输

可靠传输要求：

有线链路：误码率低，通常不要求可靠传输（上层处理）
无线链路：误码率高，必须提供可靠传输服务

2. 停止-等待协议（Stop-and-Wait）

2.1 工作原理

发送方：

发送一个数据分组
暂停发送，等待接收方的确认
收到 ACK 后，发送下一个分组

接收方：

收到数据分组后，进行差错检测
若正确：发送 ACK 确认
若错误：丢弃该分组，不发送任何响应

2.2 异常处理

确认丢失：

发送方超时未收到 ACK → 重新发送数据分组
接收方收到重复分组 → 丢弃但仍发送 ACK

确认迟到：

发送方超时重传 → 收到迟到的 ACK
发送方忽略迟到的 ACK，继续发送下一个分组

2.3 信道利用率

公式：

U = T_D / (T_D + RTT + T_A)

其中：
- T_D：发送数据分组的时间
- RTT：往返时延
- T_A：发送确认分组的时间

特点：

信道利用率低（大部分时间在等待确认）
适用于数据量小、实时性要求不高的场景

3. 回退N帧协议（Go-Back-N）

3.1 发送方工作原理

窗口机制：

发送窗口大小 W_T：1 < W_T ≤ 2^n - 1（n 为序号位数）
发送方可以在未收到确认的情况下，连续发送 W_T 个分组

超时重传：

若某个分组超时，从该分组开始的所有已发送但未确认的分组都需要重传
这就是"回退N帧"名称的由来

3.2 接收方工作原理

接收窗口：

接收窗口大小 W_R = 1（只能按序接收）
只接受序号在接收窗口内且无误码的分组

累计确认：

接收方不必每个分组都发送 ACK
可以在收到多个正确分组后，发送一个累计确认
例如：收到 0、1、2 后，发送 ACK 2 表示 0、1、2 都已正确接收

3.3 优缺点

优点：

实现简单
信道利用率比停止-等待协议高

缺点：

超时重传时，需要回退重传多个分组（即使后续分组已正确接收）
适用于误码率低的网络

4. 选择重传协议（Selective Repeat）

4.1 发送方工作原理

窗口机制：

发送窗口大小 W_T：1 < W_T ≤ 2^(n-1)
可以在未收到确认的情况下，连续发送 W_T 个分组

超时重传：

只重传超时的分组（不回退）
对已正确接收的分组发送确认

4.2 接收方工作原理

接收窗口：

接收窗口大小 W_R > 1（可以乱序接收）
接收方可以接受未按序到达但无误码的分组

逐个确认：

接收方对每个正确接收的分组单独发送 ACK
不使用累计确认

4.3 优缺点

优点：

只重传出错的分组，效率更高
适用于误码率较高的网络

缺点：

实现复杂
接收方需要缓存乱序到达的分组

4.4 三种协议对比

特性	停止-等待	回退N帧	选择重传
发送窗口	1	1 < W_T ≤ 2^n - 1	1 < W_T ≤ 2^(n-1)
接收窗口	1	1	W_R > 1
确认方式	逐个确认	累计确认	逐个确认
重传方式	重传单个	回退重传	选择重传
实现复杂度	低	中	高

5. PPP 协议

5.1 PPP 帧格式

F(7E) | 地址(FF) | 控制(03) | 协议 | 信息 | FCS | F(7E)

字段说明：

F（标志字段）：0x7E，帧定界符
地址字段：0xFF（广播地址）
控制字段：0x03
协议字段：标识信息字段的内容类型
FCS：帧校验序列（CRC 校验）

5.2 PPP 工作流程

建立阶段：

LCP（链路控制协议）协商链路参数
认证阶段（可选）：PAP 或 CHAP
NCP（网络控制协议）协商网络层参数

数据传输阶段：

封装数据帧
透明传输（字节填充或比特填充）

终止阶段：

LCP 关闭链路
释放连接

5.3 PPP 特点

简单可靠
支持多种网络层协议
适用于点对点链路（如拨号上网、PPPoE）

6. 总结

核心知识点

停止-等待：简单但效率低，信道利用率低
回退N帧：连续发送，累计确认，超时回退重传
选择重传：连续发送，逐个确认，选择性重传
PPP：点对点协议，简单可靠，支持多种网络层协议

选择依据

数据量小、实时性要求不高 → 停止-等待
误码率低的网络 → 回退N帧
误码率高的网络 → 选择重传
点对点链路 → PPP

路由聚合与路由选择协议

Fri, 01 Aug 2025 00:00:00 GMT

本文整理路由聚合、子网掩码以及常见路由选择协议的核心知识点。

1. 路由聚合（构造超网）

1.1 什么是路由聚合

路由聚合是将多条路由记录合并为一条的过程，目的是减少路由表条目，提高路由效率。

1.2 聚合过程详解

以 5 条路由记录为例：

原始路由	地址段
172.1.4.0/25	172.1.4.0 ~ 172.1.4.127
172.1.4.128/25	172.1.4.128 ~ 172.1.4.255
172.1.5.0/24	172.1.5.0 ~ 172.1.5.255
172.1.6.0/24	172.1.6.0 ~ 172.1.6.255
172.1.7.0/24	172.1.7.0 ~ 172.1.7.255

聚合步骤：

找共同前缀：所有地址的前 22 位相同（172.1.4.0）
计算聚合地址块：172.1.4.0/22
5 条路由 → 1 条路由

1.3 最长前缀匹配原则

当路由器转发数据包时，如果存在多条匹配的路由，选择前缀最长的那条。

网络前缀越长，地址块越小，路由越具体。

原因：更精确的路由能确保数据包到达正确的目的地。

2. 子网掩码：FLSM vs VLSM

2.1 定长子网掩码（FLSM）

特点	说明
定义	使用同一子网掩码划分所有子网
划分方式	不灵活，只能划分 2^n 个子网
IP 分配	每个子网 IP 数量相同
缺点	容易造成 IP 地址浪费

2.2 变长子网掩码（VLSM）

特点	说明
定义	使用不同子网掩码划分不同子网
划分方式	灵活，可按需分配
IP 分配	每个子网 IP 数量可以不同
优势	减少 IP 地址浪费

2.3 对比总结

对比项	FLSM	VLSM
子网掩码	统一	可变
灵活性	低	高
IP 利用率	低	高
适用场景	简单网络	复杂网络

3. 常见路由选择协议

3.1 协议分类

路由选择协议分为两大类：

内部网关协议（IGP）：用于自治系统内部
外部网关协议（EGP）：用于自治系统之间

3.2 内部网关协议（IGP）

RIP（路由信息协议）

基于距离向量算法
因特网上最早使用的路由协议
简单但收敛慢，适用于小型网络
最大跳数限制为 15 跳（16 跳视为不可达）
每 30 秒向邻居广播整个路由表

IGRP（内部网关路由协议）

思科私有协议
已被 EIGRP 替代

EIGRP（增强型内部网关路由协议）

思科私有的混合型协议
结合距离向量和链路状态的优点

OSPF（开放最短路径优先）

基于链路状态算法
广泛使用的 IGP 协议
收敛快，支持大型网络

IS-IS（中间系统到中间系统）

基于链路状态算法
ISP 骨干网最常用的 IGP 协议

3.3 外部网关协议（EGP）

BGP（边界网关协议）

自治系统间的域间路由协议
互联网骨干网的核心协议

4. 总结

概念	关键点
路由聚合	合并多条路由为一条，减少路由表条目
最长前缀匹配	选择前缀最长的路由，更精确
VLSM	按需分配 IP，减少浪费
OSPF	链路状态协议，广泛使用
BGP	自治系统间路由协议

学习建议：

理解路由聚合的计算过程
掌握 VLSM 子网划分方法
熟悉常见协议的特点和适用场景

VLAN 与 IPv4 地址笔记

Fri, 01 Aug 2025 00:00:00 GMT

1. MAC 地址与多播

1.1 MAC 多播地址判断

判断方法：检查 MAC 地址第一字节的最低位（b0 位）：

b0 = 0：单播地址（一对一通信）
b0 = 1：多播地址（一对多通信）

示例：07-E0-12-F6-2A-D8

第一字节 07 的二进制为 0000 0111
最低位 b0 = 1 → 这是多播地址

1.2 IEEE 802 局域网 MAC 地址格式

EUI-48 格式（48 位 = 6 字节）：

字段	长度	说明
OUI（组织唯一标识符）	3 字节	由 IEEE 分配给厂商
网络接口标识符	3 字节	厂商自行分配

第一字节的位含义：

b0 位：0 = 单播，1 = 多播
b1 位：0 = 全球管理（厂商分配），1 = 本地管理

地址数量：2^47 ≈ 281 万亿个全球单播地址

2. VLAN 技术

2.1 IEEE 802.1Q 帧格式

VLAN 标记结构（插入 4 字节 VLAN 标签）：

目的MAC(6B) | 源MAC(6B) | VLAN标签(4B) | 类型(2B) | 数据(46-1500B) | FCS(4B)

VLAN 标签字段：

TPID（2 字节）：0x8100，表示 802.1Q 帧
TCI（2 字节）：包含优先级、CFI、VID

VID（VLAN ID）：

取值范围：0 ~ 4095（12 位）
有效范围：1 ~ 4094（0 和 4095 保留）
唯一标识以太网帧属于哪个 VLAN

交换机处理：

入向：收到普通以太网帧 → 打标签（插入 4 字节 VLAN 标记）
出向：转发前 → 去标签（删除 4 字节 VLAN 标记）

2.2 交换机端口类型

三种端口类型：

类型	说明	PVID
Access	连接终端设备，只属于一个 VLAN	通常为 1
Trunk	连接交换机/路由器，可属于多个 VLAN	默认为 1
Hybrid	华为特有，灵活配置	可自定义

2.3 Tagged 与 Untagged 帧

Untagged Frame（普通数据帧）：

终端设备（电脑、打印机）发出的原始以太网帧
不带任何 VLAN 标签，终端设备不认识 VLAN

Tagged Frame（带标签的数据帧）：

交换机之间传输时，在帧中插入 4 字节 VLAN Tag
明确标明该帧属于哪个 VLAN（VID）

2.4 PVID（Port VLAN ID）

PVID 的核心作用：给"无标签"的数据帧"贴标签"

术语对照：

思科：称为 Native VLAN（本征 VLAN）
华为：称为 Port VLAN ID（端口 VLAN ID）

工作流程：

数据进入交换机（Ingress）：

收到 Untagged 数据帧
查看端口 PVID 设置（假设 PVID=10）
为数据帧打上 VLAN Tag，标记为 VLAN 10
后续按 VLAN 10 成员处理和转发

数据离开交换机（Egress）：

检查端口设置
若端口允许该 VLAN 以 Untagged 方式送出 → 剥离 VLAN Tag 再发送
若端口允许该 VLAN 以 Tagged 方式送出 → 保留 VLAN Tag 直接发送

2.5 Trunk 端口工作原理

Trunk 端口特点：

用于交换机之间或交换机与路由器互连
可以承载多个 VLAN 的流量
默认 PVID = 1

发送处理：

对 VID = PVID 的帧：去标签后转发
对 VID ≠ PVID 的帧：保留标签转发

接收处理：

收到未打标签的帧：根据端口 PVID 打标签
收到已打标签的帧：直接转发

3. IPv4 地址

3.1 IPv4 地址分类

地址分类规则（根据第一个十进制数）：

类别	第一字节范围	网络号长度	主机号长度
A 类	1 ~ 126	8 位	24 位
B 类	128 ~ 191	16 位	16 位
C 类	192 ~ 223	24 位	8 位

判断要点：

网络号全 0：本网络本主机（DHCP）
主机号全 0：网络地址（不可指派）
主机号全 1：广播地址（不可指派）

3.2 特殊 IPv4 地址

地址类型	示例	用途
网络号全 0	0.x.x.x	本网络本主机（DHCP）
主机号全 1	x.x.x.255	本网络广播
网络号全 1	255.255.255.255	受限广播（路由器不转发）
127.x.x.x	127.0.0.1	本地环回测试

环回测试：通过"自发自收"方式验证本地协议栈，不经过网卡。

3.3 子网划分

子网划分步骤：

确定子网掩码：将 IP 地址与子网掩码进行 AND 运算
计算网络地址：IP & 子网掩码 = 网络地址
计算广播地址：网络地址 | (NOT 子网掩码) = 广播地址

示例：

IP：180.80.77.55
子网掩码：255.255.252.0（/22）

计算过程：

IP：      180.80.0100 1101.0011 0111
掩码：    255.255.1111 1100.0000 0000
网络地址：180.80.0100 1100.0000 0000 = 180.80.76.0
广播地址：180.80.0100 1111.1111 1111 = 180.80.79.255

4. 总结

核心知识点

MAC 多播：第一字节最低位为 1
VLAN：802.1Q 帧插入 4 字节标签，VID 范围 1-4094
端口类型：Access（终端）、Trunk（交换机间）、Hybrid（灵活）
Tagged/Untagged：终端发 Untagged，交换机间发 Tagged
PVID：为 Untagged 帧打标签（入向），或剥离标签（出向）
IPv4 分类：A/B/C 类根据第一字节判断
子网划分：IP & 掩码 = 网络地址，网络地址 | (NOT 掩码) = 广播地址

C++ 知识点

Thu, 31 Jul 2025 00:00:00 GMT

sort(first, last)

first：指向排序范围的起始位置（包含）。
last：指向排序范围的末尾的下一个位置（不包含）。
因此，sort(sum, sum + 5) 排序的是 sum[0] 到 sum[4]。

如果要降序排序，可以使用：

方法 1：greater<int>()

sort(a, a + 4, greater<int>());  // 结果：{9, 5, 2, 1}

方法 2：Lambda 表达式（C++11）

sort(a, a + 4, [](int x, int y) { return x > y; });

max(res, nums[i])

在 C++ 中，res = max(res, nums[i]); 是用于更新变量 res 为当前最大值的一种常见写法。它的作用是：比较 res 和 nums[i]，并将较大的值赋给 res

s.length()和s.size()区别

不同点

1. length() 主要用于字符串，size() 更通用

length() 是 std::string 的成员函数，不适用于 STL 容器（如 vector、list）。
size() 是 STL 容器的通用接口，适用于 string 和所有 STL 容器。

判断质数的函数

bool fun(int x) {
    if (x <= 1)
        return false;
    if (x == 2)
        return true;
    for (int i = 2; i * i <= x; i++)
        if (x % i == 0)
            return false;
    return true;
}

getline(cin, s)

在 C++ 中，getline(cin, s) 用于从标准输入（键盘）读取一行字符串，并存储到 std::string 变量 s 中。它比 cin >> s 更强大，可以读取包含空格的字符串。

混合 `cin >>` 和 `getline` 时要注意缓冲区

如果先 cin >> 再 getline，cin 会留下 \n 在缓冲区，导致 getline 直接读取空行

解决方法：

在 cin >> 后加 cin.ignore() 清除缓冲区：

`getline` 可以指定分隔符（默认 `\n`）

string data;
getline(cin, data, ',');  // 读取直到遇到逗号

1. 按位与（`&`）按位或（`|`）

对两个数的二进制表示逐位比较，只有两个位都为 1 时，结果的该位才为 1，否则为 0。

int a = 5;    // 二进制: 0101
int b = 3;    // 二进制: 0011
int c = a & b; // 结果:  0001 (十进制 1)
cout << c;    // 输出 1

对两个数的二进制表示逐位比较，只要有一个位为 1，结果的该位就为 1，否则为 0。

int a = 5;    // 二进制: 0101
int b = 3;    // 二进制: 0011
int c = a | b; // 结果:  0111 (十进制 7)
cout << c;    // 输出 7

vector

push_back()用于在容器的末尾添加一个新元素。

GFW 识别 CDN 相关笔记

Sun, 27 Jul 2025 00:00:00 GMT

参考讨论：GFW 大战 Cloudflare，以及积至公司推荐的火爆翻墙项目

1. SNI（服务器名称指示）—— 明文的"门牌号"

什么是 SNI？

当你访问一个 HTTPS 网站时，在加密连接建立之前，你会明文发送一个字段叫 SNI，告诉服务器你要访问哪个域名。

比如访问 worker-demo.yourname.workers.dev，这个域名会以明文形式在网络上传输。

GFW 如何利用 SNI？

正常用户访问的 SNI：
- www.baidu.com
- www.bilibili.com
- api.github.com

翻墙用户访问的 SNI：
- proxy123.username.workers.dev  ← Workers 默认域名
- tunnel.abcd.pages.dev          ← Pages 域名
- *.trycloudflare.com            ← Tunnel 临时域名

识别逻辑：

GFW 可以维护一个"Workers 子域名黑名单"
只要检测到 SNI 包含 workers.dev、pages.dev 等特征，或匹配已知的翻墙 Worker 子域名，就直接阻断
即使你用自定义域名（如 my-proxy.com），如果 GFW 发现这个域名指向 Cloudflare Workers IP 且有异常流量模式，也会被标记

长时间连接检测：

正常 HTTPS 连接平均持续 30-60 秒
代理连接可能持续 30 分钟以上，且期间一直有数据传输
GFW 标记"持续活跃的 HTTPS 长连接"为可疑

流量指纹（Packet Size & Timing）：

你的代理工具（如 Clash、V2Ray）在加密数据时，会产生特定大小的数据包
比如每 2 秒发送一个 1400 字节的心跳包
GFW 通过机器学习识别这种"机械式"的流量模式

综合举例：GFW 如何判定你在用 edgetunnel

假设你在用 edgetunnel（一个基于 Workers 的代理）：

DNS 阶段：你的电脑查询 edgetunnel.yourname.workers.dev → 可疑
TLS 握手阶段：SNI 明文显示 yourname.workers.dev → 确认是 Workers
指纹检测：JA3 显示这不是浏览器，是代理客户端 → 确认是代理
流量分析：连接持续 2 小时，上下行流量对称，心跳包规律 → 确认是代理隧道
IP 分析：你连接的 Cloudflare IP 是 104.16.x.x，不是最优节点 → 确认使用了优选 IP

结论：阻断该连接，或限速，或记录你的 IP 进行重点监控。

GFW 识别 Workers 代理的多重手段：

1. SNI 明文检查（第一层）
   workers.dev / pages.dev → 直接标记

2. 自定义域名（第二层）
   yourdomain.com → 指向 104.16.x.x 
                 → 流量特征异常 
                 → 回溯发现是 Workers IP 
                 → 标记

3. DNS 情报收集（第三层）
   监控全国 DNS 查询日志
   → 发现大量 .workers.dev 查询来自特定用户群
   → 分析这些域名
   → 发现是代理工具
   → 加入黑名单

4. IP + 流量指纹（第四层）
   无论域名是什么
   → 只要连接到 Workers IP 段
   → 且 JA3/流量模式匹配代理特征
   → 精准识别

补充：为什么机场较少用 Hysteria

一个常见疑问：Hysteria 协议出来挺久了，为什么少见机场采用？大致原因：

迁移成本：Hysteria 较新，原有机场既有协议用得好，没必要冒风险换。
QUIC 被限流：Hysteria 基于 QUIC（UDP），运营商对 UDP 的 QoS 限流比较狠，高峰期尤其明显，自己建一个对比测速就能感受到。
替代方案够强：目前抗审查能力很强的组合是 VLESS + Reality——VLESS 开销小，Reality 伪装到位，对机场来说够用且稳定。

所以选型不是"新就一定好"，而是在抗审查、稳定性、带宽开销之间权衡。

计算机网络基础：OSI 模型与网络设备

Sun, 27 Jul 2025 00:00:00 GMT

1. OSI七层模型

OSI定义了网络互连的七层框架，即ISO开放互连系统参考模型。

应用层（Application Layer）：提供用户接口和应用程序之间的通信服务
表示层（Presentation Layer）：负责数据的格式化、加密和压缩
会话层（Session Layer）：管理应用程序之间的通信会话
传输层（Transport Layer）：为应用程序提供端到端的数据传输服务，主要使用 TCP 和 UDP
网络层（Network Layer）：负责数据包的路由和转发，以及网络中的寻址和拥塞控制
数据链路层（Data Link Layer）：提供点对点的数据传输服务，将比特流转换为数据帧
物理层（Physical Layer）：在物理媒介上传输原始比特流

2. TCP/IP四层模型

应用层：处理用户与网络应用程序之间的通信（HTTP、FTP、SMTP等）
传输层：提供端到端的数据传输服务（TCP、UDP）
网络层：负责数据包的路由和转发（IP协议）
网络接口层：管理网络硬件设备和物理媒介之间的通信

应用层常见协议：HTTP、FTP、SMTP、POP3、IMAP、DNS、HTTPS、SSH、SNMP、Telnet

传输层常见协议：

TCP：可靠的、面向连接的数据传输（文件传输、网页浏览）
UDP：无连接的数据传输（音视频传输、在线游戏）

网络层常见协议：IP、ICMP、ARP、RARP、IPv6

3. 专用术语

(1) 实体

实体是指任何可发送或接收信息的硬件或软件进程。对等实体是指通信双方相同层次中的实体。

(2) 协议

协议是控制两个对等实体在"水平方向"进行"逻辑通信"的规则的集合。

协议有三大要素：语法、语义、同步。

语法：定义通信双方所交换信息的格式
语义：定义通信双方所要完成的操作
同步：定义通信双方的时序关系

(3) 服务

在协议的控制下，两个对等实体在水平方向的逻辑通信使得本层能够向上一层提供服务。

协议数据单元（PDU）：对等层次之间传送的数据包
服务数据单元（SDU）：同一系统内层与层之间交换的数据包

4. 计算机网络概念

集线器（Hub）：把多个结点连接起来，工作在物理层，普通民用领域已很少用
交换机（Switch）：把多个结点连接起来，工作在数据链路层，家庭/公司/学校常用
路由器（Router）：把多个计算机网络互相连接起来，工作在网络层

Tips：计算机网络课程中的"路由器"和"家用路由器"有区别。家用路由器 = 路由器 + 交换机 + 其他功能

5. 计算机网络的组成和功能

6. 电路交换、报文交换、分组交换

6.1 电路交换 vs 分组交换时延计算

条件：报文共 x(bit)，源到终点经 k 段链路，每段传播时延 d(s)，带宽 b(bit/s)。电路交换建立时间 s(s)。分组交换将报文划分为长度 p(bit) 的分组（首部长度和排队时间忽略不计）。

电路交换时延 = s + x/b + kd

分组交换时延 = x/b + (k−1)×(p/b) + kd

令电路交换时延 > 分组交换时延，解得：s > (k−1)×p/b

最优分组长度：设分组数据部分长度为 p，首部为 h，总时延 D：

令 dD/dp = 0，解得 p = √(xh/(k−1))

7. 计算机网络分类

按覆盖范围分类：**局域网（LAN）**覆盖较小区域（如办公室、校园）；**城域网（MAN）**覆盖城市范围；**广域网（WAN）**覆盖国家或全球范围；**个人区域网（PAN）**覆盖个人周围约10米范围。按拓扑结构可分为总线型、星型、环型、网状型等。

8. 性能指标

信道（Channel）：表示向某一方向传送信息的通道。一条通信线路在逻辑上对应一条发送信道和一条接收信道。

主要性能指标包括：速率（数据传输速率，单位 bit/s）、带宽（信道能通过的最高频率范围，单位 Hz 或 bit/s）、吞吐量（单位时间内通过某个网络的实际数据量）、时延（发送时延 + 传播时延 + 排队时延 + 处理时延）、往返时间 RTT、丢包率。

9. 分层架构

分层架构将复杂的网络通信问题分解为若干层次，每层实现特定功能并为上层提供服务。OSI 采用七层模型，TCP/IP 采用四层模型，两者可对应映射。各层的协议数据单元（PDU）不同：物理层为比特、数据链路层为帧、网络层为分组/包、传输层为报文段。层与层之间通过**服务访问点（SAP）**进行交互。

10. 各层功能速查

层次	传输单位	主要功能	典型协议
物理层	比特	比特流的透明传输（电气、物理特性）	—
数据链路层	帧	结点到结点的可靠传输，帧同步、差错控制、流量控制、访问控制	以太网、PPP、HDLC
网络层	分组	源主机到目的主机的分组传输（跨越多个网络）	IP、ICMP、ARP
运输层	报文	进程到进程的可靠传输	TCP、UDP
应用层	报文	提供用户接口和网络服务	HTTP、FTP、DNS、SMTP

易混点：数据链路层提供的是"分组在一个网络（或一段链路）上传输服务"，网络层提供的是"跨网络的主机到主机传输服务"。

链表基础与 LeetCode 练习

Tue, 15 Jul 2025 00:00:00 GMT

一、链表概念

与数组的区别
- 数组：连续内存空间，随机访问高效（O(1)），但插入/删除需移动元素（O(n)）
- 链表：节点离散存储，通过指针连接（逻辑连续，物理非连续）
- 访问效率：链表只能顺序访问（O(n)），但插入/删除只需修改指针（O(1)）
节点结构（C++实现）

struct ListNode {
    int val;         // 存储数据
    ListNode* next;  // 指向下一节点的指针
    ListNode(int x) : val(x), next(nullptr) {}
};

二、链表底层机制

内存分配原理
- 节点内存非连续 → 动态分配（C++用new/delete）
- 创建节点：ListNode* node = new ListNode(10);
- 释放节点：delete node;（避免内存泄漏）
指针操作图解

初始： head → A → B → C → nullptr
删除B：
  1. 定位A: A->next = B->next
  2. 释放B: delete B
结果： head → A → C → nullptr

三、链表五大基础操作（C++实现）

1. 遍历链表

void traverse(ListNode* head) {
    ListNode* cur = head;
    while (cur != nullptr) {
        cout << cur->val << " ";
        cur = cur->next;
    }
}

2. 插入节点

头部插入

void insertAtHead(ListNode*& head, int val) {
    ListNode* newNode = new ListNode(val);
    newNode->next = head;
    head = newNode;
}

尾部插入

void insertAtTail(ListNode*& head, int val) {
    ListNode* newNode = new ListNode(val);
    if (head == nullptr) {
        head = newNode;
        return;
    }
    ListNode* cur = head;
    while (cur->next != nullptr) {
        cur = cur->next;
    }
    cur->next = newNode;
}

中间插入（在pos节点后插入）

void insertAfter(ListNode* pos, int val) {
    if (pos == nullptr) return;
    ListNode* newNode = new ListNode(val);
    newNode->next = pos->next;
    pos->next = newNode;
}

3. 删除节点

void deleteNode(ListNode*& head, int val) {
    if (head == nullptr) return;

    if (head->val == val) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
        return;
    }

    ListNode* cur = head;
    while (cur->next != nullptr && cur->next->val != val) {
        cur = cur->next;
    }

    if (cur->next != nullptr) {
        ListNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
    }
}

4. 修改节点值

void updateNode(ListNode* head, int oldVal, int newVal) {
    ListNode* cur = head;
    while (cur != nullptr) {
        if (cur->val == oldVal) {
            cur->val = newVal;
            return;
        }
        cur = cur->next;
    }
}

5. 查找节点

ListNode* searchNode(ListNode* head, int val) {
    ListNode* cur = head;
    while (cur != nullptr) {
        if (cur->val == val) {
            return cur;
        }
        cur = cur->next;
    }
    return nullptr;
}

四、关键点

头指针的特殊处理
- 头节点可能被修改 → 使用ListNode*&（指针引用）或二级指针
- 空链表判断：if (head == nullptr)
边界条件检查
- 插入/删除头节点
- 操作空链表
- 处理尾节点（next指向nullptr）
内存管理要点
- 每次new后必须对应delete
- 删除节点时需先保存下一节点指针
哨兵节点技巧（简化操作）

ListNode* dummy = new ListNode(0);
dummy->next = head;
// ...执行操作...
head = dummy->next;
delete dummy;

五、链表 vs 数组

特性	数组	链表
内存连续性	连续	非连续
访问方式	O(1)随机访问	O(n)顺序访问
插入/删除成本	O(n)需要移动元素	O(1)修改指针
扩容	需重新分配内存	动态增加节点
头部插入	O(n)	O(1)
局部性原理	优	差

六、LeetCode 练习

1. 删除链表中的节点（LeetCode 237）

问题本质：在只给定被删除节点（非尾节点）的情况下，实现节点删除

void deleteNode(struct ListNode* node) {
    node->val = node->next->val;
    node->next = node->next->next;
}

要点：

无法访问前驱节点，因此采用"值替换+跳过"策略
时间复杂度 O(1)，空间复杂度 O(1)
特例处理：不能删除尾节点（题目保证）

2. 反转链表（LeetCode 206）

迭代法：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *cur = head, *pre = nullptr;
        while(cur != nullptr) {
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

迭代步骤详解（每轮循环的指针状态变化）：

步骤	状态描述	图示
1	cur=1, tmp=2, pre=null，反转 1→null
2	pre=cur 进行中，准备进入下一步
3	pre=1, cur=2, tmp=3，1→null 已反转
4	pre=cur 进行中，准备进入下一步
5	pre=2, cur=3, tmp=4，2→1→null
6	pre=cur 进行中，准备进入下一步
7	pre=3, cur=4, tmp=5，3→2→1→null
8	pre=cur 进行中，准备进入下一步
9	pre=4, cur=5, tmp=null，4→3→2→1→null
10	pre=cur 进行中，准备进入下一步
11	循环结束：5→4→3→2→1→null，返回 pre

递归法：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        return recur(head, nullptr);
    }
private:
    ListNode* recur(ListNode* cur, ListNode* pre) {
        if (cur == nullptr) return pre;
        ListNode* res = recur(cur->next, cur);
        cur->next = pre;
        return res;
    }
};

方法	时间复杂度	空间复杂度	适用场景
迭代法	O(n)	O(1)	内存敏感场景
递归法	O(n)	O(n)	代码简洁要求场景

3. 设计链表（LeetCode 707）

双向链表实现框架：

typedef struct MyLinkedListNode {
    int val;
    struct MyLinkedListNode *prev;
    struct MyLinkedListNode *next;
} Node;

typedef struct {
    Node *head;
    Node *tail;
    int size;
} MyLinkedList;

设计原则：

虚拟头尾节点：统一处理边界情况
size维护：避免多余遍历
指针安全：每次操作前检查NULL

4. K 个一组翻转链表（LeetCode 25）

问题描述：给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

原始链表：1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9
按 k=4 分组：
  组1: 1 → 2 → 3 → 4
  组2: 5 → 6 → 7 → 8 → 9 (剩余不足 4 个，保持原序)

翻转后：4 → 3 → 2 → 1 → 5 → 6 → 7 → 8 → 9

class Solution {
public:
    // 翻转 [a, b) 区间内的链表节点（不包含 b）
    ListNode* reverse(ListNode* a, ListNode* b) {
        ListNode *pre = nullptr, *cur = a, *next;
        while (cur != b) {
            next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;  // 返回翻转后的新头
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        if (head == nullptr) return nullptr;

        ListNode *a = head, *b = head;
        // 前进 k 步，找到本组尾部
        for (int i = 0; i < k; i++) {
            if (b == nullptr) return head;  // 不足 k 个，保持原序
            b = b->next;
        }

        // 翻转前 k 个
        ListNode* newHead = reverse(a, b);
        // 递归处理后续链表
        a->next = reverseKGroup(b, k);
        return newHead;
    }
};

关键点：

使用 [a, b) 半开区间翻转，避免对尾节点做特殊处理
递归处理后续分组，每次处理 k 个节点
不足 k 个的剩余节点保持原序（不翻转）
时间复杂度 O(n)，空间复杂度 O(n/k) 的递归栈

Vue.js 常见问题速查

Fri, 27 Jun 2025 00:00:00 GMT

1. `{{}}` 是什么？

文本插值语法 Vue 模板中使用双大括号 {{}} 进行文本插值，将数据绑定到 HTML 中。 示例：

<template>
  <div>{{ message }}</div>
</template>

<script setup>
const message = "Hello Vue!";
</script>

说明：

message 是响应式数据，若值变化，视图会自动更新。
注意： 插值内容会被自动转义，防止 XSS 攻击。

2. `v-if` 是什么？怎么用？

条件渲染指令 v-if 用于根据条件决定是否渲染某个元素（惰性渲染）。 示例：

<template>
  <div v-if="isVisible">显示内容</div>
  <div v-else>隐藏内容</div>
</template>

<script setup>
const isVisible = true;
</script>

特点：

条件为 false 时，元素不会出现在 DOM 中。
可搭配 v-else、v-else-if 使用。

3. `const count = ref(0);` 是什么？

声明响应式变量 使用 ref() 创建一个响应式引用，常用于基础类型（如数字、字符串）。 示例：

<template>
  <div>计数器：{{ count }}</div>
  <button @click="count++">+1</button>
</template>

<script setup>
import { ref } from 'vue';
const count = ref(0);
</script>

说明：

ref(0) 返回一个响应式对象，通过 .value 访问/修改值（在 JavaScript 中），但在模板中直接使用变量名。
当 count 变化时，视图会自动更新。

4. `onMounted(() => { ... })` 是什么？

生命周期钩子函数 onMounted 是 Vue 的生命周期钩子，在组件挂载到 DOM 后执行。 示例：

<template>
  <div id="app">组件已加载</div>
</template>

<script setup>
import { onMounted } from 'vue';

onMounted(() => {
  console.log('组件已挂载');
  // 可在此进行初始化操作（如请求数据）
});
</script>

常见用途：

发起 API 请求获取数据。
初始化第三方库（如地图、图表）。

5. `ts` 是什么？

TypeScript 简称 TypeScript 是 JavaScript 的超集，添加了静态类型检查功能。 核心优势：

提早发现错误（如变量类型不匹配）。
支持面向对象编程（类、接口等）。
更好的代码提示和重构能力。

Vue 项目中使用 TypeScript：

<template>
  <div>{{ message }}</div>
</template>

<script setup lang="ts">
// 定义类型
interface User {
  name: string;
  age: number;
}

// 使用类型
const user: User = { name: "Alice", age: 25 };
const message: string = `用户：${user.name}`;
</script>

说明：

在 <script> 或 <script setup> 标签中添加 lang="ts" 即可启用 TypeScript。

Vue 工程化与 Element Plus 实战笔记

Sun, 22 Jun 2025 00:00:00 GMT

这篇笔记记录 Vue 工程化开发和 Element Plus 的入门实践，重点从脚手架、依赖管理、项目结构和组件库使用开始。

本文要点

前端工程化强调模块化、组件化、规范化和自动化。
create-vue 可快速生成 Vue 工程化项目。
npm 负责前端依赖安装和脚本运行。
Element Plus 提供常用的企业级 UI 组件。

Vue工程化

前面我们在介绍Vue的时候，我们讲到Vue是一款用于构建用户界面的渐进式JavaScript框架。（官方：https://cn.vuejs.org/）

那在前面的课程中，我们已经学习了Vue的基本语法、表达式、指令，并基于Vue的核心包，完成了Vue的案例。那今天呢，我们要来讲解的基于Vue进行整站开发。

所以现在企业开发中更加讲究前端工程化方式的开发，主要包括如下4个特点:

模块化：将js和css等，做成一个个可复用模块
组件化：我们将UI组件，css样式，js行为封装成一个个的组件，便于管理
规范化：我们提供一套标准的规范的目录接口和编码规范，所有开发人员遵循这套规范
自动化：项目的构建，测试，部署全部都是自动完成

所以对于前端工程化，说白了，就是在企业级的前端项目开发中，把前端开发所需要的工具、技术、流程、经验进行规范化和标准化。从而统一开发规范、提升开发效率，降低开发难度、提高复用等等。接下来我们就需要学习vue的官方提供的脚手架帮我们完成前端的工程化。

环境准备

介绍

介绍：create-vue是Vue官方提供的最新的脚手架工具，用于快速生成一个工程化的Vue项目。
create-vue提供了如下功能：
- 统一的目录结构
- 本地调试
- 热部署
- 单元测试
- 集成打包上线
而要想使用create-vue来创建vue项目，则必须安装依赖环境：NodeJS

npm介绍

**npm：**Node Package Manager，是NodeJS的软件包管理器。

在开发前端项目的过程中，我们需要相关的依赖，就可以直接通过 npm install xxx 命令，直接从远程仓库中将依赖直接下载到本地了。

Vue项目创建

项目创建

创建一个工程化的Vue项目，执行命令：npm create vue``@3.3.4

详细步骤说明：

Project name：------------------》项目名称，默认值：vue-project，可输入想要的项目名称。
Add TypeScript? ----------------》是否加入TypeScript组件？默认值：No。
Add JSX Support? --------------》是否加入JSX支持？默认值：No。
Add Vue Router...--------------》是否为单页应用程序开发添加Vue Router路由管理组件？默认值：No。
Add Pinia ...----------------------》是否添加Pinia组件来进行状态管理？默认值：No。
Add Vitest ...---------------------》是否添加Vitest来进行单元测试？默认值：No。
Add an End-to-End ...-----------》是否添加端到端测试？默认值No。
Add ESLint for code quality? ---》是否添加ESLint来进行代码质量检查？默认值：No。

**提示：**执行上述指令，将会安装并执行 create-vue，它是 Vue 官方的项目脚手架工具

项目创建完成以后，进入vue-project01 项目目录，执行命令安装当前项目的依赖：npm install

创建项目以及安装依赖的过程，都是需要联网的。【如果网络不太好，可能会造成依赖下载不完整报错，继续再次执行命令安装。】

项目结构

我们可以使用VsCode直接打开这个Vue项目。

这是我们创建的第一个项目结构，接下来呢，我们来介绍一下这个项目的结构。如图所示：

在上述的目录中，我们以后操作的最多的目录，就是src目录，因为我们需要在这个目录下来编写前端代码。

Vue项目开发流程

如下图：

其中*.vue是Vue项目中的组件文件，在Vue项目中也称为单文件组件（SFC，Single-File Components）。Vue 的单文件组件会将一个组件的逻辑 (JS)，模板 (HTML) 和样式 (CSS) 封装在同一个文件里（*.vue）

API风格

Vue的组件有两种不同的风格：组合式API 和 选项式API
**组合式API：**是Vue3提供的一种基于函数的组件编写方式，通过使用函数来组织和复用组件的逻辑。它提供了一种更灵活、更可组合的方式来编写组件。代码形式如下：

<script setup>
import { ref, onMounted } from 'vue';
const count = ref(0); //声明响应式变量

function increment(){ //声明函数
   count.value++;
}

onMounted(() => { //声明钩子函数
  console.log('Vue Mounted....'); 
})
</script>

<template>
   <input type="button" @click="increment"> Api Demo1 Count : {{ count }}
</template>

<style scoped>
   
</style>

setup：是一个标识，告诉Vue需要进行一些处理，让我们可以更简洁的使用组合式API。
ref()：接收一个内部值，返回一个响应式的ref对象，此对象只有一个指向内部值的属性 value。
onMounted()：在组合式API中的钩子方法，注册一个回调函数，在组件挂载完成后执行。
选项式API

**选项式API：**可以用包含多个选项的对象来描述组件的逻辑，如：data，methods，mounted等。选项定义的属性都会暴露在函数内部的this上，它会指向当前的组件实例。

<script>
export default{
   data() {
      return {
         count: 0
      }
   },
   methods: {
      increment: function(){
         this.count++
      }
   },
   mounted() {
      console.log('vue mounted.....');
   }
}
</script>

<template>
  <input type="button" @click="increment">Api Demo1 Count :  {{ count }}
</template>

<style scoped>

</style>

在Vue中的组合式API使用时，是没有this对象的，this对象是undefined。

ElementPlus

介绍

Element：是饿了么公司前端开发团队提供的一套基于 Vue3 的网站组件库，用于快速构建网页。

Element 提供了很多组件（组成网页的部件）供我们使用。例如超链接、按钮、图片、表格等等。

官方网站：https://element-plus.org/zh-CN/#/zh-CN

如下图所示就是我们开发的页面和ElementPlus提供的效果对比：可以发现ElementPlus提供的各式各样好看的按钮。

ElementPlus的学习方式和我们之前的学习方式不太一样，对于ElementPlus，我们作为一个后台开发者，只需要学会如何从 ElementPlus 的官网拷贝组件到我们自己的页面中，并且做一些修改即可。我们主要学习的是ElementPlus中提供的常用组件，至于其他组件同学们可以通过我们这几个组件的学习掌握到ElementPlus的学习技巧，然后课后自行学习。

小结

Vue 工程化把前端项目从单个页面脚本推进到可维护的项目结构。理解脚手架、npm、组件库和目录规范后，再使用 Element Plus 组件会更顺。

前后端分离开发笔记

Sat, 21 Jun 2025 00:00:00 GMT

前后台分离开发方式，如下图所示：

我们将原先的工程分为前端工程和后端工程这2个工程，然后前端工程交给专业的前端人员开发，后端工程交给专业的后端人员开发。

前端页面需要数据，可以通过发送异步请求，从后台工程获取。但是，我们前后台是分开来开发的，那么前端人员怎么知道后台返回数据的格式呢？后端人员开发，怎么知道前端人员需要的数据格式呢？

所以针对这个问题，我们前后台统一制定一套规范！我们前后台开发人员都需要遵循这套规范开发，这就是我们的 接口文档。接口文档有离线版和在线版本，接口文档示可以查询今天提供 资料/接口文档 里面的资料。

那么接口文档的内容怎么来的呢？是我们后台开发者根据产品经理提供的产品原型和需求文档所撰写出来的，产品原型示例可以参考今天提供资料/页面原型 里面的资料。

那么基于前后台分离开发的模式下，我们后台开发者开发一个功能的具体流程如何呢？如下图所示：

需求分析：首先我们需要阅读需求文档，分析需求，理解需求。
接口定义：查询接口文档中关于需求的接口的定义，包括地址，参数，响应数据类型等等
前后台并行开发：各自按照接口文档进行开发，实现需求
测试：前后台开发完了，各自按照接口文档进行测试
前后端联调测试：前端工程请求后端工程，测试功能

1. VueRouter

1. 介绍

Vue Router：Vue的官方路由。为Vue提供富有表现力、可配置的、方便的路由。
Vue中的路由，主要定义的是路径与组件之间的对应关系。

比如，我们打开一个网站，点击左侧菜单，地址栏的地址发生变化。地址栏地址一旦发生变化，在主区域显示对应的页面组件。

VueRouter主要由以下三个部分组成，如下所示：

VueRouter：路由器类，根据路由请求在路由视图中动态渲染选中的组件
<router-link>：请求链接组件，浏览器会解析成<a>
<router-view>：动态视图组件，用来渲染展示与路由路径对应的组件

1. 基础路由配置

1). 在 views/layout/index.vue 中，调整代码，具体调整位置如下：

在左侧菜单栏的 <el-menu> 标签上添加 router 属性，这会让 Element Plus 的 <el-menu> 组件自动根据路由来激活对应的菜单项。
使用 <router-view> 组件来渲染根据路由动态变化的内容。
确保每个 <el-menu-item> 的 index 属性值与你想要导航到的路径相匹配。

<script setup>
// 无需额外导入，因为我们只是使用了 Element Plus 和 Vue Router 的基本功能
</script>

<template>
  <div class="common-layout">
    <el-container>
      <!-- Header 区域 -->
      <el-header class="header">
        <span class="title">Tlias智能学习辅助系统</span>
        <span class="right_tool">
          <a href="">
            <el-icon><EditPen /></el-icon> 修改密码 &nbsp;&nbsp;&nbsp; |  &nbsp;&nbsp;&nbsp;
          </a>
          <a href="">
            <el-icon><SwitchButton /></el-icon> 退出登录
          </a>
        </span>
      </el-header>
      
      <el-container>
        <!-- 左侧菜单 -->
        <el-aside width="200px" class="aside">

          <el-menu router>
            <!-- 首页菜单 -->
            <el-menu-item index="/index">
              <el-icon><Promotion /></el-icon> 首页
            </el-menu-item>
            
            <!-- 班级管理菜单 -->
            <el-sub-menu index="/manage">
              <template #title>
                <el-icon><Menu /></el-icon> 班级学员管理
              </template>
              <el-menu-item index="/clazz">
                <el-icon><HomeFilled /></el-icon>班级管理
              </el-menu-item>
              <el-menu-item index="/stu">
                <el-icon><UserFilled /></el-icon>学员管理
              </el-menu-item>
            </el-sub-menu>
            
            <!-- 系统信息管理 -->
            <el-sub-menu index="/system">
              <template #title>
                <el-icon><Tools /></el-icon>系统信息管理
              </template>
              <el-menu-item index="/dept">
                <el-icon><HelpFilled /></el-icon>部门管理
              </el-menu-item>
              <el-menu-item index="/emp">
                <el-icon><Avatar /></el-icon>员工管理
              </el-menu-item>
            </el-sub-menu>

            <!-- 数据统计管理 -->
            <el-sub-menu index="/report">
              <template #title>
                <el-icon><Histogram /></el-icon>数据统计管理
              </template>
              <el-menu-item index="/report/emp">
                <el-icon><InfoFilled /></el-icon>员工信息统计
              </el-menu-item>
              <el-menu-item index="/report/stu">
                <el-icon><Share /></el-icon>学员信息统计
              </el-menu-item>
              <el-menu-item index="/log">
                <el-icon><Document /></el-icon>日志信息统计
              </el-menu-item>
            </el-sub-menu>
          </el-menu>
        </el-aside>
        
        <!-- 主展示区域 -->
        <el-main>
          <router-view></router-view>
        </el-main>
      </el-container>
    </el-container>
  </div>
</template>

<style scoped>
.header {
  background-image: linear-gradient(to right, #00547d, #007fa4, #00aaa0, #00d072, #a8eb12);
}

.title {
  color: white;
  font-size: 40px;
  font-family: 楷体;
  line-height: 60px;
  font-weight: bolder;
}

.right_tool{
  float: right;
  line-height: 60px;
}

a {
  color: white;
  text-decoration: none;
}

.aside {
  width: 220px;
  border-right: 1px solid #ccc;
  height: 730px;
}
</style>

2). 在 router/index.js 中配置请求路径与组件之间的关系。

import { createRouter, createWebHistory} from 'vue-router';

import IndexView from '@/views/index/index.vue';
import ClazzView from '@/views/clazz/index.vue';
import StuView from '@/views/stu/index.vue';
import DeptView from '@/views/dept/index.vue';
import EmpView from '@/views/emp/index.vue';
import EmpReportView from '@/views/report/emp/index.vue';
import StuReportView from '@/views/report/stu/index.vue';
import LogView from '@/views/log/index.vue';
import LoginView from '@/views/login/index.vue';

const routes = [
  { path: '/index', component: IndexView },
  { path: '/clazz', component: ClazzView },
  { path: '/stu', component: StuView },
  { path: '/dept', component: DeptView },
  { path: '/emp', component: EmpView },
  { path: '/report/emp', component: EmpReportView },
  { path: '/report/stu', component: StuReportView },
  { path: '/log', component: LogView },
  { path: '/login', component: LoginView },
];

const router = createRouter({
  history: createWebHistory(),
  routes,
});

export default router;

经过这么两步操作之后，我们就可以看到，在页面上，点击左侧菜单，右侧主展示区域，就会显示出对应的页面了。

那要完成这个功能效果，我们就需要用到Vue生态中的路由 Vue-Router。

1. 完善路由配置

上述我们只是完成了最基本的路由配置。并经过测试我们发现，如果我们访问 /login 路径，会发现，登录页面是在layout页面中嵌套展示的，这肯定是不合适的。

那接下来，我们就来优化一下路由的配置。最终配置形式如下，在 router/index.js 中做如下配置：

import { createRouter, createWebHistory } from 'vue-router'

import IndexView from '@/views/index/index.vue'
import ClazzView from '@/views/clazz/index.vue'
import DeptView from '@/views/dept/index.vue'
import EmpView from '@/views/emp/index.vue'
import LogView from '@/views/log/index.vue'
import StuView from '@/views/stu/index.vue'
import EmpReportView from '@/views/report/emp/index.vue'
import StuReportView from '@/views/report/stu/index.vue'
import LayoutView from '@/views/layout/index.vue'
import LoginView from '@/views/login/index.vue'

const router = createRouter({
  history: createWebHistory(import.meta.env.BASE_URL),
  routes: [
    {
     path: '/', 
     name: '',
     component: LayoutView,
     redirect: '/index', //重定向
     children: [
      {path: 'index', name: 'index', component: IndexView},
      {path: 'clazz', name: 'clazz', component: ClazzView},
      {path: 'stu', name: 'stu', component: StuView},
      {path: 'dept', name: 'dept', component: DeptView},
      {path: 'emp', name: 'emp', component: EmpView},
      {path: 'log', name: 'log', component: LogView},
      {path: 'empReport', name: 'empReport', component: EmpReportView},
      {path: 'stuReport', name: 'stuReport', component: StuReportView},
     ]
    },
    {path: '/login', name: 'login', component: LoginView}
  ]
})

export default router

具体的执行访问流程如下:

当点击左侧菜单栏的员工管理菜单时，最终地址栏会访问路径 /emp 。
此时VueRouter，会自动的到所配置的路由表（router/index.js）中，查找与该路径对应的组件，并展示在路由展示组件<router-view> 对应的位置中。

思考：直接在Vue组件中，基于axios发送异步请求，存在什么问题？

我们刚才在完成部门列表查询时，是直接基于axios发送异步请求，直接将接口的请求地址放在组件文件 .vue 中。而如果开发一个大型的项目，组件文件可能会很多很多很多，如果前端开发完毕，进行前后端联调测试了，需要修改请求地址，那么此时，就需要找到每一个 .vue 文件，然后挨个修改。所以上述的代码，虽然实现了动态加载数据的功能。但是存在以下问题：

请求路径难以维护
数据解析繁琐

1. 程序优化

1). 为了解决上述问题，我们在前端项目开发时，通常会定义一个请求处理的工具类 - src/utils/request.js 。在这个工具类中，对axios进行了封装。具体代码如下：

import axios from 'axios'

//创建axios实例对象
const request = axios.create({
  baseURL: '/api',
  timeout: 600000
})

//axios的响应 response 拦截器
request.interceptors.response.use(
  (response) => { //成功回调
    return response.data
  },
  (error) => { //失败回调
    return Promise.reject(error)
  }
)

export default request

2). 而与服务端进行异步交互的逻辑，通常会按模块，封装在一个单独的API中，如：src/api/dept.js

import request from "@/utils/request"

//列表查询
export const queryAllApi = () => request.get('/depts')

3). 修改 src/views/dept/index.vue 中的代码

现在就不需要每次直接调用axios发送异步请求了，只需要将我们定义的对应模块的API导入进来，就可以直接使用了。

<script setup>
import {ref, onMounted} from 'vue'
import {queryAllApi} from '@/api/dept'

//声明列表展示数据
let deptList= ref([])

//动态加载数据-查询部门
const queryAll = async () => {
  const result = await queryAllApi()
  deptList.value = result.data
}

//钩子函数
onMounted(() => {
  queryAll()
})

// 编辑部门 - 根据ID查询回显数据
const handleEdit = (id) => {
  console.log(`Edit item with ID ${id}`);
  // 在这里实现编辑功能
};

// 删除部门 - 根据ID删除部门
const handleDelete = (id) => {
  console.log(`Delete item with ID ${id}`);
  // 在这里实现删除功能
};
</script>

做完上面这三步之后，我们打开浏览器发现，并不能访问到接口数据。原因是因为，目前请求路径不对。

4). 在 vite.config.js 中配置前端请求服务器的信息

在服务器中配置代理proxy的信息，并在配置代理时，执行目标服务器。以及url路径重写的规则。

import { fileURLToPath, URL } from 'node:url'

import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import vueJsx from '@vitejs/plugin-vue-jsx'

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [
    vue(),
    vueJsx(),
  ],
  resolve: {
    alias: {
      '@': fileURLToPath(new URL('./src', import.meta.url))
    }
  },
  server: {
    proxy: {
      '/api': {
        target: 'http://localhost:8080',
        secure: false,
        changeOrigin: true,
        rewrite: (path) => path.replace(/^\/api/, ''),
      }
    }
  }
})

然后，我们就可以启动服务器端的程序（将之前开发的服务端程序启动起来测试一下），进行测试了（【注意：测试时, 记得将令牌校验的过滤器及拦截器, 以及记录日志的AOP程序全部注释】）。

异常处理

Sat, 21 Jun 2025 00:00:00 GMT

这篇笔记记录文件上传和后端异常处理的课程内容。正文里有手机号示例和云服务上下文，公开前需要再做一次人工脱敏复核。

本文要点

文件上传常见流程是后端接收文件，再上传到对象存储。
未处理异常时，框架默认响应可能不符合统一接口规范。
全局异常处理器可以集中处理 Controller 层抛出的异常。
统一响应结构有助于前端稳定解析错误信息。

文件上传使用阿里云oss，后端写好了，apifox通过

1. 异常处理

1. 问题分析

当我们在修改部门数据的时候，如果输入一个在数据库表中已经存在的手机号，点击保存按钮之后，前端提示了错误信息，但是返回的结果并不是统一的响应结果，而是框架默认返回的错误结果。

状态码为500，表示服务器端异常，我们打开idea，来看一下，服务器端出了什么问题。

上述错误信息的含义是，emp员工表的phone手机号字段的值重复了，因为在数据库表emp中已经有了138xxxx0027这个手机号了，我们之前设计这张表时，为phone字段建议了唯一约束，所以该字段的值是不能重复的。

而当我们再将该员工的手机号也设置为 138xxxx0027，就违反了唯一约束，此时就会报错。

我们来看一下出现异常之后，最终服务端给前端响应回来的数据长什么样。

响应回来的数据是一个JSON格式的数据。但这种JSON格式的数据还是我们开发规范当中所提到的统一响应结果Result吗？显然并不是。由于返回的数据不符合开发规范，所以前端并不能解析出响应的JSON数据。

接下来我们需要思考的是出现异常之后，当前案例项目的异常是怎么处理的？答案：没有做任何的异常处理

当我们没有做任何的异常处理时，我们三层架构处理异常的方案：

Mapper接口在操作数据库的时候出错了，此时异常会往上抛(谁调用Mapper就抛给谁)，会抛给service。
service 中也存在异常了，会抛给controller。
而在controller当中，我们也没有做任何的异常处理，所以最终异常会再往上抛。最终抛给框架之后，框架就会返回一个JSON格式的数据，里面封装的就是错误的信息，但是框架返回的JSON格式的数据并不符合我们的开发规范。

2. 解决方案

那么在三层构架项目中，出现了异常，该如何处理?

方案一：在所有Controller的所有方法中进行try…catch处理

缺点：代码臃肿（不推荐）

**方案二：**全局异常处理器

好处：简单、优雅（推荐）

3. 全局异常处理器

我们该怎么样定义全局异常处理器？

定义全局异常处理器非常简单，就是定义一个类，在类上加上一个注解@RestControllerAdvice，加上这个注解就代表我们定义了一个全局异常处理器。
在全局异常处理器当中，需要定义一个方法来捕获异常，在这个方法上需要加上注解@ExceptionHandler。通过@ExceptionHandler注解当中的value属性来指定我们要捕获的是哪一类型的异常。

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    //处理异常
    @ExceptionHandler
    public Result ex(Exception e){//方法形参中指定能够处理的异常类型
        e.printStackTrace();//打印堆栈中的异常信息
        //捕获到异常之后，响应一个标准的Result
        return Result.error("对不起,操作失败,请联系管理员");
    }
    
}

@RestControllerAdvice = @ControllerAdvice + @ResponseBody

处理异常的方法返回值会转换为json后再响应给前端

重新启动SpringBoot服务，打开浏览器，再来测试一下修改员工这个操作，我们依然设置已存在的 138xxxx0027这个手机号：

此时，我们可以看到，出现异常之后，异常已经被全局异常处理器捕获了。然后返回的错误信息，被前端程序正常解析，然后提示出了对应的错误提示信息。

以上就是全局异常处理器的使用，主要涉及到两个注解：

@RestControllerAdvice //表示当前类为全局异常处理器
@ExceptionHandler //指定可以捕获哪种类型的异常进行处理

小结

文件上传和异常处理都属于后端接口稳定性的一部分。前者关注资源如何接收与保存，后者关注错误如何以统一格式返回给前端。

登录认证与 JWT 令牌笔记

Sat, 21 Jun 2025 00:00:00 GMT

这篇笔记整理后端登录认证的基础流程，包括登录接口、JWT 令牌和请求过滤。正文包含 token、密码等教学示例，公开前需要确认没有真实凭据。

本文要点

登录成功后通常返回用户基础信息和认证令牌。
JWT 可用于在请求之间携带认证状态。
服务端需要在过滤器或拦截器中校验请求令牌。
认证逻辑需要特别注意密钥、过期时间和异常响应。

1). 准备实体类 LoginInfo ，封装登录成功后，返回给前端的数据 。

/**
 * 登录成功结果封装类
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginInfo {
    private Integer id; //员工ID
    private String username; //用户名
    private String name; //姓名
    private String token; //令牌
}

2). 定义 LoginController

@Slf4j
@RestController
public class LoginController {

    @Autowired
    private EmpService empService;

    @PostMapping("/login")
    public Result login(@RequestBody Emp emp){
        log.info("员工来登录啦 , {}", emp);
        LoginInfo loginInfo = empService.login(emp);
        if(loginInfo != null){
            return Result.success(loginInfo);
        }
        return Result.error("用户名或密码错误~");
    }

}

3). **EmpService**接口中增加 login 登录方法

/**
 * 登录
 */
LoginInfo login(Emp emp);

4). EmpServiceImpl 实现login方法

@Override
public LoginInfo login(Emp emp) {
    Emp empLogin = empMapper.getUsernameAndPassword(emp);
    if(empLogin != null){
        LoginInfo loginInfo = new LoginInfo(empLogin.getId(), empLogin.getUsername(), empLogin.getName(), null);
        return loginInfo;
    }
    return null;
}

5). **EmpMapper**增加接口方法

/**
 * 根据用户名和密码查询员工信息
 */
@Select("select * from emp where username = #{username} and password = #{password}")
Emp getUsernameAndPassword(Emp emp);

1. 登录校验

什么是登录校验？

所谓登录校验，指的是我们在服务器端接收到浏览器发送过来的请求之后，首先我们要对请求进行校验。先要校验一下用户登录了没有，如果用户已经登录了，就直接执行对应的业务操作就可以了；如果用户没有登录，此时就不允许他执行相关的业务操作，直接给前端响应一个错误的结果，最终跳转到登录页面，要求他登录成功之后，再来访问对应的数据。

1. 思路

了解完什么是登录校验之后，接下来我们分析一下登录校验大概的实现思路。

首先我们在宏观上先有一个认知：

前面在讲解HTTP协议的时候，我们提到HTTP协议是无状态协议。什么又是无状态的协议？

所谓无状态，指的是每一次请求都是独立的，下一次请求并不会携带上一次请求的数据。而浏览器与服务器之间进行交互，基于HTTP协议也就意味着现在我们通过浏览器来访问了登陆这个接口，实现了登陆的操作，接下来我们在执行其他业务操作时，服务器也并不知道这个员工到底登陆了没有。因为HTTP协议是无状态的，两次请求之间是独立的，所以是无法判断这个员工到底登陆了没有。

那应该怎么来实现登录校验的操作呢？具体的实现思路可以分为两部分：

在员工登录成功后，需要将用户登录成功的信息存起来，记录用户已经登录成功的标记。
在浏览器发起请求时，需要在服务端进行统一拦截，拦截后进行登录校验。

想要判断员工是否已经登录，我们需要在员工登录成功之后，存储一个登录成功的标记，接下来在每一个接口方法执行之前，先做一个条件判断，判断一下这个员工到底登录了没有。如果是登录了，就可以执行正常的业务操作，如果没有登录，会直接给前端返回一个错误的信息，前端拿到这个错误信息之后会自动的跳转到登录页面。

我们程序中所开发的查询功能、删除功能、添加功能、修改功能，都需要使用以上套路进行登录校验。此时就会出现：相同代码逻辑，每个功能都需要编写，就会造成代码非常繁琐。

为了简化这块操作，我们可以使用一种技术：统一拦截技术。

通过统一拦截的技术，我们可以来拦截浏览器发送过来的所有的请求，拦截到这个请求之后，就可以通过请求来获取之前所存入的登录标记，在获取到登录标记且标记为登录成功，就说明员工已经登录了。如果已经登录，我们就直接放行(意思就是可以访问正常的业务接口了)。

我们要完成以上操作，会涉及到web开发中的两个技术：

会话技术：用户登录成功之后，在后续的每一次请求中，都可以获取到该标记。
统一拦截技术：过滤器Filter、拦截器Interceptor

下面我们先学习会话技术，然后再学习统一拦截技术。

1. 会话技术

介绍了登录校验的大概思路之后，我们先来学习下会话技术。

1. 介绍

什么是会话？

在我们日常生活当中，会话指的就是谈话、交谈。
在web开发当中，会话指的就是浏览器与服务器之间的一次连接，我们就称为一次会话。

在用户打开浏览器第一次访问服务器的时候，这个会话就建立了，直到有任何一方断开连接，此时会话就结束了。在一次会话当中，是可以包含多次请求和响应的。

比如：打开了浏览器来访问web服务器上的资源（浏览器不能关闭、服务器不能断开）

第1次：访问的是登录的接口，完成登录操作
第2次：访问的是部门管理接口，查询所有部门数据
第3次：访问的是员工管理接口，查询员工数据

只要浏览器和服务器都没有关闭，以上3次请求都属于一次会话当中完成的。

需要注意的是：会话是和浏览器关联的，当有三个浏览器客户端和服务器建立了连接时，就会有三个会话。同一个浏览器在未关闭之前请求了多次服务器，这多次请求是属于同一个会话。比如：1、2、3这三个请求都是属于同一个会话。当我们关闭浏览器之后，这次会话就结束了。而如果我们是直接把web服务器关了，那么所有的会话就都结束了。

知道了会话的概念了，接下来我们再来了解下会话跟踪。

**会话跟踪：**一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。

服务器会接收很多的请求，但是服务器是需要识别出这些请求是不是同一个浏览器发出来的。比如：1和2这两个请求是不是同一个浏览器发出来的，3和5这两个请求不是同一个浏览器发出来的。如果是同一个浏览器发出来的，就说明是同一个会话。如果是不同的浏览器发出来的，就说明是不同的会话。而识别多次请求是否来自于同一浏览器的过程，我们就称为会话跟踪。

我们使用会话跟踪技术就是要完成在同一个会话中，多个请求之间进行共享数据。

为什么要共享数据呢？

由于HTTP是无状态协议，在后面请求中怎么拿到前一次请求生成的数据呢？此时就需要在一次会话的多次请求之间进行数据共享

会话跟踪技术有两种：

Cookie（客户端会话跟踪技术）：数据存储在客户端浏览器当中
Session（服务端会话跟踪技术）：数据存储在储在服务端
令牌技术

1. 方案三 - 令牌技术

这里我们所提到的令牌，其实它就是一个用户身份的标识，看似很高大上，很神秘，其实本质就是一个字符串。

如果通过令牌技术来跟踪会话，我们就可以在浏览器发起请求。在请求登录接口的时候，如果登录成功，我就可以生成一个令牌，令牌就是用户的合法身份凭证。接下来我在响应数据的时候，我就可以直接将令牌响应给前端。

接下来我们在前端程序当中接收到令牌之后，就需要将这个令牌存储起来。这个存储可以存储在 cookie 当中，也可以存储在其他的存储空间(比如：localStorage)当中。

接下来，在后续的每一次请求当中，都需要将令牌携带到服务端。携带到服务端之后，接下来我们就需要来校验令牌的有效性。如果令牌是有效的，就说明用户已经执行了登录操作，如果令牌是无效的，就说明用户之前并未执行登录操作。

此时，如果是在同一次会话的多次请求之间，我们想共享数据，我们就可以将共享的数据存储在令牌当中就可以了。

优缺点

优点：
- 支持PC端、移动端
- 解决集群环境下的认证问题
- 减轻服务器的存储压力（无需在服务器端存储）
缺点：需要自己实现（包括令牌的生成、令牌的传递、令牌的校验）

针对于这三种方案，现在企业开发当中使用的最多的就是第三种令牌技术进行会话跟踪。而前面的这两种传统的方案，现在企业项目开发当中已经很少使用了。所以在我们的课程当中，我们也将会采用令牌技术来解决案例项目当中的会话跟踪问题。

JWT令牌最典型的应用场景就是登录认证：

在浏览器发起请求来执行登录操作，此时会访问登录的接口，如果登录成功之后，我们需要生成一个jwt令牌，将生成的 jwt令牌返回给前端。
前端拿到jwt令牌之后，会将jwt令牌存储起来。在后续的每一次请求中都会将jwt令牌携带到服务端。
服务端统一拦截请求之后，先来判断一下这次请求有没有把令牌带过来，如果没有带过来，直接拒绝访问，如果带过来了，还要校验一下令牌是否是有效。如果有效，就直接放行进行请求的处理。

在JWT登录认证的场景中我们发现，整个流程当中涉及到两步操作：

在登录成功之后，要生成令牌。
每一次请求当中，要接收令牌并对令牌进行校验。

稍后我们再来学习如何来生成jwt令牌，以及如何来校验jwt令牌。

1. JWT令牌

前面我们介绍了基于令牌技术来实现会话追踪。这里所提到的令牌就是用户身份的标识，其本质就是一个字符串。令牌的形式有很多，我们使用的是功能强大的 JWT令牌。

1. 介绍

JWT全称 JSON Web Token （官网：https://jwt.io/），定义了一种简洁的、自包含的格式，用于在通信双方以json数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的。
- 简洁：是指jwt就是一个简单的字符串。可以在请求参数或者是请求头当中直接传递。
- 自包含：指的是jwt令牌，看似是一个随机的字符串，但是我们是可以根据自身的需求在jwt令牌中存储自定义的数据内容。如：可以直接在jwt令牌中存储用户的相关信息。
- 简单来讲，jwt就是将原始的json数据格式进行了安全的封装，这样就可以直接基于jwt在通信双方安全的进行信息传输了。

JWT的组成：（JWT令牌由三个部分组成，三个部分之间使用英文的点来分割）

第一部分：Header(头），记录令牌类型、签名算法等。例如：{"alg":"HS256","type":"JWT"}
第二部分：Payload(有效载荷），携带一些自定义信息、默认信息等。例如：{"id":"1","username":"Tom"}
第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来。

签名的目的就是为了防jwt令牌被篡改，而正是因为jwt令牌最后一个部分数字签名的存在，所以整个jwt 令牌是非常安全可靠的。一旦jwt令牌当中任何一个部分、任何一个字符被篡改了，整个令牌在校验的时候都会失败，所以它是非常安全可靠的。

JWT是如何将原始的JSON格式数据，转变为字符串的呢？

其实在生成JWT令牌时，会对JSON格式的数据进行一次编码：进行base64编码
Base64：是一种基于64个可打印的字符来表示二进制数据的编码方式。既然能编码，那也就意味着也能解码。所使用的64个字符分别是A到Z、a到z、 0- 9，一个加号，一个斜杠，加起来就是64个字符。任何数据经过base64编码之后，最终就会通过这64个字符来表示。当然还有一个符号，那就是等号。等号它是一个补位的符号
需要注意的是Base64是编码方式，而不是加密方式。

1. 生成和校验

简单介绍了JWT令牌以及JWT令牌的组成之后，接下来我们就来学习基于Java代码如何生成和校验JWT令牌。

1). 首先我们先来实现JWT令牌的生成。要想使用JWT令牌，需要先引入JWT的依赖：

<!-- JWT依赖-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

在引入完JWT来赖后，就可以调用工具包中提供的API来完成JWT令牌的生成和校验。工具类：Jwts

2). 生成JWT代码实现：

@Test
public void testGenJwt() {
    Map<String, Object> claims = new HashMap<>();
    claims.put("id", 10);
    claims.put("username", "itheima");

    String jwt = Jwts.builder().signWith(SignatureAlgorithm.HS256, "aXRjYXN0")
        .addClaims(claims)
        .setExpiration(new Date(System.currentTimeMillis() + 12 * 3600 * 1000))
        .compact();

    System.out.println(jwt);
}

运行测试方法：

eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjcyNzI5NzMwfQ.fHi0Ub8npbyt71UqLXDdLyipptLgxBUg_mSuGJtXtBk

输出的结果就是生成的JWT令牌,，通过英文的点分割对三个部分进行分割，我们可以将生成的令牌复制一下，然后打开JWT的官网，将生成的令牌直接放在Encoded位置，此时就会自动的将令牌解析出来。

第一部分解析出来，看到JSON格式的原始数据，所使用的签名算法为HS256。

第二个部分是我们自定义的数据，之前我们自定义的数据就是id，还有一个exp代表的是我们所设置的过期时间。

由于前两个部分是base64编码，所以是可以直接解码出来。但最后一个部分并不是base64编码，是经过签名算法计算出来的，所以最后一个部分是不会解析的。

3). 实现了JWT令牌的生成，下面我们接着使用Java代码来校验JWT令牌(解析生成的令牌)：

@Test
public void testParseJwt() {
    Claims claims = Jwts.parser().setSigningKey("aXRjYXN0")
        .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MTAsInVzZXJuYW1lIjoiaXRoZWltYSIsImV4cCI6MTcwMTkwOTAxNX0.N-MD6DmoeIIY5lB5z73UFLN9u7veppx1K5_N_jS9Yko")
        .getBody();
    System.out.println(claims);
}

运行测试方法：

{id=10, username=itheima, exp=1701909015}

令牌解析后，我们可以看到id和过期时间，如果在解析的过程当中没有报错，就说明解析成功了。

下面我们做一个测试：把令牌header中的数字9变为8，运行测试方法后发现报错：

结论：篡改令牌中的任何一个字符，在对令牌进行解析时都会报错，所以JWT令牌是非常安全可靠的。

我们继续测试：修改生成令牌的时指定的过期时间，修改为1分钟。

@Test
public void genJwt(){
    Map<String, Object> claims = new HashMap<>();
    claims.put("id", 10);
    claims.put("username", "itheima");

    String jwt = Jwts.builder().signWith(SignatureAlgorithm.HS256, "aXRjYXN0")
        .addClaims(claims)
        .setExpiration(new Date(System.currentTimeMillis() + 60 * 1000)) //有效期60s
        .compact();
    System.out.println(jwt);
    //输出结果：eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjczMDA5NzU0fQ.RcVIR65AkGiax-ID6FjW60eLFH3tPTKdoK7UtE4A1ro
}

@Test
public void parseJwt(){
    Claims claims = Jwts.parser()
        .setSigningKey("aXRjYXN0")//指定签名密钥
        .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwiZXhwIjoxNjczMDA5NzU0fQ.RcVIR65AkGiax-ID6FjW60eLFH3tPTKdoK7UtE4A1ro")
        .getBody();

    System.out.println(claims);
}

等待1分钟之后运行测试方法发现也报错了，说明：JWT令牌过期后，令牌就失效了，解析的为非法令牌。

通过以上测试，我们在使用JWT令牌时需要注意：

JWT校验时使用的签名秘钥，必须和生成JWT令牌时使用的秘钥是配套的。
如果JWT令牌解析校验时报错，则说明 JWT令牌被篡改或失效了，令牌非法。

1. 登录时下发令牌

JWT令牌的生成和校验的基本操作我们已经学习完了，接下来我们就需要在案例当中通过JWT令牌技术来跟踪会话。具体的思路我们前面已经分析过了，主要就是两步操作：

生成令牌
1. 在登录成功之后来生成一个JWT令牌，并且把这个令牌直接返回给前端
校验令牌
1. 拦截前端请求，从请求中获取到令牌，对令牌进行解析校验

那我们首先来完成：登录成功之后生成JWT令牌，并且把令牌返回给前端。

实现步骤：

引入JWT工具类：在项目工程下创建 com.itheima.util 包，并把提供JWT工具类复制到该包下

package com.itheima.util;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;
import java.util.Map;

public class JwtUtils {

    private static String signKey = "SVRIRUlNQQ==";
    private static Long expire = 43200000L;

    /**
     * 生成JWT令牌
     * @return
     */
    public static String generateJwt(Map<String,Object> claims){
        String jwt = Jwts.builder()
                .addClaims(claims)
                .signWith(SignatureAlgorithm.HS256, signKey)
                .setExpiration(new Date(System.currentTimeMillis() + expire))
                .compact();
        return jwt;
    }

    /**
     * 解析JWT令牌
     * @param jwt JWT令牌
     * @return JWT第二部分负载 payload 中存储的内容
     */
    public static Claims parseJWT(String jwt){
        Claims claims = Jwts.parser()
                .setSigningKey(signKey)
                .parseClaimsJws(jwt)
                .getBody();
        return claims;
    }
}

完善 EmpServiceImpl中的 login 方法逻辑，登录成功，生成JWT令牌并返回

@Override
public LoginInfo login(Emp emp) {
    Emp empLogin = empMapper.getUsernameAndPassword(emp);
    if(empLogin != null){
        //1. 生成JWT令牌
        Map<String,Object> dataMap = new HashMap<>();
        dataMap.put("id", empLogin.getId());
        dataMap.put("username", empLogin.getUsername());
        
        String jwt = JwtUtils.generateJwt(dataMap);
        LoginInfo loginInfo = new LoginInfo(empLogin.getId(), empLogin.getUsername(), empLogin.getName(), jwt);
        return loginInfo;
    }
    return null;
}

重启服务，打开 Apifox 测试登录接口：

打开浏览器完成前后端联调操作：利用开发者工具，抓取一下网络请求

登录请求完成后，可以看到JWT令牌已经响应给了前端，此时前端就会将JWT令牌存储在浏览器本地。

服务器响应的JWT令牌存储在本地浏览器哪里了呢？

在当前案例中，JWT令牌存储在浏览器的本地存储空间 localstorage中了。 localstorage 是浏览器的本地存储，在移动端也是支持的。

我们在发起一个查询部门数据的请求，此时我们可以看到在请求头中包含一个token(JWT令牌)，后续的每一次请求当中，都会将这个令牌携带到服务端。

1. 过滤器Filter

刚才通过浏览器的开发者工具，我们可以看到在后续的请求当中，都会在请求头中携带JWT令牌到服务端，而服务端需要统一拦截所有的请求，从而判断是否携带的有合法的JWT令牌。

那怎么样来统一拦截到所有的请求校验令牌的有效性呢？这里我们会学习两种解决方案：

Filter过滤器
Interceptor拦截器

我们首先来学习过滤器Filter。

1. Filter快速入门

什么是Filter？

Filter表示过滤器，是 JavaWeb三大组件(Servlet、Filter、Listener)之一。
过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能
- 使用了过滤器之后，要想访问web服务器上的资源，必须先经过滤器，过滤器处理完毕之后，才可以访问对应的资源。
过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等。

下面我们通过Filter快速入门程序掌握过滤器的基本使用操作：

第1步，定义过滤器：1.定义一个类，实现 Filter 接口，并重写其所有方法。
第2步，配置过滤器：Filter类上加 @WebFilter 注解，配置拦截资源的路径。引导类上加 @ServletComponentScan 开启Servlet组件支持。

1). 定义过滤器

public class DemoFilter implements Filter {
    //初始化方法, web服务器启动, 创建Filter实例时调用, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init ...");
    }

    //拦截到请求时,调用该方法,可以调用多次
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
        System.out.println("拦截到了请求...");
    }

    //销毁方法, web服务器关闭时调用, 只调用一次
    public void destroy() {
        System.out.println("destroy ... ");
    }
}

init方法：过滤器的初始化方法。在web服务器启动的时候会自动的创建Filter过滤器对象，在创建过滤器对象的时候会自动调用init初始化方法，这个方法只会被调用一次。
doFilter方法：这个方法是在每一次拦截到请求之后都会被调用，所以这个方法是会被调用多次的，每拦截到一次请求就会调用一次doFilter()方法。
destroy方法：是销毁的方法。当我们关闭服务器的时候，它会自动的调用销毁方法destroy，而这个销毁方法也只会被调用一次。

2). 配置过滤器

在定义完Filter之后，Filter其实并不会生效，还需要完成Filter的配置，Filter的配置非常简单，只需要在Filter类上添加一个注解：@WebFilter，并指定属性urlPatterns，通过这个属性指定过滤器要拦截哪些请求

@WebFilter(urlPatterns = "/*") //配置过滤器要拦截的请求路径（ /* 表示拦截浏览器的所有请求 ）
public class DemoFilter implements Filter {
    //初始化方法, web服务器启动, 创建Filter实例时调用, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init ...");
    }

    //拦截到请求时,调用该方法,可以调用多次
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
        System.out.println("拦截到了请求...");
    }

    //销毁方法, web服务器关闭时调用, 只调用一次
    public void destroy() {
        System.out.println("destroy ... ");
    }
}

当我们在Filter类上面加了@WebFilter注解之后，接下来我们还需要在启动类上面加上一个注解@ServletComponentScan，通过这个@ServletComponentScan注解来开启SpringBoot项目对于Servlet组件的支持。

@ServletComponentScan //开启对Servlet组件的支持
@SpringBootApplication
public class TliasManagementApplication {
    public static void main(String[] args) {
        SpringApplication.run(TliasManagementApplication.class, args);
    }
}

重新启动服务，打开浏览器，执行部门管理的请求，可以看到控制台输出了过滤器中的内容：

**注意事项：**在过滤器Filter中，如果不执行放行操作，将无法访问后面的资源。放行操作：chain.doFilter(request, response);

1. 登录校验过滤器

1. 分析

过滤器Filter的快速入门以及使用细节我们已经介绍完了，接下来最后一步，我们需要使用过滤器Filter来完成案例当中的登录校验功能。

我们先来回顾下前面分析过的登录校验的基本流程：

要进入到后台管理系统，我们必须先完成登录操作，此时就需要访问登录接口login。
登录成功之后，我们会在服务端生成一个JWT令牌，并且把JWT令牌返回给前端，前端会将JWT令牌存储下来。
在后续的每一次请求当中，都会将JWT令牌携带到服务端，请求到达服务端之后，要想去访问对应的业务功能，此时我们必须先要校验令牌的有效性。
对于校验令牌的这一块操作，我们使用登录校验的过滤器，在过滤器当中来校验令牌的有效性。如果令牌是无效的，就响应一个错误的信息，也不会再去放行访问对应的资源了。如果令牌存在，并且它是有效的，此时就会放行去访问对应的web资源，执行相应的业务操作。

大概清楚了在Filter过滤器的实现步骤了，那在正式开发登录校验过滤器之前，我们思考两个问题：

所有的请求，拦截到了之后，都需要校验令牌吗？
1. 答案：登录请求例外
拦截到请求后，什么情况下才可以放行，执行业务操作？
1. 答案：有令牌，且令牌校验通过(合法)；否则都返回未登录错误结果

1. 具体流程

我们要完成登录校验，主要是利用Filter过滤器实现，而Filter过滤器的流程步骤：

基于上面的业务流程，我们分析出具体的操作步骤：

获取请求url
判断请求url中是否包含login，如果包含，说明是登录操作，放行
获取请求头中的令牌（token）
判断令牌是否存在，如果不存在，响应 401
解析token，如果解析失败，响应 401
放行

1. 代码实现

在 com.itheima.filter 包下创建TokenFilter，具体代码如下：

package com.itheima.filter;

import com.itheima.utils.JwtUtils;
import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpStatus;
import org.springframework.util.StringUtils;
import java.io.IOException;

/**
 * 令牌校验过滤器
 */
@Slf4j
@WebFilter(urlPatterns = "/*")
public class TokenFilter implements Filter {

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //1. 获取请求url。
        String url = request.getRequestURL().toString();

        //2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行。
        if(url.contains("login")){ //登录请求
            log.info("登录请求 , 直接放行");
            chain.doFilter(request, response);
            return;
        }

        //3. 获取请求头中的令牌（token）。
        String jwt = request.getHeader("token");

        //4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）。
        if(!StringUtils.hasLength(jwt)){ //jwt为空
            log.info("获取到jwt令牌为空, 返回错误结果");
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
            return;
        }

        //5. 解析token，如果解析失败，返回错误结果（未登录）。
        try {
            JwtUtils.parseJWT(jwt);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("解析令牌失败, 返回错误结果");
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
            return;
        }

        //6. 放行。
        log.info("令牌合法, 放行");
        chain.doFilter(request , response);
    }

}

登录校验的过滤器我们编写完成了，接下来我们就可以重新启动服务来做一个测试：

测试1：未登录是否可以访问部门管理页面

首先关闭浏览器，重新打开浏览器，在地址栏中输入：http://localhost:90

由于用户没有登录，登录校验过滤器返回错误信息，前端页面根据返回的错误信息结果，自动跳转到登录页面了

测试2：先进行登录操作，再访问部门管理页面

登录校验成功之后，可以正常访问相关业务操作页面

1. Filter详解

Filter过滤器的快速入门程序我们已经完成了，接下来我们就要详细的介绍一下过滤器Filter在使用中的一些细节。主要介绍以下3个方面的细节：

过滤器的执行流程
过滤器的拦截路径配置
过滤器链

1. 执行流程

首先我们先来看下过滤器的执行流程：

过滤器当中我们拦截到了请求之后，如果希望继续访问后面的web资源，就要执行放行操作，放行就是调用 FilterChain对象当中的doFilter()方法，在调用doFilter()这个方法之前所编写的代码属于放行之前的逻辑。

在放行后访问完 web 资源之后还会回到过滤器当中，回到过滤器之后如有需求还可以执行放行之后的逻辑，放行之后的逻辑我们写在doFilter()这行代码之后。

测试代码：

@WebFilter(urlPatterns = "/*") 
public class DemoFilter implements Filter {
    
    @Override //初始化方法, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");
    }
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        
        System.out.println("DemoFilter   放行前逻辑.....");

        //放行请求
        filterChain.doFilter(servletRequest,servletResponse);

        System.out.println("DemoFilter   放行后逻辑.....");
        
    }

    @Override //销毁方法, 只调用一次
    public void destroy() {
        System.out.println("destroy 销毁方法执行了");
    }
}

启动之后运行测试：

1. 拦截路径

执行流程我们搞清楚之后，接下来再来介绍一下过滤器的拦截路径，Filter可以根据需求，配置不同的拦截资源路径：

拦截路径	urlPatterns值	含义
拦截具体路径	/login	只有访问 /login 路径时，才会被拦截
目录拦截	/emps/*	访问/emps下的所有资源，都会被拦截
拦截所有	/*	访问所有资源，都会被拦截

下面我们来测试"拦截具体路径"：

@WebFilter(urlPatterns = "/login")  //拦截/login具体路径
public class DemoFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("DemoFilter   放行前逻辑.....");

        //放行请求
        filterChain.doFilter(servletRequest,servletResponse);

        System.out.println("DemoFilter   放行后逻辑.....");
    }


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

1. 过滤器链

最后我们在来介绍下过滤器链，什么是过滤器链呢？所谓过滤器链指的是在一个web应用程序当中，可以配置多个过滤器，多个过滤器就形成了一个过滤器链。

比如：在我们web服务器当中，定义了两个过滤器，这两个过滤器就形成了一个过滤器链。

而这个链上的过滤器在执行的时候会一个一个的执行，会先执行第一个Filter，放行之后再来执行第二个Filter，如果执行到了最后一个过滤器放行之后，才会访问对应的web资源。

访问完web资源之后，按照我们刚才所介绍的过滤器的执行流程，还会回到过滤器当中来执行过滤器放行后的逻辑，而在执行放行后的逻辑的时候，顺序是反着的。

先要执行过滤器2放行之后的逻辑，再来执行过滤器1放行之后的逻辑，最后在给浏览器响应数据。

过滤器链上过滤器的执行顺序：注解配置的Filter，优先级是按照过滤器类名（字符串）的自然排序。比如：

AbcFilter
DemoFilter

这两个过滤器来说，AbcFilter 会先执行，DemoFilter会后执行。

小结

登录认证的主线是“登录生成凭证，请求携带凭证，服务端校验凭证”。JWT 和过滤器只是实现这条主线的常见工具，公开前尤其要检查示例密钥和令牌是否只是教学占位。

MySQL 基础与 SQL 语句笔记

Sat, 21 Jun 2025 00:00:00 GMT

这篇笔记记录 MySQL 入门阶段的核心概念和 SQL 基础语法。当前内容偏课堂摘录，后续精修时可以把 DDL、DML、DQL、DCL 分开整理。

1. 相关概念

数据库：英文为 DataBase，简称DB，它是存储和管理数据的仓库。
数据库管理系统（DataBase Management System，简称DBMS），是操作和管理数据库的大型软件。

将来我们只需要操作这个软件，就可以通过这个软件来操纵和管理数据库了。

SQL（Structured Query Language，简称SQL）：结构化查询语言，它是操作关系型数据库的编程语言，定义了一套操作关系型数据库的统一标准。

1.1 关系型数据库（RDBMS）

概念：建立在关系模型基础上，由多张相互连接的二维表组成的数据库。而所谓二维表，指的是由行和列组成的表，如下图：

二维表的优点：

使用表存储数据，格式统一，便于维护
使用SQL语言操作，标准统一，使用方便，可用于复杂查询

1.2 数据模型

介绍完了关系型数据库之后，接下来我们再来看一看在Mysql数据库当中到底是如何来存储数据的，也就是Mysql 的数据模型。

MySQL是关系型数据库，是基于二维表进行数据存储的，具体的结构图下:

通过MySQL客户端连接数据库管理系统DBMS，然后通过DBMS操作数据库。
使用MySQL客户端，向数据库管理系统发送一条SQL语句，由数据库管理系统根据SQL语句指令去操作数据库中的表结构及数据。
一个数据库服务器中可以创建多个数据库，一个数据库中也可以包含多张表，而一张表中又可以包含多行记录。

1. SQL语句

SQL：结构化查询语言。一门操作关系型数据库的编程语言，定义操作所有关系型数据库的统一标准。SQL语句根据其功能被分为四大类：DDL、DML、DQL、DCL 。

分类	全称	说明
DDL	Data Definition Language	数据定义语言，用来定义数据库对象(数据库，表，字段)
DML	Data Manipulation Language	数据操作语言，用来对数据库表中的数据进行增删改
DQL	Data Query Language	数据查询语言，用来查询数据库中表的记录
DCL	Data Control Language	数据控制语言，用来创建数据库用户、控制数据库的访问权限

1.1 DDL语句

1.1 表操作

学习完了DDL语句当中关于数据库的操作之后，接下来我们继续学习DDL语句当中关于表结构的操作。

关于表结构的操作也是包含四个部分：创建表、查询表、修改表、删除表。

1.1 创建

语法：

  create table  表名(
          字段1  字段1类型 [约束]  [comment  字段1注释 ],
          字段2  字段2类型 [约束]  [comment  字段2注释 ],
          ......
          字段n  字段n类型 [约束]  [comment  字段n注释 ] 
  ) [ comment  表注释 ] ;

注意： [ ] 中的内容为可选参数；最后一个字段后面没有逗号

例：建表语句：

		create table tb_user (
		    id int comment 'ID,唯一标识',   # id是一行数据的唯一标识（不能重复）
		    username varchar(20) comment '用户名',
		    name varchar(10) comment '姓名',
		    age int comment '年龄',
		    gender char(1) comment '性别'
		) comment '用户表';

1.2 约束

概念：所谓约束就是作用在表中字段上的规则，用于限制存储在表中的数据。
作用：就是来保证数据库当中数据的正确性、有效性和完整性。（后面的学习会验证这些）
在MySQL数据库当中，提供了以下5种约束：

约束	描述	关键字
非空约束	限制该字段值不能为null	not null
唯一约束	保证字段的所有数据都是唯一、不重复的	unique
主键约束	主键是一行数据的唯一标识，要求非空且唯一	primary key
默认约束	保存数据时，如果未指定该字段值，则采用默认值	default
外键约束	让两张表的数据建立连接，保证数据的一致性和完整性	foreign key

注意：约束是作用于表中字段上的，可以在创建表/修改表的时候添加约束。

主键自增：auto_increment

每次插入新的行记录时，数据库自动生成id字段(主键)下的值
具有auto_increment的数据列是一个正数序列开始增长(从1开始自增)

1.3 数据类型

在上面建表语句中，我们在指定字段的数据类型时，用到了int 、varchar、char，那么在MySQL中除了以上的数据类型，还有哪些常见的数据类型呢？接下来,我们就来详细介绍一下MySQL的数据类型。

MySQL中的数据类型有很多，主要分为三类：数值类型、字符串类型、日期时间类型。

1). 数值类型

类型	大小	有符号(SIGNED)范围	无符号(UNSIGNED)范围	描述
TINYINT	1byte	(-128，127)	(0，255)	小整数值
SMALLINT	2bytes	(-32768，32767)	(0，65535)	大整数值
MEDIUMINT	3bytes	(-8388608，8388607)	(0，16777215)	大整数值
INT/INTEGER	4bytes	(-2147483648，2147483647)	(0，4294967295)	大整数值
BIGINT	8bytes	(-2^63，2^63-1)	(0，2^64-1)	极大整数值
FLOAT	4bytes	(-3.402823466 E+38，3.402823466351 E+38)	0 和 (1.175494351 E-38，3.402823466 E+38)	单精度浮点数值
DOUBLE	8bytes	(-1.7976931348623157 E+308，1.7976931348623157 E+308)	0 和 (2.2250738585072014 E-308，1.7976931348623157 E+308)	双精度浮点数值
DECIMAL		依赖于M(精度)和D(标度)的值	依赖于M(精度)和D(标度)的值	小数值(精确定点数)

2). 字符串类型

类型	大小	描述
CHAR	0-255 bytes	定长字符串(需要指定长度)
VARCHAR	0-65535 bytes	变长字符串(需要指定长度)
TINYBLOB	0-255 bytes	不超过255个字符的二进制数据
TINYTEXT	0-255 bytes	短文本字符串
BLOB	0-65 535 bytes	二进制形式的长文本数据
TEXT	0-65 535 bytes	长文本数据
MEDIUMBLOB	0-16 777 215 bytes	二进制形式的中等长度文本数据
MEDIUMTEXT	0-16 777 215 bytes	中等长度文本数据
LONGBLOB	0-4 294 967 295 bytes	二进制形式的极大文本数据
LONGTEXT	0-4 294 967 295 bytes	极大文本数据

char 与 varchar 都可以描述字符串，char是定长字符串，指定长度多长，就占用多少个字符，和字段值的长度无关。而varchar是变长字符串，指定的长度为最大占用长度。相对来说，char的性能会更高些。

3). 日期时间类型

类型	大小	范围	格式	描述
DATE	3	1000-01-01 至 9999-12-31	YYYY-MM-DD	日期值
TIME	3	-838:59:59 至 838:59:59	HH:MM:SS	时间值或持续时间
YEAR	1	1901 至 2155	YYYY	年份值
DATETIME	8	1000-01-01 00:00:00 至 9999-12-31 23:59:59	YYYY-MM-DD HH:MM:SS	混合日期和时间值
TIMESTAMP	4	1970-01-01 00:00:01 至 2038-01-19 03:14:07	YYYY-MM-DD HH:MM:SS	混合日期和时间值，时间戳

关于表结构的查看、修改、删除操作，工作中一般都是直接基于图形化界面操作。

修改数据库表结构的具体语法：

添加字段

-- 添加字段
alter table 表名 add  字段名  类型(长度)  [comment 注释]  [约束];

-- 比如： 为tb_emp表添加字段qq，字段类型为 varchar(11)
alter table tb_emp add  qq  varchar(11) comment 'QQ号码';

1.2 DML语句

DML英文全称是Data Manipulation Language(数据操作语言)，用来对数据库中表的数据记录进行增、删、改操作。

添加数据（INSERT）
修改数据（UPDATE）
删除数据（DELETE）

1.2.1 增加(insert)

1.2.1.1 语法

向指定字段添加数据

insert into 表名 (字段名1, 字段名2) values (值1, 值2);

全部字段添加数据

insert into 表名 values (值1, 值2, ...);

批量添加数据（指定字段）

insert into 表名 (字段名1, 字段名2) values (值1, 值2), (值1, 值2);

批量添加数据（全部字段）

insert into 表名 values (值1, 值2, ...), (值1, 值2, ...);

1.2.1.2 案例演示

案例1：向emp表的username, name, gender, phone, create_time, update_time字段插入数据

-- 因为设计表时create_time, update_time两个字段不能为NULL，所以也做为要插入的字段
insert into emp(username, name, gender, phone, create_time, update_time)
values ('wuji', '张无忌', 1, '13309091231', now(), now());

1.2.2 修改(update)

1.2.2.1 语法

update 表名 set 字段名1 = 值1 , 字段名2 = 值2 , .... [where 条件] ;

1.2.2.2 案例演示

update emp set name='张三', update_time=now() where id=1;

1.2.3 删除(delete)

1.2.3.1 语法

delete from 表名  [where  条件] ;

1.2.3.2 案例演示

delete from emp where id = 1;

1.3 DQL语句

1.3.1 介绍

DQL英文全称是Data Query Language(数据查询语言)，用来查询数据库表中的记录。

查询关键字：SELECT

查询操作是所有SQL语句当中最为常见，也是最为重要的操作。在一个正常的业务系统中，查询操作的使用频次是要远高于增删改操作的。当我们打开某个网站或APP所看到的展示信息，都是通过从数据库中查询得到的，而在这个查询过程中，还会涉及到条件、排序、分页等操作。

1.3.2 语法，语法结构如下：

SELECT
        字段列表
FROM
        表名列表
WHERE
        条件列表
GROUP  BY
        分组字段列表
HAVING
        分组后条件列表
ORDER BY
        排序字段列表
LIMIT
        分页参数

我们今天会将上面的完整语法拆分为以下几个部分学习：

基本查询（不带任何条件）
条件查询（where）
分组查询（group by）
排序查询（order by）
分页查询（limit）

1.3.3 基本查询，不带任何的查询条件。

语法如下：

查询多个字段

select 字段1, 字段2, 字段3 from  表名;

查询所有字段（通配符）

select *  from  表名;

设置别名

select 字段1 [ as 别名1 ] , 字段2 [ as 别名2 ]  from  表名;

去除重复记录

select distinct 字段列表 from  表名;

案例演示:

案例1：查询指定字段 name，entry_date并返回

select name,entry_date from emp;

* 号代表查询所有字段，在实际开发中尽量少用（不直观、影响效率）

1.3.4 条件查询

select  字段列表  from   表名   where   条件列表 ; -- 条件列表：意味着可以有多个条件

学习条件查询就是学习条件的构建方式，而在SQL语句当中构造条件的运算符分为两类：

比较运算符
逻辑运算符

常用的比较运算符如下:

比较运算符	功能
>	大于
>=	大于等于
<	小于
<=	小于等于
=	等于
<> 或 !=	不等于
between ... and ...	在某个范围之内(含最小、最大值)
in(...)	在in之后的列表中的值，多选一
like 占位符	模糊匹配(_匹配单个字符, %匹配任意个字符)
is null	是null

常用的逻辑运算符如下:

逻辑运算符	功能
and 或 &&	并且 (多个条件同时成立)
or 或 \|\|	或者 (多个条件任意一个成立)
not 或 !	非 , 不是

案例1：查询姓名为 '杨逍' 的员工

select id, username, password, name, gender, phone, salary, job, image, entry_date, create_time, update_time
from emp
where name = '杨逍'; -- 字符串使用''或""包含

案例2：查询薪资小于等于 5000 的员工信息

select id, username, password, name, gender, phone, salary, job, image, entry_date, create_time, update_time
from emp
where salary <=5000;

注意：查询为NULL的数据时，不能使用 = null 或 ！=null 。得使用 is null 或 is not null。

之前我们做的查询都是横向查询，就是根据条件一行一行的进行判断，而使用聚合函数查询就是纵向查询，它是对一列的值进行计算，然后返回一个结果值。（将一列数据作为一个整体，进行纵向计算）

常用聚合函数：

函数	功能
count	统计数量
max	最大值
min	最小值
avg	平均值
sum	求和

注意 : 聚合函数会忽略空值，对NULL值不作为统计。

count ：按照列去统计有多少行数据。
- 在根据指定的列统计的时候，如果这一列中有null的行，该行不会被统计在其中。
sum ：计算指定列的数值和，如果不是数值类型，那么计算结果为0
max ：计算指定列的最大值
min ：计算指定列的最小值
avg ：计算指定列的平均值

案例演示:

案例1：统计该企业员工数量

-- count(字段)
select count(id) from emp;-- 结果：30
select count(job) from emp;-- 结果：29 （聚合函数对NULL值不做计算）

-- count(常量)
select count(0) from emp;
select count('A') from emp;

-- count(*)  推荐此写法（MySQL底层进行了优化）
select count(*) from emp;

1.3.5 分组查询按照某一列或者某几列，把相同的数据进行合并输出。

- 分组其实就是按列进行分类(指定列下相同的数据归为一类)，然后可以对分类完的数据进行合并计算。
- 分组查询通常会使用聚合函数进行计算。

语法：

select  字段列表  from  表名  [where 条件]  group by 分组字段名  [having 分组后过滤条件];

案例演示：

案例1：根据性别分组 , 统计男性和女性员工的数量

select gender, count(*)
from emp
group by gender; -- 按照gender字段进行分组（gender字段下相同的数据归为一组）

注意事项:

分组之后，查询的字段一般为聚合函数和分组字段，查询其他字段无任何意义
执行顺序：where > 聚合函数 > having

where与having区别（面试题）

执行时机不同：where是分组之前进行过滤，不满足where条件，不参与分组；而having是分组之后对结果进行过滤。
判断条件不同：where不能对聚合函数进行判断，而having可以。

1.3.6 排序查询开发中是非常常见的一个操作，有升序排序，也有降序排序。

语法：

select  字段列表  
from   表名   
[where  条件列表] 
[group by  分组字段 ] 
order  by  字段1  排序方式1 , 字段2  排序方式2 … ;

排序方式：
- ASC ：升序（默认值）
- DESC：降序

案例演示：

案例1：根据入职时间, 对员工进行升序排序

select id, username, password, name, gender, phone, salary, job, image, entry_date, create_time, update_time
from emp
order by entry_date ASC; -- 按照entrydate字段下的数据进行升序排序

select id, username, password, name, gender, phone, salary, job, image, entry_date, create_time, update_time
from emp
order by  entry_date; -- 默认就是ASC（升序）

注意事项：如果是升序, 可以不指定排序方式ASC

1.3.7 分页查询业务系统开发时，也是非常常见的一个功能，日常我们在网站中看到的各种各样的分页条，后台也都需要借助于数据库的分页操作。

分页查询语法：

select  字段列表  from  表名  limit  起始索引, 查询记录数 ;

案例1：从起始索引0开始查询员工数据, 每页展示5条记录

select id, username, password, name, gender, phone, salary, job, image, entry_date, create_time, update_time
from emp
limit 0 , 5; -- 从索引0开始，向后取5条记录

注意事项:

起始索引从0开始。计算公式：起始索引 = （查询页码 - 1）* 每页显示记录数
分页查询是数据库的方言，不同的数据库有不同的实现，MySQL中是LIMIT
如果查询的是第一页数据，起始索引可以省略，直接简写为 limit 条数

小结

MySQL 入门可以先按“概念、表结构、SQL 分类、查询与分页”来理解。等基础语句熟悉后，再继续整理索引、事务和性能相关内容。

Spring 事务管理学习笔记

Sat, 21 Jun 2025 00:00:00 GMT

这篇笔记整理 Spring 中事务管理的使用场景和基础写法。核心问题是：当一个业务操作包含多次数据库写入时，如何保证它们要么全部成功，要么全部失败。

本文要点

事务用于保证一组业务操作的数据一致性。
@Transactional 可以交给 Spring 管理事务开启、提交和回滚。
异常类型、传播行为和回滚规则会影响事务是否生效。
事务一般放在业务层，而不是控制器或数据访问层。

1. Spring事务管理

1. 分析

在上述实现的新增员工的功能中，一旦在保存员工基本信息后出现异常。我们就会发现，员工信息保存成功，但是工作经历信息保存失败，造成了数据的不完整不一致。

产生原因：

先执行新增员工的操作，这步执行完毕，就已经往员工表 emp 插入了数据。
执行 1/0 操作，抛出异常
抛出异常之前，下面所有的代码都不会执行了，批量保存工作经历信息，这个操作也不会执行。

此时就出现问题了，员工基本信息保存了，员工的工作经历信息未保存，业务操作前后数据不一致。

而要想保证操作前后，数据的一致性，就需要让新增员工中涉及到的两个业务操作，要么全部成功，要么全部失败。那我们如何，让这两个操作要么全部成功，要么全部失败呢？

那就可以通过事务来实现，因为一个事务中的多个业务操作，要么全部成功，要么全部失败。

此时，我们就需要在新增员工功能中添加事务。

在方法运行之前，开启事务，如果方法成功执行，就提交事务，如果方法执行的过程当中出现异常了，就回滚事务。

**思考：**开发中所有的业务操作，一旦我们要进行控制事务，是不是都是这样的套路？

**答案：**是的。

所以在spring框架当中就已经把事务控制的代码都已经封装好了，并不需要我们手动实现。我们使用了spring框架，我们只需要通过一个简单的注解@Transactional就搞定了。

1. Transactional注解

注解：@Transactional

**作用：**就是在当前这个方法执行开始之前来开启事务，方法执行完毕之后提交事务。如果在这个方法执行的过程当中出现了异常，就会进行事务的回滚操作。

**位置：**业务层的方法上、类上、接口上

方法上：当前方法交给spring进行事务管理
类上：当前类中所有的方法都交由spring进行事务管理
接口上：接口下所有的实现类当中所有的方法都交给spring 进行事务管理

接下来，我们就可以在业务方法save上加上 @Transactional 来控制事务。

@Transactional
@Override
public void save(Emp emp) {
    //1.补全基础属性
    emp.setCreateTime(LocalDateTime.now());
    emp.setUpdateTime(LocalDateTime.now());
    //2.保存员工基本信息
    empMapper.insert(emp);

    int i = 1/0;

    //3. 保存员工的工作经历信息 - 批量
    Integer empId = emp.getId();
    List<EmpExpr> exprList = emp.getExprList();
    if(!CollectionUtils.isEmpty(exprList)){
        exprList.forEach(empExpr -> empExpr.setEmpId(empId));
        empExprMapper.insertBatch(exprList);
    }
}

@Transactional注解：我们一般会在业务层当中来控制事务，因为在业务层当中，一个业务功能可能会包含多个数据访问的操作。在业务层来控制事务，我们就可以将多个数据访问操作控制在一个事务范围内。

说明：可以在application.yml配置文件中开启事务管理日志，这样就可以在控制看到和事务相关的日志信息了

#spring事务管理日志
logging: 
  level: 
    org.springframework.jdbc.support.JdbcTransactionManager: debug

接下来，我们再次添加员工，看看控制台输出的日志信息。

添加Spring事务管理后，由于服务端程序引发了异常，所以事务进行回滚。

打开数据库，我们会看到 emp 表与 emp_expr 表中都没有对应的数据信息，保证了数据的一致性、完整性。

1. 事务进阶

前面我们通过spring事务管理注解@Transactional已经控制了业务层方法的事务。接下来我们要来详细的介绍一下@Transactional事务管理注解的使用细节。我们这里主要介绍@Transactional注解当中的两个常见的属性：

异常回滚的属性：rollbackFor
事务传播行为：propagation

我们先来学习下rollbackFor属性。

1. rollbackFor

我们在之前编写的业务方法上添加了@Transactional注解，来实现事务管理。

@Transactional
@Override
public void save(Emp emp) {
    //1.补全基础属性
    emp.setCreateTime(LocalDateTime.now());
    emp.setUpdateTime(LocalDateTime.now());
    //2.保存员工基本信息
    empMapper.insert(emp);
        
    int i = 1/0;
        
    //3. 保存员工的工作经历信息 - 批量
    Integer empId = emp.getId();
    List<EmpExpr> exprList = emp.getExprList();
    if(!CollectionUtils.isEmpty(exprList)){
        exprList.forEach(empExpr -> empExpr.setEmpId(empId));
        empExprMapper.insertBatch(exprList);
    }
}

以上业务功能save方法在运行时，会引发除0的算术运算异常(运行时异常)，出现异常之后，由于我们在方法上加了@Transactional注解进行事务管理，所以发生异常会执行rollback回滚操作，从而保证事务操作前后数据是一致的。

下面我们在做一个测试，我们修改业务功能代码，在模拟异常的位置上直接抛出Exception异常（编译时异常）

@Transactional
@Override
public void save(Emp emp) {
    //1.补全基础属性
    emp.setCreateTime(LocalDateTime.now());
    emp.setUpdateTime(LocalDateTime.now());
    //2.保存员工基本信息
    empMapper.insert(emp);
        
    //模拟：异常发生
    if(true){
        throw new Exception("出现异常了~~~");
    }
        
    //3. 保存员工的工作经历信息 - 批量
    Integer empId = emp.getId();
    List<EmpExpr> exprList = emp.getExprList();
    if(!CollectionUtils.isEmpty(exprList)){
        exprList.forEach(empExpr -> empExpr.setEmpId(empId));
        empExprMapper.insertBatch(exprList);
    }
}

说明：在service中向上抛出一个Exception编译时异常之后，由于是controller调用service，所以在controller中要有异常处理代码，此时我们选择在controller中继续把异常向上抛。

重新启动服务后，打开Apifox进行测试，请求添加员工的接口：

通过Apifox返回的结果，我们看到抛出异常了。然后我们在回到IDEA的控制台来看一下。

我们看到数据库的事务居然提交了，并没有进行回滚。

通过以上测试可以得出一个结论：默认情况下，只有出现RuntimeException(运行时异常)才会回滚事务。

假如我们想让所有的异常都回滚，需要来配置@Transactional注解当中的rollbackFor属性，通过rollbackFor这个属性可以指定出现何种异常类型回滚事务。

@Transactional(rollbackFor = Exception.class)
@Override
public void save(Emp emp) throws Exception {
    //1.补全基础属性
    emp.setCreateTime(LocalDateTime.now());
    emp.setUpdateTime(LocalDateTime.now());
    //2.保存员工基本信息
    empMapper.insert(emp);
        
    //int i = 1/0;
    if(true){
        throw new Exception("出异常啦....");
    }
        
    //3. 保存员工的工作经历信息 - 批量
    Integer empId = emp.getId();
    List<EmpExpr> exprList = emp.getExprList();
    if(!CollectionUtils.isEmpty(exprList)){
        exprList.forEach(empExpr -> empExpr.setEmpId(empId));
        empExprMapper.insertBatch(exprList);
    }
}

接下来我们重新启动服务，测试新增员工的操作：

控制台日志，可以看到因为出现了异常又进行了事务回滚。

结论：

在Spring的事务管理中，默认只有运行时异常 RuntimeException才会回滚。
如果还需要回滚指定类型的异常，可以通过rollbackFor属性来指定。

1. propagation

1. 介绍

我们接着继续学习@Transactional注解当中的第二个属性propagation，这个属性是用来配置事务的传播行为的。

什么是事务的传播行为呢？

就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。

例如：两个事务方法，一个A方法，一个B方法。在这两个方法上都添加了@Transactional注解，就代表这两个方法都具有事务，而在A方法当中又去调用了B方法。

所谓事务的传播行为，指的就是在A方法运行的时候，首先会开启一个事务，在A方法当中又调用了B方法， B方法自身也具有事务，那么B方法在运行的时候，到底是加入到A方法的事务当中来，还是B方法在运行的时候新建一个事务？这个就涉及到了事务的传播行为。

我们要想控制事务的传播行为，在@Transactional注解的后面指定一个属性propagation，通过 propagation 属性来指定传播行为。接下来我们就来介绍一下常见的事务传播行为。

属性值	含义
REQUIRED	【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW	需要新事务，无论有无，总是创建新事务
SUPPORTS	支持事务，有则加入，无则在无事务状态中运行
NOT_SUPPORTED	不支持事务，在无事务状态下运行,如果当前存在已有事务,则挂起当前事务
MANDATORY	必须有事务，否则抛异常
NEVER	必须没事务，否则抛异常
…

对于这些事务传播行为，我们只需要关注以下两个就可以了：

REQUIRED（默认值）

REQUIRES_NEW

1. 案例

接下来我们就通过一个案例来演示下事务传播行为propagation属性的使用。

**需求：**在新增员工信息时，无论是成功还是失败，都要记录操作日志。

步骤：

准备日志表 emp_log、实体类EmpLog、Mapper接口EmpLogMapper
在新增员工时记录日志

准备工作：

1). 创建数据库表 emp_log 日志表

-- 创建员工日志表
create table emp_log(
    id int unsigned primary key auto_increment comment 'ID, 主键',
    operate_time datetime comment '操作时间',
    info varchar(2000) comment '日志信息'
) comment '员工日志表';

2). 引入资料中提供的实体类：EmpLog

@Data
@NoArgsConstructor
@AllArgsConstructor
public class EmpLog {
    private Integer id; //ID
    private LocalDateTime operateTime; //操作时间
    private String info; //详细信息
}

3). 引入资料中提供的Mapper接口：EmpLogMapper

@Mapper
public interface EmpLogMapper {
        //插入日志
    @Insert("insert into emp_log (operate_time, info) values (#{operateTime}, #{info})")
    public void insert(EmpLog empLog);
}

4). 引入资料中提供的业务接口：EmpLogService

public interface EmpLogService {
        //记录新增员工日志
    public void insertLog(EmpLog empLog);
}

5). 引入资料中提供的业务实现类：EmpLogServiceImpl

@Service
public class EmpLogServiceImpl implements EmpLogService {

    @Autowired
    private EmpLogMapper empLogMapper;

    @Transactional
    @Override
    public void insertLog(EmpLog empLog) {
        empLogMapper.insert(empLog);
    }
}

代码实现:

业务实现类：EmpServiceImpl

@Autowired
private EmpMapper empMapper;
@Autowired
private EmpExprMapper empExprMapper;
@Autowired
private EmpLogService empLogService;

@Transactional(rollbackFor = {Exception.class})
@Override
public void save(Emp emp) {
    try {
        //1.补全基础属性
        emp.setCreateTime(LocalDateTime.now());
        emp.setUpdateTime(LocalDateTime.now());

        //2.保存员工基本信息
        empMapper.insert(emp);

        int i = 1/0;

        //3. 保存员工的工作经历信息 - 批量
        Integer empId = emp.getId();
        List<EmpExpr> exprList = emp.getExprList();
        if(!CollectionUtils.isEmpty(exprList)){
            exprList.forEach(empExpr -> empExpr.setEmpId(empId));
            empExprMapper.insertBatch(exprList);
        }
    } finally {
        //记录操作日志
        EmpLog empLog = new EmpLog(null, LocalDateTime.now(), emp.toString());
        empLogService.insertLog(empLog);
    }

}

测试:

重新启动SpringBoot服务，测试新增员工操作。我们可以看到控制台中输出的日志：

从日志中我们可以看到：

执行了插入员工数据的操作
执行了插入日志操作
程序发生Exception异常
执行事务回滚（保存员工数据、插入操作日志因为在一个事务范围内，两个操作都会被回滚）

然后在 emp_log 表中没有记录日志数据。

原因分析:

接下来我们就需要来分析一下具体是什么原因导致的日志没有成功的记录。

在执行 save 方法时开启了一个事务
当执行 empLogService.insertLog 操作时，insertLog设置的事务传播行是默认值REQUIRED，表示有事务就加入，没有则新建事务
此时：save 和 insertLog 操作使用了同一个事务，同一个事务中的多个操作，要么同时成功，要么同时失败，所以当异常发生时进行事务回滚，就会回滚 save 和 insertLog 操作

解决方案：

在EmpLogServiceImpl类中insertLog方法上，添加 @Transactional(propagation = Propagation.REQUIRES_NEW)

Propagation.REQUIRES_NEW ：不论是否有事务，都创建新事务，运行在一个独立的事务中。

@Service
public class EmpLogServiceImpl implements EmpLogService {

    @Autowired
    private EmpLogMapper empLogMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void insertLog(EmpLog empLog) {
        empLogMapper.insert(empLog);
    }
}

重启SpringBoot服务，再次测试新增员工的操作，会看到具体的日志如下：

那此时，EmpServiceImpl 中的 save 方法运行时，会开启一个事务。当调用 empLogService.insertLog(empLog) 时，也会创建一个新的事务，那此时，当 insertLog 方法运行完毕之后，事务就已经提交了。即使外部的事务出现异常，内部已经提交的事务，也不会回滚了，因为是两个独立的事务。

到此事务传播行为已演示完成，事务的传播行为我们只需要掌握两个：REQUIRED、REQUIRES_NEW。

**REQUIRED：**大部分情况下都是用该传播行为即可。
**REQUIRES_NEW：**当我们不希望事务之间相互影响时，可以使用该传播行为。比如：下订单前需要记录日志，不论订单保存成功与否，都需要保证日志记录能够记录成功。

1. 事务四大特性

面试题：事务有哪些特性？

原子性（Atomicity）：事务是不可分割的最小单元，要么全部成功，要么全部失败。
一致性（Consistency）：事务完成时，必须使所有的数据都保持一致状态。
隔离性（Isolation）：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行。
持久性（Durability）：事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。

事务的四大特性简称为：ACID

原子性（Atomicity） ：原子性是指事务包装的一组sql是一个不可分割的工作单元，事务中的操作要么全部成功，要么全部失败。
一致性（Consistency）：一个事务完成之后数据都必须处于一致性状态。
- 如果事务成功的完成，那么数据库的所有变化将生效。
- 如果事务执行出现错误，那么数据库的所有变化将会被回滚(撤销)，返回到原始状态。
隔离性（Isolation）：多个用户并发的访问数据库时，一个用户的事务不能被其他用户的事务干扰，多个并发的事务之间要相互隔离。
- 一个事务的成功或者失败对于其他的事务是没有影响。
持久性（Durability）：一个事务一旦被提交或回滚，它对数据库的改变将是永久性的，哪怕数据库发生异常，重启之后数据亦然存在。

小结

事务管理解决的是业务操作和数据库状态一致的问题。学习 Spring 事务时，除了会用 @Transactional，还要理解异常、回滚和 ACID 特性之间的关系。

编程基础：从输入输出到算法入门

Thu, 12 Jun 2025 00:00:00 GMT

本文整理编程学习过程中的基础知识和实用技巧，涵盖输入输出、常用函数、数据结构、惯例以及踩坑记录。

1. 基础语法要点

1.1 输入输出

基本输入输出

#include <iostream>
using namespace std;

int main() {
    int a, b;
    cin >> a >> b;        // 读取输入
    cout << a + b << endl; // 输出结果
    return 0;
}

读取整行输入

getline 可以正确处理包含空格的字符串输入：

string line;
getline(cin, line);  // 读取整行，包括空格

输入流写进判断条件

持续读取直到输入结束：

int a;
while (cin >> a) {
    // 处理每个输入的值
}

1.2 常用函数

swap - 交换变量

int a = 1, b = 2;
swap(a, b);  // 交换后 a=2, b=1

sort - 排序函数

sort 是 C++ 标准库 <algorithm> 中的排序函数，平均时间复杂度 O(n log n)。

#include <algorithm>

int arr[] = {5, 2, 9, 1};

// 默认升序排序
sort(arr, arr + 4);  // 结果：1, 2, 5, 9

// 降序排序
sort(arr, arr + 4, greater<int>());  // 结果：9, 5, 2, 1

// 对 vector 排序
vector<int> v = {5, 2, 9, 1};
sort(v.begin(), v.end());

// 自定义排序规则
bool cmp(int a, int b) { return a > b; }
sort(arr, arr + 4, cmp);  // 降序

参数说明：

第一个参数：排序起始位置的指针/迭代器
第二个参数：排序结束位置的后一位指针/迭代器（左闭右开区间 [begin, end)）

max - 取最大值

int res = 0;
res = max(res, nums[i]);  // 更新最大值

pow - 幂运算

double result = pow(2, 3);  // 计算 2^3 = 8

strlen - 字符串长度

char t[] = "hello";
int len = strlen(t + 1);  // 从 t[1] 开始计算长度

1.3 变量与数据结构

vector 初始化

vector<int> nums(5);  // 初始化大小为5的向量，元素为 {0, 0, 0, 0, 0}
vector<int> v = {1, 2, 3};  // 列表初始化

结构体 vs map 的选择

根据题目特点选择：

结构体：适合需要存储多个相关字段的情况
map：适合需要按键值快速查找的情况

string 数组的限制

// 注意：大量 string 数组可能导致编译器溢出
string arr[100000];  // 可能有问题，考虑使用 vector<string>

2. 常用技巧

2.1 变量命名惯例

竞赛中常用的缩写命名：

缩写	全称	用途
`vis`	visited	标记节点/状态是否已访问，用于图遍历（DFS/BFS）、动态规划、回溯算法
`ind`	index	表示数组、列表中的索引位置
`tmp`	temporary	临时变量，暂存中间值
`ans`	answer	存储最终结果
`res`	result	存储计算结果

2.2 实用技巧

单个 & 取余

int x = 7;
int result = x & 1;  // 取余操作，判断奇偶

#define int long long 与 signed main()

竞赛中为了避免整数溢出，常用宏定义：

#define int long long  // 把所有 int 替换成 long long

// 但 main() 必须返回 int，所以用 signed 代替
signed main() {
    // signed 不会被宏替换，符合 main() 返回类型要求
    return 0;
}

动态内存管理

// C++ 方式
int *p = new int;       // 分配 1 个 int
int *arr = new int[10]; // 分配数组

delete p;        // 释放单个
delete[] arr;    // 释放数组

强制类型转换

double d = 3.14;
int i = (int)d;  // C 风格强制转换
int j = static_cast<int>(d);  // C++ 风格，更安全

3. 数据结构基础

3.1 链表

链表结构定义

struct Node {
    int val;
    Node *next;
};

now->next 的含义

now 是一个 Node* 类型指针，指向链表中的某个节点
next 是 Node 结构体的成员，类型是 Node*
now->next 指向：
- 下一个节点（如果存在）
- NULL（如果当前节点是链表的最后一个节点）

链表基本操作示例

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int val;
    Node *next;
};

int main() {
    int n;
    cin >> n;
    
    Node Head;
    Node* now = &Head;
    
    // 创建链表
    int tmp;
    for (int i = 0; i < n; i++) {
        cin >> tmp;
        now->next = new Node;
        now = now->next;
        now->val = tmp;
    }
    
    // 删除指定位置的节点
    int m;
    cin >> m;
    while (m--) {
        now = &Head;
        cin >> tmp;
        for (int i = 0; i < tmp - 1; i++) {
            now = now->next;
        }
        now->next = now->next->next;
    }
    
    // 遍历输出
    now = &Head;
    while (now->next != NULL) {
        now = now->next;
        cout << now->val << " ";
    }
    
    return 0;
}

4. 踩坑记录（经验总结）

4.1 函数返回值必须写 return 0

问题：函数在某些条件下没有返回值，这是未定义行为(UB)。

int fun(int x) {
    if (x % 7 == 0) return 1;
    // 错误：当 x 不含 7 时没有返回值！
}

后果：

本地编译器可能默认返回 0（巧合正确）
在线评测系统可能陷入死循环或返回随机值

解决：一定要写 return 0;

4.2 注意题目数据类型

仔细阅读题目要求的数据类型范围
使用 long long 避免整数溢出
注意浮点数精度问题

4.3 数组搜索超时问题

数组搜索如果使用朴素算法，可能因为超时无法通过。考虑：

使用更高效的算法（如二分查找）
使用合适的数据结构（如 set、map）

4.4 格式化输出 %.10lg

%.10lg 是 printf 中的格式化控制符：

.10：最大保留 10 位有效数字（不是小数点后 10 位）
l：参数是 double 类型
g：智能选择输出格式
- 指数小于 -4 或大于等于精度时，使用科学计数法
- 否则使用常规小数格式
- 自动删除末尾无效的零

4.5 scanf 安全警告 (Error C4996)

问题：微软编译器中 scanf 被标记为不安全。

解决：

使用 scanf_s（微软特有）
或者在文件开头添加：#pragma warning(disable:4996)
或者使用 cin 代替

5. 完整代码示例

5.1 sort 排序找第 m 大数

#include <bits/stdc++.h>
using namespace std;

const int N = 1e3 + 7;  // 定义数组最大长度
int n, m, a[N];         // 全局数组，默认初始化为 0

int main() {
    cin >> n >> m;       // 输入元素个数 n 和要找的第 m 大数
    
    for (int i = 1; i <= n; i++)
        cin >> a[i];     // 输入数据存入 a[1]~a[n]
    
    sort(a + 1, a + 1 + n);  // 对 a[1]~a[n] 排序
    
    cout << a[n - m + 1] << endl;  // 输出第 m 大的数
    return 0;
}

说明：

排序后数组是升序，a[n] 是最大值
第 m 大的数位于 a[n - m + 1]

5.2 自定义排序规则

#include <bits/stdc++.h>
using namespace std;

// 自定义比较函数：降序
bool cmp(int a, int b) {
    return a > b;
}

int main() {
    int arr[] = {5, 2, 9, 1};
    sort(arr, arr + 4, cmp);  // 降序排序
    
    for (int i = 0; i < 4; i++)
        cout << arr[i] << " ";  // 输出：9 5 2 1
    
    return 0;
}

6. 总结

学习路径建议：

先掌握基础语法和输入输出
熟悉常用函数（sort、swap、max 等）
了解竞赛中的命名惯例和实用技巧
学习基础数据结构（数组、链表、vector）

常见错误清单：

[ ] 函数必须有返回值
[ ] 注意数据类型范围
[ ] 排序区间是左闭右开 [begin, end)
[ ] 链表操作注意空指针
[ ] 大数组考虑使用 vector 动态分配

常用算法笔记：BFS、贪心、前缀和与差分

Thu, 05 Jun 2025 00:00:00 GMT

1. BFS 广度优先搜索

1.1 核心思想

层级遍历：从起点逐层向外扩展，使用队列（FIFO）保证访问顺序
适用场景：无权图最短路径、连通性检测、迷宫问题

1.2 算法步骤

将起始节点放入队列，并标记为已访问
从队列中取出一个节点，访问其所有未被访问的相邻节点，并将这些节点加入队列
重复步骤 2，直到队列为空

1.3 C++ 模板代码

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

void BFS(vector<vector<int>>& graph, int start) {
    vector<bool> visited(graph.size(), false);
    queue<int> q;
    q.push(start);
    visited[start] = true;

    while (!q.empty()) {
        int node = q.front();
        q.pop();
        cout << node << " "; // 处理节点
        for (int neighbor : graph[node]) {
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
}

// 示例：邻接表图遍历
int main() {
    vector<vector<int>> graph = {{1,2}, {0,3}, {0,3,4}, {1,2,4}, {2,3}};
    cout << "BFS顺序：";
    BFS(graph, 0); // 输出：0 1 2 3 4
    return 0;
}

1.4 BFS 最短路径（带路径记录）

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
using namespace std;

vector<string> shortest_path(unordered_map<string, vector<string>>& graph, 
                           string start, string end) {
    queue<string> q;
    unordered_map<string, bool> visited;
    unordered_map<string, string> parent;  // 记录路径父节点
    
    q.push(start);
    visited[start] = true;
    parent[start] = "";

    while (!q.empty()) {
        string cur = q.front();
        q.pop();
        if (cur == end) {
            // 反向回溯路径
            vector<string> path;
            for (string at = end; at != ""; at = parent[at]) 
                path.push_back(at);
            reverse(path.begin(), path.end());
            return path;
        }
        for (string neighbor : graph[cur]) {
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                parent[neighbor] = cur;  // 记录父节点
                q.push(neighbor);
            }
        }
    }
    return {}; // 无路径
}

1.5 复杂度分析

时间复杂度：O(V + E)，其中 V 是节点数，E 是边数
空间复杂度：O(V)，最坏情况下需要存储所有节点

1.6 与 DFS 的区别

特性	BFS	DFS
遍历方式	按层级	按深度
数据结构	队列	栈/递归
最短路径	✅ 无权图最优	❌ 不保证
空间占用	较多（队列）	较少（递归栈）
适用场景	最短路径、层级遍历	路径存在性、回溯

2. 贪心算法

2.1 核心思想

局部最优：每一步选择当前最优解，无后效性
适用条件：问题需满足贪心选择性和最优子结构

2.2 C++ 模板与示例

#include <algorithm>
#include <vector>
using namespace std;

// 活动选择问题（最早结束优先）
struct Activity { int start, end; };
bool compare(Activity a, Activity b) { return a.end < b.end; }

int maxActivities(vector<Activity>& acts) {
    sort(acts.begin(), acts.end(), compare);
    int count = 1, lastEnd = acts[0].end;
    for (int i = 1; i < acts.size(); i++) {
        if (acts[i].start >= lastEnd) {
            count++;
            lastEnd = acts[i].end;
        }
    }
    return count;
}

2.3 典型应用场景

场景	策略	说明
活动安排	按结束时间排序	选择相容活动
Huffman 编码	合并频率最低节点	需优先队列
最小硬币找零	面值从大到小遍历	仅适用特定面值

2.4 贪心的局限性

反例：硬币面值 {1, 3, 4}，找零 6

贪心解：{4, 1, 1}（3 枚）
最优解：{3, 3}（2 枚）

结论：贪心不一定全局最优，需数学证明贪心策略的正确性。

3. 前缀和与差分

3.1 一维前缀和

用途：快速计算区间和，预处理 O(n)，查询 O(1)。

vector<int> prefix(n + 1, 0);
for (int i = 1; i <= n; i++) 
    prefix[i] = prefix[i-1] + arr[i-1];

// 查询 [L, R] 和：sum = prefix[R] - prefix[L-1];

应用场景：

区间求和问题
子数组和等于 k
结合哈希表优化

3.2 二维前缀和

用途：子矩阵求和（如 LeetCode 304）。

// 预处理
vector<vector<int>> sum(n+1, vector<int>(m+1, 0));
for (int i = 1; i <= n; i++)
    for (int j = 1; j <= m; j++)
        sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + matrix[i-1][j-1];

// 查询 (x1,y1) 到 (x2,y2) 和：
int area = sum[x2][y2] - sum[x1-1][y2] - sum[x2][y1-1] + sum[x1-1][y1-1];

3.3 差分

用途：高效处理区间增减（如批量加减 k）。

vector<int> diff(n + 2, 0); // 多开空间防越界

void add(int l, int r, int k) {
    diff[l] += k;
    diff[r+1] -= k;
}

// 还原数组
for (int i = 1; i <= n; i++) 
    arr[i] = arr[i-1] + diff[i];

3.4 前缀和与差分的关系

操作	前缀和	差分
主要用途	快速查询	快速修改
时间复杂度	O(1) 查询	O(1) 修改
逆操作	差分的前缀和 = 原数组	前缀和的差分 = 原数组

结合使用：先差分批量更新，再前缀和得到最终数组。

3.5 典型例题

前缀和：区间和、子数组和等于 k、LeetCode 304
差分：区间覆盖统计（MC0351）、航班预订统计（LeetCode 1109）

4. 字典序最小序列

4.1 定义

字典序：从左到右逐字符比较，首个不同位字符小的序列更小。

示例：

"apple" < "apricot"（第三个字符 'p' < 'r'）
[1, 2, 3] < [1, 3, 2]（第二个元素 2 < 3）

4.2 贪心构造

核心思想：每一步选当前可用的最小字符，确保后续合法。

// 拼接字符串使字典序最小
sort(strs.begin(), strs.end(), [](string a, string b) {
    return a + b < b + a;
});
string ans;
for (string s : strs) ans += s;

5. C++ Queue 操作

函数	作用	示例
`push()`	队尾插入元素	`q.push(10);`
`pop()`	删除队首元素	`q.pop();`
`front()`	访问队首元素	`int x = q.front();`
`back()`	访问队尾元素	`int y = q.back();`
`empty()`	检测队列是否为空	`if (q.empty()) { ... }`
`size()`	返回队列元素数量	`int len = q.size();`

注意事项：

front() 和 pop() 前需检查队列非空，否则行为未定义
vector 不能作为底层容器（缺少 pop_front()）

Logback 日志框架入门笔记

Wed, 14 May 2025 00:00:00 GMT

这篇笔记整理 Java 项目中使用日志框架的基本原因和 Logback 的入门配置。当前主要保留课堂示例，后续可以补充生产环境日志切分、日志级别策略和问题排查案例。

本文要点

System.out.println 不适合长期承担项目日志职责。
日志框架可以控制输出级别、输出位置和格式。
Logback 常通过 logback.xml 配置 appender、encoder 和 root level。
合理的日志级别有助于调试、监控和后续维护。
之前我们编写程序时，也可以通过 System.out.println(...) 来输出日志，为什么我们还要学习单独的日志技术呢？

这是因为，如果通过 System.out.println(...) 来记录日志，会存在以下几点问题：

硬编码。所有的记录日志的代码，都是硬编码，没有办法做到灵活控制，要想不输出这个日志了，只能删除掉记录日志的代码。
只能输出日志到控制台。
不便于程序的扩展、维护。

所以，在现在的项目开发中，我们一般都会使用专业的日志框架，来解决这些问题。

1. 日志框架

1. Logback入门

1). 准备工作：引入logback的依赖（springboot中无需引入，在springboot中已经传递了此依赖）

2). 引入配置文件 logback.xml （资料中已经提供，拷贝进来，放在 src/main/resources 目录下；或者直接AI生成）

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度  %msg：日志消息，%n是换行符 -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50}-%msg%n</pattern>
        </encoder>
    </appender>

    <!-- 日志输出级别 -->
    <root level="ALL">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

3). 记录日志：定义日志记录对象Logger，记录日志

public class LogTest {
    
    //定义日志记录对象
    private static final Logger log = LoggerFactory.getLogger(LogTest.class);

    @Test
    public void testLog(){
        log.debug("开始计算...");
        int sum = 0;
        int[] nums = {1, 5, 3, 2, 1, 4, 5, 4, 6, 7, 4, 34, 2, 23};
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        log.info("计算结果为: "+sum);
        log.debug("结束计算...");
    }

}

运行单元测试，可以在控制台中看到输出的日志，如下所示：

我们可以看到在输出的日志信息中，不仅输出了日志的信息，还包括：日志的输出时间、线程名、具体在那个类中输出的。

1. Logback配置文件

Logback日志框架的配置文件叫 logback.xml 。

该配置文件是对Logback日志框架输出的日志进行控制的，可以来配置输出的格式、位置及日志开关等。

常用的两种输出日志的位置：控制台、系统文件。

1). 如果需要输出日志到控制台。添加如下配置：

<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d 表示日期，%thread 表示线程名，%-5level表示级别从左显示5个字符宽度，%msg表示日志消息，%n表示换行符 -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50}-%msg%n</pattern>
    </encoder>
</appender>

2). 如果需要输出日志到文件。添加如下配置：

<!-- 按照每天生成日志文件 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <!-- 日志文件输出的文件名, %i表示序号 -->
        <FileNamePattern>D:/tlias-%d{yyyy-MM-dd}-%i.log</FileNamePattern>
        <!-- 最多保留的历史日志文件数量 -->
        <MaxHistory>30</MaxHistory>
        <!-- 最大文件大小，超过这个大小会触发滚动到新文件，默认为 10MB -->
        <maxFileSize>10MB</maxFileSize>
    </rollingPolicy>

    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
        <!--格式化输出：%d 表示日期，%thread 表示线程名，%-5level表示级别从左显示5个字符宽度，%msg表示日志消息，%n表示换行符 -->
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50}-%msg%n</pattern>
    </encoder>
</appender>

3). 日志开关配置（开启日志（ALL），取消日志（OFF））

<!-- 日志输出级别 -->
<root level="ALL">
    <!--输出到控制台-->
    <appender-ref ref="STDOUT" />
    <!--输出到文件-->
    <appender-ref ref="FILE" />
</root>

1. Logback日志级别

日志级别指的是日志信息的类型，日志都会分级别，常见的日志级别如下（优先级由低到高）：

日志级别	说明	记录方式
trace	追踪，记录程序运行轨迹【使用很少】	log.trace("...")
debug	调试，记录程序调试过程中的信息，实际应用中一般将其视为最低级别【使用较多】	log.debug("...")
info	记录一般信息，描述程序运行的关键事件，如：网络连接、io操作【使用较多】	log.info("...")
warn	警告信息，记录潜在有害的情况【使用较多】	log.warn("...")
error	错误信息【使用较多】	log.error("...")

可以在配置文件logback.xml中，灵活的控制输出那些类型的日志。（大于等于配置的日志级别的日志才会输出）

<!-- 日志输出级别 -->
<root level="info">
    <!--输出到控制台-->
    <appender-ref ref="STDOUT" />
    <!--输出到文件-->
    <appender-ref ref="FILE" />
</root>

小结

日志框架解决的是可控制、可扩展、可排查的问题。掌握 Logback 的配置结构和日志级别后，再结合真实项目决定哪些信息应该输出到控制台、文件或监控系统。

数据库多表关系与 MyBatis 查询笔记

Wed, 14 May 2025 00:00:00 GMT

这篇笔记整理数据库表关系和后端查询实现，重点是理解外键约束、逻辑外键以及多表查询在业务代码中的落地方式。公开前建议再复核示例字段是否需要脱敏。

本文要点

外键约束用于建立表之间的数据关系，保证一致性和完整性。
实际项目中常见物理外键和逻辑外键两种取舍。
一对多、多对多关系会影响表结构和查询方式。
MyBatis 多表查询需要同时考虑 SQL、实体对象和结果映射。

一对多

外键约束：让两张表的数据建立连接，保证数据的一致性和完整性。

对应的关键字：foreign key

外键约束的语法：

-- 创建表时指定
create table 表名(
        字段名    数据类型,
        ...
        [constraint]   [外键名称]  foreign  key (外键字段名)   references   主表 (主表列名)        
);


-- 建完表后，添加外键
alter table  表名  add constraint  外键名称  foreign key(外键字段名) references 主表(主表列名);

方式1：通过SQL语句操作

-- 修改表： 添加外键约束
alter table emp  add  constraint  fk_dept_id  foreign key (dept_id)  references  dept(id);

方式2：图形化界面操作

在左侧菜单栏，在emp表上右键，选择 modify Table... (old UI)

当我们添加了外键之后，再删除ID为3的部门，就会发现，此时数据库报错了，不允许删除。

外键约束（foreign key）：保证了数据的完整性和一致性。

1. 物理外键与逻辑外键

物理外键
- 概念：使用foreign key定义外键关联另外一张表。
- 缺点：
  - 影响增、删、改的效率（需要检查外键关系）。
  - 仅用于单节点数据库，不适用于分布式、集群场景。
  - 容易引发数据库的死锁问题，消耗性能。
逻辑外键
- 概念：在业务层逻辑中，解决外键关联。
- 通过逻辑外键，就可以很方便的解决上述问题。

在现在的企业开发中，很少会使用物理外键，都是使用逻辑外键。甚至在一些数据库开发规范中，会明确指出禁止使用物理外键 foreign key

1. 一对一

其实一对一我们可以看成一种特殊的一对多。一对多我们是怎么设计表关系的？是不是在多的一方添加外键。同样我们也可以通过外键来体现一对一之间的关系，我们只需要在任意一方来添加一个外键就可以了。

一对一：在任意一方加入外键，关联另外一方的主键，并且设置外键为唯一的(UNIQUE)

2. 多对多

实现关系：建立第三张中间表，中间表至少包含两个外键，分别关联两方主键

SQL脚本：

-- 学生表
create table tb_student(
    id int auto_increment primary key comment '主键ID',
    name varchar(10) comment '姓名',
    no varchar(10) comment '学号'
) comment '学生表';
-- 学生表测试数据
insert into tb_student(name, no) values ('黛绮丝', '2000100101'),
                                        ('谢逊', '2000100102'),
                                        ('殷天正', '2000100103'),
                                        ('韦一笑', '2000100104');

-- 课程表
create table tb_course(
   id int auto_increment primary key comment '主键ID',
   name varchar(10) comment '课程名称'
) comment '课程表';
-- 课程表测试数据
insert into tb_course (name) values ('Java'), ('PHP'), ('MySQL') , ('Hadoop');

-- 学生课程表（中间表）
create table tb_student_course(
   id int auto_increment comment '主键' primary key,
   student_id int not null comment '学生ID',
   course_id  int not null comment '课程ID',
   constraint fk_courseid foreign key (course_id) references tb_course (id),
   constraint fk_studentid foreign key (student_id) references tb_student (id)
)comment '学生课程中间表';

-- 学生课程表测试数据
insert into tb_student_course(student_id, course_id) values (1,1),(1,2),(1,3),(2,2),(2,3),(3,4);

多对多：需要建立一张中间表，中间表中有两个外键字段，分别关联两方的主键。

1. 多表查询

1. 介绍

多表查询：查询时从多张表中获取所需数据

单表查询的SQL语句：select 字段列表 from 表名;

那么要执行多表查询，只需要使用逗号分隔多张表即可，如： select 字段列表 from 表1, 表2;

**笛卡尔积：**笛卡尔乘积是指在数学中，两个集合(A集合和B集合)的所有组合情况。

在多表查询时，需要消除无效的笛卡尔积，只保留表关联部分的数据。

在SQL语句中，如何去除无效的笛卡尔积呢？只需要给多表查询加上连接查询的条件即可。

select * from emp , dept where emp.dept_id = dept.id ;

1. 分类

多表查询可以分为：

连接查询
1. 内连接：相当于查询A、B交集部分数据
2. 外连接
  - 左外连接：查询左表所有数据(包括两张表交集部分数据)
  - 右外连接：查询右表所有数据(包括两张表交集部分数据)
子查询

1. 内连接

内连接查询：查询两表或多表中交集部分数据。

内连接从语法上可以分为：

隐式内连接
显式内连接

隐式内连接语法：

select  字段列表   from   表1 , 表2   where  条件 ... ;

显式内连接语法：

select  字段列表   from   表1  [ inner ]  join 表2  on  连接条件 ... ;

案例1：查询所有员工的ID，姓名，及所属的部门名称

隐式内连接实现

  select emp.id, emp.name, dept.name from emp , dept where emp.dept_id = dept.id;

显式内连接实现

  select emp.id, emp.name, dept.name from emp inner join dept on emp.dept_id = dept.id;

案例2：查询性别为男, 且工资高于8000 的员工的ID, 姓名, 及所属的部门名称
- 隐式内连接实现
- ```
  select emp.id, emp.name, dept.name from emp , dept where emp.dept_id = dept.id and emp.gender = 1 and emp.salary > 8000;
```
- 显式内连接实现
- ```
  select emp.id, emp.name, dept.name from emp inner join dept on emp.dept_id = dept.id where emp.gender = 1 and emp.salary > 8000;
```
- 在多表联查时，我们指定字段时，需要在字段名前面加上表名，来指定具体是哪一张的字段。如：emp.dept_id

给表起别名简化书写：

select  字段列表 from 表1 as 别名1 , 表2 as  别名2  where  条件 ... ;

select  字段列表 from 表1 别名1 , 表2  别名2  where  条件 ... ;  -- as 可以省略

使用了别名的多表查询：

select e.id, e.name, d.name from emp as e , dept as d where e.dept_id = d.id and e.gender = 1 and e.salary > 8000;

注意事项: 一旦为表起了别名，就不能再使用表名来指定对应的字段了，此时只能够使用别名来指定字段。

1. 外连接

外连接分为两种：左外连接和右外连接。

左外连接语法：

select  字段列表   from   表1  left  [ outer ]  join 表2  on  连接条件 ... ;

左外连接相当于查询表1(左表)的所有数据，当然也包含表1和表2交集部分的数据。

右外连接语法：

select  字段列表   from   表1  right  [ outer ]  join 表2  on  连接条件 ... ;

右外连接相当于查询表2(右表)的所有数据，当然也包含表1和表2交集部分的数据。

案例1：查询员工表所有员工的姓名, 和对应的部门名称 (左外连接)

-- 左外连接：以left join关键字左边的表为主表，查询主表中所有数据，以及和主表匹配的右边表中的数据
select e.name , d.name  from emp as e left join dept as d on e.dept_id = d.id ;

案例2：查询部门表所有部门的名称, 和对应的员工名称 (右外连接)

-- 右外连接：以right join关键字右边的表为主表，查询主表中所有数据，以及和主表匹配的左边表中的数据
select e.name , d.name from emp as e right join dept as d on e.dept_id = d.id;

案例3：查询工资高于8000 的所有员工的姓名, 和对应的部门名称 (左外连接)

select e.name , d.name  from emp as e left join dept as d on e.dept_id = d.id where e.salary > 8000;

注意事项：

左外连接和右外连接是可以相互替换的，只需要调整连接查询时SQL语句中表的先后顺序就可以了。而我们在日常开发使用时，更偏向于左外连接。

1. 子查询

1. 介绍

SQL语句中嵌套select语句，称为嵌套查询，又称子查询。

SELECT  *  FROM   t1   WHERE  column1 =  ( SELECT  column1  FROM  t2 ... );

子查询外部的语句可以是insert / update / delete / select 的任何一个，最常见的是 select。

根据子查询结果的不同分为：

标量子查询（子查询结果为单个值 [一行一列]）
列子查询（子查询结果为一列，但可以是多行）
行子查询（子查询结果为一行，但可以是多列）
表子查询（子查询结果为多行多列[相当于子查询结果是一张表]）

子查询可以书写的位置：

where之后
from之后
select之后

子查询的要点是，先对需求做拆分，明确具体的步骤，然后再逐条编写SQL语句。最终将多条SQL语句合并为一条。

1. 标量子查询

子查询返回的结果是单个值(数字、字符串、日期等)，最简单的形式，这种子查询称为标量子查询。

常用的操作符： = <> > >= < <=

案例1：查询最早入职的员工信息

-- 1. 查询最早的入职时间
select min(entry_date) from emp;  -- 结果: 2000-01-01

-- 2. 查询入职时间 = 最早入职时间的员工信息
select * from emp where entry_date = '2000-01-01';

-- 3. 合并为一条SQL
select * from emp where entry_date = (select min(entry_date) from emp);

案例2：查询在阮小五入职之后入职的员工信息

-- 1. 查询 "阮小五" 的入职日期
select entry_date from emp where name = '阮小五'; -- 结果: 2015-01-01

-- 2. 根据上述查询到的这个入职日期, 查询在该日期之后入职的员工信息
select * from emp where entry_date > '2015-01-01';

-- 3. 合并SQL为一条SQL
select * from emp where entry_date > (select entry_date from emp where name = '阮小五');

1. 列子查询

子查询返回的结果是一列(可以是多行)，这种子查询称为列子查询。

常用的操作符：

操作符	描述
in	在指定的集合范围之内，多选一
not in	不在指定的集合范围之内

案例1：查询 "教研部" 和 "咨询部" 的所有员工信息

-- 1. 查询 "教研部" 和 "咨询部" 的部门ID
select id from dept where name = '教研部' or name = '咨询部'; -- 结果: 3,2

-- 2. 根据上面查询出来的部门ID, 查询员工信息
select * from emp where dept_id in(3,2);

-- 3. 合并SQL为一条SQL语句
select * from emp where dept_id in (select id from dept where name = '教研部' or name = '咨询部');

1. 行子查询

子查询返回的结果是一行(可以是多列)，这种子查询称为行子查询。

常用的操作符：= 、<> 、IN 、NOT IN

案例1：查询与 "李忠" 的薪资及职位都相同的员工信息

-- 1. 查询 "李忠" 的薪资和职位
select salary , job from emp where name = '李忠'; -- 结果: 5000, 5

-- 2. 根据上述查询到的薪资和职位 , 查询对应员工的信息
select * from emp where (salary, job) = (5000,5);

-- 3. 将两条SQL合并为一条SQL
select * from emp where (salary, job) = (select salary , job from emp where name = '李忠');

1. 表子查询

子查询返回的结果是多行多列，常作为临时表，这种子查询称为表子查询。

案例：获取每个部门中薪资最高的员工信息

-- a. 获取每个部门的最高薪资
select dept_id, max(salary) from emp group by dept_id;

-- b. 查询每个部门中薪资最高的员工信息
select * from emp e , (select dept_id, max(salary) max_sal from emp group by dept_id) a
    where e.dept_id = a.dept_id and e.salary = a.max_sal;

1. 案例

根据需求，完成多表查询的SQL语句的编写。

\1. 查询 "教研部" 性别为男，且在 "2011-05-01" 之后入职的员工信息。

select e.* from emp as e , dept as d where e.dept_id = d.id and d.name = '教研部' and e.gender = 1 and e.entry_date > '2011-05-01';

\2. 查询工资低于公司平均工资的且性别为男的员工信息。

select e.* from emp as e , dept as d where e.dept_id = d.id and e.salary < (select avg(salary) from emp) and e.gender = 1;

\3. 查询部门人数超过 10 人的部门名称。

select d.name , count(*) from emp as e , dept as d where e.dept_id = d.id group by d.name having count(*) > 10;

\4. 查询在 "2010-05-01" 后入职，且薪资高于 10000 的 "教研部" 员工信息，并根据薪资倒序排序。

select * from emp e , dept d where e.dept_id = d.id and e.entry_date > '2010-05-01' and e.salary > 10000 and d.name = '教研部' order by e.salary desc;

\5. 查询工资低于本部门平均工资的员工信息。【难】

-- 5.1 查询每个部门的平均工资
select dept_id, avg(salary) avg_sal from emp group by dept_id;

-- 5.2 查询工资 低于本部门平均工资 的员工信息 。
select e.* from emp e , (select dept_id, avg(salary) avg_sal from emp group by dept_id) as a
          where e.dept_id = a.dept_id and e.salary < a.avg_sal;

1. 分页查询

要想从数据库中进行分页查询，我们要使用LIMIT关键字，格式为：limit 开始索引每页显示的条数。

1). 查询第1页数据的SQL语句是：

select * from emp  limit 0,10;

2). 查询第2页数据的SQL语句是：

select * from emp  limit 10,10;

3). 查询第3页的数据的SQL语句是：

select * from emp  limit 20,10;

观察以上SQL语句，发现：开始索引一直在改变，每页显示条数是固定的

开始索引的计算公式： 开始索引 = (当前页码 - 1) * 每页显示条数

我们继续基于页面原型，继续分析，得出以下结论：

前端在请求服务端时，传递的参数
1. 当前页码 page
2. 每页显示条数 pageSize
后端需要响应什么数据给前端
1. 所查询到的数据列表（存储到List 集合中）
2. 总记录数

后台给前端返回的数据包含：List集合(数据列表)、total(总记录数)

而这两部分我们通常封装到PageResult对象中，并将该对象转换为json格式的数据响应回给浏览器。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageResult {
        private Long total; //总记录数
        private List rows; //当前页数据列表
}

1. 接口描述

1). 基本信息

请求路径：/emps

请求方式：GET

接口描述：该接口用于员工列表数据的条件分页查询

2). 请求参数

参数名称	是否必须	示例	备注
name	否	张	姓名
gender	否	1	性别 , 1 男 , 2 女
begin	否	2010/1/1	范围匹配的开始时间(入职日期)
end	否	2020/1/1	范围匹配的结束时间(入职日期)
page	是	1	分页查询的页码，如果未指定，默认为1
pageSize	是	10	分页查询的每页记录数，如果未指定，默认为10

请求数据样例：

/emps?name=张&gender=1&begin=2007-09-01&end=2022-09-01&page=1&pageSize=10

3). 响应数据

参数格式：application/json

参数说明：

名称	类型	是否必须	备注
code	number	必须	响应码, 1 成功 , 0 失败
msg	string	非必须	提示信息
data	object	必须	返回的数据
\|- total	number	必须	总记录数
\|- rows	object []	必须	数据列表
\|- id	number	非必须	id
\|- username	string	非必须	用户名
\|- name	string	非必须	姓名
\|- password	string	非必须	密码
\|- gender	number	非必须	性别 , 1 男 ; 2 女
\|- image	string	非必须	图像
\|- job	number	非必须	职位, 说明: 1 班主任,2 讲师, 3 学工主管, 4 教研主管, 5 咨询师
\|- salary	number	非必须	薪资
\|- entryDate	string	非必须	入职日期
\|- deptId	number	非必须	部门id
\|- deptName	string	非必须	部门名称
\|- createTime	string	非必须	创建时间
\|- updateTime	string	非必须	更新时间

1. PageHelper分页插件

1. 介绍

前面我们已经完了基础的分页查询，大家会发现：分页查询功能编写起来比较繁琐。而分页查询的功能是非常常见的，我们查询员工信息需要分页查询，将来在做其他项目时，查询用户信息、订单信息、商品信息等等都是需要进行分页查询的。

而分页查询的思路、步骤是比较固定的。在Mapper接口中定义两个方法执行两条不同的SQL语句：

查询总记录数
指定页码的数据列表

在Service当中，调用Mapper接口的两个方法，分别获取：总记录数、查询结果列表，然后在将获取的数据结果封装到PageBean对象中。

大家思考下：在未来开发其他项目，只要涉及到分页查询功能(例：订单、用户、支付、商品)，都必须按照以上操作完成功能开发

结论：原始方式的分页查询，存在着"步骤固定"、"代码频繁"的问题

解决方案：可以使用一些现成的分页插件完成。对于Mybatis来讲现在最主流的就是PageHelper。

PageHelper是第三方提供的Mybatis框架中的一款功能强大、方便易用的分页插件，支持任何形式的单标、多表的分页查询。

官网：https://pagehelper.github.io/

那接下来，我们可以对比一下，使用PageHelper分页插件进行分页与原始方式进行分页代码实现的上的差别。

Mapper接口层：
- 原始的分页查询功能中，我们需要在Mapper接口中定义两条SQL语句。
- PageHelper实现分页查询之后，只需要编写一条SQL语句，而且不需要考虑分页操作，就是一条正常的查询语句。
Service层：
- 需要根据页码、每页展示记录数，手动的计算起始索引。
- 无需手动计算起始索引，直接告诉PageHelper需要查询那一页的数据，每页展示多少条记录即可。

1. 代码实现

当使用了PageHelper分页插件进行分页，就无需再Mapper中进行手动分页了。在Mapper中我们只需要进行正常的列表查询即可。在Service层中，调用Mapper的方法之前设置分页参数，在调用Mapper方法执行查询之后，解析分页结果，并将结果封装到PageResult对象中返回。

1). 在pom.xml引入依赖

<!--分页插件PageHelper-->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.4.7</version>
</dependency>

2). EmpMapper

/**
 * 查询所有的员工及其对应的部门名称
 */
@Select("select e.*, d.name deptName from emp as e left join dept as d on e.dept_id = d.id")
public List<Emp> list();

3). EmpServiceImpl

@Override
public PageResult page(Integer page, Integer pageSize) {
    //1. 设置分页参数
    PageHelper.startPage(page,pageSize);

    //2. 执行查询
    List<Emp> empList = empMapper.list();
    Page<Emp> p = (Page<Emp>) empList;

    //3. 封装结果
    return new PageResult(p.getTotal(), p.getResult());
}

注意：

PageHelper实现分页查询时，SQL语句的结尾一定一定一定不要加分号(;).。
PageHelper只会对紧跟在其后的第一条SQL语句进行分页处理。

1. 条件分页查询

条件分页查询在实际项目中非常常用，建议掌握。

小结

多表关系的核心是先把业务关系映射成表关系，再选择合适的查询和映射方式。外键是否落到数据库层，需要结合项目规模、性能和维护成本判断。

RESTful、Apifox 与 CRUD 接口实践

Wed, 14 May 2025 00:00:00 GMT

这篇笔记整理 RESTful 接口风格、Apifox 调试工具以及 Spring Boot 中 CRUD 接口的基础写法。后续精修时，可以把接口设计原则和代码实践拆成两个部分。

本文要点

REST 风格通过 URL 定位资源，通过 HTTP 动词表达操作。
常见 CRUD 操作可对应 GET、POST、PUT、DELETE。
Apifox 可用于接口文档管理、接口请求测试和 Mock。
Spring Boot 中推荐使用 @GetMapping 等派生注解限制请求方式。

什么是REST风格呢?

REST（Representational State Transfer），表述性状态转换，它是一种软件架构风格。

传统URL风格如下：

http://localhost:8080/user/getById?id=1 GET：查询id为1的用户
http://localhost:8080/user/saveUser POST：新增用户
http://localhost:8080/user/updateUser POST：修改用户
http://localhost:8080/user/deleteUser?id=1 GET：删除id为1的用户

基于REST风格URL如下：

http://localhost:8080/users/1 GET：查询id为1的用户
http://localhost:8080/users POST：新增用户
http://localhost:8080/users PUT：修改用户
http://localhost:8080/users/1 DELETE：删除id为1的用户

其中总结起来，就一句话：通过URL定位要操作的资源，通过HTTP动词(请求方式)来描述具体的操作。

在REST风格的URL中，通过四种请求方式，来操作数据的增删改查。

GET ：查询
POST ：新增
PUT ：修改
DELETE ：删除

我们看到如果是基于REST风格，定义URL，URL将会更加简洁、更加规范、更加优雅。

介绍：Apifox是一款集成了Api文档、Api调试、Api Mock、Api测试的一体化协作平台。

作用：接口文档管理、接口请求测试、Mock服务。

1. 接口测试

经过测试，我们发现，现在我们其实是可以通过任何方式的请求来访问查询部门的这个接口的。而在接口文档中，明确要求该接口的请求方式为GET，那么如何限制请求方式呢？

方式一：在controller方法的@RequestMapping注解中通过method属性来限定。
方式二：在controller方法上使用，@RequestMapping的衍生注解 @GetMapping。该注解就是标识当前方法，必须以GET方式请求。

	@RestController
	public class DeptController {
	
	    @Autowired
	    private DeptService deptService;
	
	    /**
	     * 查询部门列表
	     */
	    @GetMapping("/depts")
	    public Result list(){
	        List<Dept> deptList = deptService.findAll();
	        return Result.success(deptList);
	    }
	}
	```

上述两种方式，在项目开发中，推荐使用第二种方式，简洁、优雅。 

- GET方式：@GetMapping
- POST方式：@PostMapping
- PUT方式：@PutMapping
- DELETE方式：@DeleteMapping

#### 1. 数据封装

- 如果实体类属性名和数据库表查询返回的字段名不一致，不能自动封装。

 解决方案：

- 手动结果映射
- 起别名
- 开启驼峰命名

**3). 开启驼峰命名****(推荐)**

如果字段名与属性名符合驼峰命名规则，mybatis会自动通过驼峰命名规则映射。驼峰命名规则：   abc_xyz    =>   abcXyz

- 表中字段名：abc_xyz
- 类中属性名：abcXyz

在application.yml中做如下配置，开启开关。

```yaml
mybatis:
  configuration:
    map-underscore-to-camel-case: true

要使用驼峰命名前提是实体类的属性与数据库表中的字段名严格遵守驼峰命名。

1. 前后端联调

2. 联调测试

3. 请求访问流程

1). 浏览器发起请求，请求的是localhost:90 ，那其实请求的是nginx服务器。

2). 在nginx服务器中呢，并没有对请求直接进行处理，而是将请求转发给了后端的tomcat服务器，最终由tomcat服务器来处理该请求。

这个过程就是通过nginx的反向代理实现的。那为什么浏览器不直接请求后端的tomcat服务器，而是直接请求nginx服务器呢，主要有以下几点原因：

1). 安全：由于后端的tomcat服务器一般都会搭建集群，会有很多的服务器，把所有的tomcat暴露给前端，让前端直接请求tomcat，对于后端服务器是比较危险的。

2). 灵活：基于nginx的反向代理实现，更加灵活，后端想增加、减少服务器，对于前端来说是无感知的，只需要在nginx中配置即可。

3). 负载均衡：基于nginx的反向代理，可以很方便的实现后端tomcat的负载均衡操作。

具体的请求访问流程如下：

location：用于定义匹配特定uri请求的规则。

^~ /api/：表示精确匹配，即只匹配以/api/开头的路径。

rewrite：该指令用于重写匹配到的uri路径。

proxy_pass：该指令用于代理转发，它将匹配到的请求转发给位于后端的指令服务器。

1. 删除部门

方案二：通过Spring提供的 @RequestParam 注解，将请求参数绑定给方法形参

@DeleteMapping("/depts")
public Result delete(@RequestParam("id") Integer deptId){
    System.out.println("根据ID删除部门: " + deptId);
    return Result.success();
}

@RequestParam 注解的value属性，需要与前端传递的参数名保持一致。

@RequestParam注解required属性默认为true，代表该参数必须传递，如果不传递将报错。如果参数可选，可以将属性设置为false。

方案三：如果请求参数名与形参变量名相同，直接定义方法形参即可接收。（省略@RequestParam）

@DeleteMapping("/depts")
public Result delete(Integer id){
    System.out.println("根据ID删除部门: " + id);
    return Result.success();
}

对于以上的这三种方案呢，我们推荐第三种方案。

1. 代码实现

1). Controller层

在 DeptMapper 中，增加 delete 方法，代码实现如下：

/**
 * 根据id删除部门 - delete http://localhost:8080/depts?id=1
 */
@DeleteMapping("/depts")
public Result delete(Integer id){
    System.out.println("根据id删除部门, id=" + id);
    deptService.deleteById(id);
    return Result.success();
}

2). Service层

在 DeptService 中，增加 deleteById 方法，代码实现如下：

/**
 * 根据id删除部门
 */
void deleteById(Integer id);

在 DeptServiceImpl 中，增加 deleteById 方法，代码实现如下：

public void deleteById(Integer id) {
    deptMapper.deleteById(id);
}

3). Mapper层

在 DeptMapper 中，增加 deleteById 方法，代码实现如下：

/**
 * 根据id删除部门
 */
@Delete("delete from dept where id = #{id}")
void deleteById(Integer id);

如果mapper接口方法形参只有一个普通类型的参数，#{…} 里面的属性名可以随便写，如：#{id}、#{value}。

对于 DML 语句来说，执行完毕，也是有返回值的，返回值代表的是增删改操作，影响的记录数，所以可以将执行 DML 语句的方法返回值设置为 Integer。但是一般开发时，是不需要这个返回值的，所以也可以设置为void。

1. 新增部门

1. json参数接收

我们看到，在controller中，需要接收前端传递的请求参数。那接下来，我们就先来看看在服务器端的Controller程序中，如何获取json格式的参数。

JSON格式的参数，通常会使用一个实体对象进行接收。
规则：JSON数据的键名与方法形参对象的属性名相同，并需要使用@RequestBody注解标识。

前端传递的请求参数格式为json，内容如下：{"name":"研发部"}。这里，我们可以通过一个对象来接收，只需要保证对象中有name属性即可。

1. 代码实现

1). Controller层

在DeptController中增加方法save，具体代码如下：

/**
 * 新增部门 - POST http://localhost:8080/depts   请求参数：{"name":"研发部"}
 */
@PostMapping("/depts")
public Result save(@RequestBody Dept dept){
    System.out.println("新增部门, dept=" + dept);
    deptService.save(dept);
    return Result.success();
}

2). Service层

在DeptService中增加接口方法save，具体代码如下：

/**
 * 新增部门
 */
void save(Dept dept);

在DeptServiceImpl中增加save方法，完成添加部门的操作，具体代码如下：

public void save(Dept dept) {
    //补全基础属性
    dept.setCreateTime(LocalDateTime.now());
    dept.setUpdateTime(LocalDateTime.now());
    //保存部门
    deptMapper.insert(dept);
}

3). Mapper层

/**
 * 保存部门
 */
@Insert("insert into dept(name,create_time,update_time) values(#{name},#{createTime},#{updateTime})")
void insert(Dept dept);

如果在mapper接口中，需要传递多个参数，可以把多个参数封装到一个对象中。在SQL语句中获取参数的时候，#{...} 里面写的是对象的属性名【注意是属性名，不是表的字段名】。

1. 修改部门

对于任何业务的修改功能来说，一般都会分为两步进行：查询回显、修改数据。

1. 查询回显

1. 需求

当我们点击 "编辑" 的时候，需要根据ID查询部门数据，然后用于页面回显展示。

1. 接口描述

参照参照课程资料中提供的接口文档。 部门管理 -> 根据ID查询

1. 路径参数接收

/depts/1，/depts/2 这种在url中传递的参数，我们称之为路径参数。那么如何接收这样的路径参数呢？

路径参数：通过请求URL直接传递参数，使用{…}来标识该路径参数，需要使用 **@PathVariable**获取路径参数。如下所示：

如果路径参数名与controller方法形参名称一致，@PathVariable注解的value属性是可以省略的。

1. 代码实现

1). Controller层

在 DeptController 中增加 getById方法，具体代码如下：

/**
 * 根据ID查询 - GET http://localhost:8080/depts/1
 */
@GetMapping("/depts/{id}")
public Result getById(@PathVariable Integer id){
    System.out.println("根据ID查询, id=" + id);
    Dept dept = deptService.getById(id);
    return Result.success(dept);
}

2). Service层

在 DeptService 中增加 getById方法，具体代码如下：

/**
 * 根据id查询部门
 */
Dept getById(Integer id);

在 DeptServiceImpl 中增加 getById方法，具体代码如下：

public Dept getById(Integer id) {
    return deptMapper.getById(id);
}

3). Mapper层

在 DeptMapper 中增加 getById 方法，具体代码如下：

/**
* 根据ID查询部门数据
*/
@Select("select id, name, create_time, update_time from dept where id = #{id}")
Dept getById(Integer id);

1. 修改数据

1. 需求

查询回显回来之后，就可以对部门的信息进行修改了，修改完毕之后，点击确定，此时，就需要根据ID修改部门的数据。

通过接口文档，我们可以看到前端传递的请求参数是json格式的请求参数，在Controller的方法中，我们可以通过 @RequestBody 注解来接收，并将其封装到一个对象中。

1. 代码实现

1). Controller层

在 DeptController 中增加 update 方法，具体代码如下：

/**
 * 修改部门 - PUT http://localhost:8080/depts  请求参数：{"id":1,"name":"研发部"}
 */
@PutMapping("/depts")
public Result update(@RequestBody Dept dept){
    System.out.println("修改部门, dept=" + dept);
    deptService.update(dept);
    return Result.success();
}

2). Service层

在 DeptService 中增加 update 方法。

/**
 * 修改部门
 */
void update(Dept dept);

在 DeptServiceImpl 中增加 update 方法。由于是修改操作，每一次修改数据，都需要更新updateTime。所以，具体代码如下：

public void update(Dept dept) {
    //补全基础属性
    dept.setUpdateTime(LocalDateTime.now());
    //保存部门
    deptMapper.update(dept);
}

3). Mapper层

在 DeptMapper 中增加 update 方法，具体代码如下：

/**
 * 更新部门
 */
@Update("update dept set name = #{name},update_time = #{updateTime} where id = #{id}")
void update(Dept dept);

1. @RequestMapping

到此呢，关于基本的部门的增删改查功能，我们已经实现了。我们会发现，我们在 DeptController 中所定义的方法，所有的请求路径，都是 /depts 开头的，只要操作的是部门数据，请求路径都是 /depts 开头。

那么这个时候，我们其实是可以把这个公共的路径 /depts 抽取到类上的，那在各个方法上，就可以省略了这个 /depts 路径。代码如下：

一个完整的请求路径，应该是类上的 @RequestMapping 的value属性 + 方法上的 @RequestMapping的value属性。

小结

RESTful 的关键是资源路径和 HTTP 动词的配合，Apifox 则适合用来验证接口行为。CRUD 代码部分后续可以进一步整理成“接口设计”和“Controller 实现”两个小节。

Vue 基础语法与数据驱动视图笔记

Mon, 12 May 2025 00:00:00 GMT

这篇笔记整理 Vue 入门阶段的核心概念：渐进式框架、数据驱动视图、插值表达式和常用指令。

本文要点

Vue 是用于构建用户界面的渐进式 JavaScript 框架。
Vue 应用通过数据驱动视图，模板中可以使用插值表达式。
常用指令包括 v-for、v-bind、v-if、v-show、v-model 和 v-on。
生命周期有助于理解组件从创建到挂载、更新、销毁的过程。

vue

介绍

vue是一款用于构建用户界面的渐进式的JavaScript框架。官方网站。

构建用户界面 基于数据渲染出用户看到的界面，也就是所谓的 构建用户界面。

渐进式 所谓渐进，指的是我们使用Vue框架呢，我们不需要把所有的组件、语法全部学习完毕才可以使用Vue。而是，我们学习一点就可以使用一点了。

框架

框架：就是一套完整的项目解决方案，用于快速构建项目。这是我们接触的第一个框架，那在我们后面的学习中，我们还会学习很多的java语言中的框架，那通过这些框架呢，就可以来快速开发java项目，提高开发效率。
优点：大大提升前端项目的开发效率。
缺点：需要理解记忆框架的使用规则。（参照官网）

程序

1. 准备工作：

准备元素（div），交给 Vue 控制

2. 数据驱动视图：

准备数据。在创建Vue应用实例的时候，传入了一个js对象，在这个js对象中，我们要定义一个data方法，这个data方法的返回值就是Vue中的数据。
通过插值表达式渲染页面。插值表达式的写法：{{...}}

实现

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Vue-快速入门</title>
</head>
<body>
  <div id="app">
    {{message}}
  </div>

  <script type="module">
    import { createApp } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
    createApp({
      data(){
        return {
          message: 'Hello Vue'
        }
      }
    }).mount('#app')
  </script>
</body>
</html>

在上述入门程序编写时，需要注意这么几点：

Vue中定义数据，必须通过data方法来定义，data方法返回值是一个对象，在这个对象中定义数据。
插值表达式中编写的变量，一定是Vue中定义的数据，如果插值表达式中编写了一个变量，但是在Vue中未定义，将会报错。
Vue应用实例接管的区域是 #app，超出这个范围，就不受 Vue 控制了，所以 Vue 的插值表达式应写在 <div id="app">...</div> 里面。

vue指令

1. v-for

作用：列表渲染，遍历容器的元素或者对象的属性语法：<tr v-for="(item,index) in items" :key="item.id">{{ item }}</tr> 参数：

items 为遍历的数组
item 为遍历出来的元素
index 为索引/下标，从0开始；可以省略，省略index语法： v-for = "item in items" key：
作用：给元素添加的唯一标识，便于vue进行列表项的正确排序复用，提升渲染性能
推荐使用id作为key（唯一），不推荐使用index作为key（会变化，不对应） 注意：遍历的数组，必须在data中定义；要想让哪个标签循环展示多次，就在哪个标签上使用 v-for 指令。

2. v-bind

作用：动态为HTML标签绑定属性值，如设置href，src，style样式等。语法：v-bind:属性名="属性值"，例如 <img v-bind:src="item.image" width="30px"> 简化：:属性名="属性值"，例如 <img :src="item.image" width="30px"> 注意：v-bind 所绑定的数据，必须在data中定义/或基于data中定义的数据而来。

3. v-if & v-show

作用：这两类指令，都是用来控制元素的显示与隐藏的 v-if：

语法：v-if="表达式"，表达式值为 true，显示；false，隐藏
原理：基于条件判断，来控制创建或移除元素节点（条件渲染）
场景：要么显示，要么不显示，不频繁切换的场景
其它：可以配合 v-else-if / v-else 进行链式调用条件判断示例：

   <!-- 基于v-if/v-else-if/v-else指令来展示职位这一列 -->
  <td>
    <span v-if="emp.job === '1'">班主任</span>
    <span v-else-if="emp.job === '2'">讲师</span>
    <span v-else-if="emp.job === '3'">学工主管</span>
    <span v-else-if="emp.job === '4'">教研主管</span>
    <span v-else-if="emp.job === '5'">咨询师</span>
    <span v-else>其他</span>
  </td>

4.v-show

语法：v-show="表达式"，表达式值为 true，显示；false，隐藏
原理：基于CSS样式display来控制显示与隐藏
场景：频繁切换显示隐藏的场景

5. v-model

作用：在表单元素上使用，双向数据绑定。可以方便的获取或设置表单项数据
语法：v-model="变量名"
这里的双向数据绑定，是指 Vue中的数据变化，会影响视图中的数据展示。视图中的输入的数据变化，也会影响Vue的数据模型。

6. v-on

作用：为html标签绑定事件（添加事件监听）语法：

v-on:事件名="方法名"
简写为 @事件名="…"
<input type="button" value="点我一下试试" v-on:click="handle">
<input type="button" value="点我一下试试" @click="handle">

这里的handle函数，就需要在Vue应用实例创建的时候创建出来，在methods定义。

Ajax

介绍

Ajax: 全称Asynchronous JavaScript And XML，异步的JavaScript和XML。其作用有如下2点：

与服务器进行数据交换：通过Ajax可以给服务器发送请求，并获取服务器响应的数据。
异步交互：可以在不重新加载整个页面的情况下，与服务器交换数据并更新部分网页的技术，如：搜索联想、用户名是否可用的校验等等。

Axios

Axios是对原生的AJAX进行封装，简化书写。

async、await

如果使用axios中提供的.then(function(){....}).catch(function(){....})，这种回调函数的写法，会使得代码的可读性和维护性变差。而为了解决这个问题，我们可以使用两个关键字，分别是：async、await。可以通过async、await可以让异步变为同步操作。async就是来声明一个异步方法，await是用来等待异步任务执行。

代码修改前：

search() {
    //基于axios发送异步请求，请求https://web-server.itheima.net/emps/list，根据条件查询员工列表
    axios.get(`https://web-server.itheima.net/emps/list?name=${this.searchForm.name}&gender=${this.searchForm.gender}&job=${this.searchForm.job}`).then(res => {
      this.empList = res.data.data
    })
  },

代码修改后：

  async search() {
    //基于axios发送异步请求，请求https://web-server.itheima.net/emps/list，根据条件查询员工列表
    const result = await axios.get(`https://web-server.itheima.net/emps/list?name=${this.searchForm.name}&gender=${this.searchForm.gender}&job=${this.searchForm.job}`);
    this.empList = result.data.data;
  },

修改后，代码就变成同步操作了，一行一行的从前往后执行。在前端项目开发中，经常使用这两个关键字配合，使得代码的可读性和可维护性变高。

6. Vue生命周期

vue的生命周期：指的是vue对象从创建到销毁的过程。 vue的生命周期包含8个阶段：每触发一个生命周期事件，会自动执行一个生命周期方法，这些生命周期方法也被称为钩子方法。 其中我们需要重点关注的是mounted，其他的我们了解即可。

mounted：挂载完成，Vue初始化成功，HTML页面渲染成功。以后我们一般用于页面初始化自动的ajax请求后台数据

小结

Vue 入门可以先围绕“数据如何驱动页面变化”来理解。插值表达式、指令、事件绑定和生命周期是后续学习组件化开发的基础。

JDBC 与 MyBatis 入门笔记

Mon, 12 May 2025 00:00:00 GMT

1.介绍MyBatis

MyBatis是一款优秀的 持久层 框架，用于简化JDBC的开发。

持久层：指的是就是数据访问层(dao)，是用来操作数据库的。
框架：是一个半成品软件，是一套可重用的、通用的、软件基础代码模型。在框架的基础上进行软件开发更加高效、规范、通用、可拓展。

在创建出来的springboot工程中，在引导类所在包下，在创建一个包 mapper 。在 mapper 包下创建一个接口 UserMapper ，这是一个持久层接口（Mybatis的持久层接口规范一般都叫 XxxMapper）。

单元测试

在创建出来的SpringBoot工程中，在src下的test目录下，已经自动帮我们创建好了测试类，并且在测试类上已经添加了注解 @SpringBootTest，代表该测试类已经与SpringBoot整合。

该测试类在运行时，会自动通过引导类加载Spring的环境（IOC容器）。我们要测试那个bean对象，就可以直接通过@Autowired注解直接将其注入进行，然后就可以测试了。

测试类代码如下：

@SpringBootTest
class SpringbootMybatisQuickstartApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testFindAll(){
        List<User> userList = userMapper.findAll();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

1. 配置Mybatis日志输出

默认情况下，在Mybatis中，SQL语句执行时，我们并看不到SQL语句的执行日志。在application.properties加入如下配置，即可查看日志：

#mybatis的配置
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

数据库连接池

数据库连接池的好处：

资源重用
提升系统响应速度
避免数据库连接遗漏

1. 增删改查操作

1. 删除

需求：根据ID删除用户信息
SQL：delete from user where id = 5;

/**
 * 根据id删除
 */
@Delete("delete from user where id = #{id}")
public void deleteById(Integer id);

在Mybatis中，我们可以通过参数占位符号 #{...} 来占位，在调用deleteById方法时，传递的参数值，最终会替换占位符。

1. 新增

需求：添加一个用户
SQL：insert into user(username,password,name,age) values('zhouyu','******','周瑜',20);
Mapper接口：

/**
 * 添加用户
 */
@Insert("insert into user(username,password,name,age) values(#{username},#{password},#{name},#{age})")
public void insert(User user);

如果在SQL语句中，我们需要传递多个参数，我们可以把多个参数封装到一个对象中。然后在SQL语句中，我们可以通过#{对象属性名}的方式，获取到对象中封装的属性值。

1. 修改

需求：根据ID更新用户信息
SQL：update user set username = 'zhouyu', password = '******', name = '周瑜', age = 20 where id = 1；
Mapper接口方法：

/**
 * 根据id更新用户信息
 */
@Update("update user set username = #{username},password = #{password},name = #{name},age = #{age} where id = #{id}")
public void update(User user);

1. 查询

需求：根据用户名和密码查询用户信息
SQL：select * from user where username = 'zhouyu' and password = '******'
Mapper接口方法：

/**
 * 根据用户名和密码查询用户信息
 */
@Select("select * from user where username = #{username} and password = #{password}")
public User findByUsernameAndPassword(@Param("username") String username, @Param("password") String password);

@param注解的作用是为接口的方法形参起名字的。（由于用户名唯一的，所以查询返回的结果最多只有一个，可以直接封装到一个对象中）

**说明：**基于官方骨架创建的springboot项目中，接口编译时会保留方法形参名，@Param注解可以省略 (#{形参名})。

在Mybatis中使用XML映射文件方式开发，需要符合一定的规范：

XML映射文件的名称与Mapper接口名称一致，并且将XML映射文件和Mapper接口放置在相同包下（同包同名）
XML映射文件的namespace属性为Mapper接口全限定名一致
XML映射文件中sql语句的id与Mapper接口中的方法名一致，并保持返回类型一致。

1. XML配置文件实现

第1步：创建XML映射文件

第2步：编写XML映射文件

xml映射文件中的dtd约束，直接从mybatis官网复制即可; 或者直接AI生成。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="">
 
</mapper>

第3步：配置

a. XML映射文件的namespace属性为Mapper接口全限定名

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.mapper.UserMapper">

</mapper>

b. XML映射文件中sql语句的id与Mapper接口中的方法名一致，并保持返回类型一致

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.mapper.EmpMapper">

    <!--查询操作-->
    <select id="findAll" resultType="com.itheima.pojo.User">
        select * from user
    </select>
    
</mapper>

resultType 属性的值，与查询返回的单条记录封装的类型一致。

运行测试类，执行结果：

1. SpringBoot配置文件

我们可以来对比一下，采用 application.properties 和 application.yml 来配置同一段信息(数据库连接信息)，两者之间的配置对比：

1. 语法

简单的了解过springboot所支持的配置文件，以及不同类型配置文件之间的优缺点之后，接下来我们就来了解下yml配置文件的基本语法：

大小写敏感
数值前边必须有空格，作为分隔符
使用缩进表示层级关系，缩进时，不允许使用Tab键，只能用空格（idea中会自动将Tab转换为空格）
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
#表示注释，从这个字符一直到行尾，都会被解析器忽略

了解完yml格式配置文件的基本语法之后，接下来我们再来看下yml文件中常见的数据格式。在这里我们主要介绍最为常见的两类：

定义对象或Map集合
定义数组、list或set集合

对象/Map集合

user:
  name: zhangsan
  age: 18
  password: ******

数组/List/Set集合

hobby: 
  - java
  - game
  - sport

在yml格式的配置文件中，如果配置项的值是以 0 开头的，值需要使用 '' 引起来，因为以0开头在yml中表示8进制的数据。

Spring Boot Web 基础学习笔记

Mon, 12 May 2025 00:00:00 GMT

这篇笔记从 HTTP 协议基础切入，逐步整理 Spring Boot Web 开发里的请求处理、响应格式和分层解耦。正文内容较长，后续精修时适合拆成多篇专题文章。

本文要点

HTTP 是基于请求-响应模型的无状态协议。
Spring Boot Web 通过注解和 Controller 处理请求。
后端项目通常按 Controller、Service、Mapper/DAO 分层组织。
Bean 声明、组件扫描和依赖注入是 Spring 应用结构的基础。

Springboot

阿里云提供的脚手架，网址为：https://start.aliyun.com

1. HTTP特点

基于TCP协议: 面向连接，安全

TCP是一种面向连接的(建立连接之前是需要经过三次握手)、可靠的、基于字节流的传输层通信协议，在数据传输方面更安全

基于请求-响应模型: 一次请求对应一次响应（先请求后响应）

请求和响应是一一对应关系，没有请求，就没有响应

HTTP协议是无状态协议: 对于数据没有记忆能力。每次请求-响应都是独立的

无状态指的是客户端发送HTTP请求给服务端之后，服务端根据请求响应数据，响应完后，不会记录任何信息。

缺点: 多次请求间不能共享数据

优点: 速度快

请求之间无法共享数据会引发的问题：

如：京东购物。加入购物车和去购物车结算是两次请求

由于HTTP协议的无状态特性，加入购物车请求响应结束后，并未记录加入购物车是何商品

发起去购物车结算的请求后，因为无法获取哪些商品加入了购物车，会导致此次请求无法正确展示数据

具体使用的时候，我们发现京东是可以正常展示数据的，原因是Java早已考虑到这个问题，并提出了使用会话技术(Cookie、Session)来解决这个问题。具体如何来做，我们后面课程中会讲到。

HTTP协议又分为：请求协议和响应协议

1. HTTP请求协议

1. 介绍

请求协议：**浏览器将数据以请求格式发送到服务器。包括：**请求行、请求头、请求体

- GET方式的请求协议：

请求行 ：HTTP请求中的第一行数据。由：请求方式、资源路径、协议/版本组成（之间使用空格分隔）

请求头 ：第二行开始，上图黄色部分内容就是请求头。格式为key: value形式

http是个无状态的协议，所以在请求头设置浏览器的一些自身信息和想要响应的形式。这样服务器在收到信息后，就可以知道是谁，想干什么了

常见的HTTP请求头有:

请求头	含义
Host	表示请求的主机名
User-Agent	浏览器版本。例如：Chrome浏览器的标识类似Mozilla/5.0 ...Chrome/79 ，IE浏览器的标识类似Mozilla/5.0 (Windows NT ...)like Gecko
Accept	表示浏览器能接收的资源类型，如text/，image/或者/表示所有；
Accept-Language	表示浏览器偏好的语言，服务器可以据此返回不同语言的网页；
Accept-Encoding	表示浏览器可以支持的压缩类型，例如gzip, deflate等。
Content-Type	请求主体的数据类型
Content-Length	数据主体的大小（单位：字节）

POST方式的请求协议：

请求行：包含请求方式、资源路径、协议/版本
请求头
请求体：存储请求参数
- 请求体和请求头之间是有一个空行隔开（作用：用于标记请求头结束）

GET请求和POST请求的区别：

区别方式	GET请求	POST请求
请求参数	请求参数在请求行中。<br/>例：/brand/findAll?name=OPPO&status=1	请求参数在请求体中
请求参数长度	请求参数长度有限制(浏览器不同限制也不同)	请求参数长度没有限制
安全性	安全性低。原因：请求参数暴露在浏览器地址栏中。	安全性相对高

2. HTTP响应协议

1. 格式介绍

响应协议：服务器将数据以响应格式返回给浏览器。包括：响应行、响应头、响应体
响应行：响应数据的第一行。响应行由协议及版本、响应状态码、状态码描述组成
- 协议/版本：HTTP/1.1
- 响应状态码：200
- 状态码描述：OK
响应头(以上图中黄色部分)：响应数据的第二行开始。格式为key：value形式
- http是个无状态的协议，所以可以在请求头和响应头中设置一些信息和想要执行的动作，这样，对方在收到信息后，就可以知道你是谁，你想干什么
- 常见的HTTP响应头有:

		Content-Type：表示该响应内容的类型，例如text/html，image/jpeg ；
		
		Content-Length：表示该响应内容的长度（字节数）；
		
		Content-Encoding：表示该响应压缩算法，例如gzip ；
		
		Cache-Control：指示客户端应如何缓存，例如max-age=300表示可以最多缓存300秒 ;
		
		Set-Cookie: 告诉浏览器为当前页面所在的域设置cookie ;

响应体(以上图中绿色部分)：响应数据的最后一部分。存储响应的数据
- 响应体和响应头之间有一个空行隔开（作用：用于标记响应头结束）

响应状态码

状态码分类	说明
1xx	响应中 --- 临时状态码。表示请求已经接受，告诉客户端应该继续请求或者如果已经完成则忽略
2xx	成功 --- 表示请求已经被成功接收，处理已完成
3xx	重定向 --- 重定向到其它地方，让客户端再发起一个请求以完成整个处理
4xx	客户端错误 --- 处理发生错误，责任在客户端，如：客户端的请求一个不存在的资源，客户端未被授权，禁止访问等
5xx	服务器端错误 --- 处理发生错误，责任在服务端，如：服务端抛出异常，路由出错，HTTP版本不支持等

关于响应状态码，我们先主要认识三个状态码，其余的等后期用到了再去掌握：

200 ok 客户端请求成功
404 Not Found 请求资源不存在
500 Internal Server Error 服务端发生不可预期的错误

设置响应数据

以下内容了解即可，实际开发中较少直接使用。

Web服务器对HTTP协议的响应数据进行了封装(HttpServletResponse)，并在调用Controller方法的时候传递给了该方法。这样，就使得程序员不必直接对协议进行操作，让Web开发更加便捷。

代码演示：

package com.itheima;

import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

@RestController
public class ResponseController {

    @RequestMapping("/response")
    public void response(HttpServletResponse response) throws IOException {
        //1.设置响应状态码
        response.setStatus(401);
        //2.设置响应头
        response.setHeader("name","itcast");
        //3.设置响应体
        response.setContentType("text/html;charset=utf-8");
        response.setCharacterEncoding("utf-8");
        response.getWriter().write("<h1>hello response</h1>");
    }

    @RequestMapping("/response2")
    public ResponseEntity<String> response2(HttpServletResponse response) throws IOException {
        return ResponseEntity
                .status(401)
                .header("name","itcast")
                .body("<h1>hello response</h1>");
    }

}

2. SpringBootWeb

SpringBoot 的自动配置原理较复杂，核心是 @SpringBootApplication 注解的组合使用。

@ResponseBody注解：

类型：方法注解、类注解
位置：书写在Controller方法上或类上
作用：将方法返回值直接响应给浏览器，如果返回值类型是实体对象/集合，将会转换为JSON格式后在响应给浏览器

但是在我们所书写的Controller中，只在类上添加了@RestController注解、方法添加了@RequestMapping注解，并没有使用@ResponseBody注解，怎么给浏览器响应呢？

这是因为，我们在类上加了@RestController注解，而这个注解是由两个注解组合起来的，分别是：@Controller 、@ResponseBody。那也就意味着，我们在类上已经添加了@ResponseBody注解了，而一旦在类上加了@ResponseBody注解，就相当于该类所有的方法中都已经添加了@ResponseBody注解。

提示：前后端分离的项目中，一般直接在请求处理类上加@RestController注解，就无需在方法上加@ResponseBody注解了。

1. 分层解耦

1. 三层架构

在我们进行程序设计以及程序开发时，尽可能让每一个接口、类、方法的职责更单一些（单一职责原则）。

单一职责原则：一个类或一个方法，就只做一件事情，只管一块功能。

这样就可以让类、接口、方法的复杂度更低，可读性更强，扩展性更好，也更利于后期的维护。

在我们项目开发中呢，可以将代码分为三层，如图所示：

Controller：控制层。接收前端发送的请求，对请求进行处理，并响应数据。
Service：业务逻辑层。处理具体的业务逻辑。
Dao：数据访问层(Data Access Object)，也称为持久层。负责数据访问操作，包括数据的增、删、改、查。

基于三层架构的程序执行流程，如图所示：

前端发起的请求，由Controller层接收（Controller响应数据给前端）
Controller层调用Service层来进行逻辑处理（Service层处理完后，把处理结果返回给Controller层）
Serivce层调用Dao层（逻辑处理过程中需要用到的一些数据要从Dao层获取）
Dao层操作文件中的数据（Dao拿到的数据会返回给Service层）

更多分层解耦实践请参考官方文档。

2. 分层解耦

软件设计原则：高内聚低耦合。

**高内聚：**指的是一个模块中各个元素之间的联系的紧密程度，如果各个元素(语句、程序段)之间的联系程度越高，则内聚性越高，即 "高内聚"。

**低耦合：**指的是软件中各个层、模块之间的依赖关联程序越低越好。

解耦思路

之前我们在编写代码时，需要什么对象，就直接new一个就可以了。这种做法呢，层与层之间代码就耦合了，当service层的实现变了之后，我们还需要修改controller层的代码。那应该怎么解耦呢？

1). 首先不能在EmpController中使用new对象。

2). 将要用到的对象交给一个容器管理。

3). 应用程序中用到这个对象，就直接从容器中获取

那问题来了，我们如何将对象交给容器管理呢？程序运行时，容器如何为程序提供依赖的对象呢？

我们想要实现上述解耦操作，就涉及到Spring中的两个核心概念：

控制反转： Inversion Of Control，简称IOC。对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转。
- 对象的创建权由程序员主动创建转移到容器(由容器创建、管理对象)。这个容器称为：IOC容器或Spring容器。
依赖注入： Dependency Injection，简称DI。容器为应用程序提供运行时，所依赖的资源，称之为依赖注入。
- 程序运行时需要某个资源，此时容器就为其提供这个资源。
- 例：EmpController程序运行时需要EmpService对象，Spring容器就为其提供并注入EmpService对象。
**bean对象：**IOC容器中创建、管理的对象，称之为：bean对象。

1. IOC&DI入门

1). 将Service及Dao层的实现类，交给IOC容器管理

在实现类加上 @Component 注解，就代表把当前类产生的对象交给IOC容器管理。

A. UserDaoImpl

@Component
public class UserDaoImpl implements UserDao {
    @Override
    public List<String> findAll() {
        InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
        ArrayList<String> lines = IoUtil.readLines(in, StandardCharsets.UTF_8, new ArrayList<>());
        return lines;
    }
}

B. UserServiceImpl

@Component
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    @Override
    public List<User> findAll() {
        List<String> lines = userDao.findAll();
        List<User> userList = lines.stream().map(line -> {
            String[] parts = line.split(",");
            Integer id = Integer.parseInt(parts[0]);
            String username = parts[1];
            String password = parts[2];
            String name = parts[3];
            Integer age = Integer.parseInt(parts[4]);
            LocalDateTime updateTime = LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            return new User(id, username, password, name, age, updateTime);
        }).collect(Collectors.toList());
        return userList;
    }
}

2). 为Controller 及 Service注入运行时所依赖的对象

A. UserServiceImpl

@Component
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;
    
    @Override
    public List<User> findAll() {
        List<String> lines = userDao.findAll();
        List<User> userList = lines.stream().map(line -> {
            String[] parts = line.split(",");
            Integer id = Integer.parseInt(parts[0]);
            String username = parts[1];
            String password = parts[2];
            String name = parts[3];
            Integer age = Integer.parseInt(parts[4]);
            LocalDateTime updateTime = LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            return new User(id, username, password, name, age, updateTime);
        }).collect(Collectors.toList());
        return userList;
    }
}

B. UserController

@RestController
public class UserController {
    
    @Autowired
    private UserService userService;

    @RequestMapping("/list")
    public List<User> list(){
        //1.调用Service
        List<User> userList = userService.findAll();
        //2.响应数据
        return userList;
    }

}

启动服务，运行测试。打开浏览器，地址栏直接访问：http://localhost:8080/user.html 。依然正常访问，就说明入门程序完成了。已经完成了层与层之间的解耦。

1. IOC详解

通过IOC和DI的入门程序呢，我们已经基本了解了IOC和DI的基础操作。接下来呢，我们学习下IOC控制反转和DI依赖注入的细节。

4.3.4.1 Bean的声明

前面我们提到IOC控制反转，就是将对象的控制权交给Spring的IOC容器，由IOC容器创建及管理对象。IOC容器创建的对象称为bean对象。

在之前的入门案例中，要把某个对象交给IOC容器管理，需要在类上添加一个注解：@Component

而Spring框架为了更好的标识web应用程序开发当中，bean对象到底归属于哪一层，又提供了@Component的衍生注解：

注解	说明	位置
@Component	声明bean的基础注解	不属于以下三类时，用此注解
@Controller	@Component的衍生注解	标注在控制层类上
@Service	@Component的衍生注解	标注在业务层类上
@Repository	@Component的衍生注解	标注在数据访问层类上（由于与mybatis整合，用的少）

那么此时，我们就可以使用 @Service 注解声明Service层的bean。使用 @Repository 注解声明Dao层的bean。代码实现如下：

Service层:

@Service
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    @Override
    public List<User> findAll() {
        List<String> lines = userDao.findAll();
        List<User> userList = lines.stream().map(line -> {
            String[] parts = line.split(",");
            Integer id = Integer.parseInt(parts[0]);
            String username = parts[1];
            String password = parts[2];
            String name = parts[3];
            Integer age = Integer.parseInt(parts[4]);
            LocalDateTime updateTime = LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            return new User(id, username, password, name, age, updateTime);
        }).collect(Collectors.toList());
        return userList;
    }
}

Dao层:

@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public List<String> findAll() {
        InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
        ArrayList<String> lines = IoUtil.readLines(in, StandardCharsets.UTF_8, new ArrayList<>());
        return lines;
    }
}

注意1：声明bean的时候，可以通过注解的value属性指定bean的名字，如果没有指定，默认为类名首字母小写。

注意2：使用以上四个注解都可以声明bean，但是在springboot集成web开发中，声明控制器bean只能用@Controller。

4.3.4.2 组件扫描

问题：使用前面学习的四个注解声明的bean，一定会生效吗？

答案：不一定。（原因：bean想要生效，还需要被组件扫描）

前面声明bean的四大注解，要想生效，还需要被组件扫描注解 @ComponentScan 扫描。
该注解虽然没有显式配置，但是实际上已经包含在了启动类声明注解 @SpringBootApplication 中，默认扫描的范围是启动类所在包及其子包。

所以，我们在项目开发中，只需要按照如上项目结构，将项目中的所有的业务类，都放在启动类所在包的子包中，就无需考虑组件扫描问题。

1. DI详解

上一小节我们讲解了控制反转IOC的细节，接下来呢，我们学习依赖注解DI的细节。

依赖注入，是指IOC容器要为应用程序去提供运行时所依赖的资源，而资源指的就是对象。

在入门程序案例中，我们使用了@Autowired这个注解，完成了依赖注入的操作，而这个Autowired翻译过来叫：自动装配。

@Autowired注解，默认是按照类型进行自动装配的（去IOC容器中找某个类型的对象，然后完成注入操作）

入门程序举例：在EmpController运行的时候，就要到IOC容器当中去查找EmpService这个类型的对象，而我们的IOC容器中刚好有一个EmpService这个类型的对象，所以就找到了这个类型的对象完成注入操作。

1. @Autowired用法

@Autowired 进行依赖注入，常见的方式，有如下三种：

1). 属性注入

@RestController
public class UserController {

    //方式一: 属性注入
    @Autowired
    private UserService userService;
    
  }

优点：代码简洁、方便快速开发。
缺点：隐藏了类之间的依赖关系、可能会破坏类的封装性。

2). 构造函数注入

@RestController
public class UserController {

    //方式二: 构造器注入
    private final UserService userService;
    
    @Autowired //如果当前类中只存在一个构造函数, @Autowired可以省略
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
 }

优点：能清晰地看到类的依赖关系、提高了代码的安全性。
缺点：代码繁琐、如果构造参数过多，可能会导致构造函数臃肿。
注意：如果只有一个构造函数，@Autowired注解可以省略。（通常来说，也只有一个构造函数）

3). setter注入

/**
 * 用户信息Controller
 */
@RestController
public class UserController {
    
    //方式三: setter注入
    private UserService userService;
    
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    
}

优点：保持了类的封装性，依赖关系更清晰。
缺点：需要额外编写setter方法，增加了代码量。

在项目开发中，基于@Autowired进行依赖注入时，基本都是第一种和第二种方式。（官方推荐第二种方式，因为会更加规范）但是在企业项目开发中，很多的项目中，也会选择第一种方式因为更加简洁、高效（在规范性方面进行了妥协）。

1. 注意事项

那如果在IOC容器中，存在多个相同类型的bean对象，会出现什么情况呢？

在下面的例子中，我们准备了两个UserService的实现类，并且都交给了IOC容器管理。代码如下：

此时，我们启动项目会发现，控制台报错了：

出现错误的原因呢，是因为在Spring的容器中，UserService这个类型的bean存在两个，框架不知道具体要注入哪个bean使用，所以就报错了。

如何解决上述问题呢？Spring提供了以下几种解决方案：

@Primary
@Qualifier
@Resource

方案一：使用@Primary注解

当存在多个相同类型的Bean注入时，加上@Primary注解，来确定默认的实现。

@Primary
@Service
public class UserServiceImpl implements UserService {
}

方案二：使用@Qualifier注解

指定当前要注入的bean对象。在@Qualifier的value属性中，指定注入的bean的名称。 @Qualifier注解不能单独使用，必须配合@Autowired使用。

@RestController
public class UserController {

    @Qualifier("userServiceImpl")
    @Autowired
    private UserService userService;

方案三：使用@Resource注解

是按照bean的名称进行注入。通过name属性指定要注入的bean的名称。

@RestController
public class UserController {
        
    @Resource(name = "userServiceImpl")
    private UserService userService;

面试题：@Autowird 与 @Resource的区别

@Autowired 是spring框架提供的注解，而@Resource是JDK提供的注解
@Autowired 默认是按照类型注入，而@Resource是按照名称注入

附录：常见状态码

状态码	英文描述	解释
200	OK	客户端请求成功，即处理成功，这是我们最想看到的状态码
302	Found	指示所请求的资源已移动到由Location响应头给定的 URL，浏览器会自动重新访问到这个页面
304	Not Modified	告诉客户端，你请求的资源至上次取得后，服务端并未更改，你直接用你本地缓存吧。隐式重定向
400	Bad Request	客户端请求有语法错误，不能被服务器所理解
403	Forbidden	服务器收到请求，但是拒绝提供服务，比如：没有权限访问相关资源
404	Not Found	请求资源不存在，一般是URL输入有误，或者网站资源被删除了
405	Method Not Allowed	请求方式有误，比如应该用GET请求方式的资源，用了POST
428	Precondition Required	服务器要求有条件的请求，告诉客户端要想访问该资源，必须携带特定的请求头
429	Too Many Requests	指示用户在给定时间内发送了太多请求（“限速”），配合 Retry-After(多长时间后可以请求)响应头一起使用
431	Request Header Fields Too Large	请求头太大，服务器不愿意处理请求，因为它的头部字段太大。请求可以在减少请求头域的大小后重新提交。
500	Internal Server Error	服务器发生不可预期的错误。服务器出异常了，赶紧看日志去吧
503	Service Unavailable	服务器尚未准备好处理请求，服务器刚刚启动，还未初始化好

状态码大全：https://cloud.tencent.com/developer/chapter/13553

小结

这篇笔记覆盖了 Spring Boot Web 入门中最常见的一组基础知识：HTTP 请求响应、分层结构、依赖注入和状态码。后续可以拆成协议基础、Controller 编写和项目分层三篇来精修。

JavaScript 基础语法笔记

Sat, 03 May 2025 00:00:00 GMT

这篇笔记记录 JavaScript 入门阶段的基础语法，包括变量声明、函数写法、对象、JSON 和 DOM 操作。

本文要点

let 用于声明变量，const 用于声明常量。
函数可以用普通函数、函数表达式和箭头函数声明。
对象和 JSON 是前端处理结构化数据的基础。
DOM 操作可以让脚本读取和修改页面元素。

js基础

1. 变量/常量

特点：js是弱类型语言，变量可以存放不同类型的值
声明：
- let：声明变量
- const:声明常量，一旦声明，常量的值不能改变
注意：
- 在早期的js中，声明变量还可以使用var,但是并不严谨（不推荐）

2. 输出语句

window.alert()：弹出警告框（使用频次较高）
console.log()：写入浏览器控制台（使用频次较高）
document.write()：向HTML的body内输出内容

3. 函数

格式一

function 函数名(参数1,参数2..){
    要执行的代码
}

格式二：匿名函数

函数表达式
箭头函数

// 函数表达式
var add = function (a,b){
    return a + b;
}

// 箭头函数
var add = (a,b) => {
    return a + b;
}

// 上述匿名函数声明好了之后，是将这个函数赋值给了add变量。 那我们就可以直接通过add函数直接调用，调用代码如下：
let result = add(10,20);
alert(result);

4. 自定义对象

let 对象名 = {
    属性名1: 属性值1,
    属性名2: 属性值2,
    属性名3: 属性值3,
    方法名称: function(形参列表){}
};

示例：

<script>
    //自定义对象
    let user = {
        name: "Tom",
        age: 10,
        gender: "男",
        sing: function(){
             console.log("悠悠的唱着最炫的民族风~");
         }
    }

    console.log(user.name);
    user.sing();
</script>

注意：在定义对象中的方法时，尽量不要使用箭头函数（this）。

5. JSON

JSON对象：JavaScript Object Notation，JavaScript对象标记法。JSON是通过JavaScript标记法书写的文本。而由于语法简单，层级结构鲜明，现多用于作为数据载体，在网络中进行数据传输。

代码演示：

//3. JSON - JS对象标记法
let person = {
  name: 'itcast',
  age: 18,
  gender: '男'
}
alert(JSON.stringify(person)); //js对象 --> json字符串

let personJson = '{"name": "heima", "age": 18}';
alert(JSON.parse(personJson).name);

6. JS DOM

DOM：Document Object Model 文档对象模型。也就是 JavaScript 将 HTML 文档的各个组成部分封装为对象。

作用

改变 HTML 元素的内容
改变 HTML 元素的样式（CSS）
对 HTML DOM 事件作出反应
添加和删除 HTML 元素

DOM操作

DOM的核心思想：将网页的内容当做对象来处理，标签的所有属性在该对象上都可以找到，并且修改这个对象的属性，就会自动映射到标签身上。
document对象
- 网页中所有内容都封装在document对象中
- 它提供的属性和方法都是用来访问和操作网页内容的，如：document.write(…)
DOM操作步骤:
- 获取DOM元素对象
- 操作DOM对象的属性或方法 (查阅文档)

代码演示：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>JS-DOM</title>
</head>
<body>

  <h1 id="title1">11111</h1>
  <h1>22222</h1>
  <h1>33333</h1>

  <script>
    //1. 修改第一个h1标签中的文本内容
    //1.1 获取DOM对象
    // let h1 = document.querySelector('#title1');
    //let h1 = document.querySelector('h1'); // 获取第一个h1标签

    let hs = document.querySelectorAll('h1');

    //1.2 调用DOM对象中属性或方法
    hs[0].innerHTML = '修改后的文本内容';
  </script>
</body>
</html>

小结

JavaScript 基础需要先掌握变量、函数、对象和 DOM 操作。后续精修时，可以把示例统一成更完整的小案例，避免只停留在语法片段。

JavaScript 事件监听笔记

Sat, 03 May 2025 00:00:00 GMT

这篇笔记整理 JavaScript 事件监听的基础概念和常见事件。

本文要点

HTML 事件是发生在页面元素上的交互行为。
addEventListener 可以把事件和处理函数绑定起来。
常见事件包括点击、鼠标移入移出、键盘输入、聚焦和表单提交。
事件监听常用于表单校验、按钮交互和动态页面行为。

JS 事件监听

事件介绍

什么是事件呢？HTML事件是发生在HTML元素上的 “事情”，例如：

按钮被点击
鼠标移到元素上
输入框失去焦点
按下键盘按键
........

而我们可以给这些事件绑定函数，当事件触发时，可以自动的完成对应的功能，这就是事件监听。

例如：对于我们所说的百度注册页面，我们给用户名输入框的失去焦点事件绑定函数，当我们用户输入完内容，在标签外点击了鼠标，对于用户名输入框来说，失去焦点，然后执行绑定的函数，函数进行用户名内容的校验等操作。

事件监听语法

事件源.addEventListener('事件类型', 要执行的函数);

演示

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JS-事件-事件绑定</title>
</head>

<body>
    <input type="button" id="btn1" value="点我一下1">
    <input type="button" id="btn2" value="点我一下2">

    <script>
        document.querySelector("#btn1").addEventListener('click', ()=>{
            alert("按钮1被点击了...");
        })
    </script>
</body>
</html>

常见事件

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JS-事件-常见事件</title>
</head>

<body>
    <form action="" style="text-align: center;">
        <input type="text" name="username" id="username">
        <input type="text" name="age" id="age">
        <input id="b1" type="submit" value="提交">
        <input id="b2" type="button" value="单击事件">
    </form>

    <br><br><br>

    <table width="800px" border="1" cellspacing="0" align="center">
        <tr>
            <th>学号</th>
            <th>姓名</th>
            <th>分数</th>
            <th>评语</th>
        </tr>
        <tr align="center">
            <td>001</td>
            <td>张三</td>
            <td>90</td>
            <td>很优秀</td>
        </tr>
        <tr align="center" id="last">
            <td>002</td>
            <td>李四</td>
            <td>92</td>
            <td>优秀</td>
        </tr>
    </table>
    
    <script>
        //click: 鼠标点击事件
        document.querySelector('#b2').addEventListener('click', () => {
            console.log("我被点击了...");
        })
        
        //mouseenter: 鼠标移入
        document.querySelector('#last').addEventListener('mouseenter', () => {
            console.log("鼠标移入了...");
        })

        //mouseleave: 鼠标移出
        document.querySelector('#last').addEventListener('mouseleave', () => {
            console.log("鼠标移出了...");
        })

        //keydown: 某个键盘的键被按下
        document.querySelector('#username').addEventListener('keydown', () => {
            console.log("键盘被按下了...");
        })

        //keyup: 某个键盘的键被抬起
        document.querySelector('#username').addEventListener('keyup', () => {
            console.log("键盘被抬起了...");
        })

        //blur: 失去焦点事件
        document.querySelector('#age').addEventListener('blur', () => {
            console.log("失去焦点...");
        })

        //focus: 元素获得焦点
        document.querySelector('#age').addEventListener('focus', () => {
            console.log("获得焦点...");
        })

        //input: 用户输入时触发
        document.querySelector('#age').addEventListener('input', () => {
            console.log("用户输入时触发...");
        })

        //submit: 提交表单事件
        document.querySelector('form').addEventListener('submit', () => {
            alert("表单被提交了...");
        })
    </script>
</body>

</html>

小结

事件监听是页面交互的入口。理解事件源、事件类型和回调函数之后，表单校验、按钮响应、键盘输入等常见交互都会更容易组织。

JUnit 单元测试学习笔记

Thu, 01 May 2025 00:00:00 GMT

这篇笔记整理 Java 后端单元测试的基础概念和 JUnit 常用写法。当前仍保留课堂笔记结构，后续可以补充更完整的测试命名规范和典型业务场景。

本文要点

软件测试可分为单元测试、集成测试、系统测试和验收测试。
JUnit 可以让测试代码与业务代码分离，并支持自动化运行。
常用能力包括参数化测试、断言、生命周期注解和依赖范围配置。
单元测试重点验证最小业务单元的正确性。

1. 单元测试

1.介绍

测试：是一种用来促进鉴定软件的正确性、完整性、安全性和质量的过程。
阶段划分：单元测试、集成测试、系统测试、验收测试。

1). 单元测试

介绍：对软件的基本组成单位进行测试，最小测试单位。
目的：检验软件基本组成单位的正确性。
测试人员：开发人员

2). 集成测试

介绍：将已分别通过测试的单元，按设计要求组合成系统或子系统，再进行的测试。
目的：检查单元之间的协作是否正确。
测试人员：开发人员

3). 系统测试

介绍：对已经集成好的软件系统进行彻底的测试。
目的：验证软件系统的正确性、性能是否满足指定的要求。
测试人员：测试人员

4). 验收测试

介绍：交付测试，是针对用户需求、业务流程进行的正式的测试。
目的：验证软件系统是否满足验收标准。
测试人员：客户/需求方

**测试方法：**白盒测试、黑盒测试及灰盒测试。

2. Junit入门

我们使用了JUnit单元测试框架进行测试，将会有以下优势：

测试代码与源代码分开，便于维护。
可根据需要进行自动化测试。
可自动分析测试结果，产出测试报告。

入门程序

需求：使用JUnit，对UserService中的业务方法进行单元测试，测试其正确性。

在pom.xml中，引入JUnit的依赖。

<!--Junit单元测试依赖-->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.1</version>
    <scope>test</scope>
</dependency>

在test/java目录下，创建测试类，并编写对应的测试方法，并在方法上声明@Test注解。

@Test
public void testGetAge(){
    Integer age = new UserService().getAge("110002200505091218");
    System.out.println(age);
}

运行单元测试 (测试通过：绿色；测试失败：红色)。

测试通过显示绿色

注意：

测试类的命名规范为：XxxxTest
测试方法的命名规定为：public void xxx(){...}

参数化测试

参数化测试是一种测试方法，允许你使用不同的输入参数多次运行同一个测试方法，以验证代码在不同输入下的行为。JUnit 5 提供了 @ParameterizedTest 注解来实现参数化测试。

核心概念 @ParameterizedTest：标记一个方法是参数化测试方法。参数来源：通过 @ValueSource、@CsvSource、@MethodSource 等注解提供测试参数。多次执行：每个参数都会触发一次测试方法的执行。

3. 断言

JUnit提供了一些辅助方法，用来帮我们确定被测试的方法是否按照预期的效果正常工作，这种方式称为断言。

断言方法	描述
assertEquals(Object exp, Object act, String msg)	检查两个值是否相等，不相等就报错。
assertNotEquals(Object unexp, Object act, String msg)	检查两个值是否不相等，相等就报错。
assertNull(Object act, String msg)	检查对象是否为null，不为null，就报错。
assertNotNull(Object act, String msg)	检查对象是否不为null，为null，就报错。
assertTrue(boolean condition, String msg)	检查条件是否为true，不为true，就报错。
assertFalse(boolean condition, String msg)	检查条件是否为false，不为false，就报错。
assertSame(Object exp, Object act, String msg)	检查两个对象引用是否相等，不相等，就报错。

示例演示：

package com.itheima;

import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

public class UserServiceTest {
    
    @Test
    public void testGetAge2(){
        Integer age = new UserService().getAge("110002200505091218");
        Assertions.assertNotEquals(18, age, "两个值相等");
//        String s1 = new String("Hello");
//        String s2 = "Hello";
//        Assertions.assertSame(s1, s2, "不是同一个对象引用");
    }

    @Test
    public void testGetGender2(){
        String gender = new UserService().getGender("612429198904201611");
        Assertions.assertEquals("男", gender);
    }
}

常见注解

注解	说明	备注
@Test	测试类中的方法用它修饰才能成为测试方法，才能启动执行	单元测试
@BeforeEach	用来修饰一个实例方法，该方法会在每一个测试方法执行之前执行一次。	初始化资源(准备工作)
@AfterEach	用来修饰一个实例方法，该方法会在每一个测试方法执行之后执行一次。	释放资源(清理工作)
@BeforeAll	用来修饰一个静态方法，该方法会在所有测试方法之前只执行一次。	初始化资源(准备工作)
@AfterAll	用来修饰一个静态方法，该方法会在所有测试方法之后只执行一次。	释放资源(清理工作)
@ParameterizedTest	参数化测试的注解 (可以让单个测试运行多次，每次运行时仅参数不同)	用了该注解，就不需要@Test注解了
@ValueSource	参数化测试的参数来源，赋予测试方法参数	与参数化测试注解配合使用
@DisplayName	指定测试类、测试方法显示的名称（默认为类名、方法名）

演示 @BeforeEach，@AfterEach，@BeforeAll，@AfterAll 注解：

public class UserServiceTest {

    @BeforeEach
    public void testBefore(){
        System.out.println("before...");
    }

    @AfterEach
    public void testAfter(){
        System.out.println("after...");
    }

    @BeforeAll //该方法必须被static修饰
    public static void testBeforeAll(){ 
        System.out.println("before all ...");
    }

    @AfterAll //该方法必须被static修饰
    public static void testAfterAll(){
        System.out.println("after all...");
    }

    @Test
    public void testGetAge(){
        Integer age = new UserService().getAge("110002200505091218");
        System.out.println(age);
    }
    
    @Test
    public void testGetGender(){
        String gender = new UserService().getGender("612429198904201611");
        System.out.println(gender);
    }
 }

4. 依赖范围

依赖的jar包，默认情况下，可以在任何地方使用，在main目录下，可以使用；在test目录下，也可以使用。

在maven中，如果希望限制依赖的使用范围，可以通过 <scope>…</scope> 设置其作用范围。

作用范围：

主程序范围有效。（main文件夹范围内）
测试程序范围有效。（test文件夹范围内）
是否参与打包运行。（package指令范围内）

可以在pom.xml中配置 <scope></scope> 属性来控制依赖范围。

小结

单元测试的重点不是“跑起来”，而是把最小业务单元的预期行为写清楚。JUnit 的注解、断言和参数化测试都是围绕这个目标服务的。

Maven 项目构建与依赖管理笔记

Thu, 01 May 2025 00:00:00 GMT

这篇笔记记录 Maven 的基础使用方式，重点是理解 Maven 如何统一 Java 项目的结构、依赖和构建流程。后续精修时，可以把命令示例和 POM 配置拆成更清晰的实践小节。

本文要点

Maven 用来管理 Java 项目的依赖、构建流程和标准目录结构。
POM 是 Maven 项目的核心描述文件，坐标由 groupId、artifactId、version 组成。
Maven 仓库分为本地仓库、中央仓库和远程私服。
生命周期命令可以串联完成编译、测试、打包和发布。

1. maven介绍

1. 介绍

Maven 是一款用于管理和构建Java项目的工具，是Apache旗下的一个开源项目。

2. 作用

管理项目依赖：方便快捷的管理项目依赖的资源(jar包)，避免版本冲突问题。
管理项目构建：通过Maven中的命令，就可以很方便的完成项目的编译(compile)、测试(test)、打包(package)、发布(deploy) 等操作。而且这些操作都是跨平台的，也就是说无论你是Windows系统，还是Linux系统，还是Mac系统，这些命令都是支持的。
Maven 还提供了标准、统一的项目结构。

2. Maven概述

1. Maven的作用：

方便的依赖管理
统一的项目结构
标准的项目构建流程

2. Maven模型

项目对象模型 (Project Object Model)
依赖管理模型(Dependency)
构建生命周期/阶段(Build lifecycle & phases)

3. Maven仓库

仓库：用于存储资源，管理各种jar包仓库的本质就是一个目录(文件夹)，这个目录被用来存储开发中所有依赖(就是jar包)和插件

Maven仓库分为：

本地仓库：自己计算机上的一个目录(用来存储jar包)
中央仓库：由Maven团队维护的全球唯一的。仓库地址：https://repo1.maven.org/maven2/
远程仓库(私服)：一般由公司团队搭建的私有仓库

3. IDEA集成Maven

Maven项目的目录结构: Maven项目的目录结构:

maven-project01

        |---  src  (源代码目录和测试代码目录)
               |---  main (源代码目录)
                        |--- java (源代码java文件目录)
                        |--- resources (源代码配置文件目录)
              |---  test (测试代码目录)
                        |--- java (测试代码java目录)
                        |--- resources (测试代码配置文件目录)
        |--- target (编译、打包生成文件存放目录)

3. pom文件详解

POM (Project Object Model)：项目对象模型，用来描述当前的maven项目。 pom文件详解：

- <project> ：pom文件的根标签，表示当前maven项目
- <modelVersion>：声明项目描述遵循哪一个POM模型版本
  - 虽然模型本身的版本很少改变，但它仍然是必不可少的。目前POM模型版本是4.0.0
- 坐标 ：
  - <groupId> <artifactId> <version>
  - 定位项目在本地仓库中的位置，由以上三个标签组成一个坐标
- <maven.compiler.source> ：编译JDK的版本
- <maven.compiler.target> ：运行JDK的版本
- <project.build.sourceEncoding> : 设置项目的字符集

4. Maven坐标

什么是坐标？

Maven中的坐标是资源的唯一标识 , 通过该坐标可以唯一定位资源位置
使用坐标来定义项目或引入项目中需要的依赖

Maven坐标主要组成：

groupId：定义当前Maven项目隶属组织名称（通常是域名反写，例如：com.itheima）
artifactId：定义当前Maven项目名称（通常是模块名称，例如 order-service、goods-service）
version：定义当前项目版本号
- SNAPSHOT: 功能不稳定、尚处于开发中的版本，即快照版本
- RELEASE: 功能趋于稳定、当前更新停止，可以用于发行的版本

4. 依赖配置

1. 基本配置

依赖：指当前项目运行所需要的jar包。一个项目中可以引入多个依赖：

例如：在当前工程中，我们需要用到logback来记录日志，此时就可以在maven工程的pom.xml文件中，引入logback的依赖。具体步骤如下：

在pom.xml中编写<dependencies>标签
在<dependencies>标签中使用<dependency>引入坐标
定义坐标的 groupId、artifactId、version

5. 生命周期

1. 介绍

clean：清理工作。
default：核心工作。如：编译、测试、打包、安装、部署等。
site：生成报告、发布站点等。

每套生命周期包含一些阶段（phase），阶段是有顺序的，后面的阶段依赖于前面的阶段。我们看到这三套生命周期，里面有很多很多的阶段，这么多生命周期阶段，其实我们常用的并不多，主要关注以下几个：

clean：移除上一次构建生成的文件
compile：编译项目源代码
test：使用合适的单元测试框架运行测试(junit)
package：将编译后的文件打包，如：jar、war等
install：安装项目到本地仓库

Maven的生命周期是抽象的，这意味着生命周期本身不做任何实际工作。在Maven的设计中，实际任务（如源代码编译）都交由插件来完成。

生命周期的顺序是：clean --> validate --> compile --> test --> package --> verify --> install --> site --> deploy
我们需要关注的就是：clean --> compile --> test --> package --> install

2. 执行

在日常开发中，当我们要执行指定的生命周期时，有两种执行方式：

在idea工具右侧的maven工具栏中，选择对应的生命周期，双击执行
在DOS命令行中，通过maven命令执行

小结

Maven 的核心价值是把 Java 项目的依赖、目录结构和构建步骤标准化。先理解 POM、坐标、仓库和生命周期，再记常用命令，会比单独背配置更容易串起来。

HTML、CSS 基础与页面布局笔记

Fri, 11 Apr 2025 00:00:00 GMT

这篇笔记整理 HTML 与 CSS 入门阶段的常用知识点，重点是页面样式引入、选择器、路径写法和基础布局。

1. css引入方式

行内样式：<h1 style="...">
内部样式：<style>...</style>
外部样式：在 xxx.css 中编写样式，并通过 <link href="..."> 引入

2. 颜色表示

关键字：red
rgb表示法
rgba表示法: rgba(255,0,0,0.5)
十六进制

3.常见选择器写法

元素选择器：标签名 { ... }
类选择器：.class属性值 { ... }
id选择器：#id属性值 { ... }

4. 路径的书写形式

绝对路径:
- 绝对磁盘路径：<img src="C:\Users\Administrator\Desktop\HTML\img\logo.png">（不要使用）
- 绝对网络路径：<img src="https://i2.sinaimg.cn/dy/deco/2012/0613/yocc20120613img01/news_logo.png">
相对路径:

./ : 当前目录 , ./ 可以省略的

../: 上一级目录

盒子模型

1. 布局标签

标签：<div> <span>
特点：
<div>标签：
- 一行只显示一个（独占一行）
- 宽度默认是父元素的宽度，高度默认由内容撑开
- 可以设置宽高（width、height）
<span>标签：
- 一行可以显示多个
- 宽度和高度默认由内容撑开
- 不可以设置宽高（width、height）
<hr> 标签：水平分割线
<br> 标签：换行

2. flex布局

父元素：display: flex; 弹性布局
flex-direction: row;：默认为 row 水平布局，设置主轴
flex-start：从头开始排列
flex-end：从尾部开始排列
center：在主轴上居中对齐
space-around：平分剩余空间
space-between：先两边贴边，再平分剩余空间
justify-content: space-around;

3. 表单标签：`<form>`

表单属性：

action:表单数据提交的url地址
method:表单提交方式
get：表单数据拼接在url后面，?username=java
post:表单数据在请求体中携带/大小没有限制。注意：表单项必须有name属性才可以提交。

4. 表单项标签

<input> 的 type 属性：text、password、radio、checkbox、file、date、datetime-local、time、hidden、button、submit
<select> 定义下拉列表
<textarea> 定义文本域

小结

HTML 与 CSS 入门的重点是先建立页面结构和样式规则的基本认识。选择器、盒子模型、Flex 布局和表单标签是后续做页面开发时最常反复使用的部分。

youki的笔记

初识 Kubernetes：从 Service 与 CoreDNS 理解服务发现

1. 先理清 K8s 的几个基本对象

2. Service：一个虚拟的、稳定的"门牌号"

3. CoreDNS：一个内置的"黄页"

4. 一个完整的调用链路

5. 和单机 localhost 部署的本质区别

6. 写给自己的小结

CLI Agent 实践指南：从 Claude Code 到通用方法论

0. 三家命令速查

1. Plan 模式：所有工作的起点

1.1 决策树：能用一句话描述 diff 吗？

1.2 Plan 阶段的 3 个高阶玩法

1）用外置编辑器把计划当合同

2）计划里显式列验证步骤

1.3 三家 Plan 命令对照

2. 需要掌握的 7 个命令

2.1 @文件 / @路径/ — 精准注入上下文

2.2 !命令 — 会话内跑 shell

2.3 /clear — 切任务时清空上下文

2.4 /compact [focus...] — 长会话摘要压缩

2.5 /resume — 恢复历史会话

2.6 /rewind / /session — 回退到 checkpoint

2.7 /model + --effort — 切模型与思考强度

2.8 锦上添花

3. 上下文管理：context window

3.1 4 种"喂"上下文的姿势

3.2 3 个清理层次

3.3 4 层记忆文件 + 一键生成

3.4 跨会话：CLAUDE.md vs Auto memory vs Codex Memories

3.5 长任务的会话状态恢复

4. 安全：deny 永远第一

4.1 三级危险模型

4.2 deny 永远优先于 allow

4.3 三家权限机制对照

4.4 Approval mode 三档

4.5 --yolo / --dangerously-skip-permissions 是最后手段

5. 做 Agent 的产品经理

5.1 提问要像产品需求文档

给 Agent 配 4 种"验证门控"（按设置成本从低到高）

5.2 增量验证：每改 10 行看一次

5.3 任务拆分：一个会话 = 一件事

5.4 两次失败就 /clear 重来

5.5 子代理是 context 的瑞士军刀

5.6 测试是 Agent 时代的"免费午餐"

5.7 给 Agent 一个工具齐全的开发环境

5.8 5 条必避反模式

6. 参考

VSCode + SSH + Docker 完整配置流程

一、Linux 端准备

1.1 开启 SSH 服务

1.2 查看 IP 地址

二、Windows 端准备

2.1 安装 VSCode 插件

2.2 生成 SSH 密钥对

三、配置免密登录（公私钥）

3.1 将公钥上传到 Linux

3.2 配置 VSCode SSH 使用私钥

3.3 修复 Windows 私钥权限（关键！）

3.4 测试免密连接

四、Linux 端安装 Docker

4.1 安装 Docker

4.2 验证安装

五、解决 Docker 权限问题

六、VSCode Docker 插件使用

七、快速检查清单

八、配置文件模板

Word 排版技巧

1. 图片排版

1.1 粘贴图片显示不全

1.2 添加题注

1.3 交叉引用

1.4 修改题注样式

1.5 批量更新编号

2. 三线表制作

2.1 新建表格样式

2.2 应用样式

3. PDF 编辑

4. 总结

技巧速查表

5. 和单机 `localhost` 部署的本质区别

2.1 `@文件` / `@路径/` — 精准注入上下文

2.2 `!命令` — 会话内跑 shell

2.3 `/clear` — 切任务时清空上下文

2.4 `/compact [focus...]` — 长会话摘要压缩

2.5 `/resume` — 恢复历史会话

2.6 `/rewind` / `/session` — 回退到 checkpoint

2.7 `/model` + `--effort` — 切模型与思考强度

4.5 `--yolo` / `--dangerously-skip-permissions` 是最后手段

5.4 两次失败就 `/clear` 重来

触发陷入（进入内核）只需要执行一条特定的指令（如 `int 0x80`, `syscall`）。但，这条指令只是一个“门铃”，按下门铃后，执行的是操作系统内核中预先写好的、功能完整且复杂的服务例程

第一节课基本概念