Package org.springframework.validation.beanvalidation

# Class SpringValidatorAdapter

java.lang.Object
org.springframework.validation.beanvalidation.SpringValidatorAdapter

All Implemented Interfaces:
  `Validator`, `SmartValidator`, `Validator`

Direct Known Subclasses:
  `CustomValidatorBean`, `LocalValidatorFactoryBean`

public class SpringValidatorAdapter extends Object implements SmartValidator, Validator
Adapter that takes a JSR-303 `javax.validator.Validator` and exposes it as a Spring `Validator` while also exposing the original JSR-303 Validator interface itself.

Can be used as a programmatic wrapper. Also serves as base class for `CustomValidatorBean` and `LocalValidatorFactoryBean`, and as the primary implementation of the `SmartValidator` interface.

Since:
  3.0
Author:
  Juergen Hoeller, Sam Brannen
See Also:
  - `SmartValidator`
  - `CustomValidatorBean`
  - `LocalValidatorFactoryBean`

## Constructor Summary

Constructors
Constructor
Description
`SpringValidatorAdapter(Validator targetValidator)`
Create a new SpringValidatorAdapter for the given JSR-303 Validator.

## Method Summary

Modifier and Type
Method
Description
`protected String`
`determineErrorCode(ConstraintDescriptor<?> descriptor)`
Determine a Spring-reported error code for the given constraint descriptor.
`protected String`
`determineField(ConstraintViolation<Object> violation)`
Determine a field for the given constraint violation.
`ExecutableValidator`
`forExecutables()`
`protected Object[]`
`getArgumentsForConstraint(String objectName, String field, ConstraintDescriptor<?> descriptor)`
Return FieldError arguments for a validation error on the given field.
`BeanDescriptor`
`getConstraintsForClass(Class<?> clazz)`
`protected Object`
`getRejectedValue(String field, ConstraintViolation<Object> violation, BindingResult bindingResult)`
Extract the rejected value behind the given constraint violation, for exposure through the Spring errors representation.
`protected MessageSourceResolvable`
`getResolvableField(String objectName, String field)`
Build a resolvable wrapper for the specified field, allowing to resolve the field's name in a `MessageSource`.
`protected void`
`processConstraintViolations(Set<ConstraintViolation<Object>> violations, Errors errors)`
Process the given JSR-303 ConstraintViolations, adding corresponding errors to the provided Spring `Errors` object.
`protected boolean`
`requiresMessageFormat(ConstraintViolation<?> violation)`
Indicate whether this violation's interpolated message has remaining placeholders and therefore requires `MessageFormat` to be applied to it.
`boolean`
`supports(Class<?> clazz)`
Can this `Validator` `validate` instances of the supplied `clazz`?
`<T> T`
`unwrap(Class<T> type)`
Return a contained validator instance of the specified type, unwrapping as far as necessary.
`void`
`validate(Object target, Errors errors)`
Validate the given `target` object which must be of a `Class` for which the `Validator.supports(Class)` method typically has returned (or would return) `true`.
`void`
`validate(Object target, Errors errors, Object... validationHints)`
Validate the supplied `target` object, which must be of a type of `Class` for which the `Validator.supports(Class)` method typically returns `true`.
`<T> Set<ConstraintViolation<T>>`
`validate(T object, Class<?>... groups)`
`<T> Set<ConstraintViolation<T>>`
`validateProperty(T object, String propertyName, Class<?>... groups)`
`void`
`validateValue(Class<?> targetType, String fieldName, Object value, Errors errors, Object... validationHints)`
Validate the supplied value for the specified field on the target type, reporting the same validation errors as if the value would be bound to the field on an instance of the target class.
`<T> Set<ConstraintViolation<T>>`
`validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Methods inherited from interface org.springframework.validation.Validator

`validateObject`

## Constructor Details

### SpringValidatorAdapter

public SpringValidatorAdapter(Validator targetValidator)
Create a new SpringValidatorAdapter for the given JSR-303 Validator.

Parameters:
  `targetValidator` - the JSR-303 Validator to wrap

## Method Details

### supports

public boolean supports(Class<?> clazz)
Description copied from interface: `Validator`
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`.)

Specified by:
  `supports` in interface `Validator`
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

public void validate(Object target, Errors errors)
Description copied from interface: `Validator`
Validate the given `target` object which must be of a `Class` for which the `Validator.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.

Specified by:
  `validate` in interface `Validator`
Parameters:
  `target` - the object that is to be validated
  `errors` - contextual state about the validation process
See Also:
  - `ValidationUtils`

### validate

public void validate(Object target, Errors errors, Object... validationHints)
Description copied from interface: `SmartValidator`
Validate the supplied `target` object, which must be of a type of `Class` for which the `Validator.supports(Class)` method typically returns `true`.

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

This variant of `validate()` supports validation hints, such as validation groups against a JSR-303 provider (in which case, the provided hint objects need to be annotation arguments of type `Class`).

Note: Validation hints may get ignored by the actual target `Validator`, in which case this method should behave just like its regular `Validator.validate(Object, Errors)` sibling.

Specified by:
  `validate` in interface `SmartValidator`
Parameters:
  `target` - the object that is to be validated
  `errors` - contextual state about the validation process
  `validationHints` - one or more hint objects to be passed to the validation engine
See Also:
  - `Validator.validate(Object, Class[])`

### validateValue

public void validateValue(Class<?> targetType, String fieldName, @Nullable Object value, Errors errors, Object... validationHints)
Description copied from interface: `SmartValidator`
Validate the supplied value for the specified field on the target type, reporting the same validation errors as if the value would be bound to the field on an instance of the target class.

Specified by:
  `validateValue` in interface `SmartValidator`
Parameters:
  `targetType` - the target type
  `fieldName` - the name of the field
  `value` - the candidate value
  `errors` - contextual state about the validation process
  `validationHints` - one or more hint objects to be passed to the validation engine
See Also:
  - `Validator.validateValue(Class, String, Object, Class[])`

### processConstraintViolations

protected void processConstraintViolations(Set<ConstraintViolation<Object>> violations, Errors errors)
Process the given JSR-303 ConstraintViolations, adding corresponding errors to the provided Spring `Errors` object.

Parameters:
  `violations` - the JSR-303 ConstraintViolation results
  `errors` - the Spring errors object to register to

### determineField

protected String determineField(ConstraintViolation<Object> violation)
Determine a field for the given constraint violation.

The default implementation returns the stringified property path.

Parameters:
  `violation` - the current JSR-303 ConstraintViolation
Returns:
  the Spring-reported field (for use with `Errors`)
Since:
  4.2
See Also:
  - `ConstraintViolation.getPropertyPath()`
  - `FieldError.getField()`

### determineErrorCode

protected String determineErrorCode(ConstraintDescriptor<?> descriptor)
Determine a Spring-reported error code for the given constraint descriptor.

The default implementation returns the simple class name of the descriptor's annotation type. Note that the configured `MessageCodesResolver` will automatically generate error code variations which include the object name and the field name.

Parameters:
  `descriptor` - the JSR-303 ConstraintDescriptor for the current violation
Returns:
  a corresponding error code (for use with `Errors`)
Since:
  4.2
See Also:
  - `ConstraintDescriptor.getAnnotation()`
  - `MessageCodesResolver`

### getArgumentsForConstraint

protected Object[] getArgumentsForConstraint(String objectName, String field, ConstraintDescriptor<?> descriptor)
Return FieldError arguments for a validation error on the given field. Invoked for each violated constraint.

The default implementation returns a first argument indicating the field name (see `getResolvableField(java.lang.String, java.lang.String)`). Afterwards, it adds all actual constraint annotation attributes (i.e. excluding "message", "groups" and "payload") in alphabetical order of their attribute names.

Can be overridden to, for example, add further attributes from the constraint descriptor.

Parameters:
  `objectName` - the name of the target object
  `field` - the field that caused the binding error
  `descriptor` - the JSR-303 constraint descriptor
Returns:
  the Object array that represents the FieldError arguments
See Also:
  - `DefaultMessageSourceResolvable.getArguments()`
  - `DefaultMessageSourceResolvable`
  - `DefaultBindingErrorProcessor.getArgumentsForBindError(java.lang.String, java.lang.String)`

### getResolvableField

protected MessageSourceResolvable getResolvableField(String objectName, String field)
Build a resolvable wrapper for the specified field, allowing to resolve the field's name in a `MessageSource`.

The default implementation returns a first argument indicating the field: of type `DefaultMessageSourceResolvable`, with "objectName.field" and "field" as codes, and with the plain field name as default message.

Parameters:
  `objectName` - the name of the target object
  `field` - the field that caused the binding error
Returns:
  a corresponding `MessageSourceResolvable` for the specified field
Since:
  4.3
See Also:
  - `getArgumentsForConstraint(java.lang.String, java.lang.String, jakarta.validation.metadata.ConstraintDescriptor<?>)`

### getRejectedValue

@Nullable protected Object getRejectedValue(String field, ConstraintViolation<Object> violation, BindingResult bindingResult)
Extract the rejected value behind the given constraint violation, for exposure through the Spring errors representation.

Parameters:
  `field` - the field that caused the binding error
  `violation` - the corresponding JSR-303 ConstraintViolation
  `bindingResult` - a Spring BindingResult for the backing object which contains the current field's value
Returns:
  the invalid value to expose as part of the field error
Since:
  4.2
See Also:
  - `ConstraintViolation.getInvalidValue()`
  - `FieldError.getRejectedValue()`

### requiresMessageFormat

protected boolean requiresMessageFormat(ConstraintViolation<?> violation)
Indicate whether this violation's interpolated message has remaining placeholders and therefore requires `MessageFormat` to be applied to it. Called for a Bean Validation defined message (coming out `ValidationMessages.properties`) when rendered as the default message in Spring's MessageSource.

The default implementation considers a Spring-style "{0}" placeholder for the field name as an indication for `MessageFormat`. Any other placeholder or escape syntax occurrences are typically a mismatch, coming out of regex pattern values or the like. Note that standard Bean Validation does not support "{0}" style placeholders at all; this is a feature typically used in Spring MessageSource resource bundles.

Parameters:
  `violation` - the Bean Validation constraint violation, including BV-defined interpolation of named attribute references in its message
Returns:
  `true` if `java.text.MessageFormat` is to be applied, or `false` if the violation's message should be used as-is
Since:
  5.1.8
See Also:
  - `getArgumentsForConstraint(java.lang.String, java.lang.String, jakarta.validation.metadata.ConstraintDescriptor<?>)`

### validate

public <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups)

Specified by:
  `validate` in interface `Validator`

### validateProperty

public <T> Set<ConstraintViolation<T>> validateProperty(T object, String propertyName, Class<?>... groups)

Specified by:
  `validateProperty` in interface `Validator`

### validateValue

public <T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups)

Specified by:
  `validateValue` in interface `Validator`

### getConstraintsForClass

public BeanDescriptor getConstraintsForClass(Class<?> clazz)

Specified by:
  `getConstraintsForClass` in interface `Validator`

### unwrap

public <T> T unwrap(@Nullable Class<T> type)
Description copied from interface: `SmartValidator`
Return a contained validator instance of the specified type, unwrapping as far as necessary.

Specified by:
  `unwrap` in interface `SmartValidator`
Specified by:
  `unwrap` in interface `Validator`
Type Parameters:
  `T` - the type of the object to return
Parameters:
  `type` - the class of the object to return
Returns:
  a validator instance of the specified type; `null` if there isn't a nested validator; an exception may be raised if the specified validator type does not match.

### forExecutables

public ExecutableValidator forExecutables()

Specified by:
  `forExecutables` in interface `Validator`