| Package | Description |
|---|---|
| org.springframework.cache.annotation |
Annotations and supporting classes for declarative cache management.
|
| org.springframework.cache.aspectj | |
| org.springframework.cache.jcache.config |
Support package for declarative JSR-107 caching configuration.
|
| 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.
|
| org.springframework.context.annotation.aspectj | |
| org.springframework.jms.annotation |
Annotations and support classes for declarative JMS listener endpoints.
|
| org.springframework.messaging.simp.config |
Configuration support for WebSocket messaging using higher level messaging protocols.
|
| org.springframework.scheduling.annotation |
Java 5 annotation for asynchronous method execution.
|
| org.springframework.scheduling.aspectj | |
| org.springframework.transaction.annotation |
Spring's support for annotation-based transaction demarcation.
|
| org.springframework.transaction.aspectj | |
| org.springframework.web.context.annotation |
Provides convenience annotations for web scopes.
|
| org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
| org.springframework.web.reactive.config |
Spring WebFlux configuration infrastructure.
|
| org.springframework.web.servlet.config.annotation |
Annotation-based setup for Spring MVC.
|
| org.springframework.web.socket.config.annotation |
Support for annotation-based WebSocket setup in configuration classes.
|
| Class and Description |
|---|
| AdviceMode
Enumeration used to determine whether JDK proxy-based or
AspectJ weaving-based advice should be applied.
|
| AdviceModeImportSelector
Convenient base class for
ImportSelector implementations that select imports
based on an AdviceMode value from an annotation (such as the @Enable*
annotations). |
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |
| ImportAware
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
| 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. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| ImportAware
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| ImportAware
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| AdviceMode
Enumeration used to determine whether JDK proxy-based or
AspectJ weaving-based advice should be applied.
|
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. |
| AnnotationConfigRegistry
Common interface for annotation config application contexts,
defining
AnnotationConfigRegistry.register(java.lang.Class<?>...) and AnnotationConfigRegistry.scan(java.lang.String...) methods. |
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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.LookupElement
Class representing generic injection information about an annotated field
or setter method, supporting @Resource and related annotations.
|
| Condition
A single
condition that must be matched in order
for a component to be registered. |
| Conditional
Indicates that a component is only eligible for registration when all
specified conditions match.
|
| ConditionContext
Context information for use by
Conditions. |
| 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 ... |
| ConfigurationCondition.ConfigurationPhase
The various configuration phases where the condition could be evaluated.
|
| 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.
|
| DeferredImportSelector.Group.Entry
An entry that holds the
AnnotationMetadata of the importing
Configuration class and the class name to import. |
| EnableLoadTimeWeaving.AspectJWeaving
AspectJ weaving enablement options.
|
| FilterType
Enumeration of the type filters that may be used in conjunction with
@ComponentScan. |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |
| 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. |
| MBeanExportConfiguration.SpecificPlatform
Specific platforms that might need custom MBean handling.
|
| Role
Indicates the 'role' hint for a given bean.
|
| ScopedProxyMode
Enumerates the various scoped-proxy options.
|
| ScopeMetadata
Describes scope characteristics for a Spring-managed bean including the scope
name and the scoped-proxy behavior.
|
| ScopeMetadataResolver
Strategy interface for resolving the scope of bean definitions.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| Class and Description |
|---|
| AdviceMode
Enumeration used to determine whether JDK proxy-based or
AspectJ weaving-based advice should be applied.
|
| AdviceModeImportSelector
Convenient base class for
ImportSelector implementations that select imports
based on an AdviceMode value from an annotation (such as the @Enable*
annotations). |
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |
| ImportAware
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
| 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. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| ImportAware
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| AdviceMode
Enumeration used to determine whether JDK proxy-based or
AspectJ weaving-based advice should be applied.
|
| AdviceModeImportSelector
Convenient base class for
ImportSelector implementations that select imports
based on an AdviceMode value from an annotation (such as the @Enable*
annotations). |
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |
| ImportAware
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
| 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. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| ImportAware
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
| Role
Indicates the 'role' hint for a given bean.
|
| Class and Description |
|---|
| 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. |
| Class and Description |
|---|
| AnnotatedBeanDefinitionReader
Convenient adapter for programmatic registration of bean classes.
|
| AnnotationConfigRegistry
Common interface for annotation config application contexts,
defining
AnnotationConfigRegistry.register(java.lang.Class<?>...) and AnnotationConfigRegistry.scan(java.lang.String...) methods. |
| ClassPathBeanDefinitionScanner
A bean definition scanner that detects bean candidates on the classpath,
registering corresponding bean definitions with a given registry (
BeanFactory
or ApplicationContext). |
| ScopeMetadataResolver
Strategy interface for resolving the scope of bean definitions.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |
| Lazy
Indicates whether a bean is to be lazily initialized.
|
| Class and Description |
|---|
| Bean
Indicates that a method produces a bean to be managed by the Spring container.
|
| 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 ... |
| Import
Indicates one or more component classes to import — typically
@Configuration classes. |