# 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.
AotBeanProcessingException
Thrown when AOT fails to process a bean.
AotException
Abstract superclass for all exceptions thrown by ahead-of-time processing.
AotProcessingException
Throw when an AOT processor failed.
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: for example, in case of incomplete or contradictory bean metadata.
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.
BeanFactoryInitializer<F extends ListableBeanFactory>
Callback interface for initializing a Spring `ListableBeanFactory` prior to entering the singleton pre-instantiation phase.
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.
CodeWarnings
Helper class to register warnings that the compiler may trigger on generated code.
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, for example, bad class or field.
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 (for example, `Repository<Customer>`).
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`: for example, to perform custom initialization, or merely to check that all mandatory properties have been set.
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 (for example, a URL String).
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.
in favor of Spring's common bean definition formats and/or custom BeanDefinitionReader 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 (for example, a URL String).
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.
RegisteredBean.InstantiationDescriptor
Descriptor for how a bean should be 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, for example, in case of request or session scope.
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 time zone Strings into `ZoneId` objects.