专家博主系列专栏Java设计模式、数据结构和算法、Kafka从入门到成神、Kafka从成神到升仙、Spring从成神到升仙系列如果感觉博主的文章还不错的话请三连支持一下博主哦博主正在努力完成2023计划中以梦为马扬帆起航2023追梦人联系方式hls1793929520和大家一起学习一起进步

文章目录Spring

源码剖析1、prepareRefresh2、obtainFreshBeanFactory2.1

refreshBeanFactory3、prepareBeanFactory4、postProcessBeanFactory5、invokeBeanFactoryPostProcessors6、registerBeanPostProcessors7、initMessageSource8、initApplicationEventMulticaster9、onRefresh10、registerListeners11、finishBeanFactoryInitialization11.1

创建实例11.2

初始化逻辑12、finishRefresh13、销毁五、流程图六、总结七、附录1、注册别名的原因2、BeanFactoryPostProcessor

BeanDefinitionRegistryPostProcessor3、BeanFactoryPostProcessor

BeanDefinitionRegistryPostProcessorSpring

IOC源码解析

但随着目前程序员行业的发展我们有必要打开这个黑盒去探索其中的奥妙。

Spring

源码文章的错误将不再一行一行的带大家分析源码我们将一些不重要的部分当做黑盒处理以便我们更快、更有效的阅读源码。

废话不多说发车

这里讲个小细节如果你在面试这里一定要提前给面试官说好你阅读的源码版本有三方面好处

第一避免不同版本的Spring源码不一致导致和面试官的分歧问题

第二让面试官感觉你小子是真的阅读过源码就算你说的逻辑和面试官有分歧面试官第一反应会是源码版本差异导致的

第三装逼使用…

dependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion4.3.11.RELEASE/version

/dependency创建接口

xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsdbean

idmessageService

classcn.hls.spring.MessageServiceImpl/

/beans启动类

ClassPathXmlApplicationContext(application.xml);System.out.println(context

启动成功);MessageService

context.getBean(MessageService.class);//

输出:

worldSystem.out.println(messageService.getMessage());}

}最终输出结果

ClassPathXmlApplicationContext(application.xml);

debug

ClassPathXmlApplicationContext(String[]

configLocations,

parent){super(parent);setConfigLocations(configLocations);if

(refresh)

PathMathingResourcePatternResolver

解析配置文件setConfigLocations(configLocations)设置

到当前应用程序中refresh()解析配置文件、完成bean的注册、实例化、初始化、代理等一系列的工作最终创建出一个

Bean

System.currentTimeMillis();设置活跃状态为

Environment

对象中准备监听器和事件的集合对象默认为空的集合earlyApplicationEvents

new

LinkedHashSetApplicationEvent();

这个方法不重要也不必要去深入了解知道做了容器刷新的准备工作即可。

application.xml

DefaultListableBeanFactoryDefaultListableBeanFactory

beanFactory

createBeanFactory();beanFactory.setSerializationId(getId());customizeBeanFactory(beanFactory);loadBeanDefinitions(beanFactory);synchronized

{this.beanFactory

}上述我们必须记住这个工厂类DefaultListableBeanFactory甚至要做到背诵默写的程度

loadBeanDefinitions(beanFactory)

protected

loadBeanDefinitions(DefaultListableBeanFactory

beanFactory){//

创建XmlBeanDefinitionReader这个是我们xml文件的解析器XmlBeanDefinitionReader

beanDefinitionReader

XmlBeanDefinitionReader(beanFactory);beanDefinitionReader.setEnvironment(this.getEnvironment());beanDefinitionReader.setResourceLoader(this);beanDefinitionReader.setEntityResolver(new

ResourceEntityResolver(this));initBeanDefinitionReader(beanDefinitionReader);//

加载BeanDefinitionsloadBeanDefinitions(beanDefinitionReader);

protected

loadBeanDefinitions(XmlBeanDefinitionReader

reader)

{reader.loadBeanDefinitions(configResources);}String[]

configLocations

{reader.loadBeanDefinitions(configLocations);}

}继续往下看一直到

actualResources){ResourceLoader

resourceLoader

resourceLoader).getResources(location);//

直接看这行其余不重要int

loadBeanDefinitions(resources);if

(actualResources

{actualResources.add(resource);}}return

loadCount;}}

resourceLoader.getResource(location);int

loadCount

loadBeanDefinitions(resource);if

(actualResources

{actualResources.add(resource);}return

loadCount;}

resource);XmlBeanDefinitionReader

505

registerBeanDefinitions(Document

doc,

createBeanDefinitionDocumentReader();int

countBefore

getRegistry().getBeanDefinitionCount();//

其余不重要直接看这行documentReader.registerBeanDefinitions(doc,

createReaderContext(resource));return

getRegistry().getBeanDefinitionCount()

countBefore;

registerBeanDefinitions(Document

doc,

从根节点开始解析遍历doRegisterBeanDefinitions(root);

}protected

doRegisterBeanDefinitions(Element

root)

createDelegate(getReaderContext(),

root,

(this.delegate.isDefaultNamespace(root))

{String

root.getAttribute(PROFILE_ATTRIBUTE);if

(StringUtils.hasText(profileSpec))

{String[]

StringUtils.tokenizeToStringArray(profileSpec,

BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);}}preProcessXml(root);//

直接看这里其余不重要parseBeanDefinitions(root,

this.delegate);postProcessXml(root);this.delegate

parent;}protected

(delegate.isDefaultNamespace(root))

{NodeList

(delegate.isDefaultNamespace(ele))

{//

{delegate.parseCustomElement(ele);}}}}else

{delegate.parseCustomElement(root);}

}//

根据不同的配置走不同的分支配置:import、alias、bean、beans

private

{importBeanDefinitionResource(ele);}else

ALIAS_ELEMENT))

{processAliasRegistration(ele);}else

BEAN_ELEMENT))

recursedoRegisterBeanDefinitions(ele);}}我们这里只看

bean

解析各种xml标签去生成对应的BeanDefinition读者有兴趣可以自己看一下BeanDefinitionHolder

bdHolder

delegate.parseBeanDefinitionElement(ele);if

(bdHolder

delegate.decorateBeanDefinitionIfRequired(ele,

bdHolder);try

重点正式开始注册BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,

getReaderContext().getRegistry());}getReaderContext().fireComponentRegistered(new

BeanComponentDefinition(bdHolder));}

}public

registerBeanDefinition(BeanDefinitionHolder

definitionHolder,

definitionHolder.getBeanName();registry.registerBeanDefinition(beanName,

definitionHolder.getBeanDefinition());//

注册别名String[]

definitionHolder.getAliases();if

(aliases

{registry.registerAlias(beanName,

alias);}}}public

如果已经存在我们要排抛出异常Spring不允许覆盖BeanDefinition

oldBeanDefinition

beanDefinitionMap.get(beanName);if

(oldBeanDefinition

(!isAllowBeanDefinitionOverriding())

{throw

BeanDefinitionStoreException()}}if

(oldBeanDefinition

{this.beanDefinitionMap.put(beanName,

{//

重点在这将我们的beanName与beanDefinition放至beanDefinitionMap中this.beanDefinitionMap.put(beanName,

beanDefinition);this.beanDefinitionNames.add(beanName);this.manualSingletonNames.remove(beanName);}}到这里基本就结束了我们来回顾一下

refreshBeanFactory

扫描遍历对不同配置的标签import、alias、bean、beans走不同的逻辑判断将当前的标签各属性进行组装成

beanDefinition调用

是否被注册过如果被注册过则直接抛出异常Spring不允许覆盖如果没有注册过则将

BeanName

系列的文章大家都知道分享的很细但是我们细细品味一下我们读源码到底为了什么以及如何去读、如何有效的读、如何快速的读我相信每一个人心中都有一套读源码的方式。

至于哪一种阅读方式更为合理后面博主准备单独出一篇文章来讲解或者你可以私信我告知我你的读源码的方式一起加油、一起学习。

3、prepareBeanFactory

5、invokeBeanFactoryPostProcessors

整体简介

可以自由扩展通过实现BeanFactoryPostProcessor

BeanDefinitionRegistryPostProcessor

接口对

invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory

beanFactory)

BeanDefinitionRegistryPostProcessor接口的实现//

若这些实现有对应的order(顺序)则排序之后依次调用PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory,

getBeanFactoryPostProcessors());if

(beanFactory.getTempClassLoader()

null

beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME))

{beanFactory.addBeanPostProcessor(new

LoadTimeWeaverAwareProcessor(beanFactory));beanFactory.setTempClassLoader(new

ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}

BeanDefinitionRegistryPostProcessor

整体简介

registerBeanPostProcessors(ConfigurableListableBeanFactory

beanFactory)

实例化并且注册所有的beanPostProcessorPostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory,

this);

invokeBeanFactoryPostProcessors

里面很像都是对实现一些特定接口的类做加载但需要注意的是对于实现

BeanPostProcessor

BeanDefinitionRegistryPostProcessor

7、initMessageSource

8、initApplicationEventMulticaster

整体简介

11、finishBeanFactoryInitialization

整体简介完成所有非懒加载的单例对象的实例化操作从此方法开始进行对象的创建包含了实例化初始化循环依赖AOP等核心逻辑的处理过程此步骤是最最核心且关键的点要对其中的细节最够清楚

protected

finishBeanFactoryInitialization(ConfigurableListableBeanFactory

beanFactory)

实例化剩下的单例对象beanFactory.preInstantiateSingletons();

}public

拿到我们之前存储的所有beanDefinition的名字ListString

beanNames

ArrayList(this.beanDefinitionNames);

(String

如果beanName对应的bean不是FactoryBean只是普通的bean通过beanName获取bean实例getBean(beanName);}

}public

此方法是实际获取bean的方法也是触发依赖注入的方法return

doGetBean(name,

这里需要一步转换这里的原因我们附录1提到过这里不再过多讨论String

beanName

提前检查单例缓存中是否有手动注册的单例对象剧透一下和循环依赖有关联Object

sharedInstance

当对象都是单例的时候会尝试解决循环依赖的问题但是原型模式下如果存在循环依赖的情况那么直接抛出异常if

(isPrototypeCurrentlyInCreation(beanName))

{throw

BeanCurrentlyInCreationException(beanName);}if

(mbd.isSingleton())

返回以beanName的(原始)单例对象如果尚未注册则使用singletonFactory创建并注册一个对象:sharedInstance

{try

为给定的合并后BeanDefinition(和参数)创建一个bean实例//

createBean(beanName,

根据执行bean使用对应的策略创建新的实例如工厂方法构造函数主动注入、简单初始化BeanWrapper

instanceWrapper

对bean的属性进行填充将各个属性值注入其中可能存在依赖于其他bean的属性则会递归初始化依赖的beanpopulateBean(beanName,

mbd,

我们需要进行名称转化防止传入的是一个别名或其他的名称利用转换后的别名去调用

如果不存在则需要去根据该

可能大家有点懵怎么这么多创建的方法这里其实我们不需要太过于关注只需要关注

类名称

getInstantiationStrategy().instantiate(mbd,

beanName,

通过class得到其默认的构造方法constructorToUse

clazz.getDeclaredConstructor();//

return

BeanUtils.instantiateClass(constructorToUse);}

}public

如果当前是无参构造方法的话则argsWithDefaultValues为空return

ctor.newInstance(argsWithDefaultValues);

加锁保证线程安全得到当前

classcom.mashibing.hls.MessageServiceImplproperty

namename

注入属性applyPropertyValues(beanName,

mbd,

获取pvs的PropertyValue对象数组并将其转换成列表ListPropertyValue

original

Arrays.asList(pvs.getPropertyValues());for

(PropertyValue

因为我们的属性注入有可能注入的是一个BeanReference需要重新去

BeanFactory

按原样使用deepCopy构造一个新的MutablePropertyValues对象然后设置到bw中以对bw的属性值更新bw.setPropertyValues(new

MutablePropertyValues(deepCopy));}

}public

setPropertyValues(PropertyValues

false,

setPropertyValues(PropertyValues

pvs,

后续主要通过反射对值进行设置感兴趣的可以自己去看下源码实现setPropertyValue(pv);

}11.3

postProcessBeforeInitialization(Object

bean,

{System.out.println(我前置增强);return

bean;}public

postProcessAfterInitialization(Object

bean,

{System.out.println(我后置增强);return

bean;}

将BeanPostProcessors应用到给定的现有Bean实例调用它们的postProcessBeforeInitialization初始化方法。

//

返回的Bean实例可能是原始Bean包装器wrappedBean

applyBeanPostProcessorsBeforeInitialization(wrappedBean,

beanName);//调用初始化方法先调用bean的InitializingBean接口方法后调用bean的自定义初始化方法invokeInitMethods(beanName,

wrappedBean,

将BeanPostProcessors应用到给定的现有Bean实例调用它们的postProcessAfterInitialization方法。

//

返回的Bean实例可能是原始Bean包装器wrappedBean

applyBeanPostProcessorsAfterInitialization(wrappedBean,

wrappedBean;

applyBeanPostProcessorsBeforeInitialization(Object

existingBean,

该工厂创建的bean的BeanPostProcessors列表for

(BeanPostProcessor

processor.postProcessBeforeInitialization(result,

beanName);//

{//直接返回result中断其后续的BeanPostProcessor处理return

result;}//让result引用processor的返回结果,使其经过所有BeanPostProcess对象的后置处理的层层包装result

current;}//返回经过所有BeanPostProcess对象的后置处理的层层包装后的resultreturn

result;

在bean上调用指定的自定义init方法invokeCustomInitMethod(beanName,

bean,

ClassUtils.getInterfaceMethodIfPossible(initMethod);//

}//

applyBeanPostProcessorsAfterInitialization(Object

existingBean,

beanName){//初始化结果对象为result默认引用existingBeanObject

result

existingBean;//遍历该工厂创建的bean的BeanPostProcessors列表for

(BeanPostProcessor

{//回调BeanPostProcessor#postProcessAfterInitialization来对现有的bean实例进行包装Object

current

processor.postProcessAfterInitialization(result,

beanName);//

{//直接返回result中断其后续的BeanPostProcessor处理return

result;}//让result引用processor的返回结果,使其经过所有BeanPostProcess对象的后置处理的层层包装result

current;}//返回经过所有BeanPostProcess对象的后置处理的层层包装后的resultreturn

BeanPostProcess

完成整个容器的启动所有的对象都准备完成可以进行后续业务流程的操作清除上下文缓存初始化生命周期处理器发送刷新完成事件

13、销毁

前面我们已经创建成功了对象当我们使用完成之后肯定要进行销毁那么

Spring

直接将beanFactory置为nullcloseBeanFactory();

}protected

清空在包含的Bean名称之间映射bean名称-Bean包含的Bean名称集this.containedBeanMap.clear();//

清空在相关的Bean名称之间映射bean名称-一组相关的Bean名称this.dependentBeanMap.clear();//

清空在相关的Bean名称之j键映射bean名称bean依赖项的Bean名称集this.dependenciesForBeanMap.clear();//

清除此注册表中所有缓存的单例实例clearSingletonCache();

}protected

加锁使用单例对象的高速缓存:beam名称-bean实例作为锁synchronized

{//

清空单例对象的高速缓存:beam名称-bean实例this.singletonObjects.clear();//

清空单例工厂的缓存bean名称-ObjectFactorythis.singletonFactories.clear();//

清空早期单例对象的高速缓存bean名称-bean实例this.earlySingletonObjects.clear();//

清空已注册的单例集按照注册顺序包含bean名称this.registeredSingletons.clear();//

设置当前是否在destroySingletons中的标志为falsethis.singletonsCurrentlyInDestruction

false;}

{this.allBeanNamesByType.clear();this.singletonBeanNamesByType.clear();

直接将beanFactory置空

{beanFactory.setSerializationId(null);this.beanFactory

null;}

classcn.hls.spring.MessageServiceImpl

init-methodinit

init(){System.out.println(我是类的初始化);}public

void

destroy(){System.out.println(我是类的销毁);}

在执行

有些小伙伴可能疑惑哎博主你这不对呀你这循环依赖也没讲、三级缓存也没讲你是不是漏的有点多。

Spring

代理对象的问题这个我们后面单独出一篇来描述不要着急小黄不会不讲的。

XML

AnnotationConfigApplicationContext

Spring

我是爱敲代码的小黄独角兽企业的Java开发工程师CSDN博客专家Java领域新星创作者喜欢后端架构和中间件源码。

七、附录

canonicalName(BeanFactoryUtils.transformedBeanName(name));

public

(String)this.aliasMap.get(canonicalName);if

(resolvedName

BeanDefinitionRegistryPostProcessor

BeanFactory

postProcessBeanFactory(ConfigurableListableBeanFactory

beanFactory)

PropertyValueMutablePropertyValues

messageService

beanFactory.getBeanDefinition(messageService).getPropertyValues();ListPropertyValue

propertyValueList

messageService.getPropertyValueList();//

(PropertyValue

{System.out.println(BeanFactoryPostProcessor

name

[null]3、BeanFactoryPostProcessor

BeanDefinitionRegistryPostProcessor

AOP

postProcessBeforeInitialization(Object

bean,

{System.out.println(我会在类初始化前调用);return

bean;}Overridepublic

postProcessAfterInitialization(Object

bean,

{System.out.println(我会在类初始化后调用);return

bean;}