@TOC# Spring系列
记录在程序走的每一步___auth:huf
最近在复习Spring核心原理; 顺手记录;
Spring 真正的生命周期;
在很多文章中 写到这么个标题: XXXX原理 你只要看完这一篇就够; 作为一个技术苦行憎; 老衲很直白的说一句: 不可能的. 一个技术;需要大量时间去重复调研;最终才会摸清楚其原理; 我们还是一步一脚印;慢慢往里研究; 拨开云雾见天日 守得云开见月明;欢迎各路大神指正;共同进步
本文章开销时长 要比 之前的文章开销时长要大很多 本章节一共写了9个小时 ; 各位同学 记得三连
- 本文章 所有源码均是作者 自己从Spring源码中Copy 注释 之前有部分同学反映看不太清楚;所以把//去除以便源码的阅读;
承接周三的陈述; 我们讲到了Bean的创建; 以下是上个篇章尾部的描述:通过
1:ResourcePatternResolver获得指定包路径下的所有 .class 文件（Spring源码中将 此文件包装成了Resource对象
2:利用MetadataReaderFactory解析Resource对象得到MetadataReader（在Spring源码中 MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory， MetadataReader的具体实现类为SimpleMetadataReader）
3:利用MetadataReader进行excludeFilters和includeFilters，以及条件注解@Conditional的筛选 （条件注解并不能解析某个类上是否存在@Conditional注解，如果存在则调用注解中所指定 的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉。）
4.筛选通过后，基于metadataReader生成ScannedGenericBeanDefinition
5:再基于metadataReader判断是不是对应的类是不是接口或抽象类;
我们的主要目的是得到BeanDefinition 然后合成RootBeanDefinition;最后放进缓存集合中去
我们开始回顾; 之前的源码 就不会一遍一遍看了 如果有的 可能会一笔带过;
以下是我们创建容器的方法
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(testMain.class);
Object hufFactoryBean = context.getBean("hufFactoryBean");
System.out.println(hufFactoryBean);
再AnnotationConfigApplicationContext构造器 点进去后 我们发现 :
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
创建一个新的 context; 根据系统参数; 上一篇文章有讲到;
this();
注册Spring自己用的组件; 为创建容器 提供必须的条件; 这里不再累赘
register(componentClasses);
开始启动容器,重点关注该方法;
refresh();
}
AbstractApplicationContext.refresh() 其源码我给你们带进来这里 进行每一行代码的解释;
有部分如果内容比较多的 后面会有独立的篇章 去讲解相对应的内容; 看源码请勿心急; 如果有哪个地方没看懂;可以先放一下 把整个链路串起来 然后再看; 以下 是Spring的核心源码:
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
检查初始化环境
prepareRefresh();
通过子类获取它内部的Bean工厂 其内部有两个实现方法 如果有兴趣的同学 可以自行去查看
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
配置工厂的类加载器; 以及后置处理器; 内部使用了beanfactorypostprocessor 机制
prepareBeanFactory(beanFactory);
try {
所有 bean 定义都已加载，bean还没有 bean 被实例化。这里引出了实例化一个词
postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
实例化并调用所有已注册的 beanfactorypostprocessor 此时Bean还未实例化
仅仅是再处理配置文件的调度后置处理器
invokeBeanFactoryPostProcessors(beanFactory);
这里开始分装与注册 PostProcessor 例如MergedBeanDefinitionPostProcessor
就跟普通的Processor不一样 都再这个方法内进行分装
并且 这里创建出来了 BeanFactory 还有自己的配置 再初始化之前的接口 这里引入
InstantiationAwareBeanPostProcessor , MergedBeanDefinitionPostProcessor
再文章后面会有这两个接口的讲解 到这里 Bean的实例化还没有开始 更别说初始化
registerBeanPostProcessors(beanFactory);
这行不作解释;
beanPostProcess.end();
注册messageSource; 利用AbstractBeanFactory.dogetBean方法; 进行初始化;PostProcessor 就起效果了;
initMessageSource();
注册 初始化 特殊的Bean Spring的监听机制;
ApplicationListener及ApplicationEventMulticaster
initApplicationEventMulticaster();
初始化特定上下文子类中的其他特殊bean。 目前看源码没看到注册了什么Bean
在控制台也没看到有什么东西打印出来; 知道的小伙伴可以私聊 我们一起讨论
onRefresh();
注册Springlistener Bean 如果你实现了Listener 就会这这里被注册
registerListeners();
实例化所有 非 懒加载的 单例Bean; 本文中的重点;
finishBeanFactoryInitialization(beanFactory);
最后:发布相应的事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
注销Bean的逻辑 放到其他章节去讲;.
destroyBeans();
cancelRefresh(ex);
throw ex;
}
finally {
resetCommonCaches();
contextRefresh.end();
}
}
}
上面这个方法特别重要.也引出了很多关键的接口 以及关键的初始化;
总结;
1:初始化Bean之前 就必须实例化Bean 实例化过后才会初始化; 初始化过后的Bean才是完整的Bean
2:在初始化Bean的时候 我们有可能会影响Bean的 在实例化Bean的时候 我们也可以通过 PostProcessor来影响Bean的实例化; PostProcessor 作为Spring的"插件" 例如;InstantiationAwareBeanPostProcessor MergedBeanDefinitionPostProcessor
3:所有的监听机制 Listenner 以及 ApplicationEventMulticaster 都会再Bean 注册之前创建
4:最后创建 非 懒加载 的Bean ;
以下到 我们这篇文章的重点:
// 实例化所有 非 懒加载的 单例Bean; 本文中的重点; 该句源码是在上面源码里拿到的;
finishBeanFactoryInitialization(beanFactory);
继续往下走 点进这个方法:
protected void finishBeanFactoryInitialization(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));
}
如果没有BeanFactoryPostProcessor 就进行注册; 主要用于注释属性值中的Values
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
初始化回调 Bean 之后在其他章节中 讲解Aware;
这里同学可以试试 如果你实现LoadTimeWeaverAware 接口 那么就会在Bean注册之前 先注册这个Aware
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
停止使用临时类加载器进行类型匹配。
beanFactory.setTempClassLoader(null);
允许缓存所有bean定义元数据，不需要进一步更改。
beanFactory.freezeConfiguration();
实例化非懒加载Bean
beanFactory.preInstantiateSingletons();
}
这里 不做过多的解释; 继续往下面看;
beanFactory.preInstantiateSingletons();
进入该方法
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
允许init方法注册新的bean定义
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
这里就可以看到 得到Bean的名字集合 开始触发所有Bean的初始化;
for (String beanName : beanNames) {
继前面文章面熟 所有Beandefinition 最终会合并成为RootBeanDefinition,然后进行Bean的初始化;
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
判断是不是抽象的Bean 判断是不是单例的Bean 判断是不是懒加载的Bean
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
判断是不是工厂的Bean
if (isFactoryBean(beanName)) {
如果是 那么就用&符号加 BeanName 得到工厂的Bean
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
得到Bean后 进行类型判断 是不是工厂bean;
如果不是 那么直接调度 getBean 这段IF里面的东西先进行屏蔽;
if (bean instanceof FactoryBean) {
if (isEagerInit) {
重点 重点 重点
getBean(beanName);
}
}
}
else {
重点 重点 重点
getBean(beanName);
}
}
}
触发所有适用bean的初始化后回调。。。 这里就不多过的冗余下去;
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
.tag("beanName", beanName);
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
smartInitialize.end();
}
}
}
getBean(beanName);
点进去GetBean 方法中
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
继续往下点:
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
获取名字; 该名字 刚进来的时候也许是别名 也许是其他的名字
但是最终会通过这个方法获取到Bean的真实名字
String beanName = transformedBeanName(name);
Object beanInstance;
检查单例池是否有该Bean的存在
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
如果有 就返回 该方法里面还会有另外一个检查 此处不做细说
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
如果我们已经在创建此bean实则抛出异常;
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
检查工厂中是否存在bean定义;
BeanFactory parentBeanFactory = getParentBeanFactory();
如果有 就使用工厂的方法创建Bean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
此处源码自行查看 为方便阅读 此处省略
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
Spring系统计算 程序开销时间 与容器启动 关系不大;
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
这里不再重复陈述
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
这里就要说一个注解了 @DependsOn 这个注解的意思是 在某个类初始化之前
另外一个类再在它之前被初始化 这里插一句话;
Spring解决了循环依赖 但是又没有完全解决循环依赖;
这里的循环依赖 无法解决的 假设使用这个注解 A依赖B B依赖A 是一定会报错的;
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
创建bean实例。
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
这个逻辑是创建原型Bean的逻辑 也就是多例Bean
Object prototypeInstance = null;
try {
初始化前
beforePrototypeCreation(beanName);
初始化
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
初始化后
afterPrototypeCreation(beanName);
}
返回
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
单例bean的创建
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ′" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
初始化前
beforePrototypeCreation(beanName);
try {
初始化
return createBean(beanName, mbd, args);
}
finally {
初始化后
afterPrototypeCreation(beanName);
}
});
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}
catch (BeansException ex) {
beanCreation.tag("exception", ex.getClass().toString());
beanCreation.tag("message", String.valueOf(ex.getMessage()));
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
finally {
beanCreation.end();
}
}
return adaptBeanInstance(name, beanInstance, requiredType);
}
本文章总结:
描述了 Bean 创建的大体流程 但是销毁流程 跟属性注入 没有讲到 后面会有单独的文章进行讲解;