本文将对SpringAop中如何为AspectJ切面类创建自动代理的过程作下简单的分析，阅读本文前需要对AOP的Spring相关解析有所了解，具体可见Spring源码情操陶冶-AOP之ConfigBeanDefinitionParser解析器
官方注释
注释内容如下
/**
* {@link org.springframework.aop.framework.autoproxy.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.
*
* @author Adrian Colyer
* @author Juergen Hoeller
* @author Ramnivas Laddad
* @since 2.0
*/
从注释上可知此类是org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator抽象类的继承类，主要为AspectJ切面服务。具体的针对如何创建代理，肯定是在父类中实现了，我们在此研究下父类。
AbstractAutoProxyCreator-AOP代理实现的抽象父类
继承结构上为extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware，而其中的SmartInstantiationAwareBeanPostProcessor是beanPostProcessor接口的子类，此处注意下此接口。下面分析的内容建立在spring在实例化bean对象的时候会调用beanPostProcessor的公有接口。
AbstractAutoProxyCreator#postProcessAfterInitialization()-创建代理的入口函数
先奉上源码内容如下
/**
* Create a proxy with the configured interceptors if the bean is
* identified as one to proxy by the subclass.
* @see #getAdvicesAndAdvisorsForBean
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 如果缓存中不存在则调用wrapIfNecessary()方法创建代理
if (!this.earlyProxyReferences.contains(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
以上调用的是beanPostProcessor接口的postProcessAfterInitialization(Object bean,String beanName)的方法，其一般是bean对象被实例化的最后一步操作的，此处避而不谈了，我们转而查看wrapIfNecessary()的内部是如何操作的
AbstractAutoProxyCreator#wrapIfNecessary()-创建代理对象帮助函数
/**
* Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
* @param bean the raw bean instance
* @param beanName the name of the bean
* @param cacheKey the cache key for metadata access
* @return a proxy wrapping the bean, or the raw bean instance as-is
*/
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 查看缓存是否存在此bean
if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// Advice/Advisor/AopInfrastructureBean接口的beanClass不进行代理以及对beanName为aop内的切面名也不进行代理，此处可查看子类复写的sholdSkip()方法
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
// 查找对代理类相关的advisor对象集合，此处就与ponit-cut表达式有关了
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
// 对相应的advisor不为空才采取代理
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 调用createProxy()方法创建真正的代理对象
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
对上述的源码分析作下简单的总结
首先对
Advice/Advisor/AopInfrastructureBean接口的实现类不进行代理操作；对beanName为aspectName的bean对象也不采取代理操作再而需要查找beanClass有几个advisor与之相关联，这当然与每个
Advisor接口内的PointCut对象对应的表达式expression有关。只有关联的Advisor个数不为0，才可采取代理(此处查找Advisor关联个数的源码读者可自行分析AspectJAwareAdvisorAutoProxyCreator#shouldSkip()方法)真正的代理操作是由
AbstractAutoProxyCreator#createProxy()内部方法实现
AbstractAutoProxyCreator#createProxy()-创建真正的AOP代理
对符合条件的beanClass进行相应的代理操作，简单看下源码
/**
* Create an AOP proxy for the given bean.
* @param beanClass the class of the bean
* @param beanName the name of the bean
* @param specificInterceptors the set of interceptors that is
* specific to this bean (may be empty, but not null)
* @param targetSource the TargetSource for the proxy,
* already pre-configured to access the bean
* @return the AOP proxy for the bean
* @see #buildAdvisors
*/
protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
// 创建AOP代理工厂，拷贝相同的属性
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
// 是否采用动态代理
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
// 查看beanClass对应的类是否含有InitializingBean.class/DisposableBean.class/Aware.class接口，无则采用静态代理，有则采用动态代理
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
// 获得所有关联的Advisor集合
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
for (Advisor advisor : advisors) {
proxyFactory.addAdvisor(advisor);
}
// 此处的targetSource一般为SingletonTargetSource
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
// 是否设置预过滤模式，此处针对本文为true
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
return proxyFactory.getProxy(getProxyClassLoader());
}
对以上的源码也作下简单的总结
采用ProxyFactory对象来创建代理对象
如果AOP没有指定proxyTargetClass属性，则针对beanClass含有非
InitializingBean/DisposableBean/Aware接口的bean采用静态代理，反之采用动态代理ProxyFactory创建代理对象前也需要设置与beanClass相关联的advisor集合
ProxyFactory#getProxy()-最终创建代理类
public Object getProxy(ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
以上的源码我们只需要关注createAopProxy()方法即可，此处我们直接查看DefaultAopProxyFactory#createAopProxy()源码，参考如下
@Override
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() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
上述源码很简单，默认是采用JDK静态代理，对beanClass为非接口实现类采取CGLIB动态代理
小结
循序渐进的分析的总结见以上的各部分小结，我们只需要知道AOP代理的beanClass必须有相应的
Advisor接口与之绑定，才会创建AOP代理创建的代理类无非是JDK代理抑或是CGLIB代理，但是具体关联的
Advisor集合的处理逻辑见下文讲解