All Classes and Interfaces

Class	Description
AbstractAutowireCapableBeanFactory	Abstract bean factory superclass that implements default bean creation, with the full capabilities specified by the RootBeanDefinition class.
AbstractBeanDefinition	Base class for concrete, full-fledged BeanDefinition classes, factoring out common properties of GenericBeanDefinition, RootBeanDefinition, and ChildBeanDefinition.
AbstractBeanDefinitionParser	Abstract BeanDefinitionParser implementation providing a number of convenience methods and a template method that subclasses must override to provide the actual parsing logic.
AbstractBeanDefinitionReader	Abstract base class for bean definition readers which implement the BeanDefinitionReader interface.
AbstractBeanFactory	Abstract base class for BeanFactory implementations, providing the full capabilities of the ConfigurableBeanFactory SPI.
AbstractComponentDefinition	Base implementation of ComponentDefinition that provides a basic implementation of AbstractComponentDefinition.getDescription() which delegates to ComponentDefinition.getName().
AbstractFactoryBean<T>	Simple template superclass for FactoryBean implementations that creates a singleton or a prototype object, depending on a flag.
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.
AbstractServiceLoaderBasedFactoryBean	Abstract base class for FactoryBeans operating on the JDK 1.6 ServiceLoader facility.
AbstractSimpleBeanDefinitionParser	Convenient base class for when there exists a one-to-one mapping between attribute names on the element that is to be parsed and the property names on the Class being configured.
AbstractSingleBeanDefinitionParser	Base class for those BeanDefinitionParser implementations that need to parse and define just a single BeanDefinition.
AliasDefinition	Representation of an alias that has been registered during the parsing process.
AnnotatedBeanDefinition	Extended BeanDefinition interface that exposes AnnotationMetadata about its bean class - without requiring the class to be loaded yet.
AnnotatedGenericBeanDefinition	Extension of the GenericBeanDefinition class, adding support for annotation metadata exposed through the AnnotatedBeanDefinition interface.
AnnotationBeanWiringInfoResolver	BeanWiringInfoResolver that uses the Configurable annotation to identify which classes need autowiring.
AotServices<T>	A collection of AOT services that can be loaded from a SpringFactoriesLoader or obtained from a ListableBeanFactory.
AotServices.Loader	Loader class used to actually load the services.
AotServices.Source	Sources from which services were obtained.
ArgumentConvertingMethodInvoker	Subclass of MethodInvoker that tries to convert the given arguments for the actual target method via a TypeConverter.
Autowire	Enumeration determining autowiring status: that is, whether a bean should have its dependencies automatically injected by the Spring container using setter injection.
AutowireCandidateQualifier	Qualifier for resolving autowire candidates.
AutowireCandidateResolver	Strategy interface for determining whether a specific bean definition qualifies as an autowire candidate for a specific dependency.
AutowireCapableBeanFactory	Extension of the BeanFactory interface to be implemented by bean factories that are capable of autowiring, provided that they want to expose this functionality for existing bean instances.
Autowired	Marks a constructor, field, setter method, or config method as to be autowired by Spring's dependency injection facilities.
AutowiredAnnotationBeanPostProcessor	BeanPostProcessor implementation that autowires annotated fields, setter methods, and arbitrary config methods.
AutowiredArguments	Resolved arguments to be autowired.
AutowiredArgumentsCodeGenerator	Code generator to apply AutowiredArguments.
AutowiredFieldValueResolver	Resolver used to support the autowiring of fields.
AutowiredMethodArgumentsResolver	Resolver used to support the autowiring of methods.
AutowiredPropertyMarker	Simple marker class for an individually autowired property value, to be added to BeanDefinition.getPropertyValues() for a specific bean property.
Aware	A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware	Callback that allows a bean to be aware of the bean class loader; that is, the class loader used by the present bean factory to load bean classes.
BeanComponentDefinition	ComponentDefinition based on a standard BeanDefinition, exposing the given bean definition as well as inner bean definitions and bean references for the given bean.
BeanConfigurerSupport	Convenient base class for bean configurers that can perform Dependency Injection on objects (however they may be created).
BeanCreationException	Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition.
BeanCreationNotAllowedException	Exception thrown in case of a bean being requested despite bean creation currently not being allowed (for example, during the shutdown phase of a bean factory).
BeanCurrentlyInCreationException	Exception thrown in case of a reference to a bean that's currently in creation.
BeanDefinition	A BeanDefinition describes a bean instance, which has property values, constructor argument values, and further information supplied by concrete implementations.
BeanDefinitionBuilder	Programmatic means of constructing BeanDefinitions using the builder pattern.
BeanDefinitionCustomizer	Callback for customizing a given bean definition.
BeanDefinitionDecorator	Interface used by the DefaultBeanDefinitionDocumentReader to handle custom, nested (directly under a <bean>) tags.
BeanDefinitionDefaults	A simple holder for BeanDefinition property defaults.
BeanDefinitionDocumentReader	SPI for parsing an XML document that contains Spring bean definitions.
BeanDefinitionHolder	Holder for a BeanDefinition with name and aliases.
BeanDefinitionOverrideException	Subclass of BeanDefinitionStoreException indicating an invalid override attempt: typically registering a new definition for the same bean name while DefaultListableBeanFactory.isAllowBeanDefinitionOverriding() is false.
BeanDefinitionParser	Interface used by the DefaultBeanDefinitionDocumentReader to handle custom, top-level (directly under <beans/>) tags.
BeanDefinitionParserDelegate	Stateful delegate class used to parse XML bean definitions.
BeanDefinitionParsingException	Exception thrown when a bean definition reader encounters an error during the parsing process.
BeanDefinitionReader	Simple interface for bean definition readers that specifies load methods with Resource and String location parameters.
BeanDefinitionReaderUtils	Utility methods that are useful for bean definition reader implementations.
BeanDefinitionRegistry	Interface for registries that hold bean definitions, for example RootBeanDefinition and ChildBeanDefinition instances.
BeanDefinitionRegistryPostProcessor	Extension to the standard BeanFactoryPostProcessor SPI, allowing for the registration of further bean definitions before regular BeanFactoryPostProcessor detection kicks in.
BeanDefinitionStoreException	Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.
BeanDefinitionValidationException	Exception thrown when the validation of a bean definition failed.
BeanDefinitionValueResolver	Helper class for use in bean factory implementations, resolving values contained in bean definition objects into the actual values applied to the target bean instance.
BeanDefinitionVisitor	Visitor class for traversing BeanDefinition objects, in particular the property values and constructor argument values contained in them, resolving bean metadata values.
BeanEntry	ParseState entry representing a bean definition.
BeanExpressionContext	Context object for evaluating an expression within a bean definition.
BeanExpressionException	Exception that indicates an expression evaluation attempt having failed.
BeanExpressionResolver	Strategy interface for resolving a value by evaluating it as an expression, if applicable.
BeanFactory	The root interface for accessing a Spring bean container.
BeanFactoryAnnotationUtils	Convenience methods performing bean lookups related to Spring-specific annotations, for example Spring's @Qualifier annotation.
BeanFactoryAware	Interface to be implemented by beans that wish to be aware of their owning BeanFactory.
BeanFactoryInitializationAotContribution	AOT contribution from a BeanFactoryInitializationAotProcessor used to initialize a bean factory.
BeanFactoryInitializationAotProcessor	AOT processor that makes bean factory initialization contributions by processing ConfigurableListableBeanFactory instances.
BeanFactoryInitializationCode	Interface that can be used to configure the code that will be generated to perform bean factory initialization.
BeanFactoryPostProcessor	Factory hook that allows for custom modification of an application context's bean definitions, adapting the bean property values of the context's underlying bean factory.
BeanFactoryUtils	Convenience methods operating on bean factories, in particular on the ListableBeanFactory interface.
BeanInfoFactory	Strategy interface for creating BeanInfo instances for Spring beans.
BeanInitializationException	Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails.
BeanInstanceSupplier<T>	Specialized InstanceSupplier that provides the factory Method used to instantiate the underlying bean instance, if any.
BeanInstantiationException	Exception thrown when instantiation of a bean failed.
BeanIsAbstractException	Exception thrown when a bean instance has been requested for a bean definition which has been marked as abstract.
BeanIsNotAFactoryException	Exception thrown when a bean is not a factory, but a user tries to get at the factory for the given bean name.
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.
BeanMetadataElement	Interface to be implemented by bean metadata elements that carry a configuration source object.
BeanNameAware	Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
BeanNameGenerator	Strategy interface for generating bean names for bean definitions.
BeanNotOfRequiredTypeException	Thrown when a bean doesn't match the expected type.
BeanPostProcessor	Factory hook that allows for custom modification of new bean instances — for example, checking for marker interfaces or wrapping beans with proxies.
BeanReference	Interface that exposes a reference to a bean name in an abstract fashion.
BeanRegistrationAotContribution	AOT contribution from a BeanRegistrationAotProcessor used to register a single bean definition.
BeanRegistrationAotProcessor	AOT processor that makes bean registration contributions by processing RegisteredBean instances.
BeanRegistrationCode	Interface that can be used to configure the code that will be generated to perform registration of a single bean.
BeanRegistrationCodeFragments	Generate the various fragments of code needed to register a bean.
BeanRegistrationCodeFragmentsDecorator	A BeanRegistrationCodeFragments decorator implementation.
BeanRegistrationExcludeFilter	Filter that can be used to exclude AOT processing of a RegisteredBean.
BeanRegistrationsCode	Interface that can be used to configure the code that will be generated to register beans.
BeansDtdResolver	EntityResolver implementation for the Spring beans DTD, to load the DTD from the Spring class path (or JAR file).
BeansException	Abstract superclass for all exceptions thrown in the beans package and subpackages.
BeanUtils	Static convenience methods for JavaBeans: for instantiating beans, checking bean property types, copying bean properties, etc.
BeanWiringInfo	Holder for bean wiring metadata information about a particular class.
BeanWiringInfoResolver	Strategy interface to be implemented by objects than can resolve bean name information, given a newly instantiated bean object.
BeanWrapper	The central interface of Spring's low-level JavaBeans infrastructure.
BeanWrapperImpl	Default BeanWrapper implementation that should be sufficient for all typical use cases.
ByteArrayPropertyEditor	Editor for byte arrays.
CachedIntrospectionResults	Internal class that caches JavaBeans PropertyDescriptor information for a Java class.
CannotLoadBeanClassException	Exception thrown when the BeanFactory cannot load the specified class of a given bean.
CglibSubclassingInstantiationStrategy	Default object instantiation strategy for use in BeanFactories.
CharacterEditor	Editor for a Character, to populate a property of type Character or char from a String value.
CharArrayPropertyEditor	Editor for char arrays.
CharsetEditor	Editor for java.nio.charset.Charset, translating charset String representations into Charset objects and back.
ChildBeanDefinition	Bean definition for beans which inherit settings from their parent.
ClassArrayEditor	Property editor for an array of Classes, to enable the direct population of a Class[] property without having to use a String class name property as bridge.
ClassEditor	Property editor for java.lang.Class, to enable the direct population of a Class property without recourse to having to use a String class name property as bridge.
ClassNameBeanWiringInfoResolver	Simple default implementation of the BeanWiringInfoResolver interface, looking for a bean with the same name as the fully-qualified class name.
ComponentDefinition	Interface that describes the logical view of a set of BeanDefinitions and BeanReferences as presented in some configuration context.
CompositeComponentDefinition	ComponentDefinition implementation that holds one or more nested ComponentDefinition instances, aggregating them into a named group of components.
Configurable	Marks a class as being eligible for Spring-driven configuration.
ConfigurableBeanFactory	Configuration interface to be implemented by most bean factories.
ConfigurableListableBeanFactory	Configuration interface to be implemented by most listable bean factories.
ConfigurablePropertyAccessor	Interface that encapsulates configuration methods for a PropertyAccessor.
ConstructorArgumentEntry	ParseState entry representing a (possibly indexed) constructor argument.
ConstructorArgumentValues	Holder for constructor argument values, typically as part of a bean definition.
ConstructorArgumentValues.ValueHolder	Holder for a constructor argument value, with an optional type attribute indicating the target type of the actual constructor argument.
ConversionNotSupportedException	Exception thrown when no suitable editor or converter can be found for a bean property.
CurrencyEditor	Editor for java.util.Currency, translating currency codes into Currency objects.
CustomAutowireConfigurer	A BeanFactoryPostProcessor implementation that allows for convenient registration of custom autowire qualifier types.
CustomBooleanEditor	Property editor for Boolean/boolean properties.
CustomCollectionEditor	Property editor for Collections, converting any source Collection to a given target Collection type.
CustomDateEditor	Property editor for java.util.Date, supporting a custom java.text.DateFormat.
CustomEditorConfigurer	BeanFactoryPostProcessor implementation that allows for convenient registration of custom property editors.
CustomMapEditor	Property editor for Maps, converting any source Map to a given target Map type.
CustomNumberEditor	Property editor for any Number subclass such as Short, Integer, Long, BigInteger, Float, Double, BigDecimal.
CustomScopeConfigurer	Simple BeanFactoryPostProcessor implementation that registers custom Scope(s) with the containing ConfigurableBeanFactory.
DefaultBeanDefinitionDocumentReader	Default implementation of the BeanDefinitionDocumentReader interface that reads bean definitions according to the "spring-beans" DTD and XSD format (Spring's default XML bean definition format).
DefaultBeanNameGenerator	Default implementation of the BeanNameGenerator interface, delegating to BeanDefinitionReaderUtils.generateBeanName(BeanDefinition, BeanDefinitionRegistry).
DefaultDocumentLoader	Spring's default DocumentLoader implementation.
DefaultListableBeanFactory	Spring's default implementation of the ConfigurableListableBeanFactory and BeanDefinitionRegistry interfaces: a full-fledged bean factory based on bean definition metadata, extensible through post-processors.
DefaultNamespaceHandlerResolver	Default implementation of the NamespaceHandlerResolver interface.
DefaultsDefinition	Marker interface for a defaults definition, extending BeanMetadataElement to inherit source exposure.
DefaultSingletonBeanRegistry	Generic registry for shared bean instances, implementing the SingletonBeanRegistry.
DelegatingEntityResolver	EntityResolver implementation that delegates to a BeansDtdResolver and a PluggableSchemaResolver for DTDs and XML schemas, respectively.
DependencyDescriptor	Descriptor for a specific dependency that is about to be injected.
DeprecatedBeanWarner	Bean factory post processor that logs a warning for @Deprecated beans.
DestructionAwareBeanPostProcessor	Subinterface of BeanPostProcessor that adds a before-destruction callback.
DirectFieldAccessor	ConfigurablePropertyAccessor implementation that directly accesses instance fields.
DisposableBean	Interface to be implemented by beans that want to release resources on destruction.
DocumentDefaultsDefinition	Simple JavaBean that holds the defaults specified at the <beans> level in a standard Spring XML bean definition document: default-lazy-init, default-autowire, etc.
DocumentLoader	Strategy interface for loading an XML Document.
EmbeddedValueResolver	StringValueResolver adapter for resolving placeholders and expressions against a ConfigurableBeanFactory.
EmptyReaderEventListener	Empty implementation of the ReaderEventListener interface, providing no-op implementations of all callback methods.
ExtendedBeanInfoFactory	Extension of StandardBeanInfoFactory that supports "non-standard" JavaBeans setter methods through introspection by Spring's (package-visible) ExtendedBeanInfo implementation.
FactoryBean<T>	Interface to be implemented by objects used within a BeanFactory which are themselves factories for individual objects.
FactoryBeanNotInitializedException	Exception to be thrown from a FactoryBean's getObject() method if the bean is not fully initialized yet, for example because it is involved in a circular reference.
FactoryBeanRegistrySupport	Support base class for singleton registries which need to handle FactoryBean instances, integrated with DefaultSingletonBeanRegistry's singleton management.
FailFastProblemReporter	Simple ProblemReporter implementation that exhibits fail-fast behavior when errors are encountered.
FatalBeanException	Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g.
FieldRetrievingFactoryBean	FactoryBean which retrieves a static or non-static field value.
FileEditor	Editor for java.io.File, to directly populate a File property from a Spring resource location.
GenericBeanDefinition	GenericBeanDefinition is a one-stop shop for declarative bean definition purposes.
GenericTypeAwareAutowireCandidateResolver	Basic AutowireCandidateResolver that performs a full generic type match with the candidate's type if the dependency is declared as a generic type (e.g.
GroovyBeanDefinitionReader	A Groovy-based reader for Spring bean definitions: like a Groovy builder, but more of a DSL for Spring configuration.
HierarchicalBeanFactory	Sub-interface implemented by bean factories that can be part of a hierarchy.
ImportDefinition	Representation of an import that has been processed during the parsing process.
InitDestroyAnnotationBeanPostProcessor	BeanPostProcessor implementation that invokes annotated init and destroy methods.
InitializingBean	Interface to be implemented by beans that need to react once all their properties have been set by a BeanFactory: e.g.
InjectionMetadata	Internal class for managing injection metadata.
InjectionMetadata.InjectedElement	A single injected element.
InjectionPoint	A simple descriptor for an injection point, pointing to a method/constructor parameter or a field.
InputSourceEditor	Editor for org.xml.sax.InputSource, converting from a Spring resource location String to a SAX InputSource object.
InputStreamEditor	One-way PropertyEditor which can convert from a text String to a java.io.InputStream, interpreting the given String as a Spring resource location (e.g.
InstanceSupplier<T>	Specialized Supplier that can be set on a BeanDefinition when details about the registered bean are needed to supply the instance.
InstanceSupplierCodeGenerator	Default code generator to create an InstanceSupplier, usually in the form of a BeanInstanceSupplier that retains the executable that is used to instantiate the bean.
InstantiationAwareBeanPostProcessor	Subinterface of BeanPostProcessor that adds a before-instantiation callback, and a callback after instantiation but before explicit properties are set or autowiring occurs.
InstantiationStrategy	Interface responsible for creating instances corresponding to a root bean definition.
InvalidPropertyException	Exception thrown when referring to an invalid bean property.
ListableBeanFactory	Extension of the BeanFactory interface to be implemented by bean factories that can enumerate all their bean instances, rather than attempting bean lookup by name one by one as requested by clients.
ListFactoryBean	Simple factory for shared List instances.
LocaleEditor	Editor for java.util.Locale, to directly populate a Locale property.
Location	Class that models an arbitrary location in a resource.
Lookup	An annotation that indicates 'lookup' methods, to be overridden by the container to redirect them back to the BeanFactory for a getBean call.
LookupOverride	Represents an override of a method that looks up an object in the same IoC context, either by bean name or by bean type (based on the declared method return type).
ManagedArray	Tag collection class used to hold managed array elements, which may include runtime bean references (to be resolved into bean objects).
ManagedList<E>	Tag collection class used to hold managed List elements, which may include runtime bean references (to be resolved into bean objects).
ManagedMap<K,V>	Tag collection class used to hold managed Map values, which may include runtime bean references (to be resolved into bean objects).
ManagedProperties	Tag class which represents a Spring-managed Properties instance that supports merging of parent/child definitions.
ManagedSet<E>	Tag collection class used to hold managed Set values, which may include runtime bean references (to be resolved into bean objects).
MapFactoryBean	Simple factory for shared Map instances.
Mergeable	Interface representing an object whose value set can be merged with that of a parent object.
MergedBeanDefinitionPostProcessor	Post-processor callback interface for merged bean definitions at runtime.
MethodInvocationException	Thrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException.
MethodInvokingBean	Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast to MethodInvokingFactoryBean).
MethodInvokingFactoryBean	FactoryBean which returns a value which is the result of a static or instance method invocation.
MethodOverride	Object representing the override of a method on a managed object by the IoC container.
MethodOverrides	Set of method overrides, determining which, if any, methods on a managed object the Spring IoC container will override at runtime.
MethodReplacer	Interface to be implemented by classes that can reimplement any method on an IoC-managed object: the Method Injection form of Dependency Injection.
MutablePropertyValues	The default implementation of the PropertyValues interface.
MutableSortDefinition	Mutable implementation of the SortDefinition interface.
NamedBean	Counterpart of BeanNameAware.
NamedBeanHolder<T>	A simple holder for a given bean name plus bean instance.
NamespaceHandler	Base interface used by the DefaultBeanDefinitionDocumentReader for handling custom namespaces in a Spring XML configuration file.
NamespaceHandlerResolver	Used by the DefaultBeanDefinitionDocumentReader to locate a NamespaceHandler implementation for a particular namespace URI.
NamespaceHandlerSupport	Support class for implementing custom NamespaceHandlers.
NoSuchBeanDefinitionException	Exception thrown when a BeanFactory is asked for a bean instance for which it cannot find a definition.
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).
NoUniqueBeanDefinitionException	Exception thrown when a BeanFactory is asked for a bean instance for which multiple matching candidates have been found when only one matching bean was expected.
NullSourceExtractor	Simple implementation of SourceExtractor that returns null as the source metadata.
NullValueInNestedPathException	Exception thrown when navigation of a valid nested property path encounters a NullPointerException.
ObjectFactory<T>	Defines a factory which can return an Object instance (possibly shared or independent) when invoked.
ObjectFactoryCreatingFactoryBean	A FactoryBean implementation that returns a value which is an ObjectFactory that in turn returns a bean sourced from a BeanFactory.
ObjectProvider<T>	A variant of ObjectFactory designed specifically for injection points, allowing for programmatic optionality and lenient not-unique handling.
PagedListHolder<E>	PagedListHolder is a simple state holder for handling lists of objects, separating them into pages.
ParameterResolutionDelegate	Public delegate for resolving autowirable parameters on externally managed constructors and methods.
ParserContext	Context that gets passed along a bean definition parsing process, encapsulating all relevant configuration as well as state.
ParseState	Simple ArrayDeque-based structure for tracking the logical position during a parsing process.
ParseState.Entry	Marker interface for entries into the ParseState.
PassThroughSourceExtractor	Simple SourceExtractor implementation that just passes the candidate source metadata object through for attachment.
PathEditor	Editor for java.nio.file.Path, to directly populate a Path property instead of using a String property as bridge.
PatternEditor	Editor for java.util.regex.Pattern, to directly populate a Pattern property.
PlaceholderConfigurerSupport	Abstract base class for property resource configurers that resolve placeholders in bean definition property values.
PluggableSchemaResolver	EntityResolver implementation that attempts to resolve schema URLs into local classpath resources using a set of mappings files.
PreferencesPlaceholderConfigurer	Deprecated. as of 5.2, along with PropertyPlaceholderConfigurer
Problem	Represents a problem with a bean definition configuration.
ProblemReporter	SPI interface allowing tools and other external processes to handle errors and warnings reported during bean definition parsing.
PropertiesBeanDefinitionReader	Deprecated. as of 5.3, in favor of Spring's common bean definition formats and/or custom reader implementations
PropertiesEditor	Custom PropertyEditor for Properties objects.
PropertiesFactoryBean	Allows for making a properties file from a classpath location available as Properties instance in a bean factory.
PropertyAccessException	Superclass for exceptions related to a property access, such as type mismatch or invocation target exception.
PropertyAccessor	Common interface for classes that can access named properties (such as bean properties of an object or fields in an object).
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.
PropertyBatchUpdateException	Combined exception, composed of individual PropertyAccessException instances.
PropertyComparator<T>	PropertyComparator performs a comparison of two beans, evaluating the specified bean property via a BeanWrapper.
PropertyEditorRegistrar	Interface for strategies that register custom property editors with a property editor registry.
PropertyEditorRegistry	Encapsulates methods for registering JavaBeans PropertyEditors.
PropertyEditorRegistrySupport	Base implementation of the PropertyEditorRegistry interface.
PropertyEntry	ParseState entry representing a JavaBean property.
PropertyMatches	Helper class for calculating property matches, according to a configurable distance.
PropertyOverrideConfigurer	Property resource configurer that overrides bean property values in an application context definition.
PropertyPathFactoryBean	FactoryBean that evaluates a property path on a given target object.
PropertyPlaceholderConfigurer	Deprecated. as of 5.2; use org.springframework.context.support.PropertySourcesPlaceholderConfigurer instead which is more flexible through taking advantage of the Environment and PropertySource mechanisms.
PropertyResourceConfigurer	Allows for configuration of individual bean property values from a property resource, i.e.
PropertyValue	Object to hold information and value for an individual bean property.
PropertyValues	Holder containing one or more PropertyValue objects, typically comprising one update for a specific target bean.
PropertyValuesEditor	Editor for a PropertyValues object.
ProviderCreatingFactoryBean	A FactoryBean implementation that returns a value which is a JSR-330 Provider that in turn returns a bean sourced from a BeanFactory.
Qualifier	This annotation may be used on a field or parameter as a qualifier for candidate beans when autowiring.
QualifierAnnotationAutowireCandidateResolver	AutowireCandidateResolver implementation that matches bean definition qualifiers against qualifier annotations on the field or parameter to be autowired.
QualifierEntry	ParseState entry representing an autowire candidate qualifier.
ReaderContext	Context that gets passed along a bean definition reading process, encapsulating all relevant configuration as well as state.
ReaderEditor	One-way PropertyEditor which can convert from a text String to a java.io.Reader, interpreting the given String as a Spring resource location (e.g.
ReaderEventListener	Interface that receives callbacks for component, alias and import registrations during a bean definition reading process.
RegisteredBean	A RegisteredBean represents a bean that has been registered with a BeanFactory, but has not necessarily been instantiated.
ReplaceOverride	Extension of MethodOverride that represents an arbitrary override of a method by the IoC container.
ResourceBundleEditor	PropertyEditor implementation for standard JDK ResourceBundles.
ResourceEditorRegistrar	PropertyEditorRegistrar implementation that populates a given PropertyEditorRegistry (typically a BeanWrapper used for bean creation within an org.springframework.context.ApplicationContext) with resource editors.
ResourceEntityResolver	EntityResolver implementation that tries to resolve entity references through a ResourceLoader (usually, relative to the resource base of an ApplicationContext), if applicable.
RootBeanDefinition	A root bean definition represents the merged bean definition at runtime that backs a specific bean in a Spring BeanFactory.
RuntimeBeanNameReference	Immutable placeholder class used for a property value object when it's a reference to another bean name in the factory, to be resolved at runtime.
RuntimeBeanReference	Immutable placeholder class used for a property value object when it's a reference to another bean in the factory, to be resolved at runtime.
Scope	Strategy interface used by a ConfigurableBeanFactory, representing a target scope to hold bean instances in.
ScopeNotActiveException	A subclass of BeanCreationException which indicates that the target scope is not active, e.g.
ServiceFactoryBean	FactoryBean that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6 ServiceLoader facility.
ServiceListFactoryBean	FactoryBean that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6 ServiceLoader facility.
ServiceLoaderFactoryBean	FactoryBean that exposes the JDK 1.6 ServiceLoader for the configured service class.
ServiceLocatorFactoryBean	A FactoryBean implementation that takes an interface which must have one or more methods with the signatures MyType xxx() or MyType xxx(MyIdType id) (typically, MyService getService() or MyService getService(String id)) and creates a dynamic proxy which implements that interface, delegating to an underlying BeanFactory.
SetFactoryBean	Simple factory for shared Set instances.
SimpleAutowireCandidateResolver	AutowireCandidateResolver implementation to use when no annotation support is available.
SimpleBeanDefinitionRegistry	Simple implementation of the BeanDefinitionRegistry interface.
SimpleConstructorNamespaceHandler	Simple NamespaceHandler implementation that maps custom attributes directly through to bean properties.
SimpleInstantiationStrategy	Simple object instantiation strategy for use in a BeanFactory.
SimplePropertyNamespaceHandler	Simple NamespaceHandler implementation that maps custom attributes directly through to bean properties.
SimpleTypeConverter	Simple implementation of the TypeConverter interface that does not operate on a specific target object.
SingletonBeanRegistry	Interface that defines a registry for shared bean instances.
SmartFactoryBean<T>	Extension of the FactoryBean interface.
SmartInitializingSingleton	Callback interface triggered at the end of the singleton pre-instantiation phase during BeanFactory bootstrap.
SmartInstantiationAwareBeanPostProcessor	Extension of the InstantiationAwareBeanPostProcessor interface, adding a callback for predicting the eventual type of a processed bean.
SortDefinition	Definition for sorting bean instances by a property.
SourceExtractor	Simple strategy allowing tools to control how source metadata is attached to the bean definition metadata.
StandardBeanInfoFactory	BeanInfoFactory implementation that performs standard Introspector inspection.
StaticListableBeanFactory	Static BeanFactory implementation which allows one to register existing singleton instances programmatically.
StringArrayPropertyEditor	Custom PropertyEditor for String arrays.
StringTrimmerEditor	Property editor that trims Strings.
TimeZoneEditor	Editor for java.util.TimeZone, translating timezone IDs into TimeZone objects.
TypeConverter	Interface that defines type conversion methods.
TypeConverterSupport	Base implementation of the TypeConverter interface, using a package-private delegate.
TypedStringValue	Holder for a typed String value.
TypeMismatchException	Exception thrown on a type mismatch when trying to set a bean property.
UnsatisfiedDependencyException	Exception thrown when a bean depends on other beans or simple properties that were not specified in the bean factory definition, although dependency checking was enabled.
URIEditor	Editor for java.net.URI, to directly populate a URI property instead of using a String property as bridge.
URLEditor	Editor for java.net.URL, to directly populate a URL property instead of using a String property as bridge.
UtilNamespaceHandler	NamespaceHandler for the util namespace.
UUIDEditor	Editor for java.util.UUID, translating UUID String representations into UUID objects and back.
Value	Annotation used at the field or method/constructor parameter level that indicates a default value expression for the annotated element.
XmlBeanDefinitionReader	Bean definition reader for XML bean definitions.
XmlBeanDefinitionStoreException	XML-specific BeanDefinitionStoreException subclass that wraps a SAXException, typically a SAXParseException which contains information about the error location.
XmlReaderContext	Extension of ReaderContext, specific to use with an XmlBeanDefinitionReader.
YamlMapFactoryBean	Factory for a Map that reads from a YAML source, preserving the YAML-declared value types and their structure.
YamlProcessor	Base class for YAML factories.
YamlProcessor.DocumentMatcher	Strategy interface used to test if properties match.
YamlProcessor.MatchCallback	Callback interface used to process the YAML parsing results.
YamlProcessor.MatchStatus	Status returned from YamlProcessor.DocumentMatcher.matches(java.util.Properties).
YamlProcessor.ResolutionMethod	Method to use for resolving resources.
YamlPropertiesFactoryBean	Factory for Properties that reads from a YAML source, exposing a flat structure of String property values.
ZoneIdEditor	Editor for java.time.ZoneId, translating zone ID Strings into ZoneId objects.