处理Java中Integer类型参数的非数字输入：验证与异常处理

public class MyRequest {
    @NotNull
    @Digits(integer = 4, fraction = 0, message = "Provide valid Year in the format YYYY")
    @Min(value = 1900, message = "Year must be greater than 1900")
    private Integer year;

    // Getter and Setter
}

"Failed to convert property value of type 'java.lang.String' to required type 'java.lang.Integer' for property 'year'; nested exception is java.lang.NumberFormatException: For input string: "20c15""

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import com.fasterxml.jackson.databind.exc.MismatchedInputException;

@ControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 处理请求参数类型不匹配异常（如Integer字段接收非数字字符串）
     * 针对 @RequestParam, @PathVariable, @ModelAttribute
     */
    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    public ResponseEntity<String> handleMethodArgumentTypeMismatch(MethodArgumentTypeMismatchException ex) {
        String paramName = ex.getName();
        String requiredType = ex.getRequiredType() != null ? ex.getRequiredType().getSimpleName() : "unknown";
        String errorMessage = String.format("参数 '%s' 类型错误，期望类型为 '%s'，但接收到无法转换的值。", paramName, requiredType);
        return new ResponseEntity<>(errorMessage, HttpStatus.BAD_REQUEST);
    }

    /**
     * 处理请求体JSON反序列化类型不匹配异常
     * 针对 @RequestBody，当JSON字段类型与Java对象字段类型不匹配时
     */
    @ExceptionHandler(MismatchedInputException.class)
    public ResponseEntity<String> handleMismatchedInputException(MismatchedInputException ex) {
        String fieldName = ex.getPath().stream()
                               .map(p -> p.getFieldName())
                               .filter(name -> name != null)
                               .reduce((first, second) -> second) // 获取最后一个字段名
                               .orElse("未知字段");
        String errorMessage = String.format("请求体中字段 '%s' 类型错误，请提供有效的值。", fieldName);
        return new ResponseEntity<>(errorMessage, HttpStatus.BAD_REQUEST);
    }

    /**
     * 处理更通用的HTTP消息不可读异常，通常包含MismatchedInputException
     * 当请求体格式不正确或内容无法解析时
     */
    @ExceptionHandler(HttpMessageNotReadableException.class)
    public ResponseEntity<String> handleHttpMessageNotReadable(HttpMessageNotReadableException ex) {
        // 尝试获取更具体的异常信息
        Throwable cause = ex.getCause();
        if (cause instanceof MismatchedInputException) {
            return handleMismatchedInputException((MismatchedInputException) cause);
        }
        return new ResponseEntity<>("请求体格式错误或内容无法解析，请检查请求。", HttpStatus.BAD_REQUEST);
    }

    /**
     * 处理Bean Validation失败的异常
     * 当 @Valid 或 @Validated 验证失败时
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<String> handleValidationExceptions(MethodArgumentNotValidException ex) {
        String errors = ex.getBindingResult()
                          .getFieldErrors()
                          .stream()
                          .map(error -> error.getField() + ": " + error.getDefaultMessage())
                          .reduce("", (acc, msg) -> acc + msg + "; ");
        return new ResponseEntity<>("验证失败: " + errors, HttpStatus.BAD_REQUEST);
    }

    // 可以添加其他通用异常处理
    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleAllExceptions(Exception ex) {
        return new ResponseEntity<>("服务器内部错误：" + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

import javax.validation.constraints.Pattern;
import javax.validation.constraints.NotNull;

public class MyRequest {

    @NotNull(message = "年份不能为空")
    @Pattern(regexp = "^\d{4}$", message = "年份必须是四位数字")
    private String yearString; // 使用String类型接收年份

    // Getter and Setter for yearString

    // 提供一个方法来获取转换后的Integer值
    public Integer getYear() {
        if (yearString == null || yearString.isEmpty()) {
            return null;
        }
        try {
            // 在这里执行实际的Integer转换，并可以添加额外的业务逻辑验证
            int parsedYear = Integer.parseInt(yearString);
            if (parsedYear < 1900) {
                // 抛出自定义异常或处理业务规则
                throw new IllegalArgumentException("年份必须大于1900");
            }
            return parsedYear;
        } catch (NumberFormatException e) {
            // 理论上@Pattern已经过滤了非数字，但作为防御性编程，仍可捕获
            throw new IllegalArgumentException("年份格式不正确，无法转换为数字。", e);
        }
    }
}