The Spring Framework

## Package org.springframework.beans

This package contains interfaces and classes for manipulating Java beans.

See:
Description

Interface Summary
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
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: `PropertyAccessor` implementation that directly accesses instance fields.
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.
PropertyEditorRegistrySupport: Base implementation of the `PropertyEditorRegistry` interface.
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 any specific target object.

Exception Summary
BeanInstantiationException: Exception thrown when instantiation of a bean failed.
BeansException: Abstract superclass for all exceptions thrown in the beans package and subpackages.
FatalBeanException: Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g. bad class or field.
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 isn't writable, because there's 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).

The Spring Framework

Copyright © 2002-2008 The Spring Framework.