@NonNullApi @NonNullFields

Package org.springframework.beans

This package contains interfaces and classes for manipulating Java beans.

See: Description

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).
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.PropertyHandler	A handler for a specific property.
AbstractNestablePropertyAccessor.PropertyTokenHolder	Holder class used to store property tokens.
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.
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.
MutablePropertyValues	The 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.
PropertyMatches	Helper class for calculating property matches, according to a configurable distance.
PropertyValue	Object to hold information and value for an individual bean property.
PropertyValuesEditor	Editor for a PropertyValues object.
SimpleBeanInfoFactory	BeanInfoFactory implementation that bypasses the standard Introspector for faster introspection, reduced to basic property determination (as commonly needed in Spring).
SimpleTypeConverter	Simple implementation of the TypeConverter interface that does not operate on a specific target object.
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).