All Classes and Interfaces
Class
Description
Abstract bean factory superclass that implements default bean creation,
with the full capabilities specified by the
RootBeanDefinition class.Base class for concrete, full-fledged
BeanDefinition classes,
factoring out common properties of GenericBeanDefinition,
RootBeanDefinition, and ChildBeanDefinition.Abstract
BeanDefinitionParser implementation providing
a number of convenience methods and a
template method
that subclasses must override to provide the actual parsing logic.Abstract base class for bean definition readers which implement
the
BeanDefinitionReader interface.Abstract base class for
BeanFactory
implementations, providing the full capabilities of the
ConfigurableBeanFactory SPI.Base implementation of
ComponentDefinition that provides a basic implementation of
AbstractComponentDefinition.getDescription() which delegates to ComponentDefinition.getName().Simple template superclass for
FactoryBean implementations that
creates a singleton or a prototype object, depending on a flag.A basic
ConfigurablePropertyAccessor that provides the necessary
infrastructure for all typical use cases.A handler for a specific property.
Holder class used to store property tokens.
Abstract implementation of the
PropertyAccessor interface.Abstract base class for FactoryBeans operating on the
JDK 1.6
ServiceLoader facility.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.Base class for those
BeanDefinitionParser implementations that
need to parse and define just a single BeanDefinition.Representation of an alias that has been registered during the parsing process.
Extended
BeanDefinition
interface that exposes AnnotationMetadata
about its bean class - without requiring the class to be loaded yet.Extension of the
GenericBeanDefinition
class, adding support for annotation metadata exposed through the
AnnotatedBeanDefinition interface.BeanWiringInfoResolver that
uses the Configurable annotation to identify which classes need autowiring.Thrown when AOT fails to process a bean.
Abstract superclass for all exceptions thrown by ahead-of-time processing.
Throw when an AOT processor failed.
A collection of AOT services that can be
loaded from
a SpringFactoriesLoader or obtained from a ListableBeanFactory.Loader class used to actually load the services.
Sources from which services were obtained.
Subclass of
MethodInvoker that tries to convert the given
arguments for the actual target method via a TypeConverter.Enumeration determining autowiring status: that is, whether a bean should
have its dependencies automatically injected by the Spring container using
setter injection.
Qualifier for resolving autowire candidates.
Strategy interface for determining whether a specific bean definition
qualifies as an autowire candidate for a specific dependency.
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.Marks a constructor, field, setter method, or config method as to be autowired by
Spring's dependency injection facilities.
BeanPostProcessor
implementation that autowires annotated fields, setter methods, and arbitrary
config methods.Resolved arguments to be autowired.
Code generator to apply
AutowiredArguments.Resolver used to support the autowiring of fields.
Resolver used to support the autowiring of methods.
Simple marker class for an individually autowired property value, to be added
to
BeanDefinition.getPropertyValues() for a specific bean property.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.
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.ComponentDefinition based on a standard BeanDefinition, exposing the given bean
definition as well as inner bean definitions and bean references for the given bean.
Convenient base class for bean configurers that can perform Dependency Injection
on objects (however they may be created).
Exception thrown when a BeanFactory encounters an error when
attempting to create a bean from a bean definition.
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).
Exception thrown in case of a reference to a bean that's currently in creation.
A BeanDefinition describes a bean instance, which has property values,
constructor argument values, and further information supplied by
concrete implementations.
Programmatic means of constructing
BeanDefinitions
using the builder pattern.Callback for customizing a given bean definition.
Interface used by the
DefaultBeanDefinitionDocumentReader
to handle custom, nested (directly under a <bean>) tags.A simple holder for
BeanDefinition property defaults.SPI for parsing an XML document that contains Spring bean definitions.
Holder for a BeanDefinition with name and aliases.
Subclass of
BeanDefinitionStoreException indicating an invalid override
attempt: typically registering a new definition for the same bean name while
DefaultListableBeanFactory.isAllowBeanDefinitionOverriding() is false.Interface used by the
DefaultBeanDefinitionDocumentReader to handle custom,
top-level (directly under <beans/>) tags.Stateful delegate class used to parse XML bean definitions.
Exception thrown when a bean definition reader encounters an error
during the parsing process.
Simple interface for bean definition readers that specifies load methods with
Resource and String location parameters.Utility methods that are useful for bean definition reader implementations.
Interface for registries that hold bean definitions, for example RootBeanDefinition
and ChildBeanDefinition instances.
Extension to the standard
BeanFactoryPostProcessor SPI, allowing for
the registration of further bean definitions before regular
BeanFactoryPostProcessor detection kicks in.Exception thrown when a BeanFactory encounters an invalid bean definition:
for example, in case of incomplete or contradictory bean metadata.
Exception thrown when the validation of a bean definition failed.
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.
Visitor class for traversing
BeanDefinition objects, in particular
the property values and constructor argument values contained in them,
resolving bean metadata values.ParseState entry representing a bean definition.Context object for evaluating an expression within a bean definition.
Exception that indicates an expression evaluation attempt having failed.
Strategy interface for resolving a value by evaluating it as an expression,
if applicable.
The root interface for accessing a Spring bean container.
Convenience methods performing bean lookups related to Spring-specific annotations,
for example Spring's
@Qualifier annotation.Interface to be implemented by beans that wish to be aware of their
owning
BeanFactory.AOT contribution from a
BeanFactoryInitializationAotProcessor used to
initialize a bean factory.AOT processor that makes bean factory initialization contributions by
processing
ConfigurableListableBeanFactory instances.Interface that can be used to configure the code that will be generated to
perform bean factory initialization.
Callback interface for initializing a Spring
ListableBeanFactory
prior to entering the singleton pre-instantiation phase.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.
Convenience methods operating on bean factories, in particular
on the
ListableBeanFactory interface.Strategy interface for creating
BeanInfo instances for Spring beans.Exception that a bean implementation is suggested to throw if its own
factory-aware initialization code fails.
Specialized
InstanceSupplier that provides the factory Method
used to instantiate the underlying bean instance, if any.Exception thrown when instantiation of a bean failed.
Exception thrown when a bean instance has been requested for
a bean definition which has been marked as abstract.
Exception thrown when a bean is not a factory, but a user tries to get
at the factory for the given bean name.
Holder for a key-value style attribute that is part of a bean definition.
Extension of
AttributeAccessorSupport,
holding attributes as BeanMetadataAttribute objects in order
to keep track of the definition source.Interface to be implemented by bean metadata elements
that carry a configuration source object.
Interface to be implemented by beans that want to be aware of their
bean name in a bean factory.
Strategy interface for generating bean names for bean definitions.
Thrown when a bean doesn't match the expected type.
Factory hook that allows for custom modification of new bean instances —
for example, checking for marker interfaces or wrapping beans with proxies.
Interface that exposes a reference to a bean name in an abstract fashion.
AOT contribution from a
BeanRegistrationAotProcessor used to register
a single bean definition.AOT processor that makes bean registration contributions by processing
RegisteredBean instances.Interface that can be used to configure the code that will be generated to
perform registration of a single bean.
Generate the various fragments of code needed to register a bean.
A
BeanRegistrationCodeFragments decorator implementation.Filter that can be used to exclude AOT processing of a
RegisteredBean.Interface that can be used to configure the code that will be generated to
register beans.
EntityResolver implementation for the Spring beans DTD,
to load the DTD from the Spring class path (or JAR file).Abstract superclass for all exceptions thrown in the beans package
and subpackages.
Static convenience methods for JavaBeans: for instantiating beans,
checking bean property types, copying bean properties, etc.
Holder for bean wiring metadata information about a particular class.
Strategy interface to be implemented by objects than can resolve bean name
information, given a newly instantiated bean object.
The central interface of Spring's low-level JavaBeans infrastructure.
Default
BeanWrapper implementation that should be sufficient
for all typical use cases.Editor for byte arrays.
Internal class that caches JavaBeans
PropertyDescriptor
information for a Java class.Exception thrown when the BeanFactory cannot load the specified class
of a given bean.
Default object instantiation strategy for use in BeanFactories.
Editor for char arrays.
Editor for
java.nio.charset.Charset, translating charset
String representations into Charset objects and back.Bean definition for beans which inherit settings from their parent.
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.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.Simple default implementation of the
BeanWiringInfoResolver interface,
looking for a bean with the same name as the fully-qualified class name.Helper class to register warnings that the compiler may trigger on
generated code.
Interface that describes the logical view of a set of
BeanDefinitions
and BeanReferences as presented in some configuration context.ComponentDefinition implementation that holds one or more nested
ComponentDefinition instances, aggregating them into a named group
of components.Marks a class as being eligible for Spring-driven configuration.
Configuration interface to be implemented by most bean factories.
Configuration interface to be implemented by most listable bean factories.
Interface that encapsulates configuration methods for a PropertyAccessor.
ParseState entry representing a (possibly indexed)
constructor argument.Holder for constructor argument values, typically as part of a bean definition.
Holder for a constructor argument value, with an optional type
attribute indicating the target type of the actual constructor argument.
Exception thrown when no suitable editor or converter can be found for a bean property.
Editor for
java.util.Currency, translating currency codes into Currency
objects.A
BeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire
qualifier types.Property editor for Boolean/boolean properties.
Property editor for Collections, converting any source Collection
to a given target Collection type.
Property editor for
java.util.Date,
supporting a custom java.text.DateFormat.BeanFactoryPostProcessor implementation that allows for convenient
registration of custom property editors.Property editor for Maps, converting any source Map
to a given target Map type.
Property editor for any Number subclass such as Short, Integer, Long,
BigInteger, Float, Double, BigDecimal.
Simple
BeanFactoryPostProcessor implementation that registers
custom Scope(s) with the containing ConfigurableBeanFactory.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).Default implementation of the
BeanNameGenerator interface, delegating to
BeanDefinitionReaderUtils.generateBeanName(BeanDefinition, BeanDefinitionRegistry).Spring's default
DocumentLoader implementation.Spring's default implementation of the
ConfigurableListableBeanFactory
and BeanDefinitionRegistry interfaces: a full-fledged bean factory
based on bean definition metadata, extensible through post-processors.Default implementation of the
NamespaceHandlerResolver interface.Marker interface for a defaults definition,
extending BeanMetadataElement to inherit source exposure.
Generic registry for shared bean instances, implementing the
SingletonBeanRegistry.EntityResolver implementation that delegates to a BeansDtdResolver
and a PluggableSchemaResolver for DTDs and XML schemas, respectively.Descriptor for a specific dependency that is about to be injected.
Bean factory post processor that logs a warning for
@Deprecated beans.Subinterface of
BeanPostProcessor that adds a before-destruction callback.ConfigurablePropertyAccessor implementation that directly accesses
instance fields.Interface to be implemented by beans that want to release resources on destruction.
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.Strategy interface for loading an XML
Document.StringValueResolver adapter for resolving placeholders and
expressions against a ConfigurableBeanFactory.Empty implementation of the
ReaderEventListener interface,
providing no-op implementations of all callback methods.Extension of
StandardBeanInfoFactory that supports "non-standard"
JavaBeans setter methods through introspection by Spring's
(package-visible) ExtendedBeanInfo implementation.Interface to be implemented by objects used within a
BeanFactory which
are themselves factories for individual objects.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.Support base class for singleton registries which need to handle
FactoryBean instances,
integrated with DefaultSingletonBeanRegistry's singleton management.Simple
ProblemReporter implementation that exhibits fail-fast
behavior when errors are encountered.Thrown on an unrecoverable problem encountered in the
beans packages or sub-packages, for example, bad class or field.
FactoryBean which retrieves a static or non-static field value.Editor for
java.io.File, to directly populate a File property
from a Spring resource location.GenericBeanDefinition is a one-stop shop for declarative bean definition purposes.
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>).A Groovy-based reader for Spring bean definitions: like a Groovy builder,
but more of a DSL for Spring configuration.
Sub-interface implemented by bean factories that can be part
of a hierarchy.
Representation of an import that has been processed during the parsing process.
BeanPostProcessor implementation
that invokes annotated init and destroy methods.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.Internal class for managing injection metadata.
A single injected element.
A simple descriptor for an injection point, pointing to a method/constructor
parameter or a field.
Editor for
org.xml.sax.InputSource, converting from a
Spring resource location String to a SAX InputSource object.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).Specialized
Supplier that can be set on a
BeanDefinition
when details about the registered bean are needed to
supply the instance.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.Subinterface of
BeanPostProcessor that adds a before-instantiation callback,
and a callback after instantiation but before explicit properties are set or
autowiring occurs.Interface responsible for creating instances corresponding to a root bean definition.
Exception thrown when referring to an invalid bean property.
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.Simple factory for shared List instances.
Editor for
java.util.Locale, to directly populate a Locale property.Class that models an arbitrary location in a
resource.An annotation that indicates 'lookup' methods, to be overridden by the container
to redirect them back to the
BeanFactory
for a getBean call.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).
Tag collection class used to hold managed array elements, which may
include runtime bean references (to be resolved into bean objects).
Tag collection class used to hold managed List elements, which may
include runtime bean references (to be resolved into bean objects).
Tag collection class used to hold managed Map values, which may
include runtime bean references (to be resolved into bean objects).
Tag class which represents a Spring-managed
Properties instance
that supports merging of parent/child definitions.Tag collection class used to hold managed Set values, which may
include runtime bean references (to be resolved into bean objects).
Simple factory for shared Map instances.
Interface representing an object whose value set can be merged with
that of a parent object.
Post-processor callback interface for merged bean definitions at runtime.
Thrown when a bean property getter or setter method throws an exception,
analogous to an InvocationTargetException.
Simple method invoker bean: just invoking a target method, not expecting a result
to expose to the container (in contrast to
MethodInvokingFactoryBean).FactoryBean which returns a value which is the result of a static or instance
method invocation.Object representing the override of a method on a managed object by the IoC
container.
Set of method overrides, determining which, if any, methods on a
managed object the Spring IoC container will override at runtime.
Interface to be implemented by classes that can reimplement any method on an
IoC-managed object: the Method Injection form of Dependency Injection.
The default implementation of the
PropertyValues interface.Mutable implementation of the
SortDefinition interface.Counterpart of
BeanNameAware.A simple holder for a given bean name plus bean instance.
Base interface used by the
DefaultBeanDefinitionDocumentReader
for handling custom namespaces in a Spring XML configuration file.Used by the
DefaultBeanDefinitionDocumentReader to
locate a NamespaceHandler implementation for a particular namespace URI.Support class for implementing custom
NamespaceHandlers.Exception thrown when a
BeanFactory is asked for a bean instance for which it
cannot find a definition.Exception thrown on an attempt to get the value of a property
that isn't readable, because there's no getter method.
Exception thrown on an attempt to set the value of a property that
is not writable (typically because there is no setter method).
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.Simple implementation of
SourceExtractor that returns null
as the source metadata.Exception thrown when navigation of a valid nested property
path encounters a NullPointerException.
Defines a factory which can return an Object instance
(possibly shared or independent) when invoked.
A
FactoryBean implementation that
returns a value which is an ObjectFactory
that in turn returns a bean sourced from a BeanFactory.A variant of
ObjectFactory designed specifically for injection points,
allowing for programmatic optionality and lenient not-unique handling.PagedListHolder is a simple state holder for handling lists of objects,
separating them into pages.
Public delegate for resolving autowirable parameters on externally managed
constructors and methods.
Context that gets passed along a bean definition parsing process,
encapsulating all relevant configuration as well as state.
Simple
ArrayDeque-based structure for tracking the logical position during
a parsing process.Marker interface for entries into the
ParseState.Simple
SourceExtractor implementation that just passes
the candidate source metadata object through for attachment.Editor for
java.nio.file.Path, to directly populate a Path
property instead of using a String property as bridge.Editor for
java.util.regex.Pattern, to directly populate a Pattern property.Abstract base class for property resource configurers that resolve placeholders
in bean definition property values.
EntityResolver implementation that attempts to resolve schema URLs into
local classpath resources using a set of mappings files.Deprecated.
Represents a problem with a bean definition configuration.
SPI interface allowing tools and other external processes to handle errors
and warnings reported during bean definition parsing.
Deprecated.
as of 5.3, in favor of Spring's common bean definition formats
and/or custom reader implementations
Custom
PropertyEditor for Properties objects.Allows for making a properties file from a classpath location available
as Properties instance in a bean factory.
Superclass for exceptions related to a property access,
such as type mismatch or invocation target exception.
Common interface for classes that can access named properties
(such as bean properties of an object or fields in an object).
Simple factory facade for obtaining
PropertyAccessor instances,
in particular for BeanWrapper instances.Utility methods for classes that perform bean property access
according to the
PropertyAccessor interface.Combined exception, composed of individual PropertyAccessException instances.
PropertyComparator performs a comparison of two beans,
evaluating the specified bean property via a BeanWrapper.
Interface for strategies that register custom
property editors with a
property editor registry.Encapsulates methods for registering JavaBeans
PropertyEditors.Base implementation of the
PropertyEditorRegistry interface.ParseState entry representing a JavaBean property.Helper class for calculating property matches, according to a configurable
distance.
Property resource configurer that overrides bean property values in an application
context definition.
FactoryBean that evaluates a property path on a given target object.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.Allows for configuration of individual bean property values from a property resource,
i.e.
Object to hold information and value for an individual bean property.
Holder containing one or more
PropertyValue objects,
typically comprising one update for a specific target bean.Editor for a PropertyValues object.A
FactoryBean implementation that
returns a value which is a JSR-330 Provider that in turn
returns a bean sourced from a BeanFactory.This annotation may be used on a field or parameter as a qualifier for
candidate beans when autowiring.
AutowireCandidateResolver implementation that matches bean definition qualifiers
against qualifier annotations on the field or parameter to be autowired.ParseState entry representing an autowire candidate qualifier.Context that gets passed along a bean definition reading process,
encapsulating all relevant configuration as well as state.
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).Interface that receives callbacks for component, alias and import
registrations during a bean definition reading process.
A
RegisteredBean represents a bean that has been registered with a
BeanFactory, but has not necessarily been instantiated.Descriptor for how a bean should be instantiated.
Extension of
MethodOverride that represents an arbitrary
override of a method by the IoC container.PropertyEditor implementation for standard JDK
ResourceBundles.PropertyEditorRegistrar implementation that populates a given
PropertyEditorRegistry
(typically a BeanWrapper used for bean
creation within an org.springframework.context.ApplicationContext)
with resource editors.EntityResolver implementation that tries to resolve entity references
through a ResourceLoader (usually,
relative to the resource base of an ApplicationContext), if applicable.A root bean definition represents the merged bean definition at runtime
that backs a specific bean in a Spring BeanFactory.
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.
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.
Strategy interface used by a
ConfigurableBeanFactory,
representing a target scope to hold bean instances in.A subclass of
BeanCreationException which indicates that the target scope
is not active, for example, in case of request or session scope.FactoryBean that exposes the
'primary' service for the configured service class, obtained through
the JDK 1.6 ServiceLoader facility.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.FactoryBean that exposes the
JDK 1.6 ServiceLoader for the configured service class.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.Simple factory for shared Set instances.
AutowireCandidateResolver implementation to use when no annotation
support is available.Simple implementation of the
BeanDefinitionRegistry interface.Simple
NamespaceHandler implementation that maps custom
attributes directly through to bean properties.Simple object instantiation strategy for use in a BeanFactory.
Simple
NamespaceHandler implementation that maps custom attributes
directly through to bean properties.Simple implementation of the
TypeConverter interface that does not operate on
a specific target object.Interface that defines a registry for shared bean instances.
Extension of the
FactoryBean interface.Callback interface triggered at the end of the singleton pre-instantiation phase
during
BeanFactory bootstrap.Extension of the
InstantiationAwareBeanPostProcessor interface,
adding a callback for predicting the eventual type of a processed bean.Definition for sorting bean instances by a property.
Simple strategy allowing tools to control how source metadata is attached
to the bean definition metadata.
BeanInfoFactory implementation that performs standard
Introspector inspection.Static
BeanFactory implementation
which allows one to register existing singleton instances programmatically.Custom
PropertyEditor for String arrays.Property editor that trims Strings.
Editor for
java.util.TimeZone, translating timezone IDs into
TimeZone objects.Interface that defines type conversion methods.
Base implementation of the
TypeConverter interface, using a package-private delegate.Holder for a typed String value.
Exception thrown on a type mismatch when trying to set a bean property.
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.
Editor for
java.net.URI, to directly populate a URI property
instead of using a String property as bridge.Editor for
java.net.URL, to directly populate a URL property
instead of using a String property as bridge.NamespaceHandler for the util namespace.Editor for
java.util.UUID, translating UUID
String representations into UUID objects and back.Annotation used at the field or method/constructor parameter level
that indicates a default value expression for the annotated element.
Bean definition reader for XML bean definitions.
XML-specific BeanDefinitionStoreException subclass that wraps a
SAXException, typically a SAXParseException
which contains information about the error location.Extension of
ReaderContext,
specific to use with an XmlBeanDefinitionReader.Factory for a
Map that reads from a YAML source, preserving the
YAML-declared value types and their structure.Base class for YAML factories.
Strategy interface used to test if properties match.
Callback interface used to process the YAML parsing results.
Status returned from
YamlProcessor.DocumentMatcher.matches(java.util.Properties).Method to use for resolving resources.
Factory for
Properties that reads from a YAML source,
exposing a flat structure of String property values.Editor for
java.time.ZoneId, translating time zone Strings into ZoneId
objects.
PropertyPlaceholderConfigurer