|
spring-aop | ||||||||
PREV NEXT | FRAMES NO FRAMES |
Advice
classes
wrapping an AspectJ aspect or an AspectJ-annotated advice method.BeanPostProcessor
implementation
that wraps each eligible bean with an AOP proxy, delegating to specified interceptors
before invoking the bean itself.TargetSource
implementations
that are based on a Spring BeanFactory
,
delegating to Spring-managed bean instances.TargetSourceCreator
implementations that require creating multiple instances of a prototype bean.BeanDefinitionDecorators
wishing to add an interceptor
to the resulting bean.TargetSource
implementation that will
lazily create a user-managed object.PointcutAdvisor
implementations.TargetSource
implementations which maintain a pool of target instances, acquiring and
releasing a target object from the pool for each method invocation.TargetSource
implementations
that create new prototype bean instances to support a pooling or
new-instance-per-invocation strategy.TargetSource
implementation that
wraps a refreshable target object.FactoryBean
types that produce singleton-scoped
proxy objects.MethodInterceptor
implementation for tracing.AdvisedSupport.addAdvisors(org.springframework.aop.Advisor...)
ParseState
entry representing an advice element.AdviceEntry
class.
ProxyCreatorSupport
objects
Allows for receiving callbacks on activation and change of advice.AdvisorAdapter
beans in the BeanFactory with
an AdvisorAdapterRegistry
(by default the GlobalAdvisorAdapterRegistry
).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.AdvisorEntry
class.
AfterReturningAdvice
and ThrowsAdvice
.AfterReturningAdvice
.AspectJAwareAdvisorAutoProxyCreator
subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors.class
or
method
.NamespaceHandler
for the aop
namespace.aop
' namespace tags.AdvisedSupport
configuration objects.ComponentDefinition
that holds an aspect definition, including its nested pointcuts.ParseState
entry representing an aspect.ParameterNameDiscoverer
implementation that tries to deduce parameter names
for an advice method from the pointcut expression, returning, and throwing clauses.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.Pointcut
implementation
that uses the AspectJ weaver to evaluate a pointcut expression.AbstractAspectJAdvice
to the PointcutAdvisor
interface.AspectJProxyFactory
.
IMessageHandler
interface that
routes AspectJ weaving messages through the same logging system as the
regular Spring messages.org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor
or org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect
.AsyncExecutionAspectSupport
, using the provided default
executor unless individual async methods indicate via qualifier that a more
specific executor should be used.
MethodInterceptor
that processes method invocations
asynchronously, using a given AsyncTaskExecutor
.AsyncExecutionInterceptor
.
AspectInstanceFactory
implementation
backed by a Spring BeanFactory
.MethodBeforeAdvice
.ClassFilters
.ClassFilter.TRUE
and MethodMatcher.TRUE
.
MethodMatcher.TRUE
.
ClassFilter.TRUE
.
AopProxy
for the given AOP configuration.
null
if they are
not interested it in, in which case no special target source will be created.
BeanDefinition
for the interceptor they wish to apply to the bean being decorated.
String
name for the given MethodInvocation
that can be used for trace/logging purposes.
JdkRegexpMethodPointcut
will be used.
MethodInterceptor
implementation that allows for highly customizable
method-level tracing, using placeholders.MethodInterceptor
that can be introduced in a chain
to display verbose information about intercepted invocations to the logger.AdvisorAdapterRegistry
interface.Advised
object.AopProxyFactory
implementation,
creating either a CGLIB proxy or a JDK dynamic proxy.IntroductionAdvisor
implementation
that by default applies to any class.Log
instance used to write trace messages.
ScopedObject
interface.DefaultScopedObject
class.
IntroductionInterceptor
interface.IntroductionInterceptor
interface.ObjectPool
when destroying this object.
MethodInterceptor
.
MethodInterceptor
.
TargetSource
when there is no target
(or just the target class known), and behavior is supplied
by interfaces and advisors only.MethodInvocation
as a thread-local object.ExposeInvocationInterceptor
to the beginning of the advice chain.
candidateAdvisors
list
that is applicable to the given class.
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry)
null
).
List
of Advisors
.
null
).
BeanFactory
and returns it.
MethodInterceptor
objects
for the given method, based on this configuration.
MethodInterceptor
objects
for the given advisor chain configuration.
Log
instance to use for the given
MethodInvocation
.
Ordered
interface (only
checked for singleton beans), or an order expressed through the
Order
annotation
at the class level.
Ordered
interface,
or a fallback order.
Ordered
interface,
or a fallback order.
Ordered
interface.
Order
annotation,
falling back to Ordered.LOWEST_PRECEDENCE
.
Ordered
interface.
Ordered
interface.
TargetSource
,
implementing the specified interface.
TargetSource
that extends
the target class of the TargetSource
.
ObjectPool
.
null
.
null
if the
target is null
(it is hasn't yet been initialized),
or the target class if the target has already been initialized.
null
if none.
TargetSource
.
TargetSource
implementation that
caches a local target object, but allows the target to be swapped
while the application is running.BeanDefinitionParsers
for the
'config
', 'spring-configured
', 'aspectj-autoproxy
'
and 'scoped-proxy
' tags.
Patterns
from the supplied String[]
.
Patterns
from the supplied String[]
.
EmptyTargetSource
.
IntroductionInfo
.MethodInvocation
.
MethodInvocation
.
enterMessage
.
true
if the advisor is a form of after advice.
AjTypeSystem
.
true
if the advisor is a form of before advice.
ClassUtils.isCglibProxyClass(Class)
ClassUtils.isCglibProxyClassName(String)
invokeUnderTrace
method should be called.
Log
instance is enabled.
Advised
.
MethodMatcher.matches(java.lang.reflect.Method, Class, Object[])
method at
runtime even if the 2-arg matches method returns true
?
true
.
TargetSource.getTarget()
return the same object?
java.util.regex
package.TargetSource
that lazily accesses a
singleton bean from a BeanFactory
.MetadataAwareAspectInstanceFactory
to instantiate only once.true
if the Pattern
at index patternIndex
matches the supplied candidate String
.
IntroductionAwareMethodMatcher
(if applicable).
true
if the exclusion Pattern
at index patternIndex
matches the supplied candidate String
.
AspectInstanceFactory
that returns AspectMetadata
associated with AspectJ-annotated classes.MethodBeforeAdvice
.FactoryBean
implementation that locates a Method
on a specified bean.Pointcut
: Checks whether the target method is eligible for advice.MethodMatchers
.MethodInterceptor
for performance monitoring.$[argumentTypes]
placeholder.
$[arguments]
placeholder.
$[exception]
placeholder.
$[invocationTime]
placeholder.
$[methodName]
placeholder.
$[returnValue]
placeholder.
$[targetClassName]
placeholder.
$[targetClassShortName]
placeholder.
ComponentDefinition
implementation that holds a pointcut definition.ParseState
entry representing a pointcut.PointcutEntry
class.
proxy-target-class
attribute as found on AOP-related XML tags.
AbstractAdvisorAutoProxyCreator
.TargetSource
,
making the proxy implement the specified interface.
FactoryBean
implementation that builds an
AOP proxy based on beans in Spring BeanFactory
.MethodInvocation
interface, allowing access to the proxy that the method invocation was made through.MethodInvocation
interface,
implementing the extended
ProxyMethodInvocation
interface.Advisor
.AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(ParserContext, Element)
and
AopConfigUtils.registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry, Object)
ObjectPool
.
TargetSource.getTarget()
method.
BeanFactory
to be used when looking up executors by qualifier.
ClassFilter
to use for this pointcut.
ClassFilter
to use for this pointcut.
dynamic loggers
hide
proxy class names wherever possible.
Method
to locate.
Advised
to query proxy status.
IllegalArgumentException
and AspectJAdviceParameterNameDiscoverer.AmbiguousBindingException
must be thrown as appropriate in the case of failing to deduce advice parameter names.
afterReturning
advice binds the return value, the
returning variable name must be specified.
Method
on.
afterThrowing
advice binds the thrown value, the
throwing variable name must be specified.
true
if the
given bean should not be considered for auto-proxying by this post-processor.
AspectInstanceFactory
that creates a new instance
of the specified aspect class for every SimpleAspectInstanceFactory.getAspectInstance()
call.AspectInstanceFactory
that locates the aspect from the
BeanFactory
using a configured bean name.TargetSource
implementation,
freshly obtaining the specified target bean from its containing
Spring BeanFactory
.MetadataAwareAspectInstanceFactory
that
creates a new instance of the specified aspect class for every
SimpleAspectInstanceFactory.getAspectInstance()
call.MethodInterceptor
that can be introduced
in a chain to display verbose trace information about intercepted method
invocations, with method entry and method exit info.AspectInstanceFactory
that is backed by a
specified singleton object, returning the same instance for every
SingletonAspectInstanceFactory.getAspectInstance()
call.MetadataAwareAspectInstanceFactory
that is backed
by a specified singleton object, returning the same instance for every
SingletonAspectInstanceFactory.getAspectInstance()
call.TargetSource
interface
that holds a given object.MethodMatcher
interface but subclasses will want to be pointcuts.getInterceptors
method with an Advisor that
contains this advice as an argument?
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.toString()
will normally be delegated to the target,
this returns the equivalent for the AOP proxy.
ClassFilter
implementation using AspectJ type matching.TypePatternClassFilter
class.
TypePatternClassFilter
using the
given type pattern.
Log
instance.
Throwable
to the
supplied Log
instance.
|
spring-aop | ||||||||
PREV NEXT | FRAMES NO FRAMES |