## 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.

See:
Description

Interface Summary
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.
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.
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.
ComponentScanBeanDefinitionParser: Parser for the `<context:component-scan/>` element.
ConfigurationClassPostProcessor: `BeanFactoryPostProcessor` used for bootstrapping processing of `@Configuration` classes.
Jsr330ScopeMetadataResolver: Simple `ScopeMetadataResolver` implementation that follows JSR-330 scoping rules: defaulting to prototype scope unless `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.
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.
EnableLoadTimeWeaving.AspectJWeaving
FilterType: Enumeration of the type filters that may be used in conjunction with `@ComponentScan`.
ScopedProxyMode: Enumerates the various scoped-proxy options.

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:

     @Configuration
     public class AppConfig {
         @Bean
         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.