基于JSR 303/380的Java Bean级联验证定制与拦截增强咨询

Hey there! Let's tackle your questions about customizing cascading validation with JSR 303/380 and modifying the behavior of the @Valid annotation for cascading checks.

If you need to add custom logic to cascading validation, the best approach is to create your own constraint annotation paired with a custom validator. Here's a step-by-step example:

1. 自定义约束注解 #

First, define an annotation that replaces or extends @Valid for your cascading needs:

@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = CustomCascadingValidator.class)
@Documented
public @interface ValidWithExtraProcessing {
    String message() default "Cascading validation failed with custom checks";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

2. 实现自定义Validator #

Next, write the validator that handles both standard cascading validation and your extra logic:

public class CustomCascadingValidator implements ConstraintValidator<ValidWithExtraProcessing, Object> {
    private final ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
    private final Validator standardValidator = validatorFactory.getValidator();

    @Override
    public boolean isValid(Object nestedBean, ConstraintValidatorContext context) {
        if (nestedBean == null) {
            return true;
        }

        // Step 1: Run standard cascading validation
        Set<ConstraintViolation<Object>> standardViolations = standardValidator.validate(nestedBean);
        
        // Step 2: Execute your custom extra processing
        runCustomExtraLogic(nestedBean, context);
        
        // Step 3: Merge standard violations into the context
        for (ConstraintViolation<Object> violation : standardViolations) {
            context.buildConstraintViolationWithTemplate(violation.getMessage())
                   .addPropertyNode(violation.getPropertyPath().toString())
                   .addConstraintViolation();
        }

        // Return true only if both standard validation and custom checks pass
        return standardViolations.isEmpty() && isCustomChecksPassed(nestedBean);
    }

    private void runCustomExtraLogic(Object nestedBean, ConstraintValidatorContext context) {
        // Example: Add a custom validation rule for a specific bean type
        if (nestedBean instanceof UserProfile) {
            UserProfile profile = (UserProfile) nestedBean;
            if (profile.getAge() < 18 && profile.isAllowMinorAccess()) {
                context.buildConstraintViolationWithTemplate("Minors cannot access restricted features without consent")
                       .addPropertyNode("allowMinorAccess")
                       .addConstraintViolation();
            }
        }
        // You can also add logging, audit trails, or external service calls here
    }

    private boolean isCustomChecksPassed(Object nestedBean) {
        if (nestedBean instanceof UserProfile) {
            UserProfile profile = (UserProfile) nestedBean;
            return !(profile.getAge() < 18 && profile.isAllowMinorAccess());
        }
        return true;
    }
}

3. 在Bean中使用自定义注解 #

Replace the standard @Valid with your custom annotation:

public class User {
    @NotBlank(message = "Username cannot be empty")
    private String username;

    @ValidWithExtraProcessing // Use your custom cascading validator
    private UserProfile profile;

    // Getters and setters
}

Absolutely! There are three main approaches to modify the behavior of @Valid-driven cascading validation:

1. 完全替换@Valid #

As shown above, you can create a custom constraint annotation that takes over cascading validation entirely. This gives you full control over the validation flow and allows you to inject any extra logic you need.

2. 增强@Valid的验证逻辑 #

You can enhance the standard @Valid validation by customizing the ConstraintValidatorFactory. This lets you wrap all validators with cross-cutting logic (like pre/post validation hooks):

public class EnhancedValidatorFactory implements ConstraintValidatorFactory {
    private final ConstraintValidatorFactory delegate;

    public EnhancedValidatorFactory(ConstraintValidatorFactory delegate) {
        this.delegate = delegate;
    }

    @Override
    public <T extends ConstraintValidator<?, ?>> T getInstance(Class<T> validatorClass) {
        T validator = delegate.getInstance(validatorClass);
        // Wrap the validator in a proxy to add extra logic
        return (T) Proxy.newProxyInstance(
            validator.getClass().getClassLoader(),
            validator.getClass().getInterfaces(),
            (proxy, method, args) -> {
                if ("isValid".equals(method.getName())) {
                    // Pre-validation logic: e.g., log validation start
                    logValidationStart(args[0]);
                    // Execute the standard validation
                    Object result = method.invoke(validator, args);
                    // Post-validation logic: e.g., log validation result
                    logValidationResult(args[0], result);
                    return result;
                }
                return method.invoke(validator, args);
            }
        );
    }

    private void logValidationStart(Object bean) {
        System.out.printf("Starting validation for bean: %s%n", bean.getClass().getSimpleName());
    }

    private void logValidationResult(Object bean, Object isValid) {
        System.out.printf("Validation for bean %s completed. Result: %b%n", bean.getClass().getSimpleName(), isValid);
    }

    @Override
    public void releaseInstance(ConstraintValidator<?, ?> instance) {
        delegate.releaseInstance(instance);
    }
}

To use this in a standard setup:

ValidatorFactory factory = Validation.byDefaultProvider()
    .configure()
    .constraintValidatorFactory(new EnhancedValidatorFactory(Validation.byDefaultProvider().configure().getConstraintValidatorFactory()))
    .buildValidatorFactory();
Validator validator = factory.getValidator();

In Spring, you can wire this into a LocalValidatorFactoryBean for global use.

3. 拦截级联验证触发 #

Use a custom TraversableResolver to intercept when @Valid is triggered for a nested property. This resolver controls which properties are considered reachable and cascadable:

public class InterceptingTraversableResolver implements TraversableResolver {
    private final TraversableResolver delegate;

    public InterceptingTraversableResolver(TraversableResolver delegate) {
        this.delegate = delegate;
    }

    @Override
    public boolean isReachable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType, Path pathToTraversableObject, ElementType elementType) {
        boolean isReachable = delegate.isReachable(traversableObject, traversableProperty, rootBeanType, pathToTraversableObject, elementType);
        
        // Check if the property has @Valid annotation
        if (isReachable && traversableProperty.getAnnotation(Valid.class) != null) {
            // Execute your interception logic here
            System.out.printf("Intercepted cascading validation for property: %s%n", traversableProperty.getName());
            performExtraInterception(traversableObject);
        }
        
        return isReachable;
    }

    private void performExtraInterception(Object bean) {
        // Example: Modify bean state, trigger external checks, or log
        System.out.printf("Running extra logic on bean: %s%n", bean.getClass().getSimpleName());
    }

    @Override
    public boolean isCascadable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType, Path pathToTraversableObject, ElementType elementType) {
        return delegate.isCascadable(traversableObject, traversableProperty, rootBeanType, pathToTraversableObject, elementType);
    }
}

Configure this resolver in your ValidatorFactory:

ValidatorFactory factory = Validation.byDefaultProvider()
    .configure()
    .traversableResolver(new InterceptingTraversableResolver(Validation.byDefaultProvider().configure().getTraversableResolver()))
    .buildValidatorFactory();
Validator validator = factory.getValidator();

内容的提问来源于stack exchange，提问作者Craig Neuwirt