前文回顾
在前面我们了解到了AnnotationAwareAspectJAutoProxyCreator是如何解析Aspect切面类成Advisor列表的,在解析完Advisors之后,Spring 就要开始对符合条件的Bean做"织入"操作了.
织入切面逻辑的入口
Spring AOP是在Bean的初始化过程中进行的，Spring Bean的生命周期从宏观上可以简单视为:
实例化->依赖注入->初始化->销毁.
在完成依赖注入之后，Spring会执行initializeBean方法对Bean做初始化:
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 激活BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 激活BeanPostProcessor的postProcessBeforeInitialization方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 激活InitializingBean的afterPropertiesSet方法、initMethod
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 激活BeanPostProcessor的postProcessAfterInitialization方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
在执行完
invokeInitMethods方法之后,Spring接着触发了BeanPostProcessor的postProcessAfterInitialization方法.
AnnotationAwareAspectJAutoProxyCreator继承自AbstractAutoProxyCreator,AbstractAutoProxyCreator又通过SmartInstantiationAwareBeanPostProcessor实现了BeanPostProcessor这个顶层接口.
因此,在applyBeanPostProcessorsAfterInitialization中会触发org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization.
wrapIfNecessary
- org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 当Bean被循环引用,并且被暴露了
// 就会通过 getEarlyBeanReference来创建代理类
// 通过判断 earlyProxyReferences 中是否存在beanName来决定是否需要对target类进行动态代理
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// 代理
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
Spring在进行代理之前会判断Bean是否为空，如果不为空，那么会从缓存中查看当前Bean是否已经在之前被处理过了.
接着Spring还会查看一下earlyProxyReferences中是否存在当前bean，earlyProxyReferences是一个用来解决循环依赖的Map.
Spring处理正常Bean的织入都是在初始化后的，但是如果发生了循环依赖，Bean不得不提前暴露引用时，需要提前生成代理，此时在earlyProxyReferences中就会存放一个引用，证明当前的bean已经被提前暴露并代理了.
具体的逻辑在org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getEarlyBeanReference中.
- org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// beanName不为空，并且存在于targetSourcedBeans中，也就是自定义的TargetSource被解析过了
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// 如果Bean为advisedBeans，也不需要被代理
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// isInfrastructureClass和shouldSkip的作用:
// 识别切面类，加载切面类成advisors
// 为什么又执行一次是因为存在循环依赖的情况下无法加载advisor
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
// 返回匹配当前Bean的所有Advice、Advisor、Interceptor
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建Bean对应的代理，SingletonTargetSource用于封装实现类的信息
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;
}
- 判断缓存中是否存在当前Bean或者是当前Bean已经被代理过了，那么直接返回bean.
- 尝试再次加载advisor，避免由于循环依赖导致advisor加载不完整.
- 获取当前bean符合的advisor数组.
- 创建代理类.
本文来分析
getAdvicesAndAdvisorsForBean方法是如何在所有的advisors中找到匹配的advisor的.
- org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
// eligible->合适的、合格的
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
这里调用了
findEligibleAdvisors来寻找合适的advisors，如果返回的集合为空，那么最后返回null.
如果返回了advisors，将其数组化返回.
- org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findEligibleAdvisors
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 找到之前加载过的所有候选advisors
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 判断找到的Advisor能不能作用到当前类上
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
// 对获取到的advisor进行排序
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
- 首先获取之前解析过的advisors列表-
candidateAdvisors,这里是所有的切面类解析成的advisors.- 在
candidateAdvisors中找到当前Bean匹配的advisor-findAdvisorsThatCanApply.- 将获取到的
eligibleAdvisors进行排序.
- org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findAdvisorsThatCanApply
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
// 给currentProxiedBeanName这个ThreadLocal变量设置上正在动态代理的beanName
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
// 筛选出匹配Bean的Advisors
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
最终是调用了
AopUtils.findAdvisorsThatCanApply来筛选匹配Bean的Advisors.
- org.springframework.aop.support.AopUtils#findAdvisorsThatCanApply
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
// 存储最终匹配的Advisor集合
List<Advisor> eligibleAdvisors = new ArrayList<>();
for (Advisor candidate : candidateAdvisors) {
// 当前advisor对象是否实现了IntroductionAdvisor接口
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;
}
// canApply->判断当前的advisor的pointcut表达式是否匹配当前class
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
- 遍历
candidateAdvisors,如果advisor对象实现了IntroductionAdvisor(Introduction已经很少用了，这里不作讲解).执行canApply判断是否需要加入eligibleAdvisors.- 调用
canApply来判断当前advisor的pointcut表达式是否匹配当前class.
- org.springframework.aop.support.AopUtils#canApply
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
// 当前advisor是否实现IntroductionAdvisor
if (advisor instanceof IntroductionAdvisor) {
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
// 判断是否为PointcutAdvisor
else if (advisor instanceof PointcutAdvisor) {
// 强转为PointcutAdvisor
// Spring创建的advisor实例为InstantiationModelAwarePointcutAdvisorImpl,实现了PointcutAdvisor接口
PointcutAdvisor pca = (PointcutAdvisor) advisor;
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
// It doesn't have a pointcut so we assume it applies.
// 如果advisor没有pointcut表达式，那么匹配所有的bean
return true;
}
}
- 如果advisor是一个
IntroductionAdvisor类型的实例，那么使用ClassFilter进行matches.- 通常我们的advisor都是
InstantiationModelAwarePointcutAdvisorImpl实例，所以会执行重载的方法canApply.- 如果当前advisor没有pointcut表达式，那么匹配所有的bean.
- org.springframework.aop.support.AopUtils#canApply
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
Assert.notNull(pc, "Pointcut must not be null");
// 如果ClassFilter不匹配，也就是初步筛选失败,直接返回
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
// 如果类级别匹配，那么再继续匹配方法是否符合切点表达式
// 如果当前advisor所指代的方法切点表达式对任意方法都放行,则直接返回
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {
// No need to iterate the methods if we're matching any method anyway...
return true;
}
// 这里将methodMatcher强转为IntroductionAwareMethodMatcher类型
// 如果目标类不包含Introduction类型的advisor，那么使用
// IntroductionAwareMethodMatcher.matches方法进行匹配判断可以提升匹配的效率
// 该方法会判断目标Bean中没有使用Introduction织入新的方法，则可以使用该方法进行静态匹配，从而提升效率
// 因为Introduction类型的Advisor可以往目标类中织入新的方法，新的方法也可能是被AOP环绕的方法
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
}
Set<Class<?>> classes = new LinkedHashSet<>();
// 判断当前class是不是代理的class对象
if (!Proxy.isProxyClass(targetClass)) {
classes.add(ClassUtils.getUserClass(targetClass));
}
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(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;
}
这里就是构建拦截链中最关键的部分了，Spring要筛选出当前Bean匹配的advisor，借助了AspectJ的能力，也就是
AspectJExpressionPointcut封装的AspectJ能力.它支持类级别的匹配，也支持方法级别的匹配，还可以匹配返回值、参数类型等等.
那么顾名思义:
- ClassFilter用来匹配Class.
- MethodMatcher用来匹配Method.
再来看看整个方法，整体可以看到，先调用了ClassFilter匹配当前Bean是否符合Advisor的切点表达式，再调用了methodMatcher来匹配当前Bean的所有方法是否存在符合advisor切点表达式的.
有兴趣的可以了解一下:
org.aspectj.weaver.tools.PointcutExpression#couldMatchJoinPointsInType.
org.aspectj.weaver.tools.ShadowMatch.
- 解析后得到的advisor数组
specificInterceptors
总结
- Spring AOP的织入是发生在doCreateBean期间的，在其执行初始化时进行织入横切逻辑.但是发生循环依赖时，这个过程会被提前，也就是在暴露引用的时候可能会发生代理的创建.
- 在解析到了所有advisors之后，Spring借助AspectJ对bean进行了进一步的筛选，进而筛选到更加精确的advisor,这也使得Spring AOP支持更多元的切入点.
