|
| |
|
| java.lang.Object
 org.springframework.aop.framework.ProxyConfig
org.springframework.aop.framework.AdvisedSupport
org.springframework.aop.framework.ProxyCreatorSupport
org.springframework.aop.framework.ProxyFactoryBean
| ProxyFactoryBean | | public class ProxyFactoryBean extends ProxyCreatorSupport implements FactoryBean,BeanClassLoaderAware,BeanFactoryAware(Code) | | org.springframework.beans.factory.FactoryBean implementation that builds an
AOP proxy based on beans in Spring
org.springframework.beans.factory.BeanFactory .
org.aopalliance.intercept.MethodInterceptor MethodInterceptors and
org.springframework.aop.Advisor Advisors are identified by a list of bean
names in the current bean factory, specified through the "interceptorNames" property.
The last entry in the list can be the name of a target bean or a
org.springframework.aop.TargetSource ; however, it is normally preferable
to use the "targetName"/"target"/"targetSource" properties instead.
Global interceptors and advisors can be added at the factory level. The specified
ones are expanded in an interceptor list where an "xxx*" entry is included in the
list, matching the given prefix with the bean names (e.g. "global*" would match
both "globalBean1" and "globalBean2", "*" all defined interceptors). The matching
interceptors get applied according to their returned order value, if they implement
the
org.springframework.core.Ordered interface.
Creates a JDK proxy when proxy interfaces are given, and a CGLIB proxy for the
actual target class if not. Note that the latter will only work if the target class
does not have final methods, as a dynamic subclass will be created at runtime.
It's possible to cast a proxy obtained from this factory to
Advised ,
or to obtain the ProxyFactoryBean reference and programmatically manipulate it.
This won't work for existing prototype references, which are independent. However,
it will work for prototypes subsequently obtained from the factory. Changes to
interception will work immediately on singletons (including existing references).
However, to change interfaces or target it's necessary to obtain a new instance
from the factory. This means that singleton instances obtained from the factory
do not have the same object identity. However, they do have the same interceptors
and target, and changing any reference will change all objects.
author:
Rod Johnson
author:
Juergen Hoeller
See Also: ProxyFactoryBean.setInterceptorNames
See Also: ProxyFactoryBean.setProxyInterfaces
See Also: org.aopalliance.intercept.MethodInterceptor
See Also: org.springframework.aop.Advisor
See Also: Advised |
| Field Summary | |
| final public static String | GLOBAL_SUFFIX
This suffix in a value in an interceptor list indicates to expand globals. | | final protected Log | logger
|
| GLOBAL_SUFFIX | | final public static String GLOBAL_SUFFIX(Code) | | This suffix in a value in an interceptor list indicates to expand globals.
|
| logger | | final protected Log logger(Code) | | |
| adviceChanged | | protected void adviceChanged()(Code) | | Blow away and recache singleton on an advice change.
|
| createCompositeInterface | | protected Class createCompositeInterface(Class[] interfaces)(Code) | | Create a composite interface Class for the given interfaces,
implementing the given interfaces in one single Class.
The default implementation builds a JDK proxy class for the
given interfaces.
Parameters:
interfaces - the interfaces to merge the merged interface as Class
See Also: java.lang.reflect.Proxy.getProxyClass |
| getObject | | public Object getObject() throws BeansException(Code) | | Return a proxy. Invoked when clients obtain beans from this factory bean.
Create an instance of the AOP proxy to be returned by this factory.
The instance will be cached for a singleton, and create on each call to
getObject() for a proxy.
a fresh AOP proxy reflecting the current state of this factory |
| getObjectType | | public Class getObjectType()(Code) | | Return the type of the proxy. Will check the singleton instance if
already created, else fall back to the proxy interface (in case of just
a single one), the target bean type, or the TargetSource's target class.
See Also: org.springframework.aop.TargetSource.getTargetClass |
| getProxy | | protected Object getProxy(AopProxy aopProxy)(Code) | | Return the proxy object to expose.
The default implementation uses a getProxy call with
the factory's bean class loader. Can be overridden to specify a
custom class loader.
Parameters:
aopProxy - the prepared AopProxy instance to get the proxy from the proxy object to expose
See Also: AopProxy.getProxy(ClassLoader) |
| isSingleton | | public boolean isSingleton()(Code) | | |
| setAutodetectInterfaces | | public void setAutodetectInterfaces(boolean autodetectInterfaces)(Code) | | Set whether to autodetect proxy interfaces if none specified.
Default is "true". Turn this flag off to create a CGLIB
proxy for the full target class if no interfaces specified.
See Also: ProxyFactoryBean.setProxyTargetClass |
| setFrozen | | public void setFrozen(boolean frozen)(Code) | | |
| setInterceptorNames | | public void setInterceptorNames(String[] interceptorNames)(Code) | | Set the list of Advice/Advisor bean names. This must always be set
to use this factory bean in a bean factory.
The referenced beans should be of type Interceptor, Advisor or Advice
The last entry in the list can be the name of any bean in the factory.
If it's neither an Advice nor an Advisor, a new SingletonTargetSource
is added to wrap it. Such a target bean cannot be used if the "target"
or "targetSource" or "targetName" property is set, in which case the
"interceptorNames" array must contain only Advice/Advisor bean names.
See Also: org.aopalliance.intercept.MethodInterceptor
See Also: org.springframework.aop.Advisor
See Also: org.aopalliance.aop.Advice
See Also: org.springframework.aop.target.SingletonTargetSource |
| setSingleton | | public void setSingleton(boolean singleton)(Code) | | Set the value of the singleton property. Governs whether this factory
should always return the same proxy instance (which implies the same target)
or whether it should return a new prototype instance, which implies that
the target and interceptors may be new instances also, if they are obtained
from prototype bean definitions. This allows for fine control of
independence/uniqueness in the object graph.
|
|
|
|