資訊專欄INFORMATION COLUMN
摘要：版本如何掃描接上一回，講到了方法，該方法的目的是獲取并生成。其中英文為源碼注釋。那么，以上便是通過掃描配置并生成的過程了。一些總結讀到這兒，如何掃描配置，生成類，并匹配對應的整個流程已經很清楚了。
版本
spring 5.0.8.BUILD-SNAPSHOT
aspectjweaver 1.8.13
如何掃描Advice接上一回，講到了getAdvicesAndAdvisorsForBean方法，該方法的目的是獲取并生成Advisor Bean。其中包含了掃描通過@Aspect注解配置且與Bean方法的匹配的Advice，也是本章主要講的內容
getAdvicesAndAdvisorsForBean/org/springframework/aop/framework/autoproxy/AbstractAdvisorAutoProxyCreator.java
@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(
Class beanClass, String beanName, @Nullable TargetSource targetSource) {
List advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
/**
* Find all eligible Advisors for auto-proxying this class.
* @param beanClass the clazz to find advisors for
* @param beanName the name of the currently proxied bean
* @return the empty List, not {@code null},
* if there are no pointcuts or interceptors
* @see #findCandidateAdvisors
* @see #sortAdvisors
* @see #extendAdvisors
*/
protected List findEligibleAdvisors(Class beanClass, String beanName) {
List candidateAdvisors = findCandidateAdvisors();
List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
....
關注findEligibleAdvisors方法可以清楚地知道這里主要分四步：
findCandidateAdvisors (獲取候選Advisor)
findAdvisorsThatCanApply (獲取適用于bean的Advisor: 例如Pointcut匹配)
extendAdvisors (特殊處理，這里不贅述)
sortAdvisors (排序，不贅述)
什么是Advisor？ 首先，Advice是增強方法，即@Around, @Before等注解修飾的方法。而Advisor則是在Advice之上再包了一層。例如PointcutAdvisor則包有Advice和Pointcut
下面接著看findCandidateAdvisors和findAdvisorsThatCanApply
findCandidateAdvisors/org/springframework/aop/framework/autoproxy/AbstractAdvisorAutoProxyCreator.java .... /** * Find all candidate Advisors to use in auto-proxying. * @return the List of candidate Advisors */ protected ListfindCandidateAdvisors() { Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available"); return this.advisorRetrievalHelper.findAdvisorBeans(); } .... /org/springframework/aop/aspectj/annotation/AnnotationAwareAspectJAutoProxyCreator.java .... @Override protected List findCandidateAdvisors() { // Add all the Spring advisors found according to superclass rules. List advisors = super.findCandidateAdvisors(); // Build Advisors for all AspectJ aspects in the bean factory. if (this.aspectJAdvisorsBuilder != null) { advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors()); } return advisors; } ....
這里findCandidateAdvisors在AbstractAdvisorAutoProxyCreator中有實現，同時被AnnotationAwareAspectJAutoProxyCreator重寫了。不過可以看到重寫的方法中先調用了super.findCandidateAdvisor，因此兩個方法的代碼都被執行了。
this.advisorRetrievalHelper.findAdvisorBeans (該方法主要從BeanFactory中獲取Advisor Bean)
this.aspectJAdvisorsBuilder.buildAspectJAdvisors (從所有Bean中獲取@Aspect配置的Bean并創建Advisor，也是我們關注的內容，下面細講)
/org/springframework/aop/aspectj/annotation/BeanFactoryAspectJAdvisorsBuilder.java .... /** * Look for AspectJ-annotated aspect beans in the current bean factory, * and return to a list of Spring AOP Advisors representing them. *Creates a Spring Advisor for each AspectJ advice method. * @return the list of {@link org.springframework.aop.Advisor} beans * @see #isEligibleBean */ public List
buildAspectJAdvisors() { // aspectBeanNames，緩存 // tips: aspectBeanNames由volatile修飾 // volatile: 保證變量可見性，指令不可重排 List aspectNames = this.aspectBeanNames; // 如緩存存在，則跳過初始化步驟 if (aspectNames == null) { // synchronized， 同步鎖 // 鎖住當前實例，里面的內容同一時間只會被一個線程執行 synchronized (this) { // 拿到鎖后再次獲取緩存，避免重復初始化 aspectNames = this.aspectBeanNames; if (aspectNames == null) { List advisors = new ArrayList<>(); aspectNames = new ArrayList<>(); // 獲取原始類為Object的bean，即所有bean String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors( this.beanFactory, Object.class, true, false); for (String beanName : beanNames) { // 是否是合適的bean if (!isEligibleBean(beanName)) { continue; } // We must be careful not to instantiate beans eagerly as in this case they // would be cached by the Spring container but would not have been weaved. Class beanType = this.beanFactory.getType(beanName); if (beanType == null) { continue; } // isAspect 是否為@Aspect注解修飾的Bean // 是不是很親切方法，終于讀到它了。這是我們在第二章一開始就提到的方法。 if (this.advisorFactory.isAspect(beanType)) { aspectNames.add(beanName); // 由beanType，beanName組合Metadata，包含了創建Advisor需要的內容 AspectMetadata amd = new AspectMetadata(beanType, beanName); // PerClauseKind.SINGLETON 單例模式 // 由@Aspect中的value參數配置，這個參數Bean的scope 有點類似，用來配置生命 周期，默認都為單例。可配為"每..."的模式 if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) { // 生成實例工廠類 MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName); // 生成Advisors實例 List classAdvisors = this.advisorFactory.getAdvisors(factory); // 如果Aspect Bean是單例，則緩存到advisorsCache if (this.beanFactory.isSingleton(beanName)) { this.advisorsCache.put(beanName, classAdvisors); } // 如果不是，則將工廠緩存到aspectFactoryCache else { this.aspectFactoryCache.put(beanName, factory); } advisors.addAll(classAdvisors); } else { // Per target or per this. // bean為單例，@Aspect也要配置為單例 if (this.beanFactory.isSingleton(beanName)) { throw new IllegalArgumentException("Bean with name "" + beanName + "" is a singleton, but aspect instantiation model is not singleton"); } // 跟前一個分支一樣，生成Advisors實例，然后將工廠緩存到aspectFactoryCache 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 advisors = new ArrayList<>(); for (String aspectName : aspectNames) { // 通過aspectName(beanName)獲取advisors緩存 List cachedAdvisors = this.advisorsCache.get(aspectName); // 如已存在，則加載advisorsCache if (cachedAdvisors != null) { advisors.addAll(cachedAdvisors); } // 如不存在，則加載factoryCache，再從工廠生成advisors，與上面初始時候的兩個分支對應 // ps:這里并沒有做factory的空判斷... else { MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName); advisors.addAll(this.advisorFactory.getAdvisors(factory)); } } return advisors; } ....
由于這段代碼比較長，我將過程注釋在代碼中。其中英文為源碼注釋。
那么，以上便是通過beanName掃描@Aspect配置并生成Advisor的過程了。其中this.advisorFactory.getAdvisors(factory)是生成Advisor類的具體內容。深挖的話還能再寫一篇文章，這里就不細說了。有興趣的可以自行閱讀。
findAdvisorsThatCanApply現在我們獲得了所有的候選Advisor，那么找出和當前Bean匹配的Advisor呢？
/org/springframework/aop/framework/autoproxy/AbstractAdvisorAutoProxyCreator.java .... /** * Search the given candidate Advisors to find all Advisors that * can apply to the specified bean. * @param candidateAdvisors the candidate Advisors * @param beanClass the target"s bean class * @param beanName the target"s bean name * @return the List of applicable Advisors * @see ProxyCreationContext#getCurrentProxiedBeanName() */ protected ListfindAdvisorsThatCanApply( List candidateAdvisors, Class beanClass, String beanName) { ProxyCreationContext.setCurrentProxiedBeanName(beanName); try { return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass); } finally { ProxyCreationContext.setCurrentProxiedBeanName(null); } } ....
一步一步往下探
/org/springframework/aop/support/AopUtils.java
....
/**
* Determine the sublist of the {@code candidateAdvisors} list
* that is applicable to the given class.
* @param candidateAdvisors the Advisors to evaluate
* @param clazz the target class
* @return sublist of Advisors that can apply to an object of the given class
* (may be the incoming List as-is)
*/
public static List findAdvisorsThatCanApply(List candidateAdvisors, Class clazz) {
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
List eligibleAdvisors = new ArrayList<>();
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) {
// already processed
continue;
}
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
....
/**
* Can the given advisor apply at all on the given class?
* This is an important test as it can be used to optimize
* out a advisor for a class.
* @param advisor the advisor to check
* @param targetClass class we"re testing
* @return whether the pointcut can apply on any method
*/
public static boolean canApply(Advisor advisor, Class targetClass) {
return canApply(advisor, targetClass, false);
}
/**
* Can the given advisor apply at all on the given class?
* This is an important test as it can be used to optimize out a advisor for a class.
* This version also takes into account introductions (for IntroductionAwareMethodMatchers).
* @param advisor the advisor to check
* @param targetClass class we"re testing
* @param hasIntroductions whether or not the advisor chain for this bean includes
* any introductions
* @return whether the pointcut can apply on any method
*/
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 {
// It doesn"t have a pointcut so we assume it applies.
return true;
}
}
....
最后定位到canApply(Pointcut pc, Class targetClass, boolean hasIntroductions)方法
