Package org.springframework.context.annotation

Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.


Interface Summary
ConfigurationClassEnhancer.EnhancedConfiguration Marker interface to be implemented by all @Configuration CGLIB subclasses.
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.
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 Summary
AdviceModeImportSelector<A extends 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.
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.
ConfigurationClassBeanDefinitionReader.InvalidConfigurationImportProblem Configuration classes must be annotated with @Configuration or declare at least one @Bean method.
ConfigurationClassEnhancer Enhances ConfigurationClassEnhancer.EnhancedConfiguration classes by generating a CGLIB subclass capable of interacting with the Spring container to respect bean semantics.
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.DisposableBeanMethodInterceptor Intercepts the invocation of any DisposableBean.destroy() on @Configuration class instances for the purpose of de-registering CGLIB callbacks.
ConfigurationClassEnhancer.GetObjectMethodInterceptor Intercepts calls to FactoryBean.getObject(), delegating to calling BeanFactory.getBean(String) in order to respect caching / scoping.
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 Problem registered upon detection of a circular Import.
ConfigurationClassPostProcessor BeanFactoryPostProcessor used for bootstrapping processing of @Configuration classes.
ConfigurationClassUtils Utilities for processing @Configuration classes.
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.
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 Summary
AdviceMode Enumeration used to determine whether JDK proxy-based or AspectJ weaving-based advice should be applied.
FilterType Enumeration of the type filters that may be used in conjunction with @ComponentScan.
ScopedProxyMode Enumerates the various scoped-proxy options.

Exception Summary
CircularComponentScanException Exception thrown upon detection of circular ComponentScan use.
ConflictingBeanDefinitionException Marker subclass of IllegalStateException, allowing for explicit catch clauses in calling code.

Annotation Types Summary
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.
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:
 public class AppConfig {
     public MyBean myBean() {
         // instantiate, configure and return bean ...
DependsOn Beans on which the current bean depends.
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.
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.
Role Indicates the 'role' hint for a given bean.
Scope When used as a type-level annotation in conjunction with the Component annotation, indicates the name of a scope to use for instances of the annotated type.

Package org.springframework.context.annotation Description

Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.