Claude Code 深度技术指南：从入门到精通
Claude Code技术解析与实践指南 本文系统阐述了AI编程新范式Claude Code的核心架构与技术实现。作为Agent优先的智能开发系统，Claude Code通过五层架构（交互层→决策层→能力层→扩展层→系统层）实现复杂编程任务的自动化处理。重点解析了三大核心系统：Tools系统提供20+内置工具支持文件操作与执行；Agent系统实现任务分解与智能协作；Skills生态构建可复用工作流
·
全面解析Claude Code的核心原理、MCP协议、Agent系统、Skills生态与工程化实践
标签：AI编程、Claude Code、MCP、Agent、Skills
目录
- 一、引言：AI编程的新范式
- 二、Claude Code核心概念与架构
- 三、Tools系统深度解析
- 四、Agent系统：智能协作的秘密
- 五、MCP协议：连接一切的桥梁
- 六、Skills生态：构建可复用的工作流
- 七、工程化实践与最佳实践
一、引言：AI编程的新范式
1.1 从代码补全到Agent编程
在过去的几年里，AI编程工具经历了快速的演进。从早期的代码补全工具（如TabNine），到GitHub Copilot的实时建议，再到Cursor的整体文件重写，AI辅助编程已经成为开发者日常工作的一部分。
然而，这些工具大多停留在"辅助"层面——它们帮助你写代码，但仍然需要你来主导整个开发流程。当面对复杂的多文件重构、大规模代码库迁移、或是需要协调多个系统的任务时，这些工具往往力不从心。
Claude Code 代表了一种全新的范式：Agent优先的编程模式。它不仅仅是一个代码生成工具，而是一个能够理解需求、制定计划、自主执行、持续优化的智能开发助手。
1.2 为什么选择Claude Code？
让我们通过一个对比来直观感受：
场景：将一个使用Redux的React应用重构为使用Zustand
| 工具 | 工作方式 | 开发者参与度 | 效率 |
|---|---|---|---|
| GitHub Copilot | 提供行级建议，需要你逐文件修改 | 高（需要手动协调所有文件） | 中等 |
| Cursor | 整体重写单个文件，但文件间协调需要你完成 | 中（需要理解文件依赖关系） | 较高 |
| Claude Code | 分析项目结构 → 生成重构计划 → 逐步执行 → 运行测试 → 自动修复 | 低（只需审核计划和结果） | 极高 |
Claude Code的优势在于：
- 超大上下文窗口（200K tokens）：可以一次性理解整个大型代码库
- Agent推理能力：能够制定复杂的多步骤计划
- 工具优先：自主决定使用哪些工具完成任务
- 持续迭代：执行过程中发现问题会自动调整策略
- PR-first工作流：与现代Git工作流深度集成
1.3 本文的价值
作为一名资深Java开发者，我在学习和使用Claude Code的过程中，发现官方文档虽然详尽，但对于初学者来说仍然缺乏系统性的实践指导。本文旨在：
- 通俗易懂：用实际案例解释技术概念，避免晦涩的术语堆砌
- 深入浅出：既讲原理也讲实践，既有架构图也有代码示例
- 工程化视角：从企业级应用的角度，提供可落地的最佳实践
- 体系化知识：从Tools到Agent，从MCP到Skills，构建完整的知识图谱
无论你是刚开始使用Claude Code的新手，还是希望深入理解其工作原理的资深用户，本文都将为你提供有价值的内容。
二、Claude Code核心概念与架构
2.1 整体架构概览
Claude Code采用了典型的分层架构设计，从用户交互到底层系统调用，共分为5个清晰的层次：
让我们从上到下逐层理解：
第一层：用户交互层
这是开发者与Claude Code交互的入口点：
-
命令行界面（CLI）：通过
claude命令在终端中直接与AI对话claude "帮我优化这个SQL查询的性能" claude /review --security -
IDE插件：集成在VS Code和JetBrains系列IDE中
- 快捷键唤起（
Cmd+Esc/Ctrl+Esc） - 图形化界面
- 代码高亮和diff预览
- 与IDE原生功能无缝集成
- 快捷键唤起（
第二层：决策编排层（主Agent）
这是Claude Code的"大脑"，负责：
- 任务理解：解析用户的自然语言指令
- 上下文管理：维护200K tokens的对话上下文
- 计划制定：将复杂任务分解为可执行的步骤
- 工具选择：决定使用哪些工具完成任务
- 子Agent调度：将子任务分配给专门的Agent
- 结果聚合：汇总所有操作的结果并呈现给用户
主Agent支持Extended Thinking模式，可以在复杂问题上进行更深入的推理（最高10,000 tokens的思考预算）。
第三层：核心能力层
这一层提供了Claude Code的三大核心能力：
1. Tools System（工具系统）
20+内置工具，涵盖：
- 文件操作：Read、Write、Edit、MultiEdit
- 搜索工具：Grep、Glob
- 执行工具：Bash、NotebookEdit
- Web工具：WebFetch、WebSearch
2. Agent System（Agent系统）
专业化的子Agent：
- Plan Agent：制定详细的执行计划
- Explore Agent：快速探索代码库结构
- Task Agent：执行特定的独立任务
- 自定义Agent：根据需求配置专门的Agent（如安全审查Agent）
3. Skills System（技能系统）
可复用的工作流模板：
- 内置Skills：commit、review、test等
- 自定义Skills：通过SKILL.md定义
第四层：扩展集成层
提供灵活的扩展能力：
1. MCP Integration（Model Context Protocol集成）
通过标准协议连接外部服务：
- GitHub：PR管理、Issue跟踪
- Slack：消息发送、工作流集成
- Notion：文档管理、数据库查询
- Database：SQL执行、数据分析
2. Hooks System（钩子系统）
事件驱动的自动化：
pre-commit：提交前运行测试post-edit：编辑后自动格式化pre-bash：危险命令确认
第五层：外部系统层
Claude Code最终操作的目标系统：
- Git：版本控制、分支管理
- 文件系统：读写项目文件
- 外部API：调用第三方服务
- 数据库：执行SQL、查询数据
2.2 工作流程详解
让我们通过一个实际场景来理解Claude Code的工作流程：
场景：重构一个Java服务，将所有同步调用改为异步
关键点：
- 智能决策：主Agent判断任务复杂度，决定是否需要Plan Agent
- 工具选择：自动选择Grep搜索、Read读取、Edit修改、Bash测试
- 用户参与：在执行前展示计划，获得确认后再操作
- 错误处理：如果测试失败，会自动分析错误并修复
- 版本管理：自动提交到Git，生成清晰的commit message
2.3 与传统工具的对比
为了更清楚地理解Claude Code的特点，让我们对比几种主流工具：
| 维度 | Claude Code | GitHub Copilot | Cursor | ChatGPT |
|---|---|---|---|---|
| 架构模式 | Agent-first | 补全辅助 | 文件重写 | 对话式 |
| 上下文窗口 | 200K tokens | ~4K tokens | ~20K tokens | ~128K tokens |
| 工作单位 | 项目/多文件 | 代码行 | 单文件 | 无文件操作 |
| 任务复杂度 | 多步骤、跨文件 | 简单补全 | 单文件重构 | 建议性质 |
| 自主性 | 高（自主执行） | 低（需要接受） | 中（需要触发） | 无（仅建议） |
| Git集成 | 深度集成 | 无 | 基础 | 无 |
| 可扩展性 | MCP+Skills+Hooks | 无 | 插件 | API |
| 适用场景 | 大规模重构、自动化 | 日常编码 | 文件优化 | 问答咨询 |
结论：
- 日常编码：GitHub Copilot（快速、低延迟）
- 单文件优化：Cursor（整体重写、智能建议）
- 复杂重构：Claude Code（多文件协调、自动化流程）
- 技术咨询：ChatGPT（学习、问答）
2.4 核心设计理念
Claude Code的设计遵循以下原则：
1. Agent优先（Agent-First）
传统工具：工具 → 用户 → 决策
Claude Code：用户 → Agent → 工具
Agent作为中间层，理解意图、制定计划、执行操作，用户只需要关注结果。
2. 工具确定性（Tool Determinism）
AI擅长推理和决策，但对于具体操作（如文件搜索、命令执行），应该使用确定性的工具而不是让AI"猜测"。
例如：
- ❌ 让AI记忆所有文件路径 → 容易出错
- ✅ 使用Grep工具搜索 → 准确可靠
3. 上下文优先（Context-First）
200K tokens的超大上下文窗口使得：
- 可以一次性加载整个项目的关键文件
- 理解代码的全局依赖关系
- 避免"盲人摸象"式的局部修改
4. 可扩展性（Extensibility）
通过MCP、Skills、Hooks三大机制，可以：
- 连接任何外部服务
- 定义可复用的工作流
- 自动化任何重复性任务
三、Tools系统深度解析
3.1 工具系统概览
Claude Code内置了20+工具，这些工具是Agent与外部世界交互的"手"。理解工具系统的设计哲学和使用场景，是掌握Claude Code的关键。
工具分类
按功能划分，工具可以分为以下几类：
Tools System
├── 文件操作工具
│ ├── Read - 读取文件内容
│ ├── Write - 创建/覆写文件
│ ├── Edit - 精确字符串替换
│ └── MultiEdit - 批量编辑操作
├── 搜索工具
│ ├── Grep - 内容搜索（基于ripgrep）
│ ├── Glob - 文件模式匹配
│ └── LS - 列出目录内容
├── 执行工具
│ ├── Bash - 执行shell命令
│ ├── NotebookRead - 读取Jupyter notebook
│ └── NotebookEdit - 编辑notebook单元格
├── Web工具
│ ├── WebFetch - 获取URL内容
│ └── WebSearch - Web搜索
├── 任务管理
│ ├── TodoRead - 读取待办事项
│ └── TodoWrite - 管理待办列表
└── 流程控制
├── Task - 启动子Agent
└── ExitPlanMode - 退出规划模式
3.2 文件操作工具详解
文件操作是开发工作中最频繁的操作，Claude Code提供了三种不同级别的文件修改工具：
Read：智能的文件读取
功能：读取文件内容，支持大文件的分段读取
使用场景：
- 理解代码逻辑
- 分析项目结构
- 查看配置文件
特点：
- 默认读取全文（最多2000行）
- 支持offset和limit参数分段读取
- 自动处理多种文件格式（文本、图片、PDF、Jupyter Notebook）
- 返回格式类似`cat -n`，带行号
最佳实践：
✅ 批量Read多个相关文件（并行调用）
✅ 先Read再Edit（必须先读取才能编辑）
❌ 逐个文件顺序读取（浪费时间）
❌ 不读取直接猜测文件内容（容易出错）
示例：
# Claude内部会执行类似操作
Read(/path/to/UserService.java)
Read(/path/to/UserRepository.java)
Read(/path/to/UserDTO.java)
# 三个文件并行读取，提高效率
Edit：精确的字符串替换
功能：在文件中查找特定字符串并替换为新内容
使用场景：
- 修改方法实现
- 更新变量名
- 调整配置参数
核心机制：
// Edit工具的核心逻辑
1. 在文件中查找old_string
2. 如果找到唯一匹配 → 替换为new_string
3. 如果找到多个匹配 → 报错（需要提供更多上下文）
4. 如果找不到 → 报错（可能是文件已改变）
关键规则：
- 必须先Read：Edit前必须用Read读取文件
- 精确匹配：old_string必须与文件内容完全一致（包括空格、缩进）
- 唯一性：默认要求old_string在文件中唯一出现
- replace_all参数：如果需要替换所有匹配项，设置为true
示例：
场景：将同步方法改为异步
// 原始代码（UserService.java:45-50）
public User getUserById(Long id) {
return userRepository.findById(id);
}
// Claude执行的Edit操作
Edit(
file_path: "src/main/java/com/example/UserService.java",
old_string: "public User getUserById(Long id) {\n return userRepository.findById(id);\n}",
new_string: "public CompletableFuture<User> getUserById(Long id) {\n return CompletableFuture.supplyAsync(() -> \n userRepository.findById(id)\n );\n}"
)
常见错误：
❌ 错误1：缩进不一致
old_string: "public User getUser() {" // 没有前导空格
实际文件: " public User getUser() {" // 有4个空格
❌ 错误2：包含行号前缀
old_string: "45 public User getUser() {" // 包含了行号
实际文件: " public User getUser() {" // 无行号
✅ 正确：使用Read工具的输出，但去掉行号前缀
Read输出：
45 public User getUser() {
Edit的old_string：
" public User getUser() {" // 去掉"45 "，保留缩进
Write：创建新文件
功能：创建新文件或完全覆写现有文件
使用场景：
- 创建新的类/接口
- 生成配置文件
- 创建测试文件
重要规则：
✅ 创建新文件时优先使用
✅ 如果文件已存在，必须先Read确认
❌ 不要用于修改现有文件（应该用Edit）
❌ 不要在没有Read的情况下覆写文件
示例：
// 创建新的DTO类
Write(
file_path: "src/main/java/com/example/dto/UserAsyncDTO.java",
content: """
package com.example.dto;
import java.util.concurrent.CompletableFuture;
import lombok.Data;
@Data
public class UserAsyncDTO {
private Long id;
private String username;
private CompletableFuture<String> email;
}
"""
)
MultiEdit：批量编辑
功能：在一次调用中对多个文件执行多个编辑操作
使用场景：
- 跨文件重命名
- 统一修改多个类的相同模式
- 批量更新配置
优势：
- 原子性：要么全部成功，要么全部回滚
- 效率：一次API调用完成多个操作
- 一致性：确保所有修改同时生效
示例：
// 将多个文件中的旧类名替换为新类名
MultiEdit([
{
file_path: "UserService.java",
old_string: "UserDAO",
new_string: "UserRepository"
},
{
file_path: "OrderService.java",
old_string: "UserDAO",
new_string: "UserRepository"
},
{
file_path: "UserController.java",
old_string: "UserDAO",
new_string: "UserRepository"
}
])
3.3 搜索工具：代码库的导航系统
Grep：内容搜索的瑞士军刀
功能：基于ripgrep的高性能内容搜索工具
核心参数：
| 参数 | 说明 | 示例 |
|---|---|---|
pattern |
正则表达式模式 | "class.*User" |
output_mode |
输出模式 | files_with_matches（默认）、content、count |
glob |
文件过滤 | "*.java" |
type |
文件类型 | "java", "py", "rust" |
-i |
忽略大小写 | true |
-A, -B, -C |
上下文行数 | -A 3（后3行） |
multiline |
跨行匹配 | true |
输出模式对比：
# 1. files_with_matches（默认）- 只返回文件路径
Grep(pattern: "@Transactional", type: "java")
→ 输出：
UserService.java
OrderService.java
PaymentService.java
# 2. content - 返回匹配的行及上下文
Grep(pattern: "@Transactional", type: "java", output_mode: "content", -A: 2)
→ 输出：
UserService.java:45: @Transactional
UserService.java:46: public void createUser(User user) {
UserService.java:47: userRepository.save(user);
# 3. count - 返回每个文件的匹配数
Grep(pattern: "@Transactional", type: "java", output_mode: "count")
→ 输出：
UserService.java: 5
OrderService.java: 3
PaymentService.java: 7
高级用法：
- 查找所有TODO注释
Grep(pattern: "TODO|FIXME|XXX", -i: true, output_mode: "content")
- 查找未使用的导入（Java）
Grep(pattern: "^import.*\\.(\\w+);", type: "java", output_mode: "content")
# 需要结合代码分析进一步判断
- 查找潜在的SQL注入风险
Grep(pattern: "executeQuery.*\\+|Statement.*execute", type: "java")
- 跨行搜索
# 查找跨多行的注解
Grep(
pattern: "@RequestMapping\\([\\s\\S]*?\\)",
multiline: true,
type: "java"
)
Glob：文件名模式匹配
功能：按文件名模式快速定位文件
使用场景：
- 查找特定类型的文件
- 定位配置文件
- 扫描目录结构
模式语法：
**/*.java # 所有Java文件（递归）
src/main/**/*.xml # src/main下的所有XML
*Test.java # 当前目录下的测试文件
**/*{Service,Controller}.java # Service或Controller文件
示例：
# 查找所有Mapper接口
Glob(pattern: "**/*Mapper.java", path: "src/main/java")
# 查找所有配置文件
Glob(pattern: "**/*.{yml,yaml,properties}", path: "src/main/resources")
# 查找特定模块的文件
Glob(pattern: "mythos-user-center/**/*.java")
Grep vs Glob 选择指南：
使用Grep：
✅ 搜索文件内容（代码、注释、字符串）
✅ 需要正则表达式匹配
✅ 需要上下文信息
使用Glob：
✅ 按文件名查找
✅ 扫描目录结构
✅ 性能更高（不读取文件内容）
3.4 Bash：执行外部命令
功能：在持久化bash会话中执行shell命令
关键特性：
-
持久化会话：命令之间共享环境变量和工作目录
Bash("cd /path/to/project") Bash("mvn clean install") # 在上一步的目录中执行 -
后台运行：长时间运行的任务可以在后台执行
Bash("npm run dev", run_in_background: true) -
超时控制：默认2分钟超时，可配置最长10分钟
重要规则：
✅ 优先使用专用工具而非Bash
- 搜索文件 → 用Grep，不用 grep 命令
- 读取文件 → 用Read，不用 cat 命令
- 查找文件 → 用Glob，不用 find 命令
✅ 适合Bash的场景：
- 构建项目：mvn clean install
- 运行测试：pytest
- Git操作：git status, git diff
- 包管理：npm install, pip install
❌ 不要用Bash做：
- 文件内容搜索（用Grep）
- 文件读取（用Read）
- 简单的文件操作（用专用工具）
安全实践：
在项目配置中设置权限：
{
"permissions": {
"allow": [
"Bash(mvn:*)", // 允许所有mvn命令
"Bash(npm:*)", // 允许所有npm命令
"Bash(git status:*)", // 允许git status
"Bash(git diff:*)" // 允许git diff
],
"ask": [
"Bash(rm:*)", // 删除操作需要确认
"Bash(git push:*)" // 推送操作需要确认
],
"deny": [
"Bash(sudo:*)", // 禁止sudo命令
"Bash(chmod:*)" // 禁止修改权限
]
}
}
3.5 工具使用最佳实践
1. 并行 vs 顺序
并行执行（性能更好）：
场景：读取多个独立文件
✅ 一次消息中包含多个Read调用
Read(UserService.java)
Read(UserRepository.java)
Read(UserDTO.java)
→ 三个文件同时读取
❌ 多次消息顺序调用
消息1: Read(UserService.java)
消息2: Read(UserRepository.java)
消息3: Read(UserDTO.java)
→ 三次往返，慢3倍
顺序执行（有依赖关系）：
场景：修改文件后运行测试
1. Edit(UserService.java) → 等待完成
2. Bash("mvn test") → 使用修改后的文件
2. 工具选择决策树
需要操作文件？
├─ 是 → 读取还是修改？
│ ├─ 读取 → 使用Read
│ ├─ 新建 → 使用Write
│ ├─ 修改 → 使用Edit
│ └─ 批量 → 使用MultiEdit
│
├─ 搜索内容？
│ ├─ 文件内容 → 使用Grep
│ └─ 文件名 → 使用Glob
│
├─ 执行命令？
│ ├─ Git操作 → 使用Bash
│ ├─ 构建/测试 → 使用Bash
│ └─ 包管理 → 使用Bash
│
└─ Web资源？
├─ 获取内容 → 使用WebFetch
└─ 搜索信息 → 使用WebSearch
3. 错误处理
常见错误及解决方案：
| 错误类型 | 原因 | 解决方案 |
|---|---|---|
| Edit失败：old_string not found | 文件内容已改变 | 重新Read文件，更新old_string |
| Edit失败：multiple matches | old_string不唯一 | 增加上下文使其唯一 |
| Bash超时 | 命令执行时间过长 | 使用run_in_background |
| Grep无结果 | 模式不匹配 | 检查正则表达式，尝试-i忽略大小写 |
| Read失败：file not found | 文件路径错误 | 使用Glob先查找文件 |
小结
Tools系统是Claude Code的"手"，通过20+工具与外部世界交互。掌握工具的特点和使用场景，是高效使用Claude Code的基础。关键要点：
- 专用工具优先：Read而非cat，Grep而非bash grep
- 并行提升效率：独立操作尽量并行调用
- 先Read后Edit：修改文件前必须先读取
- 权限控制：通过配置文件管理危险操作
四、Agent系统：智能协作的秘密
4.1 Agent系统架构
Claude Code采用了分层Agent架构，通过主Agent和多个专业子Agent的协作，完成复杂的开发任务。
架构层次
主Agent（决策中心）
├── 任务理解与规划
├── 上下文管理（200K tokens）
├── 工具选择
└── 子Agent调度
│
├─→ Plan Agent（规划专家）
│ └── 制定详细执行计划
│
├─→ Explore Agent（探索专家）
│ └── 快速理解代码库结构
│
├─→ Task Agent（执行专家）
│ └── 并行执行独立任务
│
└─→ 自定义Agent（领域专家）
├── Security Review Agent
├── Performance Audit Agent
└── Code Quality Agent
4.2 内置Agent详解
Plan Agent：规划专家
职责：分析任务复杂度，制定分步执行计划
何时使用：
- 多文件重构
- 架构调整
- 新功能开发
- 不确定如何开始的任务
工作流程：
示例：
场景：将Spring Boot 2.x升级到3.x
用户: claude /plan "升级项目到Spring Boot 3"
Plan Agent工作过程：
1. 读取pom.xml，识别当前版本
2. Grep搜索使用了哪些Spring特性
3. 检查是否使用了已废弃的API
4. 分析第三方依赖兼容性
5. 生成详细升级计划
输出的计划：
===========================================
Spring Boot 3 升级计划
===========================================
第一步：更新Maven依赖
- 修改pom.xml中Spring Boot版本：2.7.5 → 3.2.0
- 更新Spring Cloud版本：2021.0.5 → 2023.0.0
- 替换javax包为jakarta包依赖
第二步：代码迁移
- 替换所有 javax.* 导入为 jakarta.*（影响23个文件）
- 更新Hibernate配置（3个文件）
- 调整Security配置（使用新的SecurityFilterChain）
第三步：配置文件调整
- application.yml：更新配置键名（5处变更）
- 移除已废弃的配置项
第四步：测试和验证
- 运行单元测试
- 运行集成测试
- 检查启动日志
预计影响：31个文件，约2小时
风险等级：中
回滚策略：Git分支隔离，可随时回滚
是否继续执行？(yes/no)
===========================================
Plan Agent的价值：
- 让用户在执行前了解全貌
- 识别潜在风险和依赖
- 提供回滚策略
- 节省时间（避免试错）
Explore Agent：代码库探索专家
职责：快速理解项目结构和技术栈
何时使用：
- 新接手的项目
- 需要理解代码库整体架构
- 查找特定功能的实现位置
- 回答"这个项目是如何工作的"类问题
thoroughness级别：
| 级别 | 说明 | 速度 | 适用场景 |
|---|---|---|---|
| quick | 快速浏览关键文件 | 快 | 了解基本结构 |
| medium | 扫描主要模块和配置 | 中 | 理解架构设计 |
| very thorough | 深入分析所有代码 | 慢 | 全面理解项目 |
示例：
# 快速探索
claude /explore --thoroughness quick "这个项目的架构是什么样的？"
Explore Agent输出：
===========================================
项目架构分析
===========================================
📁 项目结构:
myth-claude/
├── backend/ # 后端微服务
│ ├── mythos-user-center/ # 用户中心
│ ├── mythos-order-center/ # 订单中心
│ └── mythos-product-center/ # 商品中心
└── frontend/ # 前端应用
🏗️ 技术栈:
- 后端: Spring Boot 3.3.0 + MyBatis-Plus + Redis
- 前端: Vue 3 + TypeScript + Vite
- 数据库: MySQL 8.4.0
- 服务发现: Nacos
- RPC: Dubbo 3.2.5
📐 架构模式:
- 微服务架构 (DDD设计)
- 分层架构: Controller → Service → Repository
- 前后端分离
🔑 核心特点:
- 8个业务域（基础设施、商品、交易、营销等）
- 统一的Response<T>响应格式
- TraceLogger日志追踪
- 软删除设计
📝 关键文件:
- CLAUDE.md: 项目开发规约
- design/神话B2C顶层设计.md: 详细设计文档
===========================================
Explore Agent的智能之处：
- 自动识别项目类型（Spring、Django、React等）
- 理解项目的分层结构
- 识别设计模式和最佳实践
- 快速定位关键配置文件
Task Agent：并行执行专家
职责：执行独立的子任务，支持并行执行
何时使用：
- 多个独立的文件需要修改
- 可并行的操作（如多个模块的相同修改）
- 重复性任务
并行执行示例：
用户: claude "在所有Service类中添加日志记录"
主Agent的决策：
1. 使用Glob找到所有Service类（发现15个文件）
2. 任务可并行（各Service独立）
3. 启动3个Task Agent并行执行
执行过程：
┌─ Task Agent 1 ─┐ ┌─ Task Agent 2 ─┐ ┌─ Task Agent 3 ─┐
│ UserService │ │ OrderService │ │ ProductService │
│ PaymentService │ │ LogisticsServ │ │ MarketService │
│ NotifyService │ │ ... │ │ ... │
└────────────────┘ └────────────────┘ └────────────────┘
↓ ↓ ↓
5个文件完成 5个文件完成 5个文件完成
↓
主Agent聚合结果
↓
"已为15个Service添加日志"
Task Agent的优势：
- 显著提升效率（3-5倍）
- 减少等待时间
- 隔离错误（一个失败不影响其他）
4.3 自定义Agent
创建自定义Agent的场景
当你需要：
- 限制特定任务的工具权限
- 使用不同的模型（如haiku降低成本）
- 注入专业的system prompt
- 创建领域专家Agent
配置文件结构
.claude/agents/security-reviewer.yaml
name: security-reviewer
description: 专业的安全代码审查Agent
# 模型选择（可选）
model: claude-opus-4-5
# 工具权限限制
tools:
allow:
- Read # 只允许读取
- Grep # 只允许搜索
- Glob # 只允许文件查找
deny:
- Write # 禁止写入
- Edit # 禁止修改
- Bash # 禁止执行命令
# 采样参数
max_tokens: 16000
temperature: 0 # 确定性输出
# 专业system prompt
system_prompt: |
你是一个专业的安全代码审查专家，擅长识别常见的安全漏洞。
## 审查清单
### 1. 注入攻击
- [ ] SQL注入：检查所有数据库查询是否使用参数化
- [ ] XSS：检查用户输入是否被正确转义
- [ ] 命令注入：检查是否直接拼接shell命令
### 2. 认证和授权
- [ ] JWT验证：检查token验证逻辑
- [ ] 权限检查：所有接口是否有权限控制
- [ ] Session管理：检查会话超时设置
### 3. 数据保护
- [ ] 敏感数据：密码、密钥是否加密存储
- [ ] 日志安全：是否记录敏感信息
- [ ] HTTPS：是否强制使用HTTPS
### 4. 依赖库
- [ ] 已知漏洞：检查依赖库版本
- [ ] 过期依赖：识别长期未更新的库
## 输出格式
对每个发现的问题，提供：
1. 问题描述
2. 风险等级（高/中/低）
3. 受影响的代码位置（文件:行号）
4. 修复建议（具体代码示例）
5. 参考资料（OWASP链接）
如果未发现问题，明确说明"未发现明显安全问题"。
使用自定义Agent
# 方式1：直接调用
claude --agent security-reviewer "审查UserService的安全性"
# 方式2：在对话中切换
claude
> /agent security-reviewer
> 审查最近提交的代码
更多自定义Agent示例
1. 性能审查Agent
name: performance-auditor
description: 专注于性能问题的审查
model: claude-opus-4-5
tools:
allow: [Read, Grep, Glob]
system_prompt: |
你是性能优化专家，专注于识别性能瓶颈。
重点检查：
- N+1查询问题
- 缺失的数据库索引
- 不必要的循环
- 大对象的深拷贝
- 未关闭的资源
- 阻塞式I/O
为每个问题提供优化后的代码示例。
2. 测试生成Agent
name: test-generator
description: 自动生成单元测试
model: claude-sonnet-4-5 # 使用性价比更高的模型
tools:
allow: [Read, Write, Grep, Bash] # 需要写入和执行测试
system_prompt: |
你是测试工程师，专注于生成高质量的单元测试。
测试原则：
- 使用JUnit 5和Mockito
- 覆盖正常流程和边界情况
- 包含异常场景
- 清晰的测试名称（should_xxx_when_yyy）
- 遵循AAA模式（Arrange, Act, Assert）
生成测试后，运行`mvn test`验证。
4.4 Agent协作模式
模式1：顺序协作
主Agent → Plan Agent → Task Agents → 主Agent
↓ ↓ ↓ ↓
接收任务 制定计划 并行执行 汇总结果
适用场景：复杂的多步骤任务
模式2：并行协作
主Agent
/ | \
/ | \
Task-1 Task-2 Task-3
\ | /
\ | /
聚合结果
适用场景：独立的重复性任务
模式3：专家模式
主Agent → 专家Agent → 主Agent
↓ ↓ ↓
分派任务 领域处理 整合建议
适用场景：需要领域知识的任务（安全、性能、测试）
4.5 Agent选择决策指南
任务分析
├─ 任务复杂度如何？
│ ├─ 简单明确 → 主Agent直接执行
│ └─ 复杂不确定 → 使用Plan Agent
│
├─ 是否可并行？
│ ├─ 可并行 → Task Agent（并行执行）
│ └─ 有依赖 → 主Agent（顺序执行）
│
├─ 是否需要探索？
│ ├─ 新项目/不熟悉 → Explore Agent
│ └─ 熟悉的项目 → 跳过探索
│
└─ 是否需要专业知识？
├─ 安全审查 → Security Agent
├─ 性能优化 → Performance Agent
├─ 测试生成 → Test Agent
└─ 通用任务 → 主Agent
4.6 Agent最佳实践
1. 合理使用Plan Agent
✅ 适合使用Plan Agent：
- 多文件重构
- 架构调整
- 不确定从何开始
- 影响范围大的变更
❌ 不需要Plan Agent：
- 单文件修改
- 简单的bug修复
- 明确的操作步骤
- 添加一个方法
2. 自定义Agent的设计原则
✅ 好的自定义Agent：
- 单一职责（只做一件事）
- 最小权限（只授予必要的工具）
- 清晰的prompt（具体的指导）
- 可复用（多个项目通用）
❌ 避免：
- 权限过大（给了所有工具）
- prompt模糊（"做好审查"）
- 职责不清（既审查又修复）
3. Agent性能优化
成本优化：
- 简单任务使用haiku模型
- 复杂任务使用opus模型
- Task Agent可用不同模型
速度优化：
- 尽量并行执行
- 避免不必要的文件读取
- 使用Grep而非逐文件搜索
质量优化：
- 重要任务用Extended Thinking
- 安全审查用temperature=0
- 创意任务可提高temperature
小结
Agent系统是Claude Code的"智能中枢"，通过主Agent和多个专业子Agent的协作，实现了复杂任务的自动化执行。关键要点：
- Plan Agent：复杂任务先规划后执行
- Explore Agent：快速理解新项目
- Task Agent：并行执行提升效率
- 自定义Agent：创建领域专家
- 协作模式：根据任务选择合适的Agent组合
五、MCP协议：连接一切的桥梁
5.1 MCP是什么
Model Context Protocol (MCP) 是由Anthropic主导的开放协议，旨在为LLM应用程序和外部数据源、工具之间建立标准化的集成方式。
传统API vs MCP
| 维度 | 传统REST API | MCP |
|---|---|---|
| 发现机制 | 依赖文档 | 自动能力协商 |
| 类型安全 | Swagger/OpenAPI | JSON Schema |
| 状态管理 | 无状态 | 有状态会话 |
| 版本管理 | 需要版本号 | 自适应（无版本） |
| AI友好性 | 需要人工理解 | 自描述接口 |
简单理解：MCP就像是一个"翻译官"，让AI能够自动理解和使用各种外部服务，无需人工编写集成代码。
5.2 MCP协议原理
架构组成
MCP采用三层架构：
┌─────────────────────────────────┐
│ MCP Host (Claude Code) │
│ - 管理多个客户端连接 │
│ - 维护会话上下文 │
└───────────┬─────────────────────┘
│ 一对多
┌───────────▼─────────────────────┐
│ MCP Client (连接管理器) │
│ - 每个Server一个Client │
│ - JSON-RPC 2.0通信 │
└───────────┬─────────────────────┘
│ 一对一
┌───────────▼─────────────────────┐
│ MCP Server (服务提供者) │
│ - Tools（可调用函数） │
│ - Resources（上下文数据） │
│ - Prompts（指令模板） │
└─────────────────────────────────┘
通信机制
MCP基于JSON-RPC 2.0协议：
// 请求
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "search_repositories",
"arguments": {
"query": "spring boot microservices",
"language": "java"
}
}
}
// 响应
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"content": [
{
"type": "text",
"text": "找到10个仓库：\n1. spring-cloud-example\n2. ..."
}
]
}
}
初始化握手
在开始使用MCP服务器前，必须完成初始化握手：
5.3 MCP的三大核心原语
1. Tools（工具）：AI可调用的函数
特点：由AI主动发现和调用
定义示例：
{
"name": "create_github_issue",
"description": "在GitHub仓库中创建一个新Issue",
"inputSchema": {
"type": "object",
"properties": {
"owner": {
"type": "string",
"description": "仓库所有者"
},
"repo": {
"type": "string",
"description": "仓库名称"
},
"title": {
"type": "string",
"description": "Issue标题"
},
"body": {
"type": "string",
"description": "Issue内容（支持Markdown）"
},
"labels": {
"type": "array",
"items": { "type": "string" },
"description": "标签列表"
}
},
"required": ["owner", "repo", "title"]
}
}
调用示例：
用户: claude "在我的项目中创建一个bug报告"
Claude内部流程：
1. 理解意图：需要创建GitHub Issue
2. 查找MCP Tool：发现 create_github_issue
3. 提取信息：
- owner: "zhangsan"
- repo: "myth-claude"
- title: "Bug: 用户登录失败"
- body: "详细描述..."
- labels: ["bug", "high-priority"]
4. 调用Tool
5. 返回结果："✓ Issue #123已创建"
2. Resources（资源）：应用提供的上下文
特点：由应用程序主动推送给AI
使用场景：
- 数据库Schema
- API文档
- 配置信息
- 项目元数据
示例：
{
"uri": "mysql://localhost/mythos",
"name": "数据库Schema",
"description": "Mythos电商平台的数据库结构",
"mimeType": "text/plain"
}
// 读取资源
{
"content": "
TABLE users (
id BIGINT PRIMARY KEY,
username VARCHAR(50),
email VARCHAR(100),
...
)
TABLE orders (
...
)
"
}
应用价值：
场景：AI需要生成SQL查询
没有Resource：
AI: "你的数据库表结构是什么？"
用户: "有users表，字段是..."
AI: "orders表呢？"
用户: "字段有..."
→ 需要多轮对话
有Resource：
AI自动读取database-schema Resource
→ 直接生成准确的SQL
3. Prompts（提示词）：可复用的指令模板
特点：用户主动选择使用
定义示例：
{
"name": "code-review",
"description": "执行全面的代码审查",
"arguments": [
{
"name": "focus",
"description": "审查重点",
"required": false
}
]
}
// 使用时
{
"messages": [
{
"role": "user",
"content": "请审查以下代码，重点关注：{focus}\n\n{code}"
}
]
}
5.4 在Claude Code中使用MCP
配置MCP服务器
方式1：使用CLI命令
# 添加GitHub MCP服务器
claude mcp add github \
--transport http \
--url https://api.github.com/mcp \
--auth-type bearer \
--token $GITHUB_TOKEN
# 列出所有MCP服务器
claude mcp list
# 移除服务器
claude mcp remove github
方式2：编辑配置文件
~/.claude/mcp-config.json
{
"mcpServers": {
"github": {
"transport": "http",
"url": "https://api.github.com/mcp",
"auth": {
"type": "bearer",
"token": "${GITHUB_TOKEN}"
}
},
"notion": {
"transport": "stdio",
"command": "node",
"args": ["/path/to/notion-mcp-server.js"],
"env": {
"NOTION_API_KEY": "${NOTION_API_KEY}"
}
},
"database": {
"transport": "http",
"url": "http://localhost:3000/mcp",
"auth": {
"type": "none"
}
}
}
}
在对话中使用MCP
一旦配置了MCP服务器，Claude会自动发现并使用其提供的工具：
# 示例1：GitHub操作
claude
> @github 帮我分析PR #123的代码变更
→ Claude自动调用github MCP的get_pull_request工具
# 示例2：Notion集成
> @notion 在"项目管理"数据库中创建一个新任务
→ Claude自动调用notion MCP的create_page工具
# 示例3：数据库查询
> @database 查询最近一周的订单统计
→ Claude自动调用database MCP的execute_query工具
5.5 常用的MCP服务器生态
官方MCP服务器
| 服务器 | 功能 | 使用场景 |
|---|---|---|
| Filesystem | 安全的文件系统操作 | 读写项目外的文件 |
| Git | Git仓库管理 | 高级Git操作 |
| Memory | 知识图谱存储 | 持久化记忆 |
| Sequential Thinking | 问题解决工作流 | 复杂推理任务 |
社区热门服务器
开发工具类：
-
GitHub MCP Server
npm install @modelcontextprotocol/server-github # 提供功能： - 搜索仓库 - 管理Issues和PR - 查看提交历史 - Fork和Star仓库 -
Docker MCP Server
npm install @modelcontextprotocol/server-docker # 提供功能： - 容器管理 - 镜像构建 - Dockerfile生成
数据集成类：
-
PostgreSQL/MySQL MCP
# 提供功能： - 执行SQL查询 - 数据库Schema查询 - 表结构分析 -
Notion MCP
# 提供功能： - 创建和编辑页面 - 查询数据库 - 批量操作
企业服务类：
-
Slack MCP
# 提供功能： - 发送消息 - 创建频道 - 工作流集成 -
Salesforce MCP
# 提供功能： - CRM数据查询 - 创建销售线索 - 报表生成
MCP服务器目录
- mcpserver.works：3000+ MCP服务器目录
- Smithery：2200+ 服务器及安装指南
- MCP Market：排名前100的服务器
- ClaudeMCP.com：精选最佳服务器
5.6 开发自己的MCP服务器
使用场景
当你需要：
- 连接内部系统（ERP、CRM等）
- 集成专有API
- 提供自定义工具集合
- 封装复杂的业务逻辑
快速开始（Node.js示例）
1. 安装SDK
npm install @modelcontextprotocol/sdk
2. 创建服务器
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
// 创建MCP服务器
const server = new Server(
{
name: "mythos-erp",
version: "1.0.0",
},
{
capabilities: {
tools: {},
resources: {}
},
}
);
// 定义工具：查询订单
server.setRequestHandler("tools/list", async () => {
return {
tools: [
{
name: "query_orders",
description: "查询订单信息",
inputSchema: {
type: "object",
properties: {
date_from: { type: "string" },
date_to: { type: "string" },
status: { type: "string" }
}
}
}
]
};
});
// 实现工具逻辑
server.setRequestHandler("tools/call", async (request) => {
if (request.params.name === "query_orders") {
const { date_from, date_to, status } = request.params.arguments;
// 调用内部ERP API
const orders = await fetchOrdersFromERP({
dateFrom: date_from,
dateTo: date_to,
status: status
});
return {
content: [
{
type: "text",
text: JSON.stringify(orders, null, 2)
}
]
};
}
throw new Error("Unknown tool");
});
// 启动服务器（STDIO模式）
const transport = new StdioServerTransport();
await server.connect(transport);
3. 在Claude Code中配置
{
"mcpServers": {
"mythos-erp": {
"transport": "stdio",
"command": "node",
"args": ["./mcp-servers/mythos-erp.js"],
"env": {
"ERP_API_URL": "https://erp.mythos.com/api",
"ERP_API_KEY": "${ERP_API_KEY}"
}
}
}
}
4. 使用
claude
> @mythos-erp 查询本月所有待发货的订单
HTTP服务器模式（生产环境）
import express from "express";
import { MCPHttpServer } from "@modelcontextprotocol/sdk/server/http.js";
const app = express();
const mcpServer = new MCPHttpServer(/* ... */);
app.post("/mcp", async (req, res) => {
const result = await mcpServer.handleRequest(req.body);
res.json(result);
});
app.listen(3000, () => {
console.log("MCP Server running on http://localhost:3000/mcp");
});
5.7 MCP最佳实践
1. 工具设计原则
❌ 避免：一个API端点一个工具（导致工具爆炸）
{
"tools": [
"get_user_by_id",
"get_user_by_email",
"get_user_by_username",
"update_user_name",
"update_user_email",
... // 50+个工具
]
}
✅ 推荐：按任务分组（任务导向设计）
{
"tools": [
"search_users", // 统一搜索，支持多种条件
"update_user", // 统一更新，接受字段映射
"manage_permissions" // 统一权限管理
]
}
2. 性能优化
缓存策略：
{
"cachePolicy": {
"cacheable": [
"resources/list",
"resources/read",
"prompts/list"
],
"ttl": 3600,
"notCacheable": [
"tools/call"
]
}
}
好处：
- MCP内置缓存可降低Token成本40%+
- 减少API调用次数
- 提升响应速度
3. 安全性
认证授权：
// ✅ 正确：验证Token audience
const validateToken = (token) => {
const decoded = jwt.verify(token, publicKey);
if (!decoded.aud || !decoded.aud.includes("mythos-mcp")) {
throw new Error("Invalid audience");
}
if (decoded.aud === "api") {
throw new Error("Generic audience not allowed");
}
return decoded;
};
// ❌ 危险：直接传递Token（Confused Deputy问题）
server.tool("call_external_api", async (args, context) => {
return fetch("https://api.example.com", {
headers: {
"Authorization": `Bearer ${context.clientToken}` // 危险！
}
});
});
安全清单：
- HTTPS传输（生产必须）
- Token过期时间<1小时
- 验证Token audience
- 速率限制
- 输入验证
- 最小权限原则
4. 可观测性
结构化日志：
const logger = {
info: (message, context) => {
console.error(JSON.stringify({
timestamp: new Date().toISOString(),
level: "INFO",
message,
traceId: context.traceId,
...context
}));
}
};
// 使用
server.setRequestHandler("tools/call", async (request, context) => {
logger.info("Tool called", {
tool: request.params.name,
traceId: context.traceId,
userId: context.userId
});
// ...执行工具逻辑
});
关键指标：
- 服务可用性（Uptime %）
- 平均响应时间（ms）
- 错误率（%）
- Token消耗（tokens/请求）
- 缓存命中率（%）
5.8 MCP与Claude Code的深度集成
自动工具发现
Claude Code启动
↓
读取~/.claude/mcp-config.json
↓
连接所有MCP服务器
↓
调用tools/list获取工具列表
↓
将工具注册到主Agent
↓
用户对话时自动匹配工具
上下文自动加载
对话开始
↓
Claude分析任务类型
↓
识别需要哪些Resource
↓
调用resources/read加载
↓
Resource内容注入上下文
↓
基于完整上下文生成回复
实际案例
场景：使用Notion管理开发任务
# 1. 配置Notion MCP
claude mcp add notion \
--transport http \
--url https://api.notion.com/v1/mcp
# 2. 使用
claude
> 在Notion的"Mythos开发"数据库中创建一个新任务：
标题：实现用户异步登录
优先级：高
负责人：zhangsan
截止日期：2026-01-20
Claude执行：
1. 识别意图：需要在Notion创建页面
2. 查找MCP工具：发现notion的create_page工具
3. 调用工具并传递参数
4. 返回：✓ 任务已创建，链接：https://notion.so/xxx
小结
MCP协议是Claude Code连接外部世界的桥梁，通过标准化的接口，使得AI能够无缝集成各种服务。关键要点：
- 三大原语：Tools（AI调用）、Resources（应用推送）、Prompts（用户选择）
- 标准协议：基于JSON-RPC 2.0，支持能力协商
- 丰富生态：3000+ MCP服务器覆盖各种场景
- 易于扩展：可以为内部系统开发自定义MCP服务器
- 安全优先：认证、授权、审计缺一不可
在下一章节，我们将探讨Skills生态，了解如何构建可复用的工作流模板。
六、Skills生态：构建可复用的工作流
6.1 什么是Skills
Skills是Claude Code中可复用的工作流模板，通过注入专业化的system prompt来扩展Claude的能力。
Skills vs 普通命令
普通命令：git commit -m "message"
→ 直接执行，无智能
Skills：/commit
→ 触发工作流：
1. 分析代码变更
2. 运行pre-commit hooks
3. 生成语义化commit message
4. 创建commit
5. 运行post-commit hooks
Skills的核心价值
- 可复用性：一次定义，多次使用
- 一致性：团队统一的工作流程
- 专业性：注入领域知识和最佳实践
- 自动化：减少重复性操作
6.2 Skills的结构
每个Skill必须包含一个SKILL.md文件：
---
name: code-review
description: 执行全面的代码审查，关注质量、性能和安全
allowed-tools:
- Read
- Grep
- Glob
version: 1.0.0
author: team
tags:
- review
- quality
---
# 代码审查指南
## 审查范围
你将对代码进行以下维度的审查：
### 1. 代码质量
- [ ] 命名规范：变量、方法、类名是否清晰
- [ ] 代码重复：是否有重复逻辑可提取
- [ ] 复杂度：单个方法是否过长或过于复杂
- [ ] 注释：关键逻辑是否有注释
### 2. 性能
- [ ] N+1查询：数据库查询是否优化
- [ ] 缓存：是否合理使用缓存
- [ ] 大对象：是否避免不必要的深拷贝
- [ ] 资源泄漏：是否正确关闭资源
### 3. 安全性
- [ ] SQL注入：是否使用参数化查询
- [ ] XSS：用户输入是否转义
- [ ] 权限检查：接口是否有权限控制
- [ ] 敏感数据：密码、密钥是否加密
### 4. 可维护性
- [ ] 单一职责：类和方法职责是否单一
- [ ] 依赖注入：是否合理使用DI
- [ ] 异常处理：异常是否被正确处理
- [ ] 测试覆盖：是否有对应的单元测试
## 审查流程
1. 使用Grep查找潜在问题模式
2. 使用Read阅读相关文件
3. 分析代码逻辑和设计
4. 生成审查报告
## 输出格式
### ✅ 优点
- 列出代码的亮点
### ⚠️ 建议
- 列出需要改进的地方，提供具体建议
### 🚨 严重问题
- 列出必须修复的问题，提供修复方案
## 参考资料
- 阿里巴巴Java开发手册
- OWASP Top 10
- 项目CLAUDE.md中的规范
6.3 创建自定义Skills
场景1：Java代码规范检查
.claude/skills/java-lint/SKILL.md
---
name: java-lint
description: 检查Java代码是否符合项目规范
allowed-tools:
- Read
- Grep
- Glob
---
# Java代码规范检查
## 检查项
### 1. 命名规范
- 类名：大驼峰（UserService）
- 方法名：小驼峰（getUserById）
- 常量：全大写+下划线（MAX_SIZE）
- 包名：全小写（com.mythos.user）
### 2. 注解使用
- Controller方法必须有@RequestMapping
- Service方法涉及数据库操作必须有@Transactional
- 所有参数必须有JSR-303验证注解
### 3. 异常处理
- ❌ 禁止：空catch块
- ❌ 禁止：catch Exception后不处理
- ✅ 必须：@Transactional方法中抛出异常
### 4. 日志规范
- 使用TraceLogger而非slf4j
- 关键业务流程必须有INFO日志
- 异常必须记录ERROR日志
## 检查流程
1. 使用Glob找到所有Java文件
2. 对每个文件执行规范检查
3. 生成不符合规范的清单
4. 对每个问题提供修复建议
## 输出示例
Java代码规范检查报告
✅ 符合规范：23个文件
⚠️ 需要改进：5个文件
详细问题
UserService.java:45
问题：方法缺少@Transactional注解
public void createUser(User user) { // ⚠️ 缺少@Transactional
userRepository.save(user);
}
建议：添加@Transactional(rollbackFor = Exception.class)
OrderController.java:78
问题：空catch块
try {
orderService.createOrder(order);
} catch (Exception e) {
// ⚠️ 空catch块，异常被吞掉
}
建议：至少记录日志，或重新抛出异常
场景2：数据库迁移生成
.claude/skills/db-migration/SKILL.md
---
name: db-migration
description: 根据Entity变更生成Flyway迁移脚本
allowed-tools:
- Read
- Write
- Grep
- Bash
---
# 数据库迁移生成
## 工作流程
### 1. 分析Entity变更
- 读取所有@Entity类
- 对比Git diff找出变更
- 分析字段的增加、删除、修改
### 2. 生成迁移脚本
- 生成ALTER TABLE语句
- 包含向前和向后兼容性
- 添加必要的索引和约束
### 3. 生成文件
- 文件名：V{version}__{description}.sql
- 位置：src/main/resources/db/migration/
- 版本号自动递增
### 4. 验证
- 检查SQL语法
- 确保符合项目规范（见CLAUDE.md）
## SQL规范
- BIGINT UNSIGNED用于ID
- DATETIME不用TIMESTAMP
- DECIMAL(19,2)用于金额
- utf8mb4字符集
- 所有表必须包含5个标准字段
## 示例输出
```sql
-- V001__add_email_to_user.sql
ALTER TABLE `users`
ADD COLUMN `email` VARCHAR(100) NOT NULL COMMENT '邮箱地址' AFTER `username`,
ADD UNIQUE KEY `uk_email_deleted` (`email`, `is_deleted`);
### 6.4 官方和社区Skills
#### 官方Skills（anthropics/skills）
| Skill | 用途 | 场景 |
|-------|------|------|
| **/commit** | 智能生成commit message | Git提交 |
| **/review** | 代码审查 | PR审查 |
| **/test** | 生成和运行测试 | TDD开发 |
| **/docx** | Word文档处理 | 文档生成 |
#### 社区热门Skills
**1. claude-scientific-skills**（125+ 科学计算Skills）
```bash
# 安装
cd ~/.claude/skills
git clone https://github.com/user/claude-scientific-skills
# 使用
claude /bioinformatics "分析DNA序列"
claude /cheminformatics "预测化合物性质"
2. aws-skills（AWS开发）
# 提供Skills：
/aws-cdk # AWS CDK最佳实践
/serverless # Serverless架构模式
/lambda # Lambda函数开发
3. web-artifacts-builder（Web开发）
# 使用React + Tailwind + shadcn/ui创建Web组件
claude /web-artifact "创建一个用户登录表单"
Skills市场
- SkillsMP.com：聚合了数千个Skills，支持搜索和评分
- GitHub搜索：搜索"claude-skills"找到最新Skills
- Awesome Claude Skills：精选的Skills列表
6.5 Skills使用最佳实践
1. Skill设计原则
✅ 好的Skill：
- 单一职责（只做一件事）
- SKILL.md<500行（详细文档放单独文件）
- 触发丰富的描述（Claude用语义匹配）
- 清晰的步骤说明
❌ 避免：
- 一个Skill做太多事
- SKILL.md过长（影响上下文）
- 描述模糊（难以匹配）
2. Progressive Disclosure（渐进式披露）
Skills与其他内容共享200K上下文窗口，因此要使用渐进式披露：
SKILL.md（必要信息）
- 基本说明
- 关键步骤
- 输出格式
docs/detailed-guide.md（详细文档）
- 完整示例
- 边界情况处理
- 参考资料
scripts/helper.sh（辅助脚本）
- 具体实现
使用时：
- Claude首先读取SKILL.md（占用少量tokens）
- 需要时再读取详细文档（按需加载）
3. 触发优化
Skill的description是Claude用来决定何时使用的关键：
❌ 描述不佳：
description: 代码审查
✅ 描述优秀：
description: |
对代码进行全面审查，包括：
- 代码质量和规范性
- 性能优化机会
- 安全漏洞检测
- 可维护性分析
特别适合PR审查和重构前的评估。
4. 团队协作
统一Skills库：
# 项目级Skills
.claude/skills/
├── java-lint/ # Java规范检查
├── db-migration/ # 数据库迁移
├── api-doc-gen/ # API文档生成
└── deploy/ # 部署流程
# 使用Git管理
git add .claude/skills
git commit -m "添加团队共享Skills"
git push
好处：
- 团队统一的工作流程
- 新成员快速上手
- 持续积累最佳实践
6.6 实战：创建完整的Skills生态
场景：Java微服务开发全流程
1. /feature - 新功能开发
---
name: feature
description: 创建新功能的完整流程
---
# 新功能开发流程
1. 分析需求，生成设计文档
2. 创建Git分支
3. 生成Controller、Service、Repository代码
4. 生成对应的单元测试
5. 更新API文档
6. 运行测试验证
7. 生成commit message
2. /refactor - 代码重构
---
name: refactor
description: 安全地重构代码
---
# 重构流程
1. 分析现有代码结构
2. 识别重构机会
3. 制定重构计划
4. 执行重构
5. 运行全量测试
6. 生成重构报告
3. /deploy - 部署流程
---
name: deploy
description: 执行标准化部署流程
---
# 部署流程
1. 检查分支状态
2. 运行测试套件
3. 构建Docker镜像
4. 推送到镜像仓库
5. 更新Kubernetes配置
6. 执行滚动更新
7. 验证部署结果
使用效果：
# 开发新功能
claude /feature "添加用户异步登录功能"
→ 自动生成完整的代码、测试、文档
# 重构代码
claude /refactor "优化OrderService的查询性能"
→ 分析、优化、测试一气呵成
# 部署
claude /deploy production
→ 自动执行完整的部署流程
七、工程化实践与最佳实践
7.1 项目配置：CLAUDE.md
CLAUDE.md是Claude Code自动读取的项目文档，定义了项目的开发规约和上下文。
最佳结构
# CLAUDE.md
## 项目概览
**项目名称**：Mythos B2C电商平台
**技术栈**：Java 17 + Spring Boot 3 + MyBatis-Plus + Redis
**架构**：微服务 + DDD
## 快速导航
- 后端服务：`backend/mythos-*-center/`
- 前端应用：`frontend/mythos-admin/`
- 设计文档：`design/神话B2C顶层设计.md`
## 核心规约
### 1. 分层架构（严格执行）
Controller → Service → Repository → Mapper → Database
**禁止**：跨层调用、Service直接调用Mapper
### 2. 命名规范
- Controller：XxxController
- Service：XxxService / XxxServiceImpl
- Repository：XxxRepository / XxxRepositoryImpl
- DTO：XxxDTO、XxxCreateRequest、XxxVO
### 3. 事务管理
```java
// ✅ 正确
@Transactional(rollbackFor = Exception.class)
public void createOrder(OrderDTO dto) {
try {
orderRepository.save(order);
} catch (Exception e) {
log.error("创建失败", e);
throw new BusinessException("创建失败", e); // 必须重新抛出
}
}
// ❌ 错误：吞掉异常
@Transactional(rollbackFor = Exception.class)
public void createOrder(OrderDTO dto) {
try {
orderRepository.save(order);
} catch (Exception e) {
log.error("创建失败", e); // 吞掉异常，事务不会回滚
}
}
### 4. 数据库设计
所有表必须包含标准字段：
id BIGINT UNSIGNED PRIMARY KEY
is_deleted TINYINT DEFAULT 0
created_by BIGINT UNSIGNED DEFAULT 0
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
updated_by BIGINT UNSIGNED DEFAULT 0
updated_at DATETIME ON UPDATE CURRENT_TIMESTAMP
**禁止**：外键约束（微服务不兼容）
## 常用命令
```bash
# 构建
mvn clean install
mvn clean install -DskipTests
# 格式化
mvn fmt:format
# 运行
mvn spring-boot:run
# 测试
mvn test
## 关键决策记录
- 使用TraceLogger而非slf4j（自动traceId）
- 所有API返回Response<T>格式
- Repository必须extends ServiceImpl
- 查询必须过滤is_deleted=0
CLAUDE.md的价值
有CLAUDE.md：
用户: "添加用户登录功能"
Claude: [自动遵循项目规范]
- 创建UserController（符合命名规范）
- Service使用@Transactional
- Repository继承ServiceImpl
- 返回Response<UserVO>
- 使用TraceLogger
无CLAUDE.md：
用户: "添加用户登录功能"
Claude: [可能不符合规范]
- 创建LoginController
- 直接返回User实体
- 使用slf4j
- 忘记过滤is_deleted
结果：需要多轮修正，浪费时间
7.2 权限配置
.claude/settings.json
{
"alwaysThinkingEnabled": true,
"permissions": {
"allow": [
"Bash(mvn:*)", // 允许所有Maven命令
"Bash(git status:*)", // 允许git status
"Bash(git diff:*)", // 允许git diff
"WebFetch(domain:github.com)",
"WebSearch"
],
"ask": [
"Bash(rm:*)", // 删除需要确认
"Bash(git push:*)", // 推送需要确认
"Write(**/*.java)" // 写入Java文件需要确认
],
"deny": [
"Bash(sudo:*)", // 禁止sudo
"Bash(chmod:*)", // 禁止修改权限
"Bash(curl http://)*" // 禁止HTTP请求（只允许HTTPS）
]
}
}
7.3 Hooks自动化
.claude/settings.json
{
"hooks": {
"post-edit": {
"pattern": "*.java$",
"command": "mvn fmt:format -f ${FILE_PATH}",
"suppress_output": true,
"description": "自动格式化Java文件"
},
"pre-commit": {
"command": "mvn clean test",
"message": "运行测试...",
"block": true,
"continue_on_success": true,
"description": "提交前运行测试"
},
"pre-bash": {
"pattern": "rm.*\\-r|drop.*database",
"message": "⚠️ 检测到删除操作，确认继续？",
"block": true,
"description": "拦截危险操作"
}
}
}
7.4 IDE集成
VS Code配置
settings.json
{
"claude-code.keyboard_shortcut": "cmd+esc",
"claude-code.inline_diff": true,
"claude-code.auto_accept_edits": false,
"claude-code.show_plan_first": true
}
快捷键：
Cmd+Esc：打开Claude CodeCmd+K：新建对话Cmd+Enter：发送消息
JetBrains IDEA配置
快捷键：
Cmd+Esc：启动Claude CodeAlt+Enter：快速修复（Claude建议）
7.5 团队协作模式
PR-First工作流
使用Claude Code：
# 1. 创建分支
git checkout -b feature/async-login
# 2. 开发功能
claude "/feature 实现用户异步登录"
# 3. 运行测试
claude "/test"
# 4. 创建PR
claude "/pr 创建PR，标题为'feat: 用户异步登录'"
# 5. 审查
gh pr view 123
claude "/review --pr 123"
代码审查清单
使用自定义Skill自动化：
.claude/skills/pr-checklist/SKILL.md
# PR审查清单
## 自动检查
- [ ] 所有测试通过
- [ ] 代码覆盖率>80%
- [ ] 无Checkstyle警告
- [ ] 无PMD警告
- [ ] 无安全漏洞
## 人工审查
- [ ] 代码符合CLAUDE.md规范
- [ ] 变更合理且最小化
- [ ] 有必要的注释
- [ ] 更新了文档
7.6 性能优化
1. 减少Token消耗
❌ 低效做法：
- 多次顺序Read
- 重复读取相同文件
- 读取不相关文件
✅ 高效做法：
- 批量并行Read
- 利用MCP缓存
- 只读取必要文件
2. 选择合适的模型
任务类型 → 模型选择
─────────────────────────
简单修改 → claude-haiku（快速、便宜）
标准任务 → claude-opus-4-5（平衡）
复杂推理 → claude-opus-4-5 + Extended Thinking
3. 使用Task Agent并行化
场景：修改15个Service类
串行执行：15 × 30秒 = 7.5分钟
并行执行（3个Agent）：5 × 30秒 = 2.5分钟
提速3倍！
小结
工程化实践是将Claude Code从"玩具"变为"生产力工具"的关键。核心要点：
- CLAUDE.md：项目上下文的单一来源
- 权限配置：安全第一，最小权限
- Hooks自动化：减少重复劳动
- Skills生态：积累团队最佳实践
- 团队协作：统一的工作流程
官方资源
- 官方文档：https://code.claude.com/docs
- GitHub仓库：https://github.com/anthropics/claude-code
- Skills仓库：https://github.com/anthropics/skills
- MCP规范：https://modelcontextprotocol.io/
社区资源
- SkillsMP：https://skillsmp.com/（Skills市场）
- MCP Market：https://mcpmarket.com/（MCP服务器目录）
- Awesome Claude：https://github.com/awesome-claude（精选资源）
参考资料
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
9
0- 0
已为社区贡献1条内容
所有评论(0)