메뉴
Java项目代码review工具。分析Git变更+完整调用链路上下文，推断业务需求，进行多维度评分和分类汇总，生成完整PRD文档。包含细粒度Java代码审查清单（Null安全、异常处理、Streams、并发、equals/hashCode、资源管理、API设计、性能、MyBatis/ORM、事务边界、SQL/DDL质量）。
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/luokai0/ai-agent-skills-by-luo-kai --skill java-code-review명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Writers Room Story Engine mega-skill. Creates, structures, drafts, and revises compelling standalone stories from zero using premise generation, audience engagement, thematic design, character arcs, Story Spine structure, causal beats, worldbuilding in service of story, scene construction, and revision diagnostics. Use when developing short stories, standalone fiction, scripts, or narrative concepts from scratch or when improving weak drafts.
Browse Airtable bases and tables, inspect records, create records, and manage fields, comments, and table actions — powered by ClawLink.
Alibaba Cloud DNS (Alidns) CLI skill. Use to query, add, and update DNS records via aliyun-cli, including CNAME setup for Function Compute custom domains.
SKILL.md 표시 중
SOC 직업 분류 기준
| name | java-code-review |
| description | Java项目代码review工具。分析Git变更+完整调用链路上下文，推断业务需求，进行多维度评分和分类汇总，生成完整PRD文档。包含细粒度Java代码审查清单（Null安全、异常处理、Streams、并发、equals/hashCode、资源管理、API设计、性能、MyBatis/ORM、事务边界、SQL/DDL质量）。 |
| category | development |
| risk | safe |
| source | custom |
| date_added | 2026-04-28 |
| author | user |
| tags | ["java","code-review","git-diff","business-analysis","risk-detection","performance","optimization","spring","mybatis","transaction","sql-ddl","concurrency","scoring","prd","null-safety","streams","exception-handling","resource-management","api-design"] |
| tools | ["git","glob","grep","read","write","bash","lsp_diagnostics","ast_grep_search","lsp_find_references","lsp_goto_definition"] |
| compatibility | opencode |
| trigger_phrase | ["代码评审","review代码","分析变更","代码检查","检查bug","风险分析","性能检查","需求分析","业务分析","生成PRD"] |
智能化Java项目代码评审工具，完整流程（7步）：
优先询问用户，如用户未指定则使用以下策略：
@{u}（上游分支）develop 分支 → 使用 developmain/master 分支 → 使用 main/masterHEAD~10（最近10次提交）# 场景1：工作区+暂存区 vs 基准分支（最常用）
git diff <基准分支>..HEAD --name-only
git diff <基准分支>..HEAD -U500
git diff <基准分支>..HEAD --stat
# 场景2：仅检查已暂存（staged）的变更
git diff --cached -U500
git diff --cached --stat
# 场景3：工作区未暂存变更
git diff -U500
对于每个变更的方法/类，向上追溯找到业务入口：
使用 lsp_find_references 分析每个关键方法：
入口点
↓ 调用
变更方法
↓ 调用
子方法1 → 子方法2 → ... → 数据库/外部服务
基于完整链路推断业务逻辑：
变更方法：InventoryService.deduct()
完整链路：
Controller.createOrder() [下单入口]
↓
OrderService.create() [订单创建]
↓
InventoryService.deduct() [变更点] ← 库存扣减
↓
PaymentService.pay() [支付]
↓
NotificationService.notify() [通知]
推断业务需求：
用户下单 → 自动扣减库存 → 支付 → 通知
核心流程：订单+库存+支付+消息 四模块联动
重要：PRD必须覆盖所有变更点，包括新增功能和修改功能。
# 产品需求文档 PRD
## 1. 概述
### 1.1 产品名称
[模块名称-版本号]
### 1.2 需求背景
[为什么需要这个功能，解决什么问题]
### 1.3 需求范围
- 涉及模块：xxx
- 用户类型：xxx
- 使用场景：xxx
---
## 2. 功能需求
### 2.1 功能清单
| # | 功能点名称 | 功能类型 | 优先级 | 涉及文件 | 行号 |
|---|-----------|--------|--------|---------|-----|
| 1 | 功能点A | 新增 | P0 | XxxService.java | 1-100 |
| 2 | 功能点B | 新增 | P1 | XxxServiceImpl.java | 200-300 |
| 3 | 功能点C | 修改 | P2 | XxxConverter.java | 10-30 |
| 4 | 字段调整 | 修改 | P2 | DDL脚本 | - |
### 2.2 功能详情（每个变更点都需要详细描述）
#### 2.2.1 [功能点A-新增功能]
**功能类型**：新增
**功能描述**：
[详细描述这个功能做什么]
**业务规则**：
- 规则1
- 规则2
**核心链路**：
[入口] Controller.method() [POST /api/xxx] ↓ Service.method() [核心] 核心业务逻辑 ← 变更内容 ↓ DAO.method() [终点] 数据库/外部服务
**入参说明**：
| 参数 | 类型 | 必填 | 说明 |
|------|------|------|------|
| param1 | String | 是 | xxx |
| param2 | Integer | 否 | xxx |
**出参说明**：
| 参数 | 类型 | 说明 |
|------|------|------|
| result1 | String | xxx |
**异常处理**：
| 异常场景 | 错误码 | 提示信息 |
|----------|--------|----------|
| 场景1 | E_xxx | xxx |
---
#### 2.2.2 [功能点B-修改功能]
**功能类型**：修改
**涉及文件**：`xxx.java`
**涉及行号**：xxx-xxx
**修改前**：
```java
// 原代码
修改后：
// 新代码
变更原因： [为什么要这样修改]
核心链路：
[入口] Controller.method() [POST /api/xxx]
↓ Service.method()
[核心] 修改的方法 ← 变更内容
↓ DAO.method()
[终点] 数据库/外部服务
影响分析：
功能类型：优化
优化前： [优化前的描述]
优化后： [优化后的描述]
优化效果：
CREATE TABLE xxx (
id VARCHAR(36) PRIMARY KEY,
tenant_id VARCHAR(32) NOT NULL,
org_id VARCHAR(32),
doc_id VARCHAR(36) NOT NULL,
retry_type VARCHAR(32),
retry_count INT DEFAULT 0,
last_retry_time DATETIME,
create_time DATETIME NOT NULL,
PRIMARY KEY (id),
KEY idx_doc_id (doc_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='xxx表';
-- 修改字段长度
ALTER TABLE xxx MODIFY COLUMN goods_name VARCHAR(300) COMMENT '商品名称';
-- 新增字段
ALTER TABLE xxx ADD COLUMN operator VARCHAR(300) COMMENT '操作人';
[如有数据迁移需求，描述迁移脚本]
| 接口名称 | 请求方式 | 路径 | 说明 |
|---|---|---|---|
| 接口A | POST | /api/xxx | xxx |
请求参数：
{
"ids": ["xxx"],
"operator": "xxx"
}
响应参数：
{
"code": "0",
"message": "成功",
"data": null
}
| 接口名称 | 请求方式 | 路径 | 说明 |
|---|---|---|---|
| 接口A | POST | /api/xxx | 参数调整 |
变更说明： [描述接口参数变更]
| 文件路径 | 说明 |
|---|---|
| xxx.java | 新增功能 |
| 文件路径 | 修改内容 |
|---|---|
| xxx.java | 方法A新增、方法B修改 |
| 文件路径 | 删除原因 |
|---|---|
| xxx.java | 功能废弃 |
| 版本 | 日期 | 变更内容 | 作者 |
|---|---|---|---|
| v2.4.0.0 | 2026-04-30 | 初始版本 | xxx |
---
## 第4步：代码检测（P0/P1快速扫描）
在进入细粒度审查前，先快速扫描严重缺陷和代码缺陷。
### P0严重缺陷
| 检查项 | 检测模式 | 扣分 |
|--------|----------|------|
| 空指针 | `$OBJ.$METHOD()` obj未检查 | -10 |
| SQL注入 | `"SELECT " + $TABLE` 直接拼接 | -10 |
| 密钥泄露 | `password/token = "xxx"` | -10 |
| 事务缺失 | @Transactional 关键方法无事务 | -10 |
### P1代码缺陷
| 检查项 | 检测模式 | 扣分 |
|--------|----------|------|
| 资源泄漏 | new FileInputStream 未关闭 | -5 |
| 线程安全 | private static 共享变量 | -5 |
| 空catch | catch块为空或仅打印日志 | -5 |
| 循环查询 | for循环内数据库操作 | -5 |
### P2代码规范（快速扫描）
以下为不与第5步细粒度审查清单重叠的独立检查项：
| 检查项 | 检测模式 | 扣分 |
|--------|----------|------|
| 参数过多 | 方法参数超过3个 | -2 |
| 魔法数字 | 字面量未定义为常量 | -2 |
| 原始泛型 | List/Map 未指定类型参数 | -2 |
> **注意**：Streams滥用、Boolean参数、Optional.get()、equals缺hashCode、catch Exception 等 P2 检查项已整合到第5步对应分类中，此处不再重复。
---
## 第5步：细粒度代码审查清单 (Detailed Review Checklist)
### 审查策略
1. **Quick scan** - 理解变更意图，确定审查范围
2. **Checklist pass** - 按以下分类逐项检查
3. **Summary** - 按严重度汇总（Critical → Improvement → Minor）
### A. Null 安全
```java
// ❌ NPE 风险：链式调用不检查中间null
String name = user.getName().toUpperCase();
// ✅ 安全：Optional + map
String name = Optional.ofNullable(user.getName())
.map(String::toUpperCase)
.orElse("");
// ✅ 也可以：提前返回
if (user.getName() == null) {
return "";
}
return user.getName().toUpperCase();
检查项：
@Nullable / @NonNull 注解Optional.get() 没有 isPresent() 检查——改用 orElseThrow()null 而非 Optional 或空集合Objects.requireNonNull()🔧 检测方法：
grep: Optional\.get\(\) → 检查是否有 isPresent() 先导ast_grep_search: $OBJ.$METHOD() pattern 查找链式调用中缺少 null 守卫lsp_find_references: 追踪方法返回 null 的调用方建议：
Optional<T> 替代 nullObjects.requireNonNull()Collections.emptyList() 替代 null// ❌ 吞掉异常（最坏实践）
try {
process();
} catch (Exception e) {
// 没有日志，没有处理
}
// ❌ 捕获范围过宽
catch (Exception e) { }
catch (Throwable t) { }
// ❌ 丢失原始异常栈（不传cause）
catch (IOException e) {
throw new RuntimeException(e.getMessage()); // 丢失堆栈！
}
// ✅ 正确处理
catch (IOException e) {
log.error("处理文件失败: {}", filename, e);
throw new ProcessingException("文件处理失败", e); // 传递cause
}
检查项：
Exception, Throwable）🔧 检测方法：
ast_grep_search: catch (Exception 和 catch (Throwable → 宽泛捕获grep: catch\s*\( 带上下文行查找空 catch 块grep: throw new.*getMessage\(\) → 丢失原始异常栈建议：
// ❌ 遍历中修改集合 → ConcurrentModificationException
for (Item item : items) {
if (item.isExpired()) {
items.remove(item);
}
}
// ✅ 使用 removeIf
items.removeIf(Item::isExpired);
// ❌ 简单逻辑滥用Stream
list.stream().forEach(System.out::println);
// ✅ 简单场景直接用for循环
for (Item item : list) {
System.out.println(item);
}
// ❌ 假设 Collectors.toList() 返回可变List
List<String> names = users.stream()
.map(User::getName)
.collect(Collectors.toList());
names.add("extra"); // 可能不可变！
// ✅ 显式要求可变集合
List<String> names = users.stream()
.map(User::getName)
.collect(Collectors.toCollection(ArrayList::new));
检查项：
removeIf() 替代）Collectors.toList() 假定返回可变列表List.of(), Set.of(), Map.of() 创建不可变集合🔧 检测方法：
ast_grep_search: .stream().forEach → 可能的滥用模式grep: \.remove\( 在 for\s*\( 块内 → 遍历时修改grep: \.collect\(Collectors\.toList\(\)\) → 检查后续是否有 add/remove 操作建议：
List.copyOf()// ❌ 非线程安全的集合
private Map<String, User> cache = new HashMap<>();
// ✅ 线程安全集合
private Map<String, User> cache = new ConcurrentHashMap<>();
// ❌ check-then-act 竞态条件
if (!map.containsKey(key)) {
map.put(key, computeValue()); // 多线程下可能重复计算
}
// ✅ 原子操作
map.computeIfAbsent(key, k -> computeValue());
// ❌ 双重检查锁（没有volatile则broken）
if (instance == null) {
synchronized(this) {
if (instance == null) {
instance = new Instance(); // 可能看到半初始化对象
}
}
}
// ✅ 使用静态内部类 / volatile
private volatile Instance instance;
检查项：
volatile🔧 检测方法：
grep: private static.*Map|List|Set → 静态共享集合ast_grep_search: synchronized\( → 检查同步对象是否为 finalgrep: if \(.*== null\) 在 synchronized 块内 → 双重检查锁建议：
java.util.concurrent 并发集合类AtomicReference, AtomicInteger@ThreadSafe / @NotThreadSafe 注解equals & hashCode:
// ❌ 只重写equals不重写hashCode → 破坏HashMap契约！
@Override
public boolean equals(Object o) { ... }
// hashCode 缺失！
// ❌ hashCode用了可变字段 → 放入HashMap后字段变了就找不到了
@Override
public int hashCode() {
return Objects.hash(id, mutableField); // 危险！
}
// ✅ 同时重写，只用不可变字段
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof User user)) return false;
return Objects.equals(id, user.id);
}
@Override
public int hashCode() {
return Objects.hash(id);
}
toString:
// ❌ 包含敏感数据
return "User{password='" + password + "'}";
// ✅ 调试友好但安全
return "User{id=" + id + ", name='" + name + "'}";
Builder模式:
// ✅ 当构造参数 > 3 时推荐
User user = User.builder()
.name("张三")
.email("zhangsan@example.com")
.build();
检查项：
equals 有但 hashCode 缺失 → 确定要破坏HashMap/HashSet吗？hashCode 使用了可变字段toString（调试困难）instanceof pattern matching🔧 检测方法：
ast_grep_search: public boolean equals → 检查同文件是否有 public int hashCodegrep: Objects\.hash\(.*this\. → hashCode 使用了实例字段（可能可变）grep: password|secret|token 在 toString\(\) 方法内 → 敏感数据泄露// ❌ 资源泄漏
FileInputStream fis = new FileInputStream(file);
// ... 抛异常前没close
// ✅ try-with-resources
try (FileInputStream fis = new FileInputStream(file)) {
// 自动关闭
}
// ❌ 多个资源嵌套，可能内层未关闭
try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) {
// 如果 BufferedWriter 构造失败，FileWriter 可能泄漏
}
// ✅ 独立声明
try (FileWriter fw = new FileWriter(file);
BufferedWriter writer = new BufferedWriter(fw)) {
// 两者都被保证关闭
}
检查项：
Closeable/AutoCloseable 未使用 try-with-resources🔧 检测方法：
grep: new (File|Input|Output|Reader|Writer|Connection|Statement) → 检查是否在 try-with-resources 内ast_grep_search: new $CLOSEABLE($$$) 不在 try ( 块内 → 资源泄漏风险强制规则：任何实现了 Closeable/AutoCloseable 的资源，必须使用 try-with-resources。
// ❌ Boolean参数 → 调用端看不懂语义
process(data, true, false);
// ✅ 使用枚举
process(data, ProcessMode.ASYNC, ErrorHandling.STRICT);
// ❌ 找不到返回null (调用方不知道)
public User findById(Long id) {
return users.get(id); // 可能null
}
// ✅ 语义明确的 Optional
public Optional<User> findById(Long id) {
return Optional.ofNullable(users.get(id));
}
// ❌ 入参允许null → 调用方不知道能不能传null
public void process(List<Item> items) {
if (items == null) items = Collections.emptyList();
}
// ✅ 明确要求非null
public void process(List<Item> items) {
Objects.requireNonNull(items, "items must not be null");
}
检查项：
Objects.requireNonNull）🔧 检测方法：
ast_grep_search: $VISIBILITY $RET $NAME(boolean $PARAM → Boolean 参数grep: public.*\(.*,.*,.*,.*, → 参数超过3个的方法签名grep: Objects\.requireNonNull → 检查公共方法是否都有入参校验// ❌ 循环内String拼接 → 每次创建新String对象
String result = "";
for (String s : strings) {
result += s;
}
// ✅ StringBuilder
StringBuilder sb = new StringBuilder();
for (String s : strings) {
sb.append(s);
}
// ❌ 循环内编译正则 → 每次都重新编译
for (String line : lines) {
if (line.matches("pattern.*")) { }
}
// ✅ 预编译为静态常量
private static final Pattern PATTERN = Pattern.compile("pattern.*");
for (String line : lines) {
if (PATTERN.matcher(line).matches()) { }
}
// ❌ N+1 查询
for (User user : users) {
List<Order> orders = orderRepo.findByUserId(user.getId());
}
// ✅ 批量查询
Map<Long, List<Order>> ordersByUser = orderRepo.findByUserIds(userIds);
检查项：
IntStream, LongStream）🔧 检测方法：
grep: \+= 在 for\s*\( 块内 → 循环内 String 拼接grep: \.matches\( 在 for\s*\( 块内 → 循环内正则编译ast_grep_search: for.*\{.*\.(select|find|query) → N+1 查询模式建议为以下场景补充测试：
🔧 检测方法：
glob: **/src/test/**/*Test*.java → 检查是否有对应测试文件grep: @Test → 统计测试方法数量 vs 变更方法数量// ❌ N+1 查询：循环内逐条查询
for (Order order : orders) {
List<OrderItem> items = orderItemMapper.selectByOrderId(order.getId());
order.setItems(items);
}
// ✅ 批量查询 + 内存组装
List<Long> orderIds = orders.stream().map(Order::getId).collect(Collectors.toList());
List<OrderItem> allItems = orderItemMapper.selectByOrderIds(orderIds);
Map<Long, List<OrderItem>> itemsMap = allItems.stream()
.collect(Collectors.groupingBy(OrderItem::getOrderId));
orders.forEach(o -> o.setItems(itemsMap.getOrDefault(o.getId(), Collections.emptyList())));
// ❌ 分页插件滥用：先查全部再内存分页
List<User> allUsers = userMapper.selectAll();
List<User> page = allUsers.subList(offset, offset + limit);
// ✅ 使用分页插件
PageHelper.startPage(pageNum, pageSize);
List<User> users = userMapper.selectByCondition(condition);
检查项：
<if test> 条件缺少对空字符串的判断#{} 与 ${} 混用（${} 有 SQL 注入风险）🔧 检测方法：
grep: <select|<update|<insert|<delete 在 *.xml → 检查 id 命名是否与方法名一致ast_grep_search: for.*\{.*Mapper\.|for.*\{.*mapper\. → N+1 查询模式grep: PageHelper\.startPage → 检查是否紧跟 Mapper 调用（分页生效）grep: \$\{ 在 *.xml → SQL 注入风险（应使用 #{}）// ❌ 事务传播级别错误：REQUIRES_NEW 导致外层事务回滚失效
@Transactional(propagation = Propagation.REQUIRED)
public void processOrder(Order order) {
orderMapper.update(order);
paymentService.pay(order); // 内部 REQUIRES_NEW，pay 成功但外层回滚
}
// ❌ 同类方法调用事务失效（Spring AOP 代理限制）
public void batchProcess(List<Order> orders) {
for (Order order : orders) {
this.processSingle(order); // @Transactional 不生效！
}
}
// ✅ 注入自身代理或拆分到不同类
@Transactional
public void processSingle(Order order) { ... }
// ❌ 长事务导致锁竞争
@Transactional
public void exportReport() {
// 大量查询 + 文件生成 + 邮件发送 都在一个事务内
List<Data> data = dataMapper.selectAll(); // 持有数据库连接
File file = generateExcel(data); // 耗时操作
emailService.send(file); // 外部IO
}
检查项：
REQUIRES_NEW 嵌套回滚边界）@Transactional 仅用于 public 方法（非 public 不生效）readOnly=true 未设置（查询方法应标记只读）🔧 检测方法：
grep: @Transactional → 检查 propagation 属性grep: REQUIRES_NEW → 嵌套事务回滚边界grep: @Transactional 在非 public 方法上 → 事务不生效ast_grep_search: @Transactional.*\{.*(?:send|http|file|sleep) → 长事务嫌疑-- ❌ 缺索引：大表无索引导致全表扫描
CREATE TABLE t_order (
id BIGINT PRIMARY KEY,
user_id BIGINT NOT NULL,
order_no VARCHAR(64) NOT NULL,
status TINYINT,
create_time DATETIME
) ENGINE=InnoDB; -- 缺少 user_id 和 order_no 索引！
-- ✅ 合理索引
CREATE TABLE t_order (
id BIGINT PRIMARY KEY,
user_id BIGINT NOT NULL,
order_no VARCHAR(64) NOT NULL,
status TINYINT DEFAULT 0,
create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
KEY idx_user_id (user_id),
UNIQUE KEY uk_order_no (order_no),
KEY idx_status_create (status, create_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';
-- ❌ 字段类型不当
ALTER TABLE t_order ADD COLUMN amount VARCHAR(32); -- 金额应用 DECIMAL
-- ✅ 正确类型
ALTER TABLE t_order ADD COLUMN amount DECIMAL(18,2) NOT NULL DEFAULT 0.00 COMMENT '订单金额';
检查项：
🔧 检测方法：
grep: CREATE TABLE 无 COMMENT → 缺表注释grep: ALTER TABLE → 检查是否有对应回滚脚本grep: VARCHAR\( → 检查长度是否合理（如 VARCHAR(1) 或 VARCHAR(5000)）grep: amount|price|money.*VARCHAR → 金额字段类型不当| 严重度 | 标准 | 对应评分 |
|---|---|---|
| Critical | 安全漏洞、可能丢失数据、生产环境必崩 | P0 (-10) |
| High | 大概率Bug、严重性能问题、破坏API契约 | P1 (-5) |
| Medium | 代码坏味、可维护性问题、缺少最佳实践 | P2 (-2) |
| Low | 风格问题、微优化、建议性 | P2 (-2) |
| 维度 | 权重 | 计算方式 |
|---|---|---|
| 代码质量 | 20% | (100 - 扣分) * 权重 |
| 安全性 | 25% | (100 - P0问题*10) * 权重 |
| 性能 | 20% | (100 - 性能问题*8) * 权重 |
| 可维护性 | 15% | (100 - 规范问题*5) * 权重 |
| 业务风险 | 20% | (100 - 风险问题*10) * 权重 |
| 问题类型 | 扣分 |
|---|---|
| P0问题 | -10分/个 |
| P1问题 | -5分/个 |
| P2建议 | -2分/个 |
| 等级 | 分数 | 颜色 | 行动 |
|---|---|---|---|
| S | 90-100 | 🟢 绿 | 可合并 |
| A | 80-89 | 🟢 绿 | 可合并 |
| B | 70-79 | 🟡 黄 | 需要确认 |
| C | 60-69 | 🟠 橙 | 需要修改 |
| D | <60 | 🔴 红 | 拒绝合并 |
# 代码评审报告
## 基本信息
- 项目名称：xxx
- 评审范围：xxx → xxx
- 变更文件数：N
- 变更行数：+X / -Y
## 📊 质量评分
| 维度 | 得分 | 评级 |
|------|------|------|
| 代码质量 | 85 | A |
| 安全性 | 90 | S |
| 性能 | 80 | A |
| 可维护性 | 75 | B |
| 业务风险 | 70 | B |
| **总分** | **82** | **A** |
## 📋 需求汇总
### 需求1：[功能点A]
- 涉及文件：XxxService.java (新增100行)
- 变更类型：新增功能
- 入口：XxxController.create() (POST /api/xxx)
- 核心链路：
[入口] XxxController.create() ↓ XxxService.process() [核心] XxxHandler.handle() ← 变更点 ↓ XxxRepository.save() [终点] 数据库持久化
- 风险等级：🟡 中
### 需求2：[功能点B]
- 涉及文件：XxxServiceImpl.java, XxxController.java
- 变更类型：新增功能
- 入口：POST /api/xxx/action
- 核心链路：
[入口] XxxController.action() [核心] XxxServiceImpl.action() ← 变更点 ↓ 逻辑处理 [终点] 数据库更新
- 风险等级：🟡 中
## 🔴 严重问题 (P0)
- [ ] 问题1
- 文件：xxx.java
- 行号：xxx
- 修复方案
## 🟡 中等问题 (P1)
- [ ] 问题1
- 文件：xxx.java
- 优化方案
## 🟢 建议优化 (P2)
- [ ] 优化1
## 评审结论
- 总体评级：S/A/B/C/D
- 是否可以合并：是/需修改/拒绝
code-review-report.md（含评分 + 业务分析 + 细粒度代码检查）prd-{版本号}.mdTrigger: "review代码" / "检查PR" / "代码评审"
Step 1: git diff 获取变更
├─ 确定基准分支（询问用户 / 自动检测）
├─ 支持 --cached（仅暂存区）/ 分支对比
├─ 统计变更文件和行数
└─ 识别变更类型（新增/修改/删除）
Step 2: 上下文分析
├─ lsp_find_references 追踪调用链
├─ 确定业务入口（Controller/MQ/定时任务/Feign）
└─ 推断业务逻辑
Step 3: PRD文档生成（覆盖所有变更点）
├─ 功能清单（含文件+行号）
├─ 核心链路图
├─ 数据库变更
└─ 接口设计
Step 4: 代码检测（P0/P1快速扫描）
├─ P0严重缺陷（NPE/SQL注入/密钥/事务）
├─ P1代码缺陷（资源泄漏/线程安全/空catch/循环查询）
└─ P2代码规范（参数过多/魔法数字/原始泛型）
Step 5: 细粒度审查清单（12类深度检查）
├─ A. Null安全
├─ B. 异常处理
├─ C. Streams & 集合
├─ D. 并发安全
├─ E. Java惯用法 (equals/hashCode)
├─ F. 资源管理 (try-with-resources)
├─ G. API设计
├─ H. 性能
├─ I. 测试提示
├─ J. MyBatis/ORM 检查
├─ K. 事务边界检查
└─ L. SQL/DDL 质量检查
Step 6: 多维度评分
├─ 代码质量 20%
├─ 安全性 25%
├─ 性能 20%
├─ 可维护性 15%
└─ 业务风险 20%
Step 7: 生成Review报告
├─ 基本信息
├─ 质量评分（含维度拆分）
├─ 需求汇总（含调用链路）
├─ 问题清单（Critical/High/Medium/Low）
└─ 评审结论
生成PRD时，每个变更点都必须包含：