在SpringBoot的Web项目中，默认采用的是内置Tomcat，当然也可以配置支持内置的jetty，内置有什么好处呢？
1. 方便微服务部署。
2. 方便项目启动，不需要下载Tomcat或者Jetty
针对目前的容器优化，目前来说没有太多地方，需要考虑如下几个点
- 线程数
- 超时时间
- jvm优化
针对上述的优化点来说，首先线程数是一个重点，初始线程数和最大线程数，初始线程数保障启动的时候，如果有大量用户访问，能够很稳定的接受请求，
而最大线程数量用来保证系统的稳定性，而超时时间用来保障连接数不容易被压垮，如果大批量的请求过来，延迟比较高，不容易把线程打满。这种情况在生产中是比较常见的
一旦网络不稳定，宁愿丢包也不愿意把机器压垮。
jvm优化一般来说没有太多场景，无非就是加大初始的堆，和最大限制堆,当然也不是无限增大，根据的情况进快速开始
在spring boot配置文件中application.yml，添加以下配置
| 1 2 3 4 5 |
server:
tomcat:
min-spare-threads: 20
max-threads: 100
connection-timeout: 5000
|
这块对tomcat进行了一个优化配置，最大线程数是100，初始化线程是20,超时时间是5000ms
Jvm优化
这块主要不是谈如何优化，jvm优化是一个需要场景化的，没有什么太多特定参数，一般来说在server端运行都会指定如下参数
初始内存和最大内存基本会设置成一样的，具体大小根据场景设置，-server是一个必须要用的参数，
至于收集器这些使用默认的就可以了，除非有特定需求。
1.使用-server模式
设置JVM使用server模式。64位JDK默认启动该模式
java -server -jar springboot-1.0.jar
2.指定堆参数
这个根据服务器的内存大小，来设置堆参数。
-Xms :设置Java堆栈的初始化大小
-Xmx :设置最大的java堆大小
| 1 |
java -server -Xms512m -Xmx768m -jar springboot-1.0.jar
|
设置初始化堆内存为512MB，最大为768MB。
3.远程Debug
在服务器上将启动参数修改为：
java -Djavax.net.debug=ssl -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8888 -jar springboot-1.0.jar
这个时候服务端远程Debug模式开启，端口号为8888。
在IDEA中，点击Edit Configuration按钮。
出现弹窗，点击+按钮，找到Remote选项。
在【1】中填入Remote项目名称，在【2】中填IP地址和端口号，在【3】选择远程调试的项目module，配置完成后点击OK即可
如果碰到连接超时的情况，很有可能服务器的防火墙的问题，举例CentOs7,关闭防火墙
systemctl stop firewalld.service #停止firewall systemctl disable firewalld.service #禁止firewall开机启动
点击debug按钮，IDEA控制台打印信息：
说明远程调试成功。
JVM工具远程连接
jconsole与Jvisualvm远程连接
通常我们的web服务都输部署在服务器上的，在window使用jconsole是很方便的，相对于Linux就有一些麻烦了，需要进行一些设置。
1.查看hostname,首先使用
hostname -i
查看，服务器的hostname为127.0.0.1，这个是不对的，需要进行修改
2.修改hostname
修改/etc/hosts文件，将其第一行的“127.0.0.1 localhost.localdomain localhost”，修改为：“192.168.44.128 localhost.localdomain localhost”.“192.168.44.128”为实际的服务器的IP地
3.重启Linux，在服务器上输入hostname -i，查看实际设置的IP地址是否为你设置的
4.启动服务，参数为：
java -jar -Djava.rmi.server.hostname=192.168.44.128 -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=911 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false jantent-1.0-SNAPSHOT.jar
ip为192.168.44.128，端口为911 。
5.打开Jconsole，进行远程连接,输入IP和端口即可
点击连接，经过稍稍等待之后，即可完成连接，如下图所示：
同理，JvisualVm的远程连接是同样的，启动参数也是一样.
然后在本机JvisualVm输入IP：PORT，即可进行远程连接：如下图所示：
相比较Jvisualvm功能更加强大一下，界面也更美观
注明：现已入住腾讯云自媒体分享计划
Janti粉丝 - 214 关注 - 15 +加关注 13 0 « 上一篇： Java基础巩固计划
» 下一篇： JVM活学活用——Jvm内存结构 posted @ 2018-03-30 08:39 Janti 阅读(25535) 评论(17) 编辑 收藏 举报
评论列表 默认|按时间|按支持数 回复 引用 #1楼 2019-05-27 17:51 灬达 很实用的调优技能，get了，谢谢博主 支持(0) 反对(0) 回复 引用 #2楼 2019-06-03 09:38 上山打老虎 修改了hostname就得重启？ 支持(0) 反对(0) 回复 引用 #3楼 2020-06-05 11:28 艾米111
单元测试**
开发中，每当完成一个功能接口或业务方法的编写后，通常都会借助单元测试验证该功能是否正确。Spring Boot对项目的单元测试提供了很好的支持，在使用时，需要提前在项目的pom.xml文件中添加spring-boot-starter-test测试依赖启动器，可以通过相关注解实现单元测试
演示：
1．添加spring-boot-starter-test测试依赖启动器
在项目的pom.xml文件中添加spring-boot-starter-test测试依赖启动器，示例代码如下 ：
xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
注意：使用Spring Initializr方式搭建的Spring Boot项目，会自动加入spring-boot-starter-test测试依赖启动器，无需再手动添加
学习让人快乐，学习更让人觉得无知！学了1个多月的《Java工程师高薪训练营》，才发现自己对每个技术点的认知都很肤浅，根本深不下去，立个Flag：每天坚持学习一小时，一周回答网上3个技术问题，把自己知道都分享出来。
支持(0) 反对(0) 回复 引用 #4楼 2020-06-05 15:35 皮卡1234摩羯单元测试与热部署
（1）单元测试
开发中，每当完成一个功能接口或业务方法的编写后，通常都会借助单元测试验证该功能是否正确。Spring Boot对项目的单元测试提供了很好的支持，在使用时，需要提前在项目的pom.xml文件中添加spring-boot-starter-test测试依赖启动器，可以通过相关注解实现单元测试
演示：
1．添加spring-boot-starter-test测试依赖启动器
在项目的pom.xml文件中添加spring-boot-starter-test测试依赖启动器，示例代码如下 ：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
注意：使用Spring Initializr方式搭建的Spring Boot项目，会自动加入spring-boot-starter-test测试依赖启动器，无需再手动添加
2．编写单元测试类和测试方法
使用Spring Initializr方式搭建的Spring Boot项目，会在src.test.java测试目录下自动创建与项目主程序启动类对应的单元测试类
@RunWith(SpringRunner.class) // 测试启动器，并加载Spring Boot测试注解
@SpringBootTest // 标记为Spring Boot单元测试类，并加载项目的ApplicationContext上下文环境
class SpringbootDemoApplicationTests {
@Autowired
private DemoController demoController;
// 自动创建的单元测试方法实例
@Test
void contextLoads() {
String demo = demoController.demo();
System.out.println(demo);
}
}
上述代码中，先使用@Autowired注解注入了DemoController实例对象，然后在contextLoads()方法中调用了DemoController类中对应的请求控制方法contextLoads()，并输出打印结果
<img src="./images/image-20191225135927575.png" alt="image-20191225135927575" style="zoom:67%;" />
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(1) 回复 引用 #5楼 2020-06-05 17:26 皮卡1234摩羯热部署**
在开发过程中，通常会对一段业务代码不断地修改测试，在修改之后往往需要重启服务，有些服务需要加载很久才能启动成功，这种不必要的重复操作极大的降低了程序开发效率。为此，Spring Boot框架专门提供了进行热部署的依赖启动器，用于进行项目热部署，而无需手动重启项目
演示：
1．添加spring-boot-devtools热部署依赖启动器
在Spring Boot项目进行热部署测试之前，需要先在项目的pom.xml文件中添加spring-boot-devtools热部署依赖启动器:
<!-- 引入热部署依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
由于使用的是IDEA开发工具，添加热部署依赖后可能没有任何效果，接下来还需要针对IDEA开发工具进行热部署相关的功能设置
2. IDEA工具热部署设置
选择IDEA工具界面的【File】->【Settings】选项，打开Compiler面板设置页面
<img src="./images/image-20191225140602409.png" alt="image-20191225140602409" style="zoom:67%;" />
选择Build下的Compiler选项，在右侧勾选“Build project automatically”选项将项目设置为自动编译，单击【Apply】→【OK】按钮保存设置
在项目任意页面中使用组合快捷键“Ctrl+Shift+Alt+/”打开Maintenance选项框，选中并打开Registry页面，具体如图1-17所示
<img src="./images/image-20191225141511157.png" alt="image-20191225141511157" style="zoom:67%;" />
列表中找到“compiler.automake.allow.when.app.running”，将该选项后的Value值勾选，用于指定IDEA工具在程序运行过程中自动编译，最后单击【Close】按钮完成设置
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(0) 回复 引用 #6楼 2020-06-22 10:21 皮卡1234摩羯自动配置（启动流程）
概念：能够在我们添加jar包依赖的时候，自动为我们配置一些组件的相关配置，我们无需配置或者只需要少量配置就能运行编写的项目
问题：Spring Boot到底是如何进行自动配置的，都把哪些组件进行了自动配置？
Spring Boot应用的启动入口是@SpringBootApplication注解标注类中的main()方法， @SpringBootApplication能够扫描Spring组件并自动配置Spring Boot
下面，查看@SpringBootApplication内部源码进行分析 ，核心代码具体如下
@SpringBootApplication
public class SpringbootDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoApplication.class, args);
}
}
@Target({ElementType.TYPE}) //注解的适用范围,Type表示注解可以描述在类、接口、注解或枚举中
@Retention(RetentionPolicy.RUNTIME) //表示注解的生命周期，Runtime运行时
@Documented //表示注解可以记录在javadoc中
@Inherited //表示可以被子类继承该注解
@SpringBootConfiguration // 标明该类为配置类
@EnableAutoConfiguration // 启动自动配置功能
@ComponentScan( // 包扫描器
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
...
}
从上述源码可以看出，@SpringBootApplication注解是一个组合注解，前面 4 个是注解的元数据信息， 我们主要看后面 3 个注解：@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan三个核心注解，关于这三个核心注解的相关说明具体如下：
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(1) 回复 引用 #7楼 2020-06-22 10:21 皮卡1234摩羯1．@SpringBootConfiguration注解
@SpringBootConfiguration注解表示Spring Boot配置类。查看@SpringBootConfiguration注解源码，核心代码具体如下。
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration //配置IOC容器
public @interface SpringBootConfiguration {
}
从上述源码可以看出，@SpringBootConfiguration注解内部有一个核心注解@Configuration，该注解是Spring框架提供的，表示当前类为一个配置类（XML配置文件的注解表现形式），并可以被组件扫描器扫描。由此可见，@SpringBootConfiguration注解的作用与@Configuration注解相同，都是标识一个可以被组件扫描器扫描的配置类，只不过@SpringBootConfiguration是被Spring Boot进行了重新封装命名而已
2．@EnableAutoConfiguration注解
@EnableAutoConfiguration注解表示开启自动配置功能，该注解是Spring Boot框架最重要的注解，也是实现自动化配置的注解。同样，查看该注解内部查看源码信息，核心代码具体如下
可以发现它是一个组合注解，Spring 中有很多以Enable开头的注解，其作用就是借助@Import来收集并注册特定场景相关的bean，并加载到IoC容器。@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean定义，并加载到IoC容器。
下面，对这两个核心注解分别讲解 :
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(1) 回复 引用 #8楼 2020-06-23 10:27 皮卡1234摩羯@AutoConfigurationPackage注解
查看@AutoConfigurationPackage注解内部源码信息，核心代码具体如下：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class}) // 导入Registrar中注册的组件
public @interface AutoConfigurationPackage {
}
从上述源码可以看出，@AutoConfigurationPackage注解的功能是由@Import注解实现的，它是spring框架的底层注解，它的作用就是给容器中导入某个组件类，例如@Import(AutoConfigurationPackages.Registrar.class)，它就是将Registrar这个组件类导入到容器中，可查看Registrar类中registerBeanDefinitions方法，这个方法就是导入组件类的具体实现 :
从上述源码可以看出，在Registrar类中有一个registerBeanDefinitions()方法，使用Debug模式启动项目， 可以看到选中的部分就是com.lagou。也就是说，@AutoConfigurationPackage注解的主要作用就是将主程序类所在包及所有子包下的组件到扫描到spring容器中。
因此 在定义项目包结构时，要求定义的包结构非常规范，项目主程序启动类要定义在最外层的根目录位置，然后在根目录位置内部建立子包和类进行业务开发，这样才能够保证定义的类能够被组件扫描器扫描
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(1) 回复 引用 #9楼 2020-06-23 10:29 皮卡1234摩羯@Import()：将AutoConfigurationImportSelector这个类导入到spring容器中，AutoConfigurationImportSelector可以帮助springboot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器(ApplicationContext)中
继续研究AutoConfigurationImportSelector这个类，通过源码分析这个类中是通过selectImports这个方法告诉springboot都需要导入那些组件：
深入研究loadMetadata方法
深入getCandidateConfigurations方法
个方法中有一个重要方法loadFactoryNames，这个方法是让SpringFactoryLoader去加载一些组件的名字。
继续点开loadFactory方法
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
//获取出入的键
String factoryClassName = factoryClass.getName();
return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
if (result != null) {
return result;
} else {
try {
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
//如果类加载器不为null，则加载类路径下spring.factories文件，将其中设置的配置类的全路径信息封装 为Enumeration类对象
Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
LinkedMultiValueMap result = new LinkedMultiValueMap();
//循环Enumeration类对象，根据相应的节点信息生成Properties对象，通过传入的键获取值，在将值切割为一个个小的字符串转化为Array，方法result集合中
while(urls.hasMoreElements()) {
URL url = (URL)urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
Iterator var6 = properties.entrySet().iterator();
while(var6.hasNext()) {
Entry<?, ?> entry = (Entry)var6.next();
String factoryClassName = ((String)entry.getKey()).trim();
String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
int var10 = var9.length;
for(int var11 = 0; var11 < var10; ++var11) {
String factoryName = var9[var11];
result.add(factoryClassName, factoryName.trim());
}
}
}
cache.put(classLoader, result);
return result;
会去读取一个 sprin g.factories 的文件，读取不到会表这个错误，我们继续根据会看到，最终路径的长这样，而这个是spring提供的一个工具类
```java
public final class SpringFactoriesLoader {
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
}
它其实是去加载一个外部的文件，而这文件是在
@EnableAutoConfiguration就是从classpath中搜寻META-INF/spring.factories配置文件，并将其中org.springframework.boot.autoconfigure.EnableutoConfiguration对应的配置项通过反射（Java Refletion）实例化为对应的标注了@Configuration的JavaConfig形式的配置类，并加载到IOC容器中
以刚刚的项目为例，在项目中加入了Web环境依赖启动器，对应的WebMvcAutoConfiguration自动配置类就会生效，打开该自动配置类会发现，在该配置类中通过全注解配置类的方式对Spring MVC运行所需环境进行了默认配置，包括默认前缀、默认后缀、视图解析器、MVC校验器等。而这些自动配置类的本质是传统Spring MVC框架中对应的XML配置文件，只不过在Spring Boot中以自动配置类的形式进行了预先配置。因此，在Spring Boot项目中加入相关依赖启动器后，基本上不需要任何配置就可以运行程序，当然，我们也可以对这些自动配置类中默认的配置进行更改
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(0) 回复 引用 #11楼 2020-06-24 14:33 皮卡1234摩羯总结
因此springboot底层实现自动配置的步骤是：
-
springboot应用启动；
-
@SpringBootApplication起作用；
-
@EnableAutoConfiguration；
-
@AutoConfigurationPackage：这个组合注解主要是@Import(AutoConfigurationPackages.Registrar.class)，它通过将Registrar类导入到容器中，而Registrar类作用是扫描主配置类同级目录以及子包，并将相应的组件导入到springboot创建管理的容器中；
-
@Import(AutoConfigurationImportSelector.class)：它通过将AutoConfigurationImportSelector类导入到容器中，AutoConfigurationImportSelector类作用是通过selectImports方法执行的过程中，会使用内部工具类SpringFactoriesLoader，查找classpath上所有jar包中的META-INF/spring.factories进行加载，实现将配置类信息交给SpringFactory加载器进行一系列的容器创建过程
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(0) 回复 引用 #12楼 2020-06-28 11:27 皮卡1234摩羯@ComponentScan注解**
@ComponentScan注解具体扫描的包的根路径由Spring Boot项目主程序启动类所在包位置决定，在扫描过程中由前面介绍的@AutoConfigurationPackage注解进行解析，从而得到Spring Boot项目主程序启动类所在包的具体位置
总结：
@SpringBootApplication 的注解的功能就分析差不多了， 简单来说就是 3 个注解的组合注解：
|- @SpringBootConfiguration
|- @Configuration //通过javaConfig的方式来添加组件到IOC容器中
|- @EnableAutoConfiguration
|- @AutoConfigurationPackage //自动配置包，与@ComponentScan扫描到的添加到IOC
|- @Import(AutoConfigurationImportSelector.class) //到META-INF/spring.factories中定义的bean添加到IOC容器中
|- @ComponentScan //包扫描
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(0) 回复 引用 #13楼 2020-06-28 11:28 皮卡1234摩羯自定义Stater
SpringBoot starter机制
SpringBoot由众多Starter组成（一系列的自动化配置的starter插件），SpringBoot之所以流行，也是因为starter。
starter是SpringBoot非常重要的一部分，可以理解为一个可拔插式的插件，正是这些starter使得使用某个功能的开发者不需要关注各种依赖库的处理，不需要具体的配置信息，由Spring Boot自动通过classpath路径下的类发现需要的Bean，并织入相应的Bean。
例如，你想使用Reids插件，那么可以使用spring-boot-starter-redis；如果想使用MongoDB，可以使用spring-boot-starter-data-mongodb
为什么要自定义starter
开发过程中，经常会有一些独立于业务之外的配置模块。如果我们将这些可独立于业务代码之外的功能配置模块封装成一个个starter，复用的时候只需要将其在pom中引用依赖即可，SpringBoot为我们完成自动装配
自定义starter的命名规则
SpringBoot提供的starter以spring-boot-starter-xxx的方式命名的。官方建议自定义的starter使用xxx-spring-boot-starter命名规则。以区分SpringBoot生态提供的starter
整个过程分为两部分：
- 自定义starter
- 使用starter
首先，先完成自定义starter
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(0) 回复 引用 #14楼 2020-06-28 19:10 皮卡1234摩羯（1）新建maven jar工程，工程名为zdy-spring-boot-starter，导入依赖：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
<version>2.2.2.RELEASE</version>
</dependency>
</dependencies>
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(1) 回复 引用 #15楼 2020-06-28 19:11 皮卡1234摩羯（2）编写javaBean
@EnableConfigurationProperties(SimpleBean.class)
@ConfigurationProperties(prefix = "simplebean")
public class SimpleBean {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "SimpleBean{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
这些内容，是从拉勾教育的《Java工程师高薪训练营》里学到的，课程内容非常全面，还有拉勾的内推大厂服务，推荐你也看看。
支持(0) 反对(1) 回复 引用 #16楼 2020-07-02 10:29 皮卡1234摩羯SpringApplication实例的初始化创建**
查看SpringApplication实例对象初始化创建的源码信息，核心代码具体如下
public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
this.sources = new LinkedHashSet();
this.bannerMode = Mode.CONSOLE;
this.logStartupInfo = true;
this.addCommandLineProperties = true;
this.addConversionService = true;
this.headless = true;
this.registerShutdownHook = true;
this.additionalProfiles = new HashSet();
this.isCustomEnvironment = false;
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
//把项目启动类.class设置为属性存储起来
this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
//判断当前webApplicationType应用的类型
this.webApplicationType = WebApplicationType.deduceFromClasspath();
// 设置初始化器(Initializer),最后会调用这些初始化器
this.setInitializers(this.getSpringFactoriesInstances(
ApplicationContextInitializer.class));
// 设置监听器(Listener)
this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
// 用于推断并设置项目main()方法启动的主程序启动类
this.mainApplicationClass = this.deduceMainApplicationClass();
从上述源码可以看出，SpringApplication的初始化过程主要包括4部分，具体说明如下。
（1）this.webApplicationType = WebApplicationType.deduceFromClasspath()
用于判断当前webApplicationType应用的类型。deduceFromClasspath()方法用于查看Classpath类路径下是否存在某个特征类，从而判断当前webApplicationType类型是SERVLET应用（Spring 5之前的传统MVC应用）还是REACTIVE应用（Spring 5开始出现的WebFlux交互式应用）
（2）this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class))
用于SpringApplication应用的初始化器设置。在初始化器设置过程中，会使用Spring类加载器SpringFactoriesLoader从META-INF/spring.factories类路径下的META-INF下的spring.factores文件中获取所有可用的应用初始化器类ApplicationContextInitializer。
（3）this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class))
用于SpringApplication应用的监听器设置。监听器设置的过程与上一步初始化器设置的过程基本一样，也是使用SpringFactoriesLoader从META-INF/spring.factories类路径下的META-INF下的spring.factores文件中获取所有可用的监听器类ApplicationListener。
（4）this.mainApplicationClass = this.deduceMainApplicationClass()
用于推断并设置项目main()方法启动的主程序启动类
支持(0) 反对(0) 回复 引用 #17楼 2020-07-02 10:30 皮卡1234摩羯执行原理
每个Spring Boot项目都有一个主程序启动类，在主程序启动类中有一个启动项目的main()方法，在该方法中通过执行SpringApplication.run()即可启动整个Spring Boot程序。
问题：那么SpringApplication.run()方法到底是如何做到启动Spring Boot项目的呢？
下面我们查看run()方法内部的源码，核心代码具体如下：
@SpringBootApplication
public class SpringbootDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoApplication.class, args);
}
}
public static ConfigurableApplicationContext run(Class<?> primarySource,
String... args) {
return run(new Class[]{primarySource}, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources,
String[] args) {
return (new SpringApplication(primarySources)).run(args);
}