Package | Description |
---|---|
org.springframework.aop.aspectj |
AspectJ integration package.
|
org.springframework.aop.aspectj.annotation |
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
|
org.springframework.aop.aspectj.autoproxy |
Base classes enabling auto-proxying based on AspectJ.
|
org.springframework.aop.config |
Support package for declarative AOP configuration,
with XML schema being the primary configuration format.
|
org.springframework.aop.framework |
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
|
org.springframework.aop.framework.autoproxy |
Bean post-processors for use in ApplicationContexts to simplify AOP usage
by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
|
org.springframework.aop.interceptor |
Provides miscellaneous interceptor implementations.
|
org.springframework.aop.support |
Convenience classes for using Spring's AOP API.
|
org.springframework.beans |
This package contains interfaces and classes for manipulating Java beans.
|
org.springframework.beans.factory.annotation |
Support package for annotation-driven bean configuration.
|
org.springframework.beans.factory.config |
SPI interfaces and configuration-related convenience classes for bean factories.
|
org.springframework.cache.interceptor |
AOP-based solution for declarative caching demarcation.
|
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.event |
Support classes for application events, like standard context events.
|
org.springframework.context.support |
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
|
org.springframework.context.weaving |
Load-time weaving support for a Spring application context, building on Spring's
LoadTimeWeaver abstraction. |
org.springframework.core |
Provides basic classes for exception handling and version detection,
and other core helpers that are not specific to any part of the framework.
|
org.springframework.dao.annotation |
Annotation support for DAOs.
|
org.springframework.jdbc.support.lob |
Provides a stategy interface for Large OBject handling,
with implementations for various databases.
|
org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
org.springframework.scheduling.annotation |
JDK 1.5+ annotation for asynchronous method execution.
|
org.springframework.scripting.support |
Support classes for Spring's scripting package.
|
org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
org.springframework.transaction.support |
Support classes for the org.springframework.transaction package.
|
org.springframework.validation.beanvalidation |
Support classes for integrating a JSR-303 Bean Validation provider
(such as Hibernate Validator 4.0) into a Spring ApplicationContext
and in particular with Spring's data binding and validation APIs.
|
org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
org.springframework.web.method |
Common infrastructure for handler method processing, as used by
Spring MVC's
org.springframework.web.servlet.mvc.method package. |
Modifier and Type | Interface and Description |
---|---|
interface |
AspectInstanceFactory
Interface implemented to provide an instance of an AspectJ aspect.
|
interface |
AspectJPrecedenceInformation
Interface to be implemented by types that can supply the information
needed to sort advice/advisors by AspectJ's precedence rules.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractAspectJAdvice
Base class for AOP Alliance
Advice classes
wrapping an AspectJ aspect or an AspectJ-annotated advice method. |
class |
AspectJAfterAdvice
Spring AOP advice wrapping an AspectJ after advice method.
|
class |
AspectJAfterReturningAdvice
Spring AOP advice wrapping an AspectJ after-returning advice method.
|
class |
AspectJAfterThrowingAdvice
Spring AOP advice wrapping an AspectJ after-throwing advice method.
|
class |
AspectJAroundAdvice
Spring AOP around advice (MethodInterceptor) that wraps
an AspectJ advice method.
|
class |
AspectJExpressionPointcutAdvisor
Spring AOP Advisor that can be used for any AspectJ pointcut expression.
|
class |
AspectJMethodBeforeAdvice
Spring AOP advice that wraps an AspectJ before method.
|
class |
AspectJPointcutAdvisor
AspectJPointcutAdvisor that adapts an
AbstractAspectJAdvice
to the PointcutAdvisor interface. |
class |
SimpleAspectInstanceFactory
Implementation of
AspectInstanceFactory that creates a new instance
of the specified aspect class for every SimpleAspectInstanceFactory.getAspectInstance() call. |
class |
SingletonAspectInstanceFactory
Implementation of
AspectInstanceFactory that is backed by a
specified singleton object, returning the same instance for every
SingletonAspectInstanceFactory.getAspectInstance() call. |
Modifier and Type | Interface and Description |
---|---|
interface |
MetadataAwareAspectInstanceFactory
Subinterface of
AspectInstanceFactory
that returns AspectMetadata associated with AspectJ-annotated classes. |
Modifier and Type | Class and Description |
---|---|
class |
AnnotationAwareAspectJAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors. |
class |
BeanFactoryAspectInstanceFactory
AspectInstanceFactory implementation
backed by a Spring BeanFactory . |
class |
LazySingletonAspectInstanceFactoryDecorator
Decorator to cause a
MetadataAwareAspectInstanceFactory to instantiate only once. |
class |
PrototypeAspectInstanceFactory
AspectInstanceFactory backed by a BeanFactory-provided prototype,
enforcing prototype semantics.
|
protected static class |
ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor
Synthetic advisor that instantiates the aspect.
|
class |
SimpleMetadataAwareAspectInstanceFactory
Implementation of
MetadataAwareAspectInstanceFactory that
creates a new instance of the specified aspect class for every
SimpleAspectInstanceFactory.getAspectInstance() call. |
class |
SingletonMetadataAwareAspectInstanceFactory
Implementation of
MetadataAwareAspectInstanceFactory that is backed
by a specified singleton object, returning the same instance for every
SingletonAspectInstanceFactory.getAspectInstance() call. |
Modifier and Type | Class and Description |
---|---|
class |
AspectJAwareAdvisorAutoProxyCreator
AbstractAdvisorAutoProxyCreator
subclass that exposes AspectJ's invocation context and understands AspectJ's rules
for advice precedence when multiple pieces of advice come from the same aspect. |
Modifier and Type | Class and Description |
---|---|
class |
SimpleBeanFactoryAwareAspectInstanceFactory
Implementation of
AspectInstanceFactory that locates the aspect from the
BeanFactory using a configured bean name. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractAdvisingBeanPostProcessor
Base class for
BeanPostProcessor implementations that apply a
Spring AOP Advisor to specific beans. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractAdvisorAutoProxyCreator
Generic auto proxy creator that builds AOP proxies for specific beans
based on detected Advisors for each bean.
|
class |
AbstractAutoProxyCreator
BeanPostProcessor implementation
that wraps each eligible bean with an AOP proxy, delegating to specified interceptors
before invoking the bean itself. |
class |
BeanNameAutoProxyCreator
Auto proxy creator that identifies beans to proxy via a list of names.
|
class |
DefaultAdvisorAutoProxyCreator
BeanPostProcessor implementation that creates AOP proxies based on all candidate
Advisors in the current BeanFactory.
|
class |
InfrastructureAdvisorAutoProxyCreator
Auto-proxy creator that considers infrastructure Advisor beans only,
ignoring any application-defined Advisors.
|
Modifier and Type | Class and Description |
---|---|
class |
AsyncExecutionInterceptor
AOP Alliance
MethodInterceptor that processes method invocations
asynchronously, using a given AsyncTaskExecutor . |
class |
ExposeInvocationInterceptor
Interceptor that exposes the current
MethodInvocation
as a thread-local object. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractBeanFactoryPointcutAdvisor
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in a BeanFactory.
|
class |
AbstractGenericPointcutAdvisor
Abstract generic PointcutAdvisor that allows for any Advice to be configured.
|
class |
AbstractPointcutAdvisor
Abstract base class for
PointcutAdvisor
implementations. |
class |
DefaultBeanFactoryPointcutAdvisor
Concrete BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in the BeanFactory,
as well as the Pointcut to be configured through a bean property.
|
class |
DefaultIntroductionAdvisor
Simple
IntroductionAdvisor implementation
that by default applies to any class. |
class |
DefaultPointcutAdvisor
Convenient Pointcut-driven Advisor implementation.
|
class |
NameMatchMethodPointcutAdvisor
Convenient class for name-match method pointcuts that hold an Advice,
making them an Advisor.
|
class |
RegexpMethodPointcutAdvisor
Convenient class for regexp method pointcuts that hold an Advice,
making them an
Advisor . |
class |
StaticMethodMatcherPointcutAdvisor
Convenient base class for Advisors that are also static pointcuts.
|
Modifier and Type | Class and Description |
---|---|
class |
ExtendedBeanInfoFactory
BeanInfoFactory implementation that evaluates whether bean classes have
"non-standard" JavaBeans setter methods and are thus candidates for introspection
by Spring's (package-visible) ExtendedBeanInfo implementation. |
Modifier and Type | Class and Description |
---|---|
class |
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor implementation
that autowires annotated fields, setter methods and arbitrary config methods. |
class |
CustomAutowireConfigurer
A
BeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire
qualifier types. |
class |
InitDestroyAnnotationBeanPostProcessor
BeanPostProcessor implementation
that invokes annotated init and destroy methods. |
class |
RequiredAnnotationBeanPostProcessor
BeanPostProcessor implementation
that enforces required JavaBean properties to have been configured. |
Modifier and Type | Class and Description |
---|---|
class |
CustomEditorConfigurer
BeanFactoryPostProcessor implementation that allows for convenient
registration of custom property editors . |
class |
CustomScopeConfigurer
Simple
BeanFactoryPostProcessor implementation that registers
custom Scope(s) with the containing ConfigurableBeanFactory . |
class |
PlaceholderConfigurerSupport
Abstract base class for property resource configurers that resolve placeholders
in bean definition property values.
|
class |
PreferencesPlaceholderConfigurer
Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's
Preferences API (
java.util.prefs ). |
class |
PropertyOverrideConfigurer
Property resource configurer that overrides bean property values in an application
context definition.
|
class |
PropertyPlaceholderConfigurer
PlaceholderConfigurerSupport subclass that resolves ${...} placeholders
against local properties and/or system properties
and environment variables. |
class |
PropertyResourceConfigurer
Allows for configuration of individual bean property values from a property resource,
i.e.
|
Modifier and Type | Class and Description |
---|---|
class |
BeanFactoryCacheOperationSourceAdvisor
Advisor driven by a
CacheOperationSource , used to include a
cache advice bean for methods that are cacheable. |
Modifier and Type | Class and Description |
---|---|
class |
CommonAnnotationBeanPostProcessor
BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the JSR-250
annotations in the javax.annotation package. |
class |
ConfigurationClassPostProcessor
BeanFactoryPostProcessor used for bootstrapping processing of
@Configuration classes. |
Modifier and Type | Interface and Description |
---|---|
interface |
SmartApplicationListener
Extended variant of the standard
ApplicationListener interface,
exposing further metadata such as the supported event type. |
Modifier and Type | Class and Description |
---|---|
class |
GenericApplicationListenerAdapter
SmartApplicationListener adapter that determines supported event types
through introspecting the generically declared type of the target listener. |
class |
SourceFilteringListener
ApplicationListener decorator that filters
events from a specified event source, invoking its delegate listener for
matching ApplicationEvent objects only. |
Modifier and Type | Class and Description |
---|---|
class |
PropertySourcesPlaceholderConfigurer
Specialization of
PlaceholderConfigurerSupport that resolves ${...} placeholders within bean definition
property values and @Value annotations against the current Spring Environment and its set of PropertySources . |
Modifier and Type | Class and Description |
---|---|
class |
AspectJWeavingEnabler
Post-processor that registers AspectJ's
ClassPreProcessorAgentAdapter
with the Spring application context's default
LoadTimeWeaver . |
Modifier and Type | Interface and Description |
---|---|
interface |
PriorityOrdered
Extension of the
Ordered interface, expressing a 'priority'
ordering: Order values expressed by PriorityOrdered objects always
apply before order values of 'plain' Ordered values. |
Modifier and Type | Class and Description |
---|---|
class |
PersistenceExceptionTranslationAdvisor
Spring AOP exception translation aspect for use at Repository or DAO layer level.
|
class |
PersistenceExceptionTranslationPostProcessor
Bean post-processor that automatically applies persistence exception translation to any
bean marked with Spring's @
Repository
annotation, adding a corresponding PersistenceExceptionTranslationAdvisor to
the exposed proxy (either an existing AOP proxy or a newly generated proxy that
implements all of the target's interfaces). |
Modifier and Type | Class and Description |
---|---|
class |
SpringLobCreatorSynchronization
Callback for resource cleanup at the end of a Spring transaction.
|
Modifier and Type | Class and Description |
---|---|
class |
PersistenceAnnotationBeanPostProcessor
BeanPostProcessor that processes
PersistenceUnit
and PersistenceContext annotations, for injection of
the corresponding JPA resources EntityManagerFactory
and EntityManager . |
Modifier and Type | Class and Description |
---|---|
class |
AnnotationAsyncExecutionInterceptor
Specialization of
AsyncExecutionInterceptor that delegates method execution to
an Executor based on the Async annotation. |
class |
AsyncAnnotationAdvisor
Advisor that activates asynchronous method execution through the
Async
annotation. |
class |
AsyncAnnotationBeanPostProcessor
Bean post-processor that automatically applies asynchronous invocation
behavior to any bean that carries the
Async annotation at class or
method-level by adding a corresponding AsyncAnnotationAdvisor to the
exposed proxy (either an existing AOP proxy or a newly generated proxy that
implements all of the target's interfaces). |
class |
ScheduledAnnotationBeanPostProcessor
Bean post-processor that registers methods annotated with @
Scheduled
to be invoked by a TaskScheduler according
to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation. |
Modifier and Type | Class and Description |
---|---|
class |
ScriptFactoryPostProcessor
BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it. |
Modifier and Type | Class and Description |
---|---|
class |
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by a
TransactionAttributeSource , used to include
a transaction advice bean for methods that are transactional. |
class |
TransactionAttributeSourceAdvisor
Advisor driven by a
TransactionAttributeSource , used to include
a TransactionInterceptor only for methods that are transactional. |
Modifier and Type | Class and Description |
---|---|
class |
TransactionSynchronizationAdapter
Simple
TransactionSynchronization adapter containing empty
method implementations, for easier overriding of single methods. |
Modifier and Type | Class and Description |
---|---|
class |
MethodValidationPostProcessor
A convenient
BeanPostProcessor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods. |
Modifier and Type | Class and Description |
---|---|
class |
ServletContextPropertyPlaceholderConfigurer
Deprecated.
in Spring 3.1 in favor of
PropertySourcesPlaceholderConfigurer
in conjunction with StandardServletEnvironment . |
Modifier and Type | Class and Description |
---|---|
class |
ControllerAdviceBean
Encapsulates information about an @ControllerAdvice
Spring-managed bean without necessarily requiring it to be instantiated.
|
Copyright © 2024. All rights reserved.