org.springframework.validation

## Interface Validator

- All Known Subinterfaces:
    SmartValidator
  All Known Implementing Classes:
    CustomValidatorBean, LocalValidatorFactoryBean, 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.

  Find below a simple but complete `Validator` implementation, which validates that the various `String` properties of a `UserLogin` instance are not empty (that is 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.

       public class UserLoginValidator implements Validator {

          private static final int MINIMUM_PASSWORD_LENGTH = 6;

          public boolean supports(Class clazz) {
             return UserLogin.class.isAssignableFrom(clazz);
          }

          public void validate(Object target, Errors errors) {
             ValidationUtils.rejectIfEmptyOrWhitespace(errors, "userName", "field.required");
             ValidationUtils.rejectIfEmptyOrWhitespace(errors, "password", "field.required");
             UserLogin login = (UserLogin) target;
             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 it's role in an enterprise application.

  Author:
    Rod Johnson
  See Also:
    `Errors`, `ValidationUtils`

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `supports(Class<?> clazz)` Can this `Validator` `validate` instances of the supplied `clazz`?
    `void` | `validate(Object target, Errors errors)` Validate the supplied `target` object, which must be of a `Class` for which the `supports(Class)` method typically has (or would) return `true`.

- - ### Method Detail

    - #### 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 supplied `target` object, which must be of a `Class` for which the `supports(Class)` method typically has (or would) return `true`.

      The supplied `errors` instance can be used to report any resulting validation errors.

      Parameters:
        `target` - the object that is to be validated (can be `null`)
        `errors` - contextual state about the validation process (never `null`)
      See Also:
        `ValidationUtils`