前言
前面写了六篇文章详细地分析了 Spring Bean 加载流程，这部分完了之后就要进入一个比较困难的部分了，就是 AOP 的实现原理分析。为了探究 AOP 实现原理，首先定义几个类，一个 Dao 接口：
public interface Dao {
public void select();
public void insert();}
Dao 接口的实现类 DaoImpl：
public class DaoImpl implements Dao {
@Override
public void select() {System.out.println("Enter DaoImpl.select()");
}
@Override
public void insert() {System.out.println("Enter DaoImpl.insert()");
}
}
定义一个 TimeHandler，用于方法调用前后打印时间，在 AOP 中，这扮演的是横切关注点的角色：
public class TimeHandler {public void printTime() {System.out.println("CurrentTime:" + System.currentTimeMillis());
}
}定义一个 XML 文件 aop.xml：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<bean id="daoImpl" class="org.xrq.action.aop.DaoImpl" />
<bean id="timeHandler" class="org.xrq.action.aop.TimeHandler" />
<aop:config proxy-target-class="true">
<aop:aspect id="time" ref="timeHandler">
<aop:pointcut id="addAllMethod" expression="execution(* org.xrq.action.aop.Dao.*(..))" />
<aop:before method="printTime" pointcut-ref="addAllMethod" />
<aop:after method="printTime" pointcut-ref="addAllMethod" />
</aop:aspect>
</aop:config>
</beans>写一段测试代码 TestAop.java：
public class TestAop {
@Test
public void testAop() {ApplicationContext ac = new ClassPathXmlApplicationContext("spring/aop.xml");
Dao dao = (Dao)ac.getBean("daoImpl");
dao.select();}
}代码运行结果就不看了，有了以上的内容，我们就可以根据这些跟一下代码，看看 Spring 到底是如何实现 AOP 的。
AOP 实现原理——找到 Spring 处理 AOP 的源头
有很多朋友不愿意去看 AOP 源码的一个很大原因是因为找不到 AOP 源码实现的入口在哪里，这个确实是。不过我们可以看一下上面的测试代码，就普通 Bean 也好、AOP 也好，最终都是通过 getBean 方法获取到 Bean 并调用方法的，getBean 之后的对象已经前后都打印了 TimeHandler 类 printTime()方法里面的内容，可以想见它们已经是被 Spring 容器处理过了。
既然如此，那无非就两个地方处理：
加载 Bean 定义的时候应该有过特殊的处理
getBean 的时候应该有过特殊的处理
因此，本文围绕【1. 加载 Bean 定义的时候应该有过特殊的处理】展开，先找一下到底是哪里 Spring 对 AOP 做了特殊的处理。代码直接定位到 DefaultBeanDefinitionDocumentReader 的 parseBeanDefinitions 方法：
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {if (delegate.isDefaultNamespace(root)) {NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);
if (node instanceof Element) {Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {parseDefaultElement(ele, delegate);
}
else {delegate.parseCustomElement(ele);
}
}
}
}
else {delegate.parseCustomElement(root);
}
}正常来说，遇到 <bean id=”daoImpl”…>、<bean id=”timeHandler”…> 这两个标签的时候，都会执行第 9 行的代码，因为 <bean> 标签是默认的 Namespace。但是在遇到后面的 <aop:config> 标签的时候就不一样了，<aop:config> 并不是默认的 Namespace，因此会执行第 12 行的代码，看一下：
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {String namespaceUri = getNamespaceURI(ele);
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
}
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}因为之前把整个 XML 解析为了 org.w3c.dom.Document，org.w3c.dom.Document 以树的形式表示整个 XML，具体到每一个节点就是一个 Node。
首先第 2 行从 <aop:config> 这个 Node（参数 Element 是 Node 接口的子接口）中拿到 Namespace=”http://www.springframework.or…“，第 3 行的代码根据这个 Namespace 获取对应的 NamespaceHandler 即 Namespace 处理器，具体到 aop 这个 Namespace 的 NamespaceHandler 是 org.springframework.aop.config.AopNamespaceHandler 类，也就是第 3 行代码获取到的结果。具体到 AopNamespaceHandler 里面，有几个 Parser，是用于具体标签转换的，分别为：
config–>ConfigBeanDefinitionParser
aspectj-autoproxy–>AspectJAutoProxyBeanDefinitionParser
scoped-proxy–>ScopedProxyBeanDefinitionDecorator
spring-configured–>SpringConfiguredBeanDefinitionParser
接着，就是第 8 行的代码，利用 AopNamespaceHandler 的 parse 方法，解析 <aop:config> 下的内容了。
解析增强器 advisor
AOP Bean 定义加载——根据织入方式将 <aop:before>、<aop:after> 转换成名为 adviceDef 的 RootBeanDefinition
上面经过分析，已经找到了 Spring 是通过 AopNamespaceHandler 处理的 AOP，那么接着进入 AopNamespaceHandler 的 parse 方法源代码：
public BeanDefinition parse(Element element, ParserContext parserContext) {return findParserForElement(element, parserContext).parse(element, parserContext);
}
首先获取具体的 Parser，因为当前节点是 <aop:config>，上一部分最后有列，config 是通过 ConfigBeanDefinitionParser 来处理的，因此 findParserForElement(element, parserContext)这一部分代码获取到的是 ConfigBeanDefinitionParser，接着看 ConfigBeanDefinitionParser 的 parse 方法：
public BeanDefinition parse(Element element, ParserContext parserContext) {
CompositeComponentDefinition compositeDef =
new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
parserContext.pushContainingComponent(compositeDef);
configureAutoProxyCreator(parserContext, element);
List<Element> childElts = DomUtils.getChildElements(element);
for (Element elt: childElts) {String localName = parserContext.getDelegate().getLocalName(elt);
if (POINTCUT.equals(localName)) {parsePointcut(elt, parserContext);
}
else if (ADVISOR.equals(localName)) {parseAdvisor(elt, parserContext);
}
else if (ASPECT.equals(localName)) {parseAspect(elt, parserContext);
}
}
parserContext.popAndRegisterContainingComponent();
return null;
}重点先提一下第 6 行的代码，该行代码的具体实现不跟了但它非常重要，configureAutoProxyCreator 方法的作用我用几句话说一下：
向 Spring 容器注册了一个 BeanName 为 org.springframework.aop.config.internalAutoProxyCreator 的 Bean 定义，可以自定义也可以使用 Spring 提供的（根据优先级来）
Spring 默认提供的是 org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator，这个类是 AOP 的核心类，留在下篇讲解
在这个方法里面也会根据配置 proxy-target-class 和 expose-proxy，设置是否使用 CGLIB 进行代理以及是否暴露最终的代理。
<aop:config> 下的节点为 <aop:aspect>，想见必然是执行第 18 行的代码 parseAspect，跟进去：
private void parseAspect(Element aspectElement, ParserContext parserContext) {String aspectId = aspectElement.getAttribute(ID);
String aspectName = aspectElement.getAttribute(REF);
try {this.parseState.push(new AspectEntry(aspectId, aspectName));
List<BeanDefinition> beanDefinitions = new ArrayList<BeanDefinition>();
List<BeanReference> beanReferences = new ArrayList<BeanReference>();
List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
for (int i = METHOD_INDEX; i < declareParents.size(); i++) {Element declareParentsElement = declareParents.get(i);
beanDefinitions.add(parseDeclareParents(declareParentsElement, parserContext));
}
// We have to parse "advice" and all the advice kinds in one loop, to get the
// ordering semantics right.
NodeList nodeList = aspectElement.getChildNodes();
boolean adviceFoundAlready = false;
for (int i = 0; i < nodeList.getLength(); i++) {Node node = nodeList.item(i);
if (isAdviceNode(node, parserContext)) {if (!adviceFoundAlready) {
adviceFoundAlready = true;
if (!StringUtils.hasText(aspectName)) {parserContext.getReaderContext().error(
"<aspect> tag needs aspect bean reference via'ref'attribute when declaring advices.",
aspectElement, this.parseState.snapshot());
return;
}
beanReferences.add(new RuntimeBeanReference(aspectName));
}
AbstractBeanDefinition advisorDefinition = parseAdvice(aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences);
beanDefinitions.add(advisorDefinition);
}
}
AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
parserContext.pushContainingComponent(aspectComponentDefinition);
List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);
for (Element pointcutElement : pointcuts) {parsePointcut(pointcutElement, parserContext);
}
parserContext.popAndRegisterContainingComponent();}
finally {this.parseState.pop();
}
}从第 20 行~ 第 37 行的循环开始关注这个方法。这个 for 循环有一个关键的判断就是第 22 行的 ifAdviceNode 判断，看下 ifAdviceNode 方法做了什么：
private boolean isAdviceNode(Node aNode, ParserContext parserContext) {if (!(aNode instanceof Element)) {return false;}
else {String name = parserContext.getDelegate().getLocalName(aNode);
return (BEFORE.equals(name) || AFTER.equals(name) || AFTER_RETURNING_ELEMENT.equals(name) ||
AFTER_THROWING_ELEMENT.equals(name) || AROUND.equals(name));
}
}
即这个 for 循环只用来处理 <aop:aspect> 标签下的 <aop:before>、<aop:after>、<aop:after-returning>、<aop:after-throwing method=””>、<aop:around method=””> 这五个标签的。
接着，如果是上述五种标签之一，那么进入第 33 行~ 第 34 行的 parseAdvice 方法：
private AbstractBeanDefinition parseAdvice(
String aspectName, int order, Element aspectElement, Element adviceElement, ParserContext parserContext,
List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {
try {this.parseState.push(new AdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));
// create the method factory bean
RootBeanDefinition methodDefinition = new RootBeanDefinition(MethodLocatingFactoryBean.class);
methodDefinition.getPropertyValues().add("targetBeanName", aspectName);
methodDefinition.getPropertyValues().add("methodName", adviceElement.getAttribute("method"));
methodDefinition.setSynthetic(true);
// create instance factory definition
RootBeanDefinition aspectFactoryDef =
new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class);
aspectFactoryDef.getPropertyValues().add("aspectBeanName", aspectName);
aspectFactoryDef.setSynthetic(true);
// register the pointcut
AbstractBeanDefinition adviceDef = createAdviceDefinition(
adviceElement, parserContext, aspectName, order, methodDefinition, aspectFactoryDef,
beanDefinitions, beanReferences);
// configure the advisor
RootBeanDefinition advisorDefinition = new RootBeanDefinition(AspectJPointcutAdvisor.class);
advisorDefinition.setSource(parserContext.extractSource(adviceElement));
advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
if (aspectElement.hasAttribute(ORDER_PROPERTY)) {advisorDefinition.getPropertyValues().add(ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));
}
// register the final advisor
parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);
return advisorDefinition;
}
finally {this.parseState.pop();
}
}方法主要做了三件事：
根据织入方式（before、after 这些）创建 RootBeanDefinition，名为 adviceDef 即 advice 定义
将上一步创建的 RootBeanDefinition 写入一个新的 RootBeanDefinition，构造一个新的对象，名为 advisorDefinition，即 advisor 定义
将 advisorDefinition 注册到 DefaultListableBeanFactory 中
下面来看做的第一件事 createAdviceDefinition 方法定义：
private AbstractBeanDefinition createAdviceDefinition(
Element adviceElement, ParserContext parserContext, String aspectName, int order,
RootBeanDefinition methodDef, RootBeanDefinition aspectFactoryDef,
List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {RootBeanDefinition adviceDefinition = new RootBeanDefinition(getAdviceClass(adviceElement, parserContext));
adviceDefinition.setSource(parserContext.extractSource(adviceElement));
adviceDefinition.getPropertyValues().add(ASPECT_NAME_PROPERTY, aspectName);
adviceDefinition.getPropertyValues().add(DECLARATION_ORDER_PROPERTY, order);
if (adviceElement.hasAttribute(RETURNING)) {adviceDefinition.getPropertyValues().add(RETURNING_PROPERTY, adviceElement.getAttribute(RETURNING));
}
if (adviceElement.hasAttribute(THROWING)) {adviceDefinition.getPropertyValues().add(THROWING_PROPERTY, adviceElement.getAttribute(THROWING));
}
if (adviceElement.hasAttribute(ARG_NAMES)) {adviceDefinition.getPropertyValues().add(ARG_NAMES_PROPERTY, adviceElement.getAttribute(ARG_NAMES));
}
ConstructorArgumentValues cav = adviceDefinition.getConstructorArgumentValues();
cav.addIndexedArgumentValue(METHOD_INDEX, methodDef);
Object pointcut = parsePointcutProperty(adviceElement, parserContext);
if (pointcut instanceof BeanDefinition) {cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcut);
beanDefinitions.add((BeanDefinition) pointcut);
}
else if (pointcut instanceof String) {RuntimeBeanReference pointcutRef = new RuntimeBeanReference((String) pointcut);
cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcutRef);
beanReferences.add(pointcutRef);
}
cav.addIndexedArgumentValue(ASPECT_INSTANCE_FACTORY_INDEX, aspectFactoryDef);
return adviceDefinition;
}首先可以看到，创建的 AbstractBeanDefinition 实例是 RootBeanDefinition，这和普通 Bean 创建的实例为 GenericBeanDefinition 不同。然后进入第 6 行的 getAdviceClass 方法看一下：
private Class getAdviceClass(Element adviceElement, ParserContext parserContext) {String elementName = parserContext.getDelegate().getLocalName(adviceElement);
if (BEFORE.equals(elementName)) {return AspectJMethodBeforeAdvice.class;}
else if (AFTER.equals(elementName)) {return AspectJAfterAdvice.class;}
else if (AFTER_RETURNING_ELEMENT.equals(elementName)) {return AspectJAfterReturningAdvice.class;}
else if (AFTER_THROWING_ELEMENT.equals(elementName)) {return AspectJAfterThrowingAdvice.class;}
else if (AROUND.equals(elementName)) {return AspectJAroundAdvice.class;}
else {throw new IllegalArgumentException("Unknown advice kind [" + elementName + "].");
}
}既然创建 Bean 定义，必然该 Bean 定义中要对应一个具体的 Class，不同的切入方式对应不同的 Class：
before 对应 AspectJMethodBeforeAdvice
After 对应 AspectJAfterAdvice
after-returning 对应 AspectJAfterReturningAdvice
after-throwing 对应 AspectJAfterThrowingAdvice
around 对应 AspectJAroundAdvice
createAdviceDefinition 方法剩余逻辑没什么，就是判断一下标签里面的属性并设置一下相应的值而已，至此 <aop:before>、<aop:after> 两个标签对应的 AbstractBeanDefinition 就创建出来了。
AOP Bean 定义加载——将名为 adviceDef 的 RootBeanDefinition 转换成名为 advisorDefinition 的 RootBeanDefinition
下面我们看一下第二步的操作，将名为 adviceDef 的 RootBeanD 转换成名为 advisorDefinition 的 RootBeanDefinition，跟一下上面一部分 ConfigBeanDefinitionParser 类 parseAdvice 方法的第 26 行~32 行的代码：
RootBeanDefinition advisorDefinition = new RootBeanDefinition(AspectJPointcutAdvisor.class);
advisorDefinition.setSource(parserContext.extractSource(adviceElement));
advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
if (aspectElement.hasAttribute(ORDER_PROPERTY)) {advisorDefinition.getPropertyValues().add(ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));
}这里相当于将上一步生成的 RootBeanDefinition 包装了一下，new 一个新的 RootBeanDefinition 出来，Class 类型是 org.springframework.aop.aspectj.AspectJPointcutAdvisor。
第 4 行~ 第 7 行的代码是用于判断 <aop:aspect> 标签中有没有”order”属性的，有就设置一下，”order”属性是用来控制切入方法优先级的。
AOP Bean 定义加载——将 BeanDefinition 注册到 DefaultListableBeanFactory 中
最后一步就是将 BeanDefinition 注册到 DefaultListableBeanFactory 中了，代码就是前面 ConfigBeanDefinitionParser 的 parseAdvice 方法的最后一部分了：
…
// register the final advisor
parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);
…
跟一下 registerWithGeneratedName 方法的实现：
public String registerWithGeneratedName(BeanDefinition beanDefinition) {String generatedName = generateBeanName(beanDefinition);
getRegistry().registerBeanDefinition(generatedName, beanDefinition);
return generatedName;
}第 2 行获取注册的名字 BeanName，和 <bean> 的注册差不多，使用的是 Class 全路径 +”#”+ 全局计数器的方式，其中的 Class 全路径为 org.springframework.aop.aspectj.AspectJPointcutAdvisor，依次类推，每一个 BeanName 应当为 org.springframework.aop.aspectj.AspectJPointcutAdvisor#0、org.springframework.aop.aspectj.AspectJPointcutAdvisor#1、org.springframework.aop.aspectj.AspectJPointcutAdvisor#2 这样下去。
第 3 行向 DefaultListableBeanFactory 中注册，BeanName 已经有了，剩下的就是 Bean 定义，Bean 定义的解析流程之前已经看过了，就不说了。
解析切面的过程
AOP Bean 定义加载——AopNamespaceHandler 处理 <aop:pointcut> 流程
回到 ConfigBeanDefinitionParser 的 parseAspect 方法：
private void parseAspect(Element aspectElement, ParserContext parserContext) {
...
AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
parserContext.pushContainingComponent(aspectComponentDefinition);
List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);
for (Element pointcutElement : pointcuts) {parsePointcut(pointcutElement, parserContext);
}
parserContext.popAndRegisterContainingComponent();}
finally {this.parseState.pop();
}
}省略号部分表示是解析的是 <aop:before>、<aop:after> 这种标签，上部分已经说过了，就不说了，下面看一下解析 <aop:pointcut> 部分的源码。
第 5 行~ 第 7 行的代码构建了一个 Aspect 标签组件定义，并将 Apsect 标签组件定义推到 ParseContext 即解析工具上下文中，这部分代码不是关键。
第 9 行的代码拿到所有 <aop:aspect> 下的 pointcut 标签，进行遍历，由 parsePointcut 方法进行处理：
private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) {String id = pointcutElement.getAttribute(ID);
String expression = pointcutElement.getAttribute(EXPRESSION);
AbstractBeanDefinition pointcutDefinition = null;
try {this.parseState.push(new PointcutEntry(id));
pointcutDefinition = createPointcutDefinition(expression);
pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));
String pointcutBeanName = id;
if (StringUtils.hasText(pointcutBeanName)) {parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition);
}
else {pointcutBeanName = parserContext.getReaderContext().registerWithGeneratedName(pointcutDefinition);
}
parserContext.registerComponent(new PointcutComponentDefinition(pointcutBeanName, pointcutDefinition, expression));
}
finally {this.parseState.pop();
}
return pointcutDefinition;
}第 2 行~ 第 3 行的代码获取 <aop:pointcut> 标签下的”id”属性与”expression”属性。
第 8 行的代码推送一个 PointcutEntry，表示当前 Spring 上下文正在解析 Pointcut 标签。
第 9 行的代码创建 Pointcut 的 Bean 定义，之后再看，先把其他方法都看一下。
第 10 行的代码不管它，最终从 NullSourceExtractor 的 extractSource 方法获取 Source，就是个 null。
第 12 行~ 第 18 行的代码用于注册获取到的 Bean 定义，默认 pointcutBeanName 为 <aop:pointcut> 标签中定义的 id 属性：
如果 <aop:pointcut> 标签中配置了 id 属性就执行的是第 13 行~ 第 15 行的代码，pointcutBeanName=id
如果 <aop:pointcut> 标签中没有配置 id 属性就执行的是第 16 行~ 第 18 行的代码，和 Bean 不配置 id 属性一样的规则，pointcutBeanName=org.springframework.aop.aspectj.AspectJExpressionPointcut# 序号（从 0 开始累加）
第 20 行~ 第 21 行的代码向解析工具上下文中注册一个 Pointcut 组件定义
第 23 行~ 第 25 行的代码，finally 块在 <aop:pointcut> 标签解析完毕后，让之前推送至栈顶的 PointcutEntry 出栈，表示此次 <aop:pointcut> 标签解析完毕。
最后回头来一下第 9 行代码 createPointcutDefinition 的实现，比较简单：
protected AbstractBeanDefinition createPointcutDefinition(String expression) {RootBeanDefinition beanDefinition = new RootBeanDefinition(AspectJExpressionPointcut.class);
beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
beanDefinition.setSynthetic(true);
beanDefinition.getPropertyValues().add(EXPRESSION, expression);
return beanDefinition;
}关键就是注意一下两点：
<aop:pointcut> 标签对应解析出来的 BeanDefinition 是 RootBeanDefinition，且 RootBenaDefinitoin 中的 Class 是 org.springframework.aop.aspectj.AspectJExpressionPointcut
<aop:pointcut> 标签对应的 Bean 是 prototype 即原型的
这样一个流程下来，就解析了 <aop:pointcut> 标签中的内容并将之转换为 RootBeanDefintion 存储在 Spring 容器中。
AOP 为 Bean 生成代理的时机分析
上篇文章说了，org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator 这个类是 Spring 提供给开发者的 AOP 的核心类，就是 AspectJAwareAdvisorAutoProxyCreator 完成了【类 / 接口–> 代理】的转换过程，首先我们看一下 AspectJAwareAdvisorAutoProxyCreator 的层次结构：
这里最值得注意的一点是最左下角的那个方框，我用几句话总结一下：
AspectJAwareAdvisorAutoProxyCreator 是 BeanPostProcessor 接口的实现类
postProcessBeforeInitialization 方法与 postProcessAfterInitialization 方法实现在父类 AbstractAutoProxyCreator 中
postProcessBeforeInitialization 方法是一个空实现
逻辑代码在 postProcessAfterInitialization 方法中
基于以上的分析，将 Bean 生成代理的时机已经一目了然了：在每个 Bean 初始化之后，如果需要，调用 AspectJAwareAdvisorAutoProxyCreator 中的 postProcessBeforeInitialization 为 Bean 生成代理。
代理对象实例化—- 判断是否为 <bean> 生成代理
上文分析了 Bean 生成代理的时机是在每个 Bean 初始化之后，下面把代码定位到 Bean 初始化之后，先是 AbstractAutowireCapableBeanFactory 的 initializeBean 方法进行初始化：
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {if (System.getSecurityManager() != null) {AccessController.doPrivileged(new PrivilegedAction<Object>() {public Object run() {invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}初始化之前是第 16 行的 applyBeanPostProcessorsBeforeInitialization 方法，初始化之后即 29 行的 applyBeanPostProcessorsAfterInitialization 方法：
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {return result;}
}
return result;
}这里调用每个 BeanPostProcessor 的 postProcessBeforeInitialization 方法。按照之前的分析，看一下 AbstractAutoProxyCreator 的 postProcessAfterInitialization 方法实现：
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if (bean != null) {Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}跟一下第 5 行的方法 wrapIfNecessary：
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {if (this.targetSourcedBeans.contains(beanName)) {return bean;}
if (this.nonAdvisedBeans.contains(cacheKey)) {return bean;}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {this.nonAdvisedBeans.add(cacheKey);
return bean;
}
// Create proxy if we have advice.
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {this.advisedBeans.add(cacheKey);
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.nonAdvisedBeans.add(cacheKey);
return bean;
}第 2 行~ 第 11 行是一些不需要生成代理的场景判断，这里略过。首先我们要思考的第一个问题是：哪些目标对象需要生成代理？因为配置文件里面有很多 Bean，肯定不能对每个 Bean 都生成代理，因此需要一套规则判断 Bean 是不是需要生成代理，这套规则就是第 14 行的代码 getAdvicesAndAdvisorsForBean：
protected List<Advisor> findEligibleAdvisors(Class beanClass, String beanName) {List<Advisor> candidateAdvisors = findCandidateAdvisors();
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}顾名思义，方法的意思是为指定 class 寻找合适的 Advisor。
第 2 行代码，寻找候选 Advisors，根据上文的配置文件，有两个候选 Advisor，分别是 <aop:aspect> 节点下的 <aop:before> 和 <aop:after> 这两个，这两个在 XML 解析的时候已经被转换生成了 RootBeanDefinition。
跳过第 3 行的代码，先看下第 4 行的代码 extendAdvisors 方法，之后再重点看一下第 3 行的代码。第 4 行的代码 extendAdvisors 方法作用是向候选 Advisor 链的开头（也就是 List.get(0)的位置）添加一个 org.springframework.aop.support.DefaultPointcutAdvisor。
第 3 行代码，根据候选 Advisors，寻找可以使用的 Advisor，跟一下方法实现：
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {if (candidateAdvisors.isEmpty()) {return candidateAdvisors;}
List<Advisor> eligibleAdvisors = new LinkedList<Advisor>();
for (Advisor candidate : candidateAdvisors) {if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {eligibleAdvisors.add(candidate);
}
}
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
for (Advisor candidate : candidateAdvisors) {if (candidate instanceof IntroductionAdvisor) {
// already processed
continue;
}
if (canApply(candidate, clazz, hasIntroductions)) {eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}整个方法的主要判断都围绕 canApply 展开方法：
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {if (advisor instanceof IntroductionAdvisor) {return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
else if (advisor instanceof PointcutAdvisor) {PointcutAdvisor pca = (PointcutAdvisor) advisor;
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
// It doesn't have a pointcut so we assume it applies.
return true;
}
}第一个参数 advisor 的实际类型是 AspectJPointcutAdvisor，它是 PointcutAdvisor 的子类，因此执行第 7 行的方法：
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {if (!pc.getClassFilter().matches(targetClass)) {return false;}
MethodMatcher methodMatcher = pc.getMethodMatcher();
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
}
Set<Class> classes = new HashSet<Class>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
classes.add(targetClass);
for (Class<?> clazz : classes) {Method[] methods = clazz.getMethods();
for (Method method : methods) {
if ((introductionAwareMethodMatcher != null &&
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
methodMatcher.matches(method, targetClass)) {return true;}
}
}
return false;
}这个方法其实就是拿当前 Advisor 对应的 expression 做了两层判断：
目标类必须满足 expression 的匹配规则
目标类中的方法必须满足 expression 的匹配规则，当然这里方法不是全部需要满足 expression 的匹配规则，有一个方法满足即可
如果以上两条都满足，那么容器则会判断该 <bean> 满足条件，需要被生成代理对象，具体方式为返回一个数组对象，该数组对象中存储的是 <bean> 对应的 Advisor。
代理对象实例化过程
代理对象实例化—- 为 <bean> 生成代理代码上下文梳理
上文分析了为 <bean> 生成代理的条件，现在就正式看一下 Spring 上下文是如何为 <bean> 生成代理的。回到 AbstractAutoProxyCreator 的 wrapIfNecessary 方法：
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {if (this.targetSourcedBeans.contains(beanName)) {return bean;}
if (this.nonAdvisedBeans.contains(cacheKey)) {return bean;}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {this.nonAdvisedBeans.add(cacheKey);
return bean;
}
// Create proxy if we have advice.
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {this.advisedBeans.add(cacheKey);
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.nonAdvisedBeans.add(cacheKey);
return bean;
}第 14 行拿到 <bean> 对应的 Advisor 数组，第 15 行判断只要 Advisor 数组不为空，那么就会通过第 17 行的代码为 <bean> 创建代理：
protected Object createProxy(Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {ProxyFactory proxyFactory = new ProxyFactory();
// Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
proxyFactory.copyFrom(this);
if (!shouldProxyTargetClass(beanClass, beanName)) {
// Must allow for introductions; can't just set interfaces to
// the target's interfaces only.
Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
for (Class<?> targetInterface : targetInterfaces) {proxyFactory.addInterface(targetInterface);
}
}
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
for (Advisor advisor : advisors) {proxyFactory.addAdvisor(advisor);
}
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {proxyFactory.setPreFiltered(true);
}
return proxyFactory.getProxy(this.proxyClassLoader);
}第 4 行~ 第 6 行 new 出了一个 ProxyFactory，Proxy，顾名思义，代理工厂的意思，提供了简单的方式使用代码获取和配置 AOP 代理。
第 8 行的代码做了一个判断，判断的内容是 <aop:config> 这个节点中 proxy-target-class=”false”或者 proxy-target-class 不配置，即不使用 CGLIB 生成代理。如果满足条件，进判断，获取当前 Bean 实现的所有接口，讲这些接口 Class 对象都添加到 ProxyFactory 中。
第 17 行~ 第 28 行的代码没什么看的必要，向 ProxyFactory 中添加一些参数而已。重点看第 30 行 proxyFactory.getProxy(this.proxyClassLoader)这句：
public Object getProxy(ClassLoader classLoader) {return createAopProxy().getProxy(classLoader);
}实现代码就一行，但是却明确告诉我们做了两件事情：
创建 AopProxy 接口实现类
通过 AopProxy 接口的实现类的 getProxy 方法获取 <bean> 对应的代理
就从这两个点出发，分两部分分析一下。
代理对象实例化—- 创建 AopProxy 接口实现类
看一下 createAopProxy()方法的实现，它位于 DefaultAopProxyFactory 类中：
protected final synchronized AopProxy createAopProxy() {if (!this.active) {activate();
}
return getAopProxyFactory().createAopProxy(this);
}前面的部分没什么必要看，直接进入重点即 createAopProxy 方法：
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);
}
if (!cglibAvailable) {
throw new AopConfigException(
"Cannot proxy target class because CGLIB2 is not available." +
"Add CGLIB to the class path or specify proxy interfaces.");
}
return CglibProxyFactory.createCglibProxy(config);
}
else {return new JdkDynamicAopProxy(config);
}
}平时我们说 AOP 原理三句话就能概括：
对类生成代理使用 CGLIB
对接口生成代理使用 JDK 原生的 Proxy
可以通过配置文件指定对接口使用 CGLIB 生成代理
这三句话的出处就是 createAopProxy 方法。看到默认是第 19 行的代码使用 JDK 自带的 Proxy 生成代理，碰到以下三种情况例外：
ProxyConfig 的 isOptimize 方法为 true，这表示让 Spring 自己去优化而不是用户指定
ProxyConfig 的 isProxyTargetClass 方法为 true，这表示配置了 proxy-target-class=”true”
ProxyConfig 满足 hasNoUserSuppliedProxyInterfaces 方法执行结果为 true，这表示 <bean> 对象没有实现任何接口或者实现的接口是 SpringProxy 接口
在进入第 2 行的 if 判断之后再根据目标 <bean> 的类型决定返回哪种 AopProxy。简单总结起来就是：
proxy-target-class 没有配置或者 proxy-target-class=”false”，返回 JdkDynamicAopProxy
proxy-target-class=”true”或者 <bean> 对象没有实现任何接口或者只实现了 SpringProxy 接口，返回 Cglib2AopProxy
当然，不管是 JdkDynamicAopProxy 还是 Cglib2AopProxy，AdvisedSupport 都是作为构造函数参数传入的，里面存储了具体的 Advisor。
代理对象实例化—- 通过 getProxy 方法获取 <bean> 对应的代理
其实代码已经分析到了 JdkDynamicAopProxy 和 Cglib2AopProxy，剩下的就没什么好讲的了，无非就是看对这两种方式生成代理的熟悉程度而已。
Cglib2AopProxy 生成代理的代码就不看了，对 Cglib 不熟悉的朋友可以看 Cglib 及其基本使用一文。
JdkDynamicAopProxy 生成代理的方式稍微看一下：
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);}
这边解释一下第 5 行和第 6 行的代码，第 5 行代码的作用是拿到所有要代理的接口，第 6 行代码的作用是尝试寻找这些接口方法里面有没有 equals 方法和 hashCode 方法，同时都有的话打个标记，寻找结束，equals 方法和 hashCode 方法有特殊处理。
最终通过第 7 行的 Proxy.newProxyInstance 方法获取接口 / 类对应的代理对象，Proxy 是 JDK 原生支持的生成代理的方式。
代理方法调用原理
前面已经详细分析了为接口 / 类生成代理的原理，生成代理之后就要调用方法了，这里看一下使用 JdkDynamicAopProxy 调用方法的原理。
由于 JdkDynamicAopProxy 本身实现了 InvocationHandler 接口，因此具体代理前后处理的逻辑在 invoke 方法中：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Class targetClass = null;
Object target = null;
try {if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {// The target does not implement the hashCode() method itself.
return hashCode();}
if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// May be null. Get as late as possible to minimize the time we "own" the target,
// in case it comes from a pool.
target = targetSource.getTarget();
if (target != null) {targetClass = target.getClass();
}
// Get the interception chain for this method.
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// Check whether we have any advice. If we don't, we can fallback on direct
// reflective invocation of the target, and avoid creating a MethodInvocation.
if (chain.isEmpty()) {
// We can skip creating a MethodInvocation: just invoke the target directly
// Note that the final invoker must be an InvokerInterceptor so we know it does
// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
// We need to create a method invocation...
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();}
// Massage return value if necessary.
if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this" and the return type of the method
// is type-compatible. Note that we can't help if the target sets
// a reference to itself in another returned object.
retVal = proxy;
}
return retVal;
}
finally {if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
第 11 行~ 第 18 行的代码，表示 equals 方法与 hashCode 方法即使满足 expression 规则，也不会为之产生代理内容，调用的是 JdkDynamicAopProxy 的 equals 方法与 hashCode 方法。至于这两个方法是什么作用，可以自己查看一下源代码。
第 19 行~ 第 23 行的代码，表示方法所属的 Class 是一个接口并且方法所属的 Class 是 AdvisedSupport 的父类或者父接口，直接通过反射调用该方法。
第 27 行~ 第 30 行的代码，是用于判断是否将代理暴露出去的，由 <aop:config> 标签中的 expose-proxy=”true/false”配置。
第 41 行的代码，获取 AdvisedSupport 中的所有拦截器和动态拦截器列表，用于拦截方法，具体到我们的实际代码，列表中有三个 Object，分别是：
chain.get(0)：ExposeInvocationInterceptor，这是一个默认的拦截器，对应的原 Advisor 为 DefaultPointcutAdvisor
chain.get(1)：MethodBeforeAdviceInterceptor，用于在实际方法调用之前的拦截，对应的原 Advisor 为 AspectJMethodBeforeAdvice
chain.get(2)：AspectJAfterAdvice，用于在实际方法调用之后的处理
第 45 行~ 第 50 行的代码，如果拦截器列表为空，很正常，因为某个类 / 接口下的某个方法可能不满足 expression 的匹配规则，因此此时通过反射直接调用该方法。
第 51 行~ 第 56 行的代码，如果拦截器列表不为空，按照注释的意思，需要一个 ReflectiveMethodInvocation，并通过 proceed 方法对原方法进行拦截，proceed 方法感兴趣的朋友可以去看一下，里面使用到了递归的思想对 chain 中的 Object 进行了层层的调用。
CGLIB 代理实现
下面我们来看一下 CGLIB 代理的方式，这里需要读者去了解一下 CGLIB 以及其创建代理的方式：
这里将拦截器链封装到了 DynamicAdvisedInterceptor 中，并加入了 Callback，DynamicAdvisedInterceptor 实现了 CGLIB 的 MethodInterceptor，所以其核心逻辑在 intercept 方法中：
这里我们看到了与 JDK 动态代理同样的获取拦截器链的过程，并且 CglibMethodInvokcation 继承了我们在 JDK 动态代理看到的 ReflectiveMethodInvocation，但是并没有重写其 proceed 方法，只是重写了执行目标方法的逻辑，所以整体上是大同小异的。
到这里，整个 Spring 动态 AOP 的源码就分析完了，Spring 还支持静态 AOP，这里就不过多赘述了，有兴趣的读者可以查阅相关资料来学习。
微信公众号【黄小斜】作者是蚂蚁金服 JAVA 工程师，专注于 JAVA
后端技术栈：SpringBoot、SSM 全家桶、MySQL、分布式、中间件、微服务，同时也懂点投资理财，坚持学习和写作，相信终身学习的力量！关注公众号后回复”架构师“即可领取
Java 基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的 Java 学习指南、Java 程序员面试指南等干货资源