org.springframework.context.annotation (Spring Framework 5.1.20.RELEASE API)

Interface Summary
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` implementations.
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.
DeferredImportSelector.Group	Interface used to group results from different import selectors.
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
Class	Description
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 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 component 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 provides candidate components 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.
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.
DeferredImportSelector.Group.Entry	An entry that holds the `AnnotationMetadata` of the importing `Configuration` class and the class name to import.
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.
MBeanExportConfiguration	`@Configuration` class that registers a `AnnotationMBeanExporter` 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
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	AspectJ weaving enablement options.
FilterType	Enumeration of the type filters that may be used in conjunction with `@ComponentScan`.
MBeanExportConfiguration.SpecificPlatform	Specific platforms that might need custom MBean handling.
ScopedProxyMode	Enumerates the various scoped-proxy options.

Annotation Types Summary
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	Adds a textual description to bean definitions derived from `Component` or `Bean`.
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 component classes to import — typically `@Configuration` classes.
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.

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.