All Classes and Interfaces
类
说明
Base class for
BeanPostProcessor implementations that apply a
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.MethodMatcher that excludes the specified advice method.
Abstract base class for factories that can create Framework 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.
ParameterNameDiscoverer implementation that analyzes the arg names
specified at the AspectJ annotation level.
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).Abstract BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in a BeanFactory.
Base class for
TargetSource implementations that are
based on a BeanFactory, delegating to
ioc-managed bean instances.Convenient superclass for
TargetSourceCreator
implementations that require creating multiple instances of a prototype bean.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.Implemented basic
AbstractMethodInvocation.proceed() logicBase 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.
Stub for an Advisor instance that is just needed for key purposes,
allowing for efficient equals and hashCode comparisons against the
advice class and the pointcut.
Simple wrapper class around a Method.
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 join-point)
and a filter determining the applicability of the advice (such as
a pointcut).
Interface allowing extension to the 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 DefaultAdvisorAdapterRegistry).Interface for registries of Advisor adapters.
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.
Adapter to enable
AfterReturningAdvice
to be used in the AOP framework.Interceptor to wrap an
AfterReturningAdvice.AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ
annotation aspects in the current application context, as well as Framework Advisors.Simple ClassFilter that looks for a specific Java 5 annotation
being present on a class.
ClassFilter that delegates to AnnotationUtils.isCandidateClass(java.lang.Class<?>, java.util.Collection<java.lang.Class<? extends java.lang.annotation.Annotation>>)
for filtering classes whose methods are not worth searching to begin with.Simple MethodMatcher that looks for a specific Java 5 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 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.
Simple struct to hold the extracted text from a pointcut body, together
with the number of tokens consumed in extracting it.
An AOT
BeanRegistrationAotProcessor that detects the presence of
classes compiled with AspectJ and adds the related required field hints.Interface for factories that can create Framework AOP Advisors from classes
annotated with AspectJ annotation syntax.
Framework AOP advice wrapping an AspectJ after advice method.
Framework AOP advice wrapping an AspectJ after-returning advice method.
Framework AOP advice wrapping an AspectJ after-throwing advice method.
Utility methods for dealing with AspectJ advisors.
Framework AOP around advice (MethodInterceptor) that wraps
an AspectJ advice method.
BeanDefinitionParser for the aspectj-autoproxy tag,
enabling the automatic application of @AspectJ-style aspects found in
the BeanFactory.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.Implements AspectJ's
PartialOrder.PartialComparable interface for defining partial orderings.BeanFactoryInitializationAotProcessor implementation responsible for registering
hints for AOP advices.Inner class to avoid a hard dependency on AspectJ at runtime.
Framework
Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression.Framework AOP Advisor that can be used for any AspectJ pointcut expression.
Framework AOP advice that wraps an AspectJ before method.
AspectJPointcutAdvisor that adapts an
AbstractAspectJAdvice
to the PointcutAdvisor interface.Orders AspectJ advice/advisors by precedence (not invocation order).
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
Java 5 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 Framework messages.Metadata for an AspectJ aspect class, with an additional Framework AOP pointcut
for the per clause.
Base class for asynchronous method execution aspects, such as
infra.scheduling.annotation.AnnotationAsyncExecutionInterceptor
or infra.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 Framework Advisors from a BeanFactory,
for use with auto-proxying.
AspectInstanceFactory implementation
backed by a Framework BeanFactory.Helper for retrieving @AspectJ beans from a BeanFactory and building
Framework 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.
CGLIB-based
AopProxy implementation for the AOP framework.Dispatcher for any methods declared on the Advised class.
Implementation of AOP Alliance MethodInvocation used by this AOP proxy.
General purpose AOP callback.
Interceptor for unadvised dynamic targets when the proxy needs exposing.
Interceptor used to invoke a dynamic target without creating a method
invocation or evaluating an advice chain.
Dispatcher for the
equals method.Interceptor used specifically for advised methods on a frozen, static proxy.
Dispatcher for the
hashCode method.CallbackFilter to assign Callbacks to methods.
Serializable replacement for CGLIB's NoOp interface.
Dispatcher for a static target.
Method interceptor used for static targets with no advice chain, when the
proxy is to be exposed.
Method interceptor used for static targets with no advice chain.
Filter that restricts matching of a pointcut or introduction to
a given set of target classes.
ClassFilter implementation for an intersection of the given ClassFilter.
ClassFilter implementation for a logical negation of the given ClassFilter.
ClassFilter implementation for a union of the given ClassFilter.
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.
BeanDefinitionParser for the <aop:config> tag.Intercepts the construction of a new object.
Description of an invocation to a constuctor, given to an interceptor upon
construtor-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.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.
A simple but definitive way of working out an advice chain for a Method,
given an
Advised object.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 IoC container, binding the bean name to the current
invocation.
Interceptor that exposes the specified bean name as invocation attribute.
Introduction that exposes the specified bean name as invocation attribute.
Interceptor that exposes the current
MethodInvocation
as a thread-local object.Interface to be implemented by pointcuts that use String expressions.
This interface represents a field access in the program.
Intercepts field access on a target object.
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 Framework AOP Advisors wrapping AspectJ
aspects that may have a lazy initialization strategy.
Internal implementation of AspectJPointcutAdvisor.
Pointcut implementation that changes its behaviour when the advice is instantiated.
This interface represents a generic interceptor.
Factory interface for advisor chains.
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.Sub-interface 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.
JDK-based
AopProxy implementation for the AOP framework,
based on JDK dynamic proxies.Holder for the complete proxied interfaces and derived metadata,
to be cached in
AdvisedSupport.proxyMetadataCache.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.
Adapter to enable
MethodBeforeAdvice
to be used in the AOP framework.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.MethodMatcher implementation for a union of two given MethodMatchers
of which at least one is an IntroductionAwareMethodMatcher,
supporting an associated ClassFilter per MethodMatcher.
MethodMatcher implementation for a union of two given MethodMatchers,
supporting an associated ClassFilter per MethodMatcher.
MethodMatcher implementation for an intersection of two given MethodMatchers
of which at least one is an IntroductionAwareMethodMatcher.
MethodMatcher implementation for an intersection of two given MethodMatcher.
MethodMatcher implementation for a union of two given MethodMatchers
of which at least one is an IntroductionAwareMethodMatcher.
MethodMatcher implementation for a union of two given MethodMatcher.
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 pointcut abstraction.
Pointcut implementation that matches bean property getters.
Pointcut implementation that matches bean property setters.
Superinterface for all Advisors that are driven by a pointcut.
ComponentDefinition
implementation that holds a pointcut definition.ParseState entry representing a pointcut.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.Proxy Creator
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 BeanFactory.Used in the interceptor chain where we need to replace a bean with a prototype
on creating a proxy.
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<?>, infra.aop.framework.ProxyFactory) algorithm.Convenient TargetSourceCreator using bean name prefixes to create one of three
well-known TargetSource types:
: CommonsPool2TargetSource
% ThreadLocalTargetSource
!
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 Framework 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.
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.Empty class used for a serializable monitor object.
Simple ClassFilter implementation that passes classes (and optionally subclasses).
Runtime MethodInterceptor
This class encapsulates some AspectJ internal knowledge that should be
pushed back into the AspectJ project in a future release.
Check if residue of target(TYPE) kind.
Check if residue of this(TYPE) kind.
An AOP introduction interface for scoped objects.
BeanDefinitionDecorator responsible for parsing the
<aop:scoped-proxy/> tag.BeanRegistrationAotProcessor for ScopedProxyFactoryBean.Convenient proxy factory bean for scoped objects.
Utility class for creating a scoped proxy.
Internal
ShadowMatch utilities.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
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.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.
Adapter to enable
ThrowsAdvice to be used
in the AOP framework.Interceptor to wrap an after-throwing advice.
Canonical ClassFilter instance that matches all classes.
Canonical MethodMatcher instance that matches all methods.
Canonical Pointcut instance that always matches.
Framework AOP
ClassFilter implementation using AspectJ type matching.Exception thrown when an attempt is made to use an unsupported
Advisor or Advice type.