【Spring源码分析】AOP源码解析（上篇）

2024-05-26 13:10:05 255

本文内容纲要：

前言

前面写了六篇文章详细地分析了SpringBean加载流程，这部分完了之后就要进入一个比较困难的部分了，就是AOP的实现原理分析。为了探究AOP实现原理，首先定义几个类，一个Dao接口：

1publicinterfaceDao{
2
3publicvoidselect();
4
5publicvoidinsert();
6
7}

Dao接口的实现类DaoImpl：

1publicclassDaoImplimplementsDao{
2
3@Override
4publicvoidselect(){
5System.out.println("EnterDaoImpl.select()");
6}
7
8@Override
9publicvoidinsert(){
10System.out.println("EnterDaoImpl.insert()");
11}
12
13}

定义一个TimeHandler，用于方法调用前后打印时间，在AOP中，这扮演的是横切关注点的角色：

1publicclassTimeHandler{
2
3publicvoidprintTime(){
4System.out.println("CurrentTime:"+System.currentTimeMillis());
5}
6
7}

定义一个XML文件aop.xml：

1<?xmlversion="1.0"encoding="UTF-8"?>
2<beansxmlns="http://www.springframework.org/schema/beans"
3xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4xmlns:aop="http://www.springframework.org/schema/aop"
5xmlns:tx="http://www.springframework.org/schema/tx"
6xsi:schemaLocation="http://www.springframework.org/schema/beans
7http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
8http://www.springframework.org/schema/aop
9http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
10
11<beanid="daoImpl"class="org.xrq.action.aop.DaoImpl"/>
12<beanid="timeHandler"class="org.xrq.action.aop.TimeHandler"/>
13
14<aop:configproxy-target-class="true">
15<aop:aspectid="time"ref="timeHandler">
16<aop:pointcutid="addAllMethod"expression="execution(*org.xrq.action.aop.Dao.*(..))"/>
17<aop:beforemethod="printTime"pointcut-ref="addAllMethod"/>
18<aop:aftermethod="printTime"pointcut-ref="addAllMethod"/>
19</aop:aspect>
20</aop:config>
21
22</beans>

写一段测试代码TestAop.java：

1publicclassTestAop{
2
3@Test
4publicvoidtestAop(){
5ApplicationContextac=newClassPathXmlApplicationContext("spring/aop.xml");
6
7Daodao=(Dao)ac.getBean("daoImpl");
8dao.select();
9}
10
11}

代码运行结果就不看了，有了以上的内容，我们就可以根据这些跟一下代码，看看Spring到底是如何实现AOP的。

AOP实现原理----找到Spring处理AOP的源头

有很多朋友不愿意去看AOP源码的一个很大原因是因为找不到AOP源码实现的入口在哪里，这个确实是。不过我们可以看一下上面的测试代码，就普通Bean也好、AOP也好，最终都是通过getBean方法获取到Bean并调用方法的，getBean之后的对象已经前后都打印了TimeHandler类printTime()方法里面的内容，可以想见它们已经是被Spring容器处理过了。

既然如此，那无非就两个地方处理：

加载Bean定义的时候应该有过特殊的处理
getBean的时候应该有过特殊的处理

因此，本文围绕【1.加载Bean定义的时候应该有过特殊的处理】展开，先找一下到底是哪里Spring对AOP做了特殊的处理。代码直接定位到DefaultBeanDefinitionDocumentReader的parseBeanDefinitions方法：

1protectedvoidparseBeanDefinitions(Elementroot,BeanDefinitionParserDelegatedelegate){
2if(delegate.isDefaultNamespace(root)){
3NodeListnl=root.getChildNodes();
4for(inti=0;i<nl.getLength();i++){
5Nodenode=nl.item(i);
6if(nodeinstanceofElement){
7Elementele=(Element)node;
8if(delegate.isDefaultNamespace(ele)){
9parseDefaultElement(ele,delegate);
10}
11else{
12delegate.parseCustomElement(ele);
13}
14}
15}
16}
17else{
18delegate.parseCustomElement(root);
19}
20}

正常来说，遇到<beanid="daoImpl"...>、<beanid="timeHandler"...>这两个标签的时候，都会执行第9行的代码，因为标签是默认的Namespace。但是在遇到后面的aop:config标签的时候就不一样了，aop:config并不是默认的Namespace，因此会执行第12行的代码，看一下：

1publicBeanDefinitionparseCustomElement(Elementele,BeanDefinitioncontainingBd){
2StringnamespaceUri=getNamespaceURI(ele);
3NamespaceHandlerhandler=this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
4if(handler==null){
5error("UnabletolocateSpringNamespaceHandlerforXMLschemanamespace["+namespaceUri+"]",ele);
6returnnull;
7}
8returnhandler.parse(ele,newParserContext(this.readerContext,this,containingBd));
9}

因为之前把整个XML解析为了org.w3c.dom.Document，org.w3c.dom.Document以树的形式表示整个XML，具体到每一个节点就是一个Node。

首先第2行从aop:config这个Node（参数Element是Node接口的子接口）中拿到Namespace="http://www.springframework.org/schema/aop"，第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下的内容了。

AOPBean定义加载----根据织入方式将aop:before、aop:after转换成名为adviceDef的RootBeanDefinition

上面经过分析，已经找到了Spring是通过AopNamespaceHandler处理的AOP，那么接着进入AopNamespaceHandler的parse方法源代码：

1publicBeanDefinitionparse(Elementelement,ParserContextparserContext){
2returnfindParserForElement(element,parserContext).parse(element,parserContext);
3}

首先获取具体的Parser，因为当前节点是aop:config，上一部分最后有列，config是通过ConfigBeanDefinitionParser来处理的，因此findParserForElement(element,parserContext)这一部分代码获取到的是ConfigBeanDefinitionParser，接着看ConfigBeanDefinitionParser的parse方法：

1publicBeanDefinitionparse(Elementelement,ParserContextparserContext){
2CompositeComponentDefinitioncompositeDef=
3newCompositeComponentDefinition(element.getTagName(),parserContext.extractSource(element));
4parserContext.pushContainingComponent(compositeDef);
5
6configureAutoProxyCreator(parserContext,element);
7
8List<Element>childElts=DomUtils.getChildElements(element);
9for(Elementelt:childElts){
10StringlocalName=parserContext.getDelegate().getLocalName(elt);
11if(POINTCUT.equals(localName)){
12parsePointcut(elt,parserContext);
13}
14elseif(ADVISOR.equals(localName)){
15parseAdvisor(elt,parserContext);
16}
17elseif(ASPECT.equals(localName)){
18parseAspect(elt,parserContext);
19}
20}
21
22parserContext.popAndRegisterContainingComponent();
23returnnull;
24}

重点先提一下第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，跟进去：

1privatevoidparseAspect(ElementaspectElement,ParserContextparserContext){
2StringaspectId=aspectElement.getAttribute(ID);
3StringaspectName=aspectElement.getAttribute(REF);
4
5try{
6this.parseState.push(newAspectEntry(aspectId,aspectName));
7List<BeanDefinition>beanDefinitions=newArrayList<BeanDefinition>();
8List<BeanReference>beanReferences=newArrayList<BeanReference>();
9
10List<Element>declareParents=DomUtils.getChildElementsByTagName(aspectElement,DECLARE_PARENTS);
11for(inti=METHOD_INDEX;i<declareParents.size();i++){
12ElementdeclareParentsElement=declareParents.get(i);
13beanDefinitions.add(parseDeclareParents(declareParentsElement,parserContext));
14}
15
16//Wehavetoparse"advice"andalltheadvicekindsinoneloop,togetthe
17//orderingsemanticsright.
18NodeListnodeList=aspectElement.getChildNodes();
19booleanadviceFoundAlready=false;
20for(inti=0;i<nodeList.getLength();i++){
21Nodenode=nodeList.item(i);
22if(isAdviceNode(node,parserContext)){
23if(!adviceFoundAlready){
24adviceFoundAlready=true;
25if(!StringUtils.hasText(aspectName)){
26parserContext.getReaderContext().error(
27"<aspect>tagneedsaspectbeanreferencevia'ref'attributewhendeclaringadvices.",
28aspectElement,this.parseState.snapshot());
29return;
30}
31beanReferences.add(newRuntimeBeanReference(aspectName));
32}
33AbstractBeanDefinitionadvisorDefinition=parseAdvice(
34aspectName,i,aspectElement,(Element)node,parserContext,beanDefinitions,beanReferences);
35beanDefinitions.add(advisorDefinition);
36}
37}
38
39AspectComponentDefinitionaspectComponentDefinition=createAspectComponentDefinition(
40aspectElement,aspectId,beanDefinitions,beanReferences,parserContext);
41parserContext.pushContainingComponent(aspectComponentDefinition);
42
43List<Element>pointcuts=DomUtils.getChildElementsByTagName(aspectElement,POINTCUT);
44for(ElementpointcutElement:pointcuts){
45parsePointcut(pointcutElement,parserContext);
46}
47
48parserContext.popAndRegisterContainingComponent();
49}
50finally{
51this.parseState.pop();
52}
53}

从第20行~第37行的循环开始关注这个方法。这个for循环有一个关键的判断就是第22行的ifAdviceNode判断，看下ifAdviceNode方法做了什么：

1privatebooleanisAdviceNode(NodeaNode,ParserContextparserContext){
2if(!(aNodeinstanceofElement)){
3returnfalse;
4}
5else{
6Stringname=parserContext.getDelegate().getLocalName(aNode);
7return(BEFORE.equals(name)||AFTER.equals(name)||AFTER_RETURNING_ELEMENT.equals(name)||
8AFTER_THROWING_ELEMENT.equals(name)||AROUND.equals(name));
9}
10}

即这个for循环只用来处理aop:aspect标签下的aop:before、aop:after、aop:after-returning、<aop:after-throwingmethod="">、<aop:aroundmethod="">这五个标签的。

接着，如果是上述五种标签之一，那么进入第33行~第34行的parseAdvice方法：

1privateAbstractBeanDefinitionparseAdvice(
2StringaspectName,intorder,ElementaspectElement,ElementadviceElement,ParserContextparserContext,
3List<BeanDefinition>beanDefinitions,List<BeanReference>beanReferences){
4
5try{
6this.parseState.push(newAdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));
7
8//createthemethodfactorybean
9RootBeanDefinitionmethodDefinition=newRootBeanDefinition(MethodLocatingFactoryBean.class);
10methodDefinition.getPropertyValues().add("targetBeanName",aspectName);
11methodDefinition.getPropertyValues().add("methodName",adviceElement.getAttribute("method"));
12methodDefinition.setSynthetic(true);
13
14//createinstancefactorydefinition
15RootBeanDefinitionaspectFactoryDef=
16newRootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class);
17aspectFactoryDef.getPropertyValues().add("aspectBeanName",aspectName);
18aspectFactoryDef.setSynthetic(true);
19
20//registerthepointcut
21AbstractBeanDefinitionadviceDef=createAdviceDefinition(
22adviceElement,parserContext,aspectName,order,methodDefinition,aspectFactoryDef,
23beanDefinitions,beanReferences);
24
25//configuretheadvisor
26RootBeanDefinitionadvisorDefinition=newRootBeanDefinition(AspectJPointcutAdvisor.class);
27advisorDefinition.setSource(parserContext.extractSource(adviceElement));
28advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
29if(aspectElement.hasAttribute(ORDER_PROPERTY)){
30advisorDefinition.getPropertyValues().add(
31ORDER_PROPERTY,aspectElement.getAttribute(ORDER_PROPERTY));
32}
33
34//registerthefinaladvisor
35parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);
36
37returnadvisorDefinition;
38}
39finally{
40this.parseState.pop();
41}
42}

方法主要做了三件事：

根据织入方式（before、after这些）创建RootBeanDefinition，名为adviceDef即advice定义
将上一步创建的RootBeanDefinition写入一个新的RootBeanDefinition，构造一个新的对象，名为advisorDefinition，即advisor定义
将advisorDefinition注册到DefaultListableBeanFactory中

下面来看做的第一件事createAdviceDefinition方法定义：

1privateAbstractBeanDefinitioncreateAdviceDefinition(
2ElementadviceElement,ParserContextparserContext,StringaspectName,intorder,
3RootBeanDefinitionmethodDef,RootBeanDefinitionaspectFactoryDef,
4List<BeanDefinition>beanDefinitions,List<BeanReference>beanReferences){
5
6RootBeanDefinitionadviceDefinition=newRootBeanDefinition(getAdviceClass(adviceElement,parserContext));
7adviceDefinition.setSource(parserContext.extractSource(adviceElement));
8adviceDefinition.getPropertyValues().add(ASPECT_NAME_PROPERTY,aspectName);
9adviceDefinition.getPropertyValues().add(DECLARATION_ORDER_PROPERTY,order);
10
11if(adviceElement.hasAttribute(RETURNING)){
12adviceDefinition.getPropertyValues().add(
13RETURNING_PROPERTY,adviceElement.getAttribute(RETURNING));
14}
15if(adviceElement.hasAttribute(THROWING)){
16adviceDefinition.getPropertyValues().add(
17THROWING_PROPERTY,adviceElement.getAttribute(THROWING));
18}
19if(adviceElement.hasAttribute(ARG_NAMES)){
20adviceDefinition.getPropertyValues().add(
21ARG_NAMES_PROPERTY,adviceElement.getAttribute(ARG_NAMES));
22}
23
24ConstructorArgumentValuescav=adviceDefinition.getConstructorArgumentValues();
25cav.addIndexedArgumentValue(METHOD_INDEX,methodDef);
26
27Objectpointcut=parsePointcutProperty(adviceElement,parserContext);
28if(pointcutinstanceofBeanDefinition){
29cav.addIndexedArgumentValue(POINTCUT_INDEX,pointcut);
30beanDefinitions.add((BeanDefinition)pointcut);
31}
32elseif(pointcutinstanceofString){
33RuntimeBeanReferencepointcutRef=newRuntimeBeanReference((String)pointcut);
34cav.addIndexedArgumentValue(POINTCUT_INDEX,pointcutRef);
35beanReferences.add(pointcutRef);
36}
37
38cav.addIndexedArgumentValue(ASPECT_INSTANCE_FACTORY_INDEX,aspectFactoryDef);
39
40returnadviceDefinition;
41}

首先可以看到，创建的AbstractBeanDefinition实例是RootBeanDefinition，这和普通Bean创建的实例为GenericBeanDefinition不同。然后进入第6行的getAdviceClass方法看一下：

1privateClassgetAdviceClass(ElementadviceElement,ParserContextparserContext){
2StringelementName=parserContext.getDelegate().getLocalName(adviceElement);
3if(BEFORE.equals(elementName)){
4returnAspectJMethodBeforeAdvice.class;
5}
6elseif(AFTER.equals(elementName)){
7returnAspectJAfterAdvice.class;
8}
9elseif(AFTER_RETURNING_ELEMENT.equals(elementName)){
10returnAspectJAfterReturningAdvice.class;
11}
12elseif(AFTER_THROWING_ELEMENT.equals(elementName)){
13returnAspectJAfterThrowingAdvice.class;
14}
15elseif(AROUND.equals(elementName)){
16returnAspectJAroundAdvice.class;
17}
18else{
19thrownewIllegalArgumentException("Unknownadvicekind["+elementName+"].");
20}
21}

既然创建Bean定义，必然该Bean定义中要对应一个具体的Class，不同的切入方式对应不同的Class：

before对应AspectJMethodBeforeAdvice
After对应AspectJAfterAdvice
after-returning对应AspectJAfterReturningAdvice
after-throwing对应AspectJAfterThrowingAdvice
around对应AspectJAroundAdvice

createAdviceDefinition方法剩余逻辑没什么，就是判断一下标签里面的属性并设置一下相应的值而已，至此aop:before、aop:after两个标签对应的AbstractBeanDefinition就创建出来了。

AOPBean定义加载----将名为adviceDef的RootBeanDefinition转换成名为advisorDefinition的RootBeanDefinition

下面我们看一下第二步的操作，将名为adviceDef的RootBeanD转换成名为advisorDefinition的RootBeanDefinition，跟一下上面一部分ConfigBeanDefinitionParser类parseAdvice方法的第26行~32行的代码：

1RootBeanDefinitionadvisorDefinition=newRootBeanDefinition(AspectJPointcutAdvisor.class);
2advisorDefinition.setSource(parserContext.extractSource(adviceElement));
3advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
4if(aspectElement.hasAttribute(ORDER_PROPERTY)){
5advisorDefinition.getPropertyValues().add(
6ORDER_PROPERTY,aspectElement.getAttribute(ORDER_PROPERTY));
7}

这里相当于将上一步生成的RootBeanDefinition包装了一下，new一个新的RootBeanDefinition出来，Class类型是org.springframework.aop.aspectj.AspectJPointcutAdvisor。

第4行~第7行的代码是用于判断aop:aspect标签中有没有"order"属性的，有就设置一下，"order"属性是用来控制切入方法优先级的。

AOPBean定义加载----将BeanDefinition注册到DefaultListableBeanFactory中

最后一步就是将BeanDefinition注册到DefaultListableBeanFactory中了，代码就是前面ConfigBeanDefinitionParser的parseAdvice方法的最后一部分了：

1...
2//registerthefinaladvisor
3parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);
4...

跟一下registerWithGeneratedName方法的实现：

1publicStringregisterWithGeneratedName(BeanDefinitionbeanDefinition){
2StringgeneratedName=generateBeanName(beanDefinition);
3getRegistry().registerBeanDefinition(generatedName,beanDefinition);
4returngeneratedName;
5}

第2行获取注册的名字BeanName，和的注册差不多，使用的是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定义的解析流程之前已经看过了，就不说了。

AOPBean定义加载----AopNamespaceHandler处理aop:pointcut流程

回到ConfigBeanDefinitionParser的parseAspect方法：

1privatevoidparseAspect(ElementaspectElement,ParserContextparserContext){
2
3...
4
5AspectComponentDefinitionaspectComponentDefinition=createAspectComponentDefinition(
6aspectElement,aspectId,beanDefinitions,beanReferences,parserContext);
7parserContext.pushContainingComponent(aspectComponentDefinition);
8
9List<Element>pointcuts=DomUtils.getChildElementsByTagName(aspectElement,POINTCUT);
10for(ElementpointcutElement:pointcuts){
11parsePointcut(pointcutElement,parserContext);
12}
13
14parserContext.popAndRegisterContainingComponent();
15}
16finally{
17this.parseState.pop();
18}
19}

省略号部分表示是解析的是aop:before、aop:after这种标签，上部分已经说过了，就不说了，下面看一下解析aop:pointcut部分的源码。

第5行~第7行的代码构建了一个Aspect标签组件定义，并将Apsect标签组件定义推到ParseContext即解析工具上下文中，这部分代码不是关键。

第9行的代码拿到所有aop:aspect下的pointcut标签，进行遍历，由parsePointcut方法进行处理：

1privateAbstractBeanDefinitionparsePointcut(ElementpointcutElement,ParserContextparserContext){
2Stringid=pointcutElement.getAttribute(ID);
3Stringexpression=pointcutElement.getAttribute(EXPRESSION);
4
5AbstractBeanDefinitionpointcutDefinition=null;
6
7try{
8this.parseState.push(newPointcutEntry(id));
9pointcutDefinition=createPointcutDefinition(expression);
10pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));
11
12StringpointcutBeanName=id;
13if(StringUtils.hasText(pointcutBeanName)){
14parserContext.getRegistry().registerBeanDefinition(pointcutBeanName,pointcutDefinition);
15}
16else{
17pointcutBeanName=parserContext.getReaderContext().registerWithGeneratedName(pointcutDefinition);
18}
19
20parserContext.registerComponent(
21newPointcutComponentDefinition(pointcutBeanName,pointcutDefinition,expression));
22}
23finally{
24this.parseState.pop();
25}
26
27returnpointcutDefinition;
28}

第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的实现，比较简单：

1protectedAbstractBeanDefinitioncreatePointcutDefinition(Stringexpression){
2RootBeanDefinitionbeanDefinition=newRootBeanDefinition(AspectJExpressionPointcut.class);
3beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
4beanDefinition.setSynthetic(true);
5beanDefinition.getPropertyValues().add(EXPRESSION,expression);
6returnbeanDefinition;
7}

关键就是注意一下两点：

aop:pointcut标签对应解析出来的BeanDefinition是RootBeanDefinition，且RootBenaDefinitoin中的Class是org.springframework.aop.aspectj.AspectJExpressionPointcut
aop:pointcut标签对应的Bean是prototype即原型的

这样一个流程下来，就解析了aop:pointcut标签中的内容并将之转换为RootBeanDefintion存储在Spring容器中。

本文内容总结：

原文链接：https://www.cnblogs.com/xrq730/p/6753160.html

【Spring源码分析】AOP源码解析（上篇）

本文内容纲要：

热门推荐

随机推荐