Java异常处理的最佳实践指南

// 错误做法 - 异常被完全忽略
try {
    processOrder();
} catch (Exception e) {
    // 空catch块 - 极其危险!
}

// 正确做法 - 至少记录日志
try {
    processOrder();
} catch (Exception e) {
    logger.error("订单处理失败", e);
}

// 错误做法 - 过于泛化的异常
throw new Exception("操作失败");

// 正确做法 - 提供具体信息
throw new OrderProcessingException("订单ID: " + orderId + " 库存不足，当前库存: " + currentStock);

// 受检异常 (Checked Exception) - 必须处理
try {
    FileInputStream file = new FileInputStream("file.txt");
} catch (FileNotFoundException e) {
    // 必须捕获或声明抛出
}

// 非受检异常 (Unchecked Exception) - 可不处理
// RuntimeException及其子类，如NullPointerException, IllegalArgumentException等

// 业务异常类
public class BusinessException extends RuntimeException {
    private String errorCode;
    
    public BusinessException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }
    
    public String getErrorCode() {
        return errorCode;
    }
}

// 使用自定义异常
public void transferMoney(Account from, Account to, BigDecimal amount) {
    if (from.getBalance().compareTo(amount) < 0) {
        throw new BusinessException("INSUFFICIENT_BALANCE", 
            "账户余额不足，当前余额: " + from.getBalance());
    }
    // 转账逻辑...
}

@ControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    // 处理业务异常
    @ExceptionHandler(BusinessException.class)
    @ResponseBody
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException ex) {
        logger.warn("业务异常: {}", ex.getMessage());
        ErrorResponse error = new ErrorResponse(ex.getErrorCode(), ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }
    
    // 处理系统异常
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResponseEntity<ErrorResponse> handleSystemException(Exception ex) {
        logger.error("系统异常", ex);
        ErrorResponse error = new ErrorResponse("SYSTEM_ERROR", "系统繁忙，请稍后重试");
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }
    
    // 处理数据校验异常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public ResponseEntity<ErrorResponse> handleValidationException(MethodArgumentNotValidException ex) {
        String errorMessage = ex.getBindingResult().getFieldErrors().stream()
            .map(FieldError::getDefaultMessage)
            .collect(Collectors.joining(", "));
        
        ErrorResponse error = new ErrorResponse("VALIDATION_ERROR", errorMessage);
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }
}

// 统一的错误响应体
@Data
@AllArgsConstructor
class ErrorResponse {
    private String code;
    private String message;
    private long timestamp = System.currentTimeMillis();
}

// 统一格式的API响应
@Data
public class ApiResponse<T> {
    private boolean success;
    private T data;
    private ErrorInfo error;
    
    public static <T> ApiResponse<T> success(T data) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setSuccess(true);
        response.setData(data);
        return response;
    }
    
    public static ApiResponse<?> failure(String code, String message) {
        ApiResponse<?> response = new ApiResponse<>();
        response.setSuccess(false);
        response.setError(new ErrorInfo(code, message));
        return response;
    }
}

@Data
@AllArgsConstructor
class ErrorInfo {
    private String code;
    private String message;
}

@Service
@Transactional
public class OrderService {
    
    // 默认情况下，只有RuntimeException会回滚事务
    public void createOrder(Order order) {
        try {
            orderRepository.save(order);
            inventoryService.reduceStock(order.getProductId(), order.getQuantity());
            // 其他业务逻辑...
        } catch (InventoryException e) {
            // 库存不足，需要回滚事务
            throw new RuntimeException("库存操作失败", e); // 这会触发回滚
        }
    }
    
    // 指定特定异常也回滚事务
    @Transactional(rollbackFor = BusinessException.class)
    public void processRefund(String orderId) throws BusinessException {
        // 退款逻辑...
    }
}

// Service层示例
@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public User getUserById(Long id) {
        try {
            return userRepository.findById(id)
                .orElseThrow(() -> new BusinessException("USER_NOT_FOUND", "用户不存在"));
        } catch (DataAccessException e) {
            throw new SystemException("数据库访问异常", e);
        }
    }
    
    public void createUser(User user) {
        if (userRepository.existsByUsername(user.getUsername())) {
            throw new BusinessException("USERNAME_EXISTS", "用户名已存在");
        }
        
        try {
            userRepository.save(user);
        } catch (DataAccessException e) {
            throw new SystemException("用户创建失败", e);
        }
    }
}

try {
    processPayment(order);
} catch (PaymentException e) {
    // 记录必要的上下文信息
    logger.error("支付处理失败, 订单ID: {}, 用户ID: {}, 错误: {}", 
        order.getId(), order.getUserId(), e.getMessage(), e);
    throw new BusinessException("PAYMENT_FAILED", "支付失败，请重试或联系客服");
}

// 定义错误码枚举
public enum ErrorCode {
    // 用户相关
    USER_NOT_FOUND("1001", "用户不存在"),
    USERNAME_EXISTS("1002", "用户名已存在"),
    
    // 订单相关
    ORDER_NOT_FOUND("2001", "订单不存在"),
    INSUFFICIENT_STOCK("2002", "库存不足"),
    
    // 系统相关
    SYSTEM_ERROR("5000", "系统繁忙，请稍后重试");
    
    private final String code;
    private final String message;
    
    // 构造方法、getter...
}

// 前端API调用示例
api.createOrder(orderData)
  .then(response => {
    // 处理成功响应
  })
  .catch(error => {
    if (error.response.data.code === 'INSUFFICIENT_STOCK') {
      // 显示库存不足的特定UI
      showStockWarning();
    } else if (error.response.data.code === 'SYSTEM_ERROR') {
      // 显示系统错误提示
      showSystemError();
    } else {
      // 显示通用错误提示
      showError(error.response.data.message);
    }
  });