<aop:config>  标签的解析：

    <bean id="loggingAspect" class="com.zhuguang.jack.aop.aspect.AspectXml1"></bean>

    <aop:config>

        <aop:pointcut id="pointcut" expression="execution(* com.zhuguang.jack.aop.aspect.AspectXml1.*(..))" />

        <aop:aspect  ref="loggingAspect" order="1" >

            <aop:before method="before" pointcut-ref="pointcut"/>

            <aop:after method="after" pointcut-ref="pointcut"/>

            <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>

            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="exception"/>

        </aop:aspect>

    </aop:config>

aop:config对应的类是AspectJAwareAdvisorAutoProxyCreator。加到bean工厂。

aop:aspect  不用解析成类。

aop:before 对应的类是AspectJPointcutAdvisor，里面有AspectJMethodBeforeAdvice，里面有MethodLocatingFactoryBean和SimpleBeanFactoryAwareAspectInstanceFactory和pointcut。加到bean工厂。

aop:after ，aop:after-returning，aop:after-throwing与aop:before类似。

类的属性值就是根据标签上面写的解析出来的。

解析自定义标签就是创建bean的定义，<aop:before，<aop:after，<aop:after-returning，<aop:after-throwing。分别对应AspectJMethodBeforeAdvice.class;AspectJAfterAdvice.class;AspectJAfterReturningAdvice.class;AspectJAfterThrowingAdvice.class;AspectJAroundAdvice.class;

 AspectJAwareAdvisorAutoProxyCreator是支持AOP功能的入口类，必定实现BeanPostProcessor接口，bean实例化的时候就回去调用这个类，就会找这个类有没有切面，有切面就生成代理，

首先找到AopNamespaceHandler，然后找到registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());

public class AopNamespaceHandler extends NamespaceHandlerSupport {

    @Override

    public void init() {

        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());

        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());

        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());

    }

}

ConfigBeanDefinitionParser类里面有一个解析标签的方法parse()，

public BeanDefinition parse(Element element, ParserContext parserContext) { //element = [aop:config: null]，parserContext = org.springframework.beans.factory.xml.ParserContext@2fd953a6，

        CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));

        parserContext.pushContainingComponent(compositeDef);

        configureAutoProxyCreator(parserContext, element);  //ParserContext里面有一个属性XmlReaderContext readerContext，BeanDefinitionParserDelegate delegate，解析这个元素就是为了创建BeanDefinition对象，创建AspectJAwareAdvisorAutoProxyCreator的bean定义并且加载到bean工厂。这个类实现了BeanPostProcessor接口，实例化任何一个bean的时候，会调用spring容器中所有BeanPostProcessor接口的类的方法，AspectJAwareAdvisorAutoProxyCreator就会去检测要实例化的这个bean有没有切面，有切面，就帮这个bean生成代理，



        List<Element> childElts = DomUtils.getChildElements(element);   //[[aop:pointcut], [aop:advisor]]子标签，

        for (Element elt: childElts) {

            String localName = parserContext.getDelegate().getLocalName(elt);   //aop下面就3个标签，

            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;

    }

private void configureAutoProxyCreator(ParserContext parserContext, Element element) {

        AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);

    }

public static void registerAspectJAutoProxyCreatorIfNecessary(ParserContext parserContext, Element sourceElement) {

        BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(

                parserContext.getRegistry(), parserContext.extractSource(sourceElement));  //创建beanDefinition 对象，返回AspectJAwareAdvisorAutoProxyCreator的bean的定义，

        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);

        registerComponentIfNecessary(beanDefinition, parserContext);

    }

public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {

        return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);   //注册器是DefaultListableBeanFactory，null，

    }

private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {  //AspectJAwareAdvisorAutoProxyCreator，bean工厂，null，

        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {   //看bean工厂中有没有AspectJAwareAdvisorAutoProxyCreator的实例，名字是internalAutoProxyCreator，有就直接返回，没有就在bean工厂创建AspectJAwareAdvisorAutoProxyCreator的实例，名字叫做internalAutoProxyCreator。

            BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);

            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {

                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());

                int requiredPriority = findPriorityForClass(cls);

                if (currentPriority < requiredPriority) {

                    apcDefinition.setBeanClassName(cls.getName());

                }

            }

            return null;

        }

        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);  //创建AspectJAwareAdvisorAutoProxyCreator的实例

        beanDefinition.setSource(source);

        beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);

        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);   //加到bean工厂，名字叫做internalAutoProxyCreator，

        return beanDefinition;

    }

private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {

        if (sourceElement != null) {

            boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));  //获取[aop:config]标签的proxy-target-class="false"属性，true就是cglib的动态代理，faslse就是jdk的动态代理，没有写就是jdk的动态代理，

            if (proxyTargetClass) {//true

                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);

            }

            boolean exposeProxy = Boolean.valueOf(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));   //sourceElement = [aop:config]标签，

            if (exposeProxy) {

                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);

            }

        }

    }

public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {

        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {

            BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);

            definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);   //往internalAutoProxyCreator的bean定义里面加了一个属性，

        }

    }

private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ParserContext parserContext) {  //AspectJAwareAdvisorAutoProxyCreator的bean定义，org.springframework.beans.factory.xml.ParserContext@2fd953a6，

        if (beanDefinition != null) {

            BeanComponentDefinition componentDefinition = new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);  //把AspectJAwareAdvisorAutoProxyCreator的bean定义包装成BeanComponentDefinition，包装的名称叫做internalAutoProxyCreator，

            parserContext.registerComponent(componentDefinition);

        }

    }

BeanComponentDefinition extends BeanDefinitionHolder。

BeanDefinition最终会包装成BeanDefinitionHolder，BeanDefinitionHolder有BeanDefinition beanDefinition是bean的定义和String beanName 是bean的名称。

private void parseAspect(Element aspectElement, ParserContext parserContext) {  //解析<aop:aspect标签，

        String aspectId = aspectElement.getAttribute(ID);   //id属性，

        String aspectName = aspectElement.getAttribute(REF);   //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));

            }

            NodeList nodeList = aspectElement.getChildNodes();//aspect的子元素，<aop:before，<aop:after，<aop:after-returning，<aop:after-throwing。

            boolean adviceFoundAlready = false;

            for (int i = 0; i < nodeList.getLength(); i++) {

                Node node = nodeList.item(i);   //<aop:before，<aop:after，<aop:after-returning，<aop:after-throwing。

                if (isAdviceNode(node, parserContext)) {

                    if (!adviceFoundAlready) {

                        adviceFoundAlready = true;

                        beanReferences.add(new RuntimeBeanReference(aspectName));

                    }

                    AbstractBeanDefinition advisorDefinition = parseAdvice(aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences);  //解析通知节点<aop:before，<aop:after，<aop:after-returning，<aop:after-throwing标签。目的也是为了创建BeanDefinition。

//返回AspectJPointcutAdvisor的bean定义，constructorArgumentValues属性里面的gebericArgumentValues里面有AspectJMethodBeforeAdvice（现在解析的是aop:before标签）（还有after,around,throw,exception几种）的bean定义里面的constructorArgumentValues属性里面有MethodLocatingFactoryBean的bean定义和SimpleBeanFactoryAwareAspectInstanceFactory的bean定义和pointcut。

                    beanDefinitions.add(advisorDefinition);//4种前置后置环绕等通知加进去，一个是before标签的bean定义，一个是after的bean定义，一个是afterReturn的bean定义，一个是afterThrow的bean定义。

                }

            }

//解析aop:aspect标签，就是把里面的aop：before，aop:after，aop:afterthrow，aop:afterRuturnning，这几种标签解析成bean的定义，跟需要加入切面的类还没有建立直接的关系。

            AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(

                    aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);

            parserContext.pushContainingComponent(aspectComponentDefinition);

            List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);  //这个<aop:aspect  标签里面的pointcut标签，

            for (Element pointcutElement : pointcuts) {

                parsePointcut(pointcutElement, parserContext);

            }

            parserContext.popAndRegisterContainingComponent();

        }

        finally {

            this.parseState.pop();

        }

    }

private AbstractBeanDefinition parseAdvice(String aspectName, int order, Element aspectElement, Element adviceElement, ParserContext parserContext,List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {//aspectName = aop:aspect标签的ref属性的值，aspectElement = [aop:aspect: null]标签，adviceElement = <aop:before，<aop:after，<aop:after-returning，<aop:after-throwing。

        try {

            this.parseState.push(new AdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));

            RootBeanDefinition methodDefinition = new RootBeanDefinition(MethodLocatingFactoryBean.class);   //创建这个的bean定义，

            methodDefinition.getPropertyValues().add("targetBeanName", aspectName);//loggingAspect，切面类名称。

            methodDefinition.getPropertyValues().add("methodName", adviceElement.getAttribute("method"));  //执行的方法，

            methodDefinition.setSynthetic(true);

            RootBeanDefinition aspectFactoryDef = new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class); //创建这个的bean定义，

            aspectFactoryDef.getPropertyValues().add("aspectBeanName", aspectName);//loggingAspect，切面类名称。

            aspectFactoryDef.setSynthetic(true);

            AbstractBeanDefinition adviceDef = createAdviceDefinition(adviceElement, parserContext, aspectName, order, methodDefinition, aspectFactoryDef,beanDefinitions, beanReferences);  //返回AspectJMethodBeforeAdvice的bean定义constructorArgumentValues属性里面有MethodLocatingFactoryBean的bean定义和SimpleBeanFactoryAwareAspectInstanceFactory的bean定义和pointcut，前置通知的beanDefinition（<aop:before>标签的beanDefinition）。

            // configure the advisor

            RootBeanDefinition advisorDefinition = new RootBeanDefinition(AspectJPointcutAdvisor.class);  //切面内

            advisorDefinition.setSource(parserContext.extractSource(adviceElement));   //[aop:before: null]，

            advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);  //切面里面必须要有advice，通过构造函数设置值。

            if (aspectElement.hasAttribute(ORDER_PROPERTY)) {

                advisorDefinition.getPropertyValues().add(ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));

            }

            // register the final advisor

            parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);

            return advisorDefinition;//返回这个切面。AspectJPointcutAdvisor的bean定义，constructorArgumentValues属性里面的gebericArgumentValues属性里面有AspectJMethodBeforeAdvice的bean定义里面的constructorArgumentValues属性里面有MethodLocatingFactoryBean的bean定义和SimpleBeanFactoryAwareAspectInstanceFactory的bean定义和pointcut。

        }

        finally {

            this.parseState.pop();

        }

    }

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));   //AspectJMethodBeforeAdvice的bean定义，before的类是AspectJMethodBeforeAdvice，after的类是AspectJAfterAdvice，return的类是AspectJAfterReturningAdvice，afterThrowing的类是AspectJAfterThrowingAdvice，around的类是AspectJAroundAdvice。

        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);  //解析pointcut，

        if (pointcut instanceof BeanDefinition) {//有pointcut属性，返回bean定义，

            cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcut);

            beanDefinitions.add((BeanDefinition) pointcut);

        }

        else if (pointcut instanceof String) {//有pointcut-ref属性，返回字符串，

            RuntimeBeanReference pointcutRef = new RuntimeBeanReference((String) pointcut);

            cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcutRef);

            beanReferences.add(pointcutRef);

        }

        cav.addIndexedArgumentValue(ASPECT_INSTANCE_FACTORY_INDEX, aspectFactoryDef);

        return adviceDefinition;  //返回AspectJMethodBeforeAdvice的bean定义里面有MethodLocatingFactoryBean的bean定义和SimpleBeanFactoryAwareAspectInstanceFactory的bean定义和pointcut。

    }

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;

        }

    }

private Object parsePointcutProperty(Element element, ParserContext parserContext) {  //element = aop:before标签，

        if (element.hasAttribute(POINTCUT) && element.hasAttribute(POINTCUT_REF)) {   //没有pointcut和pointcut-ref属性，直接报错。

            parserContext.getReaderContext().error("Cannot define both 'pointcut' and );

            return null;

        }

        else if (element.hasAttribute(POINTCUT)) {

            String expression = element.getAttribute(POINTCUT);

            AbstractBeanDefinition pointcutDefinition = createPointcutDefinition(expression);   //创建AspectJExpressionPointcut的bean定义，

            pointcutDefinition.setSource(parserContext.extractSource(element));

            return pointcutDefinition;

        }

        else if (element.hasAttribute(POINTCUT_REF)) {

            String pointcutRef = element.getAttribute(POINTCUT_REF);

            return pointcutRef;//返回字符串，

        }

    }

private AspectComponentDefinition createAspectComponentDefinition(

            Element aspectElement, String aspectId, List<BeanDefinition> beanDefs,

            List<BeanReference> beanRefs, ParserContext parserContext) {

        BeanDefinition[] beanDefArray = beanDefs.toArray(new BeanDefinition[beanDefs.size()]);   //4个前置后置环绕等通知的数组，

        BeanReference[] beanRefArray = beanRefs.toArray(new BeanReference[beanRefs.size()]);

        Object source = parserContext.extractSource(aspectElement);

        return new AspectComponentDefinition(aspectId, beanDefArray, beanRefArray, source);

    }

自定义标签都会有一个类与之对应，这个类是spring自己的类，然后加到spring的容器中，跟非自定义标签<bean>的解析类似。

<aop:config>

        <aop:pointcut id="pointcut" expression="execution(* com.zhuguang.jack.aop.aspect.AspectXml1.*(..))" />

aop:pointcut 解析成AspectJExpressionPointcut类，aop:config不用解析。

类的属性值就是根据标签上面写的解析出来的。

parsePointcut(elt, parserContext);   //[aop:pointcut: null]，解析pointcut标签，



private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) {

        String id = pointcutElement.getAttribute(ID);   //pointcut

        String expression = pointcutElement.getAttribute(EXPRESSION);   //execution(* com.zhuguang.jack.aop.aspect.AspectXml1.*(..))，

        AbstractBeanDefinition pointcutDefinition = null;

        try {

            this.parseState.push(new PointcutEntry(id));

            pointcutDefinition = createPointcutDefinition(expression); //AspectJExpressionPointcut的bean定义，里面有point的表达式，

            pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));

            String pointcutBeanName = id;  //pointcut

            if (StringUtils.hasText(pointcutBeanName)) {

                parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition);   //加到spring的容器，名字是pointcut，bean定义是AspectJExpressionPointcut的bean定义，

            }

            parserContext.registerComponent(new PointcutComponentDefinition(pointcutBeanName, pointcutDefinition, expression));  //pointcut，AspectJExpressionPointcut的beanDefinition，execution(* com.zhuguang.jack.aop.aspect.AspectXml1.*(..))，加到栈中，

        }

        finally {

            this.parseState.pop();

        }

        return pointcutDefinition;    //返回AspectJExpressionPointcut的bean定义，

    }

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:config proxy-target-class="false">

        <aop:advisor pointcut-ref="pc" advice-ref="userTxAdvice"/>

    </aop:config>

aop:advisor 对应的类是DefaultBeanFactoryPointcutAdvisor，aop:config不用解析，然后解析pointcut-ref属性和 advice-ref属性。最后加到bean容器中去。

类的属性值就是根据标签上面写的解析出来的。

private void parseAdvisor(Element advisorElement, ParserContext parserContext) {     //解析Advisor标签

        AbstractBeanDefinition advisorDef = createAdvisorBeanDefinition(advisorElement, parserContext);   //创建bean定义对象，返回DefaultBeanFactoryPointcutAdvisor的beanDefinition，他的PropertyValues属性 = new RuntimeBeanNameReference(userTxAdvice)，userTxAdvice是需要IOC依赖注入的，

        String id = advisorElement.getAttribute(ID);

        try {

            this.parseState.push(new AdvisorEntry(id));

            String advisorBeanName = id;

            if (StringUtils.hasText(advisorBeanName)) {

                parserContext.getRegistry().registerBeanDefinition(advisorBeanName, advisorDef);   //advisorDef 加到bean工厂中去，

            }

            else {

                advisorBeanName = parserContext.getReaderContext().registerWithGeneratedName(advisorDef);   //自动生成的名字org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor#0，advisorDef 加到bean工厂中去，

            }

            Object pointcut = parsePointcutProperty(advisorElement, parserContext);   //解析pointcut-ref属性，

            if (pointcut instanceof BeanDefinition) {//根据pointcut返回beanDefinition，根据pointcut-ref返回String，

                advisorDef.getPropertyValues().add(POINTCUT, pointcut);  //  添加pointcut属性，

                parserContext.registerComponent(new AdvisorComponentDefinition(advisorBeanName, advisorDef, (BeanDefinition) pointcut));//注册到栈中，

            }

            else if (pointcut instanceof String) {

                advisorDef.getPropertyValues().add(POINTCUT, new RuntimeBeanReference((String) pointcut));//将pointcut-ref转换成RuntimeBeanReference，然后添加pointcut属性，

                parserContext.registerComponent(new AdvisorComponentDefinition(advisorBeanName, advisorDef));//注册到栈中，

            }

        }

    }

private AbstractBeanDefinition createAdvisorBeanDefinition(Element advisorElement, ParserContext parserContext) {  //[aop:advisor: null]标签，

        RootBeanDefinition advisorDefinition = new RootBeanDefinition(DefaultBeanFactoryPointcutAdvisor.class);

        advisorDefinition.setSource(parserContext.extractSource(advisorElement));

        String adviceRef = advisorElement.getAttribute(ADVICE_REF);   //advice-ref属性 = userTxAdvice（ref就是引用，就需要依赖注入）

        if (!StringUtils.hasText(adviceRef)) {

            parserContext.getReaderContext().error(pshot());

        }

        else {

            advisorDefinition.getPropertyValues().add(ADVICE_BEAN_NAME, new RuntimeBeanNameReference(adviceRef));   //userTxAdvice封装成RuntimeBeanNameReference，ref是引用要依赖注入，当发现依赖注入的类型是RuntimeBeanNameReference的时候，那么就会去通过bean工厂去拿这个对象。

        }

        if (advisorElement.hasAttribute(ORDER_PROPERTY)) {  //排序属性

            advisorDefinition.getPropertyValues().add(

                    ORDER_PROPERTY, advisorElement.getAttribute(ORDER_PROPERTY));

        }

        return advisorDefinition;//返回DefaultBeanFactoryPointcutAdvisor的beanDefinition，他的PropertyValues属性 = new RuntimeBeanNameReference(userTxAdvice)，userTxAdvice是需要IOC依赖注入的，

    }

private Object parsePointcutProperty(Element element, ParserContext parserContext) {  //element = [aop:advisor: null]标签，

        if (element.hasAttribute(POINTCUT) && element.hasAttribute(POINTCUT_REF)) {  //是否有pointcut属性

            parserContext.getReaderContext().error(ot());

            return null;

        }

        else if (element.hasAttribute(POINTCUT)) {   //pointcut属性

            // Create a pointcut for the anonymous pc and register it.

            String expression = element.getAttribute(POINTCUT);

            AbstractBeanDefinition pointcutDefinition = createPointcutDefinition(expression);  //AspectJExpressionPointcut的bean定义，

            pointcutDefinition.setSource(parserContext.extractSource(element));

            return pointcutDefinition;

        }

        else if (element.hasAttribute(POINTCUT_REF)) {  //pointcut-ref属性

            String pointcutRef = element.getAttribute(POINTCUT_REF);  //string：引用的名字，

            if (!StringUtils.hasText(pointcutRef)) {

                parserContext.getReaderContext().error(ement, this.parseState.snapshot());

                return null;

            }

            return pointcutRef; //string：引用的名字，

        }

    }