AOP源码解析（三）增强器的获取

普通增强器的获取逻辑通过getAdvisor方法实现，实现步骤包括对切点的注解的获取及根据注解信息生成增强。

    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName)    {        validate(aif.getAspectMetadata().getAspectClass());        //切点信息的获取        AspectJExpressionPointcut ajexp = getPointcut(candidateAdviceMethod, aif.getAspectMetadata().getAspectClass());        if(ajexp == null)            return null;        else            //根据切点信息生成增强器            return new InstantiationModelAwarePointcutAdvisorImpl(this, ajexp, aif, candidateAdviceMethod, declarationOrderInAspect, aspectName);    }

（1）切点信息的获取。所谓获取切点信息就是指定注解的表达式信息的获取，如@Before("test()")

    private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class candidateAspectClass)    {        //获取方法上的注解        AbstractAspectJAdvisorFactory.AspectJAnnotation aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);        if(aspectJAnnotation == null)        {            return null;        } else        {            //使用AspectJExpressionPointcut实例封装获取的信息            AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class[0]);            //提取得到的注解中的表达式如：@Pointcut（"execution(* *.*test*(..))"）中的execution(* *.*test*(..))<pre name="code" class="java">   

))
ajexp.setExpression(aspectJAnnotation.getPointcutExpression()); return ajexp; } }

 protected static AspectJAnnotation findAspectJAnnotationOnMethod(Method method)    {        //设置敏感的注解类        Class classesToLookFor[] = {            org/aspectj/lang/annotation/Before, org/aspectj/lang/annotation/Around, org/aspectj/lang/annotation/After, org/aspectj/lang/annotation/AfterReturning, org/aspectj/lang/annotation/AfterThrowing, org/aspectj/lang/annotation/Pointcut        };        for(Class<? extends Annotation> c : classsesToLookFor)        {            AspectJAnnotation foundAnnotation = findAnnotation(method, c);            if(foundAnnotation != null)                return foundAnnotation;        }        return null;    }

//获取指定方法上的注解并使用AspectJAnnotation封装

    private static AspectJAnnotation findAnnotation(Method method, Class toLookFor)    {        Annotation result = AnnotationUtils.findAnnotation(method, toLookFor);        if(result != null)            return new AspectJAnnotation(result);        else            return null;    }

（2）根据切点信息生成增强。所有的增强都有Advisor实现类InstantiationModelAwarePontcutAdvisorImpl统一疯长。

    public InstantiationModelAwarePointcutAdvisorImpl(AspectJAdvisorFactory af, AspectJExpressionPointcut ajexp, MetadataAwareAspectInstanceFactory aif, Method method, int declarationOrderInAspect, String aspectName)    {        declaredPointcut = ajexp;        this.method = method;        atAspectJAdvisorFactory = af;        aspectInstanceFactory = aif;        declarationOrder = declarationOrderInAspect;        this.aspectName = aspectName;        if(aif.getAspectMetadata().isLazilyInstantiated())        {            Pointcut preInstantiationPointcut = Pointcuts.union(aif.getAspectMetadata().getPerClausePointcut(), declaredPointcut);            pointcut = new PerTargetInstantiationModelPointcut(declaredPointcut, preInstantiationPointcut, aif);            lazy = true;        } else        {            instantiatedAdvice = instantiateAdvice(declaredPointcut);            pointcut = declaredPointcut;            lazy = false;        }    }

封装过程只是简单地将信息封装在类的实例中，所有的额信息单纯地复制。在实例初始化的过程中还完成了对于增强器的初始化。因为不同的增强所体现的逻辑是不同的，比如@Before（“test（）”）与After（“test（）”）标签的不同就是增强器增强的位置不同，所以就需要不同的增强器来完成不同的逻辑，而根据注解中的信息初始化对应的额增强器就是在instantiateAdvice函数中实现的。

    private Advice instantiateAdvice(AspectJExpressionPointcut pcut)    {        return atAspectJAdvisorFactory.getAdvice(method, pcut, aspectInstanceFactory, declarationOrder, aspectName);    }

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut ajexp, MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName)    {        Class candidateAspectClass = aif.getAspectMetadata().getAspectClass();        validate(candidateAspectClass);        AbstractAspectJAdvisorFactory.AspectJAnnotation aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);        if(aspectJAnnotation == null)            return null;       //if we get here,we know we have an AspectJ method. Check that its an AspectJ-annotated class        if(!isAspect(candidateAspectClass))            throw new AopConfigException((new StringBuilder()).append("Advice must be declared inside an aspect type: Offending method '").append(candidateAdviceMethod).append("' in class [").append(candidateAspectClass.getName()).append("]").toString());        if(logger.isDebugEnabled())            logger.debug((new StringBuilder()).append("Found AspectJ method: ").append(candidateAdviceMethod).toString());        AbstractAspectJAdvice springAdvice;        switch(_cls4..SwitchMap.org.springframework.aop.aspectj.annotation.AbstractAspectJAdvisorFactory.AspectJAnnotationType[aspectJAnnotation.getAnnotationType().ordinal()])        {        case 1: // '\001'            springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, ajexp, aif);            break;        case 2: // '\002'            springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, ajexp, aif);            break;        case 3: // '\003'            springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, ajexp, aif);            AfterReturning afterReturningAnnotation = (AfterReturning)aspectJAnnotation.getAnnotation();            if(StringUtils.hasText(afterReturningAnnotation.returning()))                springAdvice.setReturningName(afterReturningAnnotation.returning());            break;        case 4: // '\004'            springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, ajexp, aif);            AfterThrowing afterThrowingAnnotation = (AfterThrowing)aspectJAnnotation.getAnnotation();            if(StringUtils.hasText(afterThrowingAnnotation.throwing()))                springAdvice.setThrowingName(afterThrowingAnnotation.throwing());            break;        case 5: // '\005'            springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, ajexp, aif);            break;        case 6: // '\006'            if(logger.isDebugEnabled())                logger.debug((new StringBuilder()).append("Processing pointcut '").append(candidateAdviceMethod.getName()).append("'").toString());            return null;        default:            throw new UnsupportedOperationException((new StringBuilder()).append("Unsupported advice type on method ").append(candidateAdviceMethod).toString());        }        springAdvice.setAspectName(aspectName);        springAdvice.setDeclarationOrder(declarationOrderInAspect);        String argNames[] = parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);        if(argNames != null)            springAdvice.setArgumentNamesFromStringArray(argNames);        springAdvice.calculateArgumentBindings();        return springAdvice;    }        }

从函数中可以看到，Spring会根据不同的注解生成不同的增强器，例如AtBefore会对应AspectJMethodBeforeAdvice。

2.增加同步实例化增强器

如果寻找的增强器不为空而且又配置了增强延迟初始化，那么就需要在首位加入同步实例化增强器。同步实例化增强器SyntheticInstantiationAdvisor，如下：

 protected static class SyntheticInstantiationAdvisor extends DefaultPointcutAdvisor    {        public SyntheticInstantiationAdvisor(final MetadataAwareAspectInstanceFactory aif)        {            super(aif.getAspectMetadata().getPerClausePointcut(), new MethodBeforeAdvice() {                //目前方法前调用，类似@Before                public void before(Method method, Object args[], Object target)                {   //简单初始化aspect                    aif.getAspectInstance();                }

3.获取DeclareParents注解

DeclareParents主要用于引介增强的注解形式的实现，而其实现方式驭普通增强很类似，只不过使用DeclareParentsAdvisor对功能进行封装。

    private Advisor getDeclareParentsAdvisor(Field introductionField)    {        DeclareParents declareParents = (DeclareParents)introductionField.getAnnotation(org/aspectj/lang/annotation/DeclareParents);        if(declareParents == null)            return null;        if(org/aspectj/lang/annotation/DeclareParents.equals(declareParents.defaultImpl()))            throw new IllegalStateException("defaultImpl must be set on DeclareParents");        else            return new DeclareParentsAdvisor(introductionField.getType(), declareParents.value(), declareParents.defaultImpl());    }

后面一节我们一起分析一下，Spring如何寻找匹配的增强器，篇幅较长，也比较复杂，但还是希望我们一起看下去，因为这个过程虽然很艰辛，坚持过后，你会发现，收获是非常巨大的。