Claude Code使用实战教程

jiayong232026-02-15 17:08

第一章： 从零开始的AI编程之旅

一:Claude Code 简介

Claude Code 是什么?

Claude Code 是一个在终端里运行的 AI 编程助手。它不是一个编辑器,也不是 IDE 插件,而是一个命令行工具。

工作流程对比:

  • 传统方式:打开 IDE → 编写代码 → 遇到问题 → 搜索解决方案 → 复制粘贴 → 调试
  • 使用 Claude Code:在终端输入需求(如"帮我创建一个 Spring Boot 项目")→ 自动完成

主要功能

  1. 理解代码库 - 能够理解整个项目的结构
  2. 编写代码 - 创建新文件、修改现有代码
  3. 执行命令 - 运行测试、编译、部署
  4. 调试 - 发现并修复 bug
  5. 重构 - 优化代码结构
  6. 生成文档 - 自动生成注释和文档

核心优势

Claude Code 相比 IDE 自带的 AI 助手具有以下优势:

  • 全局视角 - 能够看到整个项目,不只是当前文件
  • 自主执行 - 可以自动运行命令,无需手动复制粘贴
  • 强大的理解能力 - 基于 Claude Sonnet 4 模型,理解能力出色
  • 可定制 - 可以通过配置文件自定义编码规范

二:安装配置

前置条件

开始之前,需要准备以下环境:

  1. Node.js (版本 14 或更高)

    bash 复制代码 
    # 检查是否已安装
node --version

  2. Anthropic 账号

安装步骤

方式一:直接运行
bash 复制代码 
npx @anthropic-ai/claude-code

第一次运行会自动下载并安装。

方式二:全局安装
bash 复制代码 
npm install -g @anthropic-ai/claude-code

npm install -g @anthropic-ai/claude-code --registry=https://registry.npmmirror.com

安装完成后,可以直接使用 claude 命令。

注意 : 包名是 @anthropic-ai/claude-code,不是 @claude/cli。

登录认证

首次使用需要进行登录:

bash 复制代码 
claude

系统会提示选择登录方式:

  1. Claude.ai 账号 - 免费用户可用,但有使用限制
  2. Claude Console API - 需要充值,但更稳定

选择一种方式,按照提示完成登录。登录信息会保存在本地,后续无需重复登录。

三:首次使用

启动 Claude Code

在项目目录(或任意文件夹)中运行:

bash 复制代码 
claude

启动后会看到欢迎界面:

复制代码 
╭─── Claude Code v2.1.7 ────────────────────────────────────────────────────────────────────╮
│                                    │ Tips for getting started                             │
│            Welcome back!           │ Ask Claude to create a new app or clone a repository │
│                                    │ ──────────────────────────────────────────────────── │
│               ▐▛███▜▌              │ Recent activity                                      │
│              ▝▜█████▛▘             │ No recent activity                                   │
│                ▘▘ ▝▝               │                                                      │
│                                    │                                                      │
│   Sonnet 4.5 · API Usage Billing   │                                                      │
│   D:\work\training   │                                                      │
╰───────────────────────────────────────────────────────────────────────────────────────────╯

  /model to try Opus 4.5

基础操作示例

1. 分析当前目录
复制代码 
分析一下当前目录有什么文件

系统会列出文件并识别项目类型。

2. 创建 Java 文件
复制代码 
帮我创建一个简单的 Java Hello World 程序

Claude Code 会:

  • 创建文件
  • 编写代码
  • 询问确认

输入 yes 确认后会创建文件。

3. 编译并运行
复制代码 
编译并运行刚才的 Java 程序

系统会自动执行 javac 和 java 命令。

权限确认设置

默认情况下,每次操作都需要确认。如需跳过确认,可以使用以下参数:

bash 复制代码 
claude --dangerously-skip-permissions

注意:此参数会跳过所有权限确认,请谨慎使用。

四:基础命令

斜杠命令(Slash Commands)

内置的快捷命令,以 / 开头:

命令 作用 示例
/help 查看所有可用命令 /help
/clear 清空当前对话 /clear
/resume 恢复之前的对话 /resume
/exit 退出 Claude Code /exit
/login 切换账号 /login
/model 切换模型 /model sonnet

文件操作

可以使用自然语言进行文件操作:

bash 复制代码 
# 读取文件
帮我读一下 src/Main.java 这个文件

# 编辑文件
修改 src/Main.java 中的某个方法

# 创建文件
创建一个新的 Utils.java 文件

常见使用场景

场景1:创建新项目
复制代码 
创建一个 Spring Boot 项目,包含 Web 依赖和 JPA
场景2:修复 Bug
复制代码 
我的 UserService.java 里有个 NullPointerException,帮我分析
场景3:编写测试
复制代码 
给 UserService 写单元测试,使用 JUnit 5 和 Mockito
场景4:重构代码
复制代码 
把 UserController.java 里重复的代码提取成公共方法

五:实战案例 - 创建 Java 程序

案例:计算器程序

需求:创建一个简单的命令行计算器,支持加减乘除。

步骤1:启动 Claude Code

在项目目录中运行:

bash 复制代码 
# Linux/Mac
cd ~/projects
mkdir calculator-demo
cd calculator-demo
claude

# Windows
cd C:\Users\你的用户名\projects
mkdir calculator-demo
cd calculator-demo
claude
步骤2:创建项目

在 Claude Code 中输入:

复制代码 
创建一个 Java 计算器程序,要求:
1. 有一个 Calculator 类,包含加减乘除方法
2. 有一个 Main 类,可以从命令行接收输入
3. 要有异常处理,比如除以零的情况

Claude Code 会:

  1. 创建项目结构
  2. 编写 Calculator.java
  3. 编写 Main.java
  4. 询问确认
步骤3:查看生成的代码
复制代码 
让我看看 Calculator.java 的代码
步骤4:编译并测试
复制代码 
编译这个项目并运行一下,测试加法功能
步骤5:添加功能
复制代码 
再加一个求幂运算的方法

系统会修改 Calculator.java,添加新方法。

六:Vue 3 快速入门

案例:创建 Todo List

步骤1:初始化项目
复制代码 
创建一个 Vue 3 项目,使用 Vite,包含 TypeScript
步骤2:创建组件
复制代码 
创建一个 TodoList 组件,要求:
1. 可以添加待办事项
2. 可以标记完成
3. 可以删除
4. 使用 Composition API
5. 使用 TypeScript
步骤3:运行项目
复制代码 
安装依赖并启动开发服务器

七:常见问题和解决方案

Q1: Claude Code 响应很慢怎么办?

原因:对话历史过长,上下文过多。

解决方案:

bash 复制代码 
/clear

清空对话,重新开始,或者开启新的会话。

Q2: 生成的代码有 bug 怎么办?

可以采取以下措施:

  1. 直接反馈:

    复制代码 
    这段代码有问题,抛出了 NullPointerException,帮我修复

  2. 提供错误信息:

    复制代码 
    运行时报错:java.lang.NullPointerException at line 25,帮我分析

Q3: 如何恢复之前的对话?

使用 /resume 命令可以恢复上一次的对话。

第八部分:最佳实践

1. 明确需求描述

不推荐的提问:

复制代码 
帮我写个用户管理

推荐的提问:

复制代码 
创建一个用户管理模块,包含:
- User 实体类(id, username, email, password)
- UserRepository 接口(继承 JpaRepository)
- UserService 类(实现 CRUD 操作)
- UserController 类(提供 REST API)
- 使用 Spring Boot 3.x 和 Spring Data JPA

2. 分步骤执行

不要一次性要求过多功能。建议分步进行:

第一步:

复制代码 
创建一个基础的 Spring Boot 项目

第二步:

复制代码 
添加用户实体和仓库

第三步:

复制代码 
添加用户服务和控制器

3. 利用项目上下文

Claude Code 能够理解整个项目,可以这样使用:

复制代码 
参考项目中 UserService 的写法,为 ProductService 创建类似的实现

小结

本课程学习内容:

  • Claude Code 的功能和特点
  • 安装和登录配置
  • 基础命令和使用方法
  • 实战案例:Java 计算器和 Vue Todo List
  • 最佳实践和常见问题

AI 编程的核心是学会如何有效地与 AI 协作,让它成为高效的编程助手。

第二章: CLAUDE.md 和项目配置

第一部分:CLAUDE.md 配置文件简介

配置文件说明

CLAUDE.md 是项目根目录下的 Markdown 配置文件,用于定义项目规范和开发标准。

Claude Code 启动时会自动读取此文件,并按照其中定义的规则执行任务。

配置内容

  1. 项目基本信息 - 技术栈、架构、目录结构
  2. 开发规范 - 代码风格、命名规则、最佳实践
  3. 常用命令 - 编译、测试、部署命令
  4. 注意事项 - 开发约束和限制

第二部分:创建 CLAUDE.md 配置文件

Spring Boot 项目示例

以 Spring Boot 项目为例,创建配置文件。

在项目根目录创建 CLAUDE.md:

markdown 复制代码 
# 用户管理系统

## 项目概况

这是一个基于 Spring Boot 3.2 的用户管理系统,用于管理公司员工信息。

## 技术栈

- **后端框架**: Spring Boot 3.2.0
- **Java 版本**: Java 17
- **构建工具**: Maven 3.9.x
- **数据库**: MySQL 8.0
- **ORM**: Spring Data JPA + Hibernate
- **API 文档**: SpringDoc OpenAPI 3
- **测试框架**: JUnit 5 + Mockito

## 项目结构

```
src/main/java/com/company/usermanagement/
├── controller/      # REST 控制器
├── service/         # 业务逻辑层
├── repository/      # 数据访问层
├── entity/          # 实体类
├── dto/             # 数据传输对象
├── exception/       # 自定义异常
├── config/          # 配置类
└── util/            # 工具类
```

## 开发规范

### 代码风格

1. **使用 4 个空格缩进**,不用 Tab
2. **类名用大驼峰**(PascalCase),如 `UserService`
3. **方法名和变量名用小驼峰**(camelCase),如 `getUserById`
4. **常量全大写用下划线**(UPPER_SNAKE_CASE),如 `MAX_RETRY_COUNT`
5. **包名全小写**,如 `com.company.usermanagement.controller`

### 命名规范

- **Controller 类**: 以 `Controller` 结尾,如 `UserController`
- **Service 接口**: 以 `Service` 结尾,如 `UserService`
- **Service 实现**: 以 `ServiceImpl` 结尾,如 `UserServiceImpl`
- **Repository 接口**: 以 `Repository` 结尾,如 `UserRepository`
- **Entity 类**: 直接用业务名称,如 `User`
- **DTO 类**: 以用途+DTO 结尾,如 `UserCreateDTO`, `UserResponseDTO`

### REST API 规范

- **GET** 请求用于查询,不修改数据
- **POST** 请求用于创建资源
- **PUT** 请求用于完整更新资源
- **PATCH** 请求用于部分更新资源
- **DELETE** 请求用于删除资源

URL 路径:
- 使用小写字母和连字符,如 `/api/users`
- 集合资源用复数,如 `/api/users`
- 单个资源后面跟 ID,如 `/api/users/{id}`

### 异常处理

- 使用 `@RestControllerAdvice` 统一处理异常
- 自定义业务异常继承 `RuntimeException`
- 异常类放在 `exception` 包下
- 返回统一的错误响应格式

### 日志规范

- 使用 SLF4J + Logback
- Controller 层记录请求和响应
- Service 层记录关键业务逻辑
- 异常必须记录堆栈信息
- 不要在循环中记录日志

## 常用命令

### 编译和运行

```bash
# 编译项目
mvn clean compile

# 运行测试
mvn test

# 打包
mvn clean package

# 运行应用
mvn spring-boot:run

# 指定环境运行
mvn spring-boot:run -Dspring-boot.run.profiles=dev
```

### 数据库操作

```bash
# 生成数据库迁移脚本
mvn flyway:migrate

# 清空数据库
mvn flyway:clean
```

## 测试规范

### 单元测试

- 使用 JUnit 5 的 `@Test` 注解
- 使用 Mockito 模拟依赖
- 测试类名以 `Test` 结尾,如 `UserServiceTest`
- 测试方法命名:`should_期望结果_when_条件`
  - 例如:`should_returnUser_when_userExists`

### 集成测试

- 使用 `@SpringBootTest` 注解
- 测试类名以 `IntegrationTest` 结尾
- 使用 H2 内存数据库进行测试

## 注意事项

### 必须遵守

- **永远不要**在代码中硬编码密码和密钥
- **永远不要**直接 commit 到 main 分支
- **必须**为新功能编写单元测试
- **必须**在 Pull Request 前运行所有测试

### 建议

- 优先使用 Spring Boot 的自动配置
- 使用 `@Slf4j` 注解代替手动创建 Logger
- 数据库查询优先使用 Spring Data JPA 的方法命名查询
- 复杂查询可以使用 `@Query` 注解

## 常见任务

### 创建新的实体

1. 在 `entity` 包下创建实体类
2. 使用 JPA 注解:`@Entity`, `@Table`, `@Id` 等
3. 实现 getter/setter 或使用 Lombok 的 `@Data`
4. 在 `repository` 包下创建对应的 Repository 接口

### 添加新的 API 接口

1. 在对应的 Controller 中添加方法
2. 使用合适的 HTTP 方法注解(`@GetMapping`, `@PostMapping` 等)
3. 使用 DTO 接收请求参数,不要直接使用 Entity
4. 在 Service 层实现业务逻辑
5. 编写单元测试

### 处理跨域

已在 `WebConfig` 中配置了 CORS,允许所有来源访问。生产环境需要修改为具体的前端域名。

## 其他约定

- 时间统一使用 `LocalDateTime`,不使用 `Date`
- 金额使用 `BigDecimal`,不使用 `double` 或 `float`
- 布尔类型的字段名用 `is` 开头,如 `isActive`
- 集合类型的字段名用复数,如 `users`, `orders`

Vue 3 项目示例

再来看一个 Vue 3 前端项目的配置:

markdown 复制代码 
# 员工管理前端

## 项目概况

这是员工管理系统的前端部分,使用 Vue 3 + TypeScript + Vite 构建。

## 技术栈

- **框架**: Vue 3.4.x
- **构建工具**: Vite 5.x
- **语言**: TypeScript 5.x
- **状态管理**: Pinia 2.x
- **路由**: Vue Router 4.x
- **UI 框架**: Element Plus
- **HTTP 客户端**: Axios
- **CSS**: Tailwind CSS 3.x
- **代码规范**: ESLint + Prettier
- **测试**: Vitest + @vue/test-utils

## 项目结构

```
src/
├── api/              # API 接口定义
├── assets/           # 静态资源
├── components/       # 可复用组件
├── composables/      # 组合式函数
├── layouts/          # 布局组件
├── router/           # 路由配置
├── stores/           # Pinia 状态管理
├── types/            # TypeScript 类型定义
├── utils/            # 工具函数
├── views/            # 页面组件
├── App.vue           # 根组件
└── main.ts           # 入口文件
```

## 开发规范

### 代码风格

- 使用 **2 个空格**缩进
- 字符串优先使用单引号
- 语句末尾不加分号
- 使用 ES6+ 语法

### 组件规范

#### 文件命名

- 组件文件使用 **PascalCase**,如 `UserList.vue`
- 组合式函数使用 `use` 前缀,如 `useUser.ts`
- 工具函数文件用小驼峰,如 `formatDate.ts`

#### 组件结构

```vue
<script setup lang="ts">
// 1. 导入依赖
import { ref, computed, onMounted } from 'vue'

// 2. 定义 Props
interface Props {
  userId: number
  userName?: string
}
const props = defineProps<Props>()

// 3. 定义 Emits
interface Emits {
  (e: 'update', user: User): void
  (e: 'delete', id: number): void
}
const emit = defineEmits<Emits>()

// 4. 响应式数据
const count = ref(0)

// 5. 计算属性
const doubleCount = computed(() => count.value * 2)

// 6. 方法
const increment = () => {
  count.value++
}

// 7. 生命周期
onMounted(() => {
  console.log('组件挂载了')
})
</script>

<template>
  <!-- 模板内容 -->
</template>

<style scoped>
/* 样式 */
</style>
```

### TypeScript 规范

- **所有组件必须使用 TypeScript**
- **必须定义接口**(interface)描述数据结构
- Props 和 Emits 必须显式定义类型
- 避免使用 `any`,实在不知道类型就用 `unknown`
- API 响应数据必须定义类型

### 状态管理规范

使用 Pinia,遵循以下规范:

```typescript
// stores/user.ts
import { defineStore } from 'pinia'

export const useUserStore = defineStore('user', () => {
  // state
  const users = ref<User[]>([])
  const currentUser = ref<User | null>(null)
  
  // getters
  const userCount = computed(() => users.value.length)
  
  // actions
  const fetchUsers = async () => {
    const data = await api.getUsers()
    users.value = data
  }
  
  return {
    users,
    currentUser,
    userCount,
    fetchUsers
  }
})
```

### API 调用规范

所有 API 调用封装在 `api/` 目录:

```typescript
// api/user.ts
import request from '@/utils/request'

export interface User {
  id: number
  name: string
  email: string
}

export const userApi = {
  getUsers: () => request.get<User[]>('/api/users'),
  
  getUserById: (id: number) => request.get<User>(`/api/users/${id}`),
  
  createUser: (data: Omit<User, 'id'>) => request.post<User>('/api/users', data),
  
  updateUser: (id: number, data: Partial<User>) => request.put<User>(`/api/users/${id}`, data),
  
  deleteUser: (id: number) => request.delete(`/api/users/${id}`)
}
```

## 常用命令

```bash
# 安装依赖
npm install

# 开发模式运行
npm run dev

# 构建生产版本
npm run build

# 预览生产构建
npm run preview

# 运行测试
npm run test

# 代码检查
npm run lint

# 代码格式化
npm run format

# 类型检查
npm run type-check
```

## 组件开发规范

### 1. 优先使用 Composition API

不要用 Options API,全部用 `<script setup>`:

```vue
<!-- ✅ 正确 -->
<script setup lang="ts">
import { ref } from 'vue'
const count = ref(0)
</script>

<!-- ❌ 错误 -->
<script lang="ts">
export default {
  data() {
    return {
      count: 0
    }
  }
}
</script>
```

### 2. Props 定义

```typescript
// ✅ 正确:使用 TypeScript 接口
interface Props {
  title: string
  count?: number  // 可选属性
  items: Item[]
}
const props = defineProps<Props>()

// ❌ 错误:不使用类型
const props = defineProps(['title', 'count', 'items'])
```

### 3. v-model 双向绑定

使用 `defineModel`:

```vue
<script setup lang="ts">
// ✅ 正确
const modelValue = defineModel<string>()

// 在组件中使用
modelValue.value = 'new value'
</script>

<template>
  <input v-model="modelValue" />
</template>
```

### 4. 组合式函数(Composables)

可复用的逻辑提取到 composables:

```typescript
// composables/useCounter.ts
import { ref, computed } from 'vue'

export const useCounter = (initialValue = 0) => {
  const count = ref(initialValue)
  
  const doubleCount = computed(() => count.value * 2)
  
  const increment = () => {
    count.value++
  }
  
  const decrement = () => {
    count.value--
  }
  
  return {
    count,
    doubleCount,
    increment,
    decrement
  }
}
```

## 测试规范

### 组件测试

使用 Vitest + @vue/test-utils:

```typescript
import { describe, it, expect } from 'vitest'
import { mount } from '@vue/test-utils'
import UserCard from './UserCard.vue'

describe('UserCard', () => {
  it('should render user name', () => {
    const wrapper = mount(UserCard, {
      props: {
        user: {
          id: 1,
          name: 'John Doe'
        }
      }
    })
    
    expect(wrapper.text()).toContain('John Doe')
  })
  
  it('should emit delete event when button clicked', async () => {
    const wrapper = mount(UserCard, {
      props: {
        user: { id: 1, name: 'John Doe' }
      }
    })
    
    await wrapper.find('button.delete').trigger('click')
    
    expect(wrapper.emitted('delete')).toBeTruthy()
    expect(wrapper.emitted('delete')?.[0]).toEqual([1])
  })
})
```

## 注意事项

### 性能优化

- 大列表使用虚拟滚动(vue-virtual-scroller)
- 使用 `v-memo` 优化重复渲染的列表项
- 图片使用懒加载
- 路由使用懒加载:`() => import('./views/User.vue')`

### 安全

- 不要在前端代码中硬编码 API 密钥
- 用户输入必须转义,防止 XSS 攻击
- 敏感数据(如 token)存储在 httpOnly cookie 中

### 可访问性

- 所有图片必须有 `alt` 属性
- 表单元素必须有 `label`
- 使用语义化的 HTML 标签

## 常见任务模板

### 创建新页面

1. 在 `views/` 下创建页面组件
2. 在 `router/index.ts` 中添加路由
3. 如果需要状态管理,在 `stores/` 中创建 store
4. 如果需要调用 API,在 `api/` 中添加接口

### 创建可复用组件

1. 在 `components/` 下创建组件
2. 定义清晰的 Props 和 Emits
3. 编写组件文档(使用注释)
4. 编写单元测试

第三部分:配置文件加载机制

自动加载

Claude Code 会自动读取 CLAUDE.md 文件。

启动 Claude Code 时,系统会:

  1. 查找 CLAUDE.md 文件
  2. 读取配置内容
  3. 应用定义的规则

验证配置

创建 CLAUDE.md 后,可以进行验证:

bash 复制代码 
claude

测试命令:

复制代码 
我们项目使用的技术栈是什么?

系统会根据 CLAUDE.md 中的内容回答。

再次测试:

复制代码 
帮我创建一个新的 User Service

系统会按照配置文件中定义的规范生成代码。

第四部分:高级配置 - settings.json

除了 CLAUDE.md,还有一个配置文件:.claude/settings.json

创建配置文件

在项目根目录创建 .claude 文件夹,然后创建 settings.json:

bash 复制代码 
# Linux/Mac
mkdir .claude
touch .claude/settings.json

# Windows (PowerShell)
New-Item -ItemType Directory -Path .claude
New-Item -ItemType File -Path .claude\settings.json

# Windows (CMD)
mkdir .claude
type nul > .claude\settings.json

注意 : .claude 目录和配置文件的具体位置和格式可能因 Claude Code 版本而异,请参考官方文档。

配置权限和 Hooks

这个配置文件可以定义:

  • 权限控制
  • 执行钩子(在某些操作前后自动运行命令)
  • 工具限制
示例配置
json 复制代码 
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "powershell -Command \"if ((git branch --show-current) -eq 'master') { [Console]::Error.WriteLine('{\\\"block\\\": true, \\\"message\\\": \\\"不能直接在 master 分支修改代码!\\\"}'); exit 2 }\"",
            "timeout": 5
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            如果
            "timeout": 30
          }
        ]
      }
    ]
  },
  "permissions": {
    "allow": ["Read", "Grep", "LS", "Bash(npm run *)"],
    "deny": ["WebFetch", "Bash(rm -rf *)"]
  }
}

配置说明

Hooks(钩子)

PreToolUse - 在执行工具前运行

  • 可以用来做权限检查
  • 比如:禁止在 main 分支修改代码

PostToolUse - 在执行工具后运行

  • 可以用来做自动化任务
  • 比如:自动格式化代码
Permissions(权限)

allow - 允许的工具和命令

  • Read - 读取文件
  • Grep - 搜索文件
  • LS - 列出文件
  • Bash(*) - 执行特定命令

deny - 禁止的工具和命令

  • 防止危险操作
  • 比如:删除文件、访问敏感数据

第五部分:实战案例 - 配置一个完整的项目

案例:Spring Boot + Vue 3 全栈项目

后端配置

创建 backend/CLAUDE.md:

markdown 复制代码 
# 后端服务

## 项目信息

基于 Spring Boot 3.2 的 RESTful API 服务。

## 技术栈

- Spring Boot 3.2, Java 17, Maven
- MySQL 8.0, Spring Data JPA
- Redis (缓存)
- JWT (认证)

## 目录结构

按照标准的分层架构:
- controller → service → repository → entity

## 开发规范

### API 设计

所有 API 以 `/api/v1` 开头:
- GET `/api/v1/users` - 获取用户列表
- POST `/api/v1/users` - 创建用户
- GET `/api/v1/users/{id}` - 获取单个用户
- PUT `/api/v1/users/{id}` - 更新用户
- DELETE `/api/v1/users/{id}` - 删除用户

### 统一响应格式

```json
{
  "code": 200,
  "message": "success",
  "data": { }
}
```

错误响应:

```json
{
  "code": 400,
  "message": "用户名已存在",
  "data": null
}
```

### 分页查询

使用 Spring Data 的 `Pageable`:

```java
Page<User> findAll(Pageable pageable)
```

### 日志

使用 `@Slf4j` 注解:

```java
@Slf4j
@RestController
public class UserController {
    public void someMethod() {
        log.info("执行某操作");
    }
}
```

## 测试

每个 Service 必须有单元测试,覆盖率至少 80%。

## 常用命令

```bash
mvn clean test
mvn spring-boot:run
mvn clean package
```
前端配置

创建 frontend/CLAUDE.md:

markdown 复制代码 
# 前端应用

## 项目信息

基于 Vue 3 + TypeScript + Vite 的单页应用。

## 技术栈

- Vue 3.4 + Composition API
- TypeScript 5
- Vite 5
- Pinia (状态管理)
- Vue Router 4
- Axios (HTTP 客户端)
- Element Plus (UI 组件库)

## 开发规范

### 组件规范

- 必须使用 `<script setup lang="ts">`
- Props 和 Emits 必须定义类型
- 使用 Composition API

### API 调用

所有 API 封装在 `src/api/` 目录:

```typescript
// api/user.ts
export const userApi = {
  getUsers: () => request.get('/api/v1/users'),
  // ...
}
```

### 路由配置

路由懒加载:

```typescript
{
  path: '/users',
  component: () => import('@/views/UserList.vue')
}
```

## 常用命令

```bash
npm run dev
npm run build
npm run lint
```

测试配置效果

测试1:创建后端 API

在 backend/ 目录下启动 Claude Code:

bash 复制代码 
cd backend
claude

执行命令:

复制代码 
创建一个 Product API,包含完整的 CRUD 操作

验证要点:

  • 是否遵循了目录结构
  • 是否使用了统一响应格式
  • 是否添加了 @Slf4j 注解
  • API 路径是否为 /api/v1/products
测试2:创建前端页面

在 frontend/ 目录下启动 Claude Code:

bash 复制代码 
cd frontend
claude

执行命令:

复制代码 
创建一个商品列表页面,包含搜索和分页功能

验证要点:

  • 是否使用了 <script setup lang="ts">
  • 是否定义了 TypeScript 接口
  • API 调用是否封装在 api/ 目录
  • 是否使用了 Element Plus 组件

第六部分:常见配置场景

场景1:禁止删除重要文件

在 .claude/settings.json 中:

json 复制代码 
{
  "permissions": {
    "deny": [
      "Edit(pom.xml)",
      "Edit(package.json)",
      "Bash(rm *)"
    ]
  }
}

场景2:自动格式化代码

json 复制代码 
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npm run format",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

场景3:提交前自动运行测试

json 复制代码 
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash(git commit *)",
        "hooks": [
          {
            "type": "command",
            "command": "mvn test",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

第七部分:最佳实践

1. 保持配置简洁

CLAUDE.md 应简洁明了,重点包含:

  • 项目概述
  • 技术栈
  • 开发规范
  • 常用命令

2. 使用具体示例

提供具体的代码示例说明规范:

markdown 复制代码 
推荐:
- GET /api/users - 获取用户列表
- POST /api/users - 创建用户

不推荐:
- /getUsers - 获取用户列表
- /addUser - 创建用户

3. 定期更新配置

项目规范变更时,及时更新 CLAUDE.md。

4. 团队共享配置

将 CLAUDE.md 和 .claude/ 目录提交到版本控制系统,确保团队使用统一规范。

小结

本课程学习内容:

  • CLAUDE.md 配置文件的作用和编写方法
  • settings.json 的高级配置选项
  • Hooks 和权限控制机制
  • 实战案例:配置全栈项目
  • 常见配置场景和最佳实践

第三章:Skills 和 MCP

什么是 Skills?

用生活中的例子理解 Skills

想象一下,你在一家餐厅工作:

没有 Skills 的情况(每次都要详细说明):

复制代码 
你:Claude,帮我做一份宫保鸡丁
Claude:好的,请告诉我:
  - 需要多少鸡肉?
  - 需要什么配菜?
  - 辣度如何?
  - 用什么调料?
  - 炒多久?
  - 装什么盘子?
你:(每次都要回答这些问题...)

有 Skills 的情况(一句话搞定):

复制代码 
你:Claude,用"宫保鸡丁"这个 Skill 做一份
Claude:好的!按照标准配方:
  ✅ 鸡肉 200g
  ✅ 花生米、干辣椒、葱姜蒜
  ✅ 中辣
  ✅ 标准调料配比
  ✅ 大火快炒 5 分钟
  ✅ 装入标准餐盘
  马上开始!

Skills 就是"标准化的菜谱",把重复的任务步骤固定下来,下次直接用!

Skills 在编程中的实际应用

场景1:创建 REST API

没有 Skill:

复制代码 
你:帮我创建一个 User 的 REST API
Claude:好的,请告诉我:
  - 需要哪些字段?
  - 需要哪些接口?
  - 用什么框架?
  - 用什么数据库?
  - 需要分页吗?
  - 需要搜索吗?
  - 需要测试吗?
  (你需要回答 10+ 个问题...)

有 Skill:

复制代码 
你:用 spring-rest-controller 这个 Skill 创建 User API
Claude:明白!按照标准模板:
  ✅ Spring Boot 3.2
  ✅ 完整 CRUD 操作
  ✅ 分页查询
  ✅ 参数校验
  ✅ 统一响应格式
  ✅ 单元测试
  开始生成代码...

节省时间:从 10 分钟 → 30 秒!

Skills 的三大好处

  1. 省时间 ⏱️

    • 不用每次都详细说明
    • 一句话就能完成复杂任务

  2. 保证质量 ✨

    • 代码风格统一
    • 不会遗漏重要步骤
    • 符合团队规范

  3. 可复用 🔄

    • 一次创建,永久使用
    • 团队共享
    • 持续优化

第一部分:Skills 系统简介

Skills 概述

Skills 是 Claude Code 的任务模板系统,用于将重复性任务标准化。通过创建 Skills,可以避免重复说明常见任务的执行步骤。

Skills 结构详解

Skills 本质上是一个文件夹,包含:

  • SKILL.md - 主要指令文件(必需)
  • references/ - 参考文档(可选)
  • scripts/ - 辅助脚本(可选)

文件夹结构示意图:

复制代码 
你的项目/
└── .claude/                    ← Claude Code 的配置文件夹
    └── skills/                 ← 所有 Skills 放这里
        ├── spring-rest-controller/    ← 第一个 Skill
        │   ├── SKILL.md              ← 主要指令(必需)
        │   ├── references/           ← 参考文档(可选)
        │   │   └── api-format.md
        │   └── scripts/              ← 辅助脚本(可选)
        │       └── validate.sh
        │
        ├── vue3-component/           ← 第二个 Skill
        │   └── SKILL.md
        │
        └── jpa-entity/               ← 第三个 Skill
            └── SKILL.md

每个文件的作用:

文件/文件夹 作用 是否必需 举例
SKILL.md 定义 Skill 的行为和步骤 ✅ 必需 告诉 Claude 如何生成代码
references/ 存放参考文档 ❌ 可选 API 规范、代码示例
scripts/ 存放辅助脚本 ❌ 可选 验证脚本、格式化工具

小白提示:

  • 刚开始只需要创建 SKILL.md 文件就够了
  • references/ 和 scripts/ 是高级功能,以后再学
  • 一个 Skill 就是一个文件夹,里面至少有一个 SKILL.md 文件

第二部分: 创建第一个 Skill

创建一个简单的 Skill

我们从最简单的开始,创建一个"Java 类生成器" Skill。

准备工作

你需要:

  1. 已经安装了 Claude Code(参考第一课)
  2. 有一个项目文件夹(任意文件夹都可以)
  3. 打开命令行工具(Windows 用 PowerShell 或 CMD)

预计时间: 10 分钟

第二部分:创建 Skill 示例

场景:Spring Boot REST Controller 生成器

创建一个 Skill,用于快速生成标准的 Spring Boot Controller。

步骤1:创建 Skills 目录结构
bash 复制代码 
# Linux/Mac
mkdir -p .claude/skills/spring-rest-controller
cd .claude/skills/spring-rest-controller
touch SKILL.md

# Windows (PowerShell)
New-Item -ItemType Directory -Path .claude\skills\spring-rest-controller -Force
cd .claude\skills\spring-rest-controller
New-Item -ItemType File -Path SKILL.md
步骤2:编写 SKILL.md
markdown 复制代码 
---
name: spring-rest-controller
description: 创建标准的 Spring Boot REST Controller,包含完整的 CRUD 操作。当用户需要创建新的 REST API 或 Controller 时使用。
author: 你的名字
date: 2026-01-13
---

# Spring Boot REST Controller 生成器

## 使用场景

当需要创建新的 REST API Controller 时,使用这个技能可以快速生成符合项目规范的代码。

## 生成步骤

### 1. 确认需求

首先,询问用户以下信息:
- 实体名称(如 User, Product, Order)
- 需要哪些操作(CRUD 全套,还是部分)
- 是否需要分页查询
- 是否需要搜索功能

### 2. 生成 Controller 类

创建 Controller 类,遵循以下规范:

```java
package com.company.项目名.controller;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
@RequestMapping("/api/v1/实体名复数小写")
@RequiredArgsConstructor
public class 实体名Controller {

    private final 实体名Service service;

    /**
     * 获取列表(分页)
     */
    @GetMapping
    public ResponseEntity<ApiResponse<Page<实体名>>> getAll(Pageable pageable) {
        log.info("获取实体列表,页码: {}, 每页数量: {}",
            pageable.getPageNumber(), pageable.getPageSize());

        Page<实体名> result = service.findAll(pageable);
        return ResponseEntity.ok(ApiResponse.success(result));
    }

    /**
     * 根据ID获取
     */
    @GetMapping("/{id}")
    public ResponseEntity<ApiResponse<实体名>> getById(@PathVariable Long id) {
        log.info("获取实体,ID: {}", id);

        实体名 result = service.findById(id);
        return ResponseEntity.ok(ApiResponse.success(result));
    }

    /**
     * 创建
     */
    @PostMapping
    public ResponseEntity<ApiResponse<实体名>> create(@RequestBody @Valid 实体名CreateDTO dto) {
        log.info("创建实体: {}", dto);

        实体名 result = service.create(dto);
        return ResponseEntity.ok(ApiResponse.success(result));
    }

    /**
     * 更新
     */
    @PutMapping("/{id}")
    public ResponseEntity<ApiResponse<实体名>> update(
            @PathVariable Long id,
            @RequestBody @Valid 实体名UpdateDTO dto) {
        log.info("更新实体,ID: {}, 数据: {}", id, dto);

        实体名 result = service.update(id, dto);
        return ResponseEntity.ok(ApiResponse.success(result));
    }

    /**
     * 删除
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<ApiResponse<Void>> delete(@PathVariable Long id) {
        log.info("删除实体,ID: {}", id);

        service.delete(id);
        return ResponseEntity.ok(ApiResponse.success(null));
    }
}
```

### 3. 注意事项

- **日志**:每个方法都要记录日志
- **异常处理**:由 `@RestControllerAdvice` 统一处理
- **参数校验**:使用 `@Valid` 注解
- **响应格式**:统一使用 `ApiResponse` 包装
- **命名规范**:
  - URL 用小写复数,如 `/api/v1/users`
  - 方法名用驼峰,如 `getAll`, `getById`

### 4. 生成对应的 DTO

为每个 Controller 创建对应的 DTO 类:

- `实体名CreateDTO` - 用于创建操作
- `实体名UpdateDTO` - 用于更新操作
- `实体名ResponseDTO` - 用于返回数据(可选)

### 5. 生成测试类

创建对应的测试类 `实体名ControllerTest.java`,使用 `@WebMvcTest` 测试 Controller 层。

## 示例对话

**用户**:创建一个 Product 的 REST API

**Claude**:
好的,我将为您创建 Product 的 REST Controller。请确认:
1. 需要完整的 CRUD 操作吗?(是)
2. 需要分页查询吗?(是)
3. 是否需要按名称搜索的功能?(需要的话我会添加)

**用户**:是的,全要

**Claude**:
明白了,我将创建:
1. ProductController.java - 包含完整 CRUD 和分页查询
2. ProductCreateDTO.java - 创建商品的 DTO
3. ProductUpdateDTO.java - 更新商品的 DTO
4. ProductControllerTest.java - 单元测试

开始创建...

## 检查清单

生成代码后,检查以下项目:
- [ ] Controller 类使用了 `@Slf4j` 注解
- [ ] 所有方法都有日志记录
- [ ] URL 路径遵循 RESTful 规范
- [ ] 使用了 `@Valid` 进行参数校验
- [ ] 响应使用 `ApiResponse` 统一包装
- [ ] 创建了对应的 DTO 类
- [ ] 创建了单元测试
步骤3:让 Claude Code 识别这个 Skill

Skills 会自动被识别!你不需要做任何额外配置。

步骤4:使用这个 Skill

启动 Claude Code:

bash 复制代码 
claude

然后说:

复制代码 
创建一个 Product 的 REST API

Claude Code 会:

  1. 识别到这个任务匹配 spring-rest-controller 这个 Skill
  2. 询问是否使用这个 Skill
  3. 按照 Skill 的步骤执行

你会看到提示:

复制代码 
我发现你有一个 Skill "spring-rest-controller" 可以用于这个任务。
是否使用这个 Skill?(yes/no)

输入 yes,系统将按照 Skill 的步骤执行。

第三部分:更多实用的 Skills

Skill 2:Vue 3 Component 生成器

创建 .claude/skills/vue3-component/SKILL.md:

markdown 复制代码 
---
name: vue3-component
description: 创建标准的 Vue 3 组件,使用 Composition API、TypeScript 和项目规范。当用户需要创建新的 Vue 组件时使用。
---

# Vue 3 Component 生成器

## 生成步骤

### 1. 确认组件信息

询问:
- 组件名称(如 UserCard, ProductList)
- 组件功能描述
- 是否需要 Props
- 是否需要 Emits
- 是否需要状态管理

### 2. 生成组件文件

创建 `.vue` 文件,结构如下:

```vue
<script setup lang="ts">
import { ref, computed, onMounted } from 'vue'

// Props 定义
interface Props {
  // 根据需求定义
}
const props = defineProps<Props>()

// Emits 定义
interface Emits {
  // 根据需求定义
}
const emit = defineEmits<Emits>()

// 响应式数据
const data = ref<any>(null)

// 计算属性
const computedValue = computed(() => {
  // 计算逻辑
})

// 方法
const handleClick = () => {
  // 逻辑
}

// 生命周期
onMounted(() => {
  // 初始化逻辑
})
</script>

<template>
  <div class="组件名-kebab-case">
    <!-- 模板内容 -->
  </div>
</template>

<style scoped>
.组件名-kebab-case {
  /* 样式 */
}
</style>
```

### 3. 注意事项

- 必须使用 `<script setup lang="ts">`
- Props 和 Emits 必须定义 TypeScript 接口
- 类名使用 kebab-case
- 所有数据都要明确类型

### 4. 生成测试文件

创建对应的 `.spec.ts` 测试文件。

Skill 3:Database Entity 生成器

创建 .claude/skills/jpa-entity/SKILL.md:

markdown 复制代码 
---
name: jpa-entity
description: 创建 JPA 实体类,包含常用注解和关联关系。当用户需要创建数据库实体时使用。
---

# JPA Entity 生成器

## 生成步骤

### 1. 确认实体信息

询问:
- 实体名称
- 表名(默认用实体名的下划线形式)
- 字段列表(名称、类型、是否必填、是否唯一)
- 是否需要审计字段(创建时间、更新时间)
- 关联关系(一对多、多对一、多对多)

### 2. 生成 Entity 类

```java
package com.company.项目名.entity;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.Builder;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import jakarta.persistence.*;
import java.time.LocalDateTime;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Entity
@Table(name = "表名")
@EntityListeners(AuditingEntityListener.class)
public class 实体名 {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 字段定义
    @Column(nullable = false, length = 100)
    private String name;

    // 审计字段
    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime updatedAt;
}
```

### 3. 生成 Repository

```java
package com.company.项目名.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface 实体名Repository extends JpaRepository<实体名, Long> {
    // 自定义查询方法
}
```

### 4. 注意事项

- 使用 Lombok 注解减少样板代码
- 必须添加审计字段(createdAt, updatedAt)
- 字符串字段指定长度
- Boolean 字段用 `is` 开头
- 金额字段使用 `BigDecimal`
- 时间字段使用 `LocalDateTime`

第四部分:Skills 的高级用法

1. 引用其他文件

在 Skill 目录下创建 references/ 文件夹,存放参考文档:

bash 复制代码 
.claude/skills/spring-rest-controller/
├── SKILL.md
└── references/
    ├── api-response-format.md
    ├── error-handling.md
    └── validation-rules.md
└── scripts/
    └── validate-api.sh

在 SKILL.md :

markdown 复制代码 
## 响应格式

详见 @references/api-response-format.md
复制代码 
# API 响应格式规范

## 成功响应

```json
{
  "code": 200,
  "message": "success",
  "data": {
    "id": 1,
    "name": "示例数据"
  },
  "timestamp": "2026-01-20T10:30:00Z"
}
```

## 错误响应

```json
{
  "code": 400,
  "message": "参数校验失败",
  "errors": [
    {
      "field": "email",
      "message": "邮箱格式不正确"
    }
  ],
  "timestamp": "2026-01-20T10:30:00Z"
}
```

## 状态码说明

- 200: 成功
- 400: 请求参数错误
- 401: 未认证
- 403: 无权限
- 404: 资源不存在
- 500: 服务器内部错误

## Java 实现示例

```java
@Data
@AllArgsConstructor
public class ApiResponse<T> {
    private Integer code;
    private String message;
    private T data;
    private String timestamp;
    
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "success", data, 
            LocalDateTime.now().toString());
    }
    
    public static <T> ApiResponse<T> error(Integer code, String message) {
        return new ApiResponse<>(code, message, null, 
            LocalDateTime.now().toString());
    }
}
```

2. 可执行脚本

在 Skill 目录下创建 scripts/ 文件夹:

bash 复制代码 
.claude/skills/spring-rest-controller/
├── SKILL.md

在 SKILL.md 中使用:

markdown 复制代码 
## 生成后验证

运行验证脚本:
```bash
./scripts/validate-api.sh
```
复制代码 
#!/bin/bash

echo "🔍 验证 API 代码..."

# 检查 Controller 是否有 @Slf4j 注解
echo "检查日志注解..."
if ! grep -r "@Slf4j" src/main/java/*/controller/*.java 2>/dev/null; then
    echo "❌ Controller 缺少 @Slf4j 注解"
    exit 1
fi

# 检查是否使用了 @Valid 注解
echo "检查参数校验..."
if ! grep -r "@Valid" src/main/java/*/controller/*.java 2>/dev/null; then
    echo "⚠️  警告: Controller 可能缺少参数校验"
fi

# 检查 URL 路径是否符合规范
echo "检查 URL 规范..."
if grep -r "@RequestMapping.*[A-Z]" src/main/java/*/controller/*.java 2>/dev/null; then
    echo "❌ URL 路径包含大写字母，不符合规范"
    exit 1
fi

# 检查是否有对应的测试文件
echo "检查测试文件..."
for controller in src/main/java/*/controller/*Controller.java 2>/dev/null; do
    if [ -f "$controller" ]; then
        test_file="${controller/main/test}"
        test_file="${test_file/.java/Test.java}"
        if [ ! -f "$test_file" ]; then
            echo "❌ 缺少测试文件: $test_file"
            exit 1
        fi
    fi
done

echo "✅ 所有检查通过!"

第五部分:MCP - 连接外部世界

什么是 MCP?

用最简单的话解释 MCP

MCP = 给 Claude 装上"插件"

想象一下:

  • Claude 本身 = 一个很聪明的助手,但只能在你的项目文件夹里工作
  • MCP = 给这个助手装上各种"工具",让它能做更多事情

生活中的例子:

就像你的手机:

  • 手机本身:可以打电话、发短信
  • 安装微信:可以聊天、发朋友圈
  • 安装支付宝:可以付款、转账
  • 安装地图:可以导航、查路线

MCP 就是给 Claude 安装"应用",让它能:

  • 连接 GitHub(就像安装 GitHub 客户端)
  • 连接数据库(就像安装数据库管理工具)
  • 连接 Slack(就像安装 Slack 客户端)
没有 MCP vs 有 MCP

场景:你想让 Claude 在 GitHub 上创建一个 Issue

没有 MCP(传统方式)
复制代码 
你:帮我在 GitHub 上创建一个 Issue
Claude:好的,我可以告诉你步骤:
  1. 打开浏览器
  2. 访问 GitHub 仓库
  3. 点击 Issues 标签
  4. 点击 New Issue
  5. 填写标题和描述
  6. 点击 Submit
你:(自己手动操作,花费 2 分钟)
有 MCP(高效方式)
复制代码 
你:在 GitHub 上创建一个 Issue,标题是"修复登录 Bug"
Claude:✅ 已创建!Issue #123
  标题:修复登录 Bug
  链接:https://github.com/your-repo/issues/123
你:(30 秒搞定!)

效率对比:

  • 传统方式:2 分钟手动操作
  • 使用 MCP:30 秒自动完成
  • 节省时间:75%!
MCP 的三大好处

  1. 自动化操作

    • Claude 可以直接操作外部服务
    • 不需要你手动复制粘贴
    • 一句话完成复杂任务

  2. 实时数据

    • 可以查询数据库
    • 可以获取最新的 API 数据
    • 可以读取外部文件

  3. 无缝集成

    • 连接你常用的工具
    • 在一个地方完成所有工作
    • 提升工作效率
常用的 MCP Servers
MCP Server 作用 使用场景
GitHub 操作 GitHub 创建 Issue、PR,查看代码
PostgreSQL 查询数据库 根据表结构生成代码
Filesystem 操作文件 搜索文件、批量处理
Slack 发送消息 通知团队、自动回复
提示
  • MCP 是可选的:不安装也能用 Claude Code
  • 按需安装:只安装你需要的 MCP Server
  • 先学 Skills:建议先掌握 Skills,再学 MCP
  • 安全第一:配置 MCP 时注意保护敏感信息

MCP 概述

Model Context Protocol(模型上下文协议)是一个开放标准,使 AI 能够连接外部工具和服务。

MCP 可以让 Claude Code 实现以下功能:

  • 访问数据库
  • 调用 API
  • 读写文件系统
  • 连接 GitHub
  • 访问 Slack
  • 等等...

MCP 的应用场景

  1. 连接 GitHub - 自动创建 Issue、PR、查看代码
  2. 连接数据库 - 直接查询数据库生成代码
  3. 连接 Figma - 从设计稿生成前端代码
  4. 连接 Sentry - 自动修复线上 Bug
  5. 连接内部 API - 访问公司内部服务

第六部分:安装和配置 MCP Servers

配置你的第一个 MCP Server

准备工作清单

在开始之前,请确认:

  • 已安装 Claude Code
  • 已安装 Node.js(版本 14 或更高)
  • 有一个 GitHub 账号(用于测试 GitHub MCP)
  • 知道如何打开命令行工具

预计完成时间: 20-30 分钟

难度等级: ⭐⭐⭐ 中等偏难

实战案例:配置 GitHub MCP Server

我们将配置 GitHub MCP Server,让 Claude 能够直接操作 GitHub。

步骤1:获取 GitHub Personal Access Token

目标: 获取访问 GitHub 的密钥

操作步骤:

  1. 登录 GitHub

  2. 进入设置页面

    • 点击右上角头像
    • 选择 "Settings"(设置)

  3. 创建 Token

    • 在左侧菜单找到 "Developer settings"(开发者设置)
    • 点击 "Personal access tokens"
    • 选择 "Tokens (classic)"
    • 点击 "Generate new token" → "Generate new token (classic)"

  4. 配置 Token 权限

    • Note(备注):填写 "Claude Code MCP"
    • Expiration(过期时间):选择 "90 days"(90天)
    • 勾选以下权限:
      • ✅ repo (完整的仓库访问权限)
      • ✅ workflow (工作流权限)
      • ✅ write:discussion (讨论写入权限)

  5. 生成并保存 Token

    • 点击页面底部的 "Generate token"
    • 重要! 复制生成的 token(以 ghp_ 开头)
    • 保存到安全的地方(只显示一次!)

验证步骤:

你应该得到一个类似这样的 token:

复制代码 
ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

常见问题:

❌ 问题: 找不到 "Developer settings"

✅ 解决: 确保你在个人设置页面,不是仓库设置页面

❌ 问题: Token 生成后忘记复制

✅ 解决: 删除旧 token,重新生成一个

步骤2:配置环境变量

目标: 让 Claude Code 能够使用这个 Token

操作步骤:

Windows 用户(PowerShell)

  1. 打开 PowerShell(以管理员身份)

  2. 设置环境变量

    powershell 复制代码 
    # 临时设置(当前会话有效)
$env:GITHUB_PERSONAL_ACCESS_TOKEN = "ghp_你的token"

# 永久设置(推荐)
[System.Environment]::SetEnvironmentVariable('GITHUB_PERSONAL_ACCESS_TOKEN', 'ghp_你的token', 'User')

  3. 验证设置

    powershell 复制代码 
    # 查看环境变量
$env:GITHUB_PERSONAL_ACCESS_TOKEN

    应该显示你的 token

Linux/Mac 用户

  1. 打开 Terminal

  2. 编辑配置文件

    bash 复制代码 
    # 如果使用 bash
nano ~/.bashrc

# 如果使用 zsh
nano ~/.zshrc

  3. 添加环境变量

    在文件末尾添加:

    bash 复制代码 
    export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_你的token"

  4. 保存并重新加载

    bash 复制代码 
    # bash 用户
source ~/.bashrc

# zsh 用户
source ~/.zshrc

  5. 验证设置

    bash 复制代码 
    echo $GITHUB_PERSONAL_ACCESS_TOKEN

    应该显示你的 token

安全提示:

  • ⚠️ 不要把 token 提交到 Git 仓库
  • ⚠️ 不要在公开的地方分享 token
  • ⚠️ 定期更换 token
步骤3:配置 MCP Server

目标: 告诉 Claude Code 使用 GitHub MCP

操作步骤:

  1. 找到 Claude Code 配置目录

    Windows:

    复制代码 
    cd 你的项目

    Linux/Mac:

    复制代码 
    ~/.claude/

  2. 创建或编辑 MCP 配置文件

    在配置目录中创建 .mcp.json 文件:

    json 复制代码 
    {
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}"
      }
    }
  }
}

  3. 保存文件

文件说明:

  • "github": MCP Server 的名称
  • "command": "npx": 使用 npx 运行
  • "args": 指定要运行的 MCP Server 包
  • "env": 环境变量配置

小白提示:

  • 这个配置文件告诉 Claude Code:"当需要操作 GitHub 时,运行 GitHub MCP Server"
  • ${GITHUB_PERSONAL_ACCESS_TOKEN} 会自动替换为你设置的环境变量
步骤4:测试 MCP Server

目标: 验证 GitHub MCP 是否正常工作

操作步骤:

  1. 重启 Claude Code

    bash 复制代码 
    # 如果 Claude Code 正在运行,先退出
/exit

# 重新启动
claude

  2. 检查 MCP Server 状态

    bash 复制代码 
    /mcp

    你应该看到:

    复制代码 
    Available MCP Servers:
- github (connected)

  3. 测试 GitHub 操作

    在 Claude Code 中输入:

    复制代码 
    列出我的 GitHub 仓库

    Claude 应该能够:

    • 连接到 GitHub
    • 获取你的仓库列表
    • 显示仓库信息

预期结果:

复制代码 
你的 GitHub 仓库:
1. username/repo1 - 描述...
2. username/repo2 - 描述...
3. username/repo3 - 描述...

验证成功的标志:

  • ✅ /mcp 显示 github 已连接
  • ✅ Claude 能够获取你的仓库信息
  • ✅ 没有报错信息
步骤5:实际应用

现在你可以让 Claude 做这些事情:

  1. 创建 Issue

    复制代码 
    在 my-repo 仓库创建一个 Issue:
标题:添加用户登录功能
描述:需要实现用户登录和注册功能

  2. 查看 Issue

    复制代码 
    列出 my-repo 仓库的所有 open issues

  3. 创建 Pull Request

    复制代码 
    为 my-repo 仓库创建一个 PR:
从 feature-branch 合并到 main
标题:添加新功能

  4. 查看代码

    复制代码 
    显示 my-repo 仓库的 README.md 文件内容

常见问题排查

Q1: /mcp 显示 github 未连接

可能原因:

  1. 环境变量未设置

    bash 复制代码 
    # 检查环境变量
# Windows
$env:GITHUB_PERSONAL_ACCESS_TOKEN

# Linux/Mac
echo $GITHUB_PERSONAL_ACCESS_TOKEN

  2. 配置文件路径错误

    • 确保 mcp_settings.json 在正确的位置
    • Windows: C:\Users\你的用户名\.claude\mcp_settings.json
    • Linux/Mac: ~/.claude/mcp_settings.json

  3. Node.js 未安装或版本过低

    bash 复制代码 
    node --version
# 需要 14 或更高版本
Q2: Claude 说"无法连接到 GitHub"

可能原因:

  1. Token 无效或过期

    • 检查 token 是否正确
    • 检查 token 是否过期
    • 重新生成 token

  2. Token 权限不足

    • 确保勾选了 repo 权限
    • 重新生成 token 并勾选所有必需权限

  3. 网络问题

    • 检查网络连接
    • 检查是否能访问 GitHub
Q3: 配置文件格式错误

症状: Claude Code 启动时报错

解决方案:

  1. 检查 JSON 格式

    • 使用在线 JSON 验证工具
    • 确保所有引号、逗号、括号都正确

  2. 使用正确的模板

    json 复制代码 
    {
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}"
      }
    }
  }
}

查看可用的 MCP Servers

在 Claude Code 中:

bash 复制代码 
/mcp

会列出已安装的 MCP Servers。

安装常用的 MCP Servers

重要提示: MCP 服务器的安装和配置方式可能因 Claude Code 版本而异。以下命令仅供参考,请以官方文档为准。建议访问 https://modelcontextprotocol.io 和 Claude Code 官方文档获取最新的安装方法。

1. GitHub MCP Server

让 Claude Code 可以操作 GitHub。

MCP 服务器通常通过配置文件添加,而不是命令行。你可能需要:

  1. 在用户配置目录创建 MCP 配置文件
  2. 或使用 Claude Code 的配置界面添加

配置示例:

bash 复制代码 
export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_你的token"

使用:

复制代码 
在 GitHub 上创建一个新的 Issue,标题是"修复登录 Bug",描述详细说明问题

Claude Code 会直接调用 GitHub API 创建 Issue。

2. PostgreSQL MCP Server

让 Claude Code 可以查询数据库。

参考 MCP 官方文档配置 PostgreSQL 服务器。

环境变量配置:

bash 复制代码 
export POSTGRES_URL="postgresql://user:password@localhost:5432/dbname"

使用:

复制代码 
查询数据库中有多少用户,然后根据用户表结构生成对应的 JPA Entity
3. File System MCP Server

让 Claude Code 可以更强大地操作文件。

参考 MCP 官方文档配置文件系统服务器。

使用:

复制代码 
搜索项目中所有包含 "TODO" 注释的文件,列出来

MCP 配置文件

MCP 的配置可以写在项目的 .mcp.json 文件中:

json 复制代码 
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_URL": "${DATABASE_URL}"
      }
    }
  }
}

把这个文件提交到仓库,团队成员就能共享配置。

小结

本课程学习内容:

  • Skills 系统的原理和创建方法
  • 实用的 Skills 示例
  • Skills 的高级用法
  • MCP 的概念和作用
  • 常用 MCP Servers 的安装和配置
  • 最佳实践

Skills 和 MCP 能够显著提升开发效率和代码质量。

第四课:高级提示词与 Sub-Agents

第一部分:提示词优化技巧

提示词的重要性

与 AI 交互的方式直接影响输出质量。

对比示例:

不推荐的提示词:

复制代码 
帮我写个用户管理

此提示过于模糊,AI 无法准确理解需求。

推荐的提示词:

复制代码 
创建一个用户管理模块,具体要求:

1. 技术栈:Spring Boot 3.2 + MySQL + JPA
2. 功能:CRUD + 搜索 + 分页
3. 包含:
   - User 实体(id, username, email, password, createdAt, updatedAt)
   - UserRepository(继承 JpaRepository,添加 findByEmail 方法)
   - UserService(实现 CRUD 和 findByEmail)
   - UserController(提供 REST API)
   - UserDTO(CreateDTO、UpdateDTO、ResponseDTO)
4. 规范:
   - 使用 Lombok
   - 密码用 BCrypt 加密
   - 使用 @Slf4j 记录日志
   - 统一异常处理
5. 测试:
   - UserServiceTest(单元测试)
   - UserControllerTest(集成测试)

第二个提示词提供了清晰的需求和约束条件。

提示词编写原则

1. 明确性(Be Specific)

不推荐:"优化一下这个方法"

推荐:

复制代码 
优化 UserService.findAll() 方法:
1. 添加分页功能
2. 添加按用户名搜索的功能
3. 使用 Specification 构建动态查询
4. 保持向后兼容
2. 结构化(Be Structured)

使用编号、分段、层次结构:

复制代码 
任务:创建商品管理 API

## 第一步:实体设计
- Product 实体包含:id, name, price, description, stock
- 使用 JPA 注解
- 添加审计字段

## 第二步:Repository
- 继承 JpaRepository
- 添加 findByNameContaining 方法

## 第三步:Service
- 实现 CRUD
- 添加库存检查
- 添加事务管理

## 第四步:Controller
- REST API 遵循 RESTful 规范
- 使用 DTO 传输数据
- 添加参数校验
3. 示例驱动(Show Examples)

给出具体例子:

复制代码 
创建一个工具类 StringUtils,包含以下方法:

1. isEmpty() - 检查字符串是否为空
   示例:isEmpty(null) -> true
        isEmpty("") -> true
        isEmpty(" ") -> false

2. isBlank() - 检查字符串是否为空白
   示例:isBlank(null) -> true
        isBlank("") -> true
        isBlank(" ") -> true
        isBlank("a") -> false

3. capitalize() - 首字母大写
   示例:capitalize("hello") -> "Hello"
        capitalize("HELLO") -> "Hello"
4. 约束条件(Define Constraints)

明确什么能做、什么不能做:

复制代码 
重构 UserService,要求:

推荐 必须做:
- 保持现有 API 签名不变
- 使用依赖注入
- 添加事务注解
- 记录日志

不推荐 不要做:
- 不要改变数据库表结构
- 不要删除现有方法
- 不要使用过时的 API
- 不要使用硬编码的配置
5. 上下文提供(Provide Context)

让 AI 知道项目背景:

复制代码 
我们的项目是一个电商系统,现在要实现订单模块。

背景:
- 已有 User、Product 模块
- 使用 Spring Boot 3.2
- 数据库是 MySQL 8.0
- 前端是 Vue 3

当前任务:
创建 Order 模块,需要关联 User 和 Product

第二部分:提示词进阶技巧

技巧1:分步执行

对于复杂任务,分成多个步骤:

复制代码 
第一步:先不要写代码,帮我分析一下实现支付功能需要哪些组件和步骤。

等 AI 给出分析后...

第二步:好的,现在按照这个计划创建 Payment 实体和 Repository。

完成后...

第三步:创建 PaymentService,实现支付和退款逻辑。

为什么要这样?

  • 避免 AI 一口气生成一大堆代码,出错了不好改
  • 可以在每一步检查和调整
  • AI 的上下文更聚焦

技巧2:让 AI 先计划再执行

复制代码 
帮我重构 OrderService,让代码更清晰易维护。

在开始之前,请先:
1. 分析当前代码的问题
2. 提出重构方案
3. 列出重构步骤
4. 说明每一步的原因

确认后再开始重构。

技巧3:使用 "Think" 关键词

Claude Code 支持特殊的关键词,让 AI 花更多时间思考:

bash 复制代码 
# 轻度思考
Think. 分析一下这段代码有什么性能问题

# 中度思考  
Think harder. 设计一个高并发场景下的缓存方案

# 深度思考
Ultrathink. 重新设计整个系统的架构,考虑可扩展性和容错性

提示:思考级别越高,消耗的 tokens 越多,但结果通常更好。

技巧4:角色扮演

让 AI 扮演特定角色:

复制代码 
你现在是一个资深的 Java 架构师,有 10 年的 Spring Boot 经验。

请帮我 review 这段代码,从以下角度分析:
1. 代码质量
2. 性能问题
3. 安全隐患
4. 可维护性
5. 最佳实践

给出具体的改进建议和重构代码。

技巧5:错误修复模式

当代码有 bug 时:

复制代码 
运行测试时出现了以下错误:

java.lang.NullPointerException: Cannot invoke "User.getName()" because "user" is null

at UserService.updateUser(UserService.java:45)

复制代码 
请:
1. 分析错误原因
2. 找到问题代码
3. 提出 2-3 种修复方案
4. 说明每种方案的优缺点
5. 推荐最佳方案并实施

技巧6:测试驱动

让 AI 先写测试:

复制代码 
我要实现一个 CalculatorService,包含加减乘除功能。

请先帮我写单元测试,覆盖以下场景:
1. 正常计算
2. 除以零的异常情况
3. 超大数字的处理
4. 负数的处理
5. 边界值测试

然后根据测试来实现 CalculatorService。

第三部分:Java 开发的实战提示词模板

模板1:创建 REST API

复制代码 
创建一个 [实体名] 的 REST API,要求:

## 技术栈
- Spring Boot 3.2
- Spring Data JPA
- MySQL 8.0
- Lombok

## 实体设计
[实体名] 包含字段:
- id: Long, 主键,自增
- name: String, 非空,最大100字符
- [其他字段...]
- createdAt: LocalDateTime, 创建时间
- updatedAt: LocalDateTime, 更新时间

## 功能要求
1. CRUD 操作
2. 分页查询(使用 Pageable)
3. 按 name 搜索(模糊查询)
4. 参数校验(使用 @Valid)
5. 统一异常处理

## 代码结构
- entity/[实体名].java
- repository/[实体名]Repository.java
- service/[实体名]Service.java
- service/impl/[实体名]ServiceImpl.java
- controller/[实体名]Controller.java
- dto/[实体名]CreateDTO.java
- dto/[实体名]UpdateDTO.java
- dto/[实体名]ResponseDTO.java

## 规范
- 使用 @Slf4j 记录日志
- Controller 的 URL 以 /api/v1/[实体名复数小写] 开头
- 所有响应使用 ApiResponse<T> 包装
- 异常由 GlobalExceptionHandler 处理

## 测试
- [实体名]ServiceTest - 单元测试
- [实体名]ControllerTest - 集成测试

请按顺序创建这些文件。

模板2:代码重构

复制代码 
重构 [类名],目标是提高代码质量和可维护性。

## 当前问题
1. [问题1]
2. [问题2]
3. [问题3]

## 重构目标
1. 提取重复代码
2. 简化复杂方法
3. 改进命名
4. 添加必要的注释
5. 优化性能

## 重构原则
- 不改变对外的 API
- 保持测试通过
- 遵循 SOLID 原则
- 遵循项目编码规范

## 步骤
1. 先分析当前代码结构
2. 提出重构方案
3. 确认后开始重构
4. 重构后运行测试
5. 提供重构前后的对比

模板3:性能优化

复制代码 
优化 [类名/方法名] 的性能,分析并解决性能瓶颈。

## 性能问题描述
[描述当前的性能问题]

## 分析要求
1. 识别性能瓶颈(数据库查询、循环、算法等)
2. 测量当前性能(如果可能)
3. 提出优化方案

## 优化方向
- 数据库查询优化(索引、批量操作、N+1 问题)
- 缓存策略(本地缓存、Redis)
- 算法优化(降低时间复杂度)
- 并发处理(CompletableFuture、线程池)

## 验证
优化后要:
1. 保持功能不变
2. 测试通过
3. 性能有明显提升

第四部分:Vue 3 开发的实战提示词模板

模板1:创建组件

复制代码 
创建一个 Vue 3 组件:[组件名]

## 功能描述
[描述组件的功能]

## 技术要求
- 使用 <script setup lang="ts">
- 使用 Composition API
- TypeScript 类型安全
- 响应式设计

## Props 定义
定义组件的 Props 接口:
interface Props {
  // 定义 props
}

## Emits 定义
定义组件的 Emits 接口:
interface Emits {
  // 定义 emits
}

## 状态管理
- 需要哪些响应式数据
- 需要哪些计算属性

## 交互逻辑
- 需要哪些方法
- 需要哪些生命周期钩子

## 样式要求
- 使用 Tailwind CSS
- 支持暗色模式

## 测试
创建对应的测试文件,覆盖主要交互。

模板2:状态管理

复制代码 
创建一个 Pinia Store:[Store名]

## 功能
[描述这个 Store 管理什么状态]

## State
定义状态接口:
interface State {
  // 定义状态
}

## Getters
- [getter1]: [功能描述]
- [getter2]: [功能描述]

## Actions
- [action1]: [功能描述]
- [action2]: [功能描述]

## API 集成
需要调用的 API:
- [API1]
- [API2]

## 持久化
- 是否需要持久化到 localStorage
- 需要持久化哪些字段

第五部分:Sub-Agents(子代理)

重要提示: Sub-Agents 功能和具体实现方式可能因 Claude Code 版本而异。以下内容为概念性介绍和可能的使用方式,实际功能请以官方文档为准。

Sub-Agents 是什么?

Sub-Agent 就是一个专门的 AI 助手,只负责特定类型的任务。

就像公司里不同部门的人:

  • 前端开发 Agent - 只负责 Vue 组件
  • 后端开发 Agent - 只负责 Spring Boot API
  • 测试 Agent - 只负责写测试
  • Code Review Agent - 只负责代码审查

为什么需要 Sub-Agents?

  1. 专业化 - 每个 Agent 专注于自己的领域,做得更好
  2. 并行处理 - 多个 Agent 可以同时工作
  3. 上下文隔离 - 每个 Agent 有自己的上下文,不会互相干扰

第六部分:创建自己的 Sub-Agents

创建 Agent 配置文件

在项目根目录创建 .claude/agents/ 文件夹:

bash 复制代码 
mkdir -p .claude/agents

Agent 1:后端开发 Agent

创建 .claude/agents/backend-developer.md:

markdown 复制代码 
---
name: backend-developer
description: 专门负责 Spring Boot 后端开发,精通 Java、Spring Framework、JPA、MySQL。
skills: spring-rest-controller, jpa-entity
---

# 后端开发专家

你是一个资深的 Java 后端开发工程师,专注于 Spring Boot 应用开发。

## 专长领域
- Spring Boot 3.x 应用开发
- RESTful API 设计
- Spring Data JPA
- MySQL 数据库设计
- 微服务架构

## 工作方式

### 创建新功能
1. 先理解业务需求
2. 设计数据模型(实体)
3. 创建 Repository
4. 实现 Service 层(业务逻辑)
5. 创建 Controller(API 接口)
6. 编写单元测试
7. 编写集成测试

### 代码规范
- 使用 Lombok 减少样板代码
- 使用 @Slf4j 记录日志
- Service 接口和实现分离
- Controller 只处理 HTTP,不写业务逻辑
- 使用 DTO 而非直接暴露 Entity
- 统一异常处理
- 统一响应格式

### 性能考虑
- 避免 N+1 查询问题
- 合理使用索引
- 大数据量使用分页
- 适当使用缓存

### 安全性
- 参数校验
- SQL 注入防护
- XSS 攻击防护
- 敏感数据加密

## 不要做的事
- 不要在 Controller 中写业务逻辑
- 不要忽略异常处理
- 不要返回过多的数据
- 不要使用 SELECT *

Agent 2:前端开发 Agent

创建 .claude/agents/frontend-developer.md:

markdown 复制代码 
---
name: frontend-developer
description: 专门负责 Vue 3 前端开发,精通 TypeScript、Composition API、Pinia、Tailwind CSS。
skills: vue3-component
---

# 前端开发专家

你是一个资深的 Vue 3 前端开发工程师。

## 专长领域
- Vue 3 Composition API
- TypeScript
- Pinia 状态管理
- Vue Router
- Tailwind CSS
- 响应式设计

## 工作方式

### 创建组件
1. 分析组件功能和交互
2. 定义 Props 和 Emits 接口
3. 设计状态结构
4. 实现业务逻辑
5. 编写模板
6. 添加样式
7. 编写单元测试

### 代码规范
- 必须使用 <script setup lang="ts">
- Props 和 Emits 必须定义类型
- 优先使用 Composition API
- 组件文件用 PascalCase
- 使用 defineModel 处理 v-model
- 使用 Tailwind CSS 类名

### 性能优化
- 大列表使用虚拟滚动
- 合理使用 computed 和 watch
- 避免不必要的重新渲染
- 图片懒加载
- 路由懒加载

### 用户体验
- 加载状态提示
- 错误提示友好
- 表单验证及时
- 响应式布局
- 无障碍访问(a11y)

## 不要做的事
- 不要使用 Options API
- 不要在模板中写复杂逻辑
- 不要直接修改 props
- 不要在 computed 中有副作用

Agent 3:测试 Agent

创建 .claude/agents/tester.md:

markdown 复制代码 
---
name: tester
description: 专门负责编写测试代码,精通 JUnit、Mockito、Vitest、@vue/test-utils。
---

# 测试专家

你是一个专业的测试工程师,精通自动化测试。

## 专长领域
- 单元测试
- 集成测试
- 端到端测试
- 测试覆盖率分析

## Java 后端测试

### 单元测试(JUnit 5 + Mockito)
- 测试 Service 层业务逻辑
- Mock 所有外部依赖
- 覆盖正常流程和异常流程
- 边界值测试

### 集成测试
- 使用 @SpringBootTest
- 测试 Controller 层
- 测试数据库交互
- 使用 H2 内存数据库

### 测试规范
- 测试类名以 Test 结尾
- 测试方法命名:should_期望结果_when_条件
- 使用 @DisplayName 描述测试
- 每个测试独立运行
- 测试数据使用 Builder 模式

## Vue 前端测试

### 组件测试(Vitest + @vue/test-utils)
- 测试组件渲染
- 测试用户交互
- 测试 Props 和 Emits
- 测试异步行为

### 测试规范
- 测试文件以 .spec.ts 结尾
- 测试用户行为而非实现细节
- 使用 findBy* 查询元素
- Mock API 调用
- 避免测试内部状态

## 测试覆盖率
- 单元测试覆盖率至少 80%
- 关键业务逻辑 100% 覆盖
- 异常分支要覆盖

Agent 4:Code Review Agent

创建 .claude/agents/code-reviewer.md:

markdown 复制代码 
---
name: code-reviewer
description: 专门负责代码审查,检查代码质量、性能、安全性。
---

# 代码审查专家

你是一个严格的代码审查员,负责保证代码质量。

## 审查维度

### 1. 代码质量
- 命名是否清晰
- 逻辑是否简洁
- 是否有重复代码
- 是否符合 SOLID 原则

### 2. 性能
- 是否有性能瓶颈
- 数据库查询是否优化
- 是否有不必要的循环
- 算法复杂度是否合理

### 3. 安全性
- 是否有 SQL 注入风险
- 是否有 XSS 风险
- 敏感数据是否加密
- 权限检查是否完整

### 4. 可维护性
- 代码是否易读
- 是否有足够的注释
- 是否有单元测试
- 是否符合项目规范

### 5. 最佳实践
- 是否遵循 Spring Boot 最佳实践
- 是否遵循 Vue 3 最佳实践
- 是否使用了合适的设计模式

## 审查流程
1. 整体浏览代码结构
2. 逐个方法详细检查
3. 列出问题清单
4. 按严重程度分类(严重、一般、建议)
5. 提供具体的改进建议
6. 如果需要,提供修改后的代码

## 反馈格式

### 严重问题 🔴
- [问题描述]
- 影响:[说明影响]
- 建议:[修改建议]

### 一般问题 🟡
- [问题描述]
- 建议:[修改建议]

### 优化建议 🟢
- [建议内容]

第七部分:使用 Sub-Agents

注意: 以下命令和用法需要根据实际的 Claude Code 版本进行验证。

启动特定的 Agent(如果支持)

bash 复制代码 
# 以下命令仅为示例,实际用法请参考官方文档
claude --agent backend-developer

或者在对话中切换(如果支持):

复制代码 
# 以下命令仅为示例
/agent backend-developer

让多个 Agents 协作

场景:创建一个完整的功能模块

bash 复制代码 
# 启动 Claude Code
claude

# 步骤1:让后端 Agent 创建 API
使用 backend-developer agent 创建 Product 模块的完整后端代码
/
# 步骤2:让前端 Agent 创建页面
使用 frontend-developer agent 创建 Product 管理页面

# 步骤3:让测试 Agent 添加测试
使用 tester agent 为 Product 模块添加完整的测试

# 步骤4:让 Review Agent 检查
使用 code-reviewer agent 审查刚才创建的所有代码

并行运行多个 Agents

如果你安装了 Claude Code 的 VSCode 扩展,可以同时开多个终端,运行不同的 Agents:

bash 复制代码 
# Terminal 1
claude --agent backend-developer

# Terminal 2
claude --agent frontend-developer

# Terminal 3  
claude --agent tester

它们各自独立工作,互不干扰。

第八部分:实战案例 - 完整的开发流程

案例:开发一个订单管理模块

第一阶段:需求分析
复制代码 
我要开发一个订单管理模块,功能包括:
- 创建订单
- 查询订单列表(分页)
- 查询订单详情
- 更新订单状态
- 取消订单

技术栈:
- 后端:Spring Boot 3.2 + MySQL
- 前端:Vue 3 + TypeScript

请先分析需要哪些组件,给出实现方案。
第二阶段:后端开发
复制代码 
/agent backend-developer

创建 Order 模块的后端代码:

1. Order 实体:
   - id, orderNo, userId, totalAmount, status, createdAt, updatedAt
   - status 枚举:PENDING, PAID, SHIPPED, COMPLETED, CANCELLED

2. OrderItem 实体(订单明细):
   - id, orderId, productId, quantity, price

3. 完整的 Repository、Service、Controller

4. 状态流转逻辑:
   - PENDING -> PAID -> SHIPPED -> COMPLETED
   - 任何状态都可以 -> CANCELLED

5. 业务规则:
   - 创建订单时自动生成订单号
   - 只有 PENDING 状态可以修改
   - 取消订单要检查状态
第三阶段:前端开发
复制代码 
/agent frontend-developer

创建订单管理前端页面:

1. OrderList.vue - 订单列表页
   - 表格展示订单
   - 分页
   - 按状态筛选
   - 搜索订单号

2. OrderDetail.vue - 订单详情页
   - 显示订单信息
   - 显示订单明细
   - 显示状态流转按钮

3. Pinia Store:
   - 管理订单列表
   - 管理当前订单
   - API 调用封装
第四阶段:测试
复制代码 
/agent tester

为 Order 模块添加测试:

1. 后端测试:
   - OrderServiceTest - 测试所有业务逻辑
   - OrderControllerTest - 测试所有 API

2. 前端测试:
   - OrderList.spec.ts - 测试列表页交互
   - OrderDetail.spec.ts - 测试详情页交互
第五阶段:代码审查
复制代码 
/agent code-reviewer

审查 Order 模块的所有代码,检查:
- 代码质量
- 性能问题
- 安全隐患
- 最佳实践

给出详细的审查报告。

第九部分:提示词和 Agents 的最佳实践

提示词最佳实践

  1. 从简单到复杂

    • 先让 AI 理解任务
    • 再添加细节要求
    • 最后加上约束条件

  2. 使用模板

    • 把常用的提示词保存成模板
    • 根据具体情况调整
    • 积累自己的提示词库

  3. 迭代优化

    • 第一次结果不满意?调整提示词再试
    • 记录哪些提示词效果好
    • 不断优化自己的提示词

  4. 充分利用项目上下文

    • 让 AI 参考已有代码
    • 引用 CLAUDE.md 里的规范
    • 使用 Skills 和 MCP

Agents 最佳实践

  1. 专业化

    • 每个 Agent 只负责一个领域
    • 不要创建"全能" Agent

  2. 清晰的职责

    • Agent 的描述要清楚
    • 说明什么时候使用这个 Agent

  3. 合理分工

    • 复杂任务拆分给不同 Agents
    • 避免 Agents 之间的职责重叠

  4. 定期维护

    • Agent 配置要随项目演进更新
    • 删除不再使用的 Agents
相关推荐
烁烁闪闪烁烁1 天前
【weelinking系列Claude教程】 04 - Claude Code 安装与配置
人工智能·chatgpt·ai编程·claude·cursor·claude code·opencode
曦云沐1 天前
AI 编程助手三强争霸：OpenCode vs Claude Code vs Kimi Code CLI 深度对比
人工智能·claude code·kimi code·open code
26岁的学习随笔1 天前
【Claude Code】拆解 Claude Code 的 API 交互 —— 抓包看清每一个字节
llm·agent框架·claude code·prompt engineering·api分析
A洛2 天前
从零开始：OpenClaw 完整安装配置实战指南
ai·ai编程·claude code·openclaw·clawbot
A洛2 天前
OpenAI Codex CLI 完整速查表：命令、配置、MCP 一网打尽
人工智能·chatgpt·codex·claude code
鹓于4 天前
Claude code操作指南
claude code
小草cys4 天前
Claude Code for VSCode 最简安装
大模型·vs code·claude code
小小工匠4 天前
LLM - Claude-Mem 让 Claude Code 拥有长期记忆
开源·claude code·claude memory·claude mem
小小工匠4 天前
Vibe Coding - Oh My Claude Code：把 Claude Code 变成“多智能体开发助手”的完整实战指南
claude code·oh my claude·omc
热门推荐
01PHP Error: 常见错误及其解决方法02GitHub 镜像站点03Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services04UV安装并设置国内源05openClaw安装飞书插件｜核心踩坑：spawn EINVAL 错误终极解决指南06HTB 赛季10 - Pterodactyl - user07243 行 microGPT：把“训练 + 推理”拆到骨头里08爬虫逆向之观安（观镜WEB应用安全防护系统）09SwiftUI-TextField组件学习10Linux下V2Ray安装配置指南