Package org.springframework.validation

# Class DataBinder

java.lang.Object
org.springframework.validation.DataBinder

All Implemented Interfaces:
  `org.springframework.beans.PropertyEditorRegistry`, `org.springframework.beans.TypeConverter`

public class DataBinder extends Object implements org.springframework.beans.PropertyEditorRegistry, org.springframework.beans.TypeConverter
Binder that allows applying property values to a target object via constructor and setter injection, and also supports validation and binding result analysis.

The binding process can be customized by specifying allowed field patterns, required fields, custom editors, etc.

WARNING: Data binding can lead to security issues by exposing parts of the object graph that are not meant to be accessed or modified by external clients. Therefore, the design and use of data binding should be considered carefully with regard to security. For more details, please refer to the dedicated sections on data binding for Spring Web MVC and Spring WebFlux in the reference manual.

The binding results can be examined via the `BindingResult` interface, extending the `Errors` interface: see the `getBindingResult()` method. Missing fields and property access exceptions will be converted to `FieldErrors`, collected in the Errors instance, using the following error codes:

- Missing field error: "required"
- Type mismatch error: "typeMismatch"
- Method invocation error: "methodInvocation"

By default, binding errors get resolved through the `BindingErrorProcessor` strategy, processing for missing fields and property access exceptions: see the `setBindingErrorProcessor(org.springframework.validation.BindingErrorProcessor)` method. You can override the default strategy if needed, for example to generate different error codes.

Custom validation errors can be added afterwards. You will typically want to resolve such error codes into proper user-visible error messages; this can be achieved through resolving each error via a `MessageSource`, which is able to resolve an `ObjectError`/`FieldError` through its `MessageSource.getMessage(org.springframework.context.MessageSourceResolvable, java.util.Locale)` method. The list of message codes can be customized through the `MessageCodesResolver` strategy: see the `setMessageCodesResolver(org.springframework.validation.MessageCodesResolver)` method. `DefaultMessageCodesResolver`'s javadoc states details on the default resolution rules.

This generic data binder can be used in any kind of environment.

Author:
  Rod Johnson, Juergen Hoeller, Rob Harrop, Stephane Nicoll, Kazuki Shimizu, Sam Brannen
See Also:
  - `setAllowedFields(java.lang.String...)`
  - `setRequiredFields(java.lang.String...)`
  - `registerCustomEditor(java.lang.Class<?>, java.beans.PropertyEditor)`
  - `setMessageCodesResolver(org.springframework.validation.MessageCodesResolver)`
  - `setBindingErrorProcessor(org.springframework.validation.BindingErrorProcessor)`
  - `construct(org.springframework.validation.DataBinder.ValueResolver)`
  - `bind(org.springframework.beans.PropertyValues)`
  - `getBindingResult()`
  - `DefaultMessageCodesResolver`
  - `DefaultBindingErrorProcessor`
  - `MessageSource`

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static interface`
`DataBinder.NameResolver`
Strategy to determine the name of the value to bind to a method parameter.
`static interface`
`DataBinder.ValueResolver`
Strategy for `constructor binding` to look up the values to bind to a given constructor parameter.

## Field Summary

Fields
Modifier and Type
Field
Description
`static final int`
`DEFAULT_AUTO_GROW_COLLECTION_LIMIT`
Default limit for array and collection growing: 256.
`static final String`
`DEFAULT_OBJECT_NAME`
Default object name used for binding: "target".
`protected static final org.apache.commons.logging.Log`
`logger`
We'll create a lot of DataBinder instances: Let's use a static logger.

## Constructor Summary

Constructors
Constructor
Description
`DataBinder(Object target)`
Create a new DataBinder instance, with default object name.
`DataBinder(Object target, String objectName)`
Create a new DataBinder instance.

## Method Summary

Modifier and Type
Method
Description
`void`
`addCustomFormatter(Formatter<?> formatter)`
Add a custom formatter, applying it to all fields matching the `Formatter`-declared type.
`void`
`addCustomFormatter(Formatter<?> formatter, Class<?>... fieldTypes)`
Add a custom formatter, applying it to the specified field types only, if any, or otherwise to all fields matching the `Formatter`-declared type.
`void`
`addCustomFormatter(Formatter<?> formatter, String... fields)`
Add a custom formatter for the field type specified in `Formatter` class, applying it to the specified fields only, if any, or otherwise to all fields.
`void`
`addValidators(Validator... validators)`
Add Validators to apply after each binding step.
`protected void`
`applyPropertyValues(org.springframework.beans.MutablePropertyValues mpvs)`
Apply given property values to the target object.
`void`
`bind(org.springframework.beans.PropertyValues pvs)`
Bind the given property values to this binder's target.
`protected void`
`checkAllowedFields(org.springframework.beans.MutablePropertyValues mpvs)`
Check the given property values against the allowed fields, removing values for fields that are not allowed.
`protected void`
`checkRequiredFields(org.springframework.beans.MutablePropertyValues mpvs)`
Check the given property values against the required fields, generating missing field errors where appropriate.
`Map<?,?>`
`close()`
Close this DataBinder, which may result in throwing a BindException if it encountered any errors.
`void`
`construct(DataBinder.ValueResolver valueResolver)`
Create the target with constructor injection of values.
`<T> T`
`convertIfNecessary(Object value, Class<T> requiredType)`
`<T> T`
`convertIfNecessary(Object value, Class<T> requiredType, Field field)`
`<T> T`
`convertIfNecessary(Object value, Class<T> requiredType, org.springframework.core.convert.TypeDescriptor typeDescriptor)`
`<T> T`
`convertIfNecessary(Object value, Class<T> requiredType, org.springframework.core.MethodParameter methodParam)`
`protected AbstractPropertyBindingResult`
`createBeanPropertyBindingResult()`
Create the `AbstractPropertyBindingResult` instance using standard JavaBean property access.
`protected AbstractPropertyBindingResult`
`createDirectFieldBindingResult()`
Create the `AbstractPropertyBindingResult` instance using direct field access.
`protected void`
`doBind(org.springframework.beans.MutablePropertyValues mpvs)`
Actual implementation of the binding process, working with the passed-in MutablePropertyValues instance.
`PropertyEditor`
`findCustomEditor(Class<?> requiredType, String propertyPath)`
`String[]`
`getAllowedFields()`
Return the field patterns that should be allowed for binding.
`int`
`getAutoGrowCollectionLimit()`
Return the current limit for array and collection auto-growing.
`BindingErrorProcessor`
`getBindingErrorProcessor()`
Return the strategy for processing binding errors.
`BindingResult`
`getBindingResult()`
Return the BindingResult instance created by this DataBinder.
`org.springframework.core.convert.ConversionService`
`getConversionService()`
Return the associated ConversionService, if any.
`String[]`
`getDisallowedFields()`
Return the field patterns that should not be allowed for binding.
`protected AbstractPropertyBindingResult`
`getInternalBindingResult()`
Return the internal BindingResult held by this DataBinder, as an AbstractPropertyBindingResult.
`DataBinder.NameResolver`
`getNameResolver()`
Return the `configured` name resolver for constructor parameters.
`String`
`getObjectName()`
Return the name of the bound object.
`protected org.springframework.beans.ConfigurablePropertyAccessor`
`getPropertyAccessor()`
Return the underlying PropertyAccessor of this binder's BindingResult.
`protected org.springframework.beans.PropertyEditorRegistry`
`getPropertyEditorRegistry()`
Return the underlying TypeConverter of this binder's BindingResult.
`String[]`
`getRequiredFields()`
Return the fields that are required for each binding process.
`protected org.springframework.beans.SimpleTypeConverter`
`getSimpleTypeConverter()`
Return this binder's underlying SimpleTypeConverter.
`Object`
`getTarget()`
Return the wrapped target object.
`org.springframework.core.ResolvableType`
`getTargetType()`
Return the `configured` type for the target object.
`protected org.springframework.beans.TypeConverter`
`getTypeConverter()`
Return the underlying TypeConverter of this binder's BindingResult.
`Validator`
`getValidator()`
Return the primary Validator to apply after each binding step, if any.
`List<Validator>`
`getValidators()`
Return the Validators to apply after data binding.
`List<Validator>`
`getValidatorsToApply()`
Return the Validators to apply after data binding.
`void`
`initBeanPropertyAccess()`
Initialize standard JavaBean property access for this DataBinder.
`void`
`initDirectFieldAccess()`
Initialize direct field access for this DataBinder, as alternative to the default bean property access.
`protected boolean`
`isAllowed(String field)`
Determine if the given field is allowed for binding.
`boolean`
`isAutoGrowNestedPaths()`
Return whether "auto-growing" of nested paths has been activated.
`boolean`
`isDeclarativeBinding()`
Return whether to bind only fields intended for binding.
`boolean`
`isIgnoreInvalidFields()`
Return whether to ignore invalid fields when binding.
`boolean`
`isIgnoreUnknownFields()`
Return whether to ignore unknown fields when binding.
`void`
`registerCustomEditor(Class<?> requiredType, PropertyEditor propertyEditor)`
`void`
`registerCustomEditor(Class<?> requiredType, String field, PropertyEditor propertyEditor)`
`void`
`replaceValidators(Validator... validators)`
Replace the Validators to apply after each binding step.
`void`
`setAllowedFields(String... allowedFields)`
Register field patterns that should be allowed for binding.
`void`
`setAutoGrowCollectionLimit(int autoGrowCollectionLimit)`
Specify the limit for array and collection auto-growing.
`void`
`setAutoGrowNestedPaths(boolean autoGrowNestedPaths)`
Set whether this binder should attempt to "auto-grow" a nested path that contains a null value.
`void`
`setBindingErrorProcessor(BindingErrorProcessor bindingErrorProcessor)`
Set the strategy to use for processing binding errors, that is, required field errors and `PropertyAccessException`s.
`void`
`setConversionService(org.springframework.core.convert.ConversionService conversionService)`
Specify a `ConversionService` to use for converting property values, as an alternative to JavaBeans PropertyEditors.
`void`
`setDeclarativeBinding(boolean declarativeBinding)`
Set whether to bind only fields explicitly intended for binding including: Constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)`.
`void`
`setDisallowedFields(String... disallowedFields)`
Register field patterns that should not be allowed for binding.
`void`
`setExcludedValidators(Predicate<Validator> predicate)`
Configure a predicate to exclude validators.
`void`
`setIgnoreInvalidFields(boolean ignoreInvalidFields)`
Set whether to ignore invalid fields, that is, whether to ignore bind parameters that have corresponding fields in the target object which are not accessible (for example because of null values in the nested path).
`void`
`setIgnoreUnknownFields(boolean ignoreUnknownFields)`
Set whether to ignore unknown fields, that is, whether to ignore bind parameters that do not have corresponding fields in the target object.
`void`
`setMessageCodesResolver(MessageCodesResolver messageCodesResolver)`
Set the strategy to use for resolving errors into message codes.
`void`
`setNameResolver(DataBinder.NameResolver nameResolver)`
Configure a resolver to determine the name of the value to bind to a constructor parameter in `construct(org.springframework.validation.DataBinder.ValueResolver)`.
`void`
`setRequiredFields(String... requiredFields)`
Register fields that are required for each binding process.
`void`
`setTargetType(org.springframework.core.ResolvableType targetType)`
Set the type for the target object.
`void`
`setValidator(Validator validator)`
Set the Validator to apply after each binding step.
`protected boolean`
`shouldConstructArgument(org.springframework.core.MethodParameter param)`
Whether to instantiate the constructor argument of the given type, matching its own constructor arguments to bind values.
`protected boolean`
`shouldNotBindPropertyValues()`
Whether to not bind parameters to properties.
`void`
`validate()`
Invoke the specified Validators, if any.
`void`
`validate(Object... validationHints)`
Invoke the specified Validators, if any, with the given validation hints.

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

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

## Field Details

### DEFAULT_OBJECT_NAME

public static final String DEFAULT_OBJECT_NAME
Default object name used for binding: "target".

See Also:
  - Constant Field Values

### DEFAULT_AUTO_GROW_COLLECTION_LIMIT

public static final int DEFAULT_AUTO_GROW_COLLECTION_LIMIT
Default limit for array and collection growing: 256.

See Also:
  - Constant Field Values

### logger

protected static final org.apache.commons.logging.Log logger
We'll create a lot of DataBinder instances: Let's use a static logger.

## Constructor Details

### DataBinder

public DataBinder(@Nullable Object target)
Create a new DataBinder instance, with default object name.

Parameters:
  `target` - the target object to bind onto (or `null` if the binder is just used to convert a plain parameter value)
See Also:
  - `DEFAULT_OBJECT_NAME`

### DataBinder

public DataBinder(@Nullable Object target, String objectName)
Create a new DataBinder instance.

Parameters:
  `target` - the target object to bind onto (or `null` if the binder is just used to convert a plain parameter value)
  `objectName` - the name of the target object

## Method Details

### getTarget

@Nullable public Object getTarget()
Return the wrapped target object.

If the target object is `null` and `getTargetType()` is set, then `construct(ValueResolver)` may be called to create the target.

### getObjectName

public String getObjectName()
Return the name of the bound object.

### setTargetType

public void setTargetType(org.springframework.core.ResolvableType targetType)
Set the type for the target object. When the target is `null`, setting the targetType allows using `construct(org.springframework.validation.DataBinder.ValueResolver)` to create the target.

Parameters:
  `targetType` - the type of the target object
Since:
  6.1
See Also:
  - `construct(org.springframework.validation.DataBinder.ValueResolver)`

### getTargetType

@Nullable public org.springframework.core.ResolvableType getTargetType()
Return the `configured` type for the target object.

Since:
  6.1

### setAutoGrowNestedPaths

public void setAutoGrowNestedPaths(boolean autoGrowNestedPaths)
Set whether this binder should attempt to "auto-grow" a nested path that contains a null value.

If "true", a null path location will be populated with a default object value and traversed instead of resulting in an exception. This flag also enables auto-growth of collection elements when accessing an out-of-bounds index.

Default is "true" on a standard DataBinder. Note that since Spring 4.1 this feature is supported for bean property access (DataBinder's default mode) and field access.

Used for setter/field injection via `bind(PropertyValues)`, and not applicable to constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)`.

See Also:
  - `initBeanPropertyAccess()`
  - `ConfigurablePropertyAccessor.setAutoGrowNestedPaths(boolean)`

### isAutoGrowNestedPaths

public boolean isAutoGrowNestedPaths()
Return whether "auto-growing" of nested paths has been activated.

### setAutoGrowCollectionLimit

public void setAutoGrowCollectionLimit(int autoGrowCollectionLimit)
Specify the limit for array and collection auto-growing.

Default is 256, preventing OutOfMemoryErrors in case of large indexes. Raise this limit if your auto-growing needs are unusually high.

Used for setter/field injection via `bind(PropertyValues)`, and not applicable to constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)`.

See Also:
  - `initBeanPropertyAccess()`
  - `BeanWrapper.setAutoGrowCollectionLimit(int)`

### getAutoGrowCollectionLimit

public int getAutoGrowCollectionLimit()
Return the current limit for array and collection auto-growing.

### initBeanPropertyAccess

public void initBeanPropertyAccess()
Initialize standard JavaBean property access for this DataBinder.

This is the default; an explicit call just leads to eager initialization.

See Also:
  - `initDirectFieldAccess()`
  - `createBeanPropertyBindingResult()`

### createBeanPropertyBindingResult

protected AbstractPropertyBindingResult createBeanPropertyBindingResult()
Create the `AbstractPropertyBindingResult` instance using standard JavaBean property access.

Since:
  4.2.1

### initDirectFieldAccess

public void initDirectFieldAccess()
Initialize direct field access for this DataBinder, as alternative to the default bean property access.

See Also:
  - `initBeanPropertyAccess()`
  - `createDirectFieldBindingResult()`

### createDirectFieldBindingResult

protected AbstractPropertyBindingResult createDirectFieldBindingResult()
Create the `AbstractPropertyBindingResult` instance using direct field access.

Since:
  4.2.1

### getInternalBindingResult

protected AbstractPropertyBindingResult getInternalBindingResult()
Return the internal BindingResult held by this DataBinder, as an AbstractPropertyBindingResult.

### getPropertyAccessor

protected org.springframework.beans.ConfigurablePropertyAccessor getPropertyAccessor()
Return the underlying PropertyAccessor of this binder's BindingResult.

### getSimpleTypeConverter

protected org.springframework.beans.SimpleTypeConverter getSimpleTypeConverter()
Return this binder's underlying SimpleTypeConverter.

### getPropertyEditorRegistry

protected org.springframework.beans.PropertyEditorRegistry getPropertyEditorRegistry()
Return the underlying TypeConverter of this binder's BindingResult.

### getTypeConverter

protected org.springframework.beans.TypeConverter getTypeConverter()
Return the underlying TypeConverter of this binder's BindingResult.

### getBindingResult

public BindingResult getBindingResult()
Return the BindingResult instance created by this DataBinder. This allows for convenient access to the binding results after a bind operation.

Returns:
  the BindingResult instance, to be treated as BindingResult or as Errors instance (Errors is a super-interface of BindingResult)
See Also:
  - `Errors`
  - `bind(org.springframework.beans.PropertyValues)`

### setDeclarativeBinding

public void setDeclarativeBinding(boolean declarativeBinding)
Set whether to bind only fields explicitly intended for binding including:

- Constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)`.
- Property binding with configured `allowedFields`.

Default is "false". Turn this on to limit binding to constructor parameters and allowed fields.

Since:
  6.1

### isDeclarativeBinding

public boolean isDeclarativeBinding()
Return whether to bind only fields intended for binding.

Since:
  6.1

### setIgnoreUnknownFields

public void setIgnoreUnknownFields(boolean ignoreUnknownFields)
Set whether to ignore unknown fields, that is, whether to ignore bind parameters that do not have corresponding fields in the target object.

Default is "true". Turn this off to enforce that all bind parameters must have a matching field in the target object.

Note that this setting only applies to binding operations on this DataBinder, not to retrieving values via its `BindingResult`.

Used for binding to fields with `bind(PropertyValues)`, and not applicable to constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)` which uses only the values it needs.

See Also:
  - `bind(org.springframework.beans.PropertyValues)`

### isIgnoreUnknownFields

public boolean isIgnoreUnknownFields()
Return whether to ignore unknown fields when binding.

### setIgnoreInvalidFields

public void setIgnoreInvalidFields(boolean ignoreInvalidFields)
Set whether to ignore invalid fields, that is, whether to ignore bind parameters that have corresponding fields in the target object which are not accessible (for example because of null values in the nested path).

Default is "false". Turn this on to ignore bind parameters for nested objects in non-existing parts of the target object graph.

Note that this setting only applies to binding operations on this DataBinder, not to retrieving values via its `BindingResult`.

Used for binding to fields with `bind(PropertyValues)`, and not applicable to constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)`, which uses only the values it needs.

See Also:
  - `bind(org.springframework.beans.PropertyValues)`

### isIgnoreInvalidFields

public boolean isIgnoreInvalidFields()
Return whether to ignore invalid fields when binding.

### setAllowedFields

public void setAllowedFields(@Nullable String... allowedFields)
Register field patterns that should be allowed for binding.

Default is all fields.

Restrict this for example to avoid unwanted modifications by malicious users when binding HTTP request parameters.

Supports `"xxx*"`, `"*xxx"`, `"*xxx*"`, and `"xxx*yyy"` matches (with an arbitrary number of pattern parts), as well as direct equality.

The default implementation of this method stores allowed field patterns in canonical form. Subclasses which override this method must therefore take this into account.

More sophisticated matching can be implemented by overriding the `isAllowed(java.lang.String)` method.

Alternatively, specify a list of disallowed field patterns.

Used for binding to fields with `bind(PropertyValues)`, and not applicable to constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)`, which uses only the values it needs.

Parameters:
  `allowedFields` - array of allowed field patterns
See Also:
  - `setDisallowedFields(java.lang.String...)`
  - `isAllowed(String)`

### getAllowedFields

@Nullable public String[] getAllowedFields()
Return the field patterns that should be allowed for binding.

Returns:
  array of allowed field patterns
See Also:
  - `setAllowedFields(String...)`

### setDisallowedFields

public void setDisallowedFields(@Nullable String... disallowedFields)
Register field patterns that should not be allowed for binding.

Default is none.

Mark fields as disallowed, for example to avoid unwanted modifications by malicious users when binding HTTP request parameters.

Supports `"xxx*"`, `"*xxx"`, `"*xxx*"`, and `"xxx*yyy"` matches (with an arbitrary number of pattern parts), as well as direct equality.

The default implementation of this method stores disallowed field patterns in canonical form, and subsequently pattern matching in `isAllowed(java.lang.String)` is case-insensitive. Subclasses that override this method must therefore take this transformation into account.

More sophisticated matching can be implemented by overriding the `isAllowed(java.lang.String)` method.

Alternatively, specify a list of allowed field patterns.

Used for binding to fields with `bind(PropertyValues)`, and not applicable to constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)`, which uses only the values it needs.

Parameters:
  `disallowedFields` - array of disallowed field patterns
See Also:
  - `setAllowedFields(java.lang.String...)`
  - `isAllowed(String)`

### getDisallowedFields

@Nullable public String[] getDisallowedFields()
Return the field patterns that should not be allowed for binding.

Returns:
  array of disallowed field patterns
See Also:
  - `setDisallowedFields(String...)`

### setRequiredFields

public void setRequiredFields(@Nullable String... requiredFields)
Register fields that are required for each binding process.

If one of the specified fields is not contained in the list of incoming property values, a corresponding "missing field" error will be created, with error code "required" (by the default binding error processor).

Used for binding to fields with `bind(PropertyValues)`, and not applicable to constructor binding via `construct(org.springframework.validation.DataBinder.ValueResolver)`, which uses only the values it needs.

Parameters:
  `requiredFields` - array of field names
See Also:
  - `setBindingErrorProcessor(org.springframework.validation.BindingErrorProcessor)`
  - `DefaultBindingErrorProcessor.MISSING_FIELD_ERROR_CODE`

### getRequiredFields

@Nullable public String[] getRequiredFields()
Return the fields that are required for each binding process.

Returns:
  array of field names

### setNameResolver

public void setNameResolver(DataBinder.NameResolver nameResolver)
Configure a resolver to determine the name of the value to bind to a constructor parameter in `construct(org.springframework.validation.DataBinder.ValueResolver)`.

If not configured, or if the name cannot be resolved, by default `DefaultParameterNameDiscoverer` is used.

Parameters:
  `nameResolver` - the resolver to use
Since:
  6.1

### getNameResolver

@Nullable public DataBinder.NameResolver getNameResolver()
Return the `configured` name resolver for constructor parameters.

Since:
  6.1

### setMessageCodesResolver

public void setMessageCodesResolver(@Nullable MessageCodesResolver messageCodesResolver)
Set the strategy to use for resolving errors into message codes. Applies the given strategy to the underlying errors holder.

Default is a DefaultMessageCodesResolver.

See Also:
  - `AbstractBindingResult.setMessageCodesResolver(org.springframework.validation.MessageCodesResolver)`
  - `DefaultMessageCodesResolver`

### setBindingErrorProcessor

public void setBindingErrorProcessor(BindingErrorProcessor bindingErrorProcessor)
Set the strategy to use for processing binding errors, that is, required field errors and `PropertyAccessException`s.

Default is a DefaultBindingErrorProcessor.

See Also:
  - `DefaultBindingErrorProcessor`

### getBindingErrorProcessor

public BindingErrorProcessor getBindingErrorProcessor()
Return the strategy for processing binding errors.

### setValidator

public void setValidator(@Nullable Validator validator)
Set the Validator to apply after each binding step.

See Also:
  - `addValidators(Validator...)`
  - `replaceValidators(Validator...)`

### setExcludedValidators

public void setExcludedValidators(Predicate<Validator> predicate)
Configure a predicate to exclude validators.

Since:
  6.1

### addValidators

public void addValidators(Validator... validators)
Add Validators to apply after each binding step.

See Also:
  - `setValidator(Validator)`
  - `replaceValidators(Validator...)`

### replaceValidators

public void replaceValidators(Validator... validators)
Replace the Validators to apply after each binding step.

See Also:
  - `setValidator(Validator)`
  - `addValidators(Validator...)`

### getValidator

@Nullable public Validator getValidator()
Return the primary Validator to apply after each binding step, if any.

### getValidators

public List<Validator> getValidators()
Return the Validators to apply after data binding.

### getValidatorsToApply

public List<Validator> getValidatorsToApply()
Return the Validators to apply after data binding. This includes the configured `validators` filtered by the `exclude predicate`.

Since:
  6.1

### setConversionService

public void setConversionService(@Nullable org.springframework.core.convert.ConversionService conversionService)
Specify a `ConversionService` to use for converting property values, as an alternative to JavaBeans PropertyEditors.

### getConversionService

@Nullable public org.springframework.core.convert.ConversionService getConversionService()
Return the associated ConversionService, if any.

### addCustomFormatter

public void addCustomFormatter(Formatter<?> formatter)
Add a custom formatter, applying it to all fields matching the `Formatter`-declared type.

Registers a corresponding `PropertyEditor` adapter underneath the covers.

Parameters:
  `formatter` - the formatter to add, generically declared for a specific type
Since:
  4.2
See Also:
  - `registerCustomEditor(Class, PropertyEditor)`

### addCustomFormatter

public void addCustomFormatter(Formatter<?> formatter, String... fields)
Add a custom formatter for the field type specified in `Formatter` class, applying it to the specified fields only, if any, or otherwise to all fields.

Registers a corresponding `PropertyEditor` adapter underneath the covers.

Parameters:
  `formatter` - the formatter to add, generically declared for a specific type
  `fields` - the fields to apply the formatter to, or none if to be applied to all
Since:
  4.2
See Also:
  - `registerCustomEditor(Class, String, PropertyEditor)`

### addCustomFormatter

public void addCustomFormatter(Formatter<?> formatter, Class<?>... fieldTypes)
Add a custom formatter, applying it to the specified field types only, if any, or otherwise to all fields matching the `Formatter`-declared type.

Registers a corresponding `PropertyEditor` adapter underneath the covers.

Parameters:
  `formatter` - the formatter to add (does not need to generically declare a field type if field types are explicitly specified as parameters)
  `fieldTypes` - the field types to apply the formatter to, or none if to be derived from the given `Formatter` implementation class
Since:
  4.2
See Also:
  - `registerCustomEditor(Class, PropertyEditor)`

### registerCustomEditor

public void registerCustomEditor(Class<?> requiredType, PropertyEditor propertyEditor)

Specified by:
  `registerCustomEditor` in interface `org.springframework.beans.PropertyEditorRegistry`

### registerCustomEditor

public void registerCustomEditor(@Nullable Class<?> requiredType, @Nullable String field, PropertyEditor propertyEditor)

Specified by:
  `registerCustomEditor` in interface `org.springframework.beans.PropertyEditorRegistry`

### findCustomEditor

@Nullable public PropertyEditor findCustomEditor(@Nullable Class<?> requiredType, @Nullable String propertyPath)

Specified by:
  `findCustomEditor` in interface `org.springframework.beans.PropertyEditorRegistry`

### convertIfNecessary

@Nullable public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType) throws org.springframework.beans.TypeMismatchException

Specified by:
  `convertIfNecessary` in interface `org.springframework.beans.TypeConverter`
Throws:
  `org.springframework.beans.TypeMismatchException`

### convertIfNecessary

@Nullable public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType, @Nullable org.springframework.core.MethodParameter methodParam) throws org.springframework.beans.TypeMismatchException

Specified by:
  `convertIfNecessary` in interface `org.springframework.beans.TypeConverter`
Throws:
  `org.springframework.beans.TypeMismatchException`

### convertIfNecessary

@Nullable public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType, @Nullable Field field) throws org.springframework.beans.TypeMismatchException

Specified by:
  `convertIfNecessary` in interface `org.springframework.beans.TypeConverter`
Throws:
  `org.springframework.beans.TypeMismatchException`

### convertIfNecessary

@Nullable public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType, @Nullable org.springframework.core.convert.TypeDescriptor typeDescriptor) throws org.springframework.beans.TypeMismatchException

Specified by:
  `convertIfNecessary` in interface `org.springframework.beans.TypeConverter`
Throws:
  `org.springframework.beans.TypeMismatchException`

### construct

public void construct(DataBinder.ValueResolver valueResolver)
Create the target with constructor injection of values. It is expected that `setTargetType(ResolvableType)` was previously called and that `getTarget()` is `null`.

Uses a public, no-arg constructor if available in the target object type, also supporting a "primary constructor" approach for data classes as follows: It understands the JavaBeans `ConstructorProperties` annotation as well as runtime-retained parameter names in the bytecode, associating input values with constructor arguments by name. If no such constructor is found, the default constructor will be used (even if not public), assuming subsequent bean property bindings through setter methods.

After the call, use `getBindingResult()` to check for failures to bind to, and/or validate constructor arguments. If there are no errors, the target is set, and `doBind(MutablePropertyValues)` can be used for further initialization via setters.

Parameters:
  `valueResolver` - to resolve constructor argument values with
Throws:
  `org.springframework.beans.BeanInstantiationException` - in case of constructor failure
Since:
  6.1

### shouldConstructArgument

protected boolean shouldConstructArgument(org.springframework.core.MethodParameter param)
Whether to instantiate the constructor argument of the given type, matching its own constructor arguments to bind values.

By default, simple value types, maps, collections, and arrays are excluded from nested constructor binding initialization.

Since:
  6.1.2

### bind

public void bind(org.springframework.beans.PropertyValues pvs)
Bind the given property values to this binder's target.

This call can create field errors, representing basic binding errors like a required field (code "required"), or type mismatch between value and bean property (code "typeMismatch").

Note that the given PropertyValues should be a throwaway instance: For efficiency, it will be modified to just contain allowed fields if it implements the MutablePropertyValues interface; else, an internal mutable copy will be created for this purpose. Pass in a copy of the PropertyValues if you want your original instance to stay unmodified in any case.

Parameters:
  `pvs` - property values to bind
See Also:
  - `doBind(org.springframework.beans.MutablePropertyValues)`

### shouldNotBindPropertyValues

protected boolean shouldNotBindPropertyValues()
Whether to not bind parameters to properties. Returns "true" if `isDeclarativeBinding()` is on, and `allowedFields` are not configured.

Since:
  6.1

### doBind

protected void doBind(org.springframework.beans.MutablePropertyValues mpvs)
Actual implementation of the binding process, working with the passed-in MutablePropertyValues instance.

Parameters:
  `mpvs` - the property values to bind, as MutablePropertyValues instance
See Also:
  - `checkAllowedFields(org.springframework.beans.MutablePropertyValues)`
  - `checkRequiredFields(org.springframework.beans.MutablePropertyValues)`
  - `applyPropertyValues(org.springframework.beans.MutablePropertyValues)`

### checkAllowedFields

protected void checkAllowedFields(org.springframework.beans.MutablePropertyValues mpvs)
Check the given property values against the allowed fields, removing values for fields that are not allowed.

Parameters:
  `mpvs` - the property values to be bound (can be modified)
See Also:
  - `getAllowedFields()`
  - `isAllowed(String)`

### isAllowed

protected boolean isAllowed(String field)
Determine if the given field is allowed for binding.

Invoked for each passed-in property value.

Checks for `"xxx*"`, `"*xxx"`, `"*xxx*"`, and `"xxx*yyy"` matches (with an arbitrary number of pattern parts), as well as direct equality, in the configured lists of allowed field patterns and disallowed field patterns.

Matching against allowed field patterns is case-sensitive; whereas, matching against disallowed field patterns is case-insensitive.

A field matching a disallowed pattern will not be accepted even if it also happens to match a pattern in the allowed list.

Can be overridden in subclasses, but care must be taken to honor the aforementioned contract.

Parameters:
  `field` - the field to check
Returns:
  `true` if the field is allowed
See Also:
  - `setAllowedFields(java.lang.String...)`
  - `setDisallowedFields(java.lang.String...)`
  - `PatternMatchUtils.simpleMatch(String, String)`

### checkRequiredFields

protected void checkRequiredFields(org.springframework.beans.MutablePropertyValues mpvs)
Check the given property values against the required fields, generating missing field errors where appropriate.

Parameters:
  `mpvs` - the property values to be bound (can be modified)
See Also:
  - `getRequiredFields()`
  - `getBindingErrorProcessor()`
  - `BindingErrorProcessor.processMissingFieldError(java.lang.String, org.springframework.validation.BindingResult)`

### applyPropertyValues

protected void applyPropertyValues(org.springframework.beans.MutablePropertyValues mpvs)
Apply given property values to the target object.

Default implementation applies all the supplied property values as bean property values. By default, unknown fields will be ignored.

Parameters:
  `mpvs` - the property values to be bound (can be modified)
See Also:
  - `getTarget()`
  - `getPropertyAccessor()`
  - `isIgnoreUnknownFields()`
  - `getBindingErrorProcessor()`
  - `BindingErrorProcessor.processPropertyAccessException(org.springframework.beans.PropertyAccessException, org.springframework.validation.BindingResult)`

### validate

public void validate()
Invoke the specified Validators, if any.

See Also:
  - `setValidator(Validator)`
  - `getBindingResult()`

### validate

public void validate(Object... validationHints)
Invoke the specified Validators, if any, with the given validation hints.

Note: Validation hints may get ignored by the actual target Validator.

Parameters:
  `validationHints` - one or more hint objects to be passed to a `SmartValidator`
Since:
  3.1
See Also:
  - `setValidator(Validator)`
  - `SmartValidator.validate(Object, Errors, Object...)`

### close

public Map<?,?> close() throws BindException
Close this DataBinder, which may result in throwing a BindException if it encountered any errors.

Returns:
  the model Map, containing target object and Errors instance
Throws:
  `BindException` - if there were any errors in the bind operation
See Also:
  - `BindingResult.getModel()`