【SpringBoot】一、SpringBoot启动流程源码分析

冷不防 2023-10-09 14:18 62阅读 0赞

上一篇 [【Spring】六、Spring与MyBatis整合核心源码分析][Spring_Spring_MyBatis]

下一篇[【SpringBoot】二、SpringBoot自动配置原理][SpringBoot_SpringBoot]

#### 文章目录 ####

*  SpringBoot启动流程（SpringBoot启动原理）
 *  宏观步骤：（概括为18个小步骤）
 *  SpringBoot启动流程源码分析
 *   *   *   *  1.入口main方法执行；
             *  2.、执行run方法；
             *  3.看一下run(new Class<?>\[\] \{ primarySource \}, args);方法；
             *  4、先看做的第一件事情，new了一个SpringApplication对象
             *  5、然后我们看做的第二件事情，执行new出来的SpringApplication对象的run()方法；
             *  6、接下来我们重点看一下run方法里面的几个重要步骤，首先看看红色标记的创建spring容器上下文context = createApplicationContext();这段代码主要是根据项目类型创建Spring上下文，并且会注入几个核心组件类；
             *  7、然后再看一下run方法里面另一个比较重要的步骤，红色标记的创建和刷新spring容器refreshContext()方法，refreshContext(context) 这个方法，该方法启动spring的代码加载了bean，还启动了内嵌的web容器；
             *  8.再看onRefresh()方法
 *  流程图

## SpringBoot启动流程（SpringBoot启动原理） ##

启动流程主要分为三个部分：

*  第一部分进行SpringApplication的初始化模块，配置一些基本的环境变量、资源、构造器、监听器；（了解一下）
 *  第二部分实现了应用具体的启动方案，包括启动流程的监听模块、加载配置环境模块、及核心的创建Spring上下文环境模块；（掌握）
 *  第三部分是自动化配置模块，该模块是SpringBoot自动配置的核心；（掌握）

## 宏观步骤：（概括为18个小步骤） ##

*  1、创建并启动计时监控类StopWatch
 *  2、初始化应用上下文和异常报告集合（ConfigurableApplicationContext和Collection）
 *  3、设置系统属性 configureHeadlessProperty()
 *  4、创建Spring运行的监听器并启动
 *  5、初始化默认应用参数类
 *  6、准备Spring环境
 *  7、创建beanner打印类
 *  8、创建应用Spring上下文（也就是spring容器）
 *  9、准备异常报告器
 *  10、准备应用上下文（也就是spring容器）
 *  11、刷新上下文（也就是spring容器）
 *  12、应用上下文刷新后置处理（也就是spring容器）
 *  13、停止计时监控类
 *  14、输出日志信息
 *  15、发布应用上下文启动完成事件
 *  16、执行所有Runner运行器（如果实现CommandLineRunner接口）
 *  17、发布应用上下文就绪事件
 *  18、完成返回容器对象

## SpringBoot启动流程源码分析 ##

##### 1.入口main方法执行； #####

public static void main(String[] args) {
        
    	SpringApplication.run(Application.class, args);
    }

##### 2.、执行run方法； #####

public static ConfigurableApplicationContext run(Class<?> primarySource,
    			String... args) {
        
            //调用run() 方法
    		return run(new Class<?>[] {
         primarySource }, args);
    }

##### 3.看一下run(new Class<?>\[\] \{ primarySource \}, args);方法； #####

public static ConfigurableApplicationContext run(Class<?>[] primarySources,
    			String[] args) {
        
    		return new SpringApplication(primarySources).run(args);
    }
    //这个run方法主要做两件事情
    //1、new了一个SpringApplication 这么一个对象；
    (1)把main方法这个类赋给一个成员变量；
    (2)判断是java项目还是web项目；
    (3)设置了一个初始化器和事件发送的监听器；
    //2、然后执行SpringApplication对象的run()方法；

##### 4、先看做的第一件事情，new了一个SpringApplication对象 #####

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        
    		this.resourceLoader = resourceLoader;
    		Assert.notNull(primarySources, "PrimarySources must not be null");
    		//1、先把主类保存起来
    		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    		//2、判断运行项目的类型
    		this.webApplicationType = WebApplicationType.deduceFromClasspath();
    		//3、扫描当前路径下META-INF/spring.factories文件的，加载ApplicationContextInitializer接口实例
    		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    		//4、扫描当前路径下META-INF/spring.factories文件的，加载ApplicationListener接口实例
    		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
            //判断main方法的类
    		this.mainApplicationClass = deduceMainApplicationClass();
    	}
    这里面用到了一种类似于Java SPI机制的方式扫描META-INF/spring.factories这个文件，并且加载?ApplicationContextInitializer、ApplicationListener 接口实例；
    （1）ApplicationContextInitializer 这个类当springboot上下文Context初始化完成后会调用；
    （2）ApplicationListener 当springboot启动时事件change后都会触发
    我们可以自定义实现ApplicationContextInitializer、ApplicationListener 接口，
    然后运行时会被触发执行；

##### 5、然后我们看做的第二件事情，执行new出来的SpringApplication对象的run()方法； #####

public ConfigurableApplicationContext run(String... args) {
        
        
    	
    	StopWatch stopWatch = new StopWatch();
    	stopWatch.start();
    	ConfigurableApplicationContext context = null;
    	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    	
    	
    	configureHeadlessProperty();
    
    	
    	SpringApplicationRunListeners listeners = getRunListeners(args);
    	listeners.starting();
    
    	try {
        
    		
    		ApplicationArguments applicationArguments = new DefaultApplicationArguments(
    				args);
    
    		
    		ConfigurableEnvironment environment = prepareEnvironment(listeners,
    				applicationArguments);
    
    		
    		configureIgnoreBeanInfo(environment);
    
    		
    		Banner printedBanner = printBanner(environment);
    
    		
    		context = createApplicationContext();
    
    		
    		exceptionReporters = getSpringFactoriesInstances(
    				SpringBootExceptionReporter.class,
    				new Class[] {
         ConfigurableApplicationContext.class }, context);
    
    		
    		prepareContext(context, environment, listeners, applicationArguments,
    				printedBanner);
    
    		
    		//这个refreshContext()不仅创建bean，还启动了内嵌的web容器，非常重要
    		refreshContext(context);
    
    		
    		afterRefresh(context, applicationArguments);
    		stopWatch.stop();
    		if (this.logStartupInfo) {
        
    			new StartupInfoLogger(this.mainApplicationClass)
    					.logStarted(getApplicationLog(), stopWatch);
    		}
    
    		
    		listeners.started(context);
    
    		
    		callRunners(context, applicationArguments);
    	}
    	catch (Throwable ex) {
        
    		handleRunFailure(context, listeners, exceptionReporters, ex);
    		throw new IllegalStateException(ex);
    	}
    	listeners.running(context);
    	return context;
    }

##### 6、接下来我们重点看一下run方法里面的几个重要步骤，首先看看红色标记的创建spring容器上下文context = createApplicationContext();这段代码主要是根据项目类型创建Spring上下文，并且会注入几个核心组件类； #####

protected ConfigurableApplicationContext createApplicationContext() {
        
    	Class<?> contextClass = this.applicationContextClass;
    	if (contextClass == null) {
        
    		try {
        
    			switch (this.webApplicationType) {
        
    			case SERVLET:
    				contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
    				break;
    			case REACTIVE:
    				contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
    				break;
    			default:
    				contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
    			}
    		}
    		catch (ClassNotFoundException ex) {
        
    			throw new IllegalStateException(
    					"Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
    		}
    	}
    	return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
    }
    
    
    public AnnotationConfigServletWebServerApplicationContext() {
        
           //1：会去注入一些spring核心组件
    	   this.reader = new AnnotatedBeanDefinitionReader(this);
    	   this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
    
    Web类型项目创建上下文对象AnnotationConfigServletWebServerApplicationContext，这里会把?ConfigurationClassPostProcessor 、
    AutowiredAnnotationBeanPostProcessor 等一些核心组件加入到Spring容器，这其实已经是spring ioc容器的源码，如果了解spring ioc源码，那么对springboot源码的阅读会有很大的帮助；

##### 7、然后再看一下run方法里面另一个比较重要的步骤，红色标记的创建和刷新spring容器refreshContext()方法，refreshContext(context) 这个方法，该方法启动spring的代码加载了bean，还启动了内嵌的web容器； #####

private void refreshContext(ConfigurableApplicationContext context) {
        
    	//刷新和创建spring容器
    	refresh(context);
    	if (this.registerShutdownHook) {
        
    		try {
        
    			context.registerShutdownHook();
    		}
    		catch (AccessControlException ex) {
        
    			// Not allowed in some environments.
    		}
    	}
    }
    
    protected void refresh(ApplicationContext applicationContext) {
        
    	Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
    	//进入refresh()方法
    	((AbstractApplicationContext) applicationContext).refresh();
    }

##### 8.再看onRefresh()方法 #####

接下来进入到Spring ioc容器刷新和创建的12个步骤的源码中，AbstractApplicationContext - >refresh()方法，在这12个步骤中，这里主要看一下onRefresh() 这个方法，但是发现这个方法里面什么都没有，显然是一个钩子方法，它会钩到它子类重写onRefresh()方法，所以去看子类里面的onRefresh()方法；  
由于我们这里是一个Web项目，所以就可以看到 ServletWebServerApplicationContext 这个类，这个类下面的 onRefresh() 方法：

protected void onRefresh() {
        
    	super.onRefresh();
    	try {
        
    		//看到了内嵌web容器的影子
    		createWebServer();
    	}
    	catch (Throwable ex) {
        
    		throw new ApplicationContextException("Unable to start web server", ex);
    	}
    }
    
    private void createWebServer() {
        
    	WebServer webServer = this.webServer;
    	ServletContext servletContext = getServletContext();
    	if (webServer == null && servletContext == null) {
        
    		//1、获取webServerFactory
    		ServletWebServerFactory factory = getWebServerFactory();
    		this.webServer = factory.getWebServer(getSelfInitializer());
    	}
    	else if (servletContext != null) {
        
    		try {
        
    			getSelfInitializer().onStartup(servletContext);
    		}
    		catch (ServletException ex) {
        
    			throw new ApplicationContextException("Cannot initialize servlet context",
    					ex);
    		}
    	}
    	initPropertySources();
    }
    
    //继续看下getWebServletFactory() 这个方法，这里面选择出哪种类型的web容器
    protected ServletWebServerFactory getWebServerFactory() {
        
    	// Use bean names so that we don't consider the hierarchy
    	String[] beanNames = getBeanFactory()
    			.getBeanNamesForType(ServletWebServerFactory.class);
    	if (beanNames.length == 0) {
        
    		throw new ApplicationContextException(
    				"Unable to start ServletWebServerApplicationContext due to missing "
    						+ "ServletWebServerFactory bean.");
    	}
    	if (beanNames.length > 1) {
        
    		throw new ApplicationContextException(
    				"Unable to start ServletWebServerApplicationContext due to multiple "
    						+ "ServletWebServerFactory beans : "
    						+ StringUtils.arrayToCommaDelimitedString(beanNames));
    	}
    	return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
    }
    
    // 再回头去看factory.getWebServer(getSelfInitializer()) ，转到定义就会看到很熟悉的名字tomcat
    public WebServer getWebServer(ServletContextInitializer... initializers) {
        
    	//看到了我们熟悉的tomcat
    	Tomcat tomcat = new Tomcat();
    	File baseDir = (this.baseDirectory != null ? this.baseDirectory
    			: createTempDir("tomcat"));
    	tomcat.setBaseDir(baseDir.getAbsolutePath());
    	Connector connector = new Connector(this.protocol);
    	tomcat.getService().addConnector(connector);
    	customizeConnector(connector);
    	tomcat.setConnector(connector);
    	tomcat.getHost().setAutoDeploy(false);
    	configureEngine(tomcat.getEngine());
    	for (Connector additionalConnector : this.additionalTomcatConnectors) {
        
    		tomcat.getService().addConnector(additionalConnector);
    	}
    	prepareContext(tomcat.getHost(), initializers);
    	return getTomcatWebServer(tomcat);
    }
    内置的Servlet容器就是在onRefresh() 方法里面启动的，至此一个Servlet容器就启动OK了；

## 流程图 ##

![在这里插入图片描述][6939cff3bd7f4667b7f4122728d807a4.png_pic_center]

[Spring_Spring_MyBatis]: https://blog.csdn.net/weixin_43333483/article/details/125134469?spm=1001.2014.3001.5502
[SpringBoot_SpringBoot]: https://blog.csdn.net/weixin_43333483/article/details/125136812?spm=1001.2014.3001.5502
[6939cff3bd7f4667b7f4122728d807a4.png_pic_center]: https://img-blog.csdnimg.cn/6939cff3bd7f4667b7f4122728d807a4.png#pic_center