本章节开始分析bean是何时以及如何加载bean的,同时也会留有之前@propertySource生效的问题.
1.后期还会解析其内嵌式tomcat如何运作
2.AOP的整理比如采用了哪些方式来调用jdk或者cglib的动态代理
3.解析整个整个spring容器的运转流程
4.总结整个springboot启动流程的总结
5.用processon画上面的流程图
首先spring启动的时候会将单例且非懒加载的bean实例存放在singleObjects(concurrentHashMap) key是beanName value 就是具体的对象实例,
同时还存储了其他的比如class和beanName之间的concurrentHashMap,用来提供多种查询方式。
我们主要关注AbstractApplicationContext的finishBeanFactoryInitialization方法
该方法的作用是:初始化其他非懒加载的实例,也就是说我们的bean会在这边被实例化并初始化,其源码如下:
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
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));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
- 1.首先检测ConversionService是否存在,如果存在就给beanFactory设置该属性,ConversionService的作用就是作为一个内部的bean的属性编辑器,编辑bean的属性
- 2.查找的方式就是先检测其是否携带&然后根据真实的名字或者最终的别名,然后根据别名去查找,如果不存在且父类beanFactory存在就去父类找
- 如果不存在 value resolver就注册一个默认的embedded value resolver的beanPostProcessor
- 4.初始化LoadTimeWeaverAware
- 5.不在使用mporary ClassLoader 进行类型比较
- 6.不在允许修改beanDefinition,把beanDefinitionNames的放入到frozenBeanDefinitionNames,但是可以新增beanDefinition
- 7.进行所有的剩余非懒加载bean的初始化
最终初始化bean的源码如下
@Override
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
- 1.迭代的是副本,这样在生成bean的时候,还有可能注册新的beanDefinition
- 2个for循环,第一个是调用判断是否要获取factorybean,如果是调用getBean,然后判断factory是否继承了SmartFactoryBean,若是则看isEagerInit方法返回true还是false,true表示现在就需要调用getObject方法。
第二个是调用实例化成功的bean(实现SmartInitializingSingleton)的afterSingletonsInstantiated
- 2个for循环,第一个是调用判断是否要获取factorybean,如果是调用getBean,然后判断factory是否继承了SmartFactoryBean,若是则看isEagerInit方法返回true还是false,true表示现在就需要调用getObject方法。
- 3.RootBeanDefinition 和 ChildBeanDefinition 的关系目前只能通过xml配置的形式,通过设置bean标签的parent属性。这样的好处是当我们设置好了父类的bean标签 我们子类只要指定parent,其大部分属性都会继承父类,当然子BeanDefinition也可以覆盖或者新增一些新的配置信息
- 4.子BeanDefinition继承父BeanDefinition的scope、constructor 、property 、method overrides,并添加新配置。子BeanDefinition会覆盖父子BeanDefinition的配置有:initialization method、destroy method、static factory method settings
- 子BeanDefinition有些配置始终不会继承父BeanDefinition:depends on、autowire mode、dependency check、singleton、lazy init。
- 如果子类的bean 没有定义class 属性会默认使用父类,子bean的class必须要和父bean的class兼容,也就是说能够接受父bean的配置。
具体的代码解析
- 1.首先获取getMergedLocalBeanDefinition,该方法就是对于获取childbean的时候,先去获取parentbean,然后先将子类的大部分属性都设置为父类,然后在检测子类自身非beandefinition,看看如果有的属性子类已经设置过了,就使用子类的。
- 2.然后只有不是抽象类且是单例并非懒加载的才可以加载
isFactoryBean(beanName)
分为三个部分
获取单例,如果不存在也不创建他
Object beanInstance = getSingleton(beanName, false);
if (beanInstance != null) {
return (beanInstance instanceof FactoryBean);
}
如果bean实例不存在 但是beanDefinition存在且其父beanFactory是ConfigurableBeanFactory,则调用父亲的isFactoryBean方法
// No singleton instance found -> check bean definition.
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
// No bean definition found in this factory -> delegate to parent.
return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
}
//如果bean和beanDefinition都不存在 在调用 isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));方法判断
return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
第一部分:
- 1.去singletonObjects尝试获取,当获取不到且当前bean正在创建中(即singletonsCurrentlyInCreation中包含当前beanName)
- 2.再去earlySingletonObjects获取,如果获取不到且allowEarlyReference=true 即允许提前创建bean,则会从singletonFactories获取ObjectFactory
- 3.如果ObjectFactory存在,通过getObject方法获取真正的对象,并把这个对象放入earlySingletonObjects并从singletonFactories删除ObjectFactory
第二部分:
- 1.当变化后的beanDefinition不存在,但是父beanfactory存在 则使用原始的name去查看实例是否存在并判断是否factoryBean
第三部分:
- 1.当转化后得到的beanName 如果存在beanDefinition,我们在获取mergedbean,然后预判断该bean未来是否是factoryBean
- 首先尝试获取mergedbean的targetType,如果存在就用他判断是否factoryBean
- 然后在判断factorymethodname是否存在,如果存在就不是factroyBean,如果这个也不存在 就进行下一步
- 然后在判断mergedbean的beanClass类型,如果这个也不存在就根据getBeanClassName判断bean的类型
回到preInstantiateSingletons这个方法
- 1.如果是factoryBean 则先获取工厂的bean,然后判断该工厂是否继承了smartFactoryBean ,该smartFactoryBean 的isEagerInit 默认为false表示真正的getOject中的bean对象现在不需要实例化,true为需要立即实例化
- 2.然后调用getBean方法
- 3.然后最后一个for循环循环调用实现SmartInitializingSingleton接口的afterSingletonsInstantiated方法
下一章节我们仔细分析getBean方法