public class CustomEditorConfigurer extends Object implements BeanFactoryPostProcessor, org.springframework.core.Ordered
BeanFactoryPostProcessor implementation that allows for convenient
 registration of custom property editors.
 In case you want to register PropertyEditor instances,
 the recommended usage as of Spring 2.0 is to use custom
 PropertyEditorRegistrar implementations that in turn register any
 desired editor instances on a given
 registry. Each
 PropertyEditorRegistrar can register any number of custom editors.
 
 <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer">
   <property name="propertyEditorRegistrars">
     <list>
       <bean class="mypackage.MyCustomDateEditorRegistrar"/>
       <bean class="mypackage.MyObjectEditorRegistrar"/>
     </list>
   </property>
 </bean>
 
 
 It's perfectly fine to register PropertyEditor classes via
 the customEditors property. Spring will create fresh instances of
 them for each editing attempt then:
 
 <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer">
   <property name="customEditors">
     <map>
       <entry key="java.util.Date" value="mypackage.MyCustomDateEditor"/>
       <entry key="mypackage.MyObject" value="mypackage.MyObjectEditor"/>
     </map>
   </property>
 </bean>
 
 
 Note, that you shouldn't register PropertyEditor bean instances via
 the customEditors property as PropertyEditors are stateful
 and the instances will then have to be synchronized for every editing
 attempt. In case you need control over the instantiation process of
 PropertyEditors, use a PropertyEditorRegistrar to register
 them.
 
 Also supports "java.lang.String[]"-style array class names and primitive
 class names (e.g. "boolean"). Delegates to ClassUtils for actual
 class name resolution.
 
NOTE: Custom property editors registered with this configurer do
 not apply to data binding. Custom editors for data binding need to
 be registered on the org.springframework.validation.DataBinder:
 Use a common base class or delegate to common PropertyEditorRegistrar
 implementations to reuse editor registration there.
PropertyEditor, 
PropertyEditorRegistrar, 
ConfigurableBeanFactory.addPropertyEditorRegistrar(org.springframework.beans.PropertyEditorRegistrar), 
ConfigurableBeanFactory.registerCustomEditor(java.lang.Class<?>, java.lang.Class<? extends java.beans.PropertyEditor>), 
org.springframework.validation.DataBinder#registerCustomEditor| Constructor and Description | 
|---|
| CustomEditorConfigurer() | 
| Modifier and Type | Method and Description | 
|---|---|
| int | getOrder() | 
| void | postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)Modify the application context's internal bean factory after its standard
 initialization. | 
| void | setCustomEditors(Map<Class<?>,Class<? extends PropertyEditor>> customEditors)Specify the custom editors to register via a  Map, using the
 class name of the required type as the key and the class name of the
 associatedPropertyEditoras value. | 
| void | setOrder(int order) | 
| void | setPropertyEditorRegistrars(PropertyEditorRegistrar[] propertyEditorRegistrars)Specify the  PropertyEditorRegistrarsto apply to beans defined within the current application context. | 
protected final Log logger
public void setOrder(int order)
public int getOrder()
getOrder in interface org.springframework.core.Orderedpublic void setPropertyEditorRegistrars(PropertyEditorRegistrar[] propertyEditorRegistrars)
PropertyEditorRegistrars
 to apply to beans defined within the current application context.
 This allows for sharing PropertyEditorRegistrars with
 DataBinders, etc.
 Furthermore, it avoids the need for synchronization on custom editors:
 A PropertyEditorRegistrar will always create fresh editor
 instances for each bean creation attempt.
public void setCustomEditors(Map<Class<?>,Class<? extends PropertyEditor>> customEditors)
Map, using the
 class name of the required type as the key and the class name of the
 associated PropertyEditor as value.public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
BeanFactoryPostProcessorpostProcessBeanFactory in interface BeanFactoryPostProcessorbeanFactory - the bean factory used by the application contextBeansException - in case of errors