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

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

目录

• 1. AI Coding：编程范式的革命
• 2. 主流AI Coding工具全景对比
• 3. Claude Code深度实践
• 4. Cursor深度实践
• 5. 实战案例：构建Spring Boot AI应用
• 6. 最佳实践与进阶技巧

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

1.1 什么是AI Coding？

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

AI Coding传统编程效率提升3-5倍AI生成代码描述需求Review & 调整AI生成测试AI优化建议持续迭代查阅文档思考需求编写代码调试运行手动测试优化重构

1.2 AI Coding的核心价值

对开发者的价值：

典型应用场景：

1.3 AI Coding vs 传统IDE辅助

AI Coding传统IDE辅助进化进化理解意图智能补全上下文感知跨文件理解架构级别智能建议业务逻辑最佳实践基于语法代码补全基于已有代码编译错误错误提示语法错误

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

2.1 市场格局概览

新兴工具云服务型CLI工具型IDE集成型WindsurfSupermavenAmazon QReplit AIClaude CodeAiderCursorGitHub CopilotCodeiumTabnine

2.2 详细对比矩阵

2.2.1 核心功能对比

2.2.2 技术特点对比

Claude Code

Cursor

2.2.3 选择决策树

日常开发复杂任务团队协作有预算预算有限是否选择AI Coding工具主要用途?预算?Claude CodeGitHub Copilot熟悉VS Code?Codeium免费版Cursor尝试多个工具推荐入门推荐

2.3 工具组合建议

最佳组合方案：

开发工作流Cursor - 日常开发Claude Code - 复杂任务GitHub Copilot - 代码补全快速迭代架构设计提升效率综合效率最大化

分工建议：

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

3. Claude Code深度实践

3.1 Claude Code核心概念

3.1.1 架构设计

扩展层工具层核心引擎层用户交互层Hooks钩子MCP服务器自定义AgentBash工具文件操作Read/Write/Edit搜索工具Glob/GrepTask代理自定义SkillsClaude 4.5 Sonnet上下文管理工具调度器CLI命令行交互式对话

3.1.2 工作流程

用户Claude CLIClaude 4.5工具集文件系统输入需求传递上下文+需求分析需求调用工具（如Read）读取文件返回内容工具结果推理决策loop[思考与执行]调用Edit工具修改文件返回结果展示输出用户Claude CLIClaude 4.5工具集文件系统

3.2 核心工具详解

3.2.1 文件操作工具

1. Read工具 - 读取文件

# Claude Code会自动调用Read工具# 用户只需描述需求 claude "请分析UserService的代码质量"# Claude内部执行：# 1. Read(/path/to/UserService.java)# 2. 分析代码# 3. 给出建议

Read工具特性：

Read工具支持分页读取自动处理大文件多种文件格式代码文件配置文件图片文件PDF文档避免Token超限

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工具的工作原理：

ClaudeRead工具Edit工具文件读取文件内容读取返回内容文件内容分析需要修改的部分Edit(old_string, new_string)精确字符串匹配替换写入修改确认修改成功ClaudeRead工具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模式语法：

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"# 显示匹配次数

搜索工具组合使用：

是否文件名模式代码内容搜索任务知道文件名?直接Read文件搜索什么?使用Glob使用Grep获得文件列表获得匹配内容Read具体文件分析处理

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代理的工作流程：

用户主ClaudeTask代理文件系统"分析项目的缓存策略"判断需要深度探索启动Explore代理代理独立工作Glob搜索cache相关文件Grep搜索@CacheableRead配置文件分析整合信息返回分析结果整合到上下文输出总结报告用户主ClaudeTask代理文件系统

何时使用Task代理：

3.3 Prompt Engineering for Claude Code

3.3.1 有效Prompt的结构

有效的Prompt1. 角色定位2. 任务描述3. 上下文信息4. 具体要求5. 输出格式6. 约束条件你是资深Java架构师重构UserService项目用Spring Boot 3.2使用异步编程
添加缓存
保持向后兼容输出完整代码
添加注释说明不要破坏现有API
遵循阿里巴巴规范

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}} 错误信息： 

{{error stack trace}}

 已尝试的方案： 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:falsedefault: 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.yamlname: 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.yamlname: 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": "[email protected]", "phone": "13800138000" } **响应** ### json { "code": 200, "message": "success", "data": { "id": 1, "username": "zhangsan", "email": "[email protected]" } } 

错误码

生成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允许你在特定事件发生时自动执行命令，实现工作流自动化。

有无是否用户操作触发事件Hook配置?执行Hook命令正常流程Hook结果继续执行?中断操作

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执行流程：

用户Agent(Claude)工具集重构legacy代码Phase 1: 探索Glob(legacy/**/*.java)返回10个Java文件Read每个文件文件内容分析代码质量Phase 2: 规划制定重构计划1. 先重构工具类2. 再重构Service3. 最后重构ControllerPhase 3: 执行Edit(重构代码)Write(生成测试)Bash(运行测试)测试结果Edit(修复代码)Bash(重新测试)alt[测试失败]loop[每个文件]Phase 4: 总结生成重构报告返回完整报告用户Agent(Claude)工具集

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 - 智能补全

工作原理：

开发者CursorAI模型代码索引输入代码查询上下文相关代码片段发送上下文+当前代码返回补全建议显示补全（灰色文本）按Tab接受开发者CursorAI模型代码索引

使用技巧：

// 1. 方法签名补全// 输入：publicUser findBy // 按Tab，Cursor建议：publicUserfindByIdAndStatus(Long id,String status){return userRepository.findByIdAndStatus(id, status);}// 2. 测试用例补全// 输入：@Testvoid testUserService // 按Tab：@TestvoidtestUserServiceGetById(){// GivenLong userId =1L;User expectedUser =User.builder().id(userId).username("test").build();when(userRepository.findById(userId)).thenReturn(Optional.of(expectedUser));// WhenUser actualUser = userService.getById(userId);// ThenassertEquals(expectedUser, actualUser);}// 3. 注释生成代码// 输入注释：// 实现用户登录，包含密码加密验证和Token生成// 按Tab，生成完整实现：publicLoginResponselogin(LoginRequest request){// 验证用户名密码User user = userRepository.findByUsername(request.getUsername()).orElseThrow(()->newBusinessException("用户不存在"));// 密码加密比对if(!passwordEncoder.matches(request.getPassword(), user.getPassword())){thrownewBusinessException("密码错误");}// 生成TokenString token = jwtTokenProvider.createToken(user.getId());returnLoginResponse.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+KpublicList<User>getActiveUsers(){List<User> users =newArrayList<>();for(User user : userRepository.findAll()){if("ACTIVE".equals(user.getStatus())){ users.add(user);}}return users;}// 输入："使用Stream API重写"// Cursor自动改为：publicList<User>getActiveUsers(){return userRepository.findAll().stream().filter(user ->"ACTIVE".equals(user.getStatus())).collect(Collectors.toList());}

场景2：添加功能

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

场景3：生成测试

// 选中Service方法，Cmd+KpublicvoidcreateOrder(OrderCreateRequest request){Order order =Order.builder().userId(request.getUserId()).amount(request.getAmount()).status(OrderStatus.PENDING).build(); orderRepository.save(order);}// 输入："生成单元测试"// Cursor在测试文件中生成：@TestvoidtestCreateOrder(){// GivenOrderCreateRequest request =OrderCreateRequest.builder().userId(1L).amount(newBigDecimal("99.99")).build();// When orderService.createOrder(request);// Thenverify(orderRepository).save(argThat(order -> order.getUserId().equals(1L)&& order.getAmount().equals(newBigDecimal("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: Entity文件2: Repository文件3: Service文件4: Controller文件5: DTO文件6: Test保持一致性完成任务

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的执行过程：

用户ComposerAI引擎文件系统提交任务分析任务生成文件清单和计划显示计划给用户确认生成文件内容返回代码创建/修改文件显示进度loop[每个文件]完成，显示所有修改用户ComposerAI引擎文件系统

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模型}

模型选择建议：

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

功能模块：

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

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执行过程：

开发者Claude CodeTools提交需求分析项目结构Bash(mkdir)创建目录创建标准Maven结构Write(pom.xml)添加依赖：Spring Boot 3.2Spring AI AlibabaPostgreSQLMyBatis PlusWrite(application.yml)配置数据源AI模型向量数据库Write创建基础类BaseEntityResult包装类BusinessExceptionGlobalExceptionHandler项目骨架创建完成开发者Claude CodeTools

生成的项目结构：

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@Slf4jpublicclassDocumentService{@ResourceprivateVectorStore vectorStore;@ResourceprivateEmbeddingModel embeddingModel;@ResourceprivateDocumentRepository documentRepository;/** * 上传并处理文档 */@AsyncpublicCompletableFuture<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());returnCompletableFuture.completedFuture(entity.getId());}catch(Exception e){ log.error("文档处理失败", e);thrownewBusinessException("文档处理失败："+ e.getMessage());}}privateorg.springframework.ai.document.DocumentparseDocument(MultipartFile file,String filePath){String contentType = file.getContentType();DocumentReader reader;if(contentType.contains("pdf")){ reader =newPdfDocumentReader(filePath);}elseif(contentType.contains("word")){ reader =newWordDocumentReader(filePath);}elseif(contentType.contains("markdown")){ reader =newMarkdownDocumentReader(filePath);}else{thrownewBusinessException("不支持的文件类型："+ contentType);}return reader.read();}privateList<org.springframework.ai.document.Document>splitDocument(org.springframework.ai.document.Document document){DocumentSplitter splitter =newTokenTextSplitter(500,// chunk size50// overlap);return splitter.split(document);}privateStringsaveFile(MultipartFile file)throwsIOException{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@Slf4jpublicclassChatService{@ResourceprivateChatClient chatClient;@ResourceprivateVectorStore vectorStore;@ResourceprivateRedisTemplate<String,Object> redisTemplate;privatestaticfinalString CHAT_HISTORY_KEY ="chat:history:";/** * 同步问答 */publicChatResponsechat(ChatRequest request){String sessionId = request.getSessionId();// 1. 加载历史对话List<Message> history =getHistory(sessionId);// 2. RAG检索相关文档List<Document> relevantDocs =retrieveRelevantDocs(request.getQuestion());// 3. 构建PromptString prompt =buildPrompt(request.getQuestion(), relevantDocs, history);// 4. 调用大模型ChatResponse response = chatClient.call(newPrompt(prompt));String answer = response.getResult().getOutput().getContent();// 5. 保存对话历史saveMessage(sessionId,Message.ofUser(request.getQuestion()));saveMessage(sessionId,Message.ofAssistant(answer));returnChatResponse.builder().answer(answer).sessionId(sessionId).sources(extractSources(relevantDocs)).build();}/** * 流式问答 */publicFlux<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(newPrompt(prompt));// 3. 收集完整答案用于保存StringBuilder fullAnswer =newStringBuilder();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));}privateList<Document>retrieveRelevantDocs(String question){// 向量检索List<Document> docs = vectorStore.similaritySearch(SearchRequest.query(question).withTopK(5)); log.info("检索到{}个相关文档片段", docs.size());return docs;}privateStringbuildPrompt(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"));returnString.format(""" # 角色 你是一个智能文档问答助手，基于提供的文档内容回答用户问题。 # 文档内容 %s # 历史对话 %s # 用户问题 %s # 要求 1. 仅基于提供的文档内容回答 2. 如果文档中没有相关信息，明确告知用户 3. 给出具体的文档引用 4. 回答要准确、简洁、专业 5. 如果有历史对话，保持上下文连贯性 """, context, historyText, question);}privateList<Message>getHistory(String sessionId){String key = CHAT_HISTORY_KEY + sessionId;return(List<Message>) redisTemplate.opsForValue().get(key);}privatevoidsaveMessage(String sessionId,Message message){String key = CHAT_HISTORY_KEY + sessionId;List<Message> history =getHistory(sessionId);if(history ==null){ history =newArrayList<>();} history.add(message);// 只保留最近10轮对话if(history.size()>20){ history = history.subList(history.size()-20, history.size());} redisTemplate.opsForValue().set(key, history,30,TimeUnit.MINUTES);}privateList<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")@Slf4jpublicclassChatController{@ResourceprivateChatService chatService;/** * 同步问答 */@PostMapping("/ask")publicResult<ChatResponse>ask(@Valid@RequestBodyChatRequest request){ log.info("收到问答请求：{}", request.getQuestion());ChatResponse response = chatService.chat(request);returnResult.success(response);}/** * 流式问答 */@PostMapping(value ="/stream", produces =MediaType.TEXT_EVENT_STREAM_VALUE)publicFlux<ServerSentEvent<String>>stream(@Valid@RequestBodyChatRequest 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}")publicResult<List<Message>>getHistory(@PathVariableString sessionId){List<Message> history = chatService.getHistory(sessionId);returnResult.success(history);}/** * 清除对话历史 */@DeleteMapping("/history/{sessionId}")publicResult<Void>clearHistory(@PathVariableString sessionId){ chatService.clearHistory(sessionId);returnResult.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)classChatServiceTest{@InjectMocksprivateChatService chatService;@MockprivateChatClient chatClient;@MockprivateVectorStore vectorStore;@MockprivateRedisTemplate<String,Object> redisTemplate;privateChatRequest request;privateList<Document> mockDocs;@BeforeEachvoidsetUp(){ request =ChatRequest.builder().sessionId("test-session").question("什么是Spring Boot？").build(); mockDocs =Arrays.asList(newDocument("Spring Boot是一个快速开发框架..."),newDocument("Spring Boot提供了自动配置..."));}@Test@DisplayName("同步问答 - 正常场景")voidtestChatSuccess(){// Givenwhen(vectorStore.similaritySearch(any())).thenReturn(mockDocs);ChatResponse mockResponse =newChatResponse(); mockResponse.setResult(newGeneration("Spring Boot是..."));when(chatClient.call(any(Prompt.class))).thenReturn(mockResponse);when(redisTemplate.opsForValue()).thenReturn(mock(ValueOperations.class));// WhenChatResponse response = chatService.chat(request);// ThenassertNotNull(response);assertNotNull(response.getAnswer());verify(vectorStore).similaritySearch(any());verify(chatClient).call(any(Prompt.class));}@Test@DisplayName("同步问答 - 无相关文档")voidtestChatNoRelevantDocs(){// Givenwhen(vectorStore.similaritySearch(any())).thenReturn(Collections.emptyList());ChatResponse mockResponse =newChatResponse(); mockResponse.setResult(newGeneration("抱歉，没有找到相关信息"));when(chatClient.call(any(Prompt.class))).thenReturn(mockResponse);when(redisTemplate.opsForValue()).thenReturn(mock(ValueOperations.class));// WhenChatResponse response = chatService.chat(request);// ThenassertNotNull(response);assertTrue(response.getAnswer().contains("没有找到"));}@Test@DisplayName("流式问答 - 正常场景")voidtestStreamChatSuccess(){// Givenwhen(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));// WhenFlux<String> resultFlux = chatService.streamChat(request);// ThenStepVerifier.create(resultFlux).expectNext("Spring ").expectNext("Boot ").expectNext("是...").verifyComplete();}@Test@DisplayName("问答失败 - 大模型异常")voidtestChatLLMError(){// Givenwhen(vectorStore.similaritySearch(any())).thenReturn(mockDocs);when(chatClient.call(any(Prompt.class))).thenThrow(newRuntimeException("API调用失败"));// When & ThenassertThrows(BusinessException.class,()->{ chatService.chat(request);});}@Test@DisplayName("测试对话历史管理")voidtestConversationHistory(){// GivenValueOperations<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 =newChatResponse(); mockResponse.setResult(newGeneration("新的回答"));when(chatClient.call(any(Prompt.class))).thenReturn(mockResponse);// When chatService.chat(request);// Thenverify(valueOps,times(2)).set(anyString(),anyList(),anyLong(),any());}privateChatResponsecreateChatResponse(String content){ChatResponse response =newChatResponse(); response.setResult(newGeneration(content));return response;}}

5.4 项目总结

开发效率对比：

工具使用分工：

20%25%35%15%5%开发时间分配Claude Code - 架构设计Claude Code - 复杂逻辑Cursor - 功能开发Cursor - 测试编写人工Review

6. 最佳实践与进阶技巧

6.1 工具组合使用策略

6.1.1 开发工作流

高中低通过不通过新功能需求复杂度Claude Code - 架构设计Cursor Composer - 多文件开发Cursor Tab/Cmd+K - 快速开发生成设计文档和骨架实现核心功能Cursor - 生成测试实现功能人工Review质量检查提交代码Claude Code - 优化

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.shecho"🔍 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.ymlname: 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使用优化

优化Token使用减少输入Token减少输出Token选择合适模型精简Prompt避免重复上下文使用代码引用明确输出要求分步骤执行避免冗长解释简单任务用Fast模型复杂任务用Sonnet避免过度使用Opus

Prompt优化示例：

# ❌ Token浪费的Prompt claude " 请帮我看一下这个项目的所有代码，然后告诉我有什么问题， 需要怎么优化，最好能给我详细的解释，包括为什么要这样改， 改了之后有什么好处，有没有什么风险，等等等等... "# ✅ Token优化的Prompt claude " 审查订单模块代码，重点： 1. 性能问题 2. 安全漏洞 3. 代码规范 输出格式： | 文件 | 问题 | 严重程度 | 修复建议 | "

6.4.2 模型选择策略

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.yamlname: 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.tsimport{ Agent, Tool }from'@anthropic-ai/agent-sdk';classJavaCodeReviewAgentextendsAgent{ name ='java-code-reviewer'; description ='专业的Java代码审查助手'; tools: Tool[]=[{ name:'checkstyle', description:'运行Checkstyle检查',execute:async(file:string)=>{// 执行CheckstylereturnawaitrunCheckstyle(file);}},{ name:'spotbugs', description:'运行SpotBugs分析',execute:async(file:string)=>{returnawaitrunSpotBugs(file);}}];asyncprocess(input:string):Promise<string>{// 1. 分析代码const analysis =awaitthis.analyzeCode(input);// 2. 运行工具检查const checkstyleResult =awaitthis.useTool('checkstyle', input);const spotbugsResult =awaitthis.useTool('spotbugs', input);// 3. 生成报告returnthis.generateReport(analysis, checkstyleResult, spotbugsResult);}}

6.6.2 MCP Server集成

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

// mcp-server.tsimport{ MCPServer }from'@anthropic-ai/mcp-sdk';const server =newMCPServer({ 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 =awaitexec(`mvn ${command}`);return result;}});// 注册资源：项目信息 server.registerResource({ name:'project-info', description:'获取项目信息',handler:async()=>{const pom =awaitreadPomXml();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快捷键

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之旅：

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