使用@Validated和@Valid与spring验证器

Question

我有一个java bean用于将JSON消息发送到spring @RestController，我有bean验证设置并使用@Valid运行得很好。但我想转向Protobuf / Thrift并远离REST。它是一个内部API，许多大公司已经在内部废除了REST。这真正意味着我不再控制消息对象 - 它们是在外部生成的。我不能再对它们加注释了。

所以现在我的验证必须是程序化的。我该怎么做呢？我编写了一个Validator，它的效果非常好。但它不使用漂亮的@Valid注释。我必须做以下事情：

@Service
public StuffEndpoint implements StuffThriftDef.Iface {

    @Autowired
    private MyValidator myValidator;

    public void things(MyMessage msg) throws BindException {
        BindingResult errors = new BeanPropertyBindingResult(msg, msg.getClass().getName());
        errors = myValidator.validate(msg);
        if (errors.hasErrors()) {
            throw new BindException(errors);
        } else {
            doRealWork();
        }
    }
}

这很臭。我必须在每一种方法中都这样做。现在，我可以将很多内容放入一个抛出BindException的方法中，这样就可以将一行代码添加到每个方法中。但那仍然不是很好。

我想要的是看起来像这样：

@Service
@Validated
public StuffEndpoint implements StuffThriftDef.Iface {

    public void things(@Valid MyMessage msg) {
        doRealWork();
    }
}

仍然得到相同的结果。记住，我的bean没有注释。是的，我知道我可以在方法上使用@InitBinder注释。但这仅适用于网络请求。

我不介意在这个类中注入正确的Validator，但我更喜欢我的ValidatorFactory可以根据supports()方法提取正确的。{/ p>

这可能吗？有没有办法配置bean验证来实际使用Spring验证？我是否必须在某个地方劫持一个方面？入侵LocalValidatorFactory或MethodValidationPostProcessor？

感谢。

Answer 1

将Spring验证和JSR-303约束结合起来非常复杂。并且没有准备好使用＆＃39;办法。主要不便之处在于Spring验证使用BindingResult，而JSR-303使用ConstraintValidatorContext作为验证结果。

您可以尝试使用Spring AOP制作自己的验证引擎。让我们考虑一下，我们需要为此做些什么。首先，声明AOP依赖（如果你还没有）：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjrt</artifactId>
   <version>1.8.8</version>
   <scope>runtime</scope>
</dependency>
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.8.8</version>
</dependency>

我使用版本为4.2.4.RELEASE的Spring，但是因为你可以使用自己的版本。 AspectJ需要使用方面注释。下一步，我们必须创建简单的验证器注册表：

public class CustomValidatorRegistry {

    private List<Validator> validatorList = new ArrayList<>();

    public void addValidator(Validator validator){
        validatorList.add(validator);
    }

    public List<Validator> getValidatorsForObject(Object o) {
        List<Validator> result = new ArrayList<>();
        for(Validator validator : validatorList){
            if(validator.supports(o.getClass())){
                result.add(validator);
            }
        }
        return result;
    }
}

如你所见，这是一个非常简单的类，它允许我们找到对象的验证器。现在让我们创建需要验证的注释，即标记方法：

package com.mydomain.validation;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomValidation {
}

由于标准BindingException类不是RuntimeException，我们无法在覆盖方法中使用它。这意味着我们需要定义自己的异常：

public class CustomValidatorException extends RuntimeException {

    private BindingResult bindingResult;

    public CustomValidatorException(BindingResult bindingResult){
        this.bindingResult = bindingResult;
    }

    public BindingResult getBindingResult() {
        return bindingResult;
    }
}

现在我们已经准备好创建一个可以完成大部分工作的方面。 Aspect将在方法之前执行，方法标有CustomValidation注释：

@Aspect
@Component
public class CustomValidatingAspect {

    @Autowired
    private CustomValidatorRegistry registry; //aspect will use our validator registry


    @Before(value = "execution(public * *(..)) && annotation(com.mydomain.validation.CustomValidation)")
    public void doBefore(JoinPoint point){
        Annotation[][] paramAnnotations  =
                ((MethodSignature)point.getSignature()).getMethod().getParameterAnnotations();
        for(int i=0; i<paramAnnotations.length; i++){
            for(Annotation annotation : paramAnnotations[i]){
                //checking for standard org.springframework.validation.annotation.Validated
                if(annotation.annotationType() == Validated.class){
                    Object arg = point.getArgs()[i];
                    if(arg==null) continue;
                    validate(arg);
                }
            }
        }
    }

    private void validate(Object arg) {
        List<Validator> validatorList = registry.getValidatorsForObject(arg);
        for(Validator validator : validatorList){
            BindingResult errors = new BeanPropertyBindingResult(arg, arg.getClass().getSimpleName());
            validator.validate(arg, errors);
            if(errors.hasErrors()){
                throw new CustomValidatorException(errors);
            }
        }
    }
}

execution(public * *(..)) && @annotation(com.springapp.mvc.validators.CustomValidation)表示此方面将应用于bean的任何公共方法，标记为@CustomValidation注释。另请注意，为了标记经过验证的参数，我们使用标准org.springframework.validation.annotation.Validated注释。但是因为我们可以做出我们的习惯。我认为方面的其他代码非常简单，不需要任何评论。示例验证器的进一步代码：

public class PersonValidator implements Validator {
    @Override
    public boolean supports(Class<?> aClass) {
        return aClass==Person.class;
    }

    @Override
    public void validate(Object o, Errors errors) {
        Person person = (Person)o;
        if(person.getAge()<=0){
            errors.rejectValue("age", "Age is too small");
        }
    }
}

现在我们已经调整配置并准备好使用了所有内容：

@Configuration
@ComponentScan(basePackages = "com.mydomain")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AppConfig{

    .....

    @Bean
    public CustomValidatorRegistry validatorRegistry(){
        CustomValidatorRegistry registry = new CustomValidatorRegistry();
        registry.addValidator(new PersonValidator());
        return registry;
    }    
}

注意，proxyTargetClass是true，因为我们将使用cglib类代理。

服务类中的目标方法示例：

@Service
public class PersonService{

    @CustomValidation
    public void savePerson(@Validated Person person){        
       ....
    }

}

由于@CustomValidation注释方面将被应用，并且由于@Validated注释person将被验证。以及在控制器（或任何其他类）中使用服务的示例：

@Controller
public class PersonConroller{

    @Autowired
    private PersonService service;

    public String savePerson(@ModelAttribute Person person, ModelMap model){
        try{
            service.savePerson(person);
        }catch(CustomValidatorException e){
            model.addAttribute("errors", e.getBindingResult());
            return "viewname";
        }
        return "viewname";
    }

}

请注意，如果您要从@CustomValidation类的方法调用PersonService，则验证将无效。因为它会调用原始类的方法，而不是代理。这意味着，如果您希望验证工作（例如@Transactional works same way），则只能从类外部（从其他类）调用此方法。

很抱歉很长的帖子。我的答案不是关于简单的陈述方式，而且可能你不需要它。但我很好奇解决了这个问题。

Answer 2

我将@ Ken的回答标记为正确，因为它是。但我已经采取了一些进一步的想要发布我所做的。我希望任何人来到这个页面会发现它很有趣。我可能会尝试在Spring人员面前看看它是否可能包含在未来版本中。

我们的想法是使用新的注释来替换@Valid。所以我称之为@SpringValid。使用此注释将启动上面的系统。以下是所有部分：

<强> SpringValid.java

package org.springframework.validation.annotation;

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

@Target({METHOD, FIELD, CONSTRUCTOR, PARAMETER})
@Retention(RUNTIME)
public @interface SpringValid {

}

<强> SpringValidationAspect.java

package org.springframework.validation;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Aspect
@Component
public class SpringValidationAspect {

  private SpringValidatorRegistry springValidatorRegistry;

  @Autowired
  public SpringValidationAspect(final SpringValidatorRegistry springValidatorRegistry) {
    this.springValidatorRegistry = springValidatorRegistry;
  }

  public SpringValidatorRegistry getSpringValidatorRegistry() {
    return springValidatorRegistry;
  }

  @Before("@target(org.springframework.validation.annotation.Validated) "
      + "&& execution(public * *(@org.springframework.validation.annotation.SpringValid (*), ..)) "
      + "&& args(validationTarget)")
  public void beforeMethodThatNeedsValidation(Object validationTarget) {
    validate(validationTarget);
  }

  private void validate(Object arg) {
    List<Validator> validatorList = springValidatorRegistry.getValidatorsForObject(arg);
    for (Validator validator : validatorList) {
      BindingResult errors = new BeanPropertyBindingResult(arg, arg.getClass().getSimpleName());
      validator.validate(arg, errors);
      if (errors.hasErrors()) {
        throw new SpringValidationException(errors);
      }
    }
  }
}

Spring的例子显示了用@Validated注释的类，所以我想保留它。上述方面仅针对类级别@Validated的类。而且，就像使用@Valid时一样，它会查找粘贴到方法参数的@SpringValid注释。

<强> SpringValidationException.java

package org.springframework.validation;

import org.springframework.validation.BindingResult;

public class SpringValidationException extends RuntimeException {

  private static final long serialVersionUID = 1L;

  private BindingResult bindingResult;

  public SpringValidationException(final BindingResult bindingResult) {
    this.bindingResult = bindingResult;
  }

  public BindingResult getBindingResult() {
    return bindingResult;
  }
}

<强> SpringValidatorRegistry.java

package org.springframework.validation;

import org.springframework.validation.Validator;

import java.util.ArrayList;
import java.util.List;

public class SpringValidatorRegistry {

  private List<Validator> validatorList = new ArrayList<>();

  public void addValidator(Validator validator) {
    validatorList.add(validator);
  }

  public List<Validator> getValidatorsForObject(Object o) {
    List<Validator> result = new ArrayList<>();
    for (Validator validator : validatorList) {
      if (validator.supports(o.getClass())) {
        result.add(validator);
      }
    }
    return result;
  }
}

就像第一个答案一样，是一个注册所有实现Spring org.springframework.validation.Validator接口的类的地方。

<强> SpringValidator.java

package org.springframework.validation.annotation;

import org.springframework.stereotype.Component;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface SpringValidator {

}

这只是额外的调整，以便更容易注册/查找Validators。您可以手动注册所有Validators，也可以通过反射找到它们。所以这部分不是必需的，我只是觉得它让事情变得更容易。

<强> MyConfig.java

package com.example.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.SpringValidationAspect;
import org.springframework.validation.SpringValidatorRegistry;
import org.springframework.validation.annotation.SpringValidator;

import java.util.Map;

import javax.validation.Validator;

@Configuration
public class MyConfig {

  @Autowired
  private ApplicationContext applicationContext;

  @Bean
  public SpringValidatorRegistry validatorRegistry() {
    SpringValidatorRegistry registry = new SpringValidatorRegistry();
    Map<String, Object> validators =
        applicationContext.getBeansWithAnnotation(SpringValidator.class);
    validators.values()
        .forEach(v -> registry.addValidator((org.springframework.validation.Validator) v));
    return registry;
  }

  @Bean
  public SpringValidationAspect springValidationAspect() {
    return new SpringValidationAspect(validatorRegistry());
  }
}

请参阅，扫描您的类路径并查找@SpringValidator类并注册它们。然后注册Aspect然后离开。

以下是此类验证器的示例： 的 MyMessageValidator.java

package com.example.validators;

import com.example.messages.MyMessage;

import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import org.springframework.validation.annotation.SpringValidator;

@SpringValidator
public class MyMessageValidator implements Validator {

  @Override
  public boolean supports(Class<?> clazz) {
    return MyMessage.class.isAssignableFrom(clazz);
  }

  @Override
  public void validate(Object target, Errors errors) {
    ValidationUtils.rejectIfEmpty(errors, "firstField", "{javax.validation.constraints.NotNull}",
    "firstField cannot be null");
    MyMessage obj = (MyMessage) target;
    if (obj.getSecondField != null && obj.getSecondField > 100) {
      errors.rejectField(errors, "secondField", "{javax.validation.constraints.Max}", "secondField is too big");
    }
  }
}

这是使用@SpringValid注释的服务类：

<强> MyService.java

package com.example.services;

import com.example.messages.MyMessage;

import org.springframework.validation.annotation.SpringValid;
import org.springframework.validation.annotation.Validated;

import javax.inject.Inject;

@Validated
public class MyService {

  public String doIt(@SpringValid final MyMessage msg) {
    return "we did it!";
  }
}

希望这在某些方面对某些人有意义。我个人认为它非常有用。许多公司开始将其内部API从REST转移到Protobuf或Thrift之类的东西。你仍然可以使用Bean验证，但你必须使用XML，它并不是那么好。所以我希望这对那些想要进行程序化验证的人有所帮助。

Answer 3

希望它有所帮助。我通过添加以下配置来实现它：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;

@Configuration
public class ValidatorConfiguration {

    @Bean
    public MethodValidationPostProcessor getMethodValidationPostProcessor(){
        MethodValidationPostProcessor processor = new MethodValidationPostProcessor();
         processor.setValidator(this.validator());
         return processor;
     }

     @Bean
     public LocalValidatorFactoryBean validator(){
         return new LocalValidatorFactoryBean();
     }

 }

然后以相同的方式注释服务（@Validated类和@Valid参数）并且可以注入到另一个bean中，可以直接调用该方法并进行验证。