How to use org.springframework.validation.beanvalidation

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  if (this.afterInitialization) {
    doValidate(bean);
  }
  return bean;
}

@Override
public void destroy() {
  close();
}

/**
 * Specify a custom Spring MessageSource for resolving validation messages,
 * instead of relying on JSR-303's default "ValidationMessages.properties" bundle
 * in the classpath. This may refer to a Spring context's shared "messageSource" bean,
 * or to some special MessageSource setup for validation purposes only.
 * <p><b>NOTE:</b> This feature requires Hibernate Validator 4.3 or higher on the classpath.
 * You may nevertheless use a different validation provider but Hibernate Validator's
 * {@link ResourceBundleMessageInterpolator} class must be accessible during configuration.
 * <p>Specify either this property or {@link #setMessageInterpolator "messageInterpolator"},
 * not both. If you would like to build a custom MessageInterpolator, consider deriving from
 * Hibernate Validator's {@link ResourceBundleMessageInterpolator} and passing in a
 * Spring-based {@code ResourceBundleLocator} when constructing your interpolator.
 * <p>In order for Hibernate's default validation messages to be resolved still, your
 * {@link MessageSource} must be configured for optional resolution (usually the default).
 * In particular, the {@code MessageSource} instance specified here should not apply
 * {@link org.springframework.context.support.AbstractMessageSource#setUseCodeAsDefaultMessage
 * "useCodeAsDefaultMessage"} behavior. Please double-check your setup accordingly.
 * @see ResourceBundleMessageInterpolator
 */
public void setValidationMessageSource(MessageSource messageSource) {
  this.messageInterpolator = HibernateValidatorDelegate.buildMessageInterpolator(messageSource);
}

@Test
public void testSpringValidationFieldType() {
  LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
  validator.afterPropertiesSet();
  ValidPerson person = new ValidPerson();
  person.setName("Phil");
  person.getAddress().setStreet("Phil's Street");
  BeanPropertyBindingResult errors = new BeanPropertyBindingResult(person, "person");
  validator.validate(person, errors);
  assertEquals(1, errors.getErrorCount());
  assertThat("Field/Value type mismatch", errors.getFieldError("address").getRejectedValue(),
      instanceOf(ValidAddress.class));
}

@Test
public void testInnerBeanValidation() {
  LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
  validator.afterPropertiesSet();
  MainBean mainBean = new MainBean();
  Errors errors = new BeanPropertyBindingResult(mainBean, "mainBean");
  validator.validate(mainBean, errors);
  Object rejected = errors.getFieldValue("inner.value");
  assertNull(rejected);
}

@Test  // SPR-16177
public void testWithList() {
  Parent parent = new Parent();
  parent.setName("Parent whit list");
  parent.getChildList().addAll(createChildren(parent));
  BeanPropertyBindingResult errors = new BeanPropertyBindingResult(parent, "parent");
  validatorAdapter.validate(parent, errors);
  assertTrue(errors.getErrorCount() > 0);
}

@Test  // SPR-16177
public void testWithSet() {
  Parent parent = new Parent();
  parent.setName("Parent with set");
  parent.getChildSet().addAll(createChildren(parent));
  BeanPropertyBindingResult errors = new BeanPropertyBindingResult(parent, "parent");
  validatorAdapter.validate(parent, errors);
  assertTrue(errors.getErrorCount() > 0);
}

@Test
public void testMethodValidationInterceptor() {
  MyValidBean bean = new MyValidBean();
  ProxyFactory proxyFactory = new ProxyFactory(bean);
  proxyFactory.addAdvice(new MethodValidationInterceptor());
  proxyFactory.addAdvisor(new AsyncAnnotationAdvisor());
  doTestProxyValidation((MyValidInterface) proxyFactory.getProxy());
}

/**
 * Create AOP advice for method validation purposes, to be applied
 * with a pointcut for the specified 'validated' annotation.
 * @param validator the JSR-303 Validator to delegate to
 * @return the interceptor to use (typically, but not necessarily,
 * a {@link MethodValidationInterceptor} or subclass thereof)
 * @since 4.2
 */
protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
  return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
}

@Override
public void validate(Object target, Errors errors, Object... validationHints) {
  if (this.targetValidator != null) {
    processConstraintViolations(
        this.targetValidator.validate(target, asValidationGroups(validationHints)), errors);
  }
}

  public static MessageInterpolator buildMessageInterpolator(MessageSource messageSource) {
    return new ResourceBundleMessageInterpolator(new MessageSourceResourceBundleLocator(messageSource));
  }
}

private List<Child> createChildren(Parent parent) {
  Child child1 = new Child();
  child1.setName("Child1");
  child1.setAge(null);
  child1.setParent(parent);
  Child child2 = new Child();
  child2.setName(null);
  child2.setAge(17);
  child2.setParent(parent);
  return Arrays.asList(child1, child2);
}

@Override
public void validate(Object target, Errors errors) {
  if (this.targetValidator != null) {
    processConstraintViolations(this.targetValidator.validate(target), errors);
  }
}

public void initialize(Same constraintAnnotation) {
  field = constraintAnnotation.field();
  comparingField = constraintAnnotation.comparingField();
  message = constraintAnnotation.message();
}

public static class MainBean {
  @InnerValid
  private InnerBean inner = new InnerBean();
  public InnerBean getInner() {
    return inner;
  }
}

@MyStereotype
public static class MyValidBean implements MyValidInterface<String> {
  @Override
  public Object myValidMethod(String arg1, int arg2) {
    return (arg2 == 0 ? null : "value");
  }
  @Override
  public void myValidAsyncMethod(String arg1, int arg2) {
  }
  @Override
  public String myGenericMethod(String value) {
    return value;
  }
}

public static class ListContainer {
  @NotXList
  private List<String> list = new LinkedList<>();
  public void addString(String value) {
    list.add(value);
  }
  public List<String> getList() {
    return list;
  }
}

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  if (!this.afterInitialization) {
    doValidate(bean);
  }
  return bean;
}

public static class MainBeanWithOptional {
  @InnerValid
  private InnerBean inner = new InnerBean();
  public Optional<InnerBean> getInner() {
    return Optional.ofNullable(inner);
  }
}

@MyStereotype
public static class MyValidFactoryBean implements FactoryBean<String>, MyValidInterface<String> {
  @Override
  public String getObject() {
    return null;
  }
  @Override
  public Class<?> getObjectType() {
    return String.class;
  }
  @Override
  public Object myValidMethod(String arg1, int arg2) {
    return (arg2 == 0 ? null : "value");
  }
  @Override
  public void myValidAsyncMethod(String arg1, int arg2) {
  }
  @Override
  public String myGenericMethod(String value) {
    return value;
  }
}