spring 中 AspectJ 基于 XML 的实现分析

前面的文章介绍了 spring 引入 AspectJ 之后，基于注解实现 AOP 的过程分析，本日我们来看下AspectJ 基于 XML 的 AOP 实现逻辑。
XML 的实现示例可以参考 AspectJ 对于 AOP 的实现。
aop:config 标签解析

先去 spring-aop 模块下，META-INF/spring.handlers 中查看 aop 定名空间对应的处置惩罚器为 AopNamespaceHandler。在 AopNamespaceHandler#init 方法中发现为 config 标签注册的解析器为 org.springframework.aop.config.ConfigBeanDefinitionParser。

1. // ConfigBeanDefinitionParser
2. @Override
3. @Nullable
4. public BeanDefinition parse(Element element, ParserContext parserContext) {
5.         CompositeComponentDefinition compositeDef =
6.                         new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
7.         parserContext.pushContainingComponent(compositeDef);
9.         // 配置自动代理生成器
10.         configureAutoProxyCreator(parserContext, element);
12.         // 解析 aop:config 子节点
13.         List<Element> childElts = DomUtils.getChildElements(element);
14.         for (Element elt: childElts) {
15.                 String localName = parserContext.getDelegate().getLocalName(elt);
16.                 if (POINTCUT.equals(localName)) {
17.                         parsePointcut(elt, parserContext);
18.                 }
19.                 else if (ADVISOR.equals(localName)) {
20.                         parseAdvisor(elt, parserContext);
21.                 }
22.                 else if (ASPECT.equals(localName)) {
23.                         parseAspect(elt, parserContext);
24.                 }
25.         }
27.         parserContext.popAndRegisterContainingComponent();
28.         return null;
29. }

复制代码

主要逻辑如下：

• 配置主动署理生成器
  
• 解析 aop:config 标签子节点
  

配置主动署理生成器

1. private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
2.         AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
3. }
4. public static void registerAspectJAutoProxyCreatorIfNecessary(
5.                 ParserContext parserContext, Element sourceElement) {
6.         // 注册一个 beanClass 为 AspectJAwareAdvisorAutoProxyCreator 的 BeanDefinition
7.         BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
8.                         parserContext.getRegistry(), parserContext.extractSource(sourceElement));
9.         // 处理 proxy-target-class 和 expose-proxy 两个属性
10.         useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
11.         registerComponentIfNecessary(beanDefinition, parserContext);
12. }
13. @Nullable
14. public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(
15.                 BeanDefinitionRegistry registry, @Nullable Object source) {
17.         return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
18. }

复制代码

实在就是在 BeanFactory 中注册一个 beanClass 为 AspectJAwareAdvisorAutoProxyCreator 的 BeanDefinition，假如 aop:config 设置了 proxy-target-class 和 expose-proxy 两个属性，则为这个注册的 BeanDefinition 也设置这两个属性，添加 proxyTargetClass 和 exposeProxy 到 propertyValues 中，供 bean 对象创建时使用。
解析 config 标签子节点

aop:config 共支持三种类型的子节点。分别如下：

• pointcut 定义切入点，配置切入点表达式
  
• advisor 自定义 Advisor，需要一个 Advice
  
• aspect 需对应一个切面类
  

在 ConfigBeanDefinitionParser#parse 中定义了三个分支分别解析对应的子节点 。
pointcut

1. // ConfigBeanDefinitionParser
2. private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) {
3.         // 获取 pointcut 标签 id 和 expression 两个属性
4.         String id = pointcutElement.getAttribute(ID);
5.         String expression = pointcutElement.getAttribute(EXPRESSION);
7.         AbstractBeanDefinition pointcutDefinition = null;
9.         try {
10.                 this.parseState.push(new PointcutEntry(id));
11.                 // 一个 pointcut 标签对应一个 AspectJExpressionPointcut
12.                 pointcutDefinition = createPointcutDefinition(expression);
13.                 pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));
15.                 // 将配置 id 作为 beanName，注册创建的 BeanDefinition，不存在 id，会生成一个 beanName 之后，进行注册
16.                 String pointcutBeanName = id;
17.                 if (StringUtils.hasText(pointcutBeanName)) {
18.                         parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition);
19.                 }
20.                 else {
21.                         pointcutBeanName = parserContext.getReaderContext().registerWithGeneratedName(pointcutDefinition);
22.                 }
24.                 parserContext.registerComponent(
25.                                 new PointcutComponentDefinition(pointcutBeanName, pointcutDefinition, expression));
26.         }
27.         finally {
28.                 this.parseState.pop();
29.         }
31.         return pointcutDefinition;
32. }
34. // 创建 beanClass 为 AspectJExpressionPointcut 的 BeanDefinition
35. protected AbstractBeanDefinition createPointcutDefinition(String expression) {
36.         RootBeanDefinition beanDefinition = new RootBeanDefinition(AspectJExpressionPointcut.class);
37.         beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
38.         beanDefinition.setSynthetic(true);
39.         beanDefinition.getPropertyValues().add(EXPRESSION, expression);
40.         return beanDefinition;
41. }

复制代码

解析 pointcut 标签目的，就是创建 beanClass 为 AspectJExpressionPointcut 的 BeanDefinition 进行注册。我们知道，AspectJExpressionPointcut 是连接 spring 和 AspectJ 的桥梁，必须需要一个切入点表达式，以是可以看到为注册的 BeanDefinition 设置了一个 expression 属性。
advisor

1. // ConfigBeanDefinitionParser
2. private void parseAdvisor(Element advisorElement, ParserContext parserContext) {
3.         // advisor --> BeanDefinition
4.         AbstractBeanDefinition advisorDef = createAdvisorBeanDefinition(advisorElement, parserContext);
5.         String id = advisorElement.getAttribute(ID);
7.         try {
8.                 this.parseState.push(new AdvisorEntry(id));
9.                 // 注册
10.                 String advisorBeanName = id;
11.                 if (StringUtils.hasText(advisorBeanName)) {
12.                         parserContext.getRegistry().registerBeanDefinition(advisorBeanName, advisorDef);
13.                 }
14.                 else {
15.                         advisorBeanName = parserContext.getReaderContext().registerWithGeneratedName(advisorDef);
16.                 }
17.                
18.                 // 解析 advisor 标签下的 pointcut 属性，为 advisorDef 设置属性
19.                 Object pointcut = parsePointcutProperty(advisorElement, parserContext);
20.                 if (pointcut instanceof BeanDefinition) {
21.                         advisorDef.getPropertyValues().add(POINTCUT, pointcut);
22.                         parserContext.registerComponent(
23.                                         new AdvisorComponentDefinition(advisorBeanName, advisorDef, (BeanDefinition) pointcut));
24.                 }
25.                 else if (pointcut instanceof String) {
26.                         advisorDef.getPropertyValues().add(POINTCUT, new RuntimeBeanReference((String) pointcut));
27.                         parserContext.registerComponent(
28.                                         new AdvisorComponentDefinition(advisorBeanName, advisorDef));
29.                 }
30.         }
31.         finally {
32.                 this.parseState.pop();
33.         }
34. }
36. private AbstractBeanDefinition createAdvisorBeanDefinition(Element advisorElement, ParserContext parserContext) {
37.         RootBeanDefinition advisorDefinition = new RootBeanDefinition(DefaultBeanFactoryPointcutAdvisor.class);
38.         advisorDefinition.setSource(parserContext.extractSource(advisorElement));
40.         // advice-ref，必须存在，不存在报错
41.         String adviceRef = advisorElement.getAttribute(ADVICE_REF);
42.         if (!StringUtils.hasText(adviceRef)) {
43.                 parserContext.getReaderContext().error(
44.                                 "'advice-ref' attribute contains empty value.", advisorElement, this.parseState.snapshot());
45.         }
46.         else {
47.                 advisorDefinition.getPropertyValues().add(
48.                                 ADVICE_BEAN_NAME, new RuntimeBeanNameReference(adviceRef));
49.         }
51.         // order
52.         if (advisorElement.hasAttribute(ORDER_PROPERTY)) {
53.                 advisorDefinition.getPropertyValues().add(
54.                                 ORDER_PROPERTY, advisorElement.getAttribute(ORDER_PROPERTY));
55.         }
57.         return advisorDefinition;
58. }
61. @Nullable
62. private Object parsePointcutProperty(Element element, ParserContext parserContext) {
63.         // pointcut 和 pointcut-ref 只能存在一个
64.         if (element.hasAttribute(POINTCUT) && element.hasAttribute(POINTCUT_REF)) {
65.                 parserContext.getReaderContext().error(
66.                                 "Cannot define both 'pointcut' and 'pointcut-ref' on <advisor> tag.",
67.                                 element, this.parseState.snapshot());
68.                 return null;
69.         }
70.         else if (element.hasAttribute(POINTCUT)) {
71.                 // pointcut 直接创建一个 beanClass 为 AspectJExpressionPointcut 的 BeanDefinition，此时 pointcut 配置的是切入点表达式
72.                 String expression = element.getAttribute(POINTCUT);
73.                 AbstractBeanDefinition pointcutDefinition = createPointcutDefinition(expression);
74.                 pointcutDefinition.setSource(parserContext.extractSource(element));
75.                 return pointcutDefinition;
76.         }
77.         else if (element.hasAttribute(POINTCUT_REF)) {
78.                 String pointcutRef = element.getAttribute(POINTCUT_REF);
79.                 if (!StringUtils.hasText(pointcutRef)) {
80.                         parserContext.getReaderContext().error(
81.                                         "'pointcut-ref' attribute contains empty value.", element, this.parseState.snapshot());
82.                         return null;
83.                 }
84.                 return pointcutRef;
85.         }
86.         else {
87.                 parserContext.getReaderContext().error(
88.                                 "Must define one of 'pointcut' or 'pointcut-ref' on <advisor> tag.",
89.                                 element, this.parseState.snapshot());
90.                 return null;
91.         }
92. }

复制代码

创建 beanClass 为 DefaultBeanFactoryPointcutAdvisor 的 BeanDefinition，之后解析 advice-ref、pointcut/pointcut-ref、order 等属性，设置 propertyValues，完成 BeanDefinition 的注册。
aspect

1. // ConfigBeanDefinitionParser
2. private void parseAspect(Element aspectElement, ParserContext parserContext) {
3.         // 获取 id 和 ref 属性
4.         String aspectId = aspectElement.getAttribute(ID);
5.         String aspectName = aspectElement.getAttribute(REF);
7.         try {
8.                 this.parseState.push(new AspectEntry(aspectId, aspectName));
9.                 List<BeanDefinition> beanDefinitions = new ArrayList<>();
10.                 List<BeanReference> beanReferences = new ArrayList<>();
12.                 // 处理子标签 declare-parents
13.                 List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
14.                 for (int i = METHOD_INDEX; i < declareParents.size(); i++) {
15.                         Element declareParentsElement = declareParents.get(i);
16.                         beanDefinitions.add(parseDeclareParents(declareParentsElement, parserContext));
17.                 }
19.                 // We have to parse "advice" and all the advice kinds in one loop, to get the
20.                 // ordering semantics right.
21.                 NodeList nodeList = aspectElement.getChildNodes();
22.                 boolean adviceFoundAlready = false;
23.                 // 遍历子节点
24.                 for (int i = 0; i < nodeList.getLength(); i++) {
25.                         Node node = nodeList.item(i);
26.                         // 判断是否是通知节点，只有是通知节点才处理
27.                         if (isAdviceNode(node, parserContext)) {
28.                                 // 依赖的切面类只处理一次
29.                                 if (!adviceFoundAlready) {
30.                                         adviceFoundAlready = true;
31.                                         // 必须存在切面类，不存在报错
32.                                         if (!StringUtils.hasText(aspectName)) {
33.                                                 parserContext.getReaderContext().error(
34.                                                                 "<aspect> tag needs aspect bean reference via 'ref' attribute when declaring advices.",
35.                                                                 aspectElement, this.parseState.snapshot());
36.                                                 return;
37.                                         }
38.                                         // 作为依赖的 bean 存在
39.                                         beanReferences.add(new RuntimeBeanReference(aspectName));
40.                                 }
41.                                 // 一个通知标签封装一个 Advisor，之后将这个 Advisor 对应的 BeanDefinition 注册到 BeanFactory
42.                                 AbstractBeanDefinition advisorDefinition = parseAdvice(
43.                                                 aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences);
44.                                 beanDefinitions.add(advisorDefinition);
45.                         }
46.                 }
48.                 AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(
49.                                 aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
50.                 parserContext.pushContainingComponent(aspectComponentDefinition);
52.                 // aop:aspect 下 pointcut 子标签，作用和 aop:config 标签下 pointcut 子标签一致
53.                 List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);
54.                 for (Element pointcutElement : pointcuts) {
55.                         parsePointcut(pointcutElement, parserContext);
56.                 }
58.                 parserContext.popAndRegisterContainingComponent();
59.         }
60.         finally {
61.                 this.parseState.pop();
62.         }
63. }
65. // 是 advice 节点，五种通知对应五个标签
66. private boolean isAdviceNode(Node aNode, ParserContext parserContext) {
67.         if (!(aNode instanceof Element)) {
68.                 return false;
69.         }
70.         else {
71.                 String name = parserContext.getDelegate().getLocalName(aNode);
72.                 return (BEFORE.equals(name) || AFTER.equals(name) || AFTER_RETURNING_ELEMENT.equals(name) ||
73.                                 AFTER_THROWING_ELEMENT.equals(name) || AROUND.equals(name));
74.         }
75. }
77. private AbstractBeanDefinition parseAdvice(
78.                 String aspectName, int order, Element aspectElement, Element adviceElement, ParserContext parserContext,
79.                 List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {
81.         try {
82.                 this.parseState.push(new AdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));
84.                 // create the method factory bean
85.                 // method --> BeanDefinition
86.                 RootBeanDefinition methodDefinition = new RootBeanDefinition(MethodLocatingFactoryBean.class);
87.                 methodDefinition.getPropertyValues().add("targetBeanName", aspectName);
88.                 methodDefinition.getPropertyValues().add("methodName", adviceElement.getAttribute("method"));
89.                 methodDefinition.setSynthetic(true);
91.                 // create instance factory definition
92.                 // 切面实例工厂
93.                 RootBeanDefinition aspectFactoryDef =
94.                                 new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class);
95.                 aspectFactoryDef.getPropertyValues().add("aspectBeanName", aspectName);
96.                 aspectFactoryDef.setSynthetic(true);
98.                 // register the pointcut
99.                 // 封装通知 advice --> BeanDefinition
100.                 AbstractBeanDefinition adviceDef = createAdviceDefinition(
101.                                 adviceElement, parserContext, aspectName, order, methodDefinition, aspectFactoryDef,
102.                                 beanDefinitions, beanReferences);
104.                 // configure the advisor
105.                 // 配置 advisor，一个 advice 对应一个 advisor
106.                 RootBeanDefinition advisorDefinition = new RootBeanDefinition(AspectJPointcutAdvisor.class);
107.                 advisorDefinition.setSource(parserContext.extractSource(adviceElement));
108.                 advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
109.                 // advisor order
110.                 if (aspectElement.hasAttribute(ORDER_PROPERTY)) {
111.                         advisorDefinition.getPropertyValues().add(
112.                                         ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));
113.                 }
115.                 // register the final advisor
116.                 // 注册 advisor
117.                 parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);
119.                 return advisorDefinition;
120.         }
121.         finally {
122.                 this.parseState.pop();
123.         }
124. }
125. private AbstractBeanDefinition createAdviceDefinition(
126.                 Element adviceElement, ParserContext parserContext, String aspectName, int order,
127.                 RootBeanDefinition methodDef, RootBeanDefinition aspectFactoryDef,
128.                 List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {
130.         // AspectJ 一种通知类型适配 spring 中一种通知类型
131.         RootBeanDefinition adviceDefinition = new RootBeanDefinition(getAdviceClass(adviceElement, parserContext));
132.         adviceDefinition.setSource(parserContext.extractSource(adviceElement));
134.         // 添加属性
135.         adviceDefinition.getPropertyValues().add(ASPECT_NAME_PROPERTY, aspectName);
136.         adviceDefinition.getPropertyValues().add(DECLARATION_ORDER_PROPERTY, order);
138.         if (adviceElement.hasAttribute(RETURNING)) {
139.                 adviceDefinition.getPropertyValues().add(
140.                                 RETURNING_PROPERTY, adviceElement.getAttribute(RETURNING));
141.         }
142.         if (adviceElement.hasAttribute(THROWING)) {
143.                 adviceDefinition.getPropertyValues().add(
144.                                 THROWING_PROPERTY, adviceElement.getAttribute(THROWING));
145.         }
146.         if (adviceElement.hasAttribute(ARG_NAMES)) {
147.                 adviceDefinition.getPropertyValues().add(
148.                                 ARG_NAMES_PROPERTY, adviceElement.getAttribute(ARG_NAMES));
149.         }
151.         // 构造参数，每一个 AspectJXXXAdvice 构造方法都需要三个参数
152.         ConstructorArgumentValues cav = adviceDefinition.getConstructorArgumentValues();
153.         cav.addIndexedArgumentValue(METHOD_INDEX, methodDef);
154.         // 切点
155.         Object pointcut = parsePointcutProperty(adviceElement, parserContext);
156.         if (pointcut instanceof BeanDefinition) {
157.                 cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcut);
158.                 beanDefinitions.add((BeanDefinition) pointcut);
159.         }
160.         else if (pointcut instanceof String) {
161.                 RuntimeBeanReference pointcutRef = new RuntimeBeanReference((String) pointcut);
162.                 cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcutRef);
163.                 beanReferences.add(pointcutRef);
164.         }
165.         // 切面实例工厂
166.         cav.addIndexedArgumentValue(ASPECT_INSTANCE_FACTORY_INDEX, aspectFactoryDef);
168.         return adviceDefinition;
169. }
171. private Class<?> getAdviceClass(Element adviceElement, ParserContext parserContext) {
172.         String elementName = parserContext.getDelegate().getLocalName(adviceElement);
173.         if (BEFORE.equals(elementName)) {
174.                 return AspectJMethodBeforeAdvice.class;
175.         }
176.         else if (AFTER.equals(elementName)) {
177.                 return AspectJAfterAdvice.class;
178.         }
179.         else if (AFTER_RETURNING_ELEMENT.equals(elementName)) {
180.                 return AspectJAfterReturningAdvice.class;
181.         }
182.         else if (AFTER_THROWING_ELEMENT.equals(elementName)) {
183.                 return AspectJAfterThrowingAdvice.class;
184.         }
185.         else if (AROUND.equals(elementName)) {
186.                 return AspectJAroundAdvice.class;
187.         }
188.         else {
189.                 throw new IllegalArgumentException("Unknown advice kind [" + elementName + "].");
190.         }
191. }
192. // 前置通知
193. public AspectJMethodBeforeAdvice(
194.                 Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
196.         super(aspectJBeforeAdviceMethod, pointcut, aif);
197. }
199. public AspectJPointcutAdvisor(AbstractAspectJAdvice advice) {
200.         Assert.notNull(advice, "Advice must not be null");
201.         this.advice = advice;
202.         this.pointcut = advice.buildSafePointcut();
203. }

复制代码

实在就是解析各种通知标签，之后封装 BeanDefinition，注册到 BeanFactory。一个通知对应一个 Advisor。
完成这些标签解析之后，也就在 BeanFactory 中注册了所有的 Advisor。
主动署理生成器的实例化

在 AbstractApplicationContext#refresh 中实行 registerBeanPostProcessors 时，完成 AspectJAwareAdvisorAutoProxyCreator 的实例化。

1. // AbstractAdvisorAutoProxyCreator
2. @Override
3. public void setBeanFactory(BeanFactory beanFactory) {
4.         // 父类 AbstractAutoProxyCreator
5.         super.setBeanFactory(beanFactory);
6.         if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
7.                 throw new IllegalArgumentException(
8.                                 "AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
9.         }
10.         initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
11. }
13. protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
14.         // 初始化赋值
15.         this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
16. }

复制代码

在初始化时，进行了相关字段的赋值。

AspectJAwareAdvisorAutoProxyCreator 继续 AbstractAutoProxyCreator，以是署理的生成也遵照 spring 中定义的逻辑。
至于前面解析的各种标签注册的 BeanDefinition，则在 AbstractApplicationContext#finishBeanFactoryInitialization 时完成实例对象的创建。
署理的实现

BeanFactory 中所有 Advisor 的实例化

在业务 bean 的实例化过程中，由于 AspectJAwareAdvisorAutoProxyCreator 的存在，就会实行到 AbstractAutoProxyCreator#postProcessBeforeInstantiation 方法中，判断业务 bean 是否需要署理。

1. @Override
2. public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
3.         Object cacheKey = getCacheKey(beanClass, beanName);
5.         if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
6.                 if (this.advisedBeans.containsKey(cacheKey)) {
7.                         return null;
8.                 }
9.                 if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
10.                         this.advisedBeans.put(cacheKey, Boolean.FALSE);
11.                         return null;
12.                 }
13.         }
15.         // Create proxy here if we have a custom TargetSource.
16.         // Suppresses unnecessary default instantiation of the target bean:
17.         // The TargetSource will handle target instances in a custom fashion.
18.         TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
19.         if (targetSource != null) {
20.                 if (StringUtils.hasLength(beanName)) {
21.                         this.targetSourcedBeans.add(beanName);
22.                 }
23.                 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
24.                 Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
25.                 this.proxyTypes.put(cacheKey, proxy.getClass());
26.                 return proxy;
27.         }
29.         return null;
30. }

复制代码

其中，AspectJAwareAdvisorAutoProxyCreator 重写了 shouldSkip 方法。

1. @Override
2. protected boolean shouldSkip(Class<?> beanClass, String beanName) {
3.         // 获取所有候选 Advisor
4.         List<Advisor> candidateAdvisors = findCandidateAdvisors();
5.         // advisor 中 aspectName 如果和带创建的 beanName 一致，表明正在创建切面类实例，返回 true，表示切面类不需要代理
6.         for (Advisor advisor : candidateAdvisors) {
7.                 if (advisor instanceof AspectJPointcutAdvisor &&
8.                                 ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
9.                         return true;
10.                 }
11.         }
12.         return super.shouldSkip(beanClass, beanName);
13. }

复制代码

主要来看下 findCandidateAdvisors 这个方法。

1. // AbstractAdvisorAutoProxyCreator
2. protected List<Advisor> findCandidateAdvisors() {
3.         Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
4.         return this.advisorRetrievalHelper.findAdvisorBeans();
5. }

复制代码

在 AspectJAwareAdvisorAutoProxyCreator 实例对象创建时，已经完成了 advisorRetrievalHelper 的创建赋值，是一个工具类 BeanFactoryAdvisorRetrievalHelper。

1. // BeanFactoryAdvisorRetrievalHelper
2. public List<Advisor> findAdvisorBeans() {
3.         // Determine list of advisor bean names, if not cached already.
4.         String[] advisorNames = this.cachedAdvisorBeanNames;
5.         if (advisorNames == null) {
6.                 // Do not initialize FactoryBeans here: We need to leave all regular beans
7.                 // uninitialized to let the auto-proxy creator apply to them!
8.                 // 获取注册的所有 Advisor 对应的名称集合
9.                 advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
10.                                 this.beanFactory, Advisor.class, true, false);
11.                 this.cachedAdvisorBeanNames = advisorNames;
12.         }
13.         if (advisorNames.length == 0) {
14.                 return new ArrayList<>();
15.         }
17.         List<Advisor> advisors = new ArrayList<>();
18.         for (String name : advisorNames) {
19.                 if (isEligibleBean(name)) {
20.                         if (this.beanFactory.isCurrentlyInCreation(name)) {
21.                                 if (logger.isTraceEnabled()) {
22.                                         logger.trace("Skipping currently created advisor '" + name + "'");
23.                                 }
24.                         }
25.                         else {
26.                                 try {
27.                                         // 对象未创建则在此时进行创建
28.                                         advisors.add(this.beanFactory.getBean(name, Advisor.class));
29.                                 }
30.                                 catch (BeanCreationException ex) {
31.                                         ...
32.                                         // 抛出异常
33.                                 }
34.                         }
35.                 }
36.         }
37.         return advisors;
38. }

复制代码

bean 的创建过程，此处不再赘述。有几点需要留意：

• 一个 pointcut 可以被多个 advisor 和 aspect 下通知子标签引用，即可以在一个切入点应用多个顾问和通知，pointcut 对应的 beanClass 为 AspectJExpressionPointcut，创建 BeanDefinition 时设置 scope 为 prototype，以是每一个对 AspectJExpressionPointcut 的引用，都会创建一个新的对象。
  
• aspect 标签下各个通知子标签对应的 Advisor 为 AspectJPointcutAdvisor，持有的 Advice 为通知子标签封装的 AspectJXXXAdvice。
  
• AspectJPointcutAdvisor 构造方法注入时，需要 AbstractAspectJAdvice，而每一个 AspectJXXXAdvice 构造方法都需要三个参数，通报给父类 AbstractAspectJAdvice。
  

1. public AbstractAspectJAdvice(
2.                 Method aspectJAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aspectInstanceFactory) {
4.         Assert.notNull(aspectJAdviceMethod, "Advice method must not be null");
5.         this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
6.         this.methodName = aspectJAdviceMethod.getName();
7.         this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
8.         this.aspectJAdviceMethod = aspectJAdviceMethod;
9.         this.pointcut = pointcut;
10.         this.aspectInstanceFactory = aspectInstanceFactory;
11. }

复制代码

第一个参数，需要的是一个切面类中的通知方法，在 aspect 标签解析时，针对通知标签，封装一个 beanClass 为 MethodLocatingFactoryBean 的 BeanDefinition。当解析第一个参数时，会实行 MethodLocatingFactoryBean 的创建。

1. // MethodLocatingFactoryBean
2. @Override
3. public void setBeanFactory(BeanFactory beanFactory) {
4.         if (!StringUtils.hasText(this.targetBeanName)) {
5.                 throw new IllegalArgumentException("Property 'targetBeanName' is required");
6.         }
7.         if (!StringUtils.hasText(this.methodName)) {
8.                 throw new IllegalArgumentException("Property 'methodName' is required");
9.         }
11.         Class<?> beanClass = beanFactory.getType(this.targetBeanName);
12.         if (beanClass == null) {
13.                 throw new IllegalArgumentException("Can't determine type of bean with name '" + this.targetBeanName + "'");
14.         }
15.         this.method = BeanUtils.resolveSignature(this.methodName, beanClass);
17.         if (this.method == null) {
18.                 throw new IllegalArgumentException("Unable to locate method [" + this.methodName +
19.                                 "] on bean [" + this.targetBeanName + "]");
20.         }
21. }

复制代码

会在 MethodLocatingFactoryBean 对象初始化时，完成目的通知方法的确定。

1. // BeanUtils 根据方法名称从指定 clazz 中确定 method
2. @Nullable
3. public static Method resolveSignature(String signature, Class<?> clazz) {
4.         Assert.hasText(signature, "'signature' must not be empty");
5.         Assert.notNull(clazz, "Class must not be null");
6.         int startParen = signature.indexOf('(');
7.         int endParen = signature.indexOf(')');
8.         if (startParen > -1 && endParen == -1) {
9.                 throw new IllegalArgumentException("Invalid method signature '" + signature +
10.                                 "': expected closing ')' for args list");
11.         }
12.         else if (startParen == -1 && endParen > -1) {
13.                 throw new IllegalArgumentException("Invalid method signature '" + signature +
14.                                 "': expected opening '(' for args list");
15.         }
16.         else if (startParen == -1) {
17.                 // 不指定参数类型
18.                 return findMethodWithMinimalParameters(clazz, signature);
19.         }
20.         else {
21.                 // 方法名
22.                 String methodName = signature.substring(0, startParen);
23.                 // 逗号分割，获取参数类型数组
24.                 String[] parameterTypeNames =
25.                                 StringUtils.commaDelimitedListToStringArray(signature.substring(startParen + 1, endParen));
26.                 Class<?>[] parameterTypes = new Class<?>[parameterTypeNames.length];
27.                 for (int i = 0; i < parameterTypeNames.length; i++) {
28.                         String parameterTypeName = parameterTypeNames[i].trim();
29.                         try {
30.                                 // 加载类型，保证配置的每一个类型的正确性
31.                                 parameterTypes[i] = ClassUtils.forName(parameterTypeName, clazz.getClassLoader());
32.                         }
33.                         catch (Throwable ex) {
34.                                 throw new IllegalArgumentException("Invalid method signature: unable to resolve type [" +
35.                                                 parameterTypeName + "] for argument " + i + ". Root cause: " + ex);
36.                         }
37.                 }
38.                 // 根据类型获取指定方法
39.                 return findMethod(clazz, methodName, parameterTypes);
40.         }
41. }
43. @Nullable
44. public static Method findMethodWithMinimalParameters(Class<?> clazz, String methodName)
45.                 throws IllegalArgumentException {
47.         // 实际上 clazz.getMethods() 已经包含了当前类及所有父类中 public、protected 修饰的方法，但不包含 private 方法
48.         Method targetMethod = findMethodWithMinimalParameters(clazz.getMethods(), methodName);
49.         if (targetMethod == null) {
50.                 // 当目标方法为 private 修饰时，通过以下方法查找
51.                 targetMethod = findDeclaredMethodWithMinimalParameters(clazz, methodName);
52.         }
53.         return targetMethod;
54. }
55. @Nullable
56. public static Method findMethodWithMinimalParameters(Method[] methods, String methodName)
57.                 throws IllegalArgumentException {
59.         Method targetMethod = null;
60.         int numMethodsFoundWithCurrentMinimumArgs = 0;
61.         for (Method method : methods) {
62.                 // 比较参数名称
63.                 if (method.getName().equals(methodName)) {
64.                         int numParams = method.getParameterCount();
65.                         // 将参数长度最短的方法作为 targetMethod 返回
66.                         if (targetMethod == null || numParams < targetMethod.getParameterCount()) {
67.                                 targetMethod = method;
68.                                 numMethodsFoundWithCurrentMinimumArgs = 1;
69.                         }
70.                         else if (!method.isBridge() && targetMethod.getParameterCount() == numParams) {
71.                                 // 用常规方法覆盖桥接方法
72.                                 if (targetMethod.isBridge()) {
73.                                         // Prefer regular method over bridge...
74.                                         targetMethod = method;
75.                                 }
76.                                 else {
77.                                         // Additional candidate with same length
78.                                         // 当存在方法重写或重载时，发现了两个名称和参数长度一样的方法，数量自增
79.                                         numMethodsFoundWithCurrentMinimumArgs++;
80.                                 }
81.                         }
82.                 }
83.         }
84.         // 存在方法重写时抛出异常，即不确定使用的是子类方法还是父类方法
85.     // 重载时也会存在，方法名称一致，参数长度一致，但类型不一致，此处只校验长度，无法确定是哪一个方法
86.         if (numMethodsFoundWithCurrentMinimumArgs > 1) {
87.                 throw new IllegalArgumentException("Cannot resolve method '" + methodName +
88.                                 "' to a unique method. Attempted to resolve to overloaded method with " +
89.                                 "the least number of parameters but there were " +
90.                                 numMethodsFoundWithCurrentMinimumArgs + " candidates.");
91.         }
92.         return targetMethod;
93. }
95. // 查找当前类，并递归父类，返回 public、protected、private 修饰方法
96. @Nullable
97. public static Method findDeclaredMethodWithMinimalParameters(Class<?> clazz, String methodName)
98.                 throws IllegalArgumentException {
100.         Method targetMethod = findMethodWithMinimalParameters(clazz.getDeclaredMethods(), methodName);
101.         if (targetMethod == null && clazz.getSuperclass() != null) {
102.                 targetMethod = findDeclaredMethodWithMinimalParameters(clazz.getSuperclass(), methodName);
103.         }
104.         return targetMethod;
105. }
107. @Nullable
108. public static Method findMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
109.         try {
110.                 return clazz.getMethod(methodName, paramTypes);
111.         }
112.         catch (NoSuchMethodException ex) {
113.                 return findDeclaredMethod(clazz, methodName, paramTypes);
114.         }
115. }

复制代码

上面的代码解释了在切面类中确定目的通知方法的实现，主要逻辑如下：

• 不指定方法参数类型时，按最短参数长度查找，指定参数类型时，按参数类型查找，也就是说，xml 中配置 methodName 时，可以是 methodName(argType1,argType2) 这种配置原型。
  
• 不指定方法参数类型时，按最短参数长度查找，若存在方法重写和方法重载导致的多个方法名称和参数长度一致，会抛出异常
  
• private 修饰的方法也可以被找到而作为目的通知方法
  

MethodLocatingFactoryBean 创建完成之后，由于是 FactoryBean 子类，会调用 this.beanFactory.getObjectFromFactoryBean 获取真正的对象。

1. // MethodLocatingFactoryBean
2. @Override
3. @Nullable
4. public Method getObject() throws Exception {
5.         return this.method;
6. }

复制代码

 可以看到，获取的 Method 对象就是上面在切面类中确定的方法。这也解释了为什么 AspectJXXXAdvice 构造方法第一个参数类型为 Method，而解析标签时却配置了一个 MethodLocatingFactoryBean 工厂。
接下来看第二个构造参数，需要的是一个 AspectJExpressionPointcut，通知子标签支持 pointcut 和 pointcut-ref 两种方式来定义切入点。
解析标签时，假如是 pointcut，直接创建一个 beanClass 为 AspectJExpressionPointcut 的 BeanDefinition，此时 pointcut 配置的是切入点表达式字符串；假如是 pointcut-ref，表明是一个引用类型，引用的 aop:pointcut 子标签已经封装成了 BeanDefinition，此处返回名称字符串封装一个 RuntimeBeanReference。以是通报给第二个构造参数的，要么是一个 BeanDefinition，要么是一个 RuntimeBeanReference。
在 ConstructorResolver#resolveConstructorArguments 方法中，解析构造参数，不管是 BeanDefinition，还是 RuntimeBeanReference 引用，由于背后定义 BeanDefinition 时设置的 scope 都是 prototype，以是此处都会创建一个新的对象。
第三个参数，需要一个 AspectInstanceFactory，即切面实例工厂，传入的是一个 beanClass 为 SimpleBeanFactoryAwareAspectInstanceFactory 的 BeanDefinition，而这个 SimpleBeanFactoryAwareAspectInstanceFactory 就是 AspectInstanceFactory 的实现类，在此时完成实例化对象创建。
事实上，aspect 下的通知子标签，一个通知对应一个 Advisor，即 AspectJPointcutAdvisor，由于存在构造参数，采用构造方法实例化，此时又对依赖的构造参数 AbstractAspectJAdvice 进行了实例化创建，这个 AbstractAspectJAdvice 又存在构造参数，继续采用 AbstractAutowireCapableBeanFactory#autowireConstructor 进行实例化对象创建。
创建完 AspectJXXXAdvice，将其作为构造参数，完成 AspectJPointcutAdvisor 的实例化。

1. public AspectJPointcutAdvisor(AbstractAspectJAdvice advice) {
2.         Assert.notNull(advice, "Advice must not be null");
3.         this.advice = advice;
4.         this.pointcut = advice.buildSafePointcut();
5. }

复制代码

在构造方法中实行了 advice.buildSafePointcut()，这是在做什么呢？继续向下看。

1. // AbstractAspectJAdvice
2. public final Pointcut buildSafePointcut() {
3.         // AspectJExpressionPointcut
4.         Pointcut pc = getPointcut();
5.         MethodMatcher safeMethodMatcher = MethodMatchers.intersection(
6.                         new AdviceExcludingMethodMatcher(this.aspectJAdviceMethod), pc.getMethodMatcher());
7.         // 组合
8.         return new ComposablePointcut(pc.getClassFilter(), safeMethodMatcher);
9. }
11. // AspectJExpressionPointcut
12. @Override
13. public MethodMatcher getMethodMatcher() {
14.         obtainPointcutExpression();
15.         return this;
16. }
18. // AspectJExpressionPointcut
19. private PointcutExpression obtainPointcutExpression() {
20.         if (getExpression() == null) {
21.                 throw new IllegalStateException("Must set property 'expression' before attempting to match");
22.         }
23.         if (this.pointcutExpression == null) {
24.                 this.pointcutClassLoader = determinePointcutClassLoader();
25.                 // 解析切入点表达式，创建 PointcutExpressionImpl 返回
26.                 this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
27.         }
28.         return this.pointcutExpression;
29. }
31. public static MethodMatcher intersection(MethodMatcher mm1, MethodMatcher mm2) {
32.         return (mm1 instanceof IntroductionAwareMethodMatcher || mm2 instanceof IntroductionAwareMethodMatcher ?
33.                         new IntersectionIntroductionAwareMethodMatcher(mm1, mm2) : new IntersectionMethodMatcher(mm1, mm2));
34. }
36. public IntersectionIntroductionAwareMethodMatcher(MethodMatcher mm1, MethodMatcher mm2) {
37.         super(mm1, mm2);
38. }

复制代码

pc.getMethodMatcher() 时完成了 pc 中切入点表达式的解析，创建了一个 org.aspectj.internal.lang.reflect.PointcutExpressionImpl 对象赋值给 AspectJExpressionPointcut 中的 pointcutExpression 字段。之后创建一个 IntersectionIntroductionAwareMethodMatcher 对象作为 safeMethodMatcher，之后将 safeMethodMatcher 和 pc.getClassFilter() 返回的 AspectJExpressionPointcut 组合起来，封装一个 ComposablePointcut 返回。
完成 AspectJPointcutAdvisor 的对象创建之后，将其加入 advisors 集合，之后将集合返回，作为候选的 Advisor，即 candidateAdvisors。
再回到 AspectJAwareAdvisorAutoProxyCreator#shouldSkip 方法中，遍历 candidateAdvisors，advisor 中 aspectName 假如和当前创建的 beanName 一致，表明正在创建切面类实例，返回 true，即需要跳过。之后在 AbstractAutoProxyCreator#postProcessBeforeInstantiation 中，针对当前 beanClass 和 beanName 生成的 cacheKey，标记为 false。
署理对象的创建

完成目的类的实例化之后，在进行初始化时，由于 AspectJAwareAdvisorAutoProxyCreator 的存在，会实行到 AbstractAutoProxyCreator#postProcessAfterInitialization --> wrapIfNecessary。

1. protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
2.         if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
3.                 return bean;
4.         }
5.         if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
6.                 return bean;
7.         }
8.         if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
9.                 this.advisedBeans.put(cacheKey, Boolean.FALSE);
10.                 return bean;
11.         }
13.         // Create proxy if we have advice.
14.         Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
15.         if (specificInterceptors != DO_NOT_PROXY) {
16.                 this.advisedBeans.put(cacheKey, Boolean.TRUE);
17.                 Object proxy = createProxy(
18.                                 bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
19.                 this.proxyTypes.put(cacheKey, proxy.getClass());
20.                 return proxy;
21.         }
23.         this.advisedBeans.put(cacheKey, Boolean.FALSE);
24.         return bean;
25. }

复制代码

这是 spring 创建署理的模板。先来看对 Advisor 的过滤，找到当前目的类需要的 Advisor。

1. // AbstractAdvisorAutoProxyCreator
2. @Override
3. @Nullable
4. protected Object[] getAdvicesAndAdvisorsForBean(
5.                 Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
7.         List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
8.         if (advisors.isEmpty()) {
9.                 return DO_NOT_PROXY;
10.         }
11.         return advisors.toArray();
12. }
13. // AbstractAdvisorAutoProxyCreator
14. protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
15.         // 获取所有 BeanFaactory 中定义的 Advisor，前面创建过，所以此处获取很快
16.         List<Advisor> candidateAdvisors = findCandidateAdvisors();
17.         // 筛选
18.         List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
19.         // 扩展
20.         extendAdvisors(eligibleAdvisors);
21.         // 排序
22.         if (!eligibleAdvisors.isEmpty()) {
23.                 eligibleAdvisors = sortAdvisors(eligibleAdvisors);
24.         }
25.         return eligibleAdvisors;
26. }
28. // AopUtils
29. public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
30.         if (candidateAdvisors.isEmpty()) {
31.                 return candidateAdvisors;
32.         }
33.         List<Advisor> eligibleAdvisors = new ArrayList<>();
34.         for (Advisor candidate : candidateAdvisors) {
35.                 if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
36.                         eligibleAdvisors.add(candidate);
37.                 }
38.         }
39.         boolean hasIntroductions = !eligibleAdvisors.isEmpty();
40.         for (Advisor candidate : candidateAdvisors) {
41.                 if (candidate instanceof IntroductionAdvisor) {
42.                         // already processed
43.                         continue;
44.                 }
45.                 if (canApply(candidate, clazz, hasIntroductions)) {
46.                         eligibleAdvisors.add(candidate);
47.                 }
48.         }
49.         return eligibleAdvisors;
50. }
51. public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
52.         if (advisor instanceof IntroductionAdvisor) {
53.                 return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
54.         }
55.         else if (advisor instanceof PointcutAdvisor) {
56.                 // 对于 Advisor 为 DefaultBeanFactoryPointcutAdvisor，在进行 canApply 时执行 pc.getClassFilter 完成切入点表达式的解析
57.                 PointcutAdvisor pca = (PointcutAdvisor) advisor;
58.                 return canApply(pca.getPointcut(), targetClass, hasIntroductions);
59.         }
60.         else {
61.                 // It doesn't have a pointcut so we assume it applies.
62.                 return true;
63.         }
64. }
66. public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
67.         Assert.notNull(pc, "Pointcut must not be null");
68.         if (!pc.getClassFilter().matches(targetClass)) {
69.                 return false;
70.         }
72.         MethodMatcher methodMatcher = pc.getMethodMatcher();
73.         if (methodMatcher == MethodMatcher.TRUE) {
74.                 // No need to iterate the methods if we're matching any method anyway...
75.                 return true;
76.         }
78.         IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
79.         if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
80.                 introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
81.         }
83.         Set<Class<?>> classes = new LinkedHashSet<>();
84.         if (!Proxy.isProxyClass(targetClass)) {
85.                 classes.add(ClassUtils.getUserClass(targetClass));
86.         }
87.         classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
89.         for (Class<?> clazz : classes) {
90.                 Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
91.                 for (Method method : methods) {
92.                         if (introductionAwareMethodMatcher != null ?
93.                                         introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
94.                                         methodMatcher.matches(method, targetClass)) {
95.                                 return true;
96.                         }
97.                 }
98.         }
100.         return false;
101. }

复制代码

这些都是 spring 中实现 AOP 的通用代码，区别就在于差异的 org.springframework.aop.PointcutAdvisor，持有的 org.springframework.aop.Pointcut 差异，差异的 org.springframework.aop.Pointcut，持有的 ClassFilter 和 MethodMatcher 差异。实现AopUtils#canApply 时，使用每个 org.springframework.aop.Pointcut 中 ClassFilter 和 MethodMatcher 中定义的 matches 方法进行匹配。以是也可以按照自己定义的规则，对 org.springframework.aop.Pointcut 进行扩展。
找到合格的 Advisor 之后，调用 AbstractAdvisorAutoProxyCreator#extendAdvisors，而 AspectJAwareAdvisorAutoProxyCreator 对此方法进行了重写。

1. @Override
2. protected void extendAdvisors(List<Advisor> candidateAdvisors) {
3.         AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors);
4. }
5. public static boolean makeAdvisorChainAspectJCapableIfNecessary(List<Advisor> advisors) {
6.         // Don't add advisors to an empty list; may indicate that proxying is just not required
7.         if (!advisors.isEmpty()) {
8.                 boolean foundAspectJAdvice = false;
9.                 for (Advisor advisor : advisors) {
10.                         // Be careful not to get the Advice without a guard, as this might eagerly
11.                         // instantiate a non-singleton AspectJ aspect...
12.                         if (isAspectJAdvice(advisor)) {
13.                                 foundAspectJAdvice = true;
14.                                 break;
15.                         }
16.                 }
17.                 if (foundAspectJAdvice && !advisors.contains(ExposeInvocationInterceptor.ADVISOR)) {
18.                         advisors.add(0, ExposeInvocationInterceptor.ADVISOR);
19.                         return true;
20.                 }
21.         }
22.         return false;
23. }
24. private static boolean isAspectJAdvice(Advisor advisor) {
25.         return (advisor instanceof InstantiationModelAwarePointcutAdvisor ||
26.                         advisor.getAdvice() instanceof AbstractAspectJAdvice ||
27.                         (advisor instanceof PointcutAdvisor &&
28.                                         ((PointcutAdvisor) advisor).getPointcut() instanceof AspectJExpressionPointcut));
29. }

复制代码

判定是否 Advisor 集合中存在 AspectJAdvice，存在，在 Advisor 集合的首位加入 ExposeInvocationInterceptor.ADVISOR。至于为啥要加入这个 Advisor，可以参考 spring 中 AspectJ 基于注解的实现分析。
此处有一点要留意，就是假如 Advisor 为 DefaultBeanFactoryPointcutAdvisor，此前虽然进行了实例化，但其中依赖的 Advice 并未进行实例化，此时实行 advisor.getAdvice() 会对依赖的 Advice 完成实例化。
扩展完 eligibleAdvisors 之后，对 eligibleAdvisors 按照优先级进行排序。详细的排序过程可以参考AspectJ 下 Advisor 的排序过程。
排序之后，将集合处置惩罚成数组返回，赋值给 specificInterceptors。
之后调用 AbstractAutoProxyCreator#createProxy 创建署理，此时 AbstractAutoProxyCreator 就是 AspectJAwareAdvisorAutoProxyCreator，将 <aop:config> 标签中定义的 proxy-target-class 和 expose-proxy 两个属性又通报给 ProxyFactory。

1. // AbstractAutoProxyCreator
2. protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
3.                 @Nullable Object[] specificInterceptors, TargetSource targetSource) {
5.         if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
6.                 AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
7.         }
9.         ProxyFactory proxyFactory = new ProxyFactory();
10.         proxyFactory.copyFrom(this);
12.         if (proxyFactory.isProxyTargetClass()) {
13.                 // Explicit handling of JDK proxy targets and lambdas (for introduction advice scenarios)
14.                 if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) {
15.                         // Must allow for introductions; can't just set interfaces to the proxy's interfaces only.
16.                         for (Class<?> ifc : beanClass.getInterfaces()) {
17.                                 proxyFactory.addInterface(ifc);
18.                         }
19.                 }
20.         }
21.         else {
22.                 // No proxyTargetClass flag enforced, let's apply our default checks...
23.                 if (shouldProxyTargetClass(beanClass, beanName)) {
24.                         proxyFactory.setProxyTargetClass(true);
25.                 }
26.                 else {
27.                         evaluateProxyInterfaces(beanClass, proxyFactory);
28.                 }
29.         }
31.         Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
32.         proxyFactory.addAdvisors(advisors);
33.         proxyFactory.setTargetSource(targetSource);
34.         customizeProxyFactory(proxyFactory);
36.         proxyFactory.setFrozen(this.freezeProxy);
37.         // true
38.         if (advisorsPreFiltered()) {
39.                 proxyFactory.setPreFiltered(true);
40.         }
42.         // Use original ClassLoader if bean class not locally loaded in overriding class loader
43.         ClassLoader classLoader = getProxyClassLoader();
44.         if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
45.                 classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
46.         }
47.         return proxyFactory.getProxy(classLoader);
48. }

复制代码

创建署理的这一步，都是遵照 spring 中的定义来实现。
方法调用

雷同处置惩罚的，此处不在赘述，可以参考spring 中主动署理生成器的实现。
有一点需要留意，就是调用 DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice 方法时，遍历 advisors。前面介绍过，aspect 标签下通知对应的 Advisor 为 AspectJPointcutAdvisor，在实行有参构造时，封装的 pointcut 为 ComposablePointcut。

两个字段，主要关注 methodMatcher，通过前面的介绍，这个 methodMatcher 为 MethodMatchers$IntersectionIntroductionAwareMethodMatcher。 mm1 为定义的 AbstractAspectJAdvice$AdviceExcludingMethodMatcher，mm2 为 pc.getMethodMatcher()，也就是 Pointcut 中持有的 MethodMatcher。
此时调用 MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher(); 得到 MethodMatchers$IntersectionIntroductionAwareMethodMatcher，接着调用其 matches 方法。

1. // IntersectionIntroductionAwareMethodMatcher
2. @Override
3. public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
4.         return (MethodMatchers.matches(this.mm1, method, targetClass, hasIntroductions) &&
5.                         MethodMatchers.matches(this.mm2, method, targetClass, hasIntroductions));
6. }
7. // MethodMatches
8. public static boolean matches(MethodMatcher mm, Method method, Class<?> targetClass, boolean hasIntroductions) {
9.         Assert.notNull(mm, "MethodMatcher must not be null");
10.         return (mm instanceof IntroductionAwareMethodMatcher ?
11.                         ((IntroductionAwareMethodMatcher) mm).matches(method, targetClass, hasIntroductions) :
12.                         mm.matches(method, targetClass));
13. }
14. // AdviceExcludingMethodMatcher
15. @Override
16. public boolean matches(Method method, Class<?> targetClass) {
17.         return !this.adviceMethod.equals(method);
18. }

复制代码

AdviceExcludingMethodMatcher 并不是 IntroductionAwareMethodMatcher 实例，调用 AdviceExcludingMethodMatcher#matches 方法判定目的方法是否是通知方法，不是返回 true。以是主要的判断还是基于 mm2，mm2 为 AspectJExpressionPointcut。

1. // AspectJExpressionPointcut
2. @Override
3. public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
4.         obtainPointcutExpression();
5.         // org.aspectj.weaver.tools.ShadowMatch
6.         ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass);
8.         // Special handling for this, target, @this, @target, @annotation
9.         // in Spring - we can optimize since we know we have exactly this class,
10.         // and there will never be matching subclass at runtime.
11.         if (shadowMatch.alwaysMatches()) {
12.                 return true;
13.         }
14.         else if (shadowMatch.neverMatches()) {
15.                 return false;
16.         }
17.         else {
18.                 // the maybe case
19.                 if (hasIntroductions) {
20.                         return true;
21.                 }
22.                 // A match test returned maybe - if there are any subtype sensitive variables
23.                 // involved in the test (this, target, at_this, at_target, at_annotation) then
24.                 // we say this is not a match as in Spring there will never be a different
25.                 // runtime subtype.
26.                 RuntimeTestWalker walker = getRuntimeTestWalker(shadowMatch);
27.                 return (!walker.testsSubtypeSensitiveVars() || walker.testTargetInstanceOfResidue(targetClass));
28.         }
29. }

复制代码

进入 AspectJExpressionPointcut#matches，委托给 AspectJ 进行切入点表达式和目的方法的匹配。
之后将筛选出的 Advisor，根据持有的通知类型的差异，适配成差异的 org.aopalliance.intercept.MethodInterceptor，封装成拦截器链。接着封装 MethodInvocation，调用 proceed 方法。
总结

介绍完了 AspectJ 下基于注解和 XML 的 AOP实现。现在我们来总结一下这两者的区别。
标签解析

实现方式	标签解析器
注解	AspectJAutoProxyBeanDefinitionParser
XML	ConfigBeanDefinitionParser

署理生成器

实现方式	署理生成器
注解	AnnotationAwareAspectJAutoProxyCreator
XML	AspectJAwareAdvisorAutoProxyCreator

Advisor 的创建

实现方式	署理生成器
注解	AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors
XML	AbstractAdvisorAutoProxyCreator#findCandidateAdvisors

注解方式下，AnnotationAwareAspectJAutoProxyCreator 重写了 findCandidateAdvisors 方法，通过找到持有 @Aspect 注解的类，接着获取类中定义的通知方法，将其封装成 Advisor。
而 XML 模式下，由于在 XML 中已经定义了切面类、切入点、通知和顾问，以是会采用 spring 中定义的通用模板来获取 Advisor。
Advisor 的类型

实现方式	Advisor 类型
注解	InstantiationModelAwarePointcutAdvisorImpl
XML	advisor 标签对应 DefaultBeanFactoryPointcutAdvisor
	aspect 下通知子标签对应 AspectJPointcutAdvisor

除了这些显式的差异，还有一个隐式的差异点，就是 AspectJ 解析 expression 的时机。

实现方式	Advisor 类型	AspectJ 解析 expression 的时机
注解	InstantiationModelAwarePointcutAdvisorImpl	AbstractAdvisorAutoProxyCreator下findEligibleAdvisors 方法中对获取的 candidateAdvisors 进行筛选时完成
XML	DefaultBeanFactoryPointcutAdvisor
	AspectJPointcutAdvisor	有参构造方法实例化，实行 buildSafePointcut 方法时完成

下面我们来看下注解和 XML 这两种实现方式的共同点。
Advisor 的创建时机，都是在实行 AbstractAutoProxyCreator#postProcessBeforeInstantiation ，第一次调用 shouldSkip 方法时完成的，并将创建的 Advisor 实例对象加入到了 DefaultListableBeanFactory 的父类 DefaultSingletonBeanRegistry 中的 singletonObjects，之后获取 Advisor 时直接从 singletonObjects 获取。
业务 bean 署理对象的创建和方法调用，完全遵从 spring 中定义的 AOP 实现。至于方法匹配，则通过 AspectJExpressionPointcut 这个纽带，完全委托给了 AspectJ 这个框架去实现。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。