# All Classes and Interfaces

Class
Description
AbstractAdvisingBeanPostProcessor
Base class for `BeanPostProcessor` implementations that apply a Spring AOP `Advisor` to specific beans.
AbstractAdvisorAutoProxyCreator
Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean.
AbstractAspectJAdvice
Base class for AOP Alliance `Advice` classes wrapping an AspectJ aspect or an AspectJ-annotated advice method.
AbstractAspectJAdvisorFactory
Abstract base class for factories that can create Spring AOP Advisors given AspectJ classes from classes honoring the AspectJ 5 annotation syntax.
AbstractAspectJAdvisorFactory.AspectJAnnotation
Class modeling an AspectJ annotation, exposing its type enumeration and pointcut String.
AbstractAspectJAdvisorFactory.AspectJAnnotationType
Enum for AspectJ annotation types.
AbstractAutoProxyCreator
`BeanPostProcessor` implementation that wraps each eligible bean with an AOP proxy, delegating to specified interceptors before invoking the bean itself.
AbstractBeanFactoryAwareAdvisingPostProcessor
Extension of `AbstractAdvisingBeanPostProcessor` which implements `BeanFactoryAware`, adds exposure of the original target class for each proxied bean (`AutoProxyUtils.ORIGINAL_TARGET_CLASS_ATTRIBUTE`), and participates in an externally enforced target-class mode for any given bean (`AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE`).
AbstractBeanFactoryBasedTargetSource
Base class for `TargetSource` implementations that are based on a Spring `BeanFactory`, delegating to Spring-managed bean instances.
AbstractBeanFactoryBasedTargetSourceCreator
Convenient superclass for `TargetSourceCreator` implementations that require creating multiple instances of a prototype bean.
AbstractBeanFactoryPointcutAdvisor
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in a BeanFactory.
AbstractExpressionPointcut
Abstract superclass for expression pointcuts, offering location and expression properties.
AbstractGenericPointcutAdvisor
Abstract generic `PointcutAdvisor` that allows for any `Advice` to be configured.
AbstractInterceptorDrivenBeanDefinitionDecorator
Base implementation for `BeanDefinitionDecorators` wishing to add an `interceptor` to the resulting bean.
AbstractLazyCreationTargetSource
`TargetSource` implementation that will lazily create a user-managed object.
AbstractMonitoringInterceptor
Base class for monitoring interceptors, such as performance monitors.
AbstractPointcutAdvisor
Abstract base class for `PointcutAdvisor` implementations.
AbstractPoolingTargetSource
Abstract base class for pooling `TargetSource` implementations which maintain a pool of target instances, acquiring and releasing a target object from the pool for each method invocation.
AbstractPrototypeBasedTargetSource
Base class for dynamic `TargetSource` implementations that create new prototype bean instances to support a pooling or new-instance-per-invocation strategy.
AbstractRefreshableTargetSource
Abstract `TargetSource` implementation that wraps a refreshable target object.
AbstractRegexpMethodPointcut
Abstract base regular expression pointcut bean.
AbstractSingletonProxyFactoryBean
Convenient superclass for `FactoryBean` types that produce singleton-scoped proxy objects.
AbstractTraceInterceptor
Base `MethodInterceptor` implementation for tracing.
Advice
Tag interface for Advice.
AdviceEntry
`ParseState` entry representing an advice element.
Advised
Interface to be implemented by classes that hold the configuration of a factory of AOP proxies.
AdvisedSupport
Base class for AOP proxy configuration managers.
AdvisedSupportListener
Listener to be registered on `ProxyCreatorSupport` objects Allows for receiving callbacks on activation and change of advice.
Advisor
Base interface holding AOP advice (action to take at a joinpoint) and a filter determining the applicability of the advice (such as a pointcut).
AdvisorAdapter
Interface allowing extension to the Spring AOP framework to allow handling of new Advisors and Advice types.
AdvisorAdapterRegistrationManager
BeanPostProcessor that registers `AdvisorAdapter` beans in the BeanFactory with an `AdvisorAdapterRegistry` (by default the `GlobalAdvisorAdapterRegistry`).
AdvisorAdapterRegistry
Interface for registries of Advisor adapters.
AdvisorChainFactory
Factory interface for advisor chains.
AdvisorComponentDefinition
`ComponentDefinition` that bridges the gap between the advisor bean definition configured by the `<aop:advisor>` tag and the component definition infrastructure.
AdvisorEntry
`ParseState` entry representing an advisor.
AfterAdvice
Common marker interface for after advice, such as `AfterReturningAdvice` and `ThrowsAdvice`.
AfterReturningAdvice
After returning advice is invoked only on normal method return, not if an exception is thrown.
AfterReturningAdviceInterceptor
Interceptor to wrap an `AfterReturningAdvice`.
AnnotationAwareAspectJAutoProxyCreator
`AspectJAwareAdvisorAutoProxyCreator` subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.
AnnotationClassFilter
Simple ClassFilter that looks for a specific annotation being present on a class.
AnnotationMatchingPointcut
Simple `Pointcut` that looks for a specific annotation being present on a class or method.
AnnotationMethodMatcher
Simple `MethodMatcher` that looks for a specific annotation being present on a method (checking both the method on the invoked interface, if any, and the corresponding method on the target class).
AopConfigException
Exception that gets thrown on illegal AOP configuration arguments.
AopConfigUtils
Utility class for handling registration of AOP auto-proxy creators.
AopContext
Class containing static methods used to obtain information about the current AOP invocation.
AopInfrastructureBean
Marker interface that indicates a bean that is part of Spring's AOP infrastructure.
AopInvocationException
Exception that gets thrown when an AOP invocation failed because of misconfiguration or unexpected runtime issues.
AopNamespaceHandler
`NamespaceHandler` for the `aop` namespace.
AopNamespaceUtils
Utility class for handling registration of auto-proxy creators used internally by the '`aop`' namespace tags.
AopProxy
Delegate interface for a configured AOP proxy, allowing for the creation of actual proxy objects.
AopProxyFactory
Interface to be implemented by factories that are able to create AOP proxies based on `AdvisedSupport` configuration objects.
AopProxyUtils
Utility methods for AOP proxy factories.
AopUtils
Utility methods for AOP support code.
AspectComponentDefinition
`ComponentDefinition` that holds an aspect definition, including its nested pointcuts.
AspectEntry
`ParseState` entry representing an aspect.
AspectException
Superclass for all AOP infrastructure exceptions.
AspectInstanceFactory
Interface implemented to provide an instance of an AspectJ aspect.
AspectJAdviceParameterNameDiscoverer
`ParameterNameDiscoverer` implementation that tries to deduce parameter names for an advice method from the pointcut expression, returning, and throwing clauses.
AspectJAdviceParameterNameDiscoverer.AmbiguousBindingException
Thrown in response to an ambiguous binding being detected when trying to resolve a method's parameter names.
AspectJAdvisorFactory
Interface for factories that can create Spring AOP Advisors from classes annotated with AspectJ annotation syntax.
AspectJAfterAdvice
Spring AOP advice wrapping an AspectJ after advice method.
AspectJAfterReturningAdvice
Spring AOP advice wrapping an AspectJ after-returning advice method.
AspectJAfterThrowingAdvice
Spring AOP advice wrapping an AspectJ after-throwing advice method.
AspectJAopUtils
Utility methods for dealing with AspectJ advisors.
AspectJAroundAdvice
Spring AOP around advice (MethodInterceptor) that wraps an AspectJ advice method.
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.
AspectJExpressionPointcut
Spring `Pointcut` implementation that uses the AspectJ weaver to evaluate a pointcut expression.
AspectJExpressionPointcutAdvisor
Spring AOP Advisor that can be used for any AspectJ pointcut expression.
AspectJMethodBeforeAdvice
Spring AOP advice that wraps an AspectJ before method.
AspectJPointcutAdvisor
`AspectJPointcutAdvisor` adapts an `AbstractAspectJAdvice` to the `PointcutAdvisor` interface.
AspectJPrecedenceInformation
Interface to be implemented by types that can supply the information needed to sort advice/advisors by AspectJ's precedence rules.
AspectJProxyFactory
AspectJ-based proxy factory, allowing for programmatic building of proxies which include AspectJ aspects (code style as well annotation style).
AspectJProxyUtils
Utility methods for working with AspectJ proxies.
AspectJWeaverMessageHandler
Implementation of AspectJ's `IMessageHandler` interface that routes AspectJ weaving messages through the same logging system as the regular Spring messages.
AspectMetadata
Metadata for an AspectJ aspect class, with an additional Spring AOP pointcut for the per clause.
AsyncExecutionAspectSupport
Base class for asynchronous method execution aspects, such as `org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor` or `org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect`.
AsyncExecutionInterceptor
AOP Alliance `MethodInterceptor` that processes method invocations asynchronously, using a given `AsyncTaskExecutor`.
AsyncUncaughtExceptionHandler
A strategy for handling uncaught exceptions thrown from asynchronous methods.
AutoProxyUtils
Utilities for auto-proxy aware components.
BeanFactoryAdvisorRetrievalHelper
Helper for retrieving standard Spring Advisors from a BeanFactory, for use with auto-proxying.
BeanFactoryAspectInstanceFactory
`AspectInstanceFactory` implementation backed by a Spring `BeanFactory`.
BeanFactoryAspectJAdvisorsBuilder
Helper for retrieving @AspectJ beans from a BeanFactory and building Spring Advisors based on them, for use with auto-proxying.
BeanFactoryRefreshableTargetSource
Refreshable TargetSource that fetches fresh target beans from a BeanFactory.
BeanNameAutoProxyCreator
Auto proxy creator that identifies beans to proxy via a list of names.
BeforeAdvice
Common marker interface for before advice, such as `MethodBeforeAdvice`.
ClassFilter
Filter that restricts matching of a pointcut or introduction to a given set of target classes.
ClassFilters
Static utility methods for composing `ClassFilters`.
CommonsPool2TargetSource
`TargetSource` implementation that holds objects in a configurable Apache Commons2 Pool.
ComposablePointcut
Convenient class for building up pointcuts.
ConcurrencyThrottleInterceptor
Interceptor that throttles concurrent access, blocking invocations if a specified concurrency limit is reached.
ConstructorInterceptor
Intercepts the construction of a new object.
ConstructorInvocation
Description of an invocation to a constructor, given to an interceptor upon constructor-call.
ControlFlowPointcut
Pointcut and method matcher for use as a simple cflow-style pointcut.
CustomizableTraceInterceptor
`MethodInterceptor` implementation that allows for highly customizable method-level tracing, using placeholders.
DebugInterceptor
AOP Alliance `MethodInterceptor` that can be introduced in a chain to display verbose information about intercepted invocations to the logger.
DeclareParentsAdvisor
Introduction advisor delegating to the given object.
DefaultAdvisorAdapterRegistry
Default implementation of the `AdvisorAdapterRegistry` interface.
DefaultAdvisorAutoProxyCreator
`BeanPostProcessor` implementation that creates AOP proxies based on all candidate `Advisor`s in the current `BeanFactory`.
DefaultAdvisorChainFactory
A simple but definitive way of working out an advice chain for a Method, given an `Advised` object.
DefaultAopProxyFactory
Default `AopProxyFactory` implementation, creating either a CGLIB proxy or a JDK dynamic proxy.
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.
DefaultIntroductionAdvisor
Simple `IntroductionAdvisor` implementation that by default applies to any class.
DefaultPointcutAdvisor
Convenient Pointcut-driven Advisor implementation.
DefaultScopedObject
Default implementation of the `ScopedObject` interface.
DelegatePerTargetObjectIntroductionInterceptor
Convenient implementation of the `IntroductionInterceptor` interface.
DelegatingIntroductionInterceptor
Convenient implementation of the `IntroductionInterceptor` interface.
DynamicIntroductionAdvice
Subinterface of AOP Alliance Advice that allows additional interfaces to be implemented by an Advice, and available via a proxy using that interceptor.
DynamicMethodMatcher
Convenient abstract superclass for dynamic method matchers, which do care about arguments at runtime.
DynamicMethodMatcherPointcut
Convenient superclass when we want to force subclasses to implement MethodMatcher interface, but subclasses will want to be pointcuts.
EmptyTargetSource
Canonical `TargetSource` when there is no target (or just the target class known), and behavior is supplied by interfaces and advisors only.
ExposeBeanNameAdvisors
Convenient methods for creating advisors that may be used when autoproxying beans created with the Spring IoC container, binding the bean name to the current invocation.
ExposeInvocationInterceptor
Interceptor that exposes the current `MethodInvocation` as a thread-local object.
ExpressionPointcut
Interface to be implemented by pointcuts that use String expressions.
GlobalAdvisorAdapterRegistry
Singleton to publish a shared DefaultAdvisorAdapterRegistry instance.
HotSwappableTargetSource
`TargetSource` implementation that caches a local target object, but allows the target to be swapped while the application is running.
InfrastructureAdvisorAutoProxyCreator
Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.
InstantiationModelAwarePointcutAdvisor
Interface to be implemented by Spring AOP Advisors wrapping AspectJ aspects that may have a lazy initialization strategy.
Interceptor
This interface represents a generic interceptor.
IntroductionAdvisor
Superinterface for advisors that perform one or more AOP introductions.
IntroductionAwareMethodMatcher
A specialized type of `MethodMatcher` that takes into account introductions when matching methods.
IntroductionInfo
Interface supplying the information necessary to describe an introduction.
IntroductionInfoSupport
Support for implementations of `IntroductionInfo`.
IntroductionInterceptor
Subinterface of AOP Alliance MethodInterceptor that allows additional interfaces to be implemented by the interceptor, and available via a proxy using that interceptor.
Invocation
This interface represents an invocation in the program.
JdkRegexpMethodPointcut
Regular expression pointcut based on the `java.util.regex` package.
Joinpoint
This interface represents a generic runtime joinpoint (in the AOP terminology).
LazyInitTargetSource
`TargetSource` that lazily accesses a singleton bean from a `BeanFactory`.
LazyInitTargetSourceCreator
`TargetSourceCreator` that enforces a `LazyInitTargetSource` for each bean that is defined as "lazy-init".
LazySingletonAspectInstanceFactoryDecorator
Decorator to cause a `MetadataAwareAspectInstanceFactory` to instantiate only once.
MetadataAwareAspectInstanceFactory
Subinterface of `AspectInstanceFactory` that returns `AspectMetadata` associated with AspectJ-annotated classes.
MethodBeforeAdvice
Advice invoked before a method is invoked.
MethodBeforeAdviceInterceptor
Interceptor to wrap a `MethodBeforeAdvice`.
MethodInterceptor
Intercepts calls on an interface on its way to the target.
MethodInvocation
Description of an invocation to a method, given to an interceptor upon method-call.
MethodInvocationProceedingJoinPoint
An implementation of the AspectJ `ProceedingJoinPoint` interface wrapping an AOP Alliance `MethodInvocation`.
MethodLocatingFactoryBean
`FactoryBean` implementation that locates a `Method` on a specified bean.
MethodMatcher
Part of a `Pointcut`: Checks whether the target method is eligible for advice.
MethodMatchers
Static utility methods for composing `MethodMatchers`.
NameMatchMethodPointcut
Pointcut bean for simple method name matches, as an alternative to regular expression patterns.
NameMatchMethodPointcutAdvisor
Convenient class for name-match method pointcuts that hold an Advice, making them an Advisor.
NotAnAtAspectException
Extension of AopConfigException thrown when trying to perform an advisor generation operation on a class that is not an AspectJ annotation-style aspect.
PerformanceMonitorInterceptor
Simple AOP Alliance `MethodInterceptor` for performance monitoring.
Pointcut
Core Spring pointcut abstraction.
PointcutAdvisor
Superinterface for all Advisors that are driven by a pointcut.
PointcutComponentDefinition
`ComponentDefinition` implementation that holds a pointcut definition.
PointcutEntry
`ParseState` entry representing a pointcut.
Pointcuts
Pointcut constants for matching getters and setters, and static methods useful for manipulating and evaluating pointcuts.
PoolingConfig
Config interface for a pooling target source.
PrototypeAspectInstanceFactory
`AspectInstanceFactory` backed by a `BeanFactory`-provided prototype, enforcing prototype semantics.
PrototypeTargetSource
`TargetSource` implementation that creates a new instance of the target bean for each request, destroying each instance on release (after each request).
ProxyConfig
Convenience superclass for configuration used in creating proxies, to ensure that all proxy creators have consistent properties.
ProxyCreationContext
Holder for the current proxy creation context, as exposed by auto-proxy creators such as `AbstractAdvisorAutoProxyCreator`.
ProxyCreatorSupport
Base class for proxy factories.
ProxyFactory
Factory for AOP proxies for programmatic use, rather than via declarative setup in a bean factory.
ProxyFactoryBean
`FactoryBean` implementation that builds an AOP proxy based on beans in a Spring `BeanFactory`.
ProxyMethodInvocation
Extension of the AOP Alliance `MethodInvocation` interface, allowing access to the proxy that the method invocation was made through.
ProxyProcessorSupport
Base class with common functionality for proxy processors, in particular ClassLoader management and the `ProxyProcessorSupport.evaluateProxyInterfaces(java.lang.Class<?>, org.springframework.aop.framework.ProxyFactory)` algorithm.
QuickTargetSourceCreator
Convenient TargetSourceCreator using bean name prefixes to create one of three well-known TargetSource types: : CommonsPool2TargetSource % ThreadLocalTargetSource ! PrototypeTargetSource
RawTargetAccess
Marker for AOP proxy interfaces (in particular: introduction interfaces) that explicitly intend to return the raw target object (which would normally get replaced with the proxy object when returned from a method invocation).
ReflectiveAspectJAdvisorFactory
Factory that can create Spring AOP Advisors given AspectJ classes from classes honoring AspectJ's annotation syntax, using reflection to invoke the corresponding advice methods.
ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor
Synthetic advisor that instantiates the aspect.
ReflectiveMethodInvocation
Spring's implementation of the AOP Alliance `MethodInvocation` interface, implementing the extended `ProxyMethodInvocation` interface.
Refreshable
Interface to be implemented by dynamic target objects, which support reloading and optionally polling for updates.
RegexpMethodPointcutAdvisor
Convenient class for regexp method pointcuts that hold an Advice, making them an `Advisor`.
RootClassFilter
Simple ClassFilter implementation that passes classes (and optionally subclasses).
ScopedObject
An AOP introduction interface for scoped objects.
ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects.
ScopedProxyUtils
Utility class for creating a scoped proxy.
ShadowMatchUtils
Internal `ShadowMatch` utilities.
SimpleAspectInstanceFactory
Implementation of `AspectInstanceFactory` that creates a new instance of the specified aspect class for every `SimpleAspectInstanceFactory.getAspectInstance()` call.
SimpleAsyncUncaughtExceptionHandler
A default `AsyncUncaughtExceptionHandler` that simply logs the exception.
SimpleBeanFactoryAwareAspectInstanceFactory
Implementation of `AspectInstanceFactory` that locates the aspect from the `BeanFactory` using a configured bean name.
SimpleBeanTargetSource
Simple `TargetSource` implementation, freshly obtaining the specified target bean from its containing Spring `BeanFactory`.
SimpleMetadataAwareAspectInstanceFactory
Implementation of `MetadataAwareAspectInstanceFactory` that creates a new instance of the specified aspect class for every `SimpleAspectInstanceFactory.getAspectInstance()` call.
SimpleTraceInterceptor
Simple AOP Alliance `MethodInterceptor` that can be introduced in a chain to display verbose trace information about intercepted method invocations, with method entry and method exit info.
SingletonAspectInstanceFactory
Implementation of `AspectInstanceFactory` that is backed by a specified singleton object, returning the same instance for every `SingletonAspectInstanceFactory.getAspectInstance()` call.
SingletonMetadataAwareAspectInstanceFactory
Implementation of `MetadataAwareAspectInstanceFactory` that is backed by a specified singleton object, returning the same instance for every `SingletonAspectInstanceFactory.getAspectInstance()` call.
SingletonTargetSource
Implementation of the `TargetSource` interface that holds a given object.
SpringProxy
Marker interface implemented by all AOP proxies.
StaticMethodMatcher
Convenient abstract superclass for static method matchers, which don't care about arguments at runtime.
StaticMethodMatcherPointcut
Convenient superclass when we want to force subclasses to implement the `MethodMatcher` interface but subclasses will want to be pointcuts.
StaticMethodMatcherPointcutAdvisor
Convenient base class for Advisors that are also static pointcuts.
TargetClassAware
Minimal interface for exposing the target class behind a proxy.
TargetSource
A `TargetSource` is used to obtain the current "target" of an AOP invocation, which will be invoked via reflection if no around advice chooses to end the interceptor chain itself.
TargetSourceCreator
Implementations can create special target sources, such as pooling target sources, for particular beans.
ThreadLocalTargetSource
Alternative to an object pool.
ThreadLocalTargetSourceStats
Statistics for a ThreadLocal TargetSource.
ThrowsAdvice
Tag interface for throws advice.
ThrowsAdviceInterceptor
Interceptor to wrap an after-throwing advice.
TypePatternClassFilter
Spring AOP `ClassFilter` implementation using AspectJ type matching.
UnknownAdviceTypeException
Exception thrown when an attempt is made to use an unsupported Advisor or Advice type.