Spring Context 6.1.4 · org.springframework.validation.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.

Method Summary

Modifier and Type	Method and Description
public static < the target object type T> Validator	Returns: the created `Validator` forInstanceOf(Class<T> the class supported by the returned validator targetClass, BiConsumer<T, Errors> function invoked with the target object, if it is an instance of type T 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.
public static < the target object type T> Validator	Returns: the created `Validator` forType(Class<T> the exact class supported by the returned validator (no subclasses) targetClass, BiConsumer<T, Errors> function invoked with the target object, if it is an instance of type T 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.
public boolean	Returns: `true` if this `Validator` can indeed `validate` instances of the supplied `clazz` supports(Class<?> the `Class` that this `Validator` is being asked if it can `validate` clazz) Can this `Validator` `validate` instances of the supplied `clazz`?
public void	validate(Object the object that is to be validated target, Errors contextual state about the validation process 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`.
public default Errors	Returns: resulting errors from the validation of the given object validateObject(Object the object that is to be validated target) Validate the given `target` object individually.

Method Detail

forInstanceOf back to summary

forInstanceOf	back to summary
public 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."); } }); Parameters <T> the target object type targetClass:Class<T> the class supported by the returned validator delegate:BiConsumer<T, Errors> function invoked with the target object, if it is an instance of type T Returns:Validator the created `Validator` Since 6.1

public 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.");
	   }
	 });

Parameters

<T>: the target object type
targetClass:Class<T>: the class supported by the returned validator
delegate:BiConsumer<T, Errors>: function invoked with the target object, if it is an instance of type T

Returns:Validator

the created Validator

Since

6.1

forType back to summary

forType	back to summary
public 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."); } }); Parameters <T> the target object type targetClass:Class<T> the exact class supported by the returned validator (no subclasses) delegate:BiConsumer<T, Errors> function invoked with the target object, if it is an instance of type T Returns:Validator the created `Validator` Since 6.1

public 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.");
	   }
	 });

Parameters

<T>: the target object type
targetClass:Class<T>: the exact class supported by the returned validator (no subclasses)
delegate:BiConsumer<T, Errors>: function invoked with the target object, if it is an instance of type T

Returns:Validator

the created Validator

Since

6.1

supports back to summary

supports	back to summary
public 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:Class<?> the `Class` that this `Validator` is being asked if it can `validate` Returns:boolean `true` if this `Validator` can indeed `validate` instances of the supplied `clazz`

public 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:Class<?>: the Class that this Validator is being asked if it can validate

Returns:boolean

true if this Validator can indeed validate instances of the supplied clazz

validate back to summary

validate	back to summary
public 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:Object the object that is to be validated errors:Errors contextual state about the validation process See Also `ValidationUtils`

public 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:Object: the object that is to be validated
errors:Errors: contextual state about the validation process

See Also

ValidationUtils

validateObject back to summary

validateObject	back to summary
public 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:Object the object that is to be validated Returns:Errors resulting errors from the validation of the given object Since 6.1 See Also `SimpleErrors`

public 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:Object: the object that is to be validated

Returns:Errors

resulting errors from the validation of the given object

Since

6.1

See Also

SimpleErrors

public Interface Validator

Method Summary

Method Detail