引言

"让 AI 帮我写了个工具类，review 时发现连参数校验都没有，单测覆盖率 0%。"——这不是 AI 不行，是 prompt 不行。大部分开发者用 AI 写代码的方式是："帮我写一个 XX 工具类"——这就像跟新人说"做个订单功能"然后期望他交付生产级代码。

AI 的输出质量 = prompt 的精确度。同一个需求，"帮我写个单测"出来的测试覆盖三条路径，而"用 JUnit5 + Mockito，覆盖正常/边界/异常三个维度，覆盖率目标 90%，Mock 外部依赖"出来的测试能直接进 CI。差距不在模型能力，在 prompt 的约束密度——你把技术栈、质量标准、验收口径告诉它，它就按工程标准交付；你只说个大概，它就给你个大概的东西。

这篇文章给 Java 开发者 5 个可以直接复制粘贴的 prompt 模板，每个覆盖一个高频场景：单元测试、代码重构、性能优化、Bug 定位、技术选型。每个模板给完整示例 + 调优技巧，模板里的方括号 [...] 是你要替换的变量。

一、模板一：单元测试生成

1.1 模板

你是一个资深的 Java 开发工程师，请为以下方法生成单元测试。

【技术栈】
- JUnit 5（@ParameterizedTest + @ValueSource/@MethodSource）
- Mockito 5（@ExtendWith(MockitoExtension.class) + @Mock + @InjectMocks）
- AssertJ（assertThat 链式断言，不要用 JUnit 原生断言）

【被测方法】
[粘贴方法代码]

【依赖类】
[粘贴相关的 Service/Repository 接口定义]

【测试要求】
1. 覆盖三个维度：正常路径、边界值、异常路径
2. 边界值包括：null 参数、空集合、最大值/最小值
3. 异常路径包括：依赖抛异常时的行为验证
4. 行覆盖率目标 90%，分支覆盖率目标 80%
5. Mock 所有外部依赖（DB/缓存/RPC），被测方法本身不能 Mock
6. 每个测试方法名用 should_预期_当_条件 格式（如 should_returnEmpty_when_userIdIsNull）

【输出格式】
1. 完整的测试类代码（可直接编译运行）
2. 覆盖率自评表（哪些分支覆盖了、哪些没覆盖、为什么）

1.2 使用示例

你是一个资深的 Java 开发工程师，请为以下方法生成单元测试。

【技术栈】
- JUnit 5（@ParameterizedTest + @ValueSource/@MethodSource）
- Mockito 5（@ExtendWith(MockitoExtension.class) + @Mock + @InjectMocks）
- AssertJ（assertThat 链式断言）

【被测方法】
public class OrderService {
    public BigDecimal calculateTotal(List<OrderItem> items, String couponCode) {
        if (items == null || items.isEmpty()) {
            throw new IllegalArgumentException("订单项不能为空");
        }
        BigDecimal subtotal = items.stream()
                .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQty())))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        if (couponCode != null && !couponCode.isBlank()) {
            Coupon coupon = couponRepository.findByCode(couponCode);
            if (coupon == null) {
                throw new BusinessException("优惠券不存在: " + couponCode);
            }
            return coupon.apply(subtotal);
        }
        return subtotal;
    }
}

【依赖类】
public interface CouponRepository { Coupon findByCode(String code); }

【测试要求】
（同模板...）

1.3 调优技巧

1.4 常见问题

• AI 生成的测试编译不过：90% 是依赖类的 import 没给全——prompt 里贴方法代码时，把相关 import 也贴上
• Mock 配置和实际行为不符：AI 假设 Repository 返回 Optional，但你实际返回 null——在 prompt 里说清楚返回类型
• 测试过度耦合实现细节：AI 可能验证私有方法调用——在 prompt 里加"只测试公共 API 行为，不验证私有方法和内部调用链"

二、模板二：代码重构

2.1 模板

你是一个资深的 Java 开发工程师，请重构以下代码。

【重构目标】
应用 [策略模式/模板方法/工厂模式/Builder/组合模式] 重构，降低圈复杂度，提升可维护性。

【约束条件】
1. 保持公共 API 兼容（方法签名不变，调用方不需要改）
2. 保持现有行为不变（先写特征测试锁定行为，再重构）
3. 单个方法圈复杂度 ≤ 10
4. 遵循单一职责：一个类一个变更理由
5. 新增的类放在 [同包/子包]，命名用 [动词+名词/名词] 格式

【待重构代码】
[粘贴代码]

【当前问题】
[描述：圈复杂度高/职责混杂/重复代码/扩展困难...]

【输出格式】
1. 重构后的完整代码
2. 重构前后的对比表（改了什么、为什么改）
3. 重构后的类图关系（文字描述）
4. 扩展性说明：如果要新增一种 [XX]，只需要在哪里加什么

2.2 使用示例

你是一个资深的 Java 开发工程师，请重构以下代码。

【重构目标】
应用策略模式重构，降低圈复杂度，提升可维护性。

【约束条件】
1. 保持公共 API 兼容（calculateShipping 方法签名不变）
2. 保持现有行为不变
3. 单个方法圈复杂度 ≤ 10
4. 遵循单一职责

【待重构代码】
public class ShippingService {
    public BigDecimal calculateShipping(String region, BigDecimal weight) {
        BigDecimal fee;
        if ("DOMESTIC".equals(region)) {
            if (weight.compareTo(BigDecimal.valueOf(1)) <= 0) {
                fee = BigDecimal.valueOf(10);
            } else if (weight.compareTo(BigDecimal.valueOf(5)) <= 0) {
                fee = BigDecimal.valueOf(15);
            } else {
                fee = BigDecimal.valueOf(25);
            }
        } else if ("INTERNATIONAL".equals(region)) {
            if (weight.compareTo(BigDecimal.valueOf(1)) <= 0) {
                fee = BigDecimal.valueOf(50);
            } else if (weight.compareTo(BigDecimal.valueOf(5)) <= 0) {
                fee = BigDecimal.valueOf(80);
            } else {
                fee = BigDecimal.valueOf(150);
            }
        } else if ("REMOTE".equals(region)) {
            fee = BigDecimal.valueOf(100).add(weight.multiply(BigDecimal.valueOf(20)));
        } else {
            throw new IllegalArgumentException("未知地区: " + region);
        }
        return fee;
    }
}

【当前问题】
圈复杂度 12，if-else 嵌套 3 层，新增地区需要改这个方法（违反开闭原则）

【输出格式】
（同模板...）

2.3 调优技巧

2.4 常见问题

• AI 用了过度设计：一个 if-else 两分支也让它上策略模式——在 prompt 里加"如果分支 ≤ 2 且预期不会扩展，不需要抽象"
• 重构后性能下降：策略模式多了对象创建——在 prompt 里加"考虑性能影响，频繁调用的场景用单例或枚举实现"
• AI 擅自改了包结构：在 prompt 里明确"不改变包结构，新类放在同包或指定的子包"

三、模板三：性能优化

3.1 模板

你是一个资深的 Java 性能优化工程师，请优化以下代码的性能。

【性能瓶颈】
[描述：CPU 高/内存占用大/响应慢/GC 频繁...]

【瓶颈定位数据】
- [JFR/Arthas/火焰图数据，如：方法耗时占比 40%，其中 ArrayList.remove 占 80%]

【待优化代码】
[粘贴代码]

【优化约束】
1. 保持业务语义不变（输入输出结果不变）
2. 优先选择算法/数据结构层面的优化，而非微优化
3. 优化后用 JMH 基准测试验证（给出 benchmark 代码）
4. 列出优化前后的预期对比（吞吐量/延迟/内存）
5. 标注每项优化的适用前提（数据量级/并发度等）

【输出格式】
1. 性能瓶颈分析（根因定位）
2. 优化方案（按收益从大到小排序）
3. 优化后完整代码
4. JMH benchmark 代码
5. 预期性能对比表

3.2 使用示例

你是一个资深的 Java 性能优化工程师，请优化以下代码的性能。

【性能瓶颈】
CPU 100%，接口 P99 800ms，火焰图显示 removeIf 内部 ArrayList.remove 占 70% CPU

【瓶颈定位数据】
- 数据量：50 万条订单记录
- 瓶颈方法：filterActiveOrders 中的 ArrayList.remove(Object) 逐个删除

【待优化代码】
public List<Order> filterActiveOrders(List<Order> allOrders) {
    List<Order> result = new ArrayList<>(allOrders);
    for (Order order : allOrders) {
        if (!order.isActive()) {
            result.remove(order);  // O(n) 每次调用都 arraycopy
        }
    }
    return result;
}

【优化约束】
1. 保持业务语义不变
2. 优先选择算法/数据结构层面的优化
3. 优化后用 JMH 基准测试验证
4. 列出优化前后的预期对比
5. 标注每项优化的适用前提

【输出格式】
（同模板...）

3.3 调优技巧

3.4 常见问题

• AI 给的 JMH 代码跑不了：缺少 JMH 依赖或注解处理器配置——让 AI 补上 pom 依赖和 maven-shade-plugin 配置
• 优化方案不适用：AI 建议用并行流但你的环境是单核——在 prompt 里说清楚运行环境约束
• 优化后行为变了：AI 在优化过程中改变了逻辑——在 prompt 里加"输出优化前后的等价性证明"

四、模板四：Bug 定位

4.1 模板

你是一个资深的 Java 排障工程师，请帮我分析以下 Bug。

【异常堆栈】
[粘贴完整堆栈，不要截断]

【相关代码】
[粘贴报错方法及上下游调用链代码]

【运行环境】
- JDK 版本：[如 JDK 21]
- 框架版本：[如 Spring Boot 3.2.5]
- 并发场景：[如 200 并发/定时任务/MQ 消费]
- 数据特征：[如 50 万条数据/空数据/边界值]

【已排查方向】
- [如：已确认 DB 连接正常/已确认非 OOM/已确认 GC 正常]

【输出格式】
1. 根因分析（从堆栈逐层解读，定位到具体代码行）
2. 修复方案（完整代码，最小改动原则）
3. 防复方案（如何防止此类问题再次发生——单测/参数校验/监控）
4. 如果根因不确定，列出 Top 3 可能原因 + 验证方法

4.2 使用示例

你是一个资深的 Java 排障工程师，请帮我分析以下 Bug。

【异常堆栈】
java.util.ConcurrentModificationException
    at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1093)
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:1043)
    at com.example.OrderService.processOrders(OrderService.java:42)
    at com.example.OrderController.batchProcess(OrderController.java:28)

【相关代码】
public class OrderService {
    public void processOrders(List<Order> orders) {
        for (Order order : orders) {              // line 42
            if (order.isExpired()) {
                orders.remove(order);             // 边遍历边删
            }
            order.process();
        }
    }
}

【运行环境】
- JDK 版本：JDK 21
- 框架版本：Spring Boot 3.2.5
- 并发场景：单线程定时任务
- 数据特征：约 5000 条订单，其中有 ~200 条过期

【已排查方向】
- 已确认非多线程并发修改（单线程执行）
- 已确认数据来源不是 DB 查询结果集（是传入的 ArrayList）

【输出格式】
（同模板...）

4.3 调优技巧

4.4 常见问题

• AI 根因分析错了：AI 看到的代码不完整就猜——把上下游调用链也贴上，别只给报错那一个方法
• AI 修复方案引入新问题：AI 用 CopyOnWriteArrayList 替换——写时复制在大数据量下内存翻倍——追问"这个方案在 50 万数据量下的内存影响"
• AI 没注意到并发因素：在 prompt 里强调并发场景——"这是 200 并发下的问题"比"有性能问题"精确得多

五、模板五：技术选型

5.1 模板

你是一个资深的架构师，请帮我做技术选型分析。

【选型问题】
[如：消息队列选 Kafka 还是 RocketMQ？缓存选 Caffeine 还是 Guava？]

【业务场景】
- [业务领域：如电商订单/日志收集/金融交易]
- [数据规模：如日订单量 100 万/单条消息 ~1KB]
- [并发要求：如峰值 5000 QPS]
- [延迟要求：如 P99 < 100ms]
- [团队规模：如 5 人 Java 团队，无专职运维]
- [现有技术栈：如 Spring Boot + MySQL + Redis]

【选型约束】
- [如：不能引入新的有状态组件/必须支持 Java/优先开源]
- [如：运维成本敏感/需要可视化控制台]

【输出格式】
1. 候选方案对比表（维度：性能/可靠性/运维成本/社区活跃度/团队学习曲线/功能完整性）
2. 每个方案的核心优势和致命短板
3. 在我的场景下的推荐方案 + 推荐理由
4. 反对意见（什么场景下不该选这个方案）
5. 迁移成本评估（如果从 [现有方案] 迁移）

5.2 使用示例

你是一个资深的架构师，请帮我做技术选型分析。

【选型问题】
定时任务方案选 @Scheduled、Quartz、XXL-Job 还是 PowerJob？

【业务场景】
- 业务领域：电商订单超时取消 + 每日对账报表
- 数据规模：日订单 10 万，超时取消 2000 单
- 并发要求：定时任务峰值并发 5000 单/批
- 延迟要求：超时取消精确到分钟级
- 团队规模：8 人 Java 团队，有独立运维
- 现有技术栈：Spring Boot 3.2 + MySQL + Redis + Nacos

【选型约束】
- 多实例部署，任务不能重复执行
- 需要可视化控制台和失败告警
- 倾向开源方案

【输出格式】
（同模板...）

5.3 调优技巧

5.4 常见问题

• AI 推荐了最新的框架：新框架社区不成熟——在 prompt 里加"优先选择社区活跃 3 年以上、生产验证过的方案"
• AI 对比表维度不全：追加"增加安全性和许可证（GPL/Apache）维度"
• AI 不给明确推荐：追加"不要说'看场景'——基于我给的场景给一个明确推荐，标注置信度"

六、模板通用调优原则

6.1 五个模板的共性结构

角色设定 → 你是一个资深的 [角色]
技术约束 → 技术栈/版本/质量标准
任务输入 → 代码/堆栈/场景
输出格式 → 代码/对比表/分析
验收标准 → 覆盖率/API 兼容/JMH/明确推荐

这五个要素缺任何一个，输出质量都会下降一个档次。最常见的问题是只有"任务输入"没有"技术约束"和"验收标准"——AI 不知道你要什么标准的产出，就给你一个"通用"的结果，而通用往往不够工程级。

6.2 通用调优速查

6.3 万能追加句

# 单测追加
"帮我检查是否有遗漏的分支，特别是空指针、并发、和数值溢出场景。"

# 重构追加
"保留旧代码作为注释做对比，并说明重构后行为等价性证明。"

# 性能追加
"给出在 [1000/10万/100万] 三种数据量下的适用性分析。"

# Bug 追加
"给出最小复现代码，我需要先复现再修复。"

# 选型追加
"不要说'看场景'——基于我给的约束给一个明确推荐，标注置信度。"

七、常见问题

7.1 AI 生成的代码能直接用吗？

不能直接上生产。AI 生成的代码有四类问题：① 编译问题——import 不全、API 版本不匹配，需要手动修正；② 边界遗漏——AI 覆盖了正常路径但可能漏了 null/并发/超时，需要补测；③ 过度设计——AI 可能把简单问题复杂化（一个 if-else 上策略模式），需要判断要不要回退；④ 安全问题——SQL 注入、敏感信息硬编码，需要 review。正确流程：AI 生成 → 人工 review → 补单测 → 跑 CI → 合并。

7.2 AI 写的测试覆盖率真有 90% 吗？

AI 的"覆盖率自评"是估算不是实测——它说覆盖了不代表 jacoco 报告里真的有 90%。正确用法：让 AI 生成测试后跑一次 jacoco，把实际覆盖率贴回去问"哪些分支没覆盖到"，AI 会补上缺失的测试。两轮对话比一轮对话的覆盖率通常高 15~20%。

7.3 AI 会把我的代码泄露吗？

取决于你用的 AI 工具：① 在线 ChatGPT/Claude——对话数据可能用于训练，敏感代码别贴；② 企业版/API 版——有数据不训练承诺（看 SLA）；③ 本地部署模型（Ollama + 本地模型）——零泄露风险但能力弱于云端。纪律：业务核心代码走企业版或本地，不贴生产配置和密钥。

7.4 模板里为什么要指定版本号？

因为 API 在不同版本间差异巨大：JUnit4 的 @Test(expected=Exception.class) 到 JUnit5 变成 assertThrows；Mockito 3 的 anyString() 参数匹配到 Mockito 5 需要显式 arg0 形式。不指定版本 AI 给你的代码可能编译不过——它选了一个"通用版本"但跟你项目的实际版本不匹配。

7.5 五个模板能组合用吗？

能。典型组合：Bug 定位 → 修复 → 补单测——先用模板四定位根因，拿到修复方案后用模板一生成回归测试。重构 → 性能验证——先用模板二重构，再用模板三跑 JMH 验证重构后性能不降。选型 → 实现——先用模板五选型，选完让 AI 按选中的方案生成集成代码。

7.6 prompt 太长会不会效果变差？

不会——但要注意结构。长 prompt 的关键是结构化分隔：用 【方括号】 或 --- 分段，AI 能识别"这段是约束""那段是输入"。最差的长 prompt 是流水账——把所有信息揉成一团，AI 分不清哪些是指令哪些是上下文。五个模板都有清晰的 【】 分段——照着结构扩展，不要破坏。

八、总结

五模板速查卡

┌──────────┬──────────────────────────────────────────┐
│ 模板      │ 核心约束                                  │
├──────────┼──────────────────────────────────────────┤
│ 单测生成  │ JUnit5+Mockito+AssertJ；正常/边界/异常三维度│
│          │ 覆盖率目标 90%；命名 should_X_when_Y       │
│ 代码重构  │ 指定设计模式；API 兼容；圈复杂度 ≤ 10     │
│          │ 先锁行为再重构；扩展性说明                 │
│ 性能优化  │ 给瓶颈数据；算法层优先；JMH 验证          │
│          │ 适用前提标注；预期对比表                   │
│ Bug 定位  │ 完整堆栈+上下游代码；运行环境+并发场景     │
│          │ 已排查方向；Top 3 可能原因+验证方法         │
│ 技术选型  │ 具体业务场景+团队约束；对比表+推荐+反对   │
│          │ 迁移成本评估；3 年后长期视角               │
└──────────┴──────────────────────────────────────────┘
通用结构：角色 → 技术约束 → 任务输入 → 输出格式 → 验收标准

一句话

AI 编程的输出质量 = prompt 的约束密度。不是"帮我写个单测"而是"JUnit5+Mockito+AssertJ，覆盖正常/边界/异常三维度，覆盖率 90%，命名 should_X_when_Y"——你把技术栈、质量标准、验收口径精确地告诉 AI，它就按工程标准交付。五个模板的核心共性是角色设定→技术约束→任务输入→输出格式→验收标准五要素——缺任何一个要素输出质量都掉一个档次。但记住 AI 生成的代码不是终稿是草稿：人工 review → 补单测 → 跑 CI → 合并，这个流程不能跳。AI 是加速器不是替代品——它帮你从 0 到 80%，你负责从 80% 到生产级的那 20%。

给团队的建议

互动话题：你用 AI 写代码时最常用哪个模板？有没有自己的私藏 prompt 模板？评论区聊聊。

参考资料

• JUnit 5 官方文档
• Mockito 5 官方文档
• AssertJ 官方文档
• JMH（Java Microbenchmark Harness）
• Refactoring Guru（设计模式 + 重构）
• OpenAI Prompt Engineering Guide
• Anthropic Claude Prompt Engineering