GitHub Copilot、Cursor、JetBrains AI Assistant 使用实战指南

本文介绍三款主流 AI 编程助手，能显著提升开发效率。掌握它们后，可以让 AI 处理繁琐的基础工作，专注于核心业务逻辑。以下是针对 4 个核心场景 的详细操作指南，包含 具体步骤、最佳实践和注意事项。

一、让 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），把时间花在 业务逻辑、架构设计 上——这才是开发者的核心竞争力。

按照此指南操作，你将大幅提升编码效率，同时保证代码质量。

GitHub Copilot、Cursor、JetBrains AI Assistant 使用实战指南