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:
  - `SmartValidator`
  - `Errors`
  - `ValidationUtils`
  - `DataBinder.setValidator(org.springframework.validation.Validator)`

## Method Summary

Modifier and Type
Method
Description
`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.
`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.
`boolean`
`supports(Class<?> clazz)`
Can this `Validator` `validate` instances of the supplied `clazz`?
`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`.
`default Errors`
`validateObject(Object target)`
Validate the given `target` object individually.

## 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:
  - `ValidationUtils`

### 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, for example, `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:
  - `SimpleErrors`

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