3分钟搞懂 springBoot 初始化过程

最新推荐文章于 2024-05-24 08:30:00 发布

fantasyYan2

最新推荐文章于 2024-05-24 08:30:00 发布

阅读量1.9k

点赞数 1

分类专栏： spring springboot

本文链接：https://blog.csdn.net/q64261750/article/details/107880559

版权

spring 同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

springboot

2 篇文章 0 订阅

订阅专栏

初始化SpringBootServletInitializer

通过new SpringApplication(primarySources)初始化SpringBootServletInitializer 相关源码代码:

@SpringBootApplication
public class MySpringbootTomcatStarter extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(MySpringbootTomcatStarter.class,args);
    }

	//为启动tomcat做准备
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(this.getClass());
    }
}

// SpringApplication.run(MySpringbootTomcatStarter.class,args)调用的方法
 public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
    }
 // 上面代码 run(new Class[]{primarySource}, args); 调用的方法
 public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }

通过new SpringApplication(primarySources))这个构建方法,推断应用类型(一般classpath下有javaxserlvet.serlvet为servlet),并加载classpath下的ApplicationListener信息到一个list中,ApplicationListener采用观察者设计模式,在applicationcontxt加载完毕时执行加载信息.相关源码代码:

public SpringApplication(Class<?>... primarySources) {
    this(null, primarySources);
}

@SuppressWarnings({"unchecked", "rawtypes"})
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    //推断应用类型，后面会根据类型初始化对应的环境。常用的一般都是servlet环境
    this.webApplicationType = deduceWebApplicationType();//2.2.1
    //初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));//2.2.2
    //初始化classpath下所有已配置的 ApplicationListener
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));//2.2.3
    //根据调用栈，推断出 main 方法的类名
    this.mainApplicationClass = deduceMainApplicationClass();
}

上下文

通过上述的run方法调用ConfigurableApplicationContext run(String… args),调用如下源代码:

public ConfigurableApplicationContext run(String... args) {
	ConfigurableApplicationContext context = null;
	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
	this.configureHeadlessProperty();
	SpringApplicationRunListeners listeners = this.getRunListeners(args);
	listeners.starting();

	Collection exceptionReporters;
	try {
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
		this.configureIgnoreBeanInfo(environment);
		
		//打印banner，这里你可以自己涂鸦一下，换成自己项目的logo
		Banner printedBanner = this.printBanner(environment);
		
		//创建应用上下文
		context = this.createApplicationContext();
		exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);

		//预处理上下文
		this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
		
		//刷新上下文
		this.refreshContext(context);
		
		//为空方法,可以自己复写代码进行扩展
		this.afterRefresh(context, applicationArguments);
		
		//启动初始化SpringBootServletInitializer中的ApplicationListener
		listeners.started(context);
		this.callRunners(context, applicationArguments);
	} catch (Throwable var10) {
		
	}

	try {
		listeners.running(context);
		return context;
	} catch (Throwable var9) {
		
	}
}

创建上下文

根据初始化SpringBootServletInitializer中的推断应用类型,创建上下文

protected ConfigurableApplicationContext createApplicationContext() {
	Class<?> contextClass = this.applicationContextClass;
	if (contextClass == null) {
		try {
			switch(this.webApplicationType) {
				case SERVLET:
                    //创建AnnotationConfigServletWebServerApplicationContext
				    contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
					break;
				case REACTIVE:
					contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
					break;
				default:
					contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
			}
		} catch (ClassNotFoundException var3) {
			throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
		}
	}

	return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}

预处理上下文

应用上下文后置处理
调用ApplicationContextInitializer接口实现类对象的initialize方法
发布ApplicationContextInitializedEvent事件
打印启动日志
注册两个单例bean（springApplicationArguments、springBootBanner）
设置是否允许bean定义重写
加载主类
发布ApplicationPreparedEvent事件

private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    // 设置上下文的environment
    context.setEnvironment(environment);
    // 应用上下文后处理
    postProcessApplicationContext(context);
    // 在context refresh之前，对其应用ApplicationContextInitializer
    applyInitializers(context);
    // 上下文准备（目前是空实现，可用于拓展）
    listeners.contextPrepared(context);
    // 打印启动日志和启动应用的Profile
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }

    // Add boot specific singleton beans
    context.getBeanFactory().registerSingleton("springApplicationArguments",
            applicationArguments);                                // 向beanFactory注册单例bean：命令行参数bean
    if (printedBanner != null) {
        // 向beanFactory注册单例bean：banner bean
        context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
    }

    // Load the sources
    Set<Object> sources = getAllSources();                        // 获取全部资源，其实就一个：SpringApplication的primarySources属性
    Assert.notEmpty(sources, "Sources must not be empty");        // 断言资源是否为空
    // 将bean加载到应用上下文中
    load(context, sources.toArray(new Object[0]));
    // 向上下文中添加ApplicationListener，并广播ApplicationPreparedEvent事件
    listeners.contextLoaded(context);
}

刷新上下文

创建webserver和tomcat(webServer用于管理tomcat的启动,一个tomcat实例就是一个Server，一个Server包含多个Service，也就是多个应用程序，每个Service包含多个Connector和一个Container，而一个Container下又包含多个子容器。)
完成bean工厂的初始化
完成对listener的注册
发布应用已经启动事件

//刷新上下文
private void refreshContext(ConfigurableApplicationContext context) {
	this.refresh(context);
	if (this.registerShutdownHook) {
		try {
			context.registerShutdownHook();
		} catch (AccessControlException var3) {
		}
	}
}

//这里直接调用最终父类AbstractApplicationContext.refresh()方法
protected void refresh(ApplicationContext applicationContext) {
	((AbstractApplicationContext)applicationContext).refresh();
}

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
	    // 准备刷新
	    prepareRefresh();
 
	    // 通知子类刷新内部bean工厂
	    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
	    // 准备bean工厂以便在此上下文中使用
	    prepareBeanFactory(beanFactory);
 
	    try {
	    	// 允许上下文子类中对bean工厂进行后处理
	    	postProcessBeanFactory(beanFactory);
 
	    	// 在bean创建之前调用BeanFactoryPostProcessors后置处理方法
	    	invokeBeanFactoryPostProcessors(beanFactory);
 
	    	// 注册BeanPostProcessor
	    	registerBeanPostProcessors(beanFactory);
 
	    	// 注册DelegatingMessageSource
	    	initMessageSource();
 
	    	// 注册multicaster
	    	initApplicationEventMulticaster();
 
	    	// 创建内置的Servlet容器
	    	onRefresh();
 
	    	// 注册Listener
	    	registerListeners();
 
	    	// 完成BeanFactory初始化，初始化剩余单例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();
	    }
    }
}
protected void onRefresh() {
	super.onRefresh();
	try {
		this.createWebServer();
	} catch (Throwable var2) {
		
	}
}

//ServletWebServerApplicationContext.java
//这里是创建webServer，但是还没有启动tomcat，这里是通过ServletWebServerFactory创建，那么接着看下ServletWebServerFactory
private void createWebServer() {
	WebServer webServer = this.webServer;
	ServletContext servletContext = this.getServletContext();
	if (webServer == null && servletContext == null) {
		ServletWebServerFactory factory = this.getWebServerFactory();
		this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
	} else if (servletContext != null) {
		try {
			this.getSelfInitializer().onStartup(servletContext);
		} catch (ServletException var4) {
		
		}
	}

	this.initPropertySources();
}

//接口
public interface ServletWebServerFactory {
    WebServer getWebServer(ServletContextInitializer... initializers);
}

//实现
AbstractServletWebServerFactory
JettyServletWebServerFactory
TomcatServletWebServerFactory
UndertowServletWebServerFactory