后端错误处理与异常捕获：实战策略全解析

// 请求参数类（用注解定义校验规则）
@Data
public class CreateUserRequest {
    @NotNull(message = "用户名不能为空")
    @Size(min = 2, max = 20, message = "用户名需2-20个字符")
    private String username;

    @NotNull(message = "密码不能为空")
    @Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$", 
             message = "密码需含大小写字母+数字，至少8位")
    private String password;
}

// 接口层用@Valid拦截无效参数
@PostMapping("/user")
public ResponseEntity<User> createUser(@Valid @RequestBody CreateUserRequest request) {
    // 不用再写if判断——无效参数会直接抛出MethodArgumentNotValidException
    return userService.create(request);
}

# FastAPI的依赖项实现全局边界校验
from fastapi import Depends, HTTPException

def validate_page_params(page: int = 1, page_size: int = 10):
    if page < 1:
        raise HTTPException(status_code=400, detail="page参数不能小于1")
    if page_size > 100:
        raise HTTPException(status_code=400, detail="pageSize不能超过100")
    return {"page": page, "page_size": page_size}

# 接口中引用依赖项
@app.get("/users")
async def get_users(params: dict = Depends(validate_page_params)):
    return userService.list(params["page"], params["page_size"])

// Java自定义业务异常
public class BusinessException extends RuntimeException {
    private int code; // 错误码（比如400=参数错，500=系统错）
    private String message; // 业务错误信息

    public BusinessException(int code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }

    // getter方法
}

# Python自定义业务异常
class BusinessError(Exception):
    def __init__(self, code: int, msg: str):
        self.code = code
        self.msg = msg
        super().__init__(msg)

@RestControllerAdvice // 全局拦截Controller层异常
public class GlobalExceptionHandler {
    // 拦截业务异常（自定义的BusinessException）
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessError(BusinessException e) {
        ErrorResponse response = new ErrorResponse(e.getCode(), e.getMessage());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }

    // 拦截参数校验异常（Hibernate Validator抛出的）
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleParamError(MethodArgumentNotValidException e) {
        // 提取校验失败的第一条信息
        String msg = e.getBindingResult().getFieldErrors().get(0).getDefaultMessage();
        ErrorResponse response = new ErrorResponse(400, msg);
        return ResponseEntity.badRequest().body(response);
    }

    // 拦截未知异常（兜底用）
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleUnknownError(Exception e) {
        Log.error("未知异常：请求ID={}, 参数={}", getRequestId(), getRequestParams(), e);
        ErrorResponse response = new ErrorResponse(500, "系统繁忙，请稍后重试");
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
    }
}

// 用Logback的JSON编码器
<appender name="JSON_FILE" class="ch.qos.logback.core.FileAppender">
    <file>logs/app.json</file>
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <fieldNames>
            <timestamp>timestamp</timestamp>
            <message>message</message>
            <logger>logger</logger>
            <level>level</level>
            <stack_trace>stack_trace</stack_trace>
        </fieldNames>
    </encoder>
</appender>

// Java用Micrometer记录异常指标
@Autowired
private MeterRegistry meterRegistry;

public void doBusiness() {
    try {
        // 业务逻辑
    } catch (BusinessException e) {
        // 记录异常次数（按错误码分类）
        Counter.builder("business_exception_total")
            .tag("error_code", String.valueOf(e.getCode()))
            .tag("scene", "create_user")
            .register(meterRegistry)
            .increment();
        throw e;
    }
}

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type

@retry(stop=stop_after_attempt(3), # 最多重试3次
       wait=wait_exponential(multiplier=1, min=1, max=10), # 重试间隔指数增长（1s→2s→4s）
       retry=retry_if_exception_type((ConnectionError, TimeoutError))) # 只重试网络异常
def call_third_party_api():
    # 调用第三方接口的逻辑
    response = requests.get("https://api.example.com/data")
    response.raise_for_status()
    return response.json()

// 1. 请求参数类
@Data
public class UpdateUserRequest {
    @NotNull(message = "用户ID不能为空")
    private Long userId;

    @Email(message = "邮箱格式不正确")
    private String email;
}

// 2. 接口层
@PutMapping("/user")
public ResponseEntity<String> updateUser(@Valid @RequestBody UpdateUserRequest request) {
    userService.update(request);
    return ResponseEntity.ok("修改成功");
}

// 3. 全局异常处理器（拦截参数错误）
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleParamError(MethodArgumentNotValidException e) {
        String msg = e.getBindingResult().getFieldErrors().get(0).getDefaultMessage();
        return ResponseEntity.badRequest().body(new ErrorResponse(400, msg));
    }
}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field

app = FastAPI()

# 1. 自定义业务异常
class BusinessError(HTTPException):
    def __init__(self, code: int, msg: str):
        super().__init__(status_code=code, detail=msg)

# 2. 请求参数类
class CreateOrderRequest(BaseModel):
    product_id: int = Field(..., gt=0, description="商品ID必须大于0")
    quantity: int = Field(..., gt=0, le=10, description="购买数量1-10件")

# 3. 接口层（抛出自定义异常）
@app.post("/order")
async def create_order(request: CreateOrderRequest):
    # 模拟库存不足的情况
    if request.product_id == 1001 and request.quantity > 5:
        raise BusinessError(code=400, msg="该商品库存不足")
    return {"order_id": 12345}

# 4. 全局异常处理器
@app.exception_handler(BusinessError)
async def handle_business_error(request, exc):
    return JSONResponse(
        status_code=exc.status_code,
        content={"code": exc.status_code, "message": exc.detail}
    )