SpringBoot_第十章(启动过程)

浅水壁虎

已于 2025-04-18 00:02:19 修改

阅读量660

点赞数 22

分类专栏：框架_SpringBoot 文章标签： spring boot

于 2025-04-18 00:02:08 首次发布

本文链接：https://blog.youkuaiyun.com/huyiju/article/details/147287202

版权

框架_SpringBoot 专栏收录该内容

11 篇文章

订阅专栏

1：SpringBoot是什么

2：Spring Boot的核心功能

3：SpringBoot启动过程（初始化过程）

3.1：运行 SpringApplication.run() 方法

3.2：new SpringBoot确定应用程序类型

3.3：new SpringBoot加载所有的初始化器、监听器

3.4：new SpringBoot加载自定义初始话器和监听器

4：执行真正的run方法

4.1：创建启动器，包含开始时间

4.2：将java.awt.headless设置为true

1：SpringBoot是什么

springboot依赖spring，拥有spring的全部功能，无需繁琐的xml配置，这取决于它自身强大的自动装配功能。内嵌的tomcat和Jetty等web容器，集成的springMVC。使得springboot可以直接运行，不需要额外的容器，提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

2：Spring Boot的核心功能

1、可独立运行的Spring项目：Spring Boot可以以jar包的形式运行。

2、内嵌的Servlet容器：Spring Boot可以选择内嵌Tomcat、Jetty或者Undertow，无须以war包形式部署项目。

3、简化了Maven配置：Spring提供推荐的基础 POM 文件来简化Maven 配置。

4、提供了自动装配Spring：Spring Boot会根据项目依赖管理来自动配置Spring 框架，极大地减少项目要使用的配置。

5、提供生产就绪型功能：提供可以直接在生产环境中使用的功能，如性能指标、应用信息和应用健康检查。

6、无代码生成和xml配置：Spring Boot不生成代码。完全不需要任何xml配置即可实现Spring的所有配置。

3：SpringBoot启动过程（初始化过程）

3.1：运行 SpringApplication.run() 方法

可以肯定的是，所有的标准的springboot的应用程序都是从run方法开始的

/**
 *
 * Spring Boot 3.3.2需要
 * Java 17 以上版本
 * Maven 3.6.3 或更高版本
 *
 * @SpringBootApplication 相当于三个注解
 *
 *      1：@SpringBootConfiguration
 *              @Configuration
 *                  @Component (第一个注解也就是把SpringBoot1Application 注册成bean)
 *
 *      2：@EnableAutoConfiguration(开启自定装配)
 *
 *              (自动装配包，将项目包和子包 org.example.springboot_1_web1 的注解bean扫描进容器 )
 *              1:@AutoConfigurationPackage
 *                      @Import(AutoConfigurationPackages.Registrar.class)
 *
 *
 *              (select选择器，在导入的spring-boot-starter-autoconfig的mate/info
 *              下边的spring.factory里边的各种AutoConfig扫描进容器的beanDifinetionMap,
 *              根据condition条件创建bean)
 *              2:@Import(AutoConfigurationImportSelector.class)
 *
 *      3：@ComponentScan(包扫描)
 *
 */
@SpringBootApplication
@MapperScan(value = "org.example.springboot_1_web2.mapper")
public class SpringBoot1Web2Application {

    public static void main(String[] args) {
        String[] strings={"zhangsan","lisi","wangwu"};
        ConfigurableApplicationContext run = SpringApplication.run(SpringBoot1Web2Application.class, strings);
        String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println("beanName:"+beanDefinitionName);
        }

    }
}

进入spring的run方法就是new了一个SpringApplication对象，对这个对象做一些准备工作，然后运行。

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
		return new SpringApplication(primarySources).run(args);
	}

3.2：new SpringBoot确定应用程序类型

在new application中通过WebApplicationType.deduceFromClasspath判断整个类型是servlet类型

3.3：new SpringBoot加载所有的初始化器、监听器

加载springboot的初始化器，

@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));
        //应用程序类型
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		this.bootstrapRegistryInitializers = new ArrayList<>(
				getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        //设置初始化器 方法一样看明白一个就理解另外一个
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        //设置监听器
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

初始化器和监听器根据源码都是在spring-boot-autoconfigure-3.4.1.jar!/META-INF/spring.factories，还有其他的包的 META-INF/spring.factories

加载之后debug截图查看：

3.4：new SpringBoot加载自定义初始话器和监听器

1：自定义初始化器ApplicationContextInitializer

/**
 * 自定义初始化器在new springboot的加载初始化容器的过程中加载 根据反射加载 在项目启动中运行
 */
public class MyApplicationInit implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("我的ApplicationContext初始化器：");
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println("初始化器:"+beanDefinitionName);
        }
    }
}

2：自定义监听器ApplicationListener

/**
 * 自定义初始化器在new springboot的加载初始化容器的过程中加载 根据反射加载 在项目启动中运行
 */
public class MyApplicationInit implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("我的ApplicationContext初始化器：");
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println("初始化器:"+beanDefinitionName);
        }
    }
}

3：新增配置

4：重启项目测试

4：执行真正的run方法

这里开始进入真正的run方法

4.1：创建启动器，包含开始时间

public ConfigurableApplicationContext run(String... args) {
        //第一步：记录启动时间
		Startup startup = Startup.create();
}

4.2：将java.awt.headless设置为true

这里将java.awt.headless设置为true，表示运行在服务器端，在没有显示器器和鼠标键盘的模式下照样可以工作，模拟输入输出设备功能。

做了这样的操作后,SpringBoot想干什么呢?其实是想设置该应用程序,即使没有检测到显示器,也允许其启动.对于服务器来说,是不需要显示器的,所以要这样设置.

方法主体如下：

private void configureHeadlessProperty() {
		System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
				System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
	}

4.3：准备环境变量（比如配置文件信息）

//加载环境变量

//源码
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
		// Create and configure the environment
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		ConfigurationPropertySources.attach(environment);
		listeners.environmentPrepared(bootstrapContext, environment);
		DefaultPropertiesPropertySource.moveToEnd(environment);
		Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
				"Environment prefix cannot be set via properties.");
		bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
			environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}

源码截图显示：

4.4：打印banner信息

Banner printedBanner = printBanner(environment);

4.5：创建应用程序的上下文

实例化应用程序的上下文，调用 createApplicationContext() 方法，这里就是用反射创建对象

//context = createApplicationContext();

4.6：准备上下文环境

/run方法代码
prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

//进入源码查看
private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
		context.setEnvironment(environment);

        //创建了DefaultListableBeanFactory
        //里边包含了 beanDefinitionMap 三级依赖等信息
		postProcessApplicationContext(context);

        
		addAotGeneratedInitializerIfNecessary(this.initializers);

        //执行初始器，包含自定义的初始化器 在这里执行
		applyInitializers(context);
		listeners.contextPrepared(context);
		bootstrapContext.close(context);
        
        //控制台输出上下文
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		// Add boot specific singleton beans
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		

        //这里将启动参数以单例的模式注册到容中的singletonObjects，是为了以后方便拿来使用，参数的beanName 为 ：springApplicationArguments
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
		if (printedBanner != null) {
			beanFactory.registerSingleton("springBootBanner", printedBanner);
		}
		if (beanFactory instanceof AbstractAutowireCapableBeanFactory autowireCapableBeanFactory) {
			autowireCapableBeanFactory.setAllowCircularReferences(this.allowCircularReferences);
			if (beanFactory instanceof DefaultListableBeanFactory listableBeanFactory) {
				listableBeanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
			}
		}
		if (this.lazyInitialization) {
			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
		}
		if (this.keepAlive) {
			context.addApplicationListener(new KeepAlive());
		}
		context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
		if (!AotDetector.useGeneratedArtifacts()) {
			// Load the sources
			Set<Object> sources = getAllSources();
			Assert.notEmpty(sources, "Sources must not be empty");
			load(context, sources.toArray(new Object[0]));
		}
		listeners.contextLoaded(context);
	}

这里准备的上下文环境是为了下一步刷新做准备的，里面还做了一些额外的事情；

4.7：刷新上下文

刷新上下文已经是spring的范畴了，自动装配和启动 tomcat就是在这个方法里面完成的，还有其他的spring自带的机制在这里就不一一细说了，

@Override
	public void refresh() throws BeansException, IllegalStateException {
		this.startupShutdownLock.lock();
		try {
			this.startupShutdownThread = Thread.currentThread();

			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
                //这里启动了tomcat，里边有个createWebServer方法
                //获取getWebServer 初始化new tomcat init启动tomcat
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
                
                //将beandefination中的类根据反射生成beaen
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (RuntimeException | Error 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 {
				contextRefresh.end();
			}
		}
		finally {
			this.startupShutdownThread = null;
			this.startupShutdownLock.unlock();
		}
	}

4.8：刷新上下文后置处理

afterRefresh 方法是启动后的一些处理，留给用户扩展使用，目前这个方法里面是空的，

afterRefresh(context, applicationArguments);

4.9：启动监听器

自定义的监听器会在这里启动。

try {
			if (context.isRunning()) {
				listeners.ready(context, startup.ready());
			}
		}

之后返回ConfigurableApplicationContext

5：总结

这个就算是spring的run方法