/java-review

## 审查结果

### ✅ 通过项
- [检查项]: 通过

### ❌ 问题项
- [检查项]: 问题描述
  - 位置: `文件路径:行号`
  - 问题: 具体问题
  - 修复: 建议的修改

// ❌ 问题
class ProductCtrl { }
class ProductImpl { }
interface IProduct { }

// ✅ 正确
class ProductController { }
class ProductServiceImpl implements IProductService { }
interface IProductService { }

// ❌ 问题
public java.util.List<String> getList() {
    return new java.util.ArrayList<>();
}
import com.dsl.service.*;

// ✅ 正确
import java.util.List;
import java.util.ArrayList;
import static com.dsl.base.exception.util.ServiceExceptionUtil.exception;

// ✅ 新建类应该这样写
@Service
@Slf4j
@RequiredArgsConstructor
public class ProductServiceImpl implements IProductService {
    private final ProductMapper productMapper;
}

// ⚠️ 存量代码（不强制修改）
@Service
public class ProductService {
    @Autowired
    private ProductMapper productMapper;
}

// ❌ 问题：Controller 包含业务逻辑
@PostMapping("/add")
public CommonResult<Long> add(@RequestBody ProductAddReq req) {
    Product product = new Product();
    BeanUtils.copyProperties(req, product);
    productMapper.insert(product);  // ❌ 业务逻辑
    return CommonResult.success(product.getId());
}

// ✅ 正确
@PostMapping("/add")
public CommonResult<Long> add(@Valid @RequestBody ProductAddReq req) {
    return CommonResult.success(productService.add(req));
}

// ❌ 问题：嵌套过深
if (order != null) {
    if (order.getStatus() == 1) {
        if (order.getAmount() > 0) {
            process(order);
        }
    }
}

// ✅ 正确：卫语句
if (order == null) {
    throw exception(ORDER_NOT_EXISTS);
}
if (order.getStatus() != 1) {
    throw exception(INVALID_STATUS);
}
process(order);

// ❌ 问题：嵌套对象未加 @Valid
@Data
public class OrderReq {
    @NotNull(message = "用户信息不能为空")
    private UserInfo userInfo;  // 内部校验不会触发
}

// ✅ 正确：嵌套对象必须加 @Valid
@Data
public class OrderReq {
    @NotNull(message = "用户信息不能为空")
    @Valid  // 必须加
    private UserInfo userInfo;
}

// ❌ 问题
log.info("用户手机号: " + phone);

// ✅ 正确
log.info("[用户注册]，手机号: {}", DesensitizeUtil.mobile(phone));

// ❌ 问题：原生异常
if (user == null) {
    throw new RuntimeException("用户不存在");
}

// ✅ 正确：使用 ServiceExceptionUtil
import static com.dsl.base.exception.util.ServiceExceptionUtil.exception;

if (user == null) {
    throw exception(USER_NOT_FOUND);
}

// ❌ 问题：事务中混用 MySQL 和 Doris
@Transactional(rollbackFor = Exception.class)
public void syncData() {
    List<Data> dorisData = dorisMapper.selectList();
    mysqlMapper.saveBatch(dorisData);
}

// ✅ 正确：拆分方法
public void syncData() {
    List<Data> dorisData = queryFromDoris();
    saveToMysql(dorisData);
}

@Transactional(rollbackFor = Exception.class)
public void saveToMysql(List<Data> data) {
    mysqlMapper.saveBatch(data);
}

<!-- ✅ 正确：白名单方式 -->
ORDER BY
<choose>
    <when test="orderColumn == 'create_time'">create_time</when>
    <when test="orderColumn == 'update_time'">update_time</when>
    <otherwise>id</otherwise>
</choose>

// ❌ 问题：循环查询
for (Order order : orders) {
    User user = userMapper.selectById(order.getUserId());  // N 次查询
}

// ✅ 正确：批量查询 + 内存关联
Set<Long> userIds = orders.stream().map(Order::getUserId).collect(Collectors.toSet());
Map<Long, User> userMap = userMapper.selectBatchIds(userIds).stream()
    .collect(Collectors.toMap(User::getId, u -> u));

// ❌ 典型漏洞：水平越权
@GetMapping("/orders/{id}")
public CommonResult<OrderDetailRsp> getOrder(@PathVariable Long id) {
    return CommonResult.success(orderService.getById(id));  // 未校验归属
}

// ✅ 正确：校验数据归属
@GetMapping("/orders/{id}")
public CommonResult<OrderDetailRsp> getOrder(@PathVariable Long id) {
    Order order = orderService.getById(id);
    if (order == null) {
        throw exception(ORDER_NOT_FOUND);
    }
    if (!order.getUserId().equals(SecurityUtils.getUserId())) {
        throw exception(NO_PERMISSION);
    }
    return CommonResult.success(convert(order));
}

// ✅ 正确：捕获并转换为业务异常
public UserDTO getUser(Long userId) {
    try {
        log.info("[用户查询]，调用用户服务，userId: {}", userId);
        UserDTO user = userClient.getById(userId);
        log.info("[用户查询]，调用成功，userId: {}", userId);
        return user;
    } catch (FeignException.NotFound e) {
        log.warn("[用户查询]，用户不存在，userId: {}", userId);
        return null;
    } catch (FeignException e) {
        log.error("[用户查询]，调用失败，userId: {}，status: {}，异常：",
            userId, e.status(), e);
        throw exception(USER_SERVICE_ERROR);
    }
}

## Java/Spring 代码审查报告

> 📋 审查范围: X 个文件 | 🕐 YYYY-MM-DD HH:mm

### 问题汇总

| 严重度 | 数量 | 可自动修复 |
|--------|------|-----------|
| 🔴 高   | X    | X         |
| ⚠️ 中   | X    | X         |
| ⚡ 低   | X    | X         |

### 🔴 高严重度问题

#### #1 [问题标题]
📍 `文件路径:行号`

```diff
- // 原代码（红色删除）
+ // 修复代码（绿色新增）

  // 上下文代码
- // 问题代码
+ // 修复代码

### 通过项汇总（折叠显示）

```markdown
### ✅ 审查通过

**X/20 项检查通过**（命名规范、Import规范、Mapper层、异常处理...）

### 📌 后续操作

| 命令 | 说明 |
|------|------|
| `fix all` | 自动修复所有可修复问题 |
| `fix #1` | 修复指定问题 |
| `fix #1,#3,#5` | 批量修复多个问题 |
| `详细 #2` | 查看问题详细说明 |

// Controller（新建类）
@RestController
@RequiredArgsConstructor
// @Validated 视业务需求，不强制

// Service（新建类）
@Service
@Slf4j
@RequiredArgsConstructor

// DTO
@Data
@NoArgsConstructor

log.info("[业务名称]，动作描述，参数: {}", value);
log.error("[业务名称]，错误描述，参数: {}，异常：", value, e);

DesensitizeUtil.mobile(phone)     // 138****1234
DesensitizeUtil.idCard(idCard)    // 310***********1234
// password/token 禁止打印

@Transactional(rollbackFor = Exception.class)

import static com.dsl.base.exception.util.ServiceExceptionUtil.exception;

throw exception(ERROR_CODE_CONSTANT);

String key = "{业务}:{模块}:{id}";
// 示例: "order:detail:12345"

RLock lock = redisson.getLock("业务:操作:" + bizId);
try {
    if (lock.tryLock(3, 30, TimeUnit.SECONDS)) {
        // 业务逻辑
    }
} finally {
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}

## Java/Spring 代码审查报告

> 📋 审查范围: 3 个文件 | 🕐 2026-01-28 14:30

### 问题汇总

| 严重度 | 数量 | 可自动修复 |
|--------|------|-----------|
| 🔴 高   | 2    | 1         |
| ⚠️ 中   | 3    | 2         |
| ⚡ 低   | 1    | 0         |

---

### 🔴 高严重度问题

#### #1 Controller 包含业务逻辑
📍 `ProductController.java:45`

```diff
- @PostMapping("/add")
- public CommonResult<Long> add(@RequestBody ProductAddReq req) {
-     Product product = new Product();
-     BeanUtils.copyProperties(req, product);
-     productMapper.insert(product);
-     return CommonResult.success(product.getId());
- }

+ @PostMapping("/add")
+ public CommonResult<Long> add(@Valid @RequestBody ProductAddReq req) {
+     return CommonResult.success(productService.add(req));
+ }

  @Transactional(rollbackFor = Exception.class)
  public void syncData() {
-     List<Data> dorisData = dorisMapper.selectList();
-     mysqlMapper.saveBatch(dorisData);
+     List<Data> dorisData = queryFromDoris();
+     saveToMysql(dorisData);
  }

- log.info("订单创建成功，orderId: {}", orderId);
+ log.info("[订单创建]，创建成功，orderId: {}", orderId);

  @NotNull(message = "用户信息不能为空")
+ @Valid
  private UserInfo userInfo;

+ /**
+  * 商品名称
+  * @mock 阿莫西林
+  */
  private String name;

---

## 规范来源

本审查规范基于以下规范文档编写：

- [命名规范](../java/references/naming.md)
- [代码风格](../java/references/coding-style.md)
- [日志规范](../java/references/logging.md)
- [异常处理](../java/references/exception.md)
- [Controller 层](../java/references/controller.md)
- [Service 层](../java/references/service.md)
- [Mapper 层](../java/references/mapper.md)
- [事务管理](../java/references/transaction.md)
- [性能优化](../java/references/performance.md)
- [缓存规范](../java/references/cache.md)
- [并发控制](../java/references/concurrency.md)
- [安全规范](../java/references/security.md)
- [异步与消息](../java/references/async-mq.md)
- [数据库设计](../java/references/database.md)
- [接口文档](../java/references/api-doc.md)