一、让 AI 为你生成单元测试和边界测试用例
为什么需要边界测试？
- 单元测试只覆盖正常场景，边界测试（如
null、极值、异常输入）能暴露隐藏 Bug。 - AI 容易遗漏边界情况，必须明确要求才会生成。
📌 操作步骤（分工具说明）
1. GitHub Copilot（适用于 VS Code、JetBrains IDE 等）
适用场景：在代码编写时实时生成测试用例。
步骤：
- 编写被测函数（例如一个计算器函数）：
def divide(a, b):
if b == 0:
raise ValueError("Cannot divide by zero")
return a / b
- 在测试文件中用注释明确要求边界测试：
# 测试 divide 函数，包括正常情况、除数为 0、除数为极小值、被除数为 0 等边界情况
def test_divide():
# 正常情况
assert divide(10, 2) == 5.0
# 边界情况 1：除数为 0，应抛出异常
try:
divide(10, 0)
assert False, "Expected ValueError"
except ValueError:
pass
# 边界情况 2：除数为极小值（接近 0 的浮点数）
assert abs(divide(1, 1e-10) - 1e10) < 1e-5
# 边界情况 3：被除数为 0
assert divide(0, 5) == 0.0
关键技巧：
- 注释中 明确列出边界场景（如
除数为 0、极小值），Copilot 会针对性生成。 - 如果生成的测试不全，迭代补充注释，例如再加
// 测试负数除法。
- 运行测试验证
用
pytest或unittest运行，确保覆盖边界。
2. JetBrains AI Assistant（IntelliJ、PyCharm、WebStorm 等）
适用场景：通过 IDE 原生功能，一键生成全覆盖测试。
步骤：
-
打开需要测试的类/函数（如
Calculator.java）。 -
右键点击函数/类 → AI Assistant → Generate Tests。
-
在弹出的对话框中 明确要求边界测试：
- Prompt 示例（在输入框中填写）：
生成 JUnit 5 测试类，覆盖以下场景：
-
正常整数除法（10/2）
-
除数为 0（期望抛出
ArithmeticException） -
除数为极小浮点数（1e-10）
-
被除数为最大值（Double.MAX_VALUE）
-
除数为负数（-2）
-
AI 会生成类似以下代码：
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class CalculatorTest {
@Test
void testNormalDivision() {
assertEquals(5.0, Calculator.divide(10, 2));
}
@Test
void testDivideByZero() {
assertThrows(ArithmeticException.class, () -> Calculator.divide(10, 0));
}
@Test
void testDivideByVerySmallNumber() {
assertEquals(1e10, Calculator.divide(1, 1e-10), 1e-5);
}
}
- 手动补充业务边界 AI 可能漏掉业务特定边界（如'用户年龄不能小于 0'），需手动添加。
3. Cursor（独立代码编辑器）
适用场景：通过自然语言聊天界面生成测试。
步骤：
- 打开 Cursor，加载项目。
- 在编辑器底部的 AI Chat 面板 输入：
为 UserService.createUser 方法生成 Jest 测试，用例要求：
- 正常创建（姓名、邮箱有效）
- 邮箱格式错误（应抛出
ValidationError） - 姓名超过 50 字符（边界测试）
- 空对象传入（边界测试）
- Cursor 会生成测试文件：
// userService.test.js
import { createUser } from './userService';
test('正常创建用户', () => {
const user = createUser({ name: '张三', email: '[email protected]' });
expect(user.id).toBeDefined();
});
test('邮箱格式错误', () => {
expect(() => createUser({ name: '李四', email: 'invalid' }))
.toThrow('ValidationError');
});
test('姓名超过 50 字符', () => {
const longName = 'a'.repeat(51);
expect(() => createUser({ name: longName, email: '[email protected]' }))
.toThrow('Name too long');
});
- 直接在编辑器中运行测试
Cursor 集成终端，一键执行
npm test。
二、让 AI 解释一段复杂的遗留代码
常见痛点
- 遗留代码无注释、命名混乱、逻辑扭曲。
- AI 可能生成表面解释，需引导它深入分析。
📌 操作步骤
1. GitHub Copilot
步骤：
- 在代码上方添加结构化注释，而非简单'解释这段代码'：
# 请逐行解释该函数的逻辑，重点说明：
# 1. 输入参数的作用和约束
# 2. 关键算法（如状态机、递归）
# 3. 可能的边界条件和 Bug 风险
# 4. 与其他模块的交互（如全局变量、外部调用）
def legacy_calculator(x, y, op):
if op == 'add':
return x + y
elif op == 'sub':
if x < y:
# 遗留代码中常见的反直觉逻辑
return 0 - (x - y)
return x - y
else:
return None
- Copilot 会生成详细解释：
参数说明：
x,y: 数字类型，未做类型检查，可能导致TypeError。op: 字符串，仅支持'add'和'sub'，其他值返回None。
逻辑分析：
- 当
op='sub'且x < y时，公式为0 - (x - y)，等同于y - x。这可能是历史 Bug 修复的遗留，实际应直接返回y - x。 - 风险点：若
x或y为浮点数，比较x < y可能因精度问题出错。
边界测试建议：
- 测试
x=0, y=0 - 测试
x=1e-16, y=2e-16（浮点数边界）
2. JetBrains AI Assistant
步骤：
- 选中代码块（例如 50 行复杂的 Java 逻辑）。
- 右键 → AI Assistant → Explain Code。
- 在弹出的解释面板中，点击'深入分析'（或手动追加提示词）：
- Prompt 补充（在 AI 面板的输入框）：
请分析该函数的 时间复杂度，并指出 潜在性能瓶颈。
同时说明，如果要重构为异步逻辑，哪些部分需要修改。
- AI 会返回结构化报告，例如：
时间复杂度：O(n²)，因内部有两层循环。
瓶颈点：for (int i=0; i<n; i++) { for (int j=0; j<n; j++) { ... } }
重构建议：
- 将内层循环改为使用
Map查找，降至 O(n)。 - 注意：第 20 行的
data.get(i)可能返回null，需添加空指针判断。
3. Cursor
步骤：
- 高亮遗留代码 → 右键 → Ask AI to Explain。
- 在 AI 面板中使用 分步提问：
- 第一轮：> 请用一句话总结该函数的目的。
- 第二轮：> 请画出该函数的流程图（Cursor 支持 Mermaid 图表）。
- 第三轮：> 该函数中，
flag变量的生命周期是多少？它什么时候被重置？
- 导出解释为 Markdown
Cursor 可将解释保存为
.md文件，方便团队共享。
三、让 AI 帮你进行代码重构和优化
重构原则
- 不改变外部行为，只优化内部结构。
- AI 可能过度优化，务必保留必要的注释。
📌 操作步骤
1. GitHub Copilot
步骤：
- 在代码上方写目标导向的注释：
// 重构该函数：
// 1. 将 SQL 查询提取为独立方法
// 2. 使用 Stream API 替代 for-loop
// 3. 添加空数据检查，避免 NPE
// 4. 保持原有接口不变
public List<User> getActiveUsers(List<User> allUsers) {
List<User> active = new ArrayList<>();
for (User u : allUsers) {
if (u.getStatus().equals("active")) {
active.add(u);
}
}
String sql = "SELECT * FROM users WHERE status = 'active'";
// ... 执行 SQL（实际上这段逻辑冗余，仅为示例）
return active;
}
- Copilot 生成重构后代码：
public List<User> getActiveUsers(List<User> allUsers) {
if (allUsers == null) return Collections.emptyList();
// 提取 SQL 为独立方法（即使实际未用，也按要求）
String activeSql = getActiveUsersSql();
return allUsers.stream()
.filter(u -> "active".equals(u.getStatus()))
.collect(Collectors.toList());
}
private String getActiveUsersSql() {
return "SELECT * FROM users WHERE status = 'active'";
}
- 手动验证
- 运行单元测试确保行为一致。
- 检查性能：Stream API 在大数据量下可能更慢，需根据场景选择。
2. JetBrains AI Assistant
步骤：
- 选中需重构的代码块。
- 右键 → AI Assistant → Refactor This Code。
- 精确指定重构目标（在提示框中输入）：
目标：
- 将循环替换为 Java Stream
- 提取
validateInput方法，处理null和空集合 - 移除未使用的变量
legacyFlag - 保持原有异常抛出逻辑
-
AI 生成 diff 对比：
-
一键应用修改 点击 Apply 即可直接修改代码。务必先备份或提交到 Git。
3. Cursor
步骤：
- 在代码旁边新建一个 临时分支（避免直接修改主分支）。
- 在 AI Chat 输入：
请重构 processData 函数：
- 将
for循环改为Promise.all（异步化） - 使用 TypeScript 类型注解
- 限制并发数为 5（避免 DDoS）
- 输出重构前/后对比
- Cursor 会生成完整重构代码，并标注关键变化：
// 重构前
async function processData(items) {
const results = [];
for (const item of items) {
results.push(await fetchData(item));
}
return results;
}
// 重构后（限并发 + 类型）
async function processData<T>(items: T[]): Promise<ReturnType<typeof fetchData>[]> {
const results: ReturnType<typeof fetchData>[] = [];
// 使用 p-limit 限制并发
const limit = pLimit(5);
const limitedFetch = items.map(item => () => fetchData(item));
return await Promise.all(limitedFetch.map(fn => limit(fn)));
}
- 运行性能测试 Cursor 集成 Benchpress，一键测试重构前后耗时。
四、用自然语言描述需求，让 AI 生成基础的 CRUD 码，你在此基础上进行业务逻辑开发
核心思路
- 先生成脚手架（模型、路由、基础增删改查），再手动添加业务逻辑（权限、事务、校验）。
- 明确指定技术栈，否则 AI 可能生成错误框架（如要求 Spring Boot 但生成 Django）。
📌 操作步骤
1. GitHub Copilot
步骤：
- 新建文件，输入自然语言需求：
# 使用 FastAPI + SQLAlchemy 生成 User CRUD：
# - 数据库表：users（id, username, email, created_at）
# - 包含：创建、查询单个、查询所有、更新、删除
# - 验证：username 长度 3-20，email 必须包含 @
# - 返回 JSON，包含状态码和消息
- Copilot 生成基础代码：
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, field_validator
from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.orm import sessionmaker, declarative_base
from datetime import datetime
app = FastAPI()
Base = declarative_base()
engine = create_engine("sqlite:///./test.db")
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
class UserBase(BaseModel):
username: str
email: str
@field_validator('username')
def validate_username(cls, v):
if len(v) < 3 or len(v) > 20:
raise ValueError('用户名长度必须在 3-20 之间')
return v
@field_validator('email')
def validate_email(cls, v):
if '@' not in v:
raise ValueError('邮箱格式无效')
return v
class UserCreate(UserBase): pass
():
:
created_at: datetime
:
orm_mode =
():
__tablename__ =
= Column(Integer, primary_key=, index=)
username = Column(String, unique=, index=)
email = Column(String, index=)
created_at = Column(DateTime, default=datetime.utcnow)
Base.metadata.create_all(bind=engine)
():
db = SessionLocal()
:
db
:
db.close()
():
db_user = UserModel(username=user.username, email=user.email)
db.add(db_user)
db.commit()
db.refresh(db_user)
db_user
- 在此基础上添加业务逻辑
例如，在
create_user中加入唯一性检查：
@app.post("/users/", response_model=User)
def create_user(user: UserCreate, db: Session = Depends(get_db)):
# 业务逻辑：检查用户名是否已存在
existing = db.query(UserModel).filter(UserModel.username == user.username).first()
if existing:
raise HTTPException(status_code=400, detail="用户名已存在")
db_user = UserModel(username=user.username, email=user.email)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
2. JetBrains AI Assistant
步骤：
- 新建一个 Spring Boot 项目（或选择现有项目）。
- 在任意空白位置右键 → AI Assistant → Generate Code from Description。
- 输入自然语言需求：
使用 Spring Boot + JPA 生成 Product 资源的 CRUD REST API。
数据库表：products（id, name, price, stock, created_at）
要求：
- 使用 Lombok 简化代码
- 添加全局异常处理（
ProductNotFoundException） - Swagger 文档支持
- 不生成测试代码（先专注核心逻辑）
- AI 会自动生成：
Product.java（实体类，含 Lombok 注解）ProductRepository.java（JPA Repository）ProductController.java（REST 控制器，含 CRUD）GlobalExceptionHandler.java（异常处理）application.yml中的 Swagger 配置
- 手动添加业务逻辑
例如，在
ProductController.updateProduct中加入库存不能为负数的校验：
@PutMapping("/{id}")
public ResponseEntity<Product> updateProduct(@PathVariable Long id, @RequestBody ProductUpdateDTO dto) {
Product product = repository.findById(id)
.orElseThrow(() -> new ProductNotFoundException(id));
// 业务逻辑：库存不能为负数
if (dto.getStock() != null && dto.getStock() < 0) {
throw new IllegalArgumentException("库存不能为负数");
}
// ... 更新字段
return ResponseEntity.ok(repository.save(product));
}
3. Cursor
步骤：
- 在项目根目录新建
prompt.txt，写入需求：
项目：Node.js + Express + Mongoose
实体：Category（分类）
字段：_id, name, description, is_active, created_at
需求：
- 生成完整 CRUD 路由（/api/categories）
- 使用 async/await
- 添加分页查询（页码、每页数量）
- 返回格式：{ code: 0, data: {...}, msg: '成功' }
- **不包含认证**
- 打开
prompt.txt→ 右键 → Ask AI to Generate Code。 - Cursor 生成目录结构：
src/
├── models/
│ └── Category.js
├── routes/
│ └── categoryRoutes.js
├── controllers/
│ └── categoryController.js
└── app.js
- 关键文件示例（
categoryController.js）：
const Category = require('../models/Category');
exports.createCategory = async (req, res) => {
try {
const { name, description, is_active } = req.body;
const category = await Category.create({
name,
description,
is_active: is_active || true,
});
res.json({ code: 0, data: category, msg: '创建成功' });
} catch (error) {
res.status(500).json({ code: -1, msg: error.message });
}
};
exports.getCategories = async (req, res) => {
try {
const page = parseInt(req.query.page) || 1;
const perPage = parseInt(req.query.perPage) || 10;
const skip = (page - 1) * perPage;
const categories = await Category.find({})
.skip(skip)
.(perPage)
.({ : - });
total = .();
res.({ : , : { : categories, total }, : });
} (error) {
res.().({ : -, : error. });
}
};
- 在此基础上开发业务逻辑
例如，在
updateCategory中加入只能管理员操作的逻辑（需先集成认证）：
exports.updateCategory = async (req, res) => {
// 业务逻辑：检查用户角色（假设 req.user 由认证中间件提供）
if (!req.user || req.user.role !== 'admin') {
return res.status(403).json({ code: -1, msg: '无权限操作' });
}
// ... 原有更新逻辑
};
✅ 最佳实践与注意事项
🔥 必做项（避免踩坑）
| 步骤 | 说明 |
|---|---|
| 1. 明确技术栈 | 在提示词中写明框架、语言、版本（如 Spring Boot 3.2 + Java 17）。AI 默认可能用旧版本。 |
| 2. 迭代生成 | 不要指望一次生成完美代码。先生成基础版 → 测试 → 补充需求 → 重新生成。 |
| 3. 必须写单元测试 | AI 生成的代码可能藏着边界 Bug。每个 CRUD 操作都要写测试（参考第一部分）。 |
| 4. 代码审查 | 即使 AI 生成，也要像自己写的一样审查： - 检查 SQL 注入风险 - 验证权限控制 - 确认异常处理 |
| 5. 记录 Prompt | 把有效的 Prompt 保存到项目的 PROMPTS.md 中，方便团队复用。 |
⚠️ 常见陷阱与规避方法
| 陷阱 | 规避方法 |
|---|---|
| AI 生成的测试用例不覆盖边界 | 在 Prompt 中 强制列出边界场景（如 // 测试金额为 0、负数、最大值）。 |
| 重构后行为改变 | 生成后运行原有测试，若无测试则先写测试再重构。 |
| CRUD 代码缺少业务校验 | 生成后立即添加业务逻辑，例如'订单金额不能为负'、'用户名唯一'。 |
| AI 混淆技术栈 | 每次生成前明确声明：// 使用 Vue 3 + TypeScript + Pinia。 |
💡 高级技巧
- 组合多个工具：
- 用 JetBrains AI 生成基础代码 → 用 Copilot 优化注释 → 用 Cursor 生成测试。
- 利用 AI 记忆上下文： 在同一个文件连续提问，AI 会记住之前的对话（如先问'解释这段代码'，再问'如何重构它'）。
- 批量生成文档：
用 Cursor 将 AI 解释的 Markdown 直接导出为
docs/目录，作为项目维基。
📌 总结
| 任务 | 推荐工具 | 为什么？ |
|---|---|---|
| 生成测试 | JetBrains AI Assistant | 一键生成 + 支持边界用例指定 |
| 解释遗留代码 | Cursor | 交互式提问 + 支持流程图 |
| 代码重构 | JetBrains AI Assistant | 原生 IDE 集成 + diff 预览 |
| 生成 CRUD | GitHub Copilot | 实时补全 + 高精度框架匹配 |
核心原则：AI 是助手，不是替身。
用 AI 处理 重复、低价值 的工作（如写测试、scaffolding），把时间花在 业务逻辑、架构设计 上——这才是开发者的核心竞争力。
