Spring源码分析AOP源码解析（下篇）
Posted 五月的仓颉
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring源码分析AOP源码解析（下篇）相关的知识，希望对你有一定的参考价值。
AspectJAwareAdvisorAutoProxyCreator及为Bean生成代理时机分析
上篇文章说了，org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator这个类是Spring提供给开发者的AOP的核心类，就是AspectJAwareAdvisorAutoProxyCreator完成了【类/接口-->代理】的转换过程，首先我们看一下AspectJAwareAdvisorAutoProxyCreator的层次结构：
这里最值得注意的一点是最左下角的那个方框，我用几句话总结一下：
- AspectJAwareAdvisorAutoProxyCreator是BeanPostProcessor接口的实现类
- postProcessBeforeInitialization方法与postProcessAfterInitialization方法实现在父类AbstractAutoProxyCreator中
- postProcessBeforeInitialization方法是一个空实现
- 逻辑代码在postProcessAfterInitialization方法中
基于以上的分析，将Bean生成代理的时机已经一目了然了：在每个Bean初始化之后，如果需要，调用AspectJAwareAdvisorAutoProxyCreator中的postProcessBeforeInitialization为Bean生成代理。
代理对象实例化----判断是否为<bean>生成代理
上文分析了Bean生成代理的时机是在每个Bean初始化之后，下面把代码定位到Bean初始化之后，先是AbstractAutowireCapableBeanFactory的initializeBean方法进行初始化：
1 protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { 2 if (System.getSecurityManager() != null) { 3 AccessController.doPrivileged(new PrivilegedAction<Object>() { 4 public Object run() { 5 invokeAwareMethods(beanName, bean); 6 return null; 7 } 8 }, getAccessControlContext()); 9 } 10 else { 11 invokeAwareMethods(beanName, bean); 12 } 13 14 Object wrappedBean = bean; 15 if (mbd == null || !mbd.isSynthetic()) { 16 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 17 } 18 19 try { 20 invokeInitMethods(beanName, wrappedBean, mbd); 21 } 22 catch (Throwable ex) { 23 throw new BeanCreationException( 24 (mbd != null ? mbd.getResourceDescription() : null), 25 beanName, "Invocation of init method failed", ex); 26 } 27 28 if (mbd == null || !mbd.isSynthetic()) { 29 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); 30 } 31 return wrappedBean; 32 }
初始化之前是第16行的applyBeanPostProcessorsBeforeInitialization方法，初始化之后即29行的applyBeanPostProcessorsAfterInitialization方法：
1 public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) 2 throws BeansException { 3 4 Object result = existingBean; 5 for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) { 6 result = beanProcessor.postProcessAfterInitialization(result, beanName); 7 if (result == null) { 8 return result; 9 } 10 } 11 return result; 12 }
这里调用每个BeanPostProcessor的postProcessBeforeInitialization方法。按照之前的分析，看一下AbstractAutoProxyCreator的postProcessAfterInitialization方法实现：
1 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 2 if (bean != null) { 3 Object cacheKey = getCacheKey(bean.getClass(), beanName); 4 if (!this.earlyProxyReferences.contains(cacheKey)) { 5 return wrapIfNecessary(bean, beanName, cacheKey); 6 } 7 } 8 return bean; 9 }
跟一下第5行的方法wrapIfNecessary：
1 protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { 2 if (this.targetSourcedBeans.contains(beanName)) { 3 return bean; 4 } 5 if (this.nonAdvisedBeans.contains(cacheKey)) { 6 return bean; 7 } 8 if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { 9 this.nonAdvisedBeans.add(cacheKey); 10 return bean; 11 } 12 13 // Create proxy if we have advice. 14 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); 15 if (specificInterceptors != DO_NOT_PROXY) { 16 this.advisedBeans.add(cacheKey); 17 Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); 18 this.proxyTypes.put(cacheKey, proxy.getClass()); 19 return proxy; 20 } 21 22 this.nonAdvisedBeans.add(cacheKey); 23 return bean; 24 }
第2行~第11行是一些不需要生成代理的场景判断，这里略过。首先我们要思考的第一个问题是：哪些目标对象需要生成代理？因为配置文件里面有很多Bean，肯定不能对每个Bean都生成代理，因此需要一套规则判断Bean是不是需要生成代理，这套规则就是第14行的代码getAdvicesAndAdvisorsForBean：
1 protected List<Advisor> findEligibleAdvisors(Class beanClass, String beanName) { 2 List<Advisor> candidateAdvisors = findCandidateAdvisors(); 3 List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName); 4 extendAdvisors(eligibleAdvisors); 5 if (!eligibleAdvisors.isEmpty()) { 6 eligibleAdvisors = sortAdvisors(eligibleAdvisors); 7 } 8 return eligibleAdvisors; 9 }
顾名思义，方法的意思是为指定class寻找合适的Advisor。
第2行代码，寻找候选Advisors，根据上文的配置文件，有两个候选Advisor，分别是<aop:aspect>节点下的<aop:before>和<aop:after>这两个，这两个在XML解析的时候已经被转换生成了RootBeanDefinition。
跳过第3行的代码，先看下第4行的代码extendAdvisors方法，之后再重点看一下第3行的代码。第4行的代码extendAdvisors方法作用是向候选Advisor链的开头（也就是List.get(0)的位置）添加一个org.springframework.aop.support.DefaultPointcutAdvisor。
第3行代码，根据候选Advisors，寻找可以使用的Advisor，跟一下方法实现：
1 public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) { 2 if (candidateAdvisors.isEmpty()) { 3 return candidateAdvisors; 4 } 5 List<Advisor> eligibleAdvisors = new LinkedList<Advisor>(); 6 for (Advisor candidate : candidateAdvisors) { 7 if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) { 8 eligibleAdvisors.add(candidate); 9 } 10 } 11 boolean hasIntroductions = !eligibleAdvisors.isEmpty(); 12 for (Advisor candidate : candidateAdvisors) { 13 if (candidate instanceof IntroductionAdvisor) { 14 // already processed 15 continue; 16 } 17 if (canApply(candidate, clazz, hasIntroductions)) { 18 eligibleAdvisors.add(candidate); 19 } 20 } 21 return eligibleAdvisors; 22 }
整个方法的主要判断都围绕canApply展开方法：
1 public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) { 2 if (advisor instanceof IntroductionAdvisor) { 3 return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass); 4 } 5 else if (advisor instanceof PointcutAdvisor) { 6 PointcutAdvisor pca = (PointcutAdvisor) advisor; 7 return canApply(pca.getPointcut(), targetClass, hasIntroductions); 8 } 9 else { 10 // It doesn\'t have a pointcut so we assume it applies. 11 return true; 12 } 13 }
第一个参数advisor的实际类型是AspectJPointcutAdvisor，它是PointcutAdvisor的子类，因此执行第7行的方法：
1 public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) { 2 if (!pc.getClassFilter().matches(targetClass)) { 3 return false; 4 } 5 6 MethodMatcher methodMatcher = pc.getMethodMatcher(); 7 IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null; 8 if (methodMatcher instanceof IntroductionAwareMethodMatcher) { 9 introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher; 10 } 11 12 Set<Class> classes = new HashSet<Class>(ClassUtils.getAllInterfacesForClassAsSet(targetClass)); 13 classes.add(targetClass); 14 for (Class<?> clazz : classes) { 15 Method[] methods = clazz.getMethods(); 16 for (Method method : methods) { 17 if ((introductionAwareMethodMatcher != null && 18 introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) || 19 methodMatcher.matches(method, targetClass)) { 20 return true; 21 } 22 } 23 } 24 return false; 25 }
这个方法其实就是拿当前Advisor对应的expression做了两层判断：
- 目标类必须满足expression的匹配规则
- 目标类中的方法必须满足expression的匹配规则，当然这里方法不是全部需要满足expression的匹配规则，有一个方法满足即可
如果以上两条都满足，那么容器则会判断该<bean>满足条件，需要被生成代理对象，具体方式为返回一个数组对象，该数组对象中存储的是<bean>对应的Advisor。
代理对象实例化----为<bean>生成代理代码上下文梳理
上文分析了为<bean>生成代理的条件，现在就正式看一下Spring上下文是如何为<bean>生成代理的。回到AbstractAutoProxyCreator的wrapIfNecessary方法：
1 protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { 2 if (this.targetSourcedBeans.contains(beanName)) { 3 return bean; 4 } 5 if (this.nonAdvisedBeans.contains(cacheKey)) { 6 return bean; 7 } 8 if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { 9 this.nonAdvisedBeans.add(cacheKey); 10 return bean; 11 } 12 13 // Create proxy if we have advice. 14 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); 15 if (specificInterceptors != DO_NOT_PROXY) { 16 this.advisedBeans.add(cacheKey); 17 Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); 18 this.proxyTypes.put(cacheKey, proxy.getClass()); 19 return proxy; 20 } 21 22 this.nonAdvisedBeans.add(cacheKey); 23 return bean; 24 }
第14行拿到<bean>对应的Advisor数组，第15行判断只要Advisor数组不为空，那么就会通过第17行的代码为<bean>创建代理：
1 protected Object createProxy( 2 Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) { 3 4 ProxyFactory proxyFactory = new ProxyFactory(); 5 // Copy our properties (proxyTargetClass etc) inherited from ProxyConfig. 6 proxyFactory.copyFrom(this); 7 8 if (!shouldProxyTargetClass(beanClass, beanName)) { 9 // Must allow for introductions; can\'t just set interfaces to 10 // the target\'s interfaces only. 11 Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader); 12 for (Class<?> targetInterface : targetInterfaces) { 13 proxyFactory.addInterface(targetInterface); 14 } 15 } 16 17 Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); 18 for (Advisor advisor : advisors) { 19 proxyFactory.addAdvisor(advisor); 20 } 21 22 proxyFactory.setTargetSource(targetSource); 23 customizeProxyFactory(proxyFactory); 24 25 proxyFactory.setFrozen(this.freezeProxy); 26 if (advisorsPreFiltered()) { 27 proxyFactory.setPreFiltered(true); 28 } 29 30 return proxyFactory.getProxy(this.proxyClassLoader); 31 }
第4行~第6行new出了一个ProxyFactory，Proxy，顾名思义，代理工厂的意思，提供了简单的方式使用代码获取和配置AOP代理。
第8行的代码做了一个判断，判断的内容是<aop:config>这个节点中proxy-target-class="false"或者proxy-target-class不配置，即不使用CGLIB生成代理。如果满足条件，进判断，获取当前Bean实现的所有接口，讲这些接口Class对象都添加到ProxyFactory中。
第17行~第28行的代码没什么看的必要，向ProxyFactory中添加一些参数而已。重点看第30行proxyFactory.getProxy(this.proxyClassLoader)这句：
1 public Object getProxy(ClassLoader classLoader) { 2 return createAopProxy().getProxy(classLoader); 3 }
实现代码就一行，但是却明确告诉我们做了两件事情：
- 创建AopProxy接口实现类
- 通过AopProxy接口的实现类的getProxy方法获取<bean>对应的代理
就从这两个点出发，分两部分分析一下。
代理对象实例化----创建AopProxy接口实现类
看一下createAopProxy()方法的实现，它位于DefaultAopProxyFactory类中：
1 protected final synchronized AopProxy createAopProxy() { 2 if (!this.active) { 3 activate(); 4 } 5 return getAopProxyFactory().createAopProxy(this); 6 }
前面的部分没什么必要看，直接进入重点即createAopProxy方法：
1 public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { 2 if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) { 3 Class targetClass = config.getTargetClass(); 4 if (targetClass == null) { 5 throw new AopConfigException("TargetSource cannot determine target class: " + 6 "Either an interface or a target is required for proxy creation."); 7 } 8 if (targetClass.isInterface()) { 9 return new JdkDynamicAopProxy(config); 10 } 11 if (!cglibAvailable) { 12 throw new AopConfigException( 13 "Cannot proxy target class because CGLIB2 is not available. " + 14 "Add CGLIB to the class path or specify proxy interfaces."); 15 } 16 return CglibProxyFactory.createCglibProxy(config); 17 } 18 else { 19 return new JdkDynamicAopProxy(config); 20 } 21 }
平时我们说AOP原理三句话就能概括：
- 对类生成代理使用CGLIB
- 对接口生成代理使用JDK原生的Proxy
- 可以通过配置文件指定对接口使用CGLIB生成代理
这三句话的出处就是createAopProxy方法。看到默认是第19行的代码使用JDK自带的Proxy生成代理，碰到以下三种情况例外：
- ProxyConfig的isOptimize方法为true，这表示让Spring自己去优化而不是用户指定
- ProxyConfig的isProxyTargetClass方法为true，这表示配置了proxy-target-class="true"
- ProxyConfig满足hasNoUserSuppliedProxyInterfaces方法执行结果为true，这表示<bean>对象没有实现任何接口或者实现的接口是SpringProxy接口
在进入第2行的if判断之后再根据目标<bean>的类型决定返回哪种AopProxy。简单总结起来就是：
- proxy-target-class没有配置或者proxy-target-class="false"，返回JdkDynamicAopProxy
- proxy-target-class="true"或者<bean>对象没有实现任何接口或者只实现了SpringProxy接口，返回Cglib2AopProxy
当然，不管是JdkDynamicAopProxy还是Cglib2AopProxy，AdvisedSupport都是作为构造函数参数传入的，里面存储了具体的Advisor。
代理对象实例化----通过getProxy方法获取<bean>对应的代理
其实代码已经分析到了JdkDynamicAopProxy和Cglib2AopProxy，剩下的就没什么好讲的了，无非就是看对这两种方式生成代理的熟悉程度而已。
Cglib2AopProxy生成代理的代码就不看了，对Cglib不熟悉的朋友可以看Cglib及其基本使用一文。
JdkDynamicAopProxy生成代理的方式稍微看一下：
1 public Object getProxy(ClassLoader classLoader) { 2 if (logger.isDebugEnabled()) { 3 logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource()); 4 } 5 Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised); 6 findDefinedEqualsAndHashCodeMethods(proxiedInterfaces); 7 return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); 8 }
这边解释一下第5行和第6行的代码，第5行代码的作用是拿到所有要代理的接口，第6行代码的作用是尝试寻找这些接口方法里面有没有equals方法和hashCode方法，同时都有的话打个标记，寻找结束，equals方法和hashCode方法有特殊处理。
最终通过第7行的Proxy.newProxyInstance方法获取接口/类对应的代理对象，Proxy是JDK原生支持的生成代理的方式。
代理方法调用原理
前面已经详细分析了为接口/类生成代理的原理，生成代理之后就要调用方法了，这里看一下使用JdkDynamicAopProxy调用方法的原理。
由于JdkDynamicAopProxy本身实现了InvocationHandler接口，因此具体代理前后处理的逻辑在invoke方法中：
1 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 2 MethodInvocation invocation; 3 Object oldProxy = null; 4 boolean setProxyContext = false; 5 6 TargetSource targetSource = this.advised.targetSource; 7 Class targetClass = null; 8 Object target = null; 9 10 try { 11 if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) { 12 // The target does not implement the equals(Object) method itself. 13 return equals(args[0]); 14 } 15 if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) { 16 // The target does not implement the hashCode() method itself. 17 return hashCode(); 18 } 19 if (!this.advised.opaque && method.getDeclaringClass().isInterface() && 20 method.getDeclaringClass().isAssignableFrom(Advised.class)) { 21 // Service invocations on ProxyConfig with the proxy config... 22 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args); 23 } 24 25 Object retVal; 26 27 if (this.advised.exposeProxy) { 28 // Make invocation available if necessary. 29 oldProxy = AopContext.setCurrentProxy(proxy); 30 setProxyContext = true; 31 } 32 33 // May be null. Get as late as possible to minimize the time we "own" the target, 34 // in case it comes from a pool. 35 target = targetSource.getTarget(); 36 if (target != null) { 37 targetClass = target.getClass(); 38 } 39 40 // Get the interception chain for this method. 41 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 42 43 // Check whether we have any advice. If we don\'t, we can fallback on direct 44 // reflective invocation of the target, and avoid creating a MethodInvocation. 45 if (chain.isEmpty()) { 46 // We can skip creating a MethodInvocation: just invoke the target directly 47 // Note that the final invoker must be an InvokerInterceptor so we know it does 48 // nothing but a reflective operation on the target, and no hot swapping or fancy proxying. 49 retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args); 50 } 51 else { 52 // We need to create a method invocation... 53 invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); 54 // Proceed to the joinpoint through the interceptor chain. 55 retVal = invocation.proceed(); 56 } 57 58 // Massage return value if necessary. 59 if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) && 60 !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) { 61 // Special case: it returned "this" and the return type of the method 62 // is type-compatible. Note that we can\'t help if the target sets 63 // a reference to itself in another returned object. 64 retVal = proxy; 65 } 66 return retVal; 67 } 68 finally { 69 if (target != null && !targetSource.isStatic()) { 70 // Must have come from TargetSource. 71 targetSource.releaseTarget(target); 72 } 73 if (setProxyContext) { 74 // Restore old proxy. 75 AopContext.setCurrentProxy(oldProxy); 76 } 77 Spring源码分析AOP源码解析（上篇）曹工说Spring Boot源码（18）-- Spring AOP源码分析三部曲，终于快讲完了 (aop：config完整解析下)