Uses of Interface
org.springframework.aop.TargetClassAware
Package
Description
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
Various
TargetSource
implementations for use
with Spring AOP.Support for dynamic, refreshable
TargetSource
implementations for use with Spring AOP.The classes in this package make JNDI easier to use,
facilitating the accessing of configuration stored in JNDI,
and provide useful superclasses for JNDI access classes.
Support classes for Spring's scripting package.
-
Uses of TargetClassAware in org.springframework.aop
Modifier and TypeInterfaceDescriptioninterface
ATargetSource
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. -
Uses of TargetClassAware in org.springframework.aop.aspectj.annotation
Modifier and TypeClassDescriptionclass
AspectJ-based proxy factory, allowing for programmatic building of proxies which include AspectJ aspects (code style as well annotation style). -
Uses of TargetClassAware in org.springframework.aop.framework
Modifier and TypeInterfaceDescriptioninterface
Interface to be implemented by classes that hold the configuration of a factory of AOP proxies.Modifier and TypeClassDescriptionclass
Base class for AOP proxy configuration managers.class
Base class for proxy factories.class
Factory for AOP proxies for programmatic use, rather than via declarative setup in a bean factory.class
FactoryBean
implementation that builds an AOP proxy based on beans in a SpringBeanFactory
. -
Uses of TargetClassAware in org.springframework.aop.target
Modifier and TypeClassDescriptionclass
Base class forTargetSource
implementations that are based on a SpringBeanFactory
, delegating to Spring-managed bean instances.class
TargetSource
implementation that will lazily create a user-managed object.class
Abstract base class for poolingTargetSource
implementations which maintain a pool of target instances, acquiring and releasing a target object from the pool for each method invocation.class
Base class for dynamicTargetSource
implementations that create new prototype bean instances to support a pooling or new-instance-per-invocation strategy.class
TargetSource
implementation that holds objects in a configurable Apache Commons2 Pool.final class
CanonicalTargetSource
when there is no target (or just the target class known), and behavior is supplied by interfaces and advisors only.class
TargetSource
implementation that caches a local target object, but allows the target to be swapped while the application is running.class
TargetSource
that lazily accesses a singleton bean from aBeanFactory
.class
TargetSource
implementation that creates a new instance of the target bean for each request, destroying each instance on release (after each request).class
SimpleTargetSource
implementation, freshly obtaining the specified target bean from its containing SpringBeanFactory
.class
Implementation of theTargetSource
interface that holds a given object.class
Alternative to an object pool. -
Uses of TargetClassAware in org.springframework.aop.target.dynamic
Modifier and TypeClassDescriptionclass
AbstractTargetSource
implementation that wraps a refreshable target object.class
Refreshable TargetSource that fetches fresh target beans from a BeanFactory. -
Uses of TargetClassAware in org.springframework.jndi
Modifier and TypeClassDescriptionclass
AOPTargetSource
that provides configurable JNDI lookups forgetTarget()
calls. -
Uses of TargetClassAware in org.springframework.scripting.support
Modifier and TypeClassDescriptionclass
Subclass ofBeanFactoryRefreshableTargetSource
that determines whether a refresh is required through the givenScriptFactory
.