See: Description
Interface | Description |
---|---|
AnnotationConfigRegistry |
Common interface for annotation config application contexts,
defining
AnnotationConfigRegistry.register(java.lang.Class<?>...) and AnnotationConfigRegistry.scan(java.lang.String...) methods. |
Condition |
A single
condition that must be matched in order
for a component to be registered. |
ConditionContext |
Context information for use by
Condition s. |
ConfigurationClassEnhancer.ConditionalCallback |
Conditional
Callback . |
ConfigurationClassEnhancer.EnhancedConfiguration |
Marker interface to be implemented by all @Configuration CGLIB subclasses.
|
ConfigurationCondition |
A
Condition that offers more fine-grained control when used with
@Configuration . |
DeferredImportSelector |
A variation of
ImportSelector that runs after all @Configuration beans
have been processed. |
ImportAware |
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
ImportBeanDefinitionRegistrar |
Interface to be implemented by types that register additional bean definitions when
processing @
Configuration classes. |
ImportRegistry | |
ImportSelector |
Interface to be implemented by types that determine which @
Configuration
class(es) should be imported based on a given selection criteria, usually one or more
annotation attributes. |
LoadTimeWeavingConfigurer |
Interface to be implemented by
@Configuration
classes annotated with @EnableLoadTimeWeaving that wish to
customize the LoadTimeWeaver instance to be used. |
ScopeMetadataResolver |
Strategy interface for resolving the scope of bean definitions.
|
Class | Description |
---|---|
AdviceModeImportSelector<A extends java.lang.annotation.Annotation> |
Convenient base class for
ImportSelector implementations that select imports
based on an AdviceMode value from an annotation (such as the @Enable*
annotations). |
AnnotatedBeanDefinitionReader |
Convenient adapter for programmatic registration of annotated bean classes.
|
AnnotationBeanNameGenerator |
BeanNameGenerator
implementation for bean classes annotated with the
@Component annotation
or with another annotation that is itself annotated with
@Component as a
meta-annotation. |
AnnotationConfigApplicationContext |
Standalone application context, accepting annotated classes as input - in particular
@Configuration -annotated classes, but also plain
@Component types and JSR-330 compliant
classes using javax.inject annotations. |
AnnotationConfigBeanDefinitionParser |
Parser for the <context:annotation-config/> element.
|
AnnotationConfigUtils |
Utility class that allows for convenient registration of common
BeanPostProcessor and
BeanFactoryPostProcessor
definitions for annotation-based configuration. |
AnnotationScopeMetadataResolver |
A
ScopeMetadataResolver implementation that by default checks for
the presence of Spring's @Scope annotation on the bean class. |
AspectJAutoProxyRegistrar |
Registers an
AnnotationAwareAspectJAutoProxyCreator against the current BeanDefinitionRegistry
as appropriate based on a given @EnableAspectJAutoProxy annotation. |
AutoProxyRegistrar |
Registers an auto proxy creator against the current
BeanDefinitionRegistry
as appropriate based on an @Enable* annotation having mode and
proxyTargetClass attributes set to the correct values. |
BeanAnnotationHelper |
Utilities for processing
Bean -annotated methods. |
BeanMethod |
Represents a
Configuration class method marked with the
Bean annotation. |
ClassPathBeanDefinitionScanner |
A bean definition scanner that detects bean candidates on the classpath,
registering corresponding bean definitions with a given registry (
BeanFactory
or ApplicationContext ). |
ClassPathScanningCandidateComponentProvider |
A component provider that scans the classpath from a base package.
|
CommonAnnotationBeanPostProcessor |
BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the JSR-250
annotations in the javax.annotation package. |
CommonAnnotationBeanPostProcessor.LookupDependencyDescriptor |
Extension of the DependencyDescriptor class,
overriding the dependency type with the specified resource type.
|
ComponentScanAnnotationParser |
Parser for the @
ComponentScan annotation. |
ComponentScanBeanDefinitionParser |
Parser for the
<context:component-scan/> element. |
ConditionEvaluator |
Internal class used to evaluate
Conditional annotations. |
ConditionEvaluator.ConditionContextImpl |
Implementation of a
ConditionContext . |
ConfigurationClass |
Represents a user-defined
@Configuration class. |
ConfigurationClassBeanDefinitionReader |
Reads a given fully-populated set of ConfigurationClass instances, registering bean
definitions with the given
BeanDefinitionRegistry based on its contents. |
ConfigurationClassBeanDefinitionReader.ConfigurationClassBeanDefinition |
RootBeanDefinition marker subclass used to signify that a bean definition
was created from a configuration class as opposed to any other configuration source. |
ConfigurationClassEnhancer |
Enhances
Configuration classes by generating a CGLIB subclass which
interacts with the Spring container to respect bean scoping semantics for
@Bean methods. |
ConfigurationClassEnhancer.BeanFactoryAwareGeneratorStrategy |
Custom extension of CGLIB's DefaultGeneratorStrategy, introducing a
BeanFactory field. |
ConfigurationClassEnhancer.BeanFactoryAwareMethodInterceptor |
Intercepts the invocation of any
BeanFactoryAware.setBeanFactory(BeanFactory) on
@Configuration class instances for the purpose of recording the BeanFactory . |
ConfigurationClassEnhancer.BeanMethodInterceptor |
Intercepts the invocation of any
Bean -annotated methods in order to ensure proper
handling of bean semantics such as scoping and AOP proxying. |
ConfigurationClassEnhancer.ConditionalCallbackFilter |
A
CallbackFilter that works by interrogating Callback s in the order
that they are defined via ConfigurationClassEnhancer.ConditionalCallback . |
ConfigurationClassParser |
Parses a
Configuration class definition, populating a collection of
ConfigurationClass objects (parsing a single Configuration class may result in
any number of ConfigurationClass objects because one Configuration class may import
another using the Import annotation). |
ConfigurationClassParser.CircularImportProblem | |
ConfigurationClassParser.DeferredImportSelectorHolder | |
ConfigurationClassParser.ImportStack | |
ConfigurationClassPostProcessor |
BeanFactoryPostProcessor used for bootstrapping processing of
@Configuration classes. |
ConfigurationClassPostProcessor.EnhancedConfigurationBeanPostProcessor |
InstantiationAwareBeanPostProcessorAdapter that ensures
ConfigurationClassEnhancer.EnhancedConfiguration beans are injected with the BeanFactory
before the AutowiredAnnotationBeanPostProcessor runs (SPR-10668). |
ConfigurationClassPostProcessor.ImportAwareBeanPostProcessor | |
ConfigurationClassUtils |
Utilities for processing @
Configuration classes. |
ConfigurationMethod | |
ContextAnnotationAutowireCandidateResolver |
Complete implementation of the
AutowireCandidateResolver strategy
interface, providing support for qualifier annotations as well as for lazy resolution
driven by the Lazy annotation in the context.annotation package. |
Jsr330ScopeMetadataResolver |
Simple
ScopeMetadataResolver implementation that follows JSR-330 scoping rules:
defaulting to prototype scope unless javax.inject.Singleton is present. |
LoadTimeWeavingConfiguration |
@Configuration class that registers a LoadTimeWeaver bean. |
MBeanExportConfiguration |
@Configuration class that registers a AnnotationMBeanExporter bean. |
ParserStrategyUtils |
Common delegate code for the handling of parser strategies, e.g.
|
ProfileCondition | |
ScannedGenericBeanDefinition |
Extension of the
GenericBeanDefinition
class, based on an ASM ClassReader, with support for annotation metadata exposed
through the AnnotatedBeanDefinition interface. |
ScopedProxyCreator |
Delegate factory class used to just introduce an AOP framework dependency
when actually creating a scoped proxy.
|
ScopeMetadata |
Describes scope characteristics for a Spring-managed bean including the scope
name and the scoped-proxy behavior.
|
Enum | Description |
---|---|
AdviceMode |
Enumeration used to determine whether JDK proxy-based or AspectJ weaving-based advice
should be applied.
|
ConfigurationCondition.ConfigurationPhase |
The various configuration phases where the condition could be evaluated.
|
EnableLoadTimeWeaving.AspectJWeaving | |
FilterType |
Enumeration of the type filters that may be used in conjunction with
@ComponentScan . |
MBeanExportConfiguration.SpecificPlatform | |
ScopedProxyMode |
Enumerates the various scoped-proxy options.
|
Exception | Description |
---|---|
ConflictingBeanDefinitionException |
Marker subclass of
IllegalStateException , allowing for explicit
catch clauses in calling code. |
Annotation Type | Description |
---|---|
Bean |
Indicates that a method produces a bean to be managed by the Spring container.
|
ComponentScan |
Configures component scanning directives for use with @
Configuration classes. |
ComponentScan.Filter |
Declares the type filter to be used as an include filter or exclude filter.
|
ComponentScans |
Container annotation that aggregates several
ComponentScan annotations. |
Conditional |
Indicates that a component is only eligible for registration when all
specified conditions match.
|
Configuration |
Indicates that a class declares one or more
@Bean methods and
may be processed by the Spring container to generate bean definitions and
service requests for those beans at runtime, for example:
@Configuration public class AppConfig { @Bean public MyBean myBean() { // instantiate, configure and return bean ... |
DependsOn |
Beans on which the current bean depends.
|
Description | |
EnableAspectJAutoProxy |
Enables support for handling components marked with AspectJ's
@Aspect annotation,
similar to functionality found in Spring's <aop:aspectj-autoproxy> XML element. |
EnableLoadTimeWeaving |
Activates a Spring
LoadTimeWeaver for this application context, available as
a bean with the name "loadTimeWeaver", similar to the <context:load-time-weaver>
element in Spring XML. |
EnableMBeanExport |
Enables default exporting of all standard
MBean s from the Spring context, as
well as well all @ManagedResource annotated beans. |
Import |
Indicates one or more
@Configuration classes to import. |
ImportResource |
Indicates one or more resources containing bean definitions to import.
|
Lazy |
Indicates whether a bean is to be lazily initialized.
|
Primary |
Indicates that a bean should be given preference when multiple candidates
are qualified to autowire a single-valued dependency.
|
Profile |
Indicates that a component is eligible for registration when one or more
specified profiles are active.
|
PropertySource |
Annotation providing a convenient and declarative mechanism for adding a
PropertySource to Spring's
Environment . |
PropertySources |
Container annotation that aggregates several
PropertySource annotations. |
Role |
Indicates the 'role' hint for a given bean.
|
Scope |
When used as a type-level annotation in conjunction with
@Component ,
@Scope indicates the name of a scope to use for instances of
the annotated type. |