Top Description Interfaces Classes
[default module]

Package org.springframework.beans

Annotations
@NonNullApi
@NonNullFields
Imports
org.springframework.lang.NonNullApi, .NonNullFields

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).

Interface Summary

Modifier and TypeInterface and Description
public interface
BeanInfoFactory

Strategy interface for creating BeanInfo instances for Spring beans.

public interface
BeanMetadataElement

Interface to be implemented by bean metadata elements that carry a configuration source object.

public interface
BeanWrapper

The central interface of Spring's low-level JavaBeans infrastructure.

public interface
ConfigurablePropertyAccessor

Interface that encapsulates configuration methods for a PropertyAccessor.

public interface
Mergeable

Interface representing an object whose value set can be merged with that of a parent object.

public interface
PropertyAccessor

Common interface for classes that can access named properties (such as bean properties of an object or fields in an object).

public interface
PropertyEditorRegistrar

Interface for strategies that register custom property editors with a property editor registry.

public interface
PropertyEditorRegistry

Encapsulates methods for registering JavaBeans PropertyEditors.

public interface
PropertyValues

Holder containing one or more PropertyValue objects, typically comprising one update for a specific target bean.

public interface
TypeConverter

Interface that defines type conversion methods.

Class Summary

Modifier and TypeClass and Description
public abstract class
AbstractNestablePropertyAccessor

A basic ConfigurablePropertyAccessor that provides the necessary infrastructure for all typical use cases.

public abstract class
AbstractPropertyAccessor

Abstract implementation of the PropertyAccessor interface.

public class
BeanInstantiationException

Exception thrown when instantiation of a bean failed.

public class
BeanMetadataAttribute

Holder for a key-value style attribute that is part of a bean definition.

public class
BeanMetadataAttributeAccessor

Extension of org.springframework.core.AttributeAccessorSupport, holding attributes as BeanMetadataAttribute objects in order to keep track of the definition source.

public abstract class
BeansException

Abstract superclass for all exceptions thrown in the beans package and subpackages.

public abstract class
BeanUtils

Static convenience methods for JavaBeans: for instantiating beans, checking bean property types, copying bean properties, etc.

Mainly for internal use within the framework, but to some degree also useful for application classes.

pack-priv class
public class
BeanWrapperImpl

Default BeanWrapper implementation that should be sufficient for all typical use cases.

public class
CachedIntrospectionResults

Internal class that caches JavaBeans java.beans.PropertyDescriptor information for a Java class.

public class
ConversionNotSupportedException

Exception thrown when no suitable editor or converter can be found for a bean property.

public class
DirectFieldAccessor

ConfigurablePropertyAccessor implementation that directly accesses instance fields.

pack-priv class
ExtendedBeanInfo

Decorator for a standard BeanInfo object, e.g. as created by Introspector#getBeanInfo(Class), designed to discover and register static and/or non-void returning setter methods.

public class
ExtendedBeanInfoFactory

Extension of StandardBeanInfoFactory that supports "non-standard" JavaBeans setter methods through introspection by Spring's (package-visible) ExtendedBeanInfo implementation.

public class
FatalBeanException

Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g. bad class or field.

pack-priv class
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.

public class
InvalidPropertyException

Exception thrown when referring to an invalid bean property.

public class
MethodInvocationException

Thrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException.

public class
MutablePropertyValues

The default implementation of the PropertyValues interface.

public class
NotReadablePropertyException

Exception thrown on an attempt to get the value of a property that isn't readable, because there's no getter method.

public class
NotWritablePropertyException

Exception thrown on an attempt to set the value of a property that is not writable (typically because there is no setter method).

public class
NullValueInNestedPathException

Exception thrown when navigation of a valid nested property path encounters a NullPointerException.

public abstract class
PropertyAccessException

Superclass for exceptions related to a property access, such as type mismatch or invocation target exception.

public class
PropertyAccessorFactory

Simple factory facade for obtaining PropertyAccessor instances, in particular for BeanWrapper instances.

public abstract class
PropertyAccessorUtils

Utility methods for classes that perform bean property access according to the PropertyAccessor interface.

public class
PropertyBatchUpdateException

Combined exception, composed of individual PropertyAccessException instances.

pack-priv abstract class
PropertyDescriptorUtils

Common delegate methods for Spring's internal PropertyDescriptor implementations.

public class
PropertyEditorRegistrySupport

Base implementation of the PropertyEditorRegistry interface.

public abstract class
PropertyMatches

Helper class for calculating property matches, according to a configurable distance.

public class
PropertyValue

Object to hold information and value for an individual bean property.

public class
pack-priv class
SimpleBeanInfoFactory

BeanInfoFactory implementation that bypasses the standard java.beans.Introspector for faster introspection, reduced to basic property determination (as commonly needed in Spring).

public class
SimpleTypeConverter

Simple implementation of the TypeConverter interface that does not operate on a specific target object.

public class
StandardBeanInfoFactory

BeanInfoFactory implementation that performs standard java.beans.Introspector inspection.

pack-priv class
TypeConverterDelegate

Internal helper class for converting property values to target types.

public abstract class
TypeConverterSupport

Base implementation of the TypeConverter interface, using a package-private delegate.

public class
TypeMismatchException

Exception thrown on a type mismatch when trying to set a bean property.