spring源码探索

ConfigurationClassParser#doProcessConfigurationClass

 for (SourceClass candidate : importCandidates) {//遍历【importCandidates】

PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

继续下一个循环

return null;//不依赖其他bean了，返回null

AbstractAutowireCapableBeanFactory#getEarlyBeanReference

ConfigurationClassBeanDefinitionReader#registerBeanDefinitionForImportedConfigurationClass

DefaultListableBeanFactory#preInstantiateSingletons

假设A，Baop(持有@Aspect) 两个类互相依赖如果先加载Baop，则Baop只会在提前暴露的时候生成代理

ContextAnnotationAutowireCandidateResolver#getLazyResolutionProxyIfNecessary

ConfigurationClassParser#processImports

Y

c2

N

1.BeanFactoryPostProcessor.postProcessBeanFactory扫描待注入的bean完成后，调用beanfactory的后置处理器的时候重置bean的beanClass属性为代理class对象。(比如@Configuration)2.getEarlyBeanReference循环依赖，触发三级缓存的时候生成代理（只处理持有@Aspect的代理）3.BeanPostProcessor.postProcessAfterInitialization依赖注入完成后，调用bean的后置处理器的时候生成代理(比如@Async)

是否实现ImportBeanDefinitionRegistrar

return bean;//没有代理直接返回当前bean

...this.beanDefinitionMap.put {@link DefaultListableBeanFactory#beanDefinitionMap}this.beanDefinitionNames.add {@link DefaultListableBeanFactory#beanDefinitionNames}//存入到这两个属性中，后续加载时遍历需要使用

 this.reader.loadBeanDefinitions(configClasses);//存入beanDefinitionNames

createBean 执行完成

AbstractAutowireCapableBeanFactory#invokeInitMethods

是否持有@Lazy注解

a3

ConfigurationClassParser#processConfigurationClass

AbstractAutoProxyCreator#getEarlyBeanReference

AbstractAutowireCapableBeanFactory#doCreateBean

是否实现ImportSelector

持有@Component

是否有@Bean

singletonObjects一级缓存是否存在

finishBeanFactoryInitialization(beanFactory);实例化bean

第一个启动类执行完，才会走这里的返回

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

...beanDef.setFactoryBeanName(configClass.getBeanName());// 这里setFactoryBeanNamebeanDef.setUniqueFactoryMethodName(methodName);// 这里setFactoryMethodNamethis.beanDefinitionMap.put {@link DefaultListableBeanFactory#beanDefinitionMap}this.beanDefinitionNames.add {@link DefaultListableBeanFactory#beanDefinitionNames}//存入到这两个属性中，后续加载时遍历需要使用

AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition

ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry

Y(该类已经是顶层的bean了)

N(仅仅是@Import)

假设A，Baop(持有@Aspect) 两个类互相依赖如果先加载A，则Baop只会在后置处理器的时候生成代理一级，二级 缓存都不会存在

a4

AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject

AbstractAutoProxyCreator#wrapIfNecessary

ConfigurationClassEnhancer.BeanMethodInterceptor#intercept

a5

return ctor.newInstance(argsWithDefaultValues);//调用无参构造函数，实例化bean(此时还没有给成员属性赋值)

if (this.advisorFactory.isAspect(beanType)) {....//只扫描所有持有【@Aspect】的aop配置类

AbstractAutoProxyCreator#postProcessAfterInitialization

AbstractBeanFactory#doGetBean

refresh()

是否已经调用过wrapIfNecessary（尝试生成过代理）

回到递归调用处继续下一个循环

是否为@Bean加载的bean

// 根据{AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition}解析的待注入项去注入

invokeBeanFactoryPostProcessors(beanFactory);扫描bean

是否有@Import

b1

关联方法

if(bean instanceof InitializingBean){   ((InitializingBean) bean).afterPropertiesSet();}...//回调InitializingBean.afterPropertiesSet();

AbstractAutowireCapableBeanFactory#invokeAwareMethods

Nc1

扫描待加载的bean

earlySingletonObjects二级缓存是否存在

ConfigurationClassPostProcessor#processConfigBeanDefinitions

b2

假设A，Baop(持有@Aspect) 两个类互相依赖如果先加载Baop，则Baop只会在提前暴露的时候生成代理initializeBean并不会生成代理，所以exposedObject == bean@Async自己依赖自己，则initializeBean的时候才生成代理，导致exposedObject != bean

if (bean instanceof Aware) {... ((BeanNameAware) bean).setBeanName(beanName);... ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);... ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);}//执行Aware感知接口

...

AutowiredAnnotationBeanPostProcessor#postProcessProperties

ConfigurationClassParser#getImports

allowEarlyReference==true?是否允许提前暴露

生成代理的点

a2

ClassPathBeanDefinitionScanner#doScan

exposedObject = earlySingletonReference;//fixme 如果是同一个对象，就偷换引用（替换成二级缓存中的代理类）

sourceClass是否为null

span style=\"font-size: inherit;\

factoryMethodName是否为空

ConfigurationClassPostProcessor#postProcessBeanFactory

a1

exposedObject == bean?initializeBean前后(代理前后)是否为同一个类

假设A，Baop(持有@Aspect) 两个类互相依赖如果先加载A，则Baop只会在后置处理器的时候生成代理此时生成，才更符合bean的生命周期比如@Async，没有持有@Aspect注解，是通过自定义后置处理器(AbstractAdvisingBeanPostProcessor)来实现代理的，所以必定不会在提前暴露的时候生成代理。

BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors()

singletonFactories三级缓存是否存在

是否有@ComponentScan

N（还有依赖其他bean未加载）

sharedInstance是否为null

SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference

parser.parse(candidates);//扫描待加载的bean//第一次循环，candidates指向的是启动类指定的配置类

Object sharedInstance = getSingleton(beanName);//从缓存中获取bean

earlySingletonReference是否为null一级，二级缓存是否存在

u style=\"\

DefaultListableBeanFactory#registerBeanDefinition

N继续下一个循环

y

a6

ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForBeanMethod

是否为@import加载的bean

...return singletonObject;

for (String beanName : beanNames) {...this.mergedBeanDefinitions.get(beanName);if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {   getBean(beanName);}...}//循环实例化前面加载的bean//如果是懒加载就直接跳过

Object font color=\"#ff3333\