springboot(4) 启动过程及实现对bean动态代理源码分析 springboot

【springboot(4) 启动过程及实现对bean动态代理源码分析】1.springboot启动过程分析

springboot启动过程run方法：

public ConfigurableApplicationContext run(String... args) {
//创建一个StopWatch对象并调用它的start方法，该类是Spring提供的一个计时器类
StopWatch stopWatch = new StopWatch();
stopWatch.start();

ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;

//设置系统属性java.awt.headless，这里设置为true，表示运行在服务器端
configureHeadlessProperty();

/**
* 获取SpringApplicationRunListeners对象，这个对象是一个SpringBoot事件广播器的管理者，
* 它主要是管理SpringApplicationRunListener对象的，
* SpringApplicationRunListener接口规定了SpringBoot的生命周期，并在各个生命周期广播相应的事件
* springboot默认为EventPublishingRunListener
* 具体可见另外一篇博文springboot（2）生命周期和监听器。
*/
SpringApplicationRunListeners listeners = getRunListeners(args);
//广播启动事件
listeners.starting();

try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);

//准备运行的环境，比如开发环境dev，测试环境test然后根据环境解析不同的配置文件，并广播环境准备事件
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);

//打印SpringBoot的LOGO
Banner printedBanner = printBanner(environment);

//创建SpringBoot的上下文判断当前是否是web环境，
//如果是web程序，创建AnnotationConfigEmbeddedWebApplicationContext的实例，
//否则创建AnnotationConfigApplicationContext的实例
context = createApplicationContext();

//创建FailureAnalyzers的对象,主要是用来处理启动时发生一些异常时的一些分析
analyzers = new FailureAnalyzers(context);

//准备上下文
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
//刷新上下文
refreshContext(context);
afterRefresh(context, applicationArguments); //发送启动完成事件
listeners.finished(context, null);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
return context;
}
catch (Throwable ex) {
handleRunFailure(context, listeners, analyzers, ex);
throw new IllegalStateException(ex);
}
}

准备运行的环境

private ConfigurableEnvironment prepareEnvironment(
SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments) {

// 检查之前设置的webEnvironment属性，如果是web程序，那么创建一个StandardServletEnvironment对象，否则创建StandardEnvironment对象
ConfigurableEnvironment environment = getOrCreateEnvironment();

//准备运行环境配置，根据环境，比如开发环境dev，加载相关配置文件
configureEnvironment(environment, applicationArguments.getSourceArgs());

//发布运行环境加载完毕的事件
listeners.environmentPrepared(environment);
if (!this.webEnvironment) {
environment = new EnvironmentConverter(getClassLoader())
.convertToStandardEnvironmentIfNecessary(environment);
}
return environment;
}

准备上下文：

private void prepareContext(ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
//设置上下文环境
context.setEnvironment(environment);

//设置上下文的beanNameGenerator和resourceLoader(如果SpringApplication有的话)
postProcessApplicationContext(context);

//利用初始化器，对上下文做初始化
//具体可见另外一篇博文 springboot （3）应用上下文初始化器ApplicationContextInitializer
applyInitializers(context);
//发布上下文准备好的事件
listeners.contextPrepared(context);

//打印启动日志
if (this.logStartupInfo) {
logStartupInfo(context.getParent() == null);
logStartupProfileInfo(context);
}

//向上下文的beanFactory中注册一个singleton的bean，bean的名字是springApplicationArguments，
//bean的实例是之前实例化的ApplicationArguments对象
context.getBeanFactory().registerSingleton("springApplicationArguments",
applicationArguments);
//向上下文的beanFactory中注册一个singleton的bean，bean的名字是springBootBanner，bean的实例就是这个printedBanner
if (printedBanner != null) {
context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
}

//向上下文注册启动类的bean，也就是调用SpringApplication.run(Application.class, args); 的类，这里只有一个
Set

刷新上下文

public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//为刷新上下文信息做准备。例如清空缓存，初始化属性信息，验证必要的属性等
prepareRefresh();

//获取到beanFactory,把refreshed属性设置成true，表示已经刷新了，下次再刷新就会抛出异常，不允许重复刷新，
//然后给beanFactory设置serializationId，就是之前通过ContextIdApplicationContextInitializer生成的id
//然后通过getBeanFactory方法拿到上下文的beanFactory(之前创建上下文的时候，创建了一个DefaultListableBeanFactory对象)
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

//对beanFactory设置相关参数
prepareBeanFactory(beanFactory);

try {
//为beanFactory添加后置处理器WebApplicationContextServletContextAwareProcessor，并忽略ServletContextAware
postProcessBeanFactory(beanFactory);

//扫描路径下的所有类，如果被@Component等注解的类，生成BeanDefinition对象，并回调BeanFactoryPostProcessor后置处理器
invokeBeanFactoryPostProcessors(beanFactory);

//注册bean的后置处理器，这些后置处理器将在bean的创建过程中被调用
registerBeanPostProcessors(beanFactory);

//初始化上下文的消息源
initMessageSource();

//初始化事件广播器，springboot在广播事件的时候，默认是同步的，如果想要实现事件异步传播，
//就需要自定义一个名叫applicationEventMulticaster的bean,
//这里就是看是否有自定义的bean，如果有则用用户创建的，否则就用默认的。
initApplicationEventMulticaster();

//初始化其他特殊的bean，比如创建serverlet容器相关的bean（TomcatEmbeddedServletContainerFactory）
onRefresh();

//想事件广播器中添加各种事件监听器
registerListeners();

//实例化所有单例bean
finishBeanFactoryInitialization(beanFactory);

//发布容器事件，结束刷新过程
finishRefresh();
}

catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}

// Destroy already created singletons to avoid dangling resources.
destroyBeans();

// Reset 'active' flag.
cancelRefresh(ex);

// Propagate exception to caller.
throw ex;
}

finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}

对beanFactory设置相关参数prepareBeanFactory

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//设置用于加载bean的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
//设置可以解析bean表达式的表达式解析器 (使用"#{xxx}"配置的属性)
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//添加属性注册器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

//添加ApplicationContextAwareProcessor后置处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

//设置了6个忽略自动注入的接口，为什么要忽略呢？因为上一步添加的ApplicationContextAwareProcessor，会在bean初始化前后调用相应的方法，
//而相应的方法里有如下6个设置对应的接口
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对象，
//如果是ResourceLoader、ApplicationEventPublisher、ApplicationContext类型，则注入当前对象(Spring上下文 - context)
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

//注册ApplicationListenerDetector，应用监听检查器，
//该检测器的主要作用是在bean初始化后，会检查该bean是否是ApplicationListener，
//如果是，那么会验证它是否是单例，如果不是单例，那么删除singletonNames中对应的key，singletonNames中记录了bean的名称及是否是单例
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}

//注册几个特殊的bean
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());
}
}

run方法步骤总结：
1.获取spring应用执行监听器(SpringApplicationRunListeners)
2.利用spring应用执行监听器广播启动事件
3.准备运行的环境(dev，test)，根据环境解析不同的配置文件
3.1 检查webEnvironment属性，如果是web程序，那么创建一个StandardServletEnvironment对象，否则创建StandardEnvironment对象
3.2 准备运行环境配置，根据环境(dev，test)，加载相关配置文件
3.3 利用spring应用执行监听器广播运行环境加载完毕的事件
4.创建spring应用上下文，如果是web程序，创建web应用上下文实例
5.准备spring应用上下文
5.1 利用spring初始化器，对上下文做初始化操作
5.2 利用spring应用执行监听器广播上下文准备好的事件
5.3 向beanFactory注册springApplicationArguments和springBootBanner单例bean
5.4 向上下文注册启动类的bean，也就是调用SpringApplication.run(Application.class, args); 的类
5.5 利用spring应用执行监听器广播上下文加载完毕事件
6.刷新spring应用上下文
6.1 为刷新上下文信息做准备。例如清空缓存，初始化属性信息，验证必要的属性等
6.2 获取应用上下文的beanFactory
6.3 对beanFactory设置相关参数
6.4 为beanFactory添加后置处理器WebApplicationContextServletContextAwareProcessor，并忽略ServletContextAware
6.5 调用beanFactory的后置处理器
6.6 注册bean的后置处理器，这些后置处理器将在bean的创建过程中被调用
6.7 初始化事件广播器(EventMulticaster)，看是否有自定义的事件广播bean(applicationEventMulticaster)，如果有则使用自定义的，否则就用默认的。
6.8 初始化其他特殊的bean，比如创建serverlet容器相关的bean
6.9 向事件广播器EventMulticaster中添加各种事件监听器
6.10 实例化所有单例bean
6.11 结束刷新，利用EventMulticaster广播上下文刷新完成事件
7.执行应用runner(或命令行runner)
8.利用spring应用执行监听器广播启动完成事件