异常处理最佳实践：自定义异常与全局处理

public class BusinessException extends RuntimeException {

    private final String errorCode;
    private final Object[] args;  // 国际化参数

    public BusinessException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
        this.args = null;
    }

    public BusinessException(String errorCode, String message,
                           Throwable cause) {
        super(message, cause);  // 保留异常链！
        this.errorCode = errorCode;
        this.args = null;
    }

    public String getErrorCode() { return errorCode; }
}

// 更具体的子异常
public class UserNotFoundException extends BusinessException {
    public UserNotFoundException(Long userId) {
        super("USER_NOT_FOUND", "用户不存在: " + userId);
    }
}

// ❌ 错误：丢失了原始异常信息
try {
    userDao.save(user);
} catch (SQLException e) {
    throw new BusinessException("SAVE_FAILED", "保存用户失败");
    // 堆栈里只有 BusinessException，看不到原始 SQLException！
}

// ✅ 正确：保留异常链
try {
    userDao.save(user);
} catch (SQLException e) {
    throw new BusinessException("SAVE_FAILED",
        "保存用户失败", e);  // 传入 cause！
}
// 堆栈中可以看到：BusinessException caused by: SQLException

@RestControllerAdvice
public class GlobalExceptionHandler {

    private static final Logger log =
        LoggerFactory.getLogger(GlobalExceptionHandler.class);

    // 业务异常 → 400
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ApiResponse<?>> handleBiz(
            BusinessException e) {
        log.warn("业务异常: {}", e.getMessage());
        return ResponseEntity.badRequest()
            .body(ApiResponse.error(e.getErrorCode(), e.getMessage()));
    }

    // 参数校验异常 → 400
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiResponse<?>> handleValidation(
            MethodArgumentNotValidException e) {
        String msg = e.getBindingResult().getFieldErrors().stream()
            .map(f -> f.getField() + ": " + f.getDefaultMessage())
            .collect(Collectors.joining("; "));
        return ResponseEntity.badRequest()
            .body(ApiResponse.error("VALIDATION_ERROR", msg));
    }

    // 兜底：未知异常 → 500
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<?>> handleUnknown(
            Exception e) {
        log.error("未预期异常", e);  // 完整堆栈
        return ResponseEntity.status(500)
            .body(ApiResponse.error("INTERNAL_ERROR",
                "服务器内部错误"));
    }
}

// ❌ 错误 1：吞掉异常（最严重的反模式）
catch (IOException e) {
    // 什么都不做
}

// ❌ 错误 2：只记消息，不记堆栈
catch (IOException e) {
    log.error("读取失败: {}", e.getMessage());
    // 丢失了完整的堆栈和 cause 链
}

// ❌ 错误 3：e.printStackTrace()（生产环境禁用）
catch (Exception e) {
    e.printStackTrace();  // 输出到 System.err，不进日志系统
}

// ✅ 正确：异常对象作为最后一个参数
catch (IOException e) {
    log.error("读取文件失败: path={}", filePath, e);
    // SLF4J 会自动打印完整堆栈
    throw new BusinessException("READ_FAILED", "读取失败", e);
}

// ❌ 反模式：用异常控制流程
try {
    User user = userService.findById(id);
    process(user);
} catch (UserNotFoundException e) {
    // 用异常来处理"用户不存在"这种正常分支
}

// ✅ 正确：用 Optional 或 if 判断
Optional<User> user = userService.findById(id);
user.ifPresent(this::process);

// ❌ 反模式：finally 中 return
try {
    return doSomething();  // 这个返回值会被 finally 覆盖
} finally {
    return defaultValue;   // 覆盖了 try 的 return！
}

// ❌ 反模式：catch 范围太大
catch (Exception e) {  // 连 NullPointerException 也吞了
    log.error("出错了", e);
}

// ✅ 正确：精确捕获
catch (FileNotFoundException e) {
    log.error("文件不存在: {}", path, e);
    throw new BusinessException("FILE_NOT_FOUND", "文件不存在", e);
}