浅谈SpringBoot启动那些事儿

最新推荐文章于 2022-11-25 22:17:42 发布
最新推荐文章于 2022-11-25 22:17:42 发布
阅读量223 收藏
点赞数
分类专栏： 容器化 云原生 博文 文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rothchil/article/details/126571731
版权
博文 同时被 3 个专栏收录
34 篇文章 1 订阅
订阅专栏
容器化
20 篇文章 3 订阅
订阅专栏
云原生
11 篇文章 0 订阅
订阅专栏

title: 浅谈SpringBoot启动那些事儿
date: 2020-01-02 19:06:00
categories: springboot
description: 浅谈SpringBoot启动那些事儿

1. 目录

springboot

本文以SpringBoot2.2.2.RELEASE版本为基础做的分析。其他版本请自行参考官方文档。

2. 构建SpringBoot源码环境

本章节主要讲述通过下载Springboot源码构建springboot开发环境，并利用此开发环境完成单用例的开发。

2.1. 下载源码

从Gihub仓库中Clone或者下载压缩包文件，Github地址为https://github.com/spring-projects/spring-boot，因为当前最新的版本为2.2.2.RELEASE，所以我在release中挑选压缩文件下载，下载后的文件名为spring-boot-2.2.2.RELEASE.zip

Springboot源码仓库截图

按照tag，找https://github.com/spring-projects/spring-boot/releases/tag/v2.2.2.RELEASE。

下载的位置

下载后，解压文件到自定义目录，再执行：

mvn clean install -DskipTests -Pfast

耐心等待所有依赖包下载完成，再将项目导入IDEA，即可完成源码环境构建。

导入IDEA目录结构

2.2. 核心父类模块

2.2.1. spring-boot-starters

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>${revision}</version>
    <relativePath>../spring-boot-dependencies</relativePath>
</parent>
<artifactId>spring-boot-parent</artifactId>
<packaging>pom</packaging>
<name>Spring Boot Parent</name>
<description>Spring Boot Parent</description>

这个模块打包POM，它也有上级spring-boot-dependencies，我看2.2.2这个版本并没有定义starter
而是用另一个模块spring-boot-starters来定义。详细见下图：

starter定义

2.2.2. spring-boot-dependencies

同样做了很多依赖包的定义，解决了我们开发过程中自己选择依赖包版本容易冲突的问题。

2.3. 新建样例

在spring-boot-project模块下新建Module，命名为spring-boot-example，为了方便，一切从简，直接构建一个Application、Controller和yml文件。

  • pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-parent</artifactId>
		<version>${revision}</version>
		<relativePath>../spring-boot-parent</relativePath>
	</parent>
	<modelVersion>4.0.0</modelVersion>

	<artifactId>spring-boot-example</artifactId>
	<name>spring boot example</name>
	<packaging>jar</packaging>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
	</properties>

	<dependencies>
		<!-- Compile -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>

	<build>
		<finalName>spring-boot-example</finalName>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<executable>true</executable> <!-- Add -->
				</configuration>
				<executions>
					<execution>
						<goals>
							<goal>repackage</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<configuration>
					<useSystemClassLoader>false</useSystemClassLoader>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>
  • 代码

package xyz.wongs.weathertop;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ExamApplication {

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



package xyz.wongs.weathertop;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping(value = "/index", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
public class IndexController {

	@GetMapping(value = "/")
	public List index() {
		List list = new ArrayList();
		list.add("这是测试");
		return list;
	}
}
  • yml文件
server:
  port: 9002

spring:
  application:
    name: exam-web

启动ExamApplication，浏览器打开地址，http://localhost:9002/index/，即可看到效果。

演示效果

2.4. 小结

以上我们利用SpringBoot源码构建一个完整Web应用，让大家熟悉下Springboot的目录结构，方便后一章节我们分析跟踪源码。

3. 源码分析

3.1. 主函数入口

package xyz.wongs.weathertop;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ExamApplication {

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

3.2. Maven依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

web的pom依赖，打开源码，它已经为我们继承好tomcat容器和spring-web、mvc的依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-json</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.apache.tomcat.embed</groupId>
                <artifactId>tomcat-embed-el</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
    </dependency>
</dependencies>

3.3. 依赖分析

在当前模块执行mvn dependency:tree，分析下依赖包，我们可以看到，这一层为我们融合很多，试想一下，如果这些都让我们自己挨个去做，不可想象。

$ mvn dependency:tree
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building spring boot example 2.2.2.RELEASE
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-dependency-plugin:3.1.1:tree (default-cli) @ spring-boot-example ---
[INFO] org.springframework.boot:spring-boot-example:jar:2.2.2.RELEASE
[INFO] +- org.springframework.boot:spring-boot-starter-web:jar:2.2.2.RELEASE:compile
[INFO] |  +- org.springframework.boot:spring-boot-starter:jar:2.2.2.RELEASE:compile
[INFO] |  |  +- org.springframework.boot:spring-boot:jar:2.2.2.RELEASE:compile
[INFO] |  |  +- org.springframework.boot:spring-boot-autoconfigure:jar:2.2.2.RELEASE:compile
[INFO] |  |  +- org.springframework.boot:spring-boot-starter-logging:jar:2.2.2.RELEASE:compile
[INFO] |  |  |  +- ch.qos.logback:logback-classic:jar:1.2.3:compile
[INFO] |  |  |  |  +- ch.qos.logback:logback-core:jar:1.2.3:compile
[INFO] |  |  |  |  \- org.slf4j:slf4j-api:jar:1.7.29:compile
[INFO] |  |  |  +- org.apache.logging.log4j:log4j-to-slf4j:jar:2.12.1:compile
[INFO] |  |  |  |  \- org.apache.logging.log4j:log4j-api:jar:2.12.1:compile
[INFO] |  |  |  \- org.slf4j:jul-to-slf4j:jar:1.7.29:compile
[INFO] |  |  +- jakarta.annotation:jakarta.annotation-api:jar:1.3.5:compile
[INFO] |  |  \- org.yaml:snakeyaml:jar:1.25:runtime
[INFO] |  +- org.springframework.boot:spring-boot-starter-json:jar:2.2.2.RELEASE:compile
[INFO] |  |  +- com.fasterxml.jackson.core:jackson-databind:jar:2.10.1:compile
[INFO] |  |  |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.10.1:compile
[INFO] |  |  |  \- com.fasterxml.jackson.core:jackson-core:jar:2.10.1:compile
[INFO] |  |  +- com.fasterxml.jackson.datatype:jackson-datatype-jdk8:jar:2.10.1:compile
[INFO] |  |  +- com.fasterxml.jackson.datatype:jackson-datatype-jsr310:jar:2.10.1:compile
[INFO] |  |  \- com.fasterxml.jackson.module:jackson-module-parameter-names:jar:2.10.1:compile
[INFO] |  +- org.springframework.boot:spring-boot-starter-tomcat:jar:2.2.2.RELEASE:compile
[INFO] |  |  +- org.apache.tomcat.embed:tomcat-embed-core:jar:9.0.29:compile
[INFO] |  |  +- org.apache.tomcat.embed:tomcat-embed-el:jar:9.0.29:compile
[INFO] |  |  \- org.apache.tomcat.embed:tomcat-embed-websocket:jar:9.0.29:compile
[INFO] |  +- org.springframework.boot:spring-boot-starter-validation:jar:2.2.2.RELEASE:compile
[INFO] |  |  +- jakarta.validation:jakarta.validation-api:jar:2.0.1:compile
[INFO] |  |  \- org.hibernate.validator:hibernate-validator:jar:6.0.18.Final:compile
[INFO] |  |     +- org.jboss.logging:jboss-logging:jar:3.4.1.Final:compile
[INFO] |  |     \- com.fasterxml:classmate:jar:1.5.1:compile
[INFO] |  +- org.springframework:spring-web:jar:5.2.2.RELEASE:compile
[INFO] |  |  \- org.springframework:spring-beans:jar:5.2.2.RELEASE:compile
[INFO] |  \- org.springframework:spring-webmvc:jar:5.2.2.RELEASE:compile
[INFO] |     +- org.springframework:spring-aop:jar:5.2.2.RELEASE:compile
[INFO] |     +- org.springframework:spring-context:jar:5.2.2.RELEASE:compile
[INFO] |     \- org.springframework:spring-expression:jar:5.2.2.RELEASE:compile
[INFO] +- org.junit.jupiter:junit-jupiter:jar:5.5.2:test
[INFO] |  +- org.junit.jupiter:junit-jupiter-api:jar:5.5.2:test
[INFO] |  |  +- org.opentest4j:opentest4j:jar:1.2.0:test
[INFO] |  |  \- org.junit.platform:junit-platform-commons:jar:1.5.2:test
[INFO] |  +- org.junit.jupiter:junit-jupiter-params:jar:5.5.2:test
[INFO] |  \- org.junit.jupiter:junit-jupiter-engine:jar:5.5.2:test
[INFO] +- org.junit.vintage:junit-vintage-engine:jar:5.5.2:test
[INFO] |  +- org.apiguardian:apiguardian-api:jar:1.1.0:test
[INFO] |  +- org.junit.platform:junit-platform-engine:jar:1.5.2:test
[INFO] |  \- junit:junit:jar:4.12:test
[INFO] +- org.mockito:mockito-junit-jupiter:jar:3.1.0:test
[INFO] +- org.assertj:assertj-core:jar:3.13.2:test
[INFO] +- org.mockito:mockito-core:jar:3.1.0:test
[INFO] |  +- net.bytebuddy:byte-buddy:jar:1.10.4:test
[INFO] |  +- net.bytebuddy:byte-buddy-agent:jar:1.10.4:test
[INFO] |  \- org.objenesis:objenesis:jar:2.6:test
[INFO] +- org.hamcrest:hamcrest:jar:2.1:test
[INFO] \- org.springframework:spring-test:jar:5.2.2.RELEASE:test
[INFO]    \- org.springframework:spring-core:jar:5.2.2.RELEASE:compile
[INFO]       \- org.springframework:spring-jcl:jar:5.2.2.RELEASE:compile

4. 重点知识

4.1. 注解

SpringBoot项目唯一入口就是上面的Application类，这个类有一个annotation注解SpringBootApplication。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

上面的注解有几个要重点说下

  • 核心SpringBootConfiguration：源于Spring时代中的Configuration，都是将当前类标记为配置类，并将当前类以@Bean注解方法注入到Spring容器。默认允许在配置类中进行bean间引用以及对该配置的@Bean方法的外部调用。当proxyBeanMethods为false时候，等同于它删除@Configuration构造型
  • 核心EnableAutoConfiguration：启用自动配置，帮助所有符合条件的Configuration都加载容器中。它的核心就是借助AutoConfigurationPackage存储导入的基本包
    ，引入了AutoConfigurationImportSelector来实现Configuration列表的导出。

EnableAutoConfiguration类图

注：AutoConfigurationImportSelector.selectImports的实现方式上，在2.1和2.2之间有明显区别，这点大家看的过程中需要关注下。

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
            .loadMetadata(this.beanClassLoader);
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
            annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
        AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    configurations = removeDuplicates(configurations);
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
    configurations = filter(configurations, autoConfigurationMetadata);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

/**
*核心就是用SpringFactoriesLoader 类的 loadFactoryNames()方法，加载ClassPath路径下META-INF/spring.factories，也就是“org.springframework.boot.autoconfigure.EnableAutoConfiguration=对应所有的导出类”
*
**/
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
            getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
            + "are using a custom packaging, make sure that file is correct.");
    return configurations;
}

也就是说EnableAutoConfiguration会从classpath路径下加载所有META-INF/spring.factories，将spring.factories文件中的EnableAutoConfiguration对应的类，通过反射机制实例化标注为@Configuration的容器类，然后即可完成依赖注入。

  • Target：用于描述类、接口(包括注解类型) 或enum声明，可选值有：1、FIELD-用于描述域；2、LOCAL_VARIABLE-用于描述局部变量；3、METHOD-用于描述方法；4、PACKAGE-用于描述包；5、PARAMETER-用于描述参数

  • Retention：用于描述生命周期，可选值有：1、SOURCE-只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃；2、CLASS-被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期；3、RUNTIME-注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在

  • Documented：javadoc记录，这里略过

  • Inherited：具备可被继承的属性，即子类也有同样的注解

  • ComponentScan： 接触过传统spring的XML文件，我们应该熟悉标签context:component-scan，即将特定的Bean批量注册到Spring容器中。常用的Bean包括：@Entity、@Service、@Controller、@Repository、@Component。它默认扫描SpringApplication的run方法里的Booter.class所在的包路径下文件，所以实际运用中把该启动类放到包的根路径。

4.2. 构造函数部分

main函数，main中的SpringApplication.run启动整个web应用，打开run对应类与方法，差不多入口都是一些静态方法。

/**
    * Static helper that can be used to run a {@link SpringApplication} from the
    * specified source using default settings.
    * @param primarySource the primary source to load
    * @param args the application arguments (usually passed from a Java main method)
    * @return the running {@link ApplicationContext}
    */
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    return run(new Class<?>[] { primarySource }, args);
}

/**
    * Static helper that can be used to run a {@link SpringApplication} from the
    * specified sources using default settings and user supplied arguments.
    * @param primarySources the primary sources to load
    * @param args the application arguments (usually passed from a Java main method)
    * @return the running {@link ApplicationContext}
    */
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    return new SpringApplication(primarySources).run(args);
}

上面的**ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args)**方法中利用构造函数初始化SpringApplication应用，并执行run。这就是我们要分析的入口。

4.2.1. 构造方法

SpringApplication的核心构造函数，主要做了两件事来完成实例化操作：初始化上下文ApplicationContextInitializer以及ApplicationListener监听器。


public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

    //判断是否是web程序(javax.servlet.Servlet和
    //org.springframework.web.context.ConfigurableWebApplicationContext是否存在)
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = deduceMainApplicationClass();
}
  • 以下就是ApplicationContextInitializer以及ApplicationListener初始化操作的核心部分，乍一看ClassLoader就大概清楚这是一个JDK原生类加载器。
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

需要加载的Class路径写在META-INF/spring.factories中，我们打开org.springframework.boot:spring-boot和org.springframework.boo:spring-boot-autocofigure两个jar包，看到键值对，这里我们只看ApplicationContextInitializer和ApplicationListener部分（“\”这是换行符），获取到实现类全名后交由SpringFactoriesLoader加载。

spring.factories截图

4.2.2. spring.factories机制

在上一节，我们看到spring.factories，这种扩展机制实际上是仿照Java中的SPI（Service Provider Interface）扩展机制来实现的，它就是在META-INF/spring.factories，获取指定接口的配置的功能。而ApplicationListener就是在spring-core包中，它有两个核心方法：

public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader);
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader);
  • loadFactories: 通过类加载器加载指定的类并实例化
  • loadFactoryNames: 由类加载器根据自定义标准类获取其实现类的实例

这样Spring会遍历整个ClassLoader中所有jar包下的spring.factories文件，这样其实也为了方便开发人员自定义自己配置中spring.factories文件，这样做既不会影响到其它地方的配置，也不会被别人的配置覆盖，这也是官方推荐的做法。

4.3. 核心run方法简介

初始化上下文和监听器之后，就会进入run方法，它负责Spring的启动流程。

/**
    * Run the Spring application, creating and refreshing a new
    * {@link ApplicationContext}.
    * @param args the application arguments (usually passed from a Java main method)
    * @return a running {@link ApplicationContext}
    */
public ConfigurableApplicationContext run(String... args) {
    //1、创建计时器
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    //2、设置headless模式
    configureHeadlessProperty();
    //3、获取META-INF/spring.factories，这里主要是SpringApplicationRunListener监听
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    try {
        //4、将命令行输入的参数包装为ApplicationArguments
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        //5、准备environment
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        configureIgnoreBeanInfo(environment);
        //6、打印Banner，也就是我们看到的Springboot的Logo，如果有自定义，则覆盖模式
        Banner printedBanner = printBanner(environment);

        //7、创建上下文ApplicationContext
        context = createApplicationContext();
        //8、从META-INF/spring.factories 获取SpringBootExceptionReporter
        exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        //9、准备上下文ApplicationContext
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        //10、刷新上下文
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
        //11、发布started事件
        listeners.started(context);
        //12、执行所有Runners
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        //13、发布running事件
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

4.3.1. 创建计时器

org.springframework.util包下面一个工具类，主要用于对程序部分的模块进行计时(ms级别)，一般用于同步单线程。
在springboot中创建匿名定时器，再开启计时。
它的好处也有无非，大家感兴趣的时候可以参看另外一篇文章作者：一个不二，标题：Spring计时器StopWatch使用

4.3.2. 设置headless模式

java.awt.headless是系统的一种配置模式。在该模式下，系统缺少显示设备、键盘或鼠标。尤其在面向服务器（如提供Web服务）往往可能缺少前述设备，但又需要使用他们提供的功能，生成相应的模拟数据，以提供给客户端（如浏览器所在的配有相关的、键盘和的主机）。

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

4.3.3. 获取SpringApplicationRunListener监听列表

4.4. ConfigurableApplicationContext部分

ConfigurableApplicationContext层次图

这是一个接口，对应在spring-context包中，它囊括ApplicationContext需要实现的所有接口，查看源码可知它继承ApplicationContext, Lifecycle, Closeable，封装上下文的配置和生命周期管理，在启动和关闭容器过程中执行此操作。

ConfigurableApplicationContext源码

王老邪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springboot源码解析（一）
qq_34548229的博客
01-03 517
springboot源码解析（一） 1、springboot的入口程序 @SpringBootApplication public class StartupApplication { public static void main(String[] args) { SpringApplication.run(StartupApplication.class, args)...
浅谈SpringBoot启动那些事儿.pdf
07-27
<name>springboot-example <packaging>jar <project.build.sourceEncoding>UTF-8 <maven.compiler.source>1.8 <maven.compiler.target>1.8 <!-- Compile --> <groupId>org.springframework.boot ...
springboot启动过程 01
weixin_48146191的博客
11-25 95
springboot源码分析
记一次Maven无法自动下载依赖的错误
qq_41345281的博客
08-07 1806
今天在导入一个项目是发现pom文件中大部分依赖都是没有找到的错误，reimport几次依旧没有用，查看仓库目录发现没有对应的文件夹，所以就是Maven根本就没有执行下载的操作，首先检查maven配置发现没有错误后控制台执行了一下命令 mvn install 发现了问题 [INFO] Scanning for projects... [ERROR] [ERROR] Some problems were encountered while processing the POMs: [FATAL] 'parent
springboot2.2.2.RELEASE 集成Activiti最佳实践
叶巨岩的博客
12-10 2230
1.新建springboot项目，项目结构如下，注意在resources文件夹下新建一个processes文件夹，到时候需要放置流程文件在里边 1.先在pom中引入相关依赖 <!--工作流activity--> <dependency> <groupId>org.activiti</groupId>...
SpringBoot 2.2.2 源码(二)：启动流程二
屑狐狸
01-06 221
上篇文章源码进行到如下位置 命令行参数解析 跟进DefaultApplicationArguments，不断追踪，会发现它是用来解析命令行参数的 最终parse方法会返回命令行参数commandLineArgs 环境配置 prepareEnvironment 进入prepareEnvironment方法继续追溯到getOrCreateEnvironment方法 可以看到这里根据webA...
浅谈消息队列
Yang_life的博客
07-05 319
各种消息队列选型以及应用介绍
浅谈LogBack
B君的军火库
09-30 240
大嘎好，好久没有写博客了，最近996感觉身体被掏空，准备在国庆大假之际更一波。 说道日志，其实以前我是觉得地位和System.out.print差不多，基本上属于日志小白。后面慢慢才发现，哇，原来有日志，追根溯源起来这么方便啊！而且日志基本属于无脑操作，反正就那些配置，知道就是会，不知道就是不会。今天特地来梳理一下SpringBoot的默认Log框架LogBack。 文章目录一、LogBack和L...
Java中关于内存泄漏的那些事儿
hello world！
09-03 269
点击上方[java大数据修炼之道]→右上角[...]→[设为星标⭐] 来自：移动开发 - CSDN博客频道 作者：Walter_Mr 链接：http://blog.csdn.net/wtt945482445/article/details/52483944 Android 内存泄漏总结 ...
浅谈springboot的三种启动方式
08-25
浅谈Spring Boot的三种启动方式 Spring Boot是一种流行的Java框架，提供了简洁的配置和自动装配机制，能够快速构建现代化的基于Spring的应用程序。启动Spring Boot项目有多种方式，本文将详细介绍其中的三种启动...
浅谈springboot自动配置原理
08-25
浅谈SpringBoot自动配置原理 SpringBoot自动配置原理是SpringBoot框架的核心机制之一，它使得开发者可以更方便、更快速地构建应用程序。自动配置原理的核心是通过@EnableAutoConfiguration注解开启自动配置功能，...
浅谈springboot 属性定义
08-29
浅谈SpringBoot属性定义 春Boot框架中，属性定义是非常重要的一部分，它允许开发者在应用程序中定义和使用自定义的属性，从而提高应用程序的灵活性和可维护性。本文将详细介绍SpringBoot属性定义的相关知识点，包括...
浅谈springBoot注解大全
08-27
CommandLineRunner 注解用于在程序启动后执行一些基础任务。 十三、@Component 注解 @Component 注解用于标注组件类，通常用于自动发现和装配一些 Bean。 Spring Boot 的注解大全为开发者提供了许多便捷的方式来...
Anaconda安装使用以及Pycharm教程
孤山之王
09-03 7740
Anaconda环境基本使用以及与Pycharm集成
Nginx禁止通过IP访问，允许域名访问
孤山之王
07-14 6328
Nginx开启域名访问模式，屏蔽通过IP访问
CentOS环境下安装Nacos
孤山之王
08-30 6159
Centos安装Nacos完成入门的学习和开发任务
Java生成SSL证书
孤山之王
08-27 5221
JAVA生成SSL证书，可以在HTTPS中使用
Docker-03：Docker管理工具Portainer
孤山之王
08-12 2259
PortaiDocker的轻量化的管理工具，跨平台和开源管理UI
浅谈springboot
最新发布
04-29
Spring Boot是一种基于Spring框架的快速开发应用程序的工具，它可以极大地简化Spring应用程序的配置和部署过程。Spring Boot利用“约定优于配置”的原则，来减少开发人员的工作量，使开发人员可以更加专注于业务逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王老邪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值