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