@NonNullApi @NonNullFields

# 程序包 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.

请参阅: 说明

- 接口概要
  接口 | 说明
  --- | ---
  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.
  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.

- 类概要
  类 | 说明
  --- | ---
  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 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.

- 枚举概要
  枚举 | 说明
  --- | ---
  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.

- 注释类型概要
  注释类型 | 说明
  --- | ---
  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 ...
           }
       }

       Bootstrapping @Configuration classes

       Via AnnotationConfigApplicationContext

       @Configuration classes are typically bootstrapped using either
       AnnotationConfigApplicationContext or its web-capable variant,
       AnnotationConfigWebApplicationContext.
  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 `@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.

## 程序包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.