All Classes and Interfaces

Class
Description
Base class for BeanPostProcessor implementations that apply a Spring AOP Advisor to specific beans.
Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean.
Base class for AOP Alliance Advice classes wrapping an AspectJ aspect or an AspectJ-annotated advice method.
Abstract base class for factories that can create Spring AOP Advisors given AspectJ classes from classes honoring the AspectJ 5 annotation syntax.
Class modeling an AspectJ annotation, exposing its type enumeration and pointcut String.
Enum for AspectJ annotation types.
BeanPostProcessor implementation that wraps each eligible bean with an AOP proxy, delegating to specified interceptors before invoking the bean itself.
Extension of AbstractAutoProxyCreator 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).
Base class for TargetSource implementations that are based on a Spring BeanFactory, delegating to Spring-managed bean instances.
Convenient superclass for TargetSourceCreator implementations that require creating multiple instances of a prototype bean.
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in a BeanFactory.
Abstract superclass for expression pointcuts, offering location and expression properties.
Abstract generic PointcutAdvisor that allows for any Advice to be configured.
Base implementation for BeanDefinitionDecorators wishing to add an interceptor to the resulting bean.
TargetSource implementation that will lazily create a user-managed object.
Base class for monitoring interceptors, such as performance monitors.
Abstract base class for PointcutAdvisor implementations.
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.
Base class for dynamic TargetSource implementations that create new prototype bean instances to support a pooling or new-instance-per-invocation strategy.
Abstract TargetSource implementation that wraps a refreshable target object.
Abstract base regular expression pointcut bean.
Convenient superclass for FactoryBean types that produce singleton-scoped proxy objects.
Base MethodInterceptor implementation for tracing.
Tag interface for Advice.
ParseState entry representing an advice element.
Interface to be implemented by classes that hold the configuration of a factory of AOP proxies.
Base class for AOP proxy configuration managers.
Listener to be registered on ProxyCreatorSupport objects Allows for receiving callbacks on activation and change of advice.
Base interface holding AOP advice (action to take at a joinpoint) and a filter determining the applicability of the advice (such as a pointcut).
Interface allowing extension to the Spring AOP framework to allow handling of new Advisors and Advice types.
BeanPostProcessor that registers AdvisorAdapter beans in the BeanFactory with an AdvisorAdapterRegistry (by default the GlobalAdvisorAdapterRegistry).
Interface for registries of Advisor adapters.
Factory interface for advisor chains.
ComponentDefinition that bridges the gap between the advisor bean definition configured by the <aop:advisor> tag and the component definition infrastructure.
ParseState entry representing an advisor.
Common marker interface for after advice, such as AfterReturningAdvice and ThrowsAdvice.
After returning advice is invoked only on normal method return, not if an exception is thrown.
Interceptor to wrap an AfterReturningAdvice.
AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.
Simple ClassFilter that looks for a specific annotation being present on a class.
Simple Pointcut that looks for a specific annotation being present on a class or method.
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).
Exception that gets thrown on illegal AOP configuration arguments.
Utility class for handling registration of AOP auto-proxy creators.
Class containing static methods used to obtain information about the current AOP invocation.
Marker interface that indicates a bean that is part of Spring's AOP infrastructure.
Exception that gets thrown when an AOP invocation failed because of misconfiguration or unexpected runtime issues.
NamespaceHandler for the aop namespace.
Utility class for handling registration of auto-proxy creators used internally by the 'aop' namespace tags.
Delegate interface for a configured AOP proxy, allowing for the creation of actual proxy objects.
Interface to be implemented by factories that are able to create AOP proxies based on AdvisedSupport configuration objects.
Utility methods for AOP proxy factories.
Utility methods for AOP support code.
ComponentDefinition that holds an aspect definition, including its nested pointcuts.
ParseState entry representing an aspect.
Superclass for all AOP infrastructure exceptions.
Interface implemented to provide an instance of an AspectJ aspect.
ParameterNameDiscoverer implementation that tries to deduce parameter names for an advice method from the pointcut expression, returning, and throwing clauses.
Thrown in response to an ambiguous binding being detected when trying to resolve a method's parameter names.
Interface for factories that can create Spring AOP Advisors from classes annotated with AspectJ annotation syntax.
Spring AOP advice wrapping an AspectJ after advice method.
Spring AOP advice wrapping an AspectJ after-returning advice method.
Spring AOP advice wrapping an AspectJ after-throwing advice method.
Utility methods for dealing with AspectJ advisors.
Spring AOP around advice (MethodInterceptor) that wraps an AspectJ advice method.
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.
Spring Pointcut implementation that uses the AspectJ weaver to evaluate a pointcut expression.
Spring AOP Advisor that can be used for any AspectJ pointcut expression.
Spring AOP advice that wraps an AspectJ before method.
AspectJ PointcutAdvisor that adapts an AbstractAspectJAdvice to the PointcutAdvisor interface.
Interface to be implemented by types that can supply the information needed to sort advice/advisors by AspectJ's precedence rules.
AspectJ-based proxy factory, allowing for programmatic building of proxies which include AspectJ aspects (code style as well annotation style).
Utility methods for working with AspectJ proxies.
Implementation of AspectJ's IMessageHandler interface that routes AspectJ weaving messages through the same logging system as the regular Spring messages.
Metadata for an AspectJ aspect class, with an additional Spring AOP pointcut for the per clause.
Base class for asynchronous method execution aspects, such as org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor or org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect.
AOP Alliance MethodInterceptor that processes method invocations asynchronously, using a given AsyncTaskExecutor.
A strategy for handling uncaught exceptions thrown from asynchronous methods.
Utilities for auto-proxy aware components.
Helper for retrieving standard Spring Advisors from a BeanFactory, for use with auto-proxying.
AspectInstanceFactory implementation backed by a Spring BeanFactory.
Helper for retrieving @AspectJ beans from a BeanFactory and building Spring Advisors based on them, for use with auto-proxying.
Refreshable TargetSource that fetches fresh target beans from a BeanFactory.
Auto proxy creator that identifies beans to proxy via a list of names.
Common marker interface for before advice, such as MethodBeforeAdvice.
Filter that restricts matching of a pointcut or introduction to a given set of target classes.
Static utility methods for composing ClassFilters.
TargetSource implementation that holds objects in a configurable Apache Commons2 Pool.
Convenient class for building up pointcuts.
Interceptor that throttles concurrent access, blocking invocations if a specified concurrency limit is reached.
Intercepts the construction of a new object.
Description of an invocation to a constructor, given to an interceptor upon constructor-call.
Pointcut and method matcher for use in simple cflow-style pointcut.
MethodInterceptor implementation that allows for highly customizable method-level tracing, using placeholders.
AOP Alliance MethodInterceptor that can be introduced in a chain to display verbose information about intercepted invocations to the logger.
Introduction advisor delegating to the given object.
Default implementation of the AdvisorAdapterRegistry interface.
BeanPostProcessor implementation that creates AOP proxies based on all candidate Advisors in the current BeanFactory.
A simple but definitive way of working out an advice chain for a Method, given an Advised object.
Default AopProxyFactory implementation, creating either a CGLIB proxy or a JDK dynamic proxy.
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.
Simple IntroductionAdvisor implementation that by default applies to any class.
Convenient Pointcut-driven Advisor implementation.
Default implementation of the ScopedObject interface.
Convenient implementation of the IntroductionInterceptor interface.
Convenient implementation of the IntroductionInterceptor interface.
Subinterface of AOP Alliance Advice that allows additional interfaces to be implemented by an Advice, and available via a proxy using that interceptor.
Convenient abstract superclass for dynamic method matchers, which do care about arguments at runtime.
Convenient superclass when we want to force subclasses to implement MethodMatcher interface, but subclasses will want to be pointcuts.
Canonical TargetSource when there is no target (or just the target class known), and behavior is supplied by interfaces and advisors only.
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.
Interceptor that exposes the current MethodInvocation as a thread-local object.
Interface to be implemented by pointcuts that use String expressions.
Singleton to publish a shared DefaultAdvisorAdapterRegistry instance.
TargetSource implementation that caches a local target object, but allows the target to be swapped while the application is running.
Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.
Interface to be implemented by Spring AOP Advisors wrapping AspectJ aspects that may have a lazy initialization strategy.
This interface represents a generic interceptor.
Superinterface for advisors that perform one or more AOP introductions.
A specialized type of MethodMatcher that takes into account introductions when matching methods.
Interface supplying the information necessary to describe an introduction.
Support for implementations of IntroductionInfo.
Subinterface of AOP Alliance MethodInterceptor that allows additional interfaces to be implemented by the interceptor, and available via a proxy using that interceptor.
This interface represents an invocation in the program.
Regular expression pointcut based on the java.util.regex package.
This interface represents a generic runtime joinpoint (in the AOP terminology).
TargetSource that lazily accesses a singleton bean from a BeanFactory.
TargetSourceCreator that enforces a LazyInitTargetSource for each bean that is defined as "lazy-init".
Decorator to cause a MetadataAwareAspectInstanceFactory to instantiate only once.
Subinterface of AspectInstanceFactory that returns AspectMetadata associated with AspectJ-annotated classes.
Advice invoked before a method is invoked.
Interceptor to wrap a MethodBeforeAdvice.
Intercepts calls on an interface on its way to the target.
Description of an invocation to a method, given to an interceptor upon method-call.
An implementation of the AspectJ ProceedingJoinPoint interface wrapping an AOP Alliance MethodInvocation.
FactoryBean implementation that locates a Method on a specified bean.
Part of a Pointcut: Checks whether the target method is eligible for advice.
Static utility methods for composing MethodMatchers.
Pointcut bean for simple method name matches, as an alternative to regexp patterns.
Convenient class for name-match method pointcuts that hold an Advice, making them an Advisor.
Extension of AopConfigException thrown when trying to perform an advisor generation operation on a class that is not an AspectJ annotation-style aspect.
Simple AOP Alliance MethodInterceptor for performance monitoring.
Core Spring pointcut abstraction.
Superinterface for all Advisors that are driven by a pointcut.
ComponentDefinition implementation that holds a pointcut definition.
ParseState entry representing a pointcut.
Pointcut constants for matching getters and setters, and static methods useful for manipulating and evaluating pointcuts.
Config interface for a pooling target source.
AspectInstanceFactory backed by a BeanFactory-provided prototype, enforcing prototype semantics.
TargetSource implementation that creates a new instance of the target bean for each request, destroying each instance on release (after each request).
Convenience superclass for configuration used in creating proxies, to ensure that all proxy creators have consistent properties.
Holder for the current proxy creation context, as exposed by auto-proxy creators such as AbstractAdvisorAutoProxyCreator.
Base class for proxy factories.
Factory for AOP proxies for programmatic use, rather than via declarative setup in a bean factory.
FactoryBean implementation that builds an AOP proxy based on beans in a Spring BeanFactory.
Extension of the AOP Alliance MethodInvocation interface, allowing access to the proxy that the method invocation was made through.
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.
Convenient TargetSourceCreator using bean name prefixes to create one of three well-known TargetSource types: : CommonsPool2TargetSource % ThreadLocalTargetSource ! PrototypeTargetSource
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).
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.
Synthetic advisor that instantiates the aspect.
Spring's implementation of the AOP Alliance MethodInvocation interface, implementing the extended ProxyMethodInvocation interface.
Interface to be implemented by dynamic target objects, which support reloading and optionally polling for updates.
Convenient class for regexp method pointcuts that hold an Advice, making them an Advisor.
Simple ClassFilter implementation that passes classes (and optionally subclasses).
An AOP introduction interface for scoped objects.
Convenient proxy factory bean for scoped objects.
Utility class for creating a scoped proxy.
Implementation of AspectInstanceFactory that creates a new instance of the specified aspect class for every SimpleAspectInstanceFactory.getAspectInstance() call.
A default AsyncUncaughtExceptionHandler that simply logs the exception.
Implementation of AspectInstanceFactory that locates the aspect from the BeanFactory using a configured bean name.
Simple TargetSource implementation, freshly obtaining the specified target bean from its containing Spring BeanFactory.
Implementation of MetadataAwareAspectInstanceFactory that creates a new instance of the specified aspect class for every SimpleAspectInstanceFactory.getAspectInstance() call.
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.
Implementation of AspectInstanceFactory that is backed by a specified singleton object, returning the same instance for every SingletonAspectInstanceFactory.getAspectInstance() call.
Implementation of MetadataAwareAspectInstanceFactory that is backed by a specified singleton object, returning the same instance for every SingletonAspectInstanceFactory.getAspectInstance() call.
Implementation of the TargetSource interface that holds a given object.
Marker interface implemented by all AOP proxies.
Convenient abstract superclass for static method matchers, which don't care about arguments at runtime.
Convenient superclass when we want to force subclasses to implement the MethodMatcher interface but subclasses will want to be pointcuts.
Convenient base class for Advisors that are also static pointcuts.
Minimal interface for exposing the target class behind a proxy.
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.
Implementations can create special target sources, such as pooling target sources, for particular beans.
Alternative to an object pool.
Statistics for a ThreadLocal TargetSource.
Tag interface for throws advice.
Interceptor to wrap an after-throwing advice.
Spring AOP ClassFilter implementation using AspectJ type matching.
Exception thrown when an attempt is made to use an unsupported Advisor or Advice type.