AI Coding工具实战指南：Claude Code & Cursor深度实践

lhrimperial

2328人浏览 · 2025-12-22 09:09:45

lhrimperial · 2025-12-22 09:09:45 发布

从传统编程到AI辅助开发的完整转型指南

1. AI Coding：编程范式的革命

1.1 什么是AI Coding？

AI Coding不是简单的代码补全，而是一种全新的编程范式：

1.2 AI Coding的核心价值

对开发者的价值：

维度	传统方式	AI Coding	提升
代码编写	纯手写	AI生成+人工Review	3-5倍效率
学习新技术	查文档+试错	AI即时解释+示例	10倍速度
代码审查	人工Review	AI自动检查+人工确认	更全面
单元测试	手写测试用例	AI生成测试框架	2-3倍效率
重构优化	手动重构	AI建议+自动重构	更安全

典型应用场景：

在这里插入图片描述

1.3 AI Coding vs 传统IDE辅助

2. 主流AI Coding工具全景对比

2.1 市场格局概览

2.2 详细对比矩阵

2.2.1 核心功能对比

工具	代码补全	对话编程	多文件编辑	Agent能力	本地运行	价格
Claude Code	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	✅	API计费
Cursor	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐	❌	$20/月
GitHub Copilot	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐	❌	$10/月
Codeium	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐	⭐⭐	✅	免费
Windsurf	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	❌	$15/月

2.2.2 技术特点对比

Claude Code

Cursor

在这里插入图片描述

2.2.3 选择决策树

2.3 工具组合建议

最佳组合方案：

分工建议：

Cursor：80%的日常开发工作
- 功能开发
- Bug修复
- 代码重构
- 单元测试
Claude Code：20%的复杂任务
- 架构设计
- 大规模重构
- 系统性问题
- 自动化脚本

3. Claude Code深度实践

3.1 Claude Code核心概念

3.1.1 架构设计

3.1.2 工作流程

3.2 核心工具详解

3.2.1 文件操作工具

1. Read工具 - 读取文件

# Claude Code会自动调用Read工具
# 用户只需描述需求
claude "请分析UserService的代码质量"

# Claude内部执行：
# 1. Read(/path/to/UserService.java)
# 2. 分析代码
# 3. 给出建议

Read工具特性：

2. Write工具 - 创建文件

# 示例：创建新的Service类
claude "创建一个OrderService，包含CRUD操作"

# Claude内部执行：
# Write工具创建文件：
# - 生成完整的类结构
# - 添加必要的注解
# - 包含JavaDoc注释

Write工具最佳实践：

✅ 适用场景：
- 创建全新的文件
- 生成配置文件
- 输出测试数据

❌ 不适用场景：
- 修改现有文件（应使用Edit）
- 部分更新（应使用Edit）

3. Edit工具 - 精确修改

# 示例：重构现有代码
claude "将UserService中的同步方法改为异步"

# Claude内部执行：
# 1. Read(UserService.java) - 读取现有代码
# 2. 分析需要修改的部分
# 3. Edit工具精确替换：
#    old_string: "public User getUser(Long id)"
#    new_string: "public CompletableFuture<User> getUser(Long id)"

Edit工具的工作原理：

Edit工具注意事项：

// ✅ 正确使用 - 提供足够的上下文
old_string:
"""
@Service
public class UserService {
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
}
"""

new_string:
"""
@Service
public class UserService {
    public CompletableFuture<User> getUser(Long id) {
        return CompletableFuture.supplyAsync(
            () -> userRepository.findById(id)
        );
    }
}
"""

// ❌ 错误使用 - 上下文不足（可能匹配多处）
old_string: "public User getUser"
new_string: "public CompletableFuture<User> getUser"

3.2.2 搜索工具

1. Glob工具 - 文件名匹配

# 使用场景
claude "找出所有的Service类"

# Claude内部执行：
# Glob(**/*Service.java)
# 返回匹配的文件列表

Glob模式语法：

模式	说明	示例
`*.java`	当前目录所有Java文件	UserService.java
`*/.java`	递归所有Java文件	src/main/…/UserService.java
`/test//*.java`	test目录下所有Java文件	src/test/…/UserTest.java
`*/{Service,Controller}.java`	Service或Controller结尾	UserService.java, UserController.java

2. Grep工具 - 内容搜索

# 使用场景
claude "找出所有使用@Transactional的地方"

# Claude内部执行：
# Grep(pattern="@Transactional", glob="**/*.java")

Grep高级用法：

# 1. 正则表达式搜索
pattern: "@Autowired.*private.*Repository"

# 2. 限定文件类型
glob: "**/*.java"
type: "java"

# 3. 上下文行数
-A: 3  # 显示匹配行后3行
-B: 2  # 显示匹配行前2行
-C: 2  # 显示匹配行前后各2行

# 4. 不同输出模式
output_mode: "content"           # 显示匹配的内容
output_mode: "files_with_matches" # 只显示文件名
output_mode: "count"             # 显示匹配次数

搜索工具组合使用：

3.2.3 Task工具 - 子代理系统

什么是Task工具？

Task工具允许Claude启动专门的子代理（Sub-agent）来处理特定任务，每个代理有专门的能力和工具集。

可用的代理类型：
在这里插入图片描述

Task工具使用示例：

# 示例1：探索代码库
claude "分析这个项目的认证机制是如何实现的"

# Claude内部执行：
# Task(
#   subagent_type: "Explore",
#   prompt: "分析认证机制的实现",
#   description: "探索认证实现"
# )

# Explore代理会：
# 1. 搜索authentication相关文件
# 2. 查找配置文件
# 3. 分析依赖关系
# 4. 总结认证流程

Task代理的工作流程：

何时使用Task代理：

在这里插入图片描述

3.3 Prompt Engineering for Claude Code

3.3.1 有效Prompt的结构

3.3.2 Prompt模板库

模板1：代码生成

角色：你是一位精通{{技术栈}}的高级开发工程师

任务：实现{{功能描述}}

技术要求：
- 框架：{{框架名称}}
- 版本：{{版本号}}
- 依赖：{{相关依赖}}

功能要求：
1. {{功能点1}}
2. {{功能点2}}
3. {{功能点3}}

代码规范：
- 遵循{{编码规范}}
- 使用{{设计模式}}
- 添加完整的JavaDoc注释
- 包含异常处理

输出：
- 完整的实现代码
- 必要的配置文件
- 使用说明

实际使用示例：

claude "
角色：你是一位精通Spring Boot和Redis的高级Java工程师

任务：实现一个支持多级缓存的用户服务

技术要求：
- 框架：Spring Boot 3.2
- 缓存：Caffeine（本地） + Redis（分布式）
- 数据库：MyBatis Plus

功能要求：
1. 实现用户的CRUD操作
2. 本地缓存（Caffeine）作为L1缓存
3. Redis作为L2缓存
4. 缓存过期时间：L1=5分钟，L2=30分钟
5. 支持缓存预热
6. 提供缓存监控指标

代码规范：
- 遵循阿里巴巴Java开发规范
- 使用Lombok减少样板代码
- 添加完整的JavaDoc
- 包含完善的异常处理

输出：
- UserService完整实现
- CacheConfig配置类
- application.yml配置
- 使用示例
"

模板2：代码重构

任务：重构以下代码

当前问题：
1. {{问题1}}
2. {{问题2}}

重构目标：
1. {{目标1}}
2. {{目标2}}

约束：
- 保持API向后兼容
- 不修改数据库结构
- 保持现有测试通过

请提供：
1. 重构后的代码
2. 重构说明
3. 影响分析
4. 迁移建议

模板3：问题排查

问题描述：{{具体问题}}

环境信息：
- 操作系统：{{OS}}
- Java版本：{{Java version}}
- 框架版本：{{Framework version}}

错误信息：


已尝试的方案：
1. {{尝试1}} - 结果：{{结果1}}
2. {{尝试2}} - 结果：{{结果2}}

请帮我：
1. 分析根本原因
2. 提供解决方案
3. 给出预防措施

3.3.3 进阶Prompt技巧

技巧1：分步骤引导

# ❌ 不好的提示（太宽泛）
claude "优化这个系统的性能"

# ✅ 好的提示（分步骤）
claude "
请分步骤优化系统性能：

Step 1: 性能分析
- 使用JProfiler分析当前性能瓶颈
- 识别高耗时的方法
- 分析数据库查询效率

Step 2: 优化方案设计
- 针对瓶颈设计优化方案
- 评估每个方案的收益和风险
- 给出优先级排序

Step 3: 实施优化
- 按优先级逐步实施
- 每一步都进行性能测试
- 记录优化效果

请从Step 1开始执行
"

技巧2：提供示例（Few-shot）

claude "
请按照以下风格编写Controller：

示例1：
@RestController
@RequestMapping(\"/api/users\")
@Slf4j
public class UserController {

    @Resource
    private UserService userService;

    @GetMapping(\"/{id}\")
    public Result<UserDTO> getUser(@PathVariable Long id) {
        log.info(\"查询用户：{}\", id);
        UserDTO user = userService.getById(id);
        return Result.success(user);
    }

    @PostMapping
    public Result<Long> createUser(@Valid @RequestBody UserCreateRequest request) {
        Long userId = userService.create(request);
        return Result.success(userId);
    }
}

示例2：
（另一个示例...）

现在，请按相同风格实现OrderController，包含订单的CRUD操作。
"

技巧3：约束引导

claude "
实现订单服务，必须满足以下约束：

必须做到（MUST）：
✓ 使用@Transactional保证事务
✓ 所有金额使用BigDecimal
✓ 订单号使用雪花算法生成
✓ 所有时间字段使用LocalDateTime

应该做到（SHOULD）：
✓ 添加操作日志
✓ 使用枚举管理订单状态
✓ 添加防重提交
✓ 实现幂等性

可以选择（MAY）：
✓ 使用消息队列异步处理
✓ 添加监控指标
✓ 实现订单缓存

禁止事项（MUST NOT）：
✗ 不要在循环中查询数据库
✗ 不要使用String处理金额
✗ 不要在Service层直接抛出Exception
✗ 不要使用魔法值
"

技巧4：思维链（Chain of Thought）

claude "
分析并优化以下慢SQL，请按这个思路分析：

1. 理解SQL意图
   - 这个SQL在做什么？
   - 查询的业务场景是什么？

2. 执行计划分析
   - 使用EXPLAIN分析执行计划
   - 识别全表扫描
   - 查找是否使用索引

3. 问题识别
   - 列举所有性能问题
   - 按影响程度排序

4. 优化方案
   - 对每个问题提出解决方案
   - 评估方案的优缺点
   - 给出推荐方案

5. 优化后SQL
   - 提供优化后的SQL
   - 说明优化点
   - 预期性能提升

请逐步执行以上分析。
"

3.4 Skills - 自定义技能扩展

3.4.1 什么是Skills？

Skills是Claude Code的扩展机制，允许你创建自定义命令来封装常用的工作流程。
在这里插入图片描述

3.4.2 Skill的结构

一个Skill包含以下部分：

# skill.yaml 配置文件
name: code-review
description: 执行全面的代码审查
version: 1.0.0
author: your-name

# Skill的入口点
entry: review.md

# 参数定义
parameters:
  - name: file
    description: 要审查的文件路径
    required: true
  - name: level
    description: 审查级别 (basic/standard/strict)
    required: false
    default: standard

<!-- review.md - Skill的执行逻辑 -->
# 代码审查Skill

## 任务
对 {{file}} 进行 {{level}} 级别的代码审查

## 审查步骤

### 1. 代码读取
首先读取目标文件的内容

### 2. 基础检查 (所有级别)
- [ ] 代码规范检查
- [ ] 命名规范检查
- [ ] 注释完整性
- [ ] 基本的空指针检查

### 3. 标准检查 (standard及以上)
- [ ] 设计模式使用
- [ ] 异常处理
- [ ] 资源管理
- [ ] 并发安全

### 4. 严格检查 (strict)
- [ ] 性能分析
- [ ] 安全漏洞扫描
- [ ] 内存泄漏检查
- [ ] 事务管理

## 输出格式

### 问题列表
| 严重程度 | 位置 | 问题描述 | 建议方案 |
|---------|------|---------|---------|
| HIGH/MEDIUM/LOW | 文件:行号 | 具体问题 | 修复建议 |

### 修改建议
提供具体的代码修改示例

### 总体评分
- 代码质量：X/10
- 可维护性：X/10
- 性能：X/10
- 安全性：X/10

3.4.3 实用Skills示例

Skill 1: Spring Boot CRUD生成器

# skills/spring-crud/skill.yaml
name: spring-crud
description: 生成Spring Boot的完整CRUD代码
version: 1.0.0

parameters:
  - name: entity
    description: 实体名称（如User、Order）
    required: true
  - name: package
    description: 包名
    required: true
  - name: features
    description: 额外特性（cache/validate/log）
    required: false

<!-- skills/spring-crud/crud.md -->
# Spring Boot CRUD生成器

## 任务
为实体 {{entity}} 生成完整的CRUD功能

## 生成内容

### 1. 实体类 (Entity)
```java
package {{package}}.entity;

@Entity
@Table(name = "t_{{entity|lower}}")
@Data
@Builder
public class {{entity}} {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 根据常见字段生成
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}


### 2. DTO类
- {{entity}}DTO
- {{entity}}CreateRequest
- {{entity}}UpdateRequest
- {{entity}}QueryRequest

### 3. Mapper接口
```java
@Mapper
public interface {{entity}}Mapper extends BaseMapper<{{entity}}> {
}


### 4. Service层
- {{entity}}Service接口
- {{entity}}ServiceImpl实现
{{#if features contains 'cache'}}
- 集成Redis缓存
{{/if}}

### 5. Controller层
```java
@RestController
@RequestMapping("/api/{{entity|lower}}s")
@Slf4j
public class {{entity}}Controller {
    // CRUD endpoints
}


### 6. 单元测试
- {{entity}}ServiceTest
- {{entity}}ControllerTest

## 额外功能
{{#if features contains 'validate'}}
- 添加参数校验
{{/if}}
{{#if features contains 'log'}}
- 添加操作日志
{{/if}}

使用方式：

# 调用Skill
claude /spring-crud entity=User package=com.example.demo features=cache,validate

# Claude会自动生成所有文件

Skill 2: 数据库迁移助手

# skills/db-migrate/skill.yaml
name: db-migrate
description: 生成Flyway数据库迁移脚本
version: 1.0.0

parameters:
  - name: description
    description: 迁移描述
    required: true
  - name: type
    description: 迁移类型（create/alter/data）
    required: true

<!-- skills/db-migrate/migrate.md -->
# 数据库迁移助手

## 任务
创建Flyway迁移脚本：{{description}}

## 步骤

### 1. 生成版本号
- 格式：V{timestamp}__{description}.sql
- 示例：V20250121120000__create_user_table.sql

### 2. 编写SQL

{{#if type == 'create'}}

### sql
-- 创建表
CREATE TABLE t_{{table_name}} (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    -- 字段定义
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    deleted TINYINT NOT NULL DEFAULT 0,
    INDEX idx_create_time (create_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='{{comment}}';

{{/if}}

{{#if type == 'alter'}}
### sql
-- 修改表结构
ALTER TABLE t_{{table_name}}
    ADD COLUMN {{column_name}} {{column_type}} {{constraints}} COMMENT '{{comment}}';

-- 添加索引
ALTER TABLE t_{{table_name}}
    ADD INDEX idx_{{column_name}} ({{column_name}})
{{/if}}

### 3. 回滚脚本
创建对应的回滚脚本 U{version}__{{description}}.sql

### 4. 验证
- 检查SQL语法
- 确保可回滚
- 添加必要的注释

Skill 3: API文档生成器

<!-- skills/api-doc/doc.md -->
# API文档生成器

## 任务
为Controller生成API文档

## 分析Controller
1. 读取Controller文件
2. 解析所有@RequestMapping方法
3. 提取参数和返回值

## 生成文档

### API概览
| 接口 | 方法 | 路径 | 描述 |
|------|------|------|------|
| 创建用户 | POST | /api/users | 创建新用户 |
| 获取用户 | GET | /api/users/{id} | 根据ID获取 |
| 更新用户 | PUT | /api/users/{id} | 更新用户信息 |
| 删除用户 | DELETE | /api/users/{id} | 删除用户 |

### 接口详情

#### 1. 创建用户

**请求**
```http
POST /api/users
Content-Type: application/json

{
  "username": "zhangsan",
  "email": "zhangsan@example.com",
  "phone": "13800138000"
}


**响应**
### json
{
  "code": 200,
  "message": "success",
  "data": {
    "id": 1,
    "username": "zhangsan",
    "email": "zhangsan@example.com"
  }
}

错误码

错误码	说明
400	参数校验失败
409	用户已存在

生成Postman Collection

同时生成可导入Postman的JSON文件


#### **3.4.4 Skills最佳实践**

**1. Skill组织结构**

.claude/
├── skills/
│ ├── code-review/ # 代码审查
│ │ ├── skill.yaml
│ │ └── review.md
│ ├── spring-crud/ # CRUD生成
│ │ ├── skill.yaml
│ │ ├── templates/
│ │ └── crud.md
│ ├── db-migrate/ # 数据库迁移
│ │ ├── skill.yaml
│ │ └── migrate.md
│ └── api-doc/ # API文档
│ ├── skill.yaml
│ └── doc.md
└── settings.json


**2. Skill设计原则**

```mermaid
mindmap
  root((Skill设计))
    单一职责
      一个Skill做一件事
      保持简单
      易于维护
    可配置性
      参数化
      默认值
      可选项
    可复用性
      通用模板
      参数化配置
      团队共享
    文档完善
      清晰的说明
      使用示例
      参数说明

3. Skill测试检查清单

# 测试新Skill时的检查项
✓ 参数验证是否正确
✓ 默认值是否生效
✓ 错误处理是否完善
✓ 输出格式是否一致
✓ 文档说明是否清晰
✓ 是否可以复用

3.5 Hooks - 工作流钩子

3.5.1 什么是Hooks？

Hooks允许你在特定事件发生时自动执行命令，实现工作流自动化。

3.5.2 可用的Hook类型

# .claude/settings.json
{
  "hooks": {
    // 用户提交prompt前
    "user-prompt-submit": "echo '开始处理...'",

    // 工具调用前
    "pre-tool-use": "echo '准备调用工具: $TOOL_NAME'",

    // 工具调用后
    "post-tool-use": "echo '工具调用完成: $TOOL_NAME'",

    // 文件写入后
    "post-write": "prettier --write $FILE_PATH",

    // 代码编辑后
    "post-edit": "eslint --fix $FILE_PATH"
  }
}

3.5.3 实用Hook示例

Hook 1: 自动格式化代码

{
  "hooks": {
    "post-write": "prettier --write ${FILE_PATH} && eslint --fix ${FILE_PATH}",
    "post-edit": "prettier --write ${FILE_PATH}"
  }
}

Hook 2: 自动运行测试

{
  "hooks": {
    "post-edit": {
      "command": "npm test -- ${FILE_PATH}",
      "when": "${FILE_PATH} matches '**/*.test.js'"
    }
  }
}

Hook 3: Git集成

{
  "hooks": {
    "post-write": [
      "git add ${FILE_PATH}",
      "echo 'File staged: ${FILE_PATH}'"
    ]
  }
}

Hook 4: 构建检查

{
  "hooks": {
    "user-prompt-submit": {
      "command": "mvn compile",
      "when": "any file matches '**/*.java'",
      "continueOnError": false
    }
  }
}

3.6 Agent模式 - 高级用法

3.6.1 什么是Agent模式？

在Claude Code中，Agent模式指的是让Claude自主决策和执行多步骤任务的能力。

3.6.2 Agent工作示例

场景：重构遗留代码

claude "
重构legacy包下的所有代码：
1. 使用现代Java特性（Stream API、Optional）
2. 添加单元测试
3. 优化性能
4. 更新文档
"

Claude的Agent执行流程：

3.6.3 Agent模式的能力边界

✅ Agent擅长的任务：

在这里插入图片描述

❌ Agent的局限：

1. 无法处理需要人工决策的场景
   - 业务逻辑设计
   - 技术方案选型（需要业务背景）

2. 无法处理需要外部交互的任务
   - 数据库直接操作（只能生成SQL）
   - 外部API调用测试

3. 有Token限制
   - 超大型项目可能超出上下文
   - 需要分批处理

3.6.4 Agent最佳实践

1. 给Agent明确的目标

# ❌ 模糊的目标
claude "优化系统"

# ✅ 明确的目标
claude "
优化订单系统的查询性能：
目标：查询响应时间从1s降到100ms以内

步骤：
1. 分析当前慢查询
2. 添加合适的索引
3. 优化N+1查询
4. 添加缓存
5. 性能测试验证

约束：
- 不能修改现有API
- 保持数据一致性
- 向后兼容
"

2. 分阶段执行复杂任务

# Phase 1: 分析
claude "分析订单系统的性能瓶颈，给出报告"

# 等待分析完成，review报告

# Phase 2: 执行优化
claude "根据刚才的分析报告，优化TOP 3的性能问题"

# Phase 3: 验证
claude "为刚才的优化生成性能测试，验证效果"

3. 使用检查点（Checkpoint）

claude "
重构用户模块：

Checkpoint 1: 重构Service层
- 任务：...
- 验证：运行单元测试
- 如果失败：停止并报告

Checkpoint 2: 重构Controller层
- 任务：...
- 验证：运行集成测试
- 如果失败：停止并报告

Checkpoint 3: 更新文档
- 任务：...
- 验证：文档完整性检查
"

4. Cursor深度实践

4.1 Cursor核心特性

4.1.1 架构设计

在这里插入图片描述

4.2 核心功能详解

4.2.1 Tab - 智能补全

工作原理：

使用技巧：

// 1. 方法签名补全
// 输入：
public User findBy

// 按Tab，Cursor建议：
public User findByIdAndStatus(Long id, String status) {
    return userRepository.findByIdAndStatus(id, status);
}

// 2. 测试用例补全
// 输入：
@Test
void testUserService

// 按Tab：
@Test
void testUserServiceGetById() {
    // Given
    Long userId = 1L;
    User expectedUser = User.builder()
        .id(userId)
        .username("test")
        .build();
    when(userRepository.findById(userId))
        .thenReturn(Optional.of(expectedUser));

    // When
    User actualUser = userService.getById(userId);

    // Then
    assertEquals(expectedUser, actualUser);
}

// 3. 注释生成代码
// 输入注释：
// 实现用户登录，包含密码加密验证和Token生成

// 按Tab，生成完整实现：
public LoginResponse login(LoginRequest request) {
    // 验证用户名密码
    User user = userRepository.findByUsername(request.getUsername())
        .orElseThrow(() -> new BusinessException("用户不存在"));

    // 密码加密比对
    if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
        throw new BusinessException("密码错误");
    }

    // 生成Token
    String token = jwtTokenProvider.createToken(user.getId());

    return LoginResponse.builder()
        .token(token)
        .userId(user.getId())
        .username(user.getUsername())
        .build();
}

最佳实践：

✓ 写清晰的注释来引导补全
✓ 保持文件上下文相关性
✓ 先写方法签名，让AI补全实现
✓ 使用Tab快速接受，Cmd+→只接受部分

4.2.2 Cmd+K - 内联编辑

什么是Cmd+K？

在代码中选中一段，按Cmd+K（Windows: Ctrl+K），可以直接用自然语言描述修改需求。

使用场景：

场景1：快速重构

// 选中这段代码，Cmd+K
public List<User> getActiveUsers() {
    List<User> users = new ArrayList<>();
    for (User user : userRepository.findAll()) {
        if ("ACTIVE".equals(user.getStatus())) {
            users.add(user);
        }
    }
    return users;
}

// 输入："使用Stream API重写"
// Cursor自动改为：
public List<User> getActiveUsers() {
    return userRepository.findAll().stream()
        .filter(user -> "ACTIVE".equals(user.getStatus()))
        .collect(Collectors.toList());
}

场景2：添加功能

// 选中方法，Cmd+K
@GetMapping("/{id}")
public Result<UserDTO> getUser(@PathVariable Long id) {
    UserDTO user = userService.getById(id);
    return Result.success(user);
}

// 输入："添加参数校验和异常处理"
// Cursor自动修改为：
@GetMapping("/{id}")
public Result<UserDTO> getUser(@PathVariable @Min(1) Long id) {
    try {
        UserDTO user = userService.getById(id);
        if (user == null) {
            return Result.error("用户不存在");
        }
        return Result.success(user);
    } catch (Exception e) {
        log.error("查询用户失败: {}", id, e);
        return Result.error("系统错误");
    }
}

场景3：生成测试

// 选中Service方法，Cmd+K
public void createOrder(OrderCreateRequest request) {
    Order order = Order.builder()
        .userId(request.getUserId())
        .amount(request.getAmount())
        .status(OrderStatus.PENDING)
        .build();
    orderRepository.save(order);
}

// 输入："生成单元测试"
// Cursor在测试文件中生成：
@Test
void testCreateOrder() {
    // Given
    OrderCreateRequest request = OrderCreateRequest.builder()
        .userId(1L)
        .amount(new BigDecimal("99.99"))
        .build();

    // When
    orderService.createOrder(request);

    // Then
    verify(orderRepository).save(argThat(order ->
        order.getUserId().equals(1L) &&
        order.getAmount().equals(new BigDecimal("99.99")) &&
        order.getStatus() == OrderStatus.PENDING
    ));
}

Cmd+K最佳实践：

在这里插入图片描述

4.2.3 Chat - 对话式编程

Chat面板的强大之处：

在这里插入图片描述

@ 符号的使用：

1. @Codebase - 搜索整个代码库

# 在Chat中输入：
@Codebase 认证是如何实现的？

# Cursor会：
# 1. 搜索整个代码库
# 2. 找到相关的认证代码
# 3. 分析认证流程
# 4. 给出完整解释

2. @Files - 引用特定文件

# 引用文件进行讨论
@UserService.java @UserController.java
这两个类的职责是否清晰？有没有改进建议？

# Cursor会分析两个文件的关系和设计

3. @Docs - 查询官方文档

# 查询框架文档
@Docs Spring Boot 3.2的新特性有哪些？

# Cursor会搜索Spring官方文档并总结

4. @Web - 搜索网络

# 搜索最新信息
@Web Java 21的虚拟线程如何使用？

# Cursor会搜索网络并给出最新的示例代码

Chat的典型对话流程：

你: @Codebase 订单支付流程是怎样的？

Cursor: 根据代码分析，订单支付流程如下：
1. OrderController接收支付请求
2. PaymentService调用第三方支付
3. 支付回调处理PaymentCallbackService
4. 更新订单状态OrderService
（附带相关代码位置）

你: 如何优化这个流程，支持异步支付？

Cursor: 建议使用消息队列优化：
1. 支付请求发送到MQ
2. 异步消费者处理支付
3. 回调结果通过MQ通知
我可以帮你实现，需要：
- 添加RabbitMQ依赖
- 创建PaymentMessage
- 实现消息生产者和消费者
是否继续？

你: 好的，请实现

Cursor: （开始生成代码文件）
已创建以下文件：
- PaymentMessage.java
- PaymentProducer.java
- PaymentConsumer.java
- RabbitMQConfig.java
（显示代码内容）

你: 帮我写一下这部分的测试

Cursor: （生成测试代码）
...

4.2.4 Composer - 多文件编辑

什么是Composer？

Composer是Cursor最强大的功能，可以同时编辑多个文件，实现跨文件的重构和功能开发。

Composer使用示例：

场景1：添加新功能模块

# 在Composer中输入：
实现一个完整的订单模块，包括：

1. 实体类Order
   - 字段：订单号、用户ID、金额、状态、创建时间
   - 使用雪花算法生成订单号

2. OrderRepository（MyBatis Plus）

3. OrderService
   - 创建订单
   - 查询订单
   - 更新订单状态
   - 取消订单

4. OrderController
   - RESTful API
   - 参数校验
   - 统一返回格式

5. DTO类
   - OrderDTO
   - OrderCreateRequest
   - OrderUpdateRequest

6. 单元测试
   - OrderServiceTest
   - OrderControllerTest

技术栈：Spring Boot 3.2 + MyBatis Plus + Lombok

Cursor的执行过程：

Composer生成的文件示例：

✓ entity/Order.java
✓ repository/OrderRepository.java
✓ service/OrderService.java
✓ service/impl/OrderServiceImpl.java
✓ controller/OrderController.java
✓ dto/OrderDTO.java
✓ dto/OrderCreateRequest.java
✓ dto/OrderUpdateRequest.java
✓ test/OrderServiceTest.java
✓ test/OrderControllerTest.java

所有文件已创建并保持一致性

场景2：大规模重构

# Composer任务：
将整个项目从同步改为异步：

1. 所有Service方法返回CompletableFuture
2. Controller层使用DeferredResult
3. 更新所有单元测试
4. 保持API向后兼容

影响文件：
- UserService及其实现
- OrderService及其实现
- UserController
- OrderController
- 相关测试文件

Composer最佳实践：

mindmap
  root((Composer使用))
    任务规划
      明确目标
      列出文件清单
      说明技术栈
    渐进式开发
      先核心后边缘
      分阶段验证
      及时Review
    保持一致性
      命名规范
      代码风格
      架构模式
    版本控制
      使用Git
      原子提交
      便于回滚

4.3 Cursor配置优化

4.3.1 模型选择

// .cursor/settings.json
{
  "cursor.general.model": "claude-3.5-sonnet",  // 主模型
  "cursor.autocomplete.model": "fast",          // 补全模型（快速）
  "cursor.chat.model": "gpt-4",                 // Chat模型
  "cursor.composer.model": "claude-3.5-sonnet"  // Composer模型
}

模型选择建议：

功能	推荐模型	原因
Tab补全	Fast	速度快，低延迟
Cmd+K	GPT-4 / Claude 3.5	代码理解能力强
Chat	Claude 3.5	推理能力强，上下文长
Composer	Claude 3.5	多文件协调能力强

4.3.2 自定义规则

<!-- .cursorrules 文件 -->
# 项目代码规范

## Java代码规范
- 使用阿里巴巴Java开发规范
- 所有类添加Lombok注解
- 使用SLF4J日志
- 异常统一使用BusinessException

## 注释规范
- 所有public方法必须有JavaDoc
- 复杂逻辑添加行内注释
- TODO标记待优化项

## 测试规范
- 使用JUnit 5
- Mock使用Mockito
- 测试覆盖率达到80%

## API规范
- RESTful风格
- 统一使用Result包装返回
- 参数使用@Valid校验

## 示例代码风格
```java
@Service
@Slf4j
public class UserServiceImpl implements UserService {

    @Resource
    private UserRepository userRepository;

    @Override
    @Cacheable(value = "user", key = "#id")
    public UserDTO getById(Long id) {
        log.info("查询用户：{}", id);
        return userRepository.findById(id)
            .map(this::toDTO)
            .orElseThrow(() -> new BusinessException("用户不存在"));
    }
}


#### **4.3.3 快捷键配置**

```json
// keybindings.json
[
  {
    "key": "cmd+l",
    "command": "cursor.chat.open",
    "when": "editorTextFocus"
  },
  {
    "key": "cmd+shift+l",
    "command": "cursor.composer.open"
  },
  {
    "key": "cmd+i",
    "command": "cursor.chat.newSession"
  }
]

5. 实战案例：构建Spring Boot AI应用

5.1 项目背景

需求： 构建一个智能文档问答系统

技术栈：

Spring Boot 3.2
Spring AI Alibaba
PostgreSQL + pgvector
Redis
MyBatis Plus

功能模块：

文档上传和解析
文档向量化存储
智能问答
对话历史管理

5.2 使用Claude Code进行架构设计

步骤1：初始化项目结构

# 启动Claude Code
claude

# 输入需求
"
我要创建一个Spring Boot 3.2项目，实现智能文档问答系统。

项目结构要求：
- 使用Maven
- 分层架构（Controller/Service/Repository）
- 集成Spring AI Alibaba
- 使用PostgreSQL存储向量

请帮我：
1. 创建项目骨架
2. 配置pom.xml
3. 创建application.yml
4. 设计包结构
"

Claude Code执行过程：

生成的项目结构：

doc-qa-system/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/com/example/docqa/
│   │   │   ├── DocQaApplication.java
│   │   │   ├── config/
│   │   │   │   ├── AiConfig.java
│   │   │   │   ├── VectorStoreConfig.java
│   │   │   │   └── RedisConfig.java
│   │   │   ├── controller/
│   │   │   │   ├── DocumentController.java
│   │   │   │   └── ChatController.java
│   │   │   ├── service/
│   │   │   │   ├── DocumentService.java
│   │   │   │   ├── VectorService.java
│   │   │   │   └── ChatService.java
│   │   │   ├── repository/
│   │   │   │   └── DocumentRepository.java
│   │   │   ├── entity/
│   │   │   │   ├── Document.java
│   │   │   │   └── Conversation.java
│   │   │   ├── dto/
│   │   │   ├── common/
│   │   │   │   ├── Result.java
│   │   │   │   └── BusinessException.java
│   │   │   └── util/
│   │   └── resources/
│   │       ├── application.yml
│   │       └── db/migration/
│   └── test/
└── README.md

步骤2：实现文档上传功能

claude "
实现文档上传和解析功能：

需求：
1. 支持PDF、Word、Markdown文件上传
2. 解析文档内容
3. 文档分块（chunk size: 500, overlap: 50）
4. 生成向量并存储到PostgreSQL
5. 保存文档元数据

技术细节：
- 使用Spring AI的DocumentReader
- 使用Tika解析文件
- 向量存储使用PgVectorStore
- 异步处理大文件

请实现完整功能，包括Controller、Service、配置类
"

Claude Code生成的核心代码：

// DocumentService.java
@Service
@Slf4j
public class DocumentService {

    @Resource
    private VectorStore vectorStore;

    @Resource
    private EmbeddingModel embeddingModel;

    @Resource
    private DocumentRepository documentRepository;

    /**
     * 上传并处理文档
     */
    @Async
    public CompletableFuture<Long> uploadDocument(MultipartFile file, String userId) {
        try {
            // 1. 保存文件
            String filePath = saveFile(file);

            // 2. 解析文档
            org.springframework.ai.document.Document document = parseDocument(file, filePath);

            // 3. 文档分块
            List<org.springframework.ai.document.Document> chunks = splitDocument(document);

            // 4. 向量化并存储
            List<Embedding> embeddings = embeddingModel.embed(
                chunks.stream()
                    .map(org.springframework.ai.document.Document::getContent)
                    .collect(Collectors.toList())
            );

            vectorStore.add(embeddings, chunks);

            // 5. 保存元数据
            DocumentEntity entity = DocumentEntity.builder()
                .userId(userId)
                .fileName(file.getOriginalFilename())
                .filePath(filePath)
                .fileSize(file.getSize())
                .chunkCount(chunks.size())
                .status("PROCESSED")
                .build();

            documentRepository.save(entity);

            log.info("文档处理完成：{}, chunks: {}", file.getOriginalFilename(), chunks.size());

            return CompletableFuture.completedFuture(entity.getId());

        } catch (Exception e) {
            log.error("文档处理失败", e);
            throw new BusinessException("文档处理失败：" + e.getMessage());
        }
    }

    private org.springframework.ai.document.Document parseDocument(MultipartFile file, String filePath) {
        String contentType = file.getContentType();

        DocumentReader reader;
        if (contentType.contains("pdf")) {
            reader = new PdfDocumentReader(filePath);
        } else if (contentType.contains("word")) {
            reader = new WordDocumentReader(filePath);
        } else if (contentType.contains("markdown")) {
            reader = new MarkdownDocumentReader(filePath);
        } else {
            throw new BusinessException("不支持的文件类型：" + contentType);
        }

        return reader.read();
    }

    private List<org.springframework.ai.document.Document> splitDocument(
        org.springframework.ai.document.Document document) {

        DocumentSplitter splitter = new TokenTextSplitter(
            500,  // chunk size
            50    // overlap
        );

        return splitter.split(document);
    }

    private String saveFile(MultipartFile file) throws IOException {
        String uploadDir = "uploads/";
        String fileName = UUID.randomUUID() + "_" + file.getOriginalFilename();
        Path filePath = Paths.get(uploadDir, fileName);

        Files.createDirectories(filePath.getParent());
        Files.write(filePath, file.getBytes());

        return filePath.toString();
    }
}

步骤3：使用Cursor实现问答功能

在Cursor中打开项目，使用Composer功能：

# 在Composer中输入：
实现智能问答功能：

1. ChatService
   - 接收用户问题
   - 使用RAG检索相关文档
   - 调用大模型生成答案
   - 保存对话历史

2. ChatController
   - POST /api/chat/ask - 同步问答
   - POST /api/chat/stream - 流式问答
   - GET /api/chat/history - 获取历史

3. DTO类
   - ChatRequest
   - ChatResponse
   - Message

4. 对话历史管理
   - 存储到Redis
   - 支持多轮对话
   - 上下文窗口管理

技术要求：
- 使用Spring AI Alibaba的ChatClient
- 支持流式响应（SSE）
- 异常处理和降级
- 添加缓存

请实现完整功能

Cursor生成的ChatService：

@Service
@Slf4j
public class ChatService {

    @Resource
    private ChatClient chatClient;

    @Resource
    private VectorStore vectorStore;

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    private static final String CHAT_HISTORY_KEY = "chat:history:";

    /**
     * 同步问答
     */
    public ChatResponse chat(ChatRequest request) {
        String sessionId = request.getSessionId();

        // 1. 加载历史对话
        List<Message> history = getHistory(sessionId);

        // 2. RAG检索相关文档
        List<Document> relevantDocs = retrieveRelevantDocs(request.getQuestion());

        // 3. 构建Prompt
        String prompt = buildPrompt(request.getQuestion(), relevantDocs, history);

        // 4. 调用大模型
        ChatResponse response = chatClient.call(
            new Prompt(prompt)
        );

        String answer = response.getResult().getOutput().getContent();

        // 5. 保存对话历史
        saveMessage(sessionId, Message.ofUser(request.getQuestion()));
        saveMessage(sessionId, Message.ofAssistant(answer));

        return ChatResponse.builder()
            .answer(answer)
            .sessionId(sessionId)
            .sources(extractSources(relevantDocs))
            .build();
    }

    /**
     * 流式问答
     */
    public Flux<String> streamChat(ChatRequest request) {
        String sessionId = request.getSessionId();

        // 1. 加载历史和检索文档（同步问答）
        List<Message> history = getHistory(sessionId);
        List<Document> relevantDocs = retrieveRelevantDocs(request.getQuestion());
        String prompt = buildPrompt(request.getQuestion(), relevantDocs, history);

        // 2. 流式调用
        Flux<ChatResponse> responseFlux = chatClient.stream(new Prompt(prompt));

        // 3. 收集完整答案用于保存
        StringBuilder fullAnswer = new StringBuilder();

        return responseFlux
            .map(response -> response.getResult().getOutput().getContent())
            .doOnNext(fullAnswer::append)
            .doOnComplete(() -> {
                // 保存对话历史
                saveMessage(sessionId, Message.ofUser(request.getQuestion()));
                saveMessage(sessionId, Message.ofAssistant(fullAnswer.toString()));
            })
            .doOnError(e -> log.error("流式问答失败", e));
    }

    private List<Document> retrieveRelevantDocs(String question) {
        // 向量检索
        List<Document> docs = vectorStore.similaritySearch(
            SearchRequest.query(question).withTopK(5)
        );

        log.info("检索到{}个相关文档片段", docs.size());
        return docs;
    }

    private String buildPrompt(String question, List<Document> docs, List<Message> history) {
        // 构建上下文
        String context = docs.stream()
            .map(Document::getContent)
            .collect(Collectors.joining("\n\n"));

        // 构建历史对话
        String historyText = history.stream()
            .map(m -> m.getRole() + ": " + m.getContent())
            .collect(Collectors.joining("\n"));

        return String.format("""
            # 角色
            你是一个智能文档问答助手，基于提供的文档内容回答用户问题。

            # 文档内容
            %s

            # 历史对话
            %s

            # 用户问题
            %s

            # 要求
            1. 仅基于提供的文档内容回答
            2. 如果文档中没有相关信息，明确告知用户
            3. 给出具体的文档引用
            4. 回答要准确、简洁、专业
            5. 如果有历史对话，保持上下文连贯性
            """, context, historyText, question);
    }

    private List<Message> getHistory(String sessionId) {
        String key = CHAT_HISTORY_KEY + sessionId;
        return (List<Message>) redisTemplate.opsForValue().get(key);
    }

    private void saveMessage(String sessionId, Message message) {
        String key = CHAT_HISTORY_KEY + sessionId;
        List<Message> history = getHistory(sessionId);
        if (history == null) {
            history = new ArrayList<>();
        }
        history.add(message);

        // 只保留最近10轮对话
        if (history.size() > 20) {
            history = history.subList(history.size() - 20, history.size());
        }

        redisTemplate.opsForValue().set(key, history, 30, TimeUnit.MINUTES);
    }

    private List<DocumentSource> extractSources(List<Document> docs) {
        return docs.stream()
            .map(doc -> DocumentSource.builder()
                .content(doc.getContent().substring(0, Math.min(100, doc.getContent().length())))
                .fileName(doc.getMetadata().get("fileName"))
                .build())
            .collect(Collectors.toList());
    }
}

Cursor同时生成的Controller：

@RestController
@RequestMapping("/api/chat")
@Slf4j
public class ChatController {

    @Resource
    private ChatService chatService;

    /**
     * 同步问答
     */
    @PostMapping("/ask")
    public Result<ChatResponse> ask(@Valid @RequestBody ChatRequest request) {
        log.info("收到问答请求：{}", request.getQuestion());
        ChatResponse response = chatService.chat(request);
        return Result.success(response);
    }

    /**
     * 流式问答
     */
    @PostMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<String>> stream(@Valid @RequestBody ChatRequest request) {
        log.info("收到流式问答请求：{}", request.getQuestion());

        return chatService.streamChat(request)
            .map(content -> ServerSentEvent.<String>builder()
                .data(content)
                .build())
            .doOnError(e -> log.error("流式响应错误", e))
            .doOnComplete(() -> log.info("流式响应完成"));
    }

    /**
     * 获取对话历史
     */
    @GetMapping("/history/{sessionId}")
    public Result<List<Message>> getHistory(@PathVariable String sessionId) {
        List<Message> history = chatService.getHistory(sessionId);
        return Result.success(history);
    }

    /**
     * 清除对话历史
     */
    @DeleteMapping("/history/{sessionId}")
    public Result<Void> clearHistory(@PathVariable String sessionId) {
        chatService.clearHistory(sessionId);
        return Result.success();
    }
}

5.3 使用Claude Code生成测试

claude "
为ChatService生成完整的单元测试：

要求：
1. 使用JUnit 5 + Mockito
2. 测试所有public方法
3. 包含正常和异常场景
4. Mock所有依赖
5. 测试覆盖率达到90%

请生成ChatServiceTest.java
"

Claude生成的测试代码：

@SpringBootTest
@ExtendWith(MockitoExtension.class)
class ChatServiceTest {

    @InjectMocks
    private ChatService chatService;

    @Mock
    private ChatClient chatClient;

    @Mock
    private VectorStore vectorStore;

    @Mock
    private RedisTemplate<String, Object> redisTemplate;

    private ChatRequest request;
    private List<Document> mockDocs;

    @BeforeEach
    void setUp() {
        request = ChatRequest.builder()
            .sessionId("test-session")
            .question("什么是Spring Boot？")
            .build();

        mockDocs = Arrays.asList(
            new Document("Spring Boot是一个快速开发框架..."),
            new Document("Spring Boot提供了自动配置...")
        );
    }

    @Test
    @DisplayName("同步问答 - 正常场景")
    void testChatSuccess() {
        // Given
        when(vectorStore.similaritySearch(any()))
            .thenReturn(mockDocs);

        ChatResponse mockResponse = new ChatResponse();
        mockResponse.setResult(new Generation("Spring Boot是..."));
        when(chatClient.call(any(Prompt.class)))
            .thenReturn(mockResponse);

        when(redisTemplate.opsForValue()).thenReturn(mock(ValueOperations.class));

        // When
        ChatResponse response = chatService.chat(request);

        // Then
        assertNotNull(response);
        assertNotNull(response.getAnswer());
        verify(vectorStore).similaritySearch(any());
        verify(chatClient).call(any(Prompt.class));
    }

    @Test
    @DisplayName("同步问答 - 无相关文档")
    void testChatNoRelevantDocs() {
        // Given
        when(vectorStore.similaritySearch(any()))
            .thenReturn(Collections.emptyList());

        ChatResponse mockResponse = new ChatResponse();
        mockResponse.setResult(new Generation("抱歉，没有找到相关信息"));
        when(chatClient.call(any(Prompt.class)))
            .thenReturn(mockResponse);

        when(redisTemplate.opsForValue()).thenReturn(mock(ValueOperations.class));

        // When
        ChatResponse response = chatService.chat(request);

        // Then
        assertNotNull(response);
        assertTrue(response.getAnswer().contains("没有找到"));
    }

    @Test
    @DisplayName("流式问答 - 正常场景")
    void testStreamChatSuccess() {
        // Given
        when(vectorStore.similaritySearch(any()))
            .thenReturn(mockDocs);

        Flux<ChatResponse> mockFlux = Flux.just(
            createChatResponse("Spring "),
            createChatResponse("Boot "),
            createChatResponse("是...")
        );
        when(chatClient.stream(any(Prompt.class)))
            .thenReturn(mockFlux);

        when(redisTemplate.opsForValue()).thenReturn(mock(ValueOperations.class));

        // When
        Flux<String> resultFlux = chatService.streamChat(request);

        // Then
        StepVerifier.create(resultFlux)
            .expectNext("Spring ")
            .expectNext("Boot ")
            .expectNext("是...")
            .verifyComplete();
    }

    @Test
    @DisplayName("问答失败 - 大模型异常")
    void testChatLLMError() {
        // Given
        when(vectorStore.similaritySearch(any()))
            .thenReturn(mockDocs);

        when(chatClient.call(any(Prompt.class)))
            .thenThrow(new RuntimeException("API调用失败"));

        // When & Then
        assertThrows(BusinessException.class, () -> {
            chatService.chat(request);
        });
    }

    @Test
    @DisplayName("测试对话历史管理")
    void testConversationHistory() {
        // Given
        ValueOperations<String, Object> valueOps = mock(ValueOperations.class);
        when(redisTemplate.opsForValue()).thenReturn(valueOps);

        List<Message> existingHistory = Arrays.asList(
            Message.ofUser("之前的问题"),
            Message.ofAssistant("之前的回答")
        );
        when(valueOps.get(anyString())).thenReturn(existingHistory);

        when(vectorStore.similaritySearch(any())).thenReturn(mockDocs);
        ChatResponse mockResponse = new ChatResponse();
        mockResponse.setResult(new Generation("新的回答"));
        when(chatClient.call(any(Prompt.class))).thenReturn(mockResponse);

        // When
        chatService.chat(request);

        // Then
        verify(valueOps, times(2)).set(anyString(), anyList(), anyLong(), any());
    }

    private ChatResponse createChatResponse(String content) {
        ChatResponse response = new ChatResponse();
        response.setResult(new Generation(content));
        return response;
    }
}

5.4 项目总结

开发效率对比：

任务	传统开发	AI辅助开发	效率提升
项目初始化	2小时	10分钟	12倍
文档上传功能	4小时	30分钟	8倍
问答功能	6小时	45分钟	8倍
单元测试	4小时	20分钟	12倍
总计	16小时	1小时45分钟	约9倍

工具使用分工：

6. 最佳实践与进阶技巧

6.1 工具组合使用策略

6.1.1 开发工作流

6.1.2 典型场景分工

场景1：新功能开发

# 阶段1：架构设计（Claude Code）
claude "
设计一个商品推荐系统：
- 基于用户行为
- 协同过滤算法
- 实时推荐
给出架构设计和技术选型
"

# 阶段2：实现核心逻辑（Cursor Composer）
# 在Cursor中：实现推荐算法、数据处理、API接口

# 阶段3：细节优化（Cursor Cmd+K）
# 选中代码，Cmd+K："优化这个算法的性能"

# 阶段4：测试编写（Claude Code或Cursor）
# 生成完整的单元测试和集成测试

场景2：代码重构

# 阶段1：分析现状（Claude Code）
claude "
@Codebase 分析订单模块的代码质量，给出重构建议
"

# 阶段2：执行重构（Cursor Composer）
# 在Composer中：按照建议重构多个文件

# 阶段3：验证测试（Claude Code）
claude "运行所有测试，确保重构没有破坏功能"

场景3：Bug修复

# 阶段1：问题诊断（Cursor Chat）
@Codebase 为什么订单创建后状态没有正确更新？

# 阶段2：修复（Cursor Cmd+K）
# 选中问题代码，描述修复方案

# 阶段3：验证（Claude Code）
claude "
为这个bug修复：
1. 生成测试用例重现问题
2. 验证修复有效
3. 检查是否有类似问题
"

6.2 Prompt最佳实践

6.2.1 通用Prompt模板

完整Prompt结构：

# 角色定位
你是{{角色描述}}，擅长{{技能列表}}

# 任务目标
{{清晰的目标描述}}

# 上下文信息
- 项目：{{项目信息}}
- 技术栈：{{技术栈列表}}
- 当前状态：{{现状说明}}

# 具体要求
1. {{要求1}}
2. {{要求2}}
3. {{要求3}}

# 约束条件
- 必须：{{必须满足的条件}}
- 禁止：{{禁止事项}}
- 优先级：{{优先级排序}}

# 期望输出
- 格式：{{输出格式}}
- 内容：{{输出内容要求}}
- 质量：{{质量标准}}

# 参考示例（可选）
{{示例代码或文档}}

6.2.2 不同场景的Prompt策略

代码生成场景：

✓ 明确技术栈和版本
✓ 提供代码风格示例
✓ 说明业务上下文
✓ 列出功能需求
✓ 指定异常处理
✓ 要求添加注释

代码审查场景：

✓ 说明审查重点（安全/性能/规范）
✓ 提供编码规范参考
✓ 要求给出具体修改建议
✓ 说明项目背景
✓ 指定输出格式

问题排查场景：

✓ 完整的错误信息
✓ 环境信息
✓ 复现步骤
✓ 已尝试的方案
✓ 相关代码片段

6.3 代码质量保证

6.3.1 AI生成代码的Review检查清单

在这里插入图片描述

自动化检查脚本：

#!/bin/bash
# ai-code-check.sh

echo "🔍 AI生成代码质量检查..."

# 1. 代码规范检查
echo "📋 检查代码规范..."
mvn checkstyle:check

# 2. 静态代码分析
echo "🔬 静态代码分析..."
mvn spotbugs:check

# 3. 安全扫描
echo "🔒 安全漏洞扫描..."
mvn dependency-check:check

# 4. 单元测试
echo "🧪 运行单元测试..."
mvn test

# 5. 测试覆盖率
echo "📊 检查测试覆盖率..."
mvn jacoco:check

# 6. 构建检查
echo "🔨 执行构建..."
mvn clean package

echo "✅ 检查完成！"

6.3.2 持续集成AI代码

# .github/workflows/ai-code-check.yml
name: AI Code Quality Check

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  check:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Code Style Check
        run: mvn checkstyle:check

      - name: Security Scan
        run: mvn dependency-check:check

      - name: Run Tests
        run: mvn test

      - name: Code Coverage
        run: mvn jacoco:report

      - name: Upload Coverage
        uses: codecov/codecov-action@v3

      - name: SonarQube Analysis
        run: mvn sonar:sonar
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

6.4 成本优化

6.4.1 Token使用优化

Prompt优化示例：

# ❌ Token浪费的Prompt
claude "
请帮我看一下这个项目的所有代码，然后告诉我有什么问题，
需要怎么优化，最好能给我详细的解释，包括为什么要这样改，
改了之后有什么好处，有没有什么风险，等等等等...
"

# ✅ Token优化的Prompt
claude "
审查订单模块代码，重点：
1. 性能问题
2. 安全漏洞
3. 代码规范

输出格式：
| 文件 | 问题 | 严重程度 | 修复建议 |
"

6.4.2 模型选择策略

任务类型	推荐模型	成本	原因
代码补全	Fast / Haiku	低	高频调用，需要速度
简单重构	GPT-3.5 / Haiku	低	任务简单，无需强推理
复杂设计	Claude 3.5 / GPT-4	高	需要强推理能力
代码审查	Claude 3.5	中高	需要深度理解
文档生成	GPT-3.5	低	主要是格式化输出

6.5 团队协作

6.5.1 共享Prompt库

team-prompts/
├── code-generation/
│   ├── spring-controller.md
│   ├── service-layer.md
│   └── repository.md
├── code-review/
│   ├── security-check.md
│   ├── performance-review.md
│   └── style-check.md
├── testing/
│   ├── unit-test.md
│   └── integration-test.md
└── documentation/
    ├── api-doc.md
    └── readme.md

6.5.2 共享Skills和Hooks

# team-skills/code-review/skill.yaml
name: team-code-review
description: 团队代码审查标准
version: 1.0.0
author: team

checklist:
  security:
    - SQL注入检查
    - XSS防护
    - 敏感信息加密
  performance:
    - 数据库查询优化
    - 缓存使用
    - 资源释放
  standards:
    - 阿里巴巴Java规范
    - 团队命名规范
    - 注释完整性

6.5.3 团队最佳实践

# 团队AI Coding规范

## 1. Prompt规范
- 使用团队Prompt模板
- 包含技术栈和版本信息
- 明确代码规范要求

## 2. 代码Review
- AI生成的代码必须人工Review
- 关注安全和性能
- 验证业务逻辑正确性

## 3. 测试要求
- AI生成代码必须有测试
- 测试覆盖率≥80%
- 关键路径100%覆盖

## 4. 文档要求
- 复杂逻辑添加注释
- 更新API文档
- 记录AI辅助开发的决策

## 5. 版本控制
- 原子性提交
- 清晰的commit message
- 标注AI辅助生成

6.6 进阶技巧

6.6.1 自定义Agent开发

使用Claude Agent SDK开发自定义Agent：

// custom-agent.ts
import { Agent, Tool } from '@anthropic-ai/agent-sdk';

class JavaCodeReviewAgent extends Agent {
  name = 'java-code-reviewer';
  description = '专业的Java代码审查助手';

  tools: Tool[] = [
    {
      name: 'checkstyle',
      description: '运行Checkstyle检查',
      execute: async (file: string) => {
        // 执行Checkstyle
        return await runCheckstyle(file);
      }
    },
    {
      name: 'spotbugs',
      description: '运行SpotBugs分析',
      execute: async (file: string) => {
        return await runSpotBugs(file);
      }
    }
  ];

  async process(input: string): Promise<string> {
    // 1. 分析代码
    const analysis = await this.analyzeCode(input);

    // 2. 运行工具检查
    const checkstyleResult = await this.useTool('checkstyle', input);
    const spotbugsResult = await this.useTool('spotbugs', input);

    // 3. 生成报告
    return this.generateReport(analysis, checkstyleResult, spotbugsResult);
  }
}

6.6.2 MCP Server集成

创建自定义MCP Server扩展Claude Code能力：

// mcp-server.ts
import { MCPServer } from '@anthropic-ai/mcp-sdk';

const server = new MCPServer({
  name: 'java-dev-server',
  version: '1.0.0'
});

// 注册工具：Maven命令
server.registerTool({
  name: 'maven',
  description: '执行Maven命令',
  parameters: {
    command: {
      type: 'string',
      description: 'Maven命令（如clean, test, package）'
    }
  },
  handler: async ({ command }) => {
    const result = await exec(`mvn ${command}`);
    return result;
  }
});

// 注册资源：项目信息
server.registerResource({
  name: 'project-info',
  description: '获取项目信息',
  handler: async () => {
    const pom = await readPomXml();
    return {
      groupId: pom.groupId,
      artifactId: pom.artifactId,
      version: pom.version,
      dependencies: pom.dependencies
    };
  }
});

server.start();

附录

A. 快速参考

A.1 Claude Code常用命令

# 启动Claude Code
claude

# 指定任务执行
claude "任务描述"

# 使用特定Skill
claude /skill-name

# 查看帮助
claude --help

# 查看版本
claude --version

A.2 Cursor快捷键

功能	Mac	Windows/Linux
打开Chat	Cmd+L	Ctrl+L
打开Composer	Cmd+Shift+L	Ctrl+Shift+L
内联编辑	Cmd+K	Ctrl+K
Tab补全	Tab	Tab
接受建议	Tab	Tab
部分接受	Cmd+→	Ctrl+→
拒绝建议	Esc	Esc

A.3 常用Prompt模板

1. 代码生成模板

实现{{功能}}：

技术栈：
- {{框架}} {{版本}}
- {{依赖列表}}

要求：
1. {{要求1}}
2. {{要求2}}
3. 遵循{{规范}}
4. 添加完整注释
5. 包含异常处理

输出：
- 完整实现代码
- 使用说明
- 测试用例

2. 代码审查模板

审查以下代码：

关注点：
- 安全性（SQL注入、XSS等）
- 性能（查询优化、资源管理）
- 代码质量（命名、结构、注释）
- 最佳实践

代码：
{{language}}
{{code}}


输出格式：
| 问题 | 严重程度 | 位置 | 建议 |

3. Bug修复模板

问题：{{问题描述}}

环境：
- OS: {{操作系统}}
- Java: {{版本}}
- 框架: {{框架及版本}}

错误信息：

{{stack trace}}


已尝试：
- {{尝试1}}
- {{尝试2}}

请提供：
1. 根本原因分析
2. 修复方案
3. 预防措施

B. 学习资源

B.1 官方文档

Claude Code: https://docs.anthropic.com/claude-code
Cursor: https://cursor.sh/docs
Anthropic API: https://docs.anthropic.com/

B.2 社区资源

GitHub Discussions
Discord社区
技术博客

B.3 推荐阅读

《The Pragmatic Programmer》
《Clean Code》
《Refactoring》

结语

AI Coding不是替代开发者，而是让开发者专注于更有价值的工作：

✅ 架构设计和技术决策
✅ 业务逻辑理解和创新
✅ 代码质量把控和优化
✅ 团队协作和知识传承

开始你的AI Coding之旅：

选择一个工具（推荐从Cursor开始）
完成一个小项目练手
总结个人Prompt模板
分享经验，持续学习

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

制造业AI模型场景泛化迭代升级：从单点算法到企业级智能体协同的技术演进路径与方案测评

AI Agent技术社区

快消AI Agent落地：从有没有AI到AI能不能产出可考核结论

AI Agent技术社区

企业如何管理Token消耗？

AI Agent技术社区

所有评论(0)

查看更多评论

lhrimperial

@u013857458

已为社区贡献3条内容

AI Coding工具实战指南：Claude Code & Cursor深度实践

lhrimperial

目录

1. AI Coding：编程范式的革命

1.1 什么是AI Coding？

1.2 AI Coding的核心价值

1.3 AI Coding vs 传统IDE辅助

2. 主流AI Coding工具全景对比

2.1 市场格局概览

2.2 详细对比矩阵

2.2.1 核心功能对比

2.2.2 技术特点对比

2.2.3 选择决策树

2.3 工具组合建议

3. Claude Code深度实践

3.1 Claude Code核心概念

3.1.1 架构设计

3.1.2 工作流程

3.2 核心工具详解

3.2.1 文件操作工具

3.2.2 搜索工具

3.2.3 Task工具 - 子代理系统

3.3 Prompt Engineering for Claude Code

3.3.1 有效Prompt的结构

3.3.2 Prompt模板库

3.3.3 进阶Prompt技巧

3.4 Skills - 自定义技能扩展

3.4.1 什么是Skills？

3.4.2 Skill的结构

3.4.3 实用Skills示例

生成Postman Collection

3.5 Hooks - 工作流钩子

3.5.1 什么是Hooks？

3.5.2 可用的Hook类型

3.5.3 实用Hook示例

3.6 Agent模式 - 高级用法

3.6.1 什么是Agent模式？

3.6.2 Agent工作示例

3.6.3 Agent模式的能力边界

3.6.4 Agent最佳实践

4. Cursor深度实践

4.1 Cursor核心特性

4.1.1 架构设计

4.2 核心功能详解

4.2.1 Tab - 智能补全

4.2.2 Cmd+K - 内联编辑

4.2.3 Chat - 对话式编程

4.2.4 Composer - 多文件编辑

4.3 Cursor配置优化

4.3.1 模型选择

4.3.2 自定义规则

5. 实战案例：构建Spring Boot AI应用

5.1 项目背景

5.2 使用Claude Code进行架构设计

步骤1：初始化项目结构

步骤2：实现文档上传功能

步骤3：使用Cursor实现问答功能

5.3 使用Claude Code生成测试

5.4 项目总结

6. 最佳实践与进阶技巧

6.1 工具组合使用策略

6.1.1 开发工作流

6.1.2 典型场景分工

6.2 Prompt最佳实践

6.2.1 通用Prompt模板

6.2.2 不同场景的Prompt策略

6.3 代码质量保证

6.3.1 AI生成代码的Review检查清单

6.3.2 持续集成AI代码

6.4 成本优化

6.4.1 Token使用优化

6.4.2 模型选择策略

6.5 团队协作

6.5.1 共享Prompt库

6.5.2 共享Skills和Hooks

6.5.3 团队最佳实践

6.6 进阶技巧

6.6.1 自定义Agent开发

6.6.2 MCP Server集成

附录