Spring源码-AOP(六)-自动代理与DefaultAdvisorAutoProxyCreator
2017-08-21 00:00
741 查看
摘要: The best way to predict the future is to invent it. 预测未来的最好方法就是创造未来。 -- 沃尔特·艾萨克森 《乔布斯传》
Spring AOP 源码解析系列,建议大家按顺序阅读,欢迎讨论
Spring源码-AOP(一)-代理模式
Spring源码-AOP(二)-AOP概念
Spring源码-AOP(三)-Spring AOP的四种实现
Spring源码-AOP(四)-ProxyFactory
Spring源码-AOP(五)-ProxyFactoryBean
Spring源码-AOP(六)-自动代理与DefaultAdvisorAutoProxyCreator
Spring源码-AOP(七)-整合AspectJ
框架存在的意义,简单来说就是将复杂的底层实现封装起来,并提供便捷的外部接口供用户使用。对于Spring AOP而言,不论是ProxyFactory还是ProxyFactoryBean,都不能满足实际业务中复杂的应用,用户不可能对每个使用AOP代理的类进行配置。这时通过一定规则自动发现和代理自然应运而生。在spring-aop工程的autoproxy目录构成了Spring AOP自动代理的基础,AbstractAutoProxyCreator是自动代理实现的抽象基类,BeanNameAutoProxyCreator和DefaultAdvisorAutoProxyCreator则是Spring提供的两个实现。
自动代理的实现原理同ProxyFactoryBean中使用FactoryBean扩展不同,而是通过BeanPostProcessor扩展对Bean对象的创建过程进行控制来实现AOP代理。抽象基类AbstractAutoProxyCreator实现了BeanPostProcessor的子接口SmartInstantiationAwareBeanPostProcessor。先来了解下这个子接口。
BeanPostProcessor
postProcessBeforeInitialization 初始化前扩展(执行init-method前)
postProcessAfterInitialization 初始化后扩展(执行init-method后)
InstantiationAwareBeanPostProcessor
postProcessBeforeInstantiation 对象实例化前扩展
postProcessAfterInstantiation 对象实例化后扩展
postProcessPropertyValues 属性依赖注入前扩展
SmartInstantiationAwareBeanPostProcessor
predictBeanType 预测bean的类型,在beanFactory的getType时被调用
determineCandidateConstructors 对象实例化时决定要使用的构造函数时被调用
getEarlyBeanReference 循环依赖处理时获取Early对象引用时被调用
而对于Spring AOP的自动代理,处理的阶段有两个,对象实例化前扩展和初始化后扩展。
LazyInitTargetSourceCreator:创建的代理对象并没有初始化,直到第一次调用时才进行初始化
QuickTargetSourceCreator:根据beanName的不同前缀创建三种常用的TargetSource类型(bean必须为多例)
CommonsPoolTargetSource:池化TargetSource,每次执行方法时从池中取代理对象,执行完方法再返回池中
ThreadLocalTargetSource:线程级的TargetSource
PrototypeTargetSource:多例TargetSource,每次执行方法创建新的代理对象,执行完销毁该对象
来看下核心代码
第一步获取定义TargetSource,即遍历所有自定义TargetSourceCreator,调用getTargetSource方法返回TargetSource。
第二步获取拦截器由子类实现,根据不同的方式获取当前bean的拦截器,在后文以子类DefaultAdvisorAutoProxyCreator为例详细介绍。
第三步创建代理对象,通过创建ProxyFactory的方式完成,原理细节见ProxyFactory,来简单看下它的实现。
可以说逻辑非常清晰,最后使用ProxyFactory创建代理对象也是使用ProxyFactory统一的API。如果最终返回的代理对象不为空,则直接返回代理对象,不再执行IOC中的对象属性注入和初始化等操作了。
wrapIfNecessary方法执行代理的核心操作。
实现过程基本同之前的一直,由子类返回拦截器集合,创建ProxyFactory对象进行代理。
DefaultAdvisorAutoProxyCreator的获取拦截器实现其实由其抽象基类AbstractAdvisorAutoProxyCreator实现。
实际操作有findEligibleAdvisors执行
主要过程分为两步,第一步寻找所有Advisor候选者,即自动发现切面,第二部筛选当前bean的Advisor。
findCandidateAdvisors由BeanFactoryAdvisorRetrievalHelper帮助类执行,原理就是从BeanFactory及其所有父级BeanFactory中寻找类型为Advisor的类,并执行getBean实例化。
findAdvisorsThatCanApply筛选Advisor是由AopUtils类实现。对不同类型的Advisor进行不同的处理,如IntroductionAdvisor和PointcutAdvisor。
其中canApply方法执行实际的匹配操作,细节部分主要是对切入点Pointcut和bean的匹配,有兴趣的可以自己深入研究其匹配过程。
至此也就完成了bean适用的Advisor切面的自动发现与筛选,最后由ProxyFactory完成代理创建。
有两个单例Bean,A和B,A中引用了B,B中引用了A。Spring对这种相互依赖做了特殊的处理,即在对象实例化后缓存一份key为beanName的ObjectFactory,ObjectFactory中的getObject方法返回当前创建对象的引用。
这里假设先创建A对象实例,当A进行依赖注入时,需要B对象,则会通过getBean方法创建B对象。此时A并没有创建完成,但在Early缓存中存有A的引用,因而当B对象进行依赖注入A时,直接返回A对象的Early引用,从而不会造成陷入无休止的依赖注入循环中。
在getEarlyBeanReference方法中,不仅只是返回对象引用,还有一个扩展点,支持SmartInstantiationAwareBeanPostProcessor接口中的getEarlyBeanReference方法对返回的对象引用进行修改。
回到AOP的自动代理上,在AbstractAutoProxyCreator中实现了getEarlyBeanReference扩展
这里将标识唯一bean的cacheKey添加到earlyProxyReferences中,在之后bean的初始化中将很有用。然后执行wrapIfNecessary返回bean的代理对象,因而如果存在循环依赖,则依赖注入的就是真正的代理对象。
在对象执行完依赖注入后,进行初始化操作,会调用初始化后扩展postProcessAfterInitialization方法,再来关注下AbstractAutoProxyCreator此方法的实现。
它判断了earlyProxyReferences中不包含当前bean的cacheKey才会执行代理操作,也就是说,如果存在循环依赖时,代理对象在getEarlyBeanReference时就创建了,而在初始化后直接跳过了,返回的bean是原始的对象。
你可能会问,既然这里返回的不是代理对象,那代理对象最后是怎样返回的呢?
Spring在对象进行初始化后,对存在循环依赖的又做了巧妙的处理。
这里的设计很是巧妙,需要结合依赖循环的处理,AOP对象的处理统一来理解。同时对循环依赖时,不直接缓存对象,而是通过ObjectFactory的方式有了更深的理解。有兴趣的同学可以反复琢磨一下。
2017/12/24更新
回头再看这个循环依赖的点,还是花了一点时间来回翻了下源码才理解,因此再补充记录下。getSingleton(beanName, false)方法,当不存在循环依赖时,会返回null,而存在循环依赖时,返回的是ObjectFactory的getEarlyBeanReference方法返回的对象。原始的bean对象经过getEarlyBeanReference方法后,可能存在SmartInstantiationAwareBeanPostProcessor处理器,在其getEarlyBeanReference方法中被改变了,比如AbstractAutoProxyCreator中会返回代理对象。而在AbstractAutoProxyCreator的实现中,使用cacheKey保证了生成的代理对象是单例的。因此当if (exposedObject == bean)判断时会返回true,从而getBean方法返回的对象就是真正的代理对象。此时还有一个疑问,代理对象并没有进行属性的依赖注入以及init-method等的初始化啊?其实代理对象没有必要去复制原始对象的内部结构,因为它持有原始对象的引用,并且实际调用方法是交由原始对象去处理的。
Spring AOP 源码解析系列,建议大家按顺序阅读,欢迎讨论
Spring源码-AOP(一)-代理模式
Spring源码-AOP(二)-AOP概念
Spring源码-AOP(三)-Spring AOP的四种实现
Spring源码-AOP(四)-ProxyFactory
Spring源码-AOP(五)-ProxyFactoryBean
Spring源码-AOP(六)-自动代理与DefaultAdvisorAutoProxyCreator
Spring源码-AOP(七)-整合AspectJ
框架存在的意义,简单来说就是将复杂的底层实现封装起来,并提供便捷的外部接口供用户使用。对于Spring AOP而言,不论是ProxyFactory还是ProxyFactoryBean,都不能满足实际业务中复杂的应用,用户不可能对每个使用AOP代理的类进行配置。这时通过一定规则自动发现和代理自然应运而生。在spring-aop工程的autoproxy目录构成了Spring AOP自动代理的基础,AbstractAutoProxyCreator是自动代理实现的抽象基类,BeanNameAutoProxyCreator和DefaultAdvisorAutoProxyCreator则是Spring提供的两个实现。
自动代理的实现原理同ProxyFactoryBean中使用FactoryBean扩展不同,而是通过BeanPostProcessor扩展对Bean对象的创建过程进行控制来实现AOP代理。抽象基类AbstractAutoProxyCreator实现了BeanPostProcessor的子接口SmartInstantiationAwareBeanPostProcessor。先来了解下这个子接口。
1.扩展接口SmartInstantiationAwareBeanPostProcessor
我们常提及的BeanPostProcessor扩展并不是只有BeanPostProcessor一个接口,而是由其形成的多层接口体系,对Bean对象在IOC容器的创建过程的各个节点扩展形成的体系。这里只展示下SmartInstantiationAwareBeanPostProcessor的类结构。BeanPostProcessor
postProcessBeforeInitialization 初始化前扩展(执行init-method前)
postProcessAfterInitialization 初始化后扩展(执行init-method后)
InstantiationAwareBeanPostProcessor
postProcessBeforeInstantiation 对象实例化前扩展
postProcessAfterInstantiation 对象实例化后扩展
postProcessPropertyValues 属性依赖注入前扩展
SmartInstantiationAwareBeanPostProcessor
predictBeanType 预测bean的类型,在beanFactory的getType时被调用
determineCandidateConstructors 对象实例化时决定要使用的构造函数时被调用
getEarlyBeanReference 循环依赖处理时获取Early对象引用时被调用
而对于Spring AOP的自动代理,处理的阶段有两个,对象实例化前扩展和初始化后扩展。
2.自动代理基类AbstractAutoProxyCreator
在对象实例化前(postProcessBeforeInstantiation)的扩展中,主要对配置了customTargetSourceCreators属性的情况进行处理,而默认的处理都是在初始化后(postProcessAfterInitialization)扩展里执行的。对象实例化前postProcessBeforeInstantiation
所谓的customTargetSourceCreators属性是在AbstractAutoProxyCreator中的一个TargetSourceCreator数组,用来对代理对象target的封装类TargetSource的生成进行自定义。spring内置的TargetSourceCreator有两个:LazyInitTargetSourceCreator和QuickTargetSourceCreator。LazyInitTargetSourceCreator:创建的代理对象并没有初始化,直到第一次调用时才进行初始化
QuickTargetSourceCreator:根据beanName的不同前缀创建三种常用的TargetSource类型(bean必须为多例)
CommonsPoolTargetSource:池化TargetSource,每次执行方法时从池中取代理对象,执行完方法再返回池中
ThreadLocalTargetSource:线程级的TargetSource
PrototypeTargetSource:多例TargetSource,每次执行方法创建新的代理对象,执行完销毁该对象
来看下核心代码
if (beanName != null) { // 获取自定义TargetSource TargetSource targetSource = getCustomTargetSource(beanClass, beanName); if (targetSource != null) { this.targetSourcedBeans.add(beanName); // 获取拦截器 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource); // 创建代理对象 Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } }
第一步获取定义TargetSource,即遍历所有自定义TargetSourceCreator,调用getTargetSource方法返回TargetSource。
protected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName) { // We can't create fancy target sources for directly registered singletons. if (this.customTargetSourceCreators != null && this.beanFactory != null && this.beanFactory.containsBean(beanName)) { for (TargetSourceCreator tsc : this.customTargetSourceCreators) { TargetSource ts = tsc.getTargetSource(beanClass, beanName); if (ts != null) { // Found a matching TargetSource. if (logger.isDebugEnabled()) { logger.debug("TargetSourceCreator [" + tsc + " found custom TargetSource for bean with name '" + beanName + "'"); } return ts; } } } // No custom TargetSource found. return null; }
第二步获取拦截器由子类实现,根据不同的方式获取当前bean的拦截器,在后文以子类DefaultAdvisorAutoProxyCreator为例详细介绍。
第三步创建代理对象,通过创建ProxyFactory的方式完成,原理细节见ProxyFactory,来简单看下它的实现。
protected Object createProxy( Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) { ProxyFactory proxyFactory = new ProxyFactory(); // copy代理配置,如proxyTargetClass,exposeProxy等 proxyFactory.copyFrom(this); // proxyTargetClass=false时 if (!proxyFactory.isProxyTargetClass()) { // 再次确认是否要代理类对象 if (shouldProxyTargetClass(beanClass, beanName)) { proxyFactory.setProxyTargetClass(true); } // 不需要则获取其代理接口集合 else { evaluateProxyInterfaces(beanClass, proxyFactory); } } // 将所有拦截器封装成Advisor Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); for (Advisor advisor : advisors) { proxyFactory.addAdvisor(advisor); } proxyFactory.setTargetSource(targetSource); // 扩展点,支持子类对ProxyFacory扩展 customizeProxyFactory(proxyFactory); proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } // 创建代理对象 return proxyFactory.getProxy(getProxyClassLoader()); }
可以说逻辑非常清晰,最后使用ProxyFactory创建代理对象也是使用ProxyFactory统一的API。如果最终返回的代理对象不为空,则直接返回代理对象,不再执行IOC中的对象属性注入和初始化等操作了。
初始化后(postProcessAfterInitialization)
如果并没有设置自定义TargetSourceCreator,代理对象就会在原始对象初始化完成后创建。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; }
wrapIfNecessary方法执行代理的核心操作。
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; } // AOP体系的子类不被代理(Advisor,Advice等) if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } // Create proxy if we have advice. // 获取拦截器 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; }
实现过程基本同之前的一直,由子类返回拦截器集合,创建ProxyFactory对象进行代理。
3.默认自动代理类DefaultAdvisorAutoProxyCreator
在基类AbstractAutoProxyCreator中通过BeanPostProcessor扩展的方式,使得bean在创建过程中完成被代理。代理的框架已有AbstractAutoProxyCreator基本完成,留给子类的是获取拦截器getAdvicesAndAdvisorsForBean方法的具体实现。我们以DefaultAdvisorAutoProxyCreator为例,了解下Spring AOP是如何完成自动发现和过滤切面的。DefaultAdvisorAutoProxyCreator的获取拦截器实现其实由其抽象基类AbstractAdvisorAutoProxyCreator实现。
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(); }
实际操作有findEligibleAdvisors执行
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) { // 寻找所有Advisor候选者 List<Advisor> candidateAdvisors = findCandidateAdvisors(); // 获取匹配当前bean的Advisor List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName); extendAdvisors(eligibleAdvisors); if (!eligibleAdvisors.isEmpty()) { // 对Advisor排序 eligibleAdvisors = sortAdvisors(eligibleAdvisors); } return eligibleAdvisors; }
主要过程分为两步,第一步寻找所有Advisor候选者,即自动发现切面,第二部筛选当前bean的Advisor。
findCandidateAdvisors由BeanFactoryAdvisorRetrievalHelper帮助类执行,原理就是从BeanFactory及其所有父级BeanFactory中寻找类型为Advisor的类,并执行getBean实例化。
public List<Advisor> findAdvisorBeans() { // Determine list of advisor bean names, if not cached already. String[] advisorNames = null; synchronized (this) { advisorNames = this.cachedAdvisorBeanNames; if (advisorNames == null) { // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let the auto-proxy creator apply to them! // 寻找Advisor类型的bean 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 { // getBean实例化 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()); } // Ignore: indicates a reference back to the bean we're trying to advise. // We want to find advisors other than the currently created bean itself. continue; } } throw ex; } } } } return advisors; }
findAdvisorsThatCanApply筛选Advisor是由AopUtils类实现。对不同类型的Advisor进行不同的处理,如IntroductionAdvisor和PointcutAdvisor。
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) { // already processed continue; } // 匹配Advisor是否适用当前bean if (canApply(candidate, clazz, hasIntroductions)) { eligibleAdvisors.add(candidate); } } return eligibleAdvisors; }
其中canApply方法执行实际的匹配操作,细节部分主要是对切入点Pointcut和bean的匹配,有兴趣的可以自己深入研究其匹配过程。
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; } }
至此也就完成了bean适用的Advisor切面的自动发现与筛选,最后由ProxyFactory完成代理创建。
4.AOP中的循环依赖
在看自动代理源码的过程中,突然注意到SmartInstantiationAwareBeanPostProcessor接口中的getEarlyBeanReference方法,它是Spring处理循环依赖时返回**未创建完(只实例化未做依赖注入)**Bean的扩展。关于循环依赖可以去Bean的循环依赖一章去详细了解,这里只做简单的说明。有两个单例Bean,A和B,A中引用了B,B中引用了A。Spring对这种相互依赖做了特殊的处理,即在对象实例化后缓存一份key为beanName的ObjectFactory,ObjectFactory中的getObject方法返回当前创建对象的引用。
// 支持单例依赖循环 if (earlySingletonExposure) { // 添加Early对象缓存 addSingletonFactory(beanName, new ObjectFactory<Object>() { [@Override](https://my.oschina.net/u/1162528) public Object getObject() throws BeansException { return getEarlyBeanReference(beanName, mbd, bean); } }); }
这里假设先创建A对象实例,当A进行依赖注入时,需要B对象,则会通过getBean方法创建B对象。此时A并没有创建完成,但在Early缓存中存有A的引用,因而当B对象进行依赖注入A时,直接返回A对象的Early引用,从而不会造成陷入无休止的依赖注入循环中。
在getEarlyBeanReference方法中,不仅只是返回对象引用,还有一个扩展点,支持SmartInstantiationAwareBeanPostProcessor接口中的getEarlyBeanReference方法对返回的对象引用进行修改。
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { Object exposedObject = bean; if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof SmartInstantiationAwareBeanPostProcessor) { SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp; // 扩展点,对Early对象进行修改 exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName); if (exposedObject == null) { return exposedObject; } } } } return exposedObject; }
回到AOP的自动代理上,在AbstractAutoProxyCreator中实现了getEarlyBeanReference扩展
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (!this.earlyProxyReferences.contains(cacheKey)) { this.earlyProxyReferences.add(cacheKey); } return wrapIfNecessary(bean, beanName, cacheKey); }
这里将标识唯一bean的cacheKey添加到earlyProxyReferences中,在之后bean的初始化中将很有用。然后执行wrapIfNecessary返回bean的代理对象,因而如果存在循环依赖,则依赖注入的就是真正的代理对象。
在对象执行完依赖注入后,进行初始化操作,会调用初始化后扩展postProcessAfterInitialization方法,再来关注下AbstractAutoProxyCreator此方法的实现。
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); // 判断early引用中是否包含cacheKey if (!this.earlyProxyReferences.contains(cacheKey)) { return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; }
它判断了earlyProxyReferences中不包含当前bean的cacheKey才会执行代理操作,也就是说,如果存在循环依赖时,代理对象在getEarlyBeanReference时就创建了,而在初始化后直接跳过了,返回的bean是原始的对象。
你可能会问,既然这里返回的不是代理对象,那代理对象最后是怎样返回的呢?
Spring在对象进行初始化后,对存在循环依赖的又做了巧妙的处理。
if (earlySingletonExposure) { // 如果存在循环依赖,则返回的为代理对象 Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { // 循环依赖下,经过初始化后的对象同原始对象一致 // 因而将代理对象赋给最终返回的对象引用 if (exposedObject == bean) { exposedObject = earlySingletonReference; } } }
这里的设计很是巧妙,需要结合依赖循环的处理,AOP对象的处理统一来理解。同时对循环依赖时,不直接缓存对象,而是通过ObjectFactory的方式有了更深的理解。有兴趣的同学可以反复琢磨一下。
2017/12/24更新
回头再看这个循环依赖的点,还是花了一点时间来回翻了下源码才理解,因此再补充记录下。getSingleton(beanName, false)方法,当不存在循环依赖时,会返回null,而存在循环依赖时,返回的是ObjectFactory的getEarlyBeanReference方法返回的对象。原始的bean对象经过getEarlyBeanReference方法后,可能存在SmartInstantiationAwareBeanPostProcessor处理器,在其getEarlyBeanReference方法中被改变了,比如AbstractAutoProxyCreator中会返回代理对象。而在AbstractAutoProxyCreator的实现中,使用cacheKey保证了生成的代理对象是单例的。因此当if (exposedObject == bean)判断时会返回true,从而getBean方法返回的对象就是真正的代理对象。此时还有一个疑问,代理对象并没有进行属性的依赖注入以及init-method等的初始化啊?其实代理对象没有必要去复制原始对象的内部结构,因为它持有原始对象的引用,并且实际调用方法是交由原始对象去处理的。
总结
Spring AOP的自动代理,它同ProxyFactoryBean采用了不同的扩展方式。FactoryBean的扩展思路非常清晰,在工厂ProxyFactoryBean创建完成后直接根据其配置动态生成不同的代理对象,适用于简单的配置,但在ApplicationContext高级容器中,就需要通过BeanPostProcessor扩展进行更细粒度的操作,从而支持复杂的业务配置。而接下来要讨论的AspectJ整合Spring的基础实现,就来自于Spring AOP的自动代理。相关文章推荐
- Spring-AOP 自动创建代理之DefaultAdvisorAutoProxyCreator
- 使用DefaultAdvisorAutoProxyCreator实现spring的自动代理
- spring 配置实例4(使用DefaultAdvisorAutoProxyCreator 自动代理,比较省时省力的做法)
- 使用DefaultAdvisorAutoProxyCreator实现spring的自动代理
- 使用DefaultAdvisorAutoProxyCreator实现spring的自动代理
- Spring-AOP 自动创建代理之BeanNameAutoProxyCreator
- Spring 使用 DefaultAdvisorAutoProxyCreator创建AOP 小结
- 《Pro Spring》学习笔记之Automatic Proxy自动代理实例--DefaultAdvisorAutoProxyCreator
- spring自动创建代理类DefaultAdvisorAutoProxyCreator和BeanNameAutoProxyCreator的声明顺序
- 死磕Spring AOP系列3:剖析Bean处理器之DefaultAdvisorAutoProxyCreator
- Spring-AOP 自动创建代理之AnnotationAwareAspectJAutoProxyCreator
- SpringAop源码情操陶冶-AspectJAwareAdvisorAutoProxyCreator
- 使用BeanNameAutoProxyCreator实现spring的自动代理
- spring用BeanNameAutoProxyCreator自动创建事务代理
- 使用BeanNameAutoProxyCreator实现spring的自动代理
- spring用BeanNameAutoProxyCreator自动创建事务代理
- spring用BeanNameAutoProxyCreator自动创建事务代理
- spring(一) spring用BeanNameAutoProxyCreator自动创建事务代理
- spring中BeanNameAutoProxyCreator和AnnotationAwareAspectJAutoProxyCreator两种AOP代理方式使用总结
- 使用BeanNameAutoProxyCreator实现spring的自动代理