|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.springframework.validation.DataBinder
public class DataBinder
Binder that allows for binding property values to a target object. The binding process can be customized through specifying allowed fields, required fields, and custom editors.
Note that there are potential security implications in failing to set
an array of allowed fields. In the case of HTTP form POST data for example,
malicious clients can attempt to subvert an application by supplying values
for fields or properties that do not exist on the form. In some cases this
could lead to illegal data being set on command objects or their nested
objects. For this reason, it is highly recommended to specify the
allowedFields
property on the DataBinder.
The binding results can be examined via the Errors interface, available as BindException instance. Missing field errors and property access exceptions will be converted to FieldErrors, collected in the Errors instance, with the following 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. The list of message codes to try can be customized through the MessageCodesResolver strategy. DefaultMessageCodesResolver's javadoc gives details on the default resolution rules.
By default, binding errors are resolved through the binding error processor for required binding errors and property access exceptions. You can override those if needed, for example to generate different error codes.
This generic data binder can be used in any sort of environment.
It is heavily used by Spring's web MVC controllers, via the subclass
org.springframework.web.bind.ServletRequestDataBinder
.
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)
,
bind(org.springframework.beans.PropertyValues)
,
getErrors()
,
DefaultMessageCodesResolver
,
DefaultBindingErrorProcessor
,
MessageSource
,
ServletRequestDataBinder
Field Summary | |
---|---|
protected static Log |
logger
We'll create a lot of DataBinder instances: Let's use a static logger. |
Constructor Summary | |
---|---|
DataBinder(Object target,
String objectName)
Create a new DataBinder instance. |
Method Summary | |
---|---|
protected void |
applyPropertyValues(MutablePropertyValues mpvs)
Apply given property values to the target object. |
void |
bind(PropertyValues pvs)
Bind the given property values to this binder's target. |
protected void |
checkAllowedFields(MutablePropertyValues mpvs)
Check the given property values against the allowed fields, removing values for fields that are not allowed. |
protected void |
checkRequiredFields(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 |
protected BindException |
createErrors(Object target,
String objectName)
Create a new Errors instance for this data binder. |
protected void |
doBind(MutablePropertyValues mpvs)
Actual implementation of the binding process, working with the passed-in MutablePropertyValues instance. |
String[] |
getAllowedFields()
Return the fields that should be allowed for binding. |
protected BeanWrapper |
getBeanWrapper()
Return the underlying BeanWrapper of the Errors object. |
BindingErrorProcessor |
getBindingErrorProcessor()
Return the strategy for processing binding errors. |
BindException |
getErrors()
Return the Errors instance for this data binder. |
String |
getObjectName()
Return the name of the bound object. |
String[] |
getRequiredFields()
Return the fields that are required for each binding process. |
Object |
getTarget()
Return the wrapped target object. |
protected boolean |
isAllowed(String field)
Return if the given field is allowed for binding. |
boolean |
isIgnoreUnknownFields()
Return whether to ignore unknown fields, i.e. whether to ignore request parameters that don't have corresponding fields in the target object. |
void |
registerCustomEditor(Class requiredType,
PropertyEditor propertyEditor)
Register the given custom property editor for all properties of the given type. |
void |
registerCustomEditor(Class requiredType,
String field,
PropertyEditor propertyEditor)
Register the given custom property editor for the given type and field, or for all fields of the given type. |
void |
setAllowedFields(String[] allowedFields)
Register fields that should be allowed for binding. |
void |
setBindingErrorProcessor(BindingErrorProcessor bindingErrorProcessor)
Set the strategy to use for processing binding errors, that is, required field errors and PropertyAccessException s. |
void |
setIgnoreUnknownFields(boolean ignoreUnknownFields)
Set whether to ignore unknown fields, i.e. whether to ignore request parameters that don't have corresponding fields in the target object. |
void |
setMessageCodesResolver(MessageCodesResolver messageCodesResolver)
Set the strategy to use for resolving errors into message codes. |
void |
setRequiredFields(String[] requiredFields)
Register fields that are required for each binding process. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
protected static final Log logger
Constructor Detail |
---|
public DataBinder(Object target, String objectName)
target
- target object to bind ontoobjectName
- name of the target objectMethod Detail |
---|
protected BindException createErrors(Object target, String objectName)
target
- target object to bind ontoobjectName
- name of the target object
close()
public Object getTarget()
public String getObjectName()
public BindException getErrors()
Errors
protected BeanWrapper getBeanWrapper()
public void setIgnoreUnknownFields(boolean ignoreUnknownFields)
public boolean isIgnoreUnknownFields()
public void setAllowedFields(String[] allowedFields)
Supports "xxx*" and "*xxx" patterns. More sophisticated matching can be implemented by overriding the isAllowed method.
allowedFields
- array of field namesServletRequestDataBinder
,
isAllowed(java.lang.String)
public String[] getAllowedFields()
public void setRequiredFields(String[] requiredFields)
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).
requiredFields
- array of field namessetBindingErrorProcessor(org.springframework.validation.BindingErrorProcessor)
,
DefaultBindingErrorProcessor.MISSING_FIELD_ERROR_CODE
public String[] getRequiredFields()
public void registerCustomEditor(Class requiredType, PropertyEditor propertyEditor)
requiredType
- type of the propertypropertyEditor
- editor to registerBeanWrapper.registerCustomEditor(java.lang.Class, java.beans.PropertyEditor)
public void registerCustomEditor(Class requiredType, String field, PropertyEditor propertyEditor)
If the field denotes an array or Collection, the PropertyEditor will get applied either to the array/Collection itself (the PropertyEditor has to create an array or Collection value) or to each element (the PropertyEditor has to create the element type), depending on the specified required type.
Note: Only one single registered custom editor per property path is supported. In case of a Collection/array, do not register an editor for both the Collection/array and each element on the same property.
requiredType
- type of the property (can be null if a field is
given but should be specified in any case for consistency checking)field
- name of the field (can also be a nested path), or
null if registering an editor for all fields of the given typepropertyEditor
- editor to registerBeanWrapper.registerCustomEditor(java.lang.Class, java.beans.PropertyEditor)
public void setMessageCodesResolver(MessageCodesResolver messageCodesResolver)
Default is a DefaultMessageCodesResolver.
BindException.setMessageCodesResolver(org.springframework.validation.MessageCodesResolver)
,
DefaultMessageCodesResolver
public void setBindingErrorProcessor(BindingErrorProcessor bindingErrorProcessor)
PropertyAccessException
s.
Default is a DefaultBindingErrorProcessor.
DefaultBindingErrorProcessor
public BindingErrorProcessor getBindingErrorProcessor()
public void bind(PropertyValues pvs)
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.
pvs
- property values to binddoBind(org.springframework.beans.MutablePropertyValues)
protected void doBind(MutablePropertyValues mpvs)
mpvs
- the property values to bind,
as MutablePropertyValues instancecheckAllowedFields(org.springframework.beans.MutablePropertyValues)
,
checkRequiredFields(org.springframework.beans.MutablePropertyValues)
,
applyPropertyValues(org.springframework.beans.MutablePropertyValues)
protected void checkAllowedFields(MutablePropertyValues mpvs)
mpvs
- the property values to be bound (can be modified)getAllowedFields()
,
isAllowed(String)
protected boolean isAllowed(String field)
The default implementation checks for "xxx*" and "*xxx" matches. Can be overridden in subclasses.
If the field is found in the allowedFields array as direct match, this method will not be invoked.
field
- the field to check
setAllowedFields(java.lang.String[])
protected void checkRequiredFields(MutablePropertyValues mpvs)
mpvs
- the property values to be bound (can be modified)getRequiredFields()
,
getBindingErrorProcessor()
,
BindingErrorProcessor.processMissingFieldError(java.lang.String, org.springframework.validation.BindException)
protected void applyPropertyValues(MutablePropertyValues mpvs)
Default implementation applies them all of them as bean property values via the corresponding BeanWrapper. Unknown fields will by default be ignored.
mpvs
- the property values to be bound (can be modified)getTarget()
,
getBeanWrapper()
,
isIgnoreUnknownFields()
,
getBindingErrorProcessor()
,
BindingErrorProcessor.processPropertyAccessException(org.springframework.beans.PropertyAccessException, org.springframework.validation.BindException)
public Map close() throws BindException
BindException
- if there were any errors in the bind operationBindException.getModel()
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |