什么是 IoC
IoC （Inversion of control ）
控制反转。它是一种思想不是一个技术实现。描述的是：
Java
开发领域对象的创建以及管理的问题。
例如：现有类
A
依赖于类
B
。传统的开发方式 ：往往是在类
A
中手动通过
new
关键字来
new
一个
B
的对象出来使用
IoC
思想的开发方式 ：不通过
new
关键字来创建对象，而是通过
IoC
容器(
Spring
框架) 来帮助我们实例化对象。我们需要哪个对象，直接从
IoC
容器里面过去即可。
从以上两种开发方式的对比来看：我们 “丧失了一个权力” (创建、管理对象的权力)，从而也得到了一个好处（不用再考虑对象的创建、管理等一系列的事情）
**
IoC
容器主要有两个容器系列：**
BeanFactory
和
ApplicationContext
。
IoC容器主要的接口设计图：
Spring 容器的 refresh() 创建容器
//下面每一个方法都会单独提出来进行分析@Overridepublicvoidrefresh()throwsBeansException,IllegalStateException{synchronized(this.startupShutdownMonitor){// 刷新前的预处理prepareRefresh();// 获取 Bean工厂，默认的 DefaultListableBeanFactoryConfigurableListableBeanFactory beanFactory =obtainFreshBeanFactory();// 准备bean工厂以供在此上下文中使用（对刚创建的bean工厂进行设置）prepareBeanFactory(beanFactory);try{// 允许在子类中对bean工厂进行后处理。目前是一个空实现//beanFactory 准备工作完成后进行的后置处理工作。postProcessBeanFactory(beanFactory);// 调用 BeanFactoryPostProcessors,//BeanFactoryPostProcessor：在 beanFactory 标准初始化完成之后执行的//两个接口 BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessorinvokeBeanFactoryPostProcessors(beanFactory);// 注册bean的处理器，拦截bean的创建过程registerBeanPostProcessors(beanFactory);// 初始化messagesource 组件，做国际化功能、消息绑定、消息解析.initMessageSource();// 初始化事件派发器initApplicationEventMulticaster();// 初始化特定子类中的其他特殊bean。留给子容器（子类）是一个空的实现// 子类重写这个方法，在容器刷新的时候可以自定义逻辑onRefresh();// 将容器中将所有项目里面的 applicationLister 注册进来registerListeners();// 初始化所有剩下的单实例bean singletons.finishBeanFactoryInitialization(beanFactory);// 最后一步：刷新Bean工厂容器。finishRefresh();}
【1】
prepareRefresh
刷新前的预处理源码分析：
protectedvoidprepareRefresh(){// 记录当前时间和容器的状态this.startupDate =System.currentTimeMillis();this.closed.set(false);this.active.set(true);// 在上下文环境中初始化属性设置，其底层是个空方法，由具体的子类定义其实现。initPropertySources();// 验证属性的合法性getEnvironment().validateRequiredProperties();//保存一些早期的容器事件this.earlyApplicationEvents =newLinkedHashSet<ApplicationEvent>();}
【2】
obtainFreshBeanFactory
获取
Bean
工厂源码分析
protectedConfigurableListableBeanFactoryobtainFreshBeanFactory(){//创建 beanFactoryrefreshBeanFactory();//获取 beanFactoryreturngetBeanFactory();}//refreshBeanFactory 源码展示，位于GenericApplicationContext类//创建 GenericApplicationContext 类的时候，默认会创建一个 bean 工厂。publicGenericApplicationContext(){this.beanFactory =newDefaultListableBeanFactory();}@OverrideprotectedfinalvoidrefreshBeanFactory()throwsIllegalStateException{if(!this.refreshed.compareAndSet(false,true)){thrownewIllegalStateException("GenericApplicationContext ... once");}//*** 给 bean工厂中创建一个序列化IDthis.beanFactory.setSerializationId(getId());}//获取一个 bean 工厂@OverridepublicfinalConfigurableListableBeanFactorygetBeanFactory(){returnthis.beanFactory;}
【3】
prepareBeanFactory
对刚创建的bean工厂进行设置，源码分析：
protectedvoidprepareBeanFactory(ConfigurableListableBeanFactory beanFactory){// 告诉内部bean工厂使用上下文的类加载器等。
beanFactory.setBeanClassLoader(getClassLoader());//设置表达式解析器等
beanFactory.setBeanExpressionResolver(newStandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(newResourceEditorRegistrar(this,getEnvironment()));// 添加部分后置处理器 ApplicationContextAwareProcessor
beanFactory.addBeanPostProcessor(newApplicationContextAwareProcessor(this));//设置忽略的自动装配的接口
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);// BeanFactory接口未在普通工厂中注册可解析类型// 注册可以解析的自动装配，我们能直接在任何组件中自动注入
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class,this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class,this);
beanFactory.registerResolvableDependency(ApplicationContext.class,this);// 注册早期的后处理器，以便将内部bean检测为applicationlisteners。
beanFactory.addBeanPostProcessor(newApplicationListenerDetector(this));// 添加编译时的 AspectJif(beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)){
beanFactory.addBeanPostProcessor(newLoadTimeWeaverAwareProcessor(beanFactory));// 为类型匹配设置临时类加载器。
beanFactory.setTempClassLoader(newContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}// 给 beanfactory 中注册能用的一些组件。if(!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)){
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME,getEnvironment());}if(!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)){
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME,getEnvironment().getSystemProperties());}if(!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)){
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME,getEnvironment().getSystemEnvironment());}}
【4】
invokeBeanFactoryPostProcessors
源码分析
protectedvoidinvokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory){PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory,getBeanFactoryPostProcessors());// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)if(beanFactory.getTempClassLoader()==null&& beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)){
beanFactory.addBeanPostProcessor(newLoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(newContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}}
【4.1】
invokeBeanFactoryPostProcessors
源码分析
publicstaticvoidinvokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory,List<BeanFactoryPostProcessor> beanFactoryPostProcessors){// 如果有，请先调用BeanDefinitionRegistryPostProcessors。Set<String> processedBeans =newHashSet<>();//当前的 beanFactory == BeanDefinitionRegistryif(beanFactory instanceofBeanDefinitionRegistry){BeanDefinitionRegistry registry =(BeanDefinitionRegistry) beanFactory;List<BeanFactoryPostProcessor> regularPostProcessors =newArrayList<>();List<BeanDefinitionRegistryPostProcessor> registryProcessors =newArrayList<>();//获取所有的 BeanFactoryPostProcessorfor(BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors){if(postProcessor instanceofBeanDefinitionRegistryPostProcessor){BeanDefinitionRegistryPostProcessor registryProcessor =(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);}else{
regularPostProcessors.add(postProcessor);}}// 首先执行实现了 priority 接口的后置处理器String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);for(String ppName : postProcessorNames){if(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);}}//限制性实现了 priorityOrdered 优先级接口的后置处理器sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();// 接下来，调用实现ordered接口的后置处理器
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);for(String ppName : postProcessorNames){if(!processedBeans.contains(ppName)&& beanFactory.isTypeMatch(ppName,Ordered.class)){
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);}}sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();// 最后，调用所有其他没有实现任何接口的后置处理器boolean reiterate =true;while(reiterate){
reiterate =false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);for(String ppName : postProcessorNames){if(!processedBeans.contains(ppName)){
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate =true;}}sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();}// 现在，调用到目前为止处理的所有处理器的postprocessebeanfactory回调。invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}else{// 调用使用上下文实例注册的工厂处理器。invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}// 不要在这里初始化factorybeans：我们需要保留所有常规bean// 获取所有的的后置处理器//后续操作与前面相同，查看是否实现了priority、order接口和获取全部String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class,true,false);// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,// Ordered, and the rest.List<BeanFactoryPostProcessor> priorityOrderedPostProcessors =newArrayList<>();List<String> orderedPostProcessorNames =newArrayList<>();List<String> nonOrderedPostProcessorNames =newArrayList<>();for(String ppName : postProcessorNames){if(processedBeans.contains(ppName)){// skip - already processed in first phase above}elseif(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName,BeanFactoryPostProcessor.class));}elseif(beanFactory.isTypeMatch(ppName,Ordered.class)){
orderedPostProcessorNames.add(ppName);}else{
nonOrderedPostProcessorNames.add(ppName);}}// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.sortPostProcessors(priorityOrderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// Next, invoke the BeanFactoryPostProcessors that implement Ordered.List<BeanFactoryPostProcessor> orderedPostProcessors =newArrayList<>();for(String postProcessorName : orderedPostProcessorNames){
orderedPostProcessors.add(beanFactory.getBean(postProcessorName,BeanFactoryPostProcessor.class));}sortPostProcessors(orderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);// Finally, invoke all other BeanFactoryPostProcessors.List<BeanFactoryPostProcessor> nonOrderedPostProcessors =newArrayList<>();for(String postProcessorName : nonOrderedPostProcessorNames){
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName,BeanFactoryPostProcessor.class));}invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);// Clear cached merged bean definitions since the post-processors might have// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();}
【5】**
registerBeanPostProcessors
源码展示：** 注册
BeanPostProcessor
，不同的接口类型的
BeanPostProcessor
；在
bean
创建前后的执行时机是不一样的。
■
BeanPostProcessor
■
DestructionAwareBeanPostProcessor
■
InstantiationAwareBeanPostProcessor
■
SmartInstantiationAwareBeanPostProcessor
■
MergedBeanDefinitionPostProcessor【internalPostProcessors】
：优先记录：
1
protectedvoidregisterBeanPostProcessors(ConfigurableListableBeanFactory beanFactory){//方法实现在外层PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory,this);}publicstaticvoidregisterBeanPostProcessors(ConfigurableListableBeanFactory beanFactory,AbstractApplicationContext applicationContext){//获取所有的 bean后置处理器String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class,true,false);// 检查和统计后置处理器int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount()+1+ postProcessorNames.length;
beanFactory.addBeanPostProcessor(newBeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));// bean 的后置处理器也有实现 priority和order接口的后置处理器，用来指定优先级List<BeanPostProcessor> priorityOrderedPostProcessors =newArrayList<>();List<BeanPostProcessor> internalPostProcessors =newArrayList<>();List<String> orderedPostProcessorNames =newArrayList<>();List<String> nonOrderedPostProcessorNames =newArrayList<>();for(String ppName : postProcessorNames){if(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){BeanPostProcessor pp = beanFactory.getBean(ppName,BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);//将实现了 MergedBeanDefinitionPostProcessor 接口的后置处理器加入到internalPostProcessorsif(pp instanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);}}elseif(beanFactory.isTypeMatch(ppName,Ordered.class)){
orderedPostProcessorNames.add(ppName);}else{
nonOrderedPostProcessorNames.add(ppName);}}// 首先，注册实现priorityordered接口的beanPostProcessors。sortPostProcessors(priorityOrderedPostProcessors, beanFactory);//注册bean后置处理器到beanFactory//beanFactory.addBeanPostProcessor(postProcessor);registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);// 接下来，注册实现ordered接口的beanPostProcessors。List<BeanPostProcessor> orderedPostProcessors =newArrayList<>();for(String ppName : orderedPostProcessorNames){BeanPostProcessor pp = beanFactory.getBean(ppName,BeanPostProcessor.class);
orderedPostProcessors.add(pp);if(pp instanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);}}sortPostProcessors(orderedPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, orderedPostProcessors);// 现在，注册所有常规beanpstprocessors。List<BeanPostProcessor> nonOrderedPostProcessors =newArrayList<>();for(String ppName : nonOrderedPostProcessorNames){BeanPostProcessor pp = beanFactory.getBean(ppName,BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);if(pp instanceofMergedBeanDefinitionPostProcessor){
internalPostProcessors.add(pp);}}registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);// 最后，重新注册所有内部 beanpstprocessors。实现了 MergedBeanDefinitionPostProcessor 接口的后置处理器sortPostProcessors(internalPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, internalPostProcessors);// 注册一个ApplicationListenerDetector 来检查bean创建完成是否为侦听器，如果是将此bean 放入到容器中// 将其移动到处理器链的末端（用于获取代理等）。
beanFactory.addBeanPostProcessor(newApplicationListenerDetector(applicationContext));}
【6】
initMessageSource
源码解析：
protectedvoidinitMessageSource(){//获取 bean工厂ConfigurableListableBeanFactory beanFactory =getBeanFactory();//查看beanFactory 中是否有 messsource 类型组件，有则赋值给messageSourceif(beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)){this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME,MessageSource.class);if(this.parent !=null&&this.messageSource instanceofHierarchicalMessageSource){HierarchicalMessageSource hms =(HierarchicalMessageSource)this.messageSource;if(hms.getParentMessageSource()==null){
hms.setParentMessageSource(getInternalParentMessageSource());}}if(logger.isTraceEnabled()){
logger.trace("Using MessageSource ["+this.messageSource +"]");}}//不存在则创建一个 messageSource 主要作用：从配置文件中取出国际化等的值else{DelegatingMessageSource dms =newDelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());this.messageSource = dms;//将messageSource 注入到容器中
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME,this.messageSource);if(logger.isTraceEnabled()){
logger.trace("No '"+MESSAGE_SOURCE_BEAN_NAME+"' bean, using ["+this.messageSource +"]");}}}
【7】
initApplicationEventMulticaster
初始化事件派发器，源码分析：
protectedvoidinitApplicationEventMulticaster(){//获取 BeanFactoryConfigurableListableBeanFactory beanFactory =getBeanFactory();//从beanFactory 中获取 applicationEventMulticaster 的事件派发器if(beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)){this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,ApplicationEventMulticaster.class);if(logger.isTraceEnabled()){
logger.trace("Using ApplicationEventMulticaster ["+this.applicationEventMulticaster +"]");}}//否则创建一个简单的事件派发器 SimpleApplicationEventMulticasterelse{this.applicationEventMulticaster =newSimpleApplicationEventMulticaster(beanFactory);//并注册到容器中，以后其他组件直接注入。
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,this.applicationEventMulticaster);if(logger.isTraceEnabled()){
logger.trace("No '"+APPLICATION_EVENT_MULTICASTER_BEAN_NAME+"' bean, using "+"["+this.applicationEventMulticaster.getClass().getSimpleName()+"]");}}}
【8】
registerListeners
源码分析：
protectedvoidregisterListeners(){// 首先注册静态指定的侦听器。for(ApplicationListener<?> listener :getApplicationListeners()){//将监听器添加到事件派发器中getApplicationEventMulticaster().addApplicationListener(listener);}// 重容器中获取所有的 ApplicationListenerString[] listenerBeanNames =getBeanNamesForType(ApplicationListener.class,true,false);for(String listenerBeanName : listenerBeanNames){//添加到监听器事件派发器中getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);}// 派发之前步骤产生的事件Set<ApplicationEvent> earlyEventsToProcess =this.earlyApplicationEvents;this.earlyApplicationEvents =null;if(earlyEventsToProcess !=null){for(ApplicationEvent earlyEvent : earlyEventsToProcess){getApplicationEventMulticaster().multicastEvent(earlyEvent);}}}
【9】初始化所有剩下的单实例
bean
的方法
finishBeanFactoryInitialization(beanFactory)
; 源码展示：
protectedvoidfinishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory){// 初始化上下文的转换服务。 （过）if(beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME)&&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME,ConversionService.class)){
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME,ConversionService.class));}// 如果没有bean后处理器，则注册默认的嵌入式值解析器 （过）// （例如propertyplaceholderconfigurer bean）在以下任何时间之前注册：// 此时，主要用于注释属性值中的分辨率。if(!beanFactory.hasEmbeddedValueResolver()){
beanFactory.addEmbeddedValueResolver(strVal ->getEnvironment().resolvePlaceholders(strVal));}// 尽早初始化loadTimeWeaveraware bean，以便尽早注册其转换器。 （过）String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class,false,false);for(String weaverAwareName : weaverAwareNames){getBean(weaverAwareName);}// 停止使用临时类加载器进行类型匹配。 （过）
beanFactory.setTempClassLoader(null);// 允许缓存所有bean定义元数据，不需要进一步更改。 （过）
beanFactory.freezeConfiguration();// *****实例化所有剩余的（非延迟初始化）单例。***
beanFactory.preInstantiateSingletons();}
【9.1】实例化所有剩余的（非延迟初始化）单例。
beanFactory.preInstantiateSingletons()
方法源码如下：
@OverridepublicvoidpreInstantiateSingletons()throwsBeansException{if(logger.isTraceEnabled()){
logger.trace("Pre-instantiating singletons in "+this);}// 获取所有bean的定义信息List<String> beanNames =newArrayList<>(this.beanDefinitionNames);// 所有非惰性单例bean的触发器初始化…for(String beanName : beanNames){//获取bean的定义信息RootBeanDefinition bd =getMergedLocalBeanDefinition(beanName);//判断不是抽象的、是单实例的、不是懒加载的则创建if(!bd.isAbstract()&& bd.isSingleton()&&!bd.isLazyInit()){//判断是否为 Factorybean:是否是实现了factoryBean接口的，通过getObject 获取实例if(isFactoryBean(beanName)){Object bean =getBean(FACTORY_BEAN_PREFIX+ beanName);if(bean instanceofFactoryBean){finalFactoryBean<?> factory =(FactoryBean<?>) bean;boolean isEagerInit;if(System.getSecurityManager()!=null&& factory instanceofSmartFactoryBean){
isEagerInit =AccessController.doPrivileged((PrivilegedAction<Boolean>)((SmartFactoryBean<?>) factory)::isEagerInit,getAccessControlContext());}else{
isEagerInit =(factory instanceofSmartFactoryBean&&((SmartFactoryBean<?>) factory).isEagerInit());}if(isEagerInit){getBean(beanName);}}}/**如果不是工厂bean——>getBean(beanName)---> doGetBean()--->获取缓存中保存的单实例Bean，如果能
*singletonObjects.get(beanName); Map<String, Object> singletonObjects用来缓存所有的单实例bean
*-->缓存中获取不到，则创建对象：1、先标记当前bean 被创建（防止多线程）2、获取bean的定义信息
*3、获取当前bean依赖的其他bean（dependsOn)，如果有按照getBean的方式，将依赖的bean先创建出来
*4、启动单实例bean的创建流程：通过beanFactory.getObject创建——>内部调用createBean创建bean——>
*拿到bean的定义信息，调用resolveBeforeInstantiation(beanName,mbdToUse)：让beanPoseProcess提前
*拦截获取代理对象的机会。InstantiationAwareBeanPostProcessor:提前执行，
*先触发postProcessBeforeInstantiation();如果有返回值则触发postProcessAfterInitalization()
*如果没有返回代理对象，则执行 doCreateBean(beanName,mbdToUse,args)创建bean。
*创建bean的流程：
* 1)、createBeanInstance(beanName,mbdToUse,args)进入此方法：
* 1.1)通过工厂方法或者执行构造器解析执行即可：创建的对象是个空对象
* 2)、applyMergedBeanDefinitionPostProcessors(mbd,beanType,beanName);调用
* MergedBeanDefinitionPostProcessor的bdp.postProcessMergedBeanDefinition(mbd,beanType,beanName)
* 3）、给bean实例赋值，populateBean(beanName,mbd,bw,pvs) 获取所有的属性信息，赋值之前获取所有的 InstantiationAwareBeanPostProcessor 后置处理器的postProcessAfterInstantiation()
* 第二次获取InstantiationAwareBeanPostProcessor后置处理器；执行 postProcessPropertyValues()
* 最后为应用 Bean属性赋值：为属性利用 setter 方法进行赋值 applyPropertyValues(beanName,mbd,bw,pvs)
* 4）、bean 初始化：initializeBean(beanName,bean,mbd)
* ①、执行xxxAware接口的方法，调用实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口的方法。
* ②、执行后置处理器之前的方法：applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)
* 所有后置处理器的 BeanPostProcessor.postProcessBeforeInitialization()
* ③、执行初始化方法：invokeInitMethods(beanName, wrappedBean, mbd);
* 先判断是否实现了InitializingBean接口的实现；执行接口规定的初始化。
* 其次自定义初始化方法。
* ④、applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);执行初始化之后的后置处理器的方法。
* BeanPostProcessor.postProcessAfterInitialization(result, beanName);
* 5)、注册bean的销毁方法到容器中registerDisposableBeanIfNecessary(beanName, bean, mbd);
*
*5、将创建的bean 添加到缓存中singleObject(Map)；其实IOC容器就是这些Map集合，很多Map里面保存了单实例Bean,环境信息等等。。。
**/else{getBean(beanName);}}}}
【9.2】所有
Bean
都利用
getBean
创建完成之后，检查所有的
Bean
是否实现了
SmartInitializingSingleton
接口，如果是，就执行
smartSingleton.afterSingletonsInstantiated();
for(String beanName : beanNames){Object singletonInstance =getSingleton(beanName);if(singletonInstance instanceofSmartInitializingSingleton){finalSmartInitializingSingleton smartSingleton =(SmartInitializingSingleton) singletonInstance;if(System.getSecurityManager()!=null){AccessController.doPrivileged((PrivilegedAction<Object>)()->{
smartSingleton.afterSingletonsInstantiated();returnnull;},getAccessControlContext());}else{
smartSingleton.afterSingletonsInstantiated();}}}
【10】
finishRefresh
：最后一步，完成
BeanFactory
的初始化创建工作；IOC容器创建完成。
用户可以实现
LifecycleProcessor
接口，可以在
BeanFactory
执行
void onRefresh();
和
void onClose();
时调用。默认从容器中找是否有
LifecycleProcessor
的组件。如果没有则创建一个默认的声明周期组件：
new DefaultLifecycleProcessor();
并注册到
beanFactory
容器中。
protectedvoidfinishRefresh(){// 清除上下文级资源缓存（例如扫描中的asm元数据）。clearResourceCaches();// 初始化与生命周期有关的后置处理器initLifecycleProcessor();//获取前面定义的声明周期处理器（BeanFactory)并调用回调方法 onRefreshgetLifecycleProcessor().onRefresh();// 发布容器刷新完成事件publishEvent(newContextRefreshedEvent(this));// 不重要。。。LiveBeansView.registerApplicationContext(this);}
Spring IOC 容器源码总结
【1】
Spring
容器在启动的时候，先会保存所有注册来的
Bean
的定义信息；
■
Xml
注册
bean：<bean>
■ 注解注册
Bean
：
@Service
、
@Component
、
@Bean
等等
【2】
Spring
容器会在合适的时机创建
bean
；
■ 用到这个
bean
的时候，利用
getBean
创建
bean
，创建好后保存在容器中。
■ 统一创建剩下所有
bean
的时候，调用
finishBeanFactoryInitialization()
【3】后置处理器：
BeanPostProcessor
：每一个
bean
的创建完成，都会使用各种后置处理器进行处理，来增强
bean
的功能：
■
AutowriteAnnotationBeanPostProcessor
：处理自动注入；
■
AnnotationAwareAspectJAutoProxyCreator
：来做
AOP
功能；等等。。。
【4】事件驱动模型：
ApplicationListener
事件监听。
ApplicationEventMulticaster
事件派发。
Spring
不⽀持原型
bean
的循环依赖。单例
bean
通过
setXxx
或者
@Autowired
进⾏循环依赖。
Spring
的循环依赖的理论依据基于
Java
的引⽤传递，当获得对象的引⽤时，对象的属性是可以延后设置的，但是构造器必须是在获取引⽤之前。
Spring
通过
setXxx
或者
@Autowired
⽅法解决循环依赖其实是通过提前暴露⼀个
ObjectFactory
对象来完成的，简单来说
ClassA
在调⽤构造器完成对象初始化之后，在调⽤
ClassA
的
setClassB
⽅法之前就把
ClassA
实例化的对象通过
ObjectFactory
提前暴露到
Spring
容器中。
<beanname="mongoDao"class="xyz.coolblog.autowire.MongoDao"/><beanname="mysqlDao"class="xyz.coolblog.autowire.MySqlDao"/><!-- 非自动注入，手动配置依赖 --><beanname="service-without-autowire"class="xyz.coolblog.autowire.Service"autowire="no"><propertyname="mysqlDao"ref="mysqlDao"/><propertyname="mongoDao"ref="mongoDao"/></bean><!-- 通过设置 autowire 属性，我们就不需要像上面那样显式配置依赖了 --><beanname="service-with-autowire"class="xyz.coolblog.autowire.Service"autowire="byName"/>
**
Spring
容器类继承图**
阅读源码的一些建议:
Spring
源码太多了太复杂，看着看着就迷失在了代码的海洋里。建议大家自己动手实现一个简单的
IOC
容器，通过实践，才会有更多的感悟。
本文转载自: https://blog.csdn.net/zhengzhaoyang122/article/details/135563941
版权归原作者 程序猿进阶 所有， 如有侵权，请联系我们删除。
版权归原作者 程序猿进阶 所有， 如有侵权，请联系我们删除。