org.springframework.beans

## Class BeanWrapperImpl

- java.lang.Object
- - org.springframework.beans.PropertyEditorRegistrySupport
  - - org.springframework.beans.TypeConverterSupport
    - - org.springframework.beans.AbstractPropertyAccessor
      - - org.springframework.beans.BeanWrapperImpl

- All Implemented Interfaces:
    BeanWrapper, ConfigurablePropertyAccessor, PropertyAccessor, PropertyEditorRegistry, TypeConverter

      public class BeanWrapperImpl
      extends AbstractPropertyAccessor
      implements BeanWrapper

  Default `BeanWrapper` implementation that should be sufficient for all typical use cases. Caches introspection results for efficiency.

  Note: Auto-registers default property editors from the `org.springframework.beans.propertyeditors` package, which apply in addition to the JDK's standard PropertyEditors. Applications can call the `PropertyEditorRegistrySupport.registerCustomEditor(Class, java.beans.PropertyEditor)` method to register an editor for a particular instance (i.e. they are not shared across the application). See the base class `PropertyEditorRegistrySupport` for details.

  `BeanWrapperImpl` will convert collection and array values to the corresponding target collections or arrays, if necessary. Custom property editors that deal with collections or arrays can either be written via PropertyEditor's `setValue`, or against a comma-delimited String via `setAsText`, as String arrays are converted in such a format if the array itself is not assignable.

  NOTE: As of Spring 2.5, this is - for almost all purposes - an internal class. It is just public in order to allow for access from other framework packages. For standard application access purposes, use the `PropertyAccessorFactory.forBeanPropertyAccess(java.lang.Object)` factory method instead.

  Since:
    15 April 2001
  Author:
    Rod Johnson, Juergen Hoeller, Rob Harrop
  See Also:
    `PropertyEditorRegistrySupport.registerCustomEditor(java.lang.Class<?>, java.beans.PropertyEditor)`, `AbstractPropertyAccessor.setPropertyValues(java.util.Map<?, ?>)`, `setPropertyValue(java.lang.String, java.lang.Object)`, `getPropertyValue(java.lang.String)`, `getPropertyType(java.lang.String)`, `BeanWrapper`, `PropertyEditorRegistrySupport`

- - ### Field Summary

    - ### Fields inherited from interface org.springframework.beans.PropertyAccessor

      `NESTED_PROPERTY_SEPARATOR, NESTED_PROPERTY_SEPARATOR_CHAR, PROPERTY_KEY_PREFIX, PROPERTY_KEY_PREFIX_CHAR, PROPERTY_KEY_SUFFIX, PROPERTY_KEY_SUFFIX_CHAR`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BeanWrapperImpl()` Create new empty BeanWrapperImpl.
    `BeanWrapperImpl(boolean registerDefaultEditors)` Create new empty BeanWrapperImpl.
    `BeanWrapperImpl(Class<?> clazz)` Create new BeanWrapperImpl, wrapping a new instance of the specified class.
    `BeanWrapperImpl(Object object)` Create new BeanWrapperImpl for the given object.
    `BeanWrapperImpl(Object object, String nestedPath, Object rootObject)` Create new BeanWrapperImpl for the given object, registering a nested path that the object is in.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Object` | `convertForProperty(Object value, String propertyName)` Convert the given value for the specified property to the latter's type.
    `int` | `getAutoGrowCollectionLimit()` Return the limit for array and collection auto-growing.
    `protected BeanWrapperImpl` | `getBeanWrapperForPropertyPath(String propertyPath)` Recursively navigate to return a BeanWrapper for the nested property path.
    `String` | `getNestedPath()` Return the nested path of the object wrapped by this BeanWrapper.
    `PropertyDescriptor` | `getPropertyDescriptor(String propertyName)` Obtain the property descriptor for a specific property of the wrapped object.
    `protected PropertyDescriptor` | `getPropertyDescriptorInternal(String propertyName)` Internal version of `getPropertyDescriptor(java.lang.String)`: Returns `null` if not found rather than throwing an exception.
    `PropertyDescriptor[]` | `getPropertyDescriptors()` Obtain the PropertyDescriptors for the wrapped object (as determined by standard JavaBeans introspection).
    `Class<?>` | `getPropertyType(String propertyName)` Determine the property type for the given property path.
    `TypeDescriptor` | `getPropertyTypeDescriptor(String propertyName)` Return a type descriptor for the specified property: preferably from the read method, falling back to the write method.
    `Object` | `getPropertyValue(String propertyName)` Actually get the value of a property.
    `Class<?>` | `getRootClass()` Return the class of the root object at the top of the path of this BeanWrapper.
    `Object` | `getRootInstance()` Return the root object at the top of the path of this BeanWrapper.
    `AccessControlContext` | `getSecurityContext()` Return the security context used during the invocation of the wrapped instance methods.
    `Class<?>` | `getWrappedClass()` Return the type of the wrapped JavaBean object.
    `Object` | `getWrappedInstance()` Return the bean instance wrapped by this object, if any.
    `boolean` | `isAutoGrowNestedPaths()` Return whether "auto-growing" of nested paths has been activated.
    `boolean` | `isReadableProperty(String propertyName)` Determine whether the specified property is readable.
    `boolean` | `isWritableProperty(String propertyName)` Determine whether the specified property is writable.
    `protected BeanWrapperImpl` | `newNestedBeanWrapper(Object object, String nestedPath)` Create a new nested BeanWrapper instance.
    `void` | `setAutoGrowCollectionLimit(int autoGrowCollectionLimit)` Specify a limit for array and collection auto-growing.
    `void` | `setAutoGrowNestedPaths(boolean autoGrowNestedPaths)` Set whether this BeanWrapper should attempt to "auto-grow" a nested path that contains a null value.
    `protected void` | `setIntrospectionClass(Class<?> clazz)` Set the class to introspect.
    `void` | `setPropertyValue(PropertyValue pv)` Set the specified value as current property value.
    `void` | `setPropertyValue(String propertyName, Object value)` Actually set a property value.
    `void` | `setSecurityContext(AccessControlContext acc)` Set the security context used during the invocation of the wrapped instance methods.
    `void` | `setWrappedInstance(Object object)` Switch the target object, replacing the cached introspection results only if the class of the new object is different to that of the replaced object.
    `void` | `setWrappedInstance(Object object, String nestedPath, Object rootObject)` Switch the target object, replacing the cached introspection results only if the class of the new object is different to that of the replaced object.
    `String` | `toString()`

    - ### Methods inherited from class org.springframework.beans.AbstractPropertyAccessor

      `isExtractOldValueForEditor, setExtractOldValueForEditor, setPropertyValues, setPropertyValues, setPropertyValues, setPropertyValues`

    - ### Methods inherited from class org.springframework.beans.TypeConverterSupport

      `convertIfNecessary, convertIfNecessary, convertIfNecessary`

    - ### Methods inherited from class org.springframework.beans.PropertyEditorRegistrySupport

      `copyCustomEditorsTo, copyDefaultEditorsTo, findCustomEditor, getConversionService, getDefaultEditor, guessPropertyTypeFromEditors, hasCustomEditorForElement, isSharedEditor, overrideDefaultEditor, registerCustomEditor, registerCustomEditor, registerDefaultEditors, registerSharedEditor, setConversionService, useConfigValueEditors`

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

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

    - ### Methods inherited from interface org.springframework.beans.ConfigurablePropertyAccessor

      `getConversionService, isExtractOldValueForEditor, setConversionService, setExtractOldValueForEditor`

    - ### Methods inherited from interface org.springframework.beans.PropertyAccessor

      `setPropertyValues, setPropertyValues, setPropertyValues, setPropertyValues`

    - ### Methods inherited from interface org.springframework.beans.PropertyEditorRegistry

      `findCustomEditor, registerCustomEditor, registerCustomEditor`

    - ### Methods inherited from interface org.springframework.beans.TypeConverter

      `convertIfNecessary, convertIfNecessary, convertIfNecessary`

- - ### Constructor Detail

    - #### BeanWrapperImpl

          public BeanWrapperImpl()

      Create new empty BeanWrapperImpl. Wrapped instance needs to be set afterwards. Registers default editors.
      See Also:
        `setWrappedInstance(java.lang.Object)`

    - #### BeanWrapperImpl

          public BeanWrapperImpl(boolean registerDefaultEditors)

      Create new empty BeanWrapperImpl. Wrapped instance needs to be set afterwards.
      Parameters:
        `registerDefaultEditors` - whether to register default editors (can be suppressed if the BeanWrapper won't need any type conversion)
      See Also:
        `setWrappedInstance(java.lang.Object)`

    - #### BeanWrapperImpl

          public BeanWrapperImpl(Object object)

      Create new BeanWrapperImpl for the given object.
      Parameters:
        `object` - object wrapped by this BeanWrapper

    - #### BeanWrapperImpl

          public BeanWrapperImpl(Class<?> clazz)

      Create new BeanWrapperImpl, wrapping a new instance of the specified class.
      Parameters:
        `clazz` - class to instantiate and wrap

    - #### BeanWrapperImpl

          public BeanWrapperImpl(Object object,
                         String nestedPath,
                         Object rootObject)

      Create new BeanWrapperImpl for the given object, registering a nested path that the object is in.
      Parameters:
        `object` - object wrapped by this BeanWrapper
        `nestedPath` - the nested path of the object
        `rootObject` - the root object at the top of the path

  - ### Method Detail

    - #### setWrappedInstance

          public void setWrappedInstance(Object object)

      Switch the target object, replacing the cached introspection results only if the class of the new object is different to that of the replaced object.
      Parameters:
        `object` - the new target object

    - #### setWrappedInstance

          public void setWrappedInstance(Object object,
                                String nestedPath,
                                Object rootObject)

      Switch the target object, replacing the cached introspection results only if the class of the new object is different to that of the replaced object.
      Parameters:
        `object` - the new target object
        `nestedPath` - the nested path of the object
        `rootObject` - the root object at the top of the path

    - #### getWrappedInstance

          public final Object getWrappedInstance()

      Description copied from interface: `BeanWrapper`
      Return the bean instance wrapped by this object, if any.
      Specified by:
        `getWrappedInstance` in interface `BeanWrapper`
      Returns:
        the bean instance, or `null` if none set

    - #### getWrappedClass

          public final Class<?> getWrappedClass()

      Description copied from interface: `BeanWrapper`
      Return the type of the wrapped JavaBean object.
      Specified by:
        `getWrappedClass` in interface `BeanWrapper`
      Returns:
        the type of the wrapped bean instance, or `null` if no wrapped object has been set

    - #### getNestedPath

          public final String getNestedPath()

      Return the nested path of the object wrapped by this BeanWrapper.

    - #### getRootInstance

          public final Object getRootInstance()

      Return the root object at the top of the path of this BeanWrapper.
      See Also:
        `getNestedPath()`

    - #### getRootClass

          public final Class<?> getRootClass()

      Return the class of the root object at the top of the path of this BeanWrapper.
      See Also:
        `getNestedPath()`

    - #### setAutoGrowNestedPaths

          public void setAutoGrowNestedPaths(boolean autoGrowNestedPaths)

      Set whether this BeanWrapper 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 a `NullValueInNestedPathException`. Turning this flag on also enables auto-growth of collection elements when accessing an out-of-bounds index.

      Default is "false" on a plain BeanWrapper.

      Specified by:
        `setAutoGrowNestedPaths` in interface `BeanWrapper`

    - #### isAutoGrowNestedPaths

          public boolean isAutoGrowNestedPaths()

      Return whether "auto-growing" of nested paths has been activated.
      Specified by:
        `isAutoGrowNestedPaths` in interface `BeanWrapper`

    - #### setAutoGrowCollectionLimit

          public void setAutoGrowCollectionLimit(int autoGrowCollectionLimit)

      Specify a limit for array and collection auto-growing.

      Default is unlimited on a plain BeanWrapper.

      Specified by:
        `setAutoGrowCollectionLimit` in interface `BeanWrapper`

    - #### getAutoGrowCollectionLimit

          public int getAutoGrowCollectionLimit()

      Return the limit for array and collection auto-growing.
      Specified by:
        `getAutoGrowCollectionLimit` in interface `BeanWrapper`

    - #### setSecurityContext

          public void setSecurityContext(AccessControlContext acc)

      Set the security context used during the invocation of the wrapped instance methods. Can be null.

    - #### getSecurityContext

          public AccessControlContext getSecurityContext()

      Return the security context used during the invocation of the wrapped instance methods. Can be null.

    - #### setIntrospectionClass

          protected void setIntrospectionClass(Class<?> clazz)

      Set the class to introspect. Needs to be called when the target object changes.
      Parameters:
        `clazz` - the class to introspect

    - #### getPropertyDescriptors

          public PropertyDescriptor[] getPropertyDescriptors()

      Description copied from interface: `BeanWrapper`
      Obtain the PropertyDescriptors for the wrapped object (as determined by standard JavaBeans introspection).
      Specified by:
        `getPropertyDescriptors` in interface `BeanWrapper`
      Returns:
        the PropertyDescriptors for the wrapped object

    - #### getPropertyDescriptor

          public PropertyDescriptor getPropertyDescriptor(String propertyName)
                                                   throws BeansException

      Description copied from interface: `BeanWrapper`
      Obtain the property descriptor for a specific property of the wrapped object.
      Specified by:
        `getPropertyDescriptor` in interface `BeanWrapper`
      Parameters:
        `propertyName` - the property to obtain the descriptor for (may be a nested path, but no indexed/mapped property)
      Returns:
        the property descriptor for the specified property
      Throws:
        `InvalidPropertyException` - if there is no such property
        `BeansException`

    - #### getPropertyDescriptorInternal

          protected PropertyDescriptor getPropertyDescriptorInternal(String propertyName)
                                                              throws BeansException

      Internal version of `getPropertyDescriptor(java.lang.String)`: Returns `null` if not found rather than throwing an exception.
      Parameters:
        `propertyName` - the property to obtain the descriptor for
      Returns:
        the property descriptor for the specified property, or `null` if not found
      Throws:
        `BeansException` - in case of introspection failure

    - #### getPropertyType

          public Class<?> getPropertyType(String propertyName)
                                   throws BeansException

      Description copied from class: `PropertyEditorRegistrySupport`
      Determine the property type for the given property path.

      Called by `PropertyEditorRegistrySupport.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.

      Specified by:
        `getPropertyType` in interface `PropertyAccessor`
      Overrides:
        `getPropertyType` in class `AbstractPropertyAccessor`
      Parameters:
        `propertyName` - the property path to determine the type for
      Returns:
        the type of the property, or `null` if not determinable
      Throws:
        `InvalidPropertyException` - if there is no such property or if the property isn't readable
        `PropertyAccessException` - if the property was valid but the accessor method failed
        `BeansException`
      See Also:
        `PropertyAccessor.getPropertyType(String)`

    - #### getPropertyTypeDescriptor

          public TypeDescriptor getPropertyTypeDescriptor(String propertyName)
                                                   throws BeansException

      Description copied from interface: `PropertyAccessor`
      Return a type descriptor for the specified property: preferably from the read method, falling back to the write method.
      Specified by:
        `getPropertyTypeDescriptor` in interface `PropertyAccessor`
      Parameters:
        `propertyName` - the property to check (may be a nested path and/or an indexed/mapped property)
      Returns:
        the property type for the particular property, or `null` if not determinable
      Throws:
        `InvalidPropertyException` - if there is no such property or if the property isn't readable
        `BeansException`

    - #### isReadableProperty

          public boolean isReadableProperty(String propertyName)

      Description copied from interface: `PropertyAccessor`
      Determine whether the specified property is readable.

      Returns `false` if the property doesn't exist.

      Specified by:
        `isReadableProperty` in interface `PropertyAccessor`
      Parameters:
        `propertyName` - the property to check (may be a nested path and/or an indexed/mapped property)
      Returns:
        whether the property is readable

    - #### isWritableProperty

          public boolean isWritableProperty(String propertyName)

      Description copied from interface: `PropertyAccessor`
      Determine whether the specified property is writable.

      Returns `false` if the property doesn't exist.

      Specified by:
        `isWritableProperty` in interface `PropertyAccessor`
      Parameters:
        `propertyName` - the property to check (may be a nested path and/or an indexed/mapped property)
      Returns:
        whether the property is writable

    - #### convertForProperty

          public Object convertForProperty(Object value,
                                  String propertyName)
                                    throws TypeMismatchException

      Convert the given value for the specified property to the latter's type.

      This method is only intended for optimizations in a BeanFactory. Use the `convertIfNecessary` methods for programmatic conversion.

      Parameters:
        `value` - the value to convert
        `propertyName` - the target property (note that nested or indexed properties are not supported here)
      Returns:
        the new value, possibly the result of type conversion
      Throws:
        `TypeMismatchException` - if type conversion failed

    - #### getBeanWrapperForPropertyPath

          protected BeanWrapperImpl getBeanWrapperForPropertyPath(String propertyPath)

      Recursively navigate to return a BeanWrapper for the nested property path.
      Parameters:
        `propertyPath` - property property path, which may be nested
      Returns:
        a BeanWrapper for the target bean

    - #### newNestedBeanWrapper

          protected BeanWrapperImpl newNestedBeanWrapper(Object object,
                                             String nestedPath)

      Create a new nested BeanWrapper instance.

      Default implementation creates a BeanWrapperImpl instance. Can be overridden in subclasses to create a BeanWrapperImpl subclass.

      Parameters:
        `object` - object wrapped by this BeanWrapper
        `nestedPath` - the nested path of the object
      Returns:
        the nested BeanWrapper instance

    - #### getPropertyValue

          public Object getPropertyValue(String propertyName)
                                  throws BeansException

      Description copied from class: `AbstractPropertyAccessor`
      Actually get the value of a property.
      Specified by:
        `getPropertyValue` in interface `PropertyAccessor`
      Specified by:
        `getPropertyValue` in class `AbstractPropertyAccessor`
      Parameters:
        `propertyName` - name of the property to get the value of
      Returns:
        the value of the property
      Throws:
        `InvalidPropertyException` - if there is no such property or if the property isn't readable
        `PropertyAccessException` - if the property was valid but the accessor method failed
        `BeansException`

    - #### setPropertyValue

          public void setPropertyValue(String propertyName,
                              Object value)
                                throws BeansException

      Description copied from class: `AbstractPropertyAccessor`
      Actually set a property value.
      Specified by:
        `setPropertyValue` in interface `PropertyAccessor`
      Specified by:
        `setPropertyValue` in class `AbstractPropertyAccessor`
      Parameters:
        `propertyName` - name of the property to set value of
        `value` - the new value
      Throws:
        `InvalidPropertyException` - if there is no such property or if the property isn't writable
        `PropertyAccessException` - if the property was valid but the accessor method failed or a type mismatch occured
        `BeansException`

    - #### setPropertyValue

          public void setPropertyValue(PropertyValue pv)
                                throws BeansException

      Description copied from interface: `PropertyAccessor`
      Set the specified value as current property value.
      Specified by:
        `setPropertyValue` in interface `PropertyAccessor`
      Overrides:
        `setPropertyValue` in class `AbstractPropertyAccessor`
      Parameters:
        `pv` - an object containing the new property value
      Throws:
        `InvalidPropertyException` - if there is no such property or if the property isn't writable
        `PropertyAccessException` - if the property was valid but the accessor method failed or a type mismatch occured
        `BeansException`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`