在Spring的AOP模块中，一个主要的部分是代理对象的生成，而对于Spring应用，可以看到，是通过配置和调用ProxyFactoryBean来完成这个任务的。
在ProxyFactoryBean中，封装了主要代理对象的生成过程。在生成过程可以使用两种方法，一种是JDK的Proxy，另一种是CGLIB。
以ProxyFactory的设计为中心，可以看到相关的类继承关系。
ProxyConfig作为共同的基类，它为各种子类提供了配置属性。
AdvisorSupport的实现中，封装了AOP对通知和通知器的相关操作，这些操作对于不同的AOP的代理对象的生成都是一样的，但
对于具体的AOP代理对象的创建，AdvisorSupport把它交给它的子类去完成。
ProxyCreatorSupport，可以将它看成是其子类创建AOP代理对象的辅助类。
具体AOP代理对象的生成，根据不同的需要，分别由AspectProxyFactory、ProxyFactory、ProxyFactoryBean来完成。
对于需要使用AspectJ的AOP应用，AspectProxyFactory起到Spring和AspectJ的集成。
ProxyFactoryBean，可以在IoC容器中完成声明式的配置。
ProxyFactory需要编程地使用Spring AOP的功能。
下面详细介绍从配置ProxyFactoryBean开始到具体的代理对象生成。
基于XML配置Spring
<bean id="testAdvisor" class="com.abc.TestAdvisor"/>
<bean id="testAOP" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>com.test.AbcInterface</value>
</property>
<property name="target">
<bean class="com.abc.TestTarget"/>
</property>
<property name="interceptorNames">
<list>
<value>testAdvisor</value>
</list>
</property>
</bean>行为，也就是Advice通知。
（2）定义ProxyFactoryBean，把它作为另一个bean来定义，它是封装AOP功能的主要类。在配置ProxyFactoryBean需要配置与其相关的属性：
interceptorNames属性的值往往设置为需要定义的通知器。这些通知器在ProxyFactoryBean配置下，是通过使用代理对象的拦截器机制起作用的。
作为target属性注入的bean，是需要用AOP通知器中的切面应用来增强的对象。
ProxyFactoryBean生成AopProxy代理对象
ProxyFactoryBean的AOP实现需要依赖JDK或者CGLIB提供的Proxy特性。从FactoryBean中获取对象，是以getObject方法作为入口完成的；
ProxyFactoryBean实现中的getObject方法，是FactoryBean需要实现的接口。对ProxyFactoryBean来说，把需要对target目标对象增加的增强处理，都通过
getObject方法进行封装了，这些增强处理是为AOP功能的实现提供服务的。
ProxyFactoryBean类中的getObject方法
@Override
public Object getObject() throws BeansException {
initializeAdvisorChain();//初始化通知器链，为Proxy代理对象配置Advisor链是在这个方法中完成的
//这里对singleton和prototyope的类型进行区分，生成对应的proxy
if (isSingleton()) {
return getSingletonInstance();
}
else {
if (this.targetName == null) {
logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
"Enable prototype proxies by setting the 'targetName' property.");
}
return newPrototypeInstance();
}
}
private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
if (this.advisorChainInitialized) {//这是一个标志位，用来表示通知器链是否已经初始化。如果初始化，这里就不再初始化，而是直接返回。
return; //也就是说初始化的工作发生在应用第一次通过ProxyFactoryBean去获取代理对象的时候。
}
if (!ObjectUtils.isEmpty(this.interceptorNames)) {
if (this.beanFactory == null) {
throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
"- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
}
if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) && this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
throw new AopConfigException("Target required after globals");
}
//这里是添加Advisor链的调用，是通过interceptorNames属性进行配置的
for (String name : this.interceptorNames) {
if (logger.isTraceEnabled()) {
logger.trace("Configuring advisor or advice '" + name + "'");
}
if (name.endsWith(GLOBAL_SUFFIX)) {
if (!(this.beanFactory instanceof ListableBeanFactory)) {
throw new AopConfigException(
"Can only use global advisors or interceptors with a ListableBeanFactory");
}
addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
}
else {
// 如果程序在这里被调用，那么需要加入命名的拦截器advice，并且需要检查这个Bean
// 是singleton还是prototype类型
Object advice;
if (this.singleton || this.beanFactory.isSingleton(name)) {
// 添加advice或者advisor
advice = this.beanFactory.getBean(name);
}
else {
// 对prototype类型Bean的处理
advice = new PrototypePlaceholderAdvisor(name);
}
addAdvisorOnChainCreation(advice, name);
}
}
}
this.advisorChainInitialized = true;
}代理对象会封装对target目标对象的调用，也就是说针对target对象的方法调用会被这里生成的代理对象所拦截。getSingletonInstance方法的具体实现为：
private synchronized Object getSingletonInstance() {
if (this.singletonInstance == null) {
this.targetSource = freshTargetSource();//首先读取ProxyFactoryBean中的配置
if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
//根据AOP框架来判断需要代理的接口
Class<?> targetClass = getTargetClass();
if (targetClass == null) {
throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
}
//这里设置代理对象的接口
setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
}
super.setFrozen(this.freezeProxy);
this.singletonInstance = getProxy(createAopProxy());//使用ProxyFactory来生成需要的Proxy
}
return this.singletonInstance;
}
protected Object getProxy(AopProxy aopProxy) {
return aopProxy.getProxy(this.proxyClassLoader);
} 子类，所以在ProxyFactoryBean中取得AopProxy是很方便的，而具体的AopProxy是通过AopProxyFactory来生成的。
createProxy()方法是ProxyCreatorSupport类中实现的：
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
//通过AopProxyFactory来创建AopProxy，AopProxyFactory是在初始化函数中定义的，使用的是DefaultAopProxyFactory
return getAopProxyFactory().createAopProxy(this);
}
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface()) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}在AopProxy代理对象的生成过程中，首先要从AdvisedSupport对象中取得配置的目标对象，这个目标对象是实现AOP功能所必需的。
AopProxy代理对象可以由JDK或CGLIB来生成，而JdkDynamicAopProxy和CglibAopProxy的实现都是通过AopProxy接口。
JDK生成AopProxy代理对象
@Override
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}CGLIB生成AopProxy代理对象
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
}
try {
Class<?> rootClass = this.advised.getTargetClass();
Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
Class<?> proxySuperClass = rootClass;
if (ClassUtils.isCglibProxyClass(rootClass)) {
proxySuperClass = rootClass.getSuperclass();
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
for (Class<?> additionalInterface : additionalInterfaces) {
this.advised.addInterface(additionalInterface);
}
}
// Validate the class, writing log messages as necessary.
validateClassIfNecessary(proxySuperClass);
// Configure CGLIB Enhancer...
Enhancer enhancer = createEnhancer();
if (classLoader != null) {
enhancer.setClassLoader(classLoader);
if (classLoader instanceof SmartClassLoader &&
((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
enhancer.setUseCache(false);
}
}
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new UndeclaredThrowableStrategy(UndeclaredThrowableException.class));
Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) {
types[x] = callbacks[x].getClass();
}
// fixedInterceptorMap only populated at this point, after getCallbacks call above
enhancer.setCallbackFilter(new ProxyCallbackFilter(
this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
// Generate the proxy class and create a proxy instance.
return createProxyClassAndInstance(enhancer, callbacks);
}
catch (CodeGenerationException ex) {
throw new AopConfigException("Could not generate CGLIB subclass of class [" +
this.advised.getTargetClass() + "]: " +
"Common causes of this problem include using a final class or a non-visible class",
ex);
}
catch (IllegalArgumentException ex) {
throw new AopConfigException("Could not generate CGLIB subclass of class [" +
this.advised.getTargetClass() + "]: " +
"Common causes of this problem include using a final class or a non-visible class",
ex);
}
catch (Exception ex) {
// TargetSource.getTarget() failed
throw new AopConfigException("Unexpected AOP exception", ex);
}
}这样，通过使用AopProxy对象封装target目标对象之后，ProxyFactoryBean的getObject方法得到的对象就不是一个普通的java对象，而是一个AopProxy代理对象。
在ProxyFactoryBean中配置的target目标对象，已经不会让应用直接调用其方法实现，而是作为AOP实现的一部分。对target目标对象的方法调用会首先被AopProxy代理对象
拦截，对不同的AopProxy代理对象生成方式，会使用不同的拦截回调入口。
796
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
