The Spring Framework

## org.springframework.beans
Class PropertyEditorRegistrySupport

    java.lang.Object
      org.springframework.beans.PropertyEditorRegistrySupport

All Implemented Interfaces:
  PropertyEditorRegistry

Direct Known Subclasses:
  AbstractPropertyAccessor, SimpleTypeConverter

    public class PropertyEditorRegistrySupport

extends Object
implements PropertyEditorRegistry

Base implementation of the `PropertyEditorRegistry` interface. Provides management of default editors and custom editors. Mainly serves as base class for `BeanWrapperImpl`.

Since:
  1.2.6
Author:
  Juergen Hoeller, Rob Harrop
See Also:
  `PropertyEditorManager`, `PropertyEditorSupport.setAsText(java.lang.String)`, `PropertyEditorSupport.setValue(java.lang.Object)`

Constructor Summary
`PropertyEditorRegistrySupport()`

Method Summary
`protected void` `copyCustomEditorsTo(PropertyEditorRegistry target, String nestedProperty)` Copy the custom editors registered in this instance to the given target registry.
`protected void` `copyDefaultEditorsTo(PropertyEditorRegistrySupport target)` Copy the default editors registered in this instance to the given target registry.
`PropertyEditor` `findCustomEditor(Class requiredType, String propertyPath)` Find a custom property editor for the given type and property.
`PropertyEditor` `getDefaultEditor(Class requiredType)` Retrieve the default editor for the given property type, if any.
`protected Class` `getPropertyType(String propertyPath)` Determine the property type for the given property path.
`protected Class` `guessPropertyTypeFromEditors(String propertyName)` Guess the property type of the specified property from the registered custom editors (provided that they were registered for a specific type).
`boolean` `hasCustomEditorForElement(Class elementType, String propertyPath)` Determine whether this registry contains a custom editor for the specified array/collection element.
`boolean` `isSharedEditor(PropertyEditor propertyEditor)` Check whether the given editor instance is a shared editor, that is, whether the given editor instance might be used concurrently.
`void` `registerCustomEditor(Class requiredType, PropertyEditor propertyEditor)` Register the given custom property editor for all properties of the given type.
`void` `registerCustomEditor(Class requiredType, String propertyPath, PropertyEditor propertyEditor)` Register the given custom property editor for the given type and property, or for all properties of the given type.
`protected void` `registerDefaultEditors()` Activate the default editors for this registry instance, allowing for lazily registering default editors when needed.
`void` `registerSharedEditor(Class requiredType, PropertyEditor propertyEditor)` Register the given custom property editor for all properties of the given type, indicating that the given instance is a shared editor that might be used concurrently.
`void` `useConfigValueEditors()` Activate config value editors which are only intended for configuration purposes, such as `StringArrayPropertyEditor`.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### PropertyEditorRegistrySupport

    public PropertyEditorRegistrySupport()

Method Detail

### registerDefaultEditors

    protected void registerDefaultEditors()

  Activate the default editors for this registry instance, allowing for lazily registering default editors when needed.

### useConfigValueEditors

    public void useConfigValueEditors()

  Activate config value editors which are only intended for configuration purposes, such as `StringArrayPropertyEditor`.

  Those editors are not registered by default simply because they are in general inappropriate for data binding purposes. Of course, you may register them individually in any case, through `registerCustomEditor(java.lang.Class, java.beans.PropertyEditor)`.

### getDefaultEditor

    public PropertyEditor getDefaultEditor(Class requiredType)

  Retrieve the default editor for the given property type, if any.

  Lazily registers the default editors, if they are active.

  Parameters:
    `requiredType` - type of the property
  Returns:
    the default editor, or `null` if none found
  See Also:
    `registerDefaultEditors()`

### copyDefaultEditorsTo

    protected void copyDefaultEditorsTo(PropertyEditorRegistrySupport target)

  Copy the default editors registered in this instance to the given target registry.

  Parameters:
    `target` - the target registry to copy to

### registerCustomEditor

    public void registerCustomEditor(Class requiredType,
                                     PropertyEditor propertyEditor)

  Description copied from interface: `PropertyEditorRegistry`
  Register the given custom property editor for all properties of the given type.

  Specified by:
    `registerCustomEditor` in interface `PropertyEditorRegistry`
  Parameters:
    `requiredType` - the type of the property
    `propertyEditor` - the editor to register

### registerCustomEditor

    public void registerCustomEditor(Class requiredType,
                                     String propertyPath,
                                     PropertyEditor propertyEditor)

  Description copied from interface: `PropertyEditorRegistry`
  Register the given custom property editor for the given type and property, or for all properties of the given type.

  If the property path denotes an array or Collection property, the editor 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 the case of a Collection/array, do not register an editor for both the Collection/array and each element on the same property.

  For example, if you wanted to register an editor for "items[n].quantity" (for all values n), you would use "items.quantity" as the value of the 'propertyPath' argument to this method.

  Specified by:
    `registerCustomEditor` in interface `PropertyEditorRegistry`
  Parameters:
    `requiredType` - the type of the property. This may be `null` if a property is given but should be specified in any case, in particular in case of a Collection - making clear whether the editor is supposed to apply to the entire Collection itself or to each of its entries. So as a general rule: Do not specify `null` here in case of a Collection/array!
    `propertyPath` - the path of the property (name or nested path), or `null` if registering an editor for all properties of the given type
    `propertyEditor` - editor to register

### registerSharedEditor

    public void registerSharedEditor(Class requiredType,
                                     PropertyEditor propertyEditor)

  Register the given custom property editor for all properties of the given type, indicating that the given instance is a shared editor that might be used concurrently.

  Parameters:
    `requiredType` - the type of the property
    `propertyEditor` - the shared editor to register

### isSharedEditor

    public boolean isSharedEditor(PropertyEditor propertyEditor)

  Check whether the given editor instance is a shared editor, that is, whether the given editor instance might be used concurrently.

  Parameters:
    `propertyEditor` - the editor instance to check
  Returns:
    whether the editor is a shared instance

### findCustomEditor

    public PropertyEditor findCustomEditor(Class requiredType,
                                           String propertyPath)

  Description copied from interface: `PropertyEditorRegistry`
  Find a custom property editor for the given type and property.

  Specified by:
    `findCustomEditor` in interface `PropertyEditorRegistry`
  Parameters:
    `requiredType` - the type of the property (can be `null` if a property is given but should be specified in any case for consistency checking)
    `propertyPath` - the path of the property (name or nested path), or `null` if looking for an editor for all properties of the given type
  Returns:
    the registered editor, or `null` if none

### hasCustomEditorForElement

    public boolean hasCustomEditorForElement(Class elementType,
                                             String propertyPath)

  Determine whether this registry contains a custom editor for the specified array/collection element.

  Parameters:
    `elementType` - the target type of the element (can be `null` if not known)
    `propertyPath` - the property path (typically of the array/collection; can be `null` if not known)
  Returns:
    whether a matching custom editor has been found

### getPropertyType

    protected Class getPropertyType(String propertyPath)

  Determine the property type for the given property path.

  Called by `findCustomEditor(java.lang.Class, java.lang.String)` if no required type has been specified, to be able to find a type-specific editor even if just given a property path.

  The default implementation always returns `null`. BeanWrapperImpl overrides this with the standard `getPropertyType` method as defined by the BeanWrapper interface.

  Parameters:
    `propertyPath` - the property path to determine the type for
  Returns:
    the type of the property, or `null` if not determinable
  See Also:
    `PropertyAccessor.getPropertyType(String)`

### guessPropertyTypeFromEditors

    protected Class guessPropertyTypeFromEditors(String propertyName)

  Guess the property type of the specified property from the registered custom editors (provided that they were registered for a specific type).

  Parameters:
    `propertyName` - the name of the property
  Returns:
    the property type, or `null` if not determinable

### copyCustomEditorsTo

    protected void copyCustomEditorsTo(PropertyEditorRegistry target,
                                       String nestedProperty)

  Copy the custom editors registered in this instance to the given target registry.

  Parameters:
    `target` - the target registry to copy to
    `nestedProperty` - the nested property path of the target registry, if any. If this is non-null, only editors registered for a path below this nested property will be copied. If this is null, all editors will be copied.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.