org.springframework.beans

Interface Summary
Interface	Description
BeanInfoFactory	Strategy interface for creating `BeanInfo` instances for Spring beans.
BeanMetadataElement	Interface to be implemented by bean metadata elements that carry a configuration source object.
BeanWrapper	The central interface of Spring's low-level JavaBeans infrastructure.
ConfigurablePropertyAccessor	Interface that encapsulates configuration methods for a PropertyAccessor.
Mergeable	Interface representing an object whose value set can be merged with that of a parent object.
PropertyAccessor	Common interface for classes that can access named properties (such as bean properties of an object or fields in an object) Serves as base interface for `BeanWrapper`.
PropertyEditorRegistrar	Interface for strategies that register custom `property editors` with a `property editor registry`.
PropertyEditorRegistry	Encapsulates methods for registering JavaBeans `PropertyEditors`.
PropertyValues	Holder containing one or more `PropertyValue` objects, typically comprising one update for a specific target bean.
TypeConverter	Interface that defines type conversion methods.

Class Summary
Class	Description
AbstractNestablePropertyAccessor	A basic `ConfigurablePropertyAccessor` that provides the necessary infrastructure for all typical use cases.
AbstractNestablePropertyAccessor.OptionalUnwrapper	Inner class to avoid a hard dependency on Java 8.
AbstractNestablePropertyAccessor.PropertyHandler
AbstractNestablePropertyAccessor.PropertyTokenHolder
AbstractPropertyAccessor	Abstract implementation of the `PropertyAccessor` interface.
BeanMetadataAttribute	Holder for a key-value style attribute that is part of a bean definition.
BeanMetadataAttributeAccessor	Extension of `AttributeAccessorSupport`, holding attributes as `BeanMetadataAttribute` objects in order to keep track of the definition source.
BeanUtils	Static convenience methods for JavaBeans: for instantiating beans, checking bean property types, copying bean properties, etc.
BeanWrapperImpl	Default `BeanWrapper` implementation that should be sufficient for all typical use cases.
CachedIntrospectionResults	Internal class that caches JavaBeans `PropertyDescriptor` information for a Java class.
DirectFieldAccessor	`ConfigurablePropertyAccessor` implementation that directly accesses instance fields.
ExtendedBeanInfo	Decorator for a standard `BeanInfo` object, e.g.
ExtendedBeanInfo.PropertyDescriptorComparator	Sorts PropertyDescriptor instances alpha-numerically to emulate the behavior of `BeanInfo.getPropertyDescriptors()`.
ExtendedBeanInfo.SimpleIndexedPropertyDescriptor
ExtendedBeanInfo.SimplePropertyDescriptor
ExtendedBeanInfoFactory	`BeanInfoFactory` implementation that evaluates whether bean classes have "non-standard" JavaBeans setter methods and are thus candidates for introspection by Spring's (package-visible) `ExtendedBeanInfo` implementation.
GenericTypeAwarePropertyDescriptor	Extension of the standard JavaBeans `PropertyDescriptor` class, overriding `getPropertyType()` such that a generically declared type variable will be resolved against the containing bean class.
MutablePropertyValues	Default implementation of the `PropertyValues` interface.
PropertyAccessorFactory	Simple factory facade for obtaining `PropertyAccessor` instances, in particular for `BeanWrapper` instances.
PropertyAccessorUtils	Utility methods for classes that perform bean property access according to the `PropertyAccessor` interface.
PropertyDescriptorUtils	Common delegate methods for Spring's internal `PropertyDescriptor` implementations.
PropertyEditorRegistrySupport	Base implementation of the `PropertyEditorRegistry` interface.
PropertyEditorRegistrySupport.CustomEditorHolder	Holder for a registered custom editor with property name.
PropertyMatches	Helper class for calculating property matches, according to a configurable distance.
PropertyMatches.BeanPropertyMatches
PropertyMatches.FieldPropertyMatches
PropertyValue	Object to hold information and value for an individual bean property.
PropertyValuesEditor	`Editor` for a `PropertyValues` object.
SimpleTypeConverter	Simple implementation of the `TypeConverter` interface that does not operate on a specific target object.
TypeConverterDelegate	Internal helper class for converting property values to target types.
TypeConverterSupport	Base implementation of the `TypeConverter` interface, using a package-private delegate.

Exception Summary
Exception	Description
BeanInstantiationException	Exception thrown when instantiation of a bean failed.
BeansException	Abstract superclass for all exceptions thrown in the beans package and subpackages.
ConversionNotSupportedException	Exception thrown when no suitable editor or converter can be found for a bean property.
FatalBeanException	Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g.
InvalidPropertyException	Exception thrown when referring to an invalid bean property.
MethodInvocationException	Thrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException.
NotReadablePropertyException	Exception thrown on an attempt to get the value of a property that isn't readable, because there's no getter method.
NotWritablePropertyException	Exception thrown on an attempt to set the value of a property that is not writable (typically because there is no setter method).
NullValueInNestedPathException	Exception thrown when navigation of a valid nested property path encounters a NullPointerException.
PropertyAccessException	Superclass for exceptions related to a property access, such as type mismatch or invocation target exception.
PropertyBatchUpdateException	Combined exception, composed of individual PropertyAccessException instances.
TypeMismatchException	Exception thrown on a type mismatch when trying to set a bean property.

Package org.springframework.beans Description

This package contains interfaces and classes for manipulating Java beans. It is used by most other Spring packages.

A BeanWrapper object may be used to set and get bean properties, singly or in bulk.

The classes in this package are discussed in Chapter 11 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).