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.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:
e.g.
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.
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.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, e.g.
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 standard 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
(e.g.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
: e.g.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 (e.g.Specialized
Supplier
that can be set on a
BeanDefinition
when details about the registered bean
are needed to
supply the instance.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 (e.g.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.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 that backs
a specific bean in a Spring BeanFactory at runtime.
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, e.g.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 zone ID Strings into ZoneId
objects.
PropertyPlaceholderConfigurer