在 Spring Data 中创建自定义验证器：综合指南

spring data 的验证框架提供了强大的内置验证器，但有时我们需要针对特定​​业务规则自定义验证逻辑。在本文中，我将向您展示如何在 spring data 中创建和实现自定义验证器。

spring 中的自定义验证器允许我们定义 @notnull 或 @size 等标准注释未涵盖的特定验证规则。它们在处理复杂的业务逻辑或特定于域的验证要求时特别有用。

让我们创建一个自定义验证器来检查字符串是否遵循特定的业务格式。这是一个分步示例：

1. 首先，创建自定义注释：

@documented
@constraint(validatedby = businesscodevalidator.class)
@target({elementtype.field})
@retention(retentionpolicy.runtime)
public @interface validbusinesscode {
    string message() default "invalid business code format";
    class<?>[] groups() default {};
    class<? extends payload>[] payload() default {};
}

1. 实现验证器类：

public class businesscodevalidator implements constraintvalidator<validbusinesscode, string> {

    @override
    public void initialize(validbusinesscode constraintannotation) {
        // initialization logic if needed
    }

    @override
    public boolean isvalid(string value, constraintvalidatorcontext context) {
        if (value == null) {
            return true; // let @notnull handle null checking
        }

        // custom validation logic
        return value.matches("^bc-[0-9]{4}-[a-z]{2}$");
    }
}

1. 将验证器应用于您的实体：

@entity
public class business {
    @id
    @generatedvalue(strategy = generationtype.identity)
    private long id;

    @validbusinesscode
    private string businesscode;

    // getters and setters
}

有时你需要组合多个验证规则。以下是创建复合验证器的方法：

@documented
@constraint(validatedby = compositevalidator.class)
@target({elementtype.type})
@retention(retentionpolicy.runtime)
public @interface validbusinessentity {
    string message() default "business validation failed";
    class<?>[] groups() default {};
    class<? extends payload>[] payload() default {};
}

public class compositevalidator implements constraintvalidator<validbusinessentity, business> {

    @override
    public boolean isvalid(business business, constraintvalidatorcontext context) {
        boolean isvalid = true;

        if (!isvalidbusinesscode(business.getbusinesscode())) {
            context.buildconstraintviolationwithtemplate("invalid business code")
                   .addpropertynode("businesscode")
                   .addconstraintviolation();
            isvalid = false;
        }

        if (!isvaliddaterange(business.getstartdate(), business.getenddate())) {
            context.buildconstraintviolationwithtemplate("invalid date range")
                   .addpropertynode("daterange")
                   .addconstraintviolation();
            isvalid = false;
        }

        return isvalid;
    }
}

对于涉及多个字段的验证：

@validdaterange
public class daterange {
    private localdate startdate;
    private localdate enddate;
    // getters and setters
}

public class daterangevalidator implements constraintvalidator<validdaterange, daterange> {

    @override
    public boolean isvalid(daterange range, constraintvalidatorcontext context) {
        if (range.getstartdate() == null || range.getenddate() == null) {
            return true;
        }

        return !range.getstartdate().isafter(range.getenddate());
    }
}

1. 关注点分离：将验证逻辑隔离在专用验证器类中。

2. 有意义的消息：提供清晰、用户友好的验证消息：

@validbusinesscode(message = "business code must follow format: bc-xxxx-yy")
private string businesscode;

1. 空值处理：明确验证器中的空值处理：

@override
public boolean isvalid(string value, constraintvalidatorcontext context) {
    if (value == null) {
        return true; // or false, depending on your requirements
    }
    // validation logic
}

1. 特定于上下文的验证：针对不同的验证上下文使用验证组：

public interface createvalidation {}
public interface updatevalidation {}

@validbusinesscode(groups = {createvalidation.class})
private string businesscode;

不要忘记测试你的验证器：

@test
public void testbusinesscodevalidator() {
    validatorfactory factory = validation.builddefaultvalidatorfactory();
    validator validator = factory.getvalidator();

    business business = new business();
    business.setbusinesscode("invalid-code");

    set<constraintviolation<business>> violations = validator.validate(business);
    assertfalse(violations.isempty());
    assertequals("invalid business code format", 
                 violations.iterator().next().getmessage());
}

实现全局异常处理程序来管理验证错误：

@ControllerAdvice
public class ValidationExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, List<String>>> handleValidationErrors(
            MethodArgumentNotValidException ex) {
        List<String> errors = ex.getBindingResult()
                               .getFieldErrors()
                               .stream()
                               .map(FieldError::getDefaultMessage)
                               .collect(Collectors.toList());
        return new ResponseEntity<>(getErrorsMap(errors), HttpStatus.BAD_REQUEST);
    }

    private Map<String, List<String>> getErrorsMap(List<String> errors) {
        Map<String, List<String>> errorResponse = new HashMap<>();
        errorResponse.put("errors", errors);
        return errorResponse;
    }
}

spring data 中的自定义验证器提供了一种实现复杂验证规则的强大方法。通过遵循这些模式和最佳实践，您可以创建可维护、可重用的验证组件，从而增强应用程序的数据完整性。

请记住让验证者保持专注、经过充分测试并记录在案。这将使它们更容易在您的应用程序中维护和重用。

此处提供的示例应该为您在 spring data 项目中实现您自己的自定义验证器奠定坚实的基础。快乐编码！

以上就是在 Spring Data 中创建自定义验证器：综合指南的详细内容，更多请关注图灵教育其它相关文章！