Package org.springframework.validation

Interface Validator

All Known Subinterfaces:
SmartValidator
All Known Implementing Classes:
CustomValidatorBean, LocalValidatorFactoryBean, OptionalValidatorFactoryBean, SpringValidatorAdapter
public interface Validator
A validator for application-specific objects.

This interface is totally divorced from any infrastructure or context; that is to say it is not coupled to validating only objects in the web tier, the data-access tier, or the whatever-tier. As such it is amenable to being used in any layer of an application, and supports the encapsulation of validation logic as a first-class citizen in its own right.

Implementations can be created via the static factory methods forInstanceOf(Class, BiConsumer) or forType(Class, BiConsumer). Below is a simple but complete Validator that validates that the various String properties of a UserLogin instance are not empty (they are not null and do not consist wholly of whitespace), and that any password that is present is at least 'MINIMUM_PASSWORD_LENGTH' characters in length. 

Validator userLoginValidator = Validator.forInstance(UserLogin.class, (login, errors) -> {
   ValidationUtils.rejectIfEmptyOrWhitespace(errors, "userName", "field.required");
   ValidationUtils.rejectIfEmptyOrWhitespace(errors, "password", "field.required");
   if (login.getPassword() != null
         && login.getPassword().trim().length() < MINIMUM_PASSWORD_LENGTH) {
      errors.rejectValue("password", "field.min.length",
            new Object[]{Integer.valueOf(MINIMUM_PASSWORD_LENGTH)},
            "The password must be at least [" + MINIMUM_PASSWORD_LENGTH + "] characters in length.");
   }
 });

See also the Spring reference manual for a fuller discussion of the Validator interface and its role in an enterprise application.

Author:
Rod Johnson, Juergen Hoeller, Toshiaki Maki, Arjen Poutsma
See Also:

  • Method Details

    • supports

      boolean supports(Class<?> clazz)
      Can this Validator validate instances of the supplied clazz?

      This method is typically implemented like so: 

      return Foo.class.isAssignableFrom(clazz);
      (Where Foo is the class (or superclass) of the actual object instance that is to be validated.)
      Parameters:
      clazz - the Class that this Validator is being asked if it can validate
      Returns:
      true if this Validator can indeed validate instances of the supplied clazz

    • validate

      void validate(Object target, Errors errors)
      Validate the given target object which must be of a Class for which the supports(Class) method typically has returned (or would return) true.

      The supplied errors instance can be used to report any resulting validation errors, typically as part of a larger binding process which this validator is meant to participate in. Binding errors have typically been pre-registered with the errors instance before this invocation already.

      Parameters:
      target - the object that is to be validated
      errors - contextual state about the validation process
      See Also:

    • validateObject

      default Errors validateObject(Object target)
      Validate the given target object individually.

      Delegates to the common validate(Object, Errors) method. The returned errors instance can be used to report any resulting validation errors for the specific target object, e.g. if (validator.validateObject(target).hasErrors()) ... or validator.validateObject(target).failOnError(IllegalStateException::new));.

      Note: This validation call comes with limitations in the Errors implementation used, in particular no support for nested paths. If this is insufficient for your purposes, call the regular validate(Object, Errors) method with a binding-capable Errors implementation such as BeanPropertyBindingResult.

      Parameters:
      target - the object that is to be validated
      Returns:
      resulting errors from the validation of the given object
      Since:
      6.1
      See Also:

    • forInstanceOf

      static <T> Validator forInstanceOf(Class<T> targetClass, BiConsumer<T,Errors> delegate)
      Return a Validator that checks whether the target object is an instance of targetClass, applying the given delegate to populate Errors if it is.

      For instance: 

      Validator passwordEqualsValidator = Validator.forInstanceOf(PasswordResetForm.class, (form, errors) -> {
   if (!Objects.equals(form.getPassword(), form.getConfirmPassword())) {
           errors.rejectValue("confirmPassword",
                 "PasswordEqualsValidator.passwordResetForm.password",
                 "password and confirm password must be same.");
           }
         });
      Type Parameters:
      T - the target object type
      Parameters:
      targetClass - the class supported by the returned validator
      delegate - function invoked with the target object, if it is an instance of type T
      Returns:
      the created Validator
      Since:
      6.1

    • forType

      static <T> Validator forType(Class<T> targetClass, BiConsumer<T,Errors> delegate)
      Return a Validator that checks whether the target object's class is identical to targetClass, applying the given delegate to populate Errors if it is.

      For instance: 

      Validator passwordEqualsValidator = Validator.forType(PasswordResetForm.class, (form, errors) -> {
   if (!Objects.equals(form.getPassword(), form.getConfirmPassword())) {
           errors.rejectValue("confirmPassword",
                 "PasswordEqualsValidator.passwordResetForm.password",
                 "password and confirm password must be same.");
           }
         });
      Type Parameters:
      T - the target object type
      Parameters:
      targetClass - the exact class supported by the returned validator (no subclasses)
      delegate - function invoked with the target object, if it is an instance of type T
      Returns:
      the created Validator
      Since:
      6.1