Claude Code使用实战教程

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

一:Claude Code 简介

Claude Code 是什么?

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

工作流程对比:

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

主要功能

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

核心优势

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

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

二:安装配置

前置条件

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

Node.js (版本 14 或更高)
bash 复制代码
```
# 检查是否已安装
node --version
```
Anthropic 账号
- 访问 https://console.anthropic.com 注册
- 可以使用 Claude.ai 账号,也可以使用 API 账号(需要充值)

安装步骤

方式一:直接运行

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

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

Claude.ai 账号 - 免费用户可用,但有使用限制
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 会:

创建项目结构
编写 Calculator.java
编写 Main.java
询问确认

步骤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 怎么办?

可以采取以下措施:

直接反馈:

复制代码

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

提供错误信息:

复制代码

运行时报错: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 启动时会自动读取此文件,并按照其中定义的规则执行任务。

配置内容

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

第二部分:创建 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 时,系统会:

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

验证配置

创建 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 的三大好处

省时间 ⏱️
- 不用每次都详细说明
- 一句话就能完成复杂任务
保证质量 ✨
- 代码风格统一
- 不会遗漏重要步骤
- 符合团队规范
可复用 🔄
- 一次创建,永久使用
- 团队共享
- 持续优化

第一部分: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。

准备工作

你需要:

已经安装了 Claude Code(参考第一课)
有一个项目文件夹(任意文件夹都可以)
打开命令行工具(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 会:

识别到这个任务匹配 spring-rest-controller 这个 Skill
询问是否使用这个 Skill
按照 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 的三大好处

自动化操作
- Claude 可以直接操作外部服务
- 不需要你手动复制粘贴
- 一句话完成复杂任务
实时数据
- 可以查询数据库
- 可以获取最新的 API 数据
- 可以读取外部文件
无缝集成
- 连接你常用的工具
- 在一个地方完成所有工作
- 提升工作效率

常用的 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 的应用场景

连接 GitHub - 自动创建 Issue、PR、查看代码
连接数据库 - 直接查询数据库生成代码
连接 Figma - 从设计稿生成前端代码
连接 Sentry - 自动修复线上 Bug
连接内部 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 的密钥

操作步骤:

登录 GitHub
- 访问 https://github.com
- 登录你的账号
进入设置页面
- 点击右上角头像
- 选择 "Settings"(设置)
创建 Token
- 在左侧菜单找到 "Developer settings"(开发者设置)
- 点击 "Personal access tokens"
- 选择 "Tokens (classic)"
- 点击 "Generate new token" → "Generate new token (classic)"
配置 Token 权限
- Note(备注):填写 "Claude Code MCP"
- Expiration(过期时间):选择 "90 days"(90天)
- 勾选以下权限:
  - ✅ repo (完整的仓库访问权限)
  - ✅ workflow (工作流权限)
  - ✅ write:discussion (讨论写入权限)
生成并保存 Token
- 点击页面底部的 "Generate token"
- 重要! 复制生成的 token(以 ghp_ 开头)
- 保存到安全的地方(只显示一次!)

验证步骤:

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

复制代码

ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

常见问题:

❌ 问题: 找不到 "Developer settings"

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

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

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

步骤2:配置环境变量

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

操作步骤:

Windows 用户(PowerShell)

打开 PowerShell(以管理员身份)

设置环境变量

powershell 复制代码

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

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

验证设置
powershell 复制代码
```
# 查看环境变量
$env:GITHUB_PERSONAL_ACCESS_TOKEN
```
应该显示你的 token

Linux/Mac 用户

打开 Terminal

编辑配置文件

bash 复制代码

# 如果使用 bash
nano ~/.bashrc

# 如果使用 zsh
nano ~/.zshrc

添加环境变量

在文件末尾添加:
bash 复制代码
```
export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_你的token"
```

保存并重新加载

bash 复制代码

# bash 用户
source ~/.bashrc

# zsh 用户
source ~/.zshrc

验证设置
bash 复制代码
```
echo $GITHUB_PERSONAL_ACCESS_TOKEN
```
应该显示你的 token

安全提示:

⚠️ 不要把 token 提交到 Git 仓库
⚠️ 不要在公开的地方分享 token
⚠️ 定期更换 token

步骤3:配置 MCP Server

目标: 告诉 Claude Code 使用 GitHub MCP

操作步骤:

找到 Claude Code 配置目录

Windows:
复制代码
```
cd 你的项目
```
Linux/Mac:
复制代码
```
~/.claude/
```

创建或编辑 MCP 配置文件

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

json 复制代码

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

保存文件

文件说明:

"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 是否正常工作

操作步骤:

重启 Claude Code

bash 复制代码

# 如果 Claude Code 正在运行,先退出
/exit

# 重新启动
claude

检查 MCP Server 状态
bash 复制代码
```
/mcp
```
你应该看到:
复制代码
```
Available MCP Servers:
- github (connected)
```
测试 GitHub 操作

在 Claude Code 中输入:
复制代码
```
列出我的 GitHub 仓库
```
Claude 应该能够:
- 连接到 GitHub
- 获取你的仓库列表
- 显示仓库信息

预期结果:

复制代码

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

验证成功的标志:

✅ /mcp 显示 github 已连接
✅ Claude 能够获取你的仓库信息
✅ 没有报错信息

步骤5:实际应用

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

创建 Issue

复制代码

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

查看 Issue

复制代码

列出 my-repo 仓库的所有 open issues

创建 Pull Request

复制代码

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

查看代码

复制代码

显示 my-repo 仓库的 README.md 文件内容

常见问题排查

Q1: `/mcp` 显示 github 未连接

可能原因:

环境变量未设置

bash 复制代码

# 检查环境变量
# Windows
$env:GITHUB_PERSONAL_ACCESS_TOKEN

# Linux/Mac
echo $GITHUB_PERSONAL_ACCESS_TOKEN

配置文件路径错误
- 确保 mcp_settings.json 在正确的位置
- Windows: C:\Users\你的用户名\.claude\mcp_settings.json
- Linux/Mac: ~/.claude/mcp_settings.json
Node.js 未安装或版本过低
bash 复制代码
```
node --version
# 需要 14 或更高版本
```

Q2: Claude 说"无法连接到 GitHub"

可能原因:

Token 无效或过期
- 检查 token 是否正确
- 检查 token 是否过期
- 重新生成 token
Token 权限不足
- 确保勾选了 repo 权限
- 重新生成 token 并勾选所有必需权限
网络问题
- 检查网络连接
- 检查是否能访问 GitHub

Q3: 配置文件格式错误

症状: Claude Code 启动时报错

解决方案:

检查 JSON 格式
- 使用在线 JSON 验证工具
- 确保所有引号、逗号、括号都正确

使用正确的模板

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 服务器通常通过配置文件添加,而不是命令行。你可能需要:

在用户配置目录创建 MCP 配置文件
或使用 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)

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

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?

专业化 - 每个 Agent 专注于自己的领域,做得更好
并行处理 - 多个 Agent 可以同时工作
上下文隔离 - 每个 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 的最佳实践

提示词最佳实践

从简单到复杂
- 先让 AI 理解任务
- 再添加细节要求
- 最后加上约束条件
使用模板
- 把常用的提示词保存成模板
- 根据具体情况调整
- 积累自己的提示词库
迭代优化
- 第一次结果不满意?调整提示词再试
- 记录哪些提示词效果好
- 不断优化自己的提示词
充分利用项目上下文
- 让 AI 参考已有代码
- 引用 CLAUDE.md 里的规范
- 使用 Skills 和 MCP

Agents 最佳实践

专业化
- 每个 Agent 只负责一个领域
- 不要创建"全能" Agent
清晰的职责
- Agent 的描述要清楚
- 说明什么时候使用这个 Agent
合理分工
- 复杂任务拆分给不同 Agents
- 避免 Agents 之间的职责重叠
定期维护
- Agent 配置要随项目演进更新
- 删除不再使用的 Agents

Claude Code使用实战教程

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

一:Claude Code 简介

Claude Code 是什么?

主要功能

核心优势

二:安装配置

前置条件

安装步骤

方式一:直接运行

方式二:全局安装

登录认证

三:首次使用

启动 Claude Code

基础操作示例

1. 分析当前目录

2. 创建 Java 文件

3. 编译并运行

权限确认设置

四:基础命令

斜杠命令(Slash Commands)

文件操作

常见使用场景

场景1:创建新项目

场景2:修复 Bug

场景3:编写测试

场景4:重构代码

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

案例:计算器程序

步骤1:启动 Claude Code

步骤2:创建项目

步骤3:查看生成的代码

步骤4:编译并测试

步骤5:添加功能

六:Vue 3 快速入门

案例:创建 Todo List

步骤1:初始化项目

步骤2:创建组件

步骤3:运行项目

七:常见问题和解决方案

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

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

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

第八部分:最佳实践

1. 明确需求描述

2. 分步骤执行

3. 利用项目上下文

小结

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

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

配置文件说明

配置内容

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

Spring Boot 项目示例

Vue 3 项目示例

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

自动加载

验证配置

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

创建配置文件

配置权限和 Hooks

示例配置

配置说明

Hooks(钩子)

Permissions(权限)

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

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

后端配置

前端配置

测试配置效果

测试1:创建后端 API

测试2:创建前端页面

第六部分:常见配置场景

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

场景2:自动格式化代码

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

第七部分:最佳实践

1. 保持配置简洁

2. 使用具体示例

3. 定期更新配置

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

Q1: `/mcp` 显示 github 未连接