@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)); } }
@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; } }