当前位置：首页 > 文章列表 > 文章 > java教程 > Spring验证：抽象参数类的简洁实现方式

Spring验证：抽象参数类的简洁实现方式

2025-10-26 09:09:33 0浏览收藏

从现在开始，我们要努力学习啦！今天我给大家带来《Spring验证：抽象参数类的优雅实现方法》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

Spring Validation：抽象请求参数类的优雅实现

本文旨在解决Spring应用中，如何针对不同类型的报表生成需求，设计可扩展且易于维护的请求参数验证机制。通过使用抽象类和具体的DTO实现，结合Spring Validation框架，实现灵活的参数校验，避免修改核心Controller代码，从而提高代码的可维护性和可扩展性。文章将提供两种实现方案，并详细介绍其使用方法和注意事项。

在Spring Boot项目中，经常会遇到需要根据不同的请求参数生成不同类型的报表的情况。针对这种情况，我们需要一种灵活的参数验证机制，使得在新增报表类型时，无需修改核心Controller代码，只需添加相应的DTO和验证规则即可。以下提供两种实现方案：

方案一：手动注入Validator进行验证

此方案的核心在于手动注入javax.validation.Validator接口，并在代码中显式调用validate方法进行验证。

步骤 1：注入 Validator

首先，在你的Spring组件（例如Service或Controller）中注入Validator接口。Spring会自动注入默认的Validator实例。

import javax.validation.Validator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ReportService {

    @Autowired
    private Validator validator;

    // ...
}

步骤 2：创建DTO类

定义一个抽象的ReportRequestDTO类，包含所有报表类型共有的参数。然后，为每种报表类型创建具体的DTO类，继承自ReportRequestDTO，并添加特定于该报表的参数。

import javax.validation.constraints.NotEmpty;
import lombok.Data;

@Data
public abstract class ReportRequestDTO  {
    @NotEmpty
    private String foo;

    @NotEmpty
    private String bar;

}

import javax.validation.constraints.NotEmpty;
import lombok.Data;
import lombok.EqualsAndHashCode;

@EqualsAndHashCode(callSuper = true)
@Data
public class ReportADTO extends ReportRequestDTO  {
    @NotEmpty
    private String foobar;
}

步骤 3：手动验证 DTO

在你的Service或Controller中，根据报表类型创建相应的DTO实例，并使用validator.validate()方法进行验证。

import javax.validation.ConstraintViolation;
import java.util.Set;

public String generateReport(String reportType, Object requestParams) {
    ReportRequestDTO reportRequestDTO;

    if ("ReportA".equals(reportType)) {
        reportRequestDTO = convertValue(requestParams, ReportADTO.class); // 使用 ObjectMapper 或其他工具将 requestParams 转换为 ReportADTO
    } else {
        // ... 其他报表类型
        reportRequestDTO = convertValue(requestParams, ReportRequestDTO.class);
    }

    Set<ConstraintViolation<ReportRequestDTO>> violations = validator.validate(reportRequestDTO);

    if (!violations.isEmpty()) {
        // 处理验证失败的情况，例如抛出异常
        StringBuilder errorMessage = new StringBuilder();
        for (ConstraintViolation<ReportRequestDTO> violation : violations) {
            errorMessage.append(violation.getMessage()).append("; ");
        }
        throw new IllegalArgumentException("Invalid request parameters: " + errorMessage.toString());
    }

    // 生成报表
    return generateReport(reportRequestDTO);
}

private <T> T convertValue(Object requestParams, Class<T> clazz) {
        // 实现将 requestParams 转换为 clazz 类型的逻辑
        // 例如，使用 ObjectMapper:
        // ObjectMapper objectMapper = new ObjectMapper();
        // return objectMapper.convertValue(requestParams, clazz);
        return null;
    }

优点：

灵活性高，可以根据需要在代码中显式控制验证过程。
可以处理复杂的验证逻辑。

缺点：

代码冗余，需要在每个需要验证的地方手动调用validator.validate()方法。
容易出错，可能会忘记进行验证。

方案二：使用 @Validated 和 @Valid 注解

此方案利用Spring的AOP特性，通过@Validated和@Valid注解实现自动验证。

步骤 1：创建DTO类

与方案一相同，定义抽象的ReportRequestDTO类和具体的DTO类。

步骤 2：创建验证类

创建一个类，并在类上使用@Validated注解，表示该类需要进行验证。在该类的方法参数中使用@Valid注解，表示需要验证该参数。

import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import javax.validation.Valid;

@Component
@Validated
public class ReportValidator {

    public void validateReportA(@Valid ReportADTO reportADTO) {
        // 验证 ReportADTO
    }

    public void validateReportB(@Valid ReportBDTO reportBDTO) {
        // 验证 ReportBDTO
    }
}

步骤 3：在Controller中调用验证方法

在Controller中，注入验证类，并根据报表类型调用相应的验证方法。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.validation.Valid;

@RestController
public class ReportController {

    @Autowired
    private ReportValidator reportValidator;

    @GetMapping("/report")
    @ResponseBody
    public ResponseEntity<String> getReport(
            @RequestParam(value = "category") String category,
            @Valid ReportADTO reportRequestDTO) {

        // 根据 category 选择不同的 DTO 进行验证
        if ("A".equals(category)) {
            reportValidator.validateReportA(reportRequestDTO);
        } else if ("B".equals(category)) {
            // reportValidator.validateReportB(reportRequestDTO); // 需要创建 ReportBDTO 和 validateReportB 方法
        } else {
            throw new IllegalArgumentException("Invalid category: " + category);
        }

        // 生成报表
        return ResponseEntity.ok("Report generated successfully");
    }
}

步骤 4：配置异常处理

配置全局异常处理，捕获MethodArgumentNotValidException异常，该异常会在验证失败时抛出。

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<String> handleValidationException(MethodArgumentNotValidException ex) {
        StringBuilder errorMessage = new StringBuilder();
        ex.getBindingResult().getFieldErrors().forEach(error ->
                errorMessage.append(error.getField()).append(": ").append(error.getDefaultMessage()).append("; "));
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Validation failed: " + errorMessage.toString());
    }

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<String> handleIllegalArgumentException(IllegalArgumentException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(ex.getMessage());
    }
}

优点：