## org.springframework.validation
Interface Validator

    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
`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`