上篇我们讲过了 AOP 的概念和使用方式。这篇就开始进行源码分析。
1、AOP 入口分析 上篇我们提到过，AOP 在 Spring 中是通过后置处理器的方式织入到对应的 bean 中的。负责这部分逻辑的是后置处理器 AnnotationAwareAspectJAutoProxyCreator ，但由于 AnnotationAwareAspectJAutoProxyCreator 中没有覆写父类的 postProcessAfterInitialization 方法，所以我们找到的入口在它的父类 AbstractAutoProxyCreator 中，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor , BeanFactoryAware { @Override public Object postProcessAfterInitialization (Object bean, String beanName) throws BeansException if (bean != null ) { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (!this .earlyProxyReferences.contains(cacheKey)) { return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; } protected Object wrapIfNecessary (Object bean, String beanName, Object cacheKey) if (beanName != null && this .targetSourcedBeans.contains(beanName)) { return bean; } if (Boolean.FALSE.equals(this .advisedBeans.get(cacheKey))) { return bean; } if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { this .advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null ); if (specificInterceptors != DO_NOT_PROXY) { this .advisedBeans.put(cacheKey, Boolean.TRUE); Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this .proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } this .advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } }
以上就是 Spring AOP 创建代理对象的入口方法分析，过程比较简单，这里简单总结一下：
若 bean 是 AOP 基础设施类型，则直接返回
为 bean 筛选合适的通知器
如果通知器数组不为空，则为 bean 生成代理对象，并返回该对象
若数组为空，则返回原始 bean
上面的流程看起来并不复杂，不过不要被表象所迷糊，以上流程不过是冰山一角。筛选合适的通知器和生成代理对象这两步将是我们重点关注的。
2、查找合适的通知器 在向目标 bean 中织入通知之前，我们先要为 bean 筛选出合适的通知器（通知器持有通知）。如何筛选呢？方式有很多，比如我们可以通过正则表达式匹配方法名，当然更多的时候用的是 AspectJ 表达式进行匹配。那下面我们就来看一下使用 AspectJ 表达式筛选通知器的过程，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) { List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName); if (advisors.isEmpty()) { return DO_NOT_PROXY; } return advisors.toArray(); } protected List<Advisor> findEligibleAdvisors (Class<?> beanClass, String beanName) List<Advisor> candidateAdvisors = findCandidateAdvisors(); List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName); extendAdvisors(eligibleAdvisors); if (!eligibleAdvisors.isEmpty()) { eligibleAdvisors = sortAdvisors(eligibleAdvisors); } return eligibleAdvisors; }
2.1 查找所有的通知器 Spring 提供了两种配置 AOP 的方式，一种是通过 XML 进行配置，另一种是注解。对于两种配置方式，Spring 的处理逻辑是不同的。如下面的 xml 方式的配置：
1 2 3 4 5 6 7 public class LogBeforeAdvice implements MethodBeforeAdvice @Override public void before (Method method, Object[] args, Object target) throws Throwable System.out.println("方法调用之前" ); } }
1 2 3 4 5 6 7 8 9 <bean id ="logBeforeAdvice" class ="com.huzb.demo.LogBeforeAdvice" /> <bean id ="logBeforeAdvisor" class ="org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor" > <property name ="advice" ref ="logBeforeAdvice" /> <property name ="expression" value ="execution(* com.huzb.demo.CarImpl.run(..))" /> </bean > <bean class ="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
它和下面的注解方式是等价的：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 @Component @Aspect public class LogAspect @Pointcut ("execution(* com.huzb.demo.CarImpl.run(..))" ) public void pointCut () } @Before ("pointCut()" ) public void logStart (JoinPoint joinPoint) Object[] args = joinPoint.getArgs(); System.out.println("方法调用之前" ); } @AfterReturning (value = "pointCut()" , returning = "result" ) public void logReturn (JoinPoint joinPoint, Object result) System.out.println("方法返回的结果为：" + result.toString()); } }
上述两种配置下，Spring 除了生成一个普通的 bean 对象外，还会生成一个类型为 AspectJExpressionPointcut 的对象和两个类型为 AspectJPointcutAdvisor（注意不是 Advice，是 Advisor，这是一种只包含一个 Advice 和一个 Pointcut 的特殊切面，可以叫它通知器） 的对象，分别表示切点和通知器。也就是说，在 Spring 中，切点和通知器是被当成单独的 bean 加入容器的，尽管它们可能并不作为一个类被定义。下面让我们看一下源码：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator @Override protected List<Advisor> findCandidateAdvisors () List<Advisor> advisors = super .findCandidateAdvisors(); advisors.addAll(this .aspectJAdvisorsBuilder.buildAspectJAdvisors()); return advisors; } }
AnnotationAwareAspectJAutoProxyCreator 覆写了父类的方法 findCandidateAdvisors，并增加了一步操作，即解析 @Aspect 注解，并构建成通知器。下面我们先来分析一下父类中的 findCandidateAdvisors 方法的逻辑，然后再来分析 buildAspectJAdvisors 方法的逻辑。
2.1.1 findCandidateAdvisors 方法分析 我们先来看一下 AbstractAdvisorAutoProxyCreator 中 findCandidateAdvisors 方法的定义，如下：
1 2 3 4 5 6 7 8 9 10 11 12 public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper; protected List<Advisor> findCandidateAdvisors () return this .advisorRetrievalHelper.findAdvisorBeans(); } }
从上面的源码中可以看出，AbstractAdvisorAutoProxyCreator 中的 findCandidateAdvisors 是个空壳方法，所有逻辑封装在了一个 BeanFactoryAdvisorRetrievalHelper 的 findAdvisorBeans 方法中。这里大家可以仔细看一下类名 BeanFactoryAdvisorRetrievalHelper 和方法 findAdvisorBeans，两个名字其实已经描述出他们的职责了。BeanFactoryAdvisorRetrievalHelper 可以理解为从 bean 容器中获取 Advisor 的帮助类，findAdvisorBeans 则可理解为查找 Advisor 类型的 bean。所以即使不看 findAdvisorBeans 方法的源码，我们也可从方法名上推断出它要做什么，即从 bean 容器中将 Advisor 类型的 bean 查找出来。下面我们来分析一下这个方法的源码，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 public List<Advisor> findAdvisorBeans () String[] advisorNames = null ; synchronized (this ) { advisorNames = this .cachedAdvisorBeanNames; if (advisorNames == null ) { advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this .beanFactory, Advisor.class, true , false ); this .cachedAdvisorBeanNames = advisorNames; } } if (advisorNames.length == 0 ) { return new LinkedList<Advisor>(); } List<Advisor> advisors = new LinkedList<Advisor>(); for (String name : advisorNames) { if (isEligibleBean(name)) { if (this .beanFactory.isCurrentlyInCreation(name)) { if (logger.isDebugEnabled()) { logger.debug("Skipping currently created advisor '" + name + "'" ); } } else { try { advisors.add(this .beanFactory.getBean(name, Advisor.class)); } catch (BeanCreationException ex) { Throwable rootCause = ex.getMostSpecificCause(); if (rootCause instanceof BeanCurrentlyInCreationException) { BeanCreationException bce = (BeanCreationException) rootCause; if (this .beanFactory.isCurrentlyInCreation(bce.getBeanName())) { if (logger.isDebugEnabled()) { logger.debug("Skipping advisor '" + name + "' with dependency on currently created bean: " + ex.getMessage()); } continue ; } } throw ex; } } } } return advisors; }
以上就是从容器中查找 Advisor 类型的 bean 所有的逻辑，代码虽然有点长，但并不复杂。主要做了三件事情：
从缓存中获取所有 Advisor 的名称
如果缓存中没有，就从容器中查找所有类型为 Advisor 的 bean 对应的名称，然后放入缓存
遍历 advisorNames，使用 getBean 方法创建或从容器中获取对应的 bean
看完上面的分析，我们继续来分析一下 @Aspect 注解的解析过程。
2.1.2 buildAspectJAdvisors 方法分析 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 public List<Advisor> buildAspectJAdvisors () List<String> aspectNames = this .aspectBeanNames; if (aspectNames == null ) { synchronized (this ) { aspectNames = this .aspectBeanNames; if (aspectNames == null ) { List<Advisor> advisors = new LinkedList<Advisor>(); aspectNames = new LinkedList<String>(); String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors( this .beanFactory, Object.class, true , false ); for (String beanName : beanNames) { if (!isEligibleBean(beanName)) { continue ; } Class<?> beanType = this .beanFactory.getType(beanName); if (beanType == null ) { continue ; } if (this .advisorFactory.isAspect(beanType)) { aspectNames.add(beanName); AspectMetadata amd = new AspectMetadata(beanType, beanName); if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) { MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this .beanFactory, beanName); List<Advisor> classAdvisors = this .advisorFactory.getAdvisors(factory); if (this .beanFactory.isSingleton(beanName)) { this .advisorsCache.put(beanName, classAdvisors); } else { this .aspectFactoryCache.put(beanName, factory); } advisors.addAll(classAdvisors); } else { if (this .beanFactory.isSingleton(beanName)) { throw new IllegalArgumentException("Bean with name '" + beanName + "' is a singleton, but aspect instantiation model is not singleton" ); } MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this .beanFactory, beanName); this .aspectFactoryCache.put(beanName, factory); advisors.addAll(this .advisorFactory.getAdvisors(factory)); } } } this .aspectBeanNames = aspectNames; return advisors; } } } if (aspectNames.isEmpty()) { return Collections.emptyList(); } List<Advisor> advisors = new LinkedList<Advisor>(); for (String aspectName : aspectNames) { List<Advisor> cachedAdvisors = this .advisorsCache.get(aspectName); if (cachedAdvisors != null ) { advisors.addAll(cachedAdvisors); } else { MetadataAwareAspectInstanceFactory factory = this .aspectFactoryCache.get(aspectName); advisors.addAll(this .advisorFactory.getAdvisors(factory)); } } return advisors; }
上面就是 buildAspectJAdvisors 的代码，看起来比较长。代码比较多，我们关注重点的方法调用即可。在进行后续的分析前，这里先对 buildAspectJAdvisors 方法的执行流程做个总结。如下：
检查是否已经解析过，已经解析过的话拿到所有包含 Aspect 注解的类名，跳到步骤6
获取容器中所有 bean 的名称（beanName）和类型
根据 beanType 判断当前 bean 是否是一个包含 Aspect 注解的类，如果是的话调用 advisorFactory.getAdvisors 获取通知器
将通知器保存在缓存中
设置 this.aspectBeanNames 为所有包含 Aspect 注解的类名
按 this.aspectBeanNames 从缓存中获取所有通知器
下面我们来重点分析 advisorFactory.getAdvisors(factory) 这个调用，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 public List<Advisor> getAdvisors (MetadataAwareAspectInstanceFactory aspectInstanceFactory) Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass(); String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName(); validate(aspectClass); MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory); List<Advisor> advisors = new LinkedList<Advisor>(); for (Method method : getAdvisorMethods(aspectClass)) { Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName); if (advisor != null ) { advisors.add(advisor); } } if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) { Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory); advisors.add(0 , instantiationAdvisor); } for (Field field : aspectClass.getDeclaredFields()) { Advisor advisor = getDeclareParentsAdvisor(field); if (advisor != null ) { advisors.add(advisor); } } return advisors; } public Advisor getAdvisor (Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrderInAspect, String aspectName) validate(aspectInstanceFactory.getAspectMetadata().getAspectClass()); AspectJExpressionPointcut expressionPointcut = getPointcut( candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass()); if (expressionPointcut == null ) { return null ; } return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this , aspectInstanceFactory, declarationOrderInAspect, aspectName); }
如上，getAdvisor 方法包含两个主要步骤，一个是获取 AspectJ 表达式切点，另一个是创建 Advisor 实现类。在第二个步骤中，包含一个隐藏步骤 – 创建 Advice。下面我将按顺序依次分析这两个步骤，先看获取 AspectJ 表达式切点的过程，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 private AspectJExpressionPointcut getPointcut (Method candidateAdviceMethod, Class<?> candidateAspectClass) AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod); if (aspectJAnnotation == null ) { return null ; } AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0 ], new Class<?>[0 ]); ajexp.setExpression(aspectJAnnotation.getPointcutExpression()); ajexp.setBeanFactory(this .beanFactory); return ajexp; } protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) { Class<?>[] classesToLookFor = new Class<?>[] { Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class}; for (Class<?> c : classesToLookFor) { AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c); if (foundAnnotation != null ) { return foundAnnotation; } } return null ; }
获取切点的过程并不复杂，不过需要注意的是，目前获取到的切点可能还只是个半成品，需要再次处理一下才行。比如下面的代码：
1 2 3 4 5 6 7 8 9 10 11 12 13 @Component @Aspect public class LogAspect @Pointcut ("execution(* com.huzb.demo.CarImpl.run(..))" ) public void pointCut () } @Before ("pointCut()" ) public void logStart (JoinPoint joinPoint) Object[] args = joinPoint.getArgs(); System.out.println("方法调用之前" ); } }
@Before 注解中的表达式是pointcut()，也就是说 ajexp 设置的表达式只是一个中间值，不是最终值。所以后续还需要将 ajexp 中的表达式进行转换，关于这个转换的过程非常复杂，也不是重点，这里就不展开了。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 public InstantiationModelAwarePointcutAdvisorImpl (AspectJExpressionPointcut declaredPointcut, Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) this .declaredPointcut = declaredPointcut; this .declaringClass = aspectJAdviceMethod.getDeclaringClass(); this .methodName = aspectJAdviceMethod.getName(); this .parameterTypes = aspectJAdviceMethod.getParameterTypes(); this .aspectJAdviceMethod = aspectJAdviceMethod; this .aspectJAdvisorFactory = aspectJAdvisorFactory; this .aspectInstanceFactory = aspectInstanceFactory; this .declarationOrder = declarationOrder; this .aspectName = aspectName; if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) { Pointcut preInstantiationPointcut = Pointcuts.union( aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this .declaredPointcut); this .pointcut = new PerTargetInstantiationModelPointcut( this .declaredPointcut, preInstantiationPointcut, aspectInstanceFactory); this .lazy = true ; } else { this .pointcut = this .declaredPointcut; this .lazy = false ; this .instantiatedAdvice = instantiateAdvice(this .declaredPointcut); } }
上面是 InstantiationModelAwarePointcutAdvisorImpl 的构造方法，不过我们无需太关心这个方法中的一些初始化逻辑。我们把目光移到构造方法的最后一行代码中，即 instantiateAdvice(this.declaredPointcut)，这个方法用于创建通知 Advice。我们之前提到过，通知器 Advisor 是通知 Advice 的持有者，所以在 Advisor 实现类的构造方法中创建通知也是合适的。那下面我们就来看看构建通知的过程是怎样的，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 private Advice instantiateAdvice (AspectJExpressionPointcut pcut) return this .aspectJAdvisorFactory.getAdvice(this .aspectJAdviceMethod, pcut, this .aspectInstanceFactory, this .declarationOrder, this .aspectName); } public Advice getAdvice (Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass(); validate(candidateAspectClass); AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod); if (aspectJAnnotation == null ) { return null ; } if (!isAspect(candidateAspectClass)) { throw new AopConfigException("Advice must be declared inside an aspect type: Offending method '" + candidateAdviceMethod + "' in class [" + candidateAspectClass.getName() + "]" ); } if (logger.isDebugEnabled()) { logger.debug("Found AspectJ method: " + candidateAdviceMethod); } AbstractAspectJAdvice springAdvice; switch (aspectJAnnotation.getAnnotationType()) { case AtBefore: springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); break ; case AtAfter: springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); break ; case AtAfterReturning: springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation(); if (StringUtils.hasText(afterReturningAnnotation.returning())) { springAdvice.setReturningName(afterReturningAnnotation.returning()); } break ; case AtAfterThrowing: springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation(); if (StringUtils.hasText(afterThrowingAnnotation.throwing())) { springAdvice.setThrowingName(afterThrowingAnnotation.throwing()); } break ; case AtAround: springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); break ; case AtPointcut: if (logger.isDebugEnabled()) { logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'" ); } return null ; default : throw new UnsupportedOperationException( "Unsupported advice type on method: " + candidateAdviceMethod); } springAdvice.setAspectName(aspectName); springAdvice.setDeclarationOrder(declarationOrder); String[] argNames = this .parameterNameDiscoverer.getParameterNames(candidateAdviceMethod); if (argNames != null ) { springAdvice.setArgumentNamesFromStringArray(argNames); } springAdvice.calculateArgumentBindings(); return springAdvice; }
上面的代码逻辑不是很复杂，主要的逻辑就是根据注解类型生成与之对应的通知对象。下面来总结一下获取通知器（getAdvisors）整个过程的逻辑，如下：
从目标 bean 中获取不包含 Pointcut 注解的方法列表
遍历上一步获取的方法列表，并调用 getAdvisor 获取当前方法对应的 Advisor
创建 AspectJExpressionPointcut 对象，并从方法中的注解中获取表达式，设置到切点对象中
创建 Advisor 实现类对象 InstantiationModelAwarePointcutAdvisorImpl
调用 instantiateAdvice 方法构建通知
调用 getAdvice 方法，并根据注解类型创建相应的通知
如上所示，上面的步骤做了一定的简化。总的来说，获取通知器的过程还是比较复杂的，并不是很容易看懂。现在，大家知道了通知是怎么创建的。那我们难道不要去看看这些通知的实现源码吗？显然，我们应该看一下。那接下里，我们一起来分析一下 AspectJMethodBeforeAdvice，也就是 @Before 注解对应的通知实现类。看看它的逻辑是什么样的。
2.1.3 AspectJMethodBeforeAdvice 分析
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice public AspectJMethodBeforeAdvice ( Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) super (aspectJBeforeAdviceMethod, pointcut, aif); } @Override public void before (Method method, Object[] args, Object target) throws Throwable invokeAdviceMethod(getJoinPointMatch(), null , null ); } @Override public boolean isBeforeAdvice () return true ; } @Override public boolean isAfterAdvice () return false ; } } protected Object invokeAdviceMethod (JoinPointMatch jpMatch, Object returnValue, Throwable ex) throws Throwable return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex)); } protected Object invokeAdviceMethodWithGivenArgs (Object[] args) throws Throwable Object[] actualArgs = args; if (this .aspectJAdviceMethod.getParameterTypes().length == 0 ) { actualArgs = null ; } try { ReflectionUtils.makeAccessible(this .aspectJAdviceMethod); return this .aspectJAdviceMethod.invoke(this .aspectInstanceFactory.getAspectInstance(), actualArgs); } catch (IllegalArgumentException ex) { throw new AopInvocationException("Mismatch on arguments to advice method [" + this .aspectJAdviceMethod + "]; pointcut expression [" + this .pointcut.getPointcutExpression() + "]" , ex); } catch (InvocationTargetException ex) { throw ex.getTargetException(); } }
如上，AspectJMethodBeforeAdvice 的源码比较简单，这里我们仅关注 before 方法。这个方法调用了父类中的 invokeAdviceMethod，然后 invokeAdviceMethod 在调用 invokeAdviceMethodWithGivenArgs，最后在 invokeAdviceMethodWithGivenArgs 通过反射执行通知方法。是不是很简单？
关于 AspectJMethodBeforeAdvice 就简单介绍到这里吧，至于剩下的几种实现，大家可以自己去看看。好了，关于 AspectJMethodBeforeAdvice 的源码分析，就分析到这里了。我们继续往下看吧。
2.2 筛选通知器 查找出所有的通知器，整个流程还没算完，接下来我们还要对这些通知器进行筛选。筛选出适合应用在当前 bean 上的通知器。那下面我们来分析一下通知器筛选的过程，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 protected List<Advisor> findAdvisorsThatCanApply ( List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) ProxyCreationContext.setCurrentProxiedBeanName(beanName); try { return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass); } finally { ProxyCreationContext.setCurrentProxiedBeanName(null ); } } public static List<Advisor> findAdvisorsThatCanApply (List<Advisor> candidateAdvisors, Class<?> clazz) if (candidateAdvisors.isEmpty()) { return candidateAdvisors; } List<Advisor> eligibleAdvisors = new LinkedList<Advisor>(); for (Advisor candidate : candidateAdvisors) { if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) { eligibleAdvisors.add(candidate); } } boolean hasIntroductions = !eligibleAdvisors.isEmpty(); for (Advisor candidate : candidateAdvisors) { if (candidate instanceof IntroductionAdvisor) { continue ; } if (canApply(candidate, clazz, hasIntroductions)) { eligibleAdvisors.add(candidate); } } return eligibleAdvisors; } public static boolean canApply (Advisor advisor, Class<?> targetClass, boolean hasIntroductions) if (advisor instanceof IntroductionAdvisor) { return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass); } else if (advisor instanceof PointcutAdvisor) { PointcutAdvisor pca = (PointcutAdvisor) advisor; return canApply(pca.getPointcut(), targetClass, hasIntroductions); } else { return true ; } } public static boolean canApply (Pointcut pc, Class<?> targetClass, boolean hasIntroductions) Assert.notNull(pc, "Pointcut must not be null" ); if (!pc.getClassFilter().matches(targetClass)) { return false ; } MethodMatcher methodMatcher = pc.getMethodMatcher(); if (methodMatcher == MethodMatcher.TRUE) { return true ; } IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null ; if (methodMatcher instanceof IntroductionAwareMethodMatcher) { introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher; } Set<Class<?>> classes = new LinkedHashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass)); classes.add(targetClass); for (Class<?> clazz : classes) { Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz); for (Method method : methods) { if ((introductionAwareMethodMatcher != null && introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) || methodMatcher.matches(method, targetClass)) { return true ; } } } return false ; }
以上是通知器筛选的过程，筛选的工作主要由 ClassFilter 和 MethodMatcher 完成。ClassFilter 和 MethodMatcher 两个接口，都有一个 matches 的抽象方法。以 AspectJExpressionPointcut 类型的切点为例。该类型切点实现了ClassFilter 和 MethodMatcher 接口，匹配的工作则是由 AspectJ 表达式解析器负责。除了使用 AspectJ 表达式进行匹配，Spring 还提供了基于正则表达式的切点类，以及更简单的根据方法名进行匹配的切点类。这块内容很多，这里就不展开了。
在完成通知器的查找和筛选过程后，还需要进行最后一步处理 – 对通知器列表进行拓展。怎么拓展呢？我们一起到下一节中一探究竟吧。
2.3 拓展筛选出通知器列表 拓展方法 extendAdvisors 做的事情并不多，逻辑也比较简单。我们一起来看一下，如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 protected void extendAdvisors (List<Advisor> candidateAdvisors) AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors); } public static boolean makeAdvisorChainAspectJCapableIfNecessary (List<Advisor> advisors) if (!advisors.isEmpty()) { boolean foundAspectJAdvice = false ; for (Advisor advisor : advisors) { if (isAspectJAdvice(advisor)) { foundAspectJAdvice = true ; } } if (foundAspectJAdvice && !advisors.contains(ExposeInvocationInterceptor.ADVISOR)) { advisors.add(0 , ExposeInvocationInterceptor.ADVISOR); return true ; } } return false ; } private static boolean isAspectJAdvice (Advisor advisor) return (advisor instanceof InstantiationModelAwarePointcutAdvisor || advisor.getAdvice() instanceof AbstractAspectJAdvice || (advisor instanceof PointcutAdvisor && ((PointcutAdvisor) advisor).getPointcut() instanceof AspectJExpressionPointcut)); }
如上，上面的代码比较少，也不复杂。由源码可以看出 extendAdvisors 是一个空壳方法，除了调用makeAdvisorChainAspectJCapableIfNecessary，该方法没有其他更多的逻辑了。至于 makeAdvisorChainAspectJCapableIfNecessary 这个方法，该方法主要的目的是向通知器列表首部添加 DefaultPointcutAdvisor 类型的通知器，也就是 ExposeInvocationInterceptor.ADVISOR。这种通知器用到的地方不多，了解一下就好。
3、总结 本篇文章我们从 AOP 的入口代码出发，看到 AOP 主要分两步：筛选合适的通知器和生成代理对象。筛选合适的通知器是个复杂的工作，因为要考虑两种情况：xml 和注解。对于 xml 形式的通知器，会声明为 Advisor 类型，所以我们的工作是找出所有 Advisor 类型的 beanName 并通过 getBean 的方式获取或创建它；对于注解形式的通知器，我们要找到所有标记了 @Aspect 的 bean，然后把它的每一个标记了 @Before、@After 等表示通知的方法封装成一个通知器。封装的过程分为两步：解析注解里的切点表达式，将其封装成一个 AspectJExpressionPointcut 对象和按照注解类型生成相应的 Advice 实现类。最后封装好的 Advisor 和原有的 Advisor 类型对象会被一起返回。接下来就是筛选工作，筛选是为了找出能和当前 bean 匹配上的 Advisor，这个工作会由 Advisor 中的 Pointcut 对象完成。以 AspectJExpressionPointcut 为例，它实现了 ClassFilter 和 MethodMatcher 两个接口的 matches 方法，内部有一个 AspectJ 表达式解析器，可以判断当前 bean 和 Advisor 是否匹配。然后我们就得到了一组匹配当前 bean 的 Advisor。
Be the first person to leave a comment!