首页  流程图  详情

Springboot启动流程

2022-12-26 10:10:23   1  举报





Springboot启动流程

后端开发

作者其他创作

大纲/内容

beanFactory.freezeConfiguration();

注册默认的环境bean。

将函数接口缓存到三级缓存

②

判断实现了EventListener接口

this.reader = new AnnotatedBeanDefinitionReader(this);

onRefresh();

MergedBeanDefinitionPostProcessor.class

SmartInitializingSingleton.class#afterSingletonsInstantiated()

AutowiredAnnotationBeanPostProcessor.AnnotatedMethodElement#inject

for (String beanName : beanNames)

ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry

初始化一个lifeCycle处理器

注册后置处理器WebApplicationContextServletContextAwareProcessor

这边只有这个创世纪的用于解析配置的类会被调用

initLifecycleProcessor()

返回不完整的bean

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this))

SpringApplication.run

环境准备

getApplicationEventMulticaster().multicastEvent(earlyEvent);

获取bean工厂注解方式

这里会把前面那些监听器放到早期监听器对象里面去earlyApplicationListeners

setter方法反射完成依赖bean注入

beforeSingletonCreation(beanName);

整理合并bean定义

自定义初始化bean的3种方式1.@PostConstruct -> 实现后置处理器2.InitializingBean接口 -> afterPropertiesSet方法3.@Bean(initMethod = \"init\") -> init-Method方法执行顺序从上到下

ApplicationContextInitializedEvent

createAopProxy().getProxy(classLoader);

移除三级缓存

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

有依赖先创建依赖的bean

循环所有beanName

循环执行start方法

⑤

第一波筛选实现了BeanDefinitionRegistryPostProcessor接口和PriorityOrdered接口的类只有创世纪类ConfigurationClassPostProcessor

播发事件

PropertySourceLocator#locate

获取所有lifeCycle实例

返回bean

DefaultLifecycleProcessor#doStart

转换对应的beanName比如去除前缀&，转换别名

缓存池没有就调用getObject()方法生成bean并且放入缓存

Object singletonObject = this.singletonObjects.get(beanName)

其他

dependsOn = mbd.getDependsOn()

getLifecycleBeans()

广播环境准备完毕事件ApplicationEnvironmentPreparedEvent

从FactoryBean缓存池中获取bean

从单例池中获取

开始处理配置文件bean

非抽象，是单例，不是懒加载才再这边创建

prototype

判断是否需要提早曝光：单例 & 允许循环依赖 & 当前bean已经正在创建中为避免后期循环依赖，在bean初始化完成前将创建实例的ObjectFactory 加入三级缓存赖这一步是解决循环依赖的

广播上下文初始化事件ApplicationContextInitializedEvent

bean

object = getCachedObjectForFactoryBean(beanName);

第九次后置处理器调用将bean注册为可销毁

最后调用bean工厂的后置处理器，这边会调用ConfigurationClassPostProcessor方法的postProcessBeanFactory方法会对所有@Configuration标注的配置文件创建cglib动态代理，为了在配置类中一个@Bean引用另外一个@Bean不直接方法调用，重复创建Bean

使用的时候调用getObject方法就会调用这边会在使用AOP的时候在这边创建动态代理实现类AbstractAutoProxyCreator.class

singleton第二个参数是函数接口

具体实现类start启动

判断bean不是FactoryBean或者beanName前缀是&返回bean本身

phases.get(key).start();

prepareBeanFactory(beanFactory);

通过下面方法去加载classpath下META-INF/spring.factories中对应的class类型的类

注册web容器的一些scope等

getRunListeners(args)

refreshContext(context);

registerWebApplicationScopes(getBeanFactory())

!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()

ApplicationEnvironmentPreparedEvent

结束后

先从一级缓存中拿

smartSingleton.afterSingletonsInstantiated();

加入多播器

启动内置tomcat

mbd.isSingleton()

BeanUtils.instantiateClass(contextClass)

AbstractBeanFactory#getBean(beanName);

AOP解析Advisor

上下文准备

RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

如果实现了InitializingBean接口调用afterPropertiesSet

EventListenerMethodProcessor#afterSingletonsInstantiated

返回bean本身

创建事件多播器管理所有监听器负责调用事件对应的监听器

new RequestObjectFactory()new ResponseObjectFactory()new SessionObjectFactory()new WebRequestObjectFactory()

this.scanner = new ClassPathBeanDefinitionScanner(this);

循环广播应用启动事件ApplicationStartingEvent

容器里面有就直接获取没有就生成一个默认的

调用实现下面接口的locate方法加载配置

markBeanAsCreated(beanName)

invokeBeanFactoryPostProcessors

判断如果实现了SmartInitializingSingleton接口就调用afterSingletonsInstantiated方法这又是一个扩展点注解方式监听器在这边解析

InstantiationAwareBeanPostProcessor.class

基于application类型创建application上下文

二级缓存中没有从三级缓存中拿，拿到的是创建动态代理的函数接口

初始化

beanName = transformedBeanName(name);

第三次调用后置处理器，允许修改合并的bean定义AutowiredAnnotationBeanPostProcessor.class解析@Autowired和@Value，封装到InjectionMetadata

createWebServer();

run

判断是否有工厂方法

播发早期事件

存在，判断FactoryBean类型

singletonObject = this.singletonObjects.get(beanName);

将动态代理放入二级缓存

SmartInstantiationAwareBeanPostProcessor.class

找不到匹配的构造函数就使用无参构造函数

Supplier<?> instanceSupplier = mbd.getInstanceSupplier();

implements

DestructionAwareBeanPostProcessor

实例化和注册beanFactory中扩展了BeanPostProcessor的bean就是说那些bean的后置处理器会在这一步实例化

ConfigurationClassPostProcessor.classAutowiredAnnotationBeanPostProcessor.classCommonAnnotationBeanPostProcessor.classEventListenerMethodProcessor.classDefaultEventListenerFactory.class

initMessageSource();

isFactoryBean(beanName)

生成四个对象缓存到resolvableDependencies

第二波筛选，上面解析完后这边能找到自己定义的实现了BeanDefinitionRegistryPostProcessor接口和Ordered接口的类

判断是否是factoryBean

PriorityOrdered

FactoryBean的getObject()方法生成的bean

bean实例化之前第一次后置处理器调用这边调用bean的后置处理器会解析AOP中Aspectj对象

推算设置应用类型SERVLETREACTIVENONE

afterPrototypeCreation(beanName);

通过application.getListeners()获取所有之前加载的监听器

实例化上下文org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext

singletonFactory = this.singletonFactories.get(beanName);

通过构造方法自动注入创建bean实例

BeanPostProcessor#postProcessBeforeInitialization

tomcat的正式启动nacos启动包括注册和定时拉取任务开始都在这边

创建方式选择

BeanDefinitionRegistryPostProcessor.class

从正在创建singletonsCurrentlyInCreation移除

填充属性其中如果存在依赖于其他bean的属性，则会递归初始依赖bean

beanFactory = obtainFreshBeanFactory()

Object sharedInstance = getSingleton(beanName);

再判断下缓存

postProcessBeanFactory(beanFactory)

实例化剩余的单实例bean

AOP创建动态代理逻辑

AutowiredAnnotationBeanPostProcessor.AnnotatedFieldElement#inject

用来调用除初始化3个Aware之外的其他一堆Aware

创建bean工厂之后的操作在spring中留给子类扩展

获取实现ApplicationListener.class接口的事件监听器

methodToInvoke.invoke(bean)

调用创世纪类进行解析

this.webApplicationType = WebApplicationType.deduceFromClasspath();

是和否最终都会调用

beforePrototypeCreation(beanName);

最后容器刷新，发布刷新事件（spring cloud从这里启动）

startBeans(true);

比如nacos配置中心

否

③

第五次调用后置处理器，属性填充前调用，可以终止属性填充

进入

对于@EventListener注解的bean

通过LifecycleProcessor来执行Lifecycle实现类的start方法

调用bean工厂的后置处理器会在此将class扫描成beanDefinition

initApplicationEventMulticaster()

jdk

getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

进入正题

⑦

((InitializingBean) bean).afterPropertiesSet();

field属性反射完成依赖bean注入

具体实例调用

执行run方法

是

singletonObject = this.earlySingletonObjects.get(beanName);

this.singletonFactories.remove(beanName)

标记下要被创建，添加到alreadyCreated中

listener.starting();

第一次拿一级缓存没有并且不是正在创建直接返回空

判断scope

获取bean

registerBeanPostProcessors(beanFactory);

new DefaultLifecycleProcessor()

WebApplicationContext.SCOPE_REQUESTWebApplicationContext.SCOPE_SESSION(WebApplicationContext.SCOPE_APPLICATION

singletonObject = singletonFactory.getObject()

⑥

NacosPropertySourceLocator

①

environmentsystemPropertiessystemEnvironment

设置监听器ApplicationListener.class类型

将创世纪的类变为bean定义

super.refresh();

接口方式直接调用

⑧

都没有就使用构造函数创建，第二次调用后置处理器这边的实现类是AutowiredAnnotationBeanPostProcessor.class

⑨

设置initializersApplicationContextInitializer.class类型

执行bean生命周期回调的init方法

一级缓存中没有，并且正在创建（第一次进来不会正在创建直接返回）从二级缓存中拿并且锁住一级缓存synchronized (this.singletonObjects)

Object singletonInstance = getSingleton(beanName);

destroySingleton(beanName)

添加该bean到正在创建singletonsCurrentlyInCreation

三级缓存获取循环依赖核心逻辑

processConfigBeanDefinitions(registry);

对bean工厂进行属性填充注册解析接口方式的监听器的bean的后置处理器

BeanPostProcessor#postProcessAfterInitialization

propertyValue属性填充包括AutowireMode方式注入的bean

afterSingletonCreation(beanName);

registerListeners()

封装为一个ApplicationListenerMethodAdapter

autoStartupOnly等于true时，bean必须实现SmartLifecycle接口，并且isAutoStartup()返回true放入LifecycleGroup中

注册web中的一些scope

beanFactory.preInstantiateSingletons();

创建出现异常销毁bean

调用bean工厂的后置处理器

回调函数接口createBean

初始化国际化资源处理器. 不是主线代码忽略，没什么学习价值。

this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);

注册到监听器

main方法启动

再循环一遍bean名称

cglib

没有拿到就要开始创建

InstantiationAwareBeanPostProcessor.class#postProcessBeforeInstantiationpostProcessAfterInitialization

生产前先冻结bean定义，注册的bean将不能被修改版

if (mbd.getFactoryMethodName() != null)

④

Aware实例方法调用，这边可以调用三种BeanNameAware -> 设置beanNameBeanClassLoaderAware -> 设置BeanClassLoaderBeanFactoryAware -> 设置beanFactory

创建bean

创建bean实例

调用bean定义的后置处理器

FactoryBean.class#getObject()

事件探测器的bean的后置处理器会去解析接口方式的事件监听器ApplicationListenerDetector

创建动态代理

setInitializers()

setListeners()

启动广播器器starting方法

第三波筛选，找到实现了BeanDefinitionRegistryPostProcessor接口的类

如果定义了init-method则调用这个方法

org.springframework.amqp.rabbit.config.internalRabbitListenerAnnotationProcessor ## rabbitmqAOPorg.springframework.context.annotation.internalAutowiredAnnotationProcessor ## 解析@Autiwired

第六次调用后置处理器@Autowired属性注入逻辑

new SpringApplication(primarySources)

PropertySourceBootstrapConfiguration

注解方式反射

finishBeanFactoryInitialization(beanFactory);

添加到单例池并且更新二三级缓存

beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this))

if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup()))

注册后置处理器ApplicationContextAwareProcessor

context.addApplicationListener(applicationListener)

prepareRefresh()

获取广播器EventPublishingRunListener