文章结构

  1. 首先提到了SpringAOP是基于postProcessBeforeInstantiation和postProcessAfterInstantiation两个方法实现的，这篇文章主讲postProcessBeforeInstantiation
  2. 加载Advisor
  3. 获取所有的Advisor又对Advisor进行了一系列的封装

    Advisor类

    看代码前首先了解一个类Advisor，如果从代码执行角度来看，Spring AOP的执行过程分为四大步骤：
  • 步骤一：Spring框架生成Advisor实例，可以是@Aspect，@Async等注解生成的实例，也可以是程序员自定义的AbstractAdvisor子类的实例。
  • 步骤二：Spring框架在目标实例初始化完成后，也就是使用BeanPostProcessor的postProcessAfterInitialization方法，根据Advisor实例中切入点Pointcut的定义，选择出适合该目标对象的Advisor实例。
  • 步骤三：Spring框架根据Advisor实例生成代理对象。
  • 步骤四：调用方法执行过程时，Spring框架执行Advisor实例的通知Advice逻辑。

  Spring中有大量的机制都是通过AOP实现的，比如说@Async的异步调用和@Transational。此外，用户也可以使用@Aspect注解定义切面或者直接继承AbstractPointcutAdvisor来提供切面逻辑。上述这些情况下，AOP都会生成对应的Advisor实例

Spring AOP中这个Advisor类，看看它的继承关系
image.png

在上篇文章中我们搭建了一个阅读源码的demo工程，然后简单介绍了一下@EnableAspectJAutoProxy注解，这个注解最重要的功能就是为向Spring中注入了一个bean, AnnotationAwareAspectJAutoProxyCreator ,本篇文章就继续来撸AOP的源码

前文已经简单提到了这个类的功能，不过这里还是要先看一下这个类的继承图
image.png

观察类图可知，AnnotationAwareAspectJAutoProxyCreator 这个类间接实现了BeanPostProcessor接口。还记得我们之前在对SpringIOC的源码进行解析时提到过，Spring在实例化Bean的前后会分别调用方法postProcessBeforeInstantiation和postProcessAfterInstantiation
而AOP的整体逻辑就是通过这两个方法来实现的

resolveBeforeInstantiation()

在前面SpringIOC中我们跟踪过IOC容器初始化的过程，其中AbstractAutowireCapableBeanFactor 方法createBean()里， resolveBeforeInstantiation()方法会对 BeanPostProcessors 处理，调用 postProcessBeforeInstantiation 和 postProcessAfterInstantiation 生成Bean的代理对象

  1. @Override
  2.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  3.             throws BeanCreationException {
  5.         if (logger.isDebugEnabled()) {
  6.             logger.debug("Creating instance of bean '" + beanName + "'");
  7.         }
  8.         RootBeanDefinition mbdToUse = mbd;
  10.         // Make sure bean class is actually resolved at this point, and
  11.         // clone the bean definition in case of a dynamically resolved Class
  12.         // which cannot be stored in the shared merged bean definition.
  13.         Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  14.         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  15.             mbdToUse = new RootBeanDefinition(mbd);
  16.             mbdToUse.setBeanClass(resolvedClass);
  17.         }
  19.         // Prepare method overrides.
  20.         try {
  21.             mbdToUse.prepareMethodOverrides();
  22.         }
  23.         catch (BeanDefinitionValidationException ex) {
  24.             throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  25.                     beanName, "Validation of method overrides failed", ex);
  26.         }
  28.         try {
  29.             //代理的BeanPostProcessors处理，调用postProcessBeforeInstantiation 和 postProcessAfterInstantiation
  30.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  31.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  32.             if (bean != null) {
  33.                 return bean;
  34.             }
  35.         }
  36.         catch (Throwable ex) {
  37.             throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  38.                     "BeanPostProcessor before instantiation of bean failed", ex);
  39.         }
  41.         try {
  42.             Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  43.             if (logger.isDebugEnabled()) {
  44.                 logger.debug("Finished creating instance of bean '" + beanName + "'");
  45.             }
  46.             return beanInstance;
  47.         }
  48.         catch (BeanCreationException ex) {
  49.             // A previously detected exception with proper bean creation context already...
  50.             throw ex;
  51.         }
  52.         catch (ImplicitlyAppearedSingletonException ex) {
  53.             // An IllegalStateException to be communicated up to DefaultSingletonBeanRegistry...
  54.             throw ex;
  55.         }
  56.         catch (Throwable ex) {
  57.             throw new BeanCreationException(
  58.                     mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  59.         }
  60.     }
  62.     @Nullable
  63.     protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
  64.         Object bean = null;
  65.         if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
  66.             // Make sure bean class is actually resolved at this point.
  67.             if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  68.                 Class<?> targetType = determineTargetType(beanName, mbd);
  69.                 if (targetType != null) {
  70.                     bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
  71.                     if (bean != null) {
  72.                         bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
  73.                     }
  74.                 }
  75.             }
  76.             mbd.beforeInstantiationResolved = (bean != null);
  77.         }
  78.         return bean;
  79.     }
  81.     @Nullable
  82.     protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
  83.         for (BeanPostProcessor bp : getBeanPostProcessors()) {
  84.             if (bp instanceof InstantiationAwareBeanPostProcessor) {
  85.                 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  86.                 //这里进行调用
  87.                 Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
  88.                 if (result != null) {
  89.                     return result;
  90.                 }
  91.             }
  92.         }
  93.         return null;
  94.     }
  96.     @Override
  97.     public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
  98.             throws BeansException {
  100.         Object result = existingBean;
  101.         for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
  102.             Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
  103.             if (current == null) {
  104.                 return result;
  105.             }
  106.             result = current;
  107.         }
  108.         return result;
  109.     }

postProcessBeforeInstantiation

首先看一下这个postProcessBeforeInstantiation方法，它是在bean实例化之前调用的，主要是针对切面类。这个方法不在AnnotationAwareAspectJAutoProxyCreator 这个类中，而是在其父类AbstractAutoProxyCreator中

  1. public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  2.     Object cacheKey = getCacheKey(beanClass, beanName);
  4.     if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
  5.       if (this.advisedBeans.containsKey(cacheKey)) {
  6.         return null;
  7.       }
  8.        //不是功能实现的基础类，shouldSkip()方法判断是否跳过, 不跳过则加载bean上的Advisor列表
  9.       if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
  10.         this.advisedBeans.put(cacheKey, Boolean.FALSE);
  11.         return null;
  12.       }
  13.     }
  15.     TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
  16.     if (targetSource != null) {
  17.       if (StringUtils.hasLength(beanName)) {
  18.         this.targetSourcedBeans.add(beanName);
  19.       }
  20.       Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
  21.       Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
  22.       this.proxyTypes.put(cacheKey, proxy.getClass());
  23.       return proxy;
  24.     }
  26.     return null;
  27.   }

加载Advisors列表

上方代码中最重要的一个方法就是shouldSkip方法了，这个方法被AspectJAwareAdvisorAutoProxyCreator所重载

  1. protected boolean shouldSkip(Class<?> beanClass, String beanName) {
  3.     //查找所有标识了@Aspect注解的类，这里是重点，接着往下看
  4.     List<Advisor> candidateAdvisors = findCandidateAdvisors();
  5.     for (Advisor advisor : candidateAdvisors) {
  6.         if (advisor instanceof AspectJPointcutAdvisor) {
  7.             if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) {
  8.                 return true;
  9.             }
  10.         }
  11.     }
  12.     return super.shouldSkip(beanClass, beanName);
  13.     }
  16.     protected List<Advisor> findCandidateAdvisors() {
  17.         return this.advisorRetrievalHelper.findAdvisorBeans();
  18.     }
  20.     protected List<Advisor> findCandidateAdvisors() {
  21.         List<Advisor> advisors = super.findCandidateAdvisors();
  22.         //buildAspectJAdvisors是重点
  23.            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
  24.         return advisors;
  25.     }

一个长方法buildAspectJAdvisors

  1. public List<Advisor> buildAspectJAdvisors() {
  2.     //所有包含Aspect注解类的名称集合
  3.     List<String> aspectNames = this.aspectBeanNames;
  4.     if (aspectNames == null) {
  5.         synchronized (this) {
  6.             aspectNames = this.aspectBeanNames;
  7.             //这个双重检查是不是在学习安全的单例模式的时候见过
  8.             if (aspectNames == null) {
  9.                 List<Advisor> advisors = new LinkedList<Advisor>();
  10.                 aspectNames = new LinkedList<String>();
  11.                 //获取所有Bean名称
  12.                 String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
  13.                         this.beanFactory, Object.class, true, false);
  14.                 for (String beanName : beanNames) {
  15.                     //判断是否符合条件，比如说有时会排除一些类，不让这些类注入进Spring
  16.                     if (!isEligibleBean(beanName)) {
  17.                         continue;
  18.                     }
  20.                     Class<?> beanType = this.beanFactory.getType(beanName);
  21.                     if (beanType == null) {
  22.                         continue;
  23.                     }
  24.                     //判断Bean的Class上是否标识@Aspect注解
  25.                     if (this.advisorFactory.isAspect(beanType)) {
  26.                         aspectNames.add(beanName);
  27.                         AspectMetadata amd = new AspectMetadata(beanType, beanName);
  28.                         if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
  29.                             MetadataAwareAspectInstanceFactory factory =
  30.                                     new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
  31.                             //下一步说，重点的重点，getAdvisors会解析这个类中的@Pointcut、@Before等注解方法封装为Advisor列表，见下
  32.                             List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
  33.                             if (this.beanFactory.isSingleton(beanName)) {
  34.                                 //将解析的Bean名称及类上的Advisors缓存起来,每个Bean只解析一次
  35.                                 this.advisorsCache.put(beanName, classAdvisors);
  36.                             }
  37.                             else {
  38.                                 this.aspectFactoryCache.put(beanName, factory);
  39.                             }
  40.                             advisors.addAll(classAdvisors);
  41.                         }
  42.                         else {
  43.                             if (this.beanFactory.isSingleton(beanName)) {
  44.                                 throw new IllegalArgumentException("Bean with name '" + beanName +
  45.                                         "' is a singleton, but aspect instantiation model is not singleton");
  46.                             }
  47.                             MetadataAwareAspectInstanceFactory factory =
  48.                                     new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
  49.                             this.aspectFactoryCache.put(beanName, factory);
  50.                             advisors.addAll(this.advisorFactory.getAdvisors(factory));
  51.                         }
  52.                     }
  53.                 }
  55.                 this.aspectBeanNames = aspectNames;
  56.                 return advisors;
  57.             }
  58.         }
  59.     }
  61.     if (aspectNames.isEmpty()) {
  62.         return Collections.emptyList();
  63.     }
  64.     List<Advisor> advisors = new LinkedList<Advisor>();
  65.     for (String aspectName : aspectNames) {
  66.         //从缓存中获取当前Bean的切面实例，如果不为空，则指明当前Bean的Class标识了@Aspect，且有切面方法
  67.         List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
  68.         if (cachedAdvisors != null) {
  69.             advisors.addAll(cachedAdvisors);
  70.         }
  71.         else {
  72.             MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
  73.             advisors.addAll(this.advisorFactory.getAdvisors(factory));
  74.         }
  75.     }
  76.     return advisors;
  77. }

advisorFactory.getAdvisors

advisorFactory.getAdvisors()方法会从@Aspect标识的类上获取@Before，@Pointcut等注解的信息及其标识的方法的信息，生成Advisor

  1. public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
  2.     Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
  3.     String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
  4.     //校验类的合法性相关
  5.     validate(aspectClass);
  7.     MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
  8.             new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
  10.     List<Advisor> advisors = new LinkedList<Advisor>();
  11.     //获取这个类所有的Advisor方法
  12.     for (Method method : getAdvisorMethods(aspectClass)) {
  13.         //生成Advisor实例，见下
  14.         Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
  15.         if (advisor != null) {
  16.             advisors.add(advisor);
  17.         }
  18.     }
  20.     if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
  21.         Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
  22.         advisors.add(0, instantiationAdvisor);
  23.     }
  25.     for (Field field : aspectClass.getDeclaredFields()) {
  26.         Advisor advisor = getDeclareParentsAdvisor(field);
  27.         if (advisor != null) {
  28.             advisors.add(advisor);
  29.         }
  30.     }
  32.     return advisors;
  33. }
  35. //获取类的的方法
  36. private List<Method> getAdvisorMethods(Class<?> aspectClass) {
  37.     final List<Method> methods = new LinkedList<Method>();
  38.     ReflectionUtils.doWithMethods(aspectClass, new ReflectionUtils.MethodCallback() {
  39.         @Override
  40.         public void doWith(Method method) throws IllegalArgumentException {
  41.                 //在@Aspect标识的类内部排除@Pointcut标识之外的所有方法，得到的方法集合包括继承自父类的方法，包括继承自Object的方法
  42.             if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
  43.                 methods.add(method);
  44.             }
  45.         }
  46.     });
  47.     //对得到的所有方法排序，
  48.     //如果方法标识了切面注解，则按@Around, @Before, @After, @AfterReturning, @AfterThrowing的顺序排序
  49.     //如果没有标识这些注解，则按方法名称的字符串排序,
  50.     //有注解的方法排在无注解的方法之前
  51.     //最后的排序应该是这样的Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class。。。
  52.     Collections.sort(methods, METHOD_COMPARATOR);
  53.     return methods;
  54. }
  56. public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
  57.         int declarationOrderInAspect, String aspectName) {
  58.     //再次校验类的合法性
  59.     validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
  60.     //切点表达式的包装类里面包含这些东西：execution(public * cn.shiyujun.service.IOCService.hollo(..))
  61.     //或者@Around中的value值，都会被封装到AspectJExpressionPointcut中
  62.     AspectJExpressionPointcut expressionPointcut = getPointcut(
  63.             candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
  64.     if (expressionPointcut == null) {
  65.         return null;
  66.     }
  67.     //根据方法、切点、AOP实例工厂、类名、序号生成Advisor实例，详细代码往下看
  68.     return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
  69.             this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
  70. }
  72. private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
  73.     //查询方法上的切面注解，根据注解生成相应类型的AspectJAnnotation,在调用AspectJAnnotation的构造函数的同时
  74.     //根据注解value或pointcut属性得到切点表达式，有argNames则设置参数名称
  75.     AspectJAnnotation<?> aspectJAnnotation =
  76.             AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
  77.     //过滤那些不含@Before, @Around, @After, @AfterReturning, @AfterThrowing注解的方法
  78.     if (aspectJAnnotation == null) {
  79.         return null;
  80.     }
  81.     //生成带表达式的切面切入点，设置其切入点表达式
  82.     AspectJExpressionPointcut ajexp =
  83.             new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
  84.     ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
  85.     ajexp.setBeanFactory(this.beanFactory);
  86.     return ajexp;
  87. }

InstantiationModelAwarePointcutAdvisorImpl 构造方法

  1. public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
  2.       Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
  3.       MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
  5.     this.declaredPointcut = declaredPointcut;
  6.     this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
  7.     this.methodName = aspectJAdviceMethod.getName();
  8.     this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
  9.     this.aspectJAdviceMethod = aspectJAdviceMethod;
  10.     this.aspectJAdvisorFactory = aspectJAdvisorFactory;
  11.     this.aspectInstanceFactory = aspectInstanceFactory;
  12.     this.declarationOrder = declarationOrder;
  13.     this.aspectName = aspectName;
  15.     if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
  16.       Pointcut preInstantiationPointcut = Pointcuts.union(
  17.           aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
  19.       this.pointcut = new PerTargetInstantiationModelPointcut(
  20.           this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
  21.       this.lazy = true;
  22.     }
  23.     else {
  24.       this.pointcut = this.declaredPointcut;
  25.       this.lazy = false;
  26.             //重点在这里
  27.       this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
  28.     }
  29.   }
  31.     private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
  32.     //再往下看
  33.     Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
  34.         this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
  35.     return (advice != null ? advice : EMPTY_ADVICE);
  36.   }

reflectiveAspectJAdvisorFactory.getAdvice

  1.    //调用这里的getAdvice
  2.   public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory implements Serializable {
  3.     public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
  4.             MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
  6.         Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
  7.         //又是一次校验
  8.         validate(candidateAspectClass);
  10.         AspectJAnnotation<?> aspectJAnnotation =
  11.                 AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
  12.         if (aspectJAnnotation == null) {
  13.             return null;
  14.         }
  16.         if (!isAspect(candidateAspectClass)) {
  17.             throw new AopConfigException("Advice must be declared inside an aspect type: " +
  18.                     "Offending method '" + candidateAdviceMethod + "' in class [" +
  19.                     candidateAspectClass.getName() + "]");
  20.         }
  22.         if (logger.isDebugEnabled()) {
  23.             logger.debug("Found AspectJ method: " + candidateAdviceMethod);
  24.         }
  26.         AbstractAspectJAdvice springAdvice;
  27.         //根据注解类型生成不同的通知实例
  28.         switch (aspectJAnnotation.getAnnotationType()) {
  29.             case AtBefore:
  30.                 springAdvice = new AspectJMethodBeforeAdvice(
  31.                         candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  32.                 break;
  33.             case AtAfter:
  34.                 springAdvice = new AspectJAfterAdvice(
  35.                         candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  36.                 break;
  37.             case AtAfterReturning:
  38.                 springAdvice = new AspectJAfterReturningAdvice(
  39.                         candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  40.                 AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
  41.                 if (StringUtils.hasText(afterReturningAnnotation.returning())) {
  42.                     springAdvice.setReturningName(afterReturningAnnotation.returning());
  43.                 }
  44.                 break;
  45.             case AtAfterThrowing:
  46.                 springAdvice = new AspectJAfterThrowingAdvice(
  47.                         candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  48.                 AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
  49.                 if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
  50.                     springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
  51.                 }
  52.                 break;
  53.             case AtAround:
  54.                 springAdvice = new AspectJAroundAdvice(
  55.                         candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  56.                 break;
  57.             case AtPointcut:
  58.                 if (logger.isDebugEnabled()) {
  59.                     logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
  60.                 }
  61.                 return null;
  62.             default:
  63.                 throw new UnsupportedOperationException(
  64.                         "Unsupported advice type on method: " + candidateAdviceMethod);
  65.         }
  67.         //设置通知方法所属的类
  68.         springAdvice.setAspectName(aspectName);
  69.         //设置通知的序号,同一个类中有多个切面注解标识的方法时,按上方说的排序规则来排序，
  70.         //其序号就是此方法在列表中的序号，第一个就是0
  71.         springAdvice.setDeclarationOrder(declarationOrder);
  72.         //获取通知方法的所有参数
  73.         String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
  74.         //将通知方法上的参数设置到通知中
  75.         if (argNames != null) {
  76.             springAdvice.setArgumentNamesFromStringArray(argNames);
  77.         }
  78.         //计算参数绑定工作，此方法详解请接着往下看
  79.         springAdvice.calculateArgumentBindings();
  80.         return springAdvice;
  81.     }
  82. }

校验方法参数并绑定(argNames()和arg())

  1. public synchronized final void calculateArgumentBindings() {
  2.     if (this.argumentsIntrospected || this.parameterTypes.length == 0) {
  3.         return;
  4.     }
  6.     int numUnboundArgs = this.parameterTypes.length;
  7.     Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
  8.     //切面注解标识的方法第一个参数要求是JoinPoint,或StaticPart，若是@Around注解则也可以是ProceedingJoinPoint
  9.     if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0])) {
  10.         numUnboundArgs--;
  11.     }
  12.     else if (maybeBindJoinPointStaticPart(parameterTypes[0])) {
  13.         numUnboundArgs--;
  14.     }
  16.     if (numUnboundArgs > 0) {
  17.     //绑定属性
  18.         bindArgumentsByName(numUnboundArgs);
  19.     }
  21.     this.argumentsIntrospected = true;
  22. }
  23. private void bindArgumentsByName(int numArgumentsExpectingToBind) {
  24.     if (this.argumentNames == null) { //获取方法参数的名称
  25.         this.argumentNames = createParameterNameDiscoverer().getParameterNames(this.aspectJAdviceMethod);
  26.     }
  27.     if (this.argumentNames != null) {
  28.         // 往下看
  29.         bindExplicitArguments(numArgumentsExpectingToBind);
  30.     }
  31.     else {
  32.         throw new IllegalStateException("Advice method [" + this.aspectJAdviceMethod.getName() + "] " +
  33.                 "requires " + numArgumentsExpectingToBind + " arguments to be bound by name, but " +
  34.                 "the argument names were not specified and could not be discovered.");
  35.     }
  36. }
  38. private void bindExplicitArguments(int numArgumentsLeftToBind) {
  39.     //此属性用来存储方法未绑定的参数名称，及参数的序号
  40.     this.argumentBindings = new HashMap<String, Integer>();
  42.     int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterTypes().length;
  43.     if (this.argumentNames.length != numExpectedArgumentNames) {
  44.         throw new IllegalStateException("Expecting to find " + numExpectedArgumentNames +
  45.                 " arguments to bind by name in advice, but actually found " +
  46.                 this.argumentNames.length + " arguments.");
  47.     }
  49.     // So we match in number...,argumentIndexOffset代表第一个未绑定参数的顺序 
  50.     int argumentIndexOffset = this.parameterTypes.length - numArgumentsLeftToBind;
  51.     for (int i = argumentIndexOffset; i < this.argumentNames.length; i++) {
  52.         //存储未绑定的参数名称及其顺序的映射关系
  53.         this.argumentBindings.put(this.argumentNames[i], i);
  54.     }
  56.     // Check that returning and throwing were in the argument names list if
  57.     // specified, and find the discovered argument types.
  58.     //如果是@AfterReturning注解的returningName 有值，验证，解析，同时得到定义返回值的类型
  59.     if (this.returningName != null) {
  60.         if (!this.argumentBindings.containsKey(this.returningName)) {
  61.             throw new IllegalStateException("Returning argument name '" + this.returningName +
  62.                     "' was not bound in advice arguments");
  63.         }
  64.         else {
  65.             Integer index = this.argumentBindings.get(this.returningName);
  66.             this.discoveredReturningType = this.aspectJAdviceMethod.getParameterTypes()[index];
  67.             this.discoveredReturningGenericType = this.aspectJAdviceMethod.getGenericParameterTypes()[index];
  68.         }
  69.     }
  70.     //如果是@AfterThrowing注解的throwingName 有值，验证，解析，同时得到抛出异常的类型
  71.     if (this.throwingName != null) {
  72.         if (!this.argumentBindings.containsKey(this.throwingName)) {
  73.             throw new IllegalStateException("Throwing argument name '" + this.throwingName +
  74.                     "' was not bound in advice arguments");
  75.         }
  76.         else {
  77.             Integer index = this.argumentBindings.get(this.throwingName);
  78.             this.discoveredThrowingType = this.aspectJAdviceMethod.getParameterTypes()[index];
  79.         }
  80.     }
  82.     // configure the pointcut expression accordingly.
  83.     configurePointcutParameters(argumentIndexOffset);
  84. }
  86. private void configurePointcutParameters(int argumentIndexOffset) {
  87.     int numParametersToRemove = argumentIndexOffset;
  88.     if (this.returningName != null) {
  89.         numParametersToRemove++;
  90.     }
  91.     if (this.throwingName != null) {
  92.         numParametersToRemove++;
  93.     }
  94.     String[] pointcutParameterNames = new String[this.argumentNames.length - numParametersToRemove];
  95.     Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
  96.     Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
  98.     int index = 0;
  99.     for (int i = 0; i < this.argumentNames.length; i++) {
  100.         if (i < argumentIndexOffset) {
  101.             continue;
  102.         }
  103.         if (this.argumentNames[i].equals(this.returningName) ||
  104.             this.argumentNames[i].equals(this.throwingName)) {
  105.             continue;
  106.         }
  107.         pointcutParameterNames[index] = this.argumentNames[i];
  108.         pointcutParameterTypes[index] = methodParameterTypes[i];
  109.         index++;
  110.     }
  111.     //剩余的未绑定的参数会赋值给AspectJExpressionPointcut(表达式形式的切入点)的属性，以备后续使用
  112.     this.pointcut.setParameterNames(pointcutParameterNames);
  113.     this.pointcut.setParameterTypes(pointcutParameterTypes);
  114. }