SpringBoot启动原理 & 内嵌tomcat和外置tomcat启动分析

最新推荐文章于 2024-04-30 22:27:49 发布
最新推荐文章于 2024-04-30 22:27:49 发布
阅读量2.6k 收藏 16
点赞数 4
分类专栏： # [TL-4]微服务-SpringBoot 文章标签： spring boot tomcat jar
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43631716/article/details/121169609
版权

文章目录

SpringBoot 是如何通过jar包启动的

得益于SpringBoot的封装，我们可以只通过jar -jar一行命令便启动一个web项目。再也不用操心搭建tomcat等相关web容器。那么，你是否探究过SpringBoot是如何达到这一操作的呢？只有了解了底层实现原理，才能更好的掌握该项技术带来的好处以及性能调优。本篇文章带大家聊一探究竟。

java -jar做了什么

先要弄清楚java -jar命令做了什么，在oracle官网找到了该命令的描述：

If the -jar option is specified, its argument is the name of the JAR file containing class and resource files for the application. The startup class must be indicated by the Main-Class manifest header in its source code.

使用-jar参数时，后面的参数是的jar文件名(本例中是springbootstarterdemo-0.0.1-SNAPSHOT.jar)；
该jar文件中包含的是class和资源文件；
在manifest文件中有Main-Class的定义；
Main-Class的源码中指定了整个应用的启动类；(in its source code) .

小结一下：
java -jar会去找jar中的manifest文件，在那里面找到真正的启动类。

疑惑出现

在MANIFEST.MF文件中有这么一行内容：

Start-Class: com.test.Application

前面的java官方文档中，只提到过Main-Class ，并没有提到Start-Class；

Start-Class的值是com.test.Application，这是我们的java代码中的唯一类，也只真正的应用启动类；
所以问题就来了：理论上看，执行java -jar命令时JarLauncher类会被执行，但实际上是com.test.Application被执行了，这其中发生了什么呢？为什么要这么做呢？

Java没有提供任何标准的方式来加载嵌套的jar文件（即，它们本身包含在jar中的jar文件）。

Jar包的打包插件及核心方法

Spring Boot项目的pom.xml文件中默认使用如下插件进行打包：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

执行maven clean package之后，会生成两个文件：

spring-learn-0.0.1-SNAPSHOT.jar
spring-learn-0.0.1-SNAPSHOT.jar.original

spring-boot-maven-plugin项目存在于spring-boot-tools目录中。spring-boot-maven-plugin默认有5个goals：repackage、run、start、stop、build-info。在打包的时候默认使用的是repackage。

spring-boot-maven-plugin的repackage能够将mvn package生成的软件包，再次打包为可执行的软件包，并将mvn package生成的软件包重命名为*.original。

spring-boot-maven-plugin的repackage在代码层面调用了RepackageMojo的execute方法，而在该方法中又调用了repackage方法。repackage方法代码及操作解析如下：

private void repackage() throws MojoExecutionException {
   // maven生成的jar，最终的命名将加上.original后缀
   Artifact source = getSourceArtifact();
   // 最终为可执行jar，即fat jar
   File target = getTargetFile();
   // 获取重新打包器，将maven生成的jar重新打包成可执行jar
   Repackager repackager = getRepackager(source.getFile());
   // 查找并过滤项目运行时依赖的jar
   Set<Artifact> artifacts = filterDependencies(this.project.getArtifacts(),
         getFilters(getAdditionalFilters()));
   // 将artifacts转换成libraries
   Libraries libraries = new ArtifactsLibraries(artifacts, this.requiresUnpack,
         getLog());
   try {
      // 获得Spring Boot启动脚本
      LaunchScript launchScript = getLaunchScript();
      // 执行重新打包，生成fat jar
      repackager.repackage(target, libraries, launchScript);
   }catch (IOException ex) {
      throw new MojoExecutionException(ex.getMessage(), ex);
   }
   // 将maven生成的jar更新成.original文件
   updateArtifact(source, target, repackager.getBackupFile());
}

执行以上命令之后，便生成了打包结果对应的两个文件。下面针对文件的内容和结构进行一探究竟。

jar包目录结构

首先来看看jar的目录结构，都包含哪些目录和文件，解压jar包可以看到如下结构：

spring-boot-learn-0.0.1-SNAPSHOT
├── META-INF
│   └── MANIFEST.MF
├── BOOT-INF
│   ├── classes
│   │   └── 应用程序类
│   └── lib
│       └── 第三方依赖jar
└── org
    └── springframework
        └── boot
            └── loader
                └── springboot启动程序

META-INF内容

在上述目录结构中，META-INF记录了相关jar包的基础信息，包括入口程序等。

Manifest-Version: 1.0
Implementation-Title: spring-learn
Implementation-Version: 0.0.1-SNAPSHOT
Start-Class: com.tulingxueyuan.Application
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.1.5.RELEASE
Created-By: Maven Archiver 3.4.0
Main-Class: org.springframework.boot.loader.JarLauncher

可以看到有Main-Class是org.springframework.boot.loader.JarLauncher ，这个是jar启动的Main函数。
还有一个Start-Class是com.tulingxueyuan.Application，这个是我们应用自己的Main函数。

Archive的概念

在继续了解底层概念和原理之前，我们先来了解一下Archive的概念：

  • archive即归档文件，这个概念在linux下比较常见。
  • 通常就是一个tar/zip格式的压缩包。
  • jar是zip格式。

SpringBoot抽象了Archive的概念，一个Archive可以是jar（JarFileArchive），可以是一个文件目录（ExplodedArchive），可以抽象为统一访问资源的逻辑层。关于Spring Boot中Archive的源码如下：

public interface Archive extends Iterable<Archive.Entry> {
    // 获取该归档的url
    URL getUrl() throws MalformedURLException;
    // 获取jar!/META-INF/MANIFEST.MF或[ArchiveDir]/META-INF/MANIFEST.MF
    Manifest getManifest() throws IOException;
    // 获取jar!/BOOT-INF/lib/*.jar或[ArchiveDir]/BOOT-INF/lib/*.jar
    List<Archive> getNestedArchives(EntryFilter filter) throws IOException;
}

SpringBoot定义了一个接口用于描述资源，也就是org.springframework.boot.loader.archive.Archive。该接口有两个实现，分别是org.springframework.boot.loader.archive.ExplodedArchive和org.springframework.boot.loader.archive.JarFileArchive。前者用于在文件夹目录下寻找资源，后者用于在jar包环境下寻找资源。而在SpringBoot打包的fatJar中，则是使用后者。

JarFile：对jar包的封装，每个JarFileArchive都会对应一个JarFile。JarFile被构造的时候会解析内部结构，去获取jar包里的各个文件或文件夹，这些文件或文件夹会被封装到Entry中，也存储在JarFileArchive中。如果Entry是个jar，会解析成JarFileArchive。
比如一个JarFileArchive对应的URL为：

jar:file:/Users/format/Develop/gitrepository/springboot-analysis/springboot-executable-jar/target/executable-jar-1.0-SNAPSHOT.jar!/

它对应的JarFile为：

/Users/format/Develop/gitrepository/springboot-analysis/springboot-executable-jar/target/executable-jar-1.0-SNAPSHOT.jar

这个JarFile有很多Entry，比如：

META-INF/
META-INF/MANIFEST.MF
spring/
spring/study/
....
spring/study/executablejar/ExecutableJarApplication.class
lib/spring-boot-starter-1.3.5.RELEASE.jar
lib/spring-boot-1.3.5.RELEASE.jar
...

JarFileArchive内部的一些依赖jar对应的URL(SpringBoot使用org.springframework.boot.loader.jar.Handler处理器来处理这些URL)：

jar:file:/Users/Format/Develop/gitrepository/springboot-analysis/springboot-executable-jar/target/executable-jar-1.0-SNAPSHOT.jar!/lib/spring-boot-starter-web-1.3.5.RELEASE.jar!/

jar:file:/Users/Format/Develop/gitrepository/springboot-analysis/springboot-executable-jar/target/executable-jar-1.0-SNAPSHOT.jar!/lib/spring-boot-loader-1.3.5.RELEASE.ja

我们看到如果有jar包中包含jar，或者jar包中包含jar包里面的class文件，那么会使用 !/ 分隔开，这种方式只有org.springframework.boot.loader.jar.Handler能处理，它是SpringBoot内部扩展出来的一种URL协议。

JarLauncher

从MANIFEST.MF可以看到Main函数是JarLauncher，下面来分析它的工作流程。JarLauncher类的继承结构是：

Launcher for JAR based archives. This launcher assumes that dependency jars are included inside a /BOOT-INF/lib directory and that application classes are included inside a /BOOT-INF/classes directory.

按照定义，JarLauncher可以加载内部/BOOT-INF/lib下的jar及/BOOT-INF/classes下的应用class，其实JarLauncher实现很简单：

public class JarLauncher extends ExecutableArchiveLauncher {
    public JarLauncher() {}
    public static void main(String[] args) throws Exception {
        new JarLauncher().launch(args);
    }
}

其主入口新建了JarLauncher并调用父类Launcher中的launch方法启动程序。在创建JarLauncher时，父类ExecutableArchiveLauncher找到自己所在的jar，并创建archive。
JarLauncher继承于org.springframework.boot.loader.ExecutableArchiveLauncher。该类的无参构造方法最主要的功能就是构建了当前main方法所在的FatJar的JarFileArchive对象。下面来看launch方法。该方法主要是做了2个事情：
（1）以FatJar为file作为入参，构造JarFileArchive对象。获取其中所有的资源目标，取得其Url，将这些URL作为参数，构建了一个URLClassLoader。
（2）以第一步构建的ClassLoader加载MANIFEST.MF文件中Start-Class指向的业务类，并且执行静态方法main。进而启动整个程序。

public abstract class ExecutableArchiveLauncher extends Launcher {
    private final Archive archive;
    public ExecutableArchiveLauncher() {
        try {
            // 找到自己所在的jar，并创建Archive
            this.archive = createArchive();
        }
        catch (Exception ex) {
            throw new IllegalStateException(ex);
        }
    }
}
 
 
public abstract class Launcher {
    protected final Archive createArchive() throws Exception {
        ProtectionDomain protectionDomain = getClass().getProtectionDomain();
        CodeSource codeSource = protectionDomain.getCodeSource();
        URI location = (codeSource == null ? null : codeSource.getLocation().toURI());
        String path = (location == null ? null : location.getSchemeSpecificPart());
        if (path == null) {
            throw new IllegalStateException("Unable to determine code source archive");
        }
        File root = new File(path);
        if (!root.exists()) {
            throw new IllegalStateException(
                    "Unable to determine code source archive from " + root);
        }
        return (root.isDirectory() ? new ExplodedArchive(root)
                : new JarFileArchive(root));
    }
}

在Launcher的launch方法中，通过以上archive的getNestedArchives方法找到/BOOT-INF/lib下所有jar及/BOOT-INF/classes目录所对应的archive，通过这些archives的url生成LaunchedURLClassLoader，并将其设置为线程上下文类加载器，启动应用。
至此，才执行我们应用程序主入口类的main方法，所有应用程序类文件均可通过/BOOT-INF/classes加载，所有依赖的第三方jar均可通过/BOOT-INF/lib加载。

URLStreamHandler

java中描述资源常使用URL。而URL有一个方法用于打开链接java.net.URL#openConnection()。由于URL用于表达各种各样的资源，打开资源的具体动作由java.net.URLStreamHandler这个类的子类来完成。根据不同的协议，会有不同的handler实现。而JDK内置了相当多的handler实现用于应对不同的协议。比如jar、file、http等等。URL内部有一个静态HashTable属性，用于保存已经被发现的协议和handler实例的映射。
获得URLStreamHandler有三种方法：

（1）实现URLStreamHandlerFactory接口，通过方法URL.setURLStreamHandlerFactory设置。该属性是一个静态属性，且只能被设置一次。

（2）直接提供URLStreamHandler的子类，作为URL的构造方法的入参之一。但是在JVM中有固定的规范要求：
子类的类名必须是Handler，同时最后一级的包名必须是协议的名称。比如自定义了Http的协议实现，则类名必然为xx.http.Handler；
JVM启动的时候，需要设置java.protocol.handler.pkgs系统属性，如果有多个实现类，那么中间用|隔开。因为JVM在尝试寻找Handler时，会从这个属性中获取包名前缀，最终使用包名前缀.协议名.Handler，使用Class.forName方法尝试初始化类，如果初始化成功，则会使用该类的实现作为协议实现。
为了实现这个目标，SpringBoot首先从支持jar in jar中内容读取做了定制，也就是支持多个!/分隔符的url路径。SpringBoot定制了以下两个方面：

（1）实现了一个java.net.URLStreamHandler的子类org.springframework.boot.loader.jar.Handler。该Handler支持识别多个!/分隔符，并且正确的打开URLConnection。打开的Connection是SpringBoot定制的org.springframework.boot.loader.jar.JarURLConnection实现。
（2）实现了一个java.net.JarURLConnection的子类org.springframework.boot.loader.jar.JarURLConnection。该链接支持多个!/分隔符，并且自己实现了在这种情况下获取InputStream的方法。而为了能够在org.springframework.boot.loader.jar.JarURLConnection正确获取输入流，SpringBoot自定义了一套读取ZipFile的工具类和方法。这部分和ZIP压缩算法规范紧密相连，就不拓展了。

Spring Boot的Jar应用启动流程总结

总结一下Spring Boot应用的启动流程：
（1）Spring Boot应用打包之后，生成一个Fat jar，包含了应用依赖的jar包和Spring Boot loader相关的类。
（2）Fat jar的启动Main函数是JarLauncher，它负责创建一个LaunchedURLClassLoader来加载/lib下面的jar，并以一个新线程启动应用的Main函数。
那么，ClassLoader是如何读取到Resource，它又需要哪些能力？查找资源和读取资源的能力。对应的API：
public URL findResource(String name)

public URL findResource(String name)
public InputStream getResourceAsStream(String name)

SpringBoot构造LaunchedURLClassLoader时，传递了一个URL[]数组。数组里是lib目录下面的jar的URL。
对于一个URL，JDK或者ClassLoader如何知道怎么读取到里面的内容的？流程如下：

  • LaunchedURLClassLoader.loadClass
  • URL.getContent()
  • URL.openConnection()
  • Handler.openConnection(URL)

最终调用的是JarURLConnection的getInputStream()函数。

/org.springframework.boot.loader.jar.JarURLConnection
 @Override
public InputStream getInputStream() throws IOException {
   connect();
   if (this.jarEntryName.isEmpty()) {
     throw new IOException("no entry name specified");
   }
   return this.jarEntryData.getInputStream();
 }

从一个URL，到最终读取到URL里的内容，整个过程是比较复杂的，总结下：

  • Spring boot注册了一个Handler来处理”jar:”这种协议的URL。
  • Spring boot扩展了JarFile和JarURLConnection，内部处理jar in jar的情况。
  • 在处理多重jar in jar的URL时，Spring Boot会循环处理，并缓存已经加载到的JarFile。
  • 对于多重jar in jar，实际上是解压到了临时目录来处理，可以参考JarFileArchive里的代码。
  • 在获取URL的InputStream时，最终获取到的是JarFile里的JarEntryData。

细节很多，上面只列出比较重要的步骤。最后，URLClassLoader是如何getResource的呢？URLClassLoader在构造时，有URL[]数组参数，它内部会用这个数组来构造一个URLClassPath:
URLClassPath ucp = new URLClassPath(urls);

在URLClassPath内部会为这些URLS都构造一个Loader，然后在getResource时，会从这些Loader里一个个去尝试获取。如果获取成功的话，就像下面那样包装为一个Resource。

Resource getResource(final String name, boolean check) {
    final URL url;
    try {
        url = new URL(base, ParseUtil.encodePath(name, false));
    } catch (MalformedURLException e) {
        throw new IllegalArgumentException("name");
    }
    final URLConnection uc;
    try {
        if (check) {
            URLClassPath.check(url);
        }
        uc = url.openConnection();
        InputStream in = uc.getInputStream();
        if (uc instanceof JarURLConnection) {
            /* Need to remember the jar file so it can be closed
             * in a hurry.
             */
            JarURLConnection juc = (JarURLConnection)uc;
            jarfile = JarLoader.checkJar(juc.getJarFile());
        }
    } catch (Exception e) {
        return null;
    }
    return new Resource() {
        public String getName() { return name; }
        public URL getURL() { return url; }
        public URL getCodeSourceURL() { return base; }
        public InputStream getInputStream() throws IOException {
            return uc.getInputStream();
        }
        public int getContentLength() throws IOException {
            return uc.getContentLength();
        }
    };
}
            JarURLConnection juc = (JarURLConnection)uc;

从代码里可以看到，实际上是调用了url.openConnection()。这样完整的链条就可以连接起来了。

总结

JarLauncher通过加载BOOT-INF/classes目录及BOOT-INF/lib目录下jar文件，实现了fat jar的启动。
SpringBoot通过扩展JarFile、JarURLConnection及URLStreamHandler，实现了jar in jar中资源的加载。
SpringBoot通过扩展URLClassLoader–LauncherURLClassLoader，实现了jar in jar中class文件的加载。

WarLauncher通过加载WEB-INF/classes目录及WEB-INF/lib和WEB-INF/lib-provided目录下的jar文件，实现了war文件的直接启动及web容器中的启动。

SpringBoot是如何启动Spring容器源码：

SpringBoot 事件监听器发布顺序：

1.ApplicationStartingEvent在运行开始时发送，但在进行任何处理之前（侦听器和初始化程序的注册除外）发送。

2.在创建上下文之前，将发送ApplicationEnvironmentPreparedEvent。

3.准备ApplicationContext并调用ApplicationContextInitializers之后，将发送ApplicationContextInitializedEvent。

4.读取完配置类后发送ApplicationPreparedEvent。

5.在刷新上下文之后但在调用任何应用程序和命令行运行程序之前，将发送ApplicationStartedEvent。

6.紧随其后发送带有LivenessState.CORRECT的AvailabilityChangeEvent，以指示该应用程序被视为处于活动状态。

7.在调用任何应用程序和命令行运行程序之后，将发送ApplicationReadyEvent。

8.紧随其后发送ReadabilityState.ACCEPTING_TRAFFIC的AvailabilityChangeEvent，以指示应用程序已准备就绪，可以处理请求。

如果启动时发生异常，则发送ApplicationFailedEvent。

1、调用SpringApplication.run启动springboot应用

SpringApplication.run(Application.class, args);

2、使用自定义SpringApplication进行启动

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

1. 创建SpringApplication

  • new SpringApplication(primarySources)
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
   this.resourceLoader = resourceLoader;
   Assert.notNull(primarySources, "PrimarySources must not be null");
   // 将启动类放入primarySources 
   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
   // 根据classpath 下的类，推算当前web应用类型(webFlux, servlet)
   this.webApplicationType = WebApplicationType.deduceFromClasspath();
   // 就是去spring.factories 中去获取所有key:org.springframework.context.ApplicationContextInitializer
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
   //就是去spring.factories 中去获取所有key: org.springframework.context.ApplicationListener
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
   // 根据main方法推算出mainApplicationClass 
   this.mainApplicationClass = deduceMainApplicationClass();
}
  • org.springframework.context.ApplicationContextInitializer
    在这里插入图片描述
  • org.springframework.context.ApplicationListener
    在这里插入图片描述

总结：

1、获取启动类:根据启动类加载ioc容器
2、获取web应用类型
3、spring.factories读取了对外扩展的ApplicationContextInitializer ,ApplicationListener 对外扩展， 对类解耦（比如全局配置文件、热部署插件）
4、根据main推算出所在的类

就是去初始化了一些信息

2. 启动

1、run
启动springboot最核心的逻辑

public ConfigurableApplicationContext run(String... args) {
    // 用来记录当前springboot启动耗时
   StopWatch stopWatch = new StopWatch();
   // 就是记录了启动开始时间
   stopWatch.start();
   // 它是任何spring上下文的接口， 所以可以接收任何ApplicationContext实现
   ConfigurableApplicationContext context = null;
   Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
   // 开启了Headless模式：
   configureHeadlessProperty();
   // 去spring.factroies中读取了SpringApplicationRunListener 的组件，  就是用来发布事件或者运行监听器
   SpringApplicationRunListeners listeners = getRunListeners(args);
   // 发布1.ApplicationStartingEvent事件，在运行开始时发送
   listeners.starting();
   try {
       // 根据命令行参数 实例化一个ApplicationArguments 
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      // 预初始化环境： 读取环境变量，读取配置文件信息（基于监听器）
      ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
      // 忽略beaninfo的bean
      configureIgnoreBeanInfo(environment);
      // 打印Banner 横幅
      Banner printedBanner = printBanner(environment);
      // 根据webApplicationType创建Spring上下文  
      context = createApplicationContext();
      exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
            new Class[] { ConfigurableApplicationContext.class }, context);
      //预初始化spring上下文
      prepareContext(context, environment, listeners, applicationArguments, printedBanner);
      // 加载spring ioc 容器   **相当重要   由于是使用AnnotationConfigServletWebServerApplicationContext 启动的spring容器所以springboot对它做了扩展：
      //  加载自动配置类：invokeBeanFactoryPostProcessors ，  创建servlet容器onRefresh
      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, ex, exceptionReporters, listeners);
      throw new IllegalStateException(ex);
   }

   try {
      listeners.running(context);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, null);
      throw new IllegalStateException(ex);
   }
   return context;
}

2、prepareEnvironment

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
      ApplicationArguments applicationArguments) {
   // 根据webApplicationType 创建Environment  创建就会读取： java环境变量和系统环境变量
   ConfigurableEnvironment environment = getOrCreateEnvironment();
   // 将命令行参数读取环境变量中
   configureEnvironment(environment, applicationArguments.getSourceArgs());
   // 将@PropertieSource的配置信息 放在第一位， 因为读取配置文件@PropertieSource优先级是最低的
   ConfigurationPropertySources.attach(environment);
   // 发布了ApplicationEnvironmentPreparedEvent 的监听器  读取了全局配置文件
   listeners.environmentPrepared(environment);
   // 将所有spring.main 开头的配置信息绑定SpringApplication
   bindToSpringApplication(environment);
   if (!this.isCustomEnvironment) {
      environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
            deduceEnvironmentClass());
   }
   //更新PropertySources
   ConfigurationPropertySources.attach(environment);
   return environment;
}

3、prepareContext
预初始化上下文

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
      SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
   context.setEnvironment(environment);
   postProcessApplicationContext(context);
   // 拿到之前读取到所有ApplicationContextInitializer的组件， 循环调用initialize方法
   applyInitializers(context);
   // 发布了ApplicationContextInitializedEvent
   listeners.contextPrepared(context);
   if (this.logStartupInfo) {
      logStartupInfo(context.getParent() == null);
      logStartupProfileInfo(context);
   }
   // 获取当前spring上下文beanFactory (负责创建bean)
   ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
   beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
   if (printedBanner != null) {
      beanFactory.registerSingleton("springBootBanner", printedBanner);
   }
   // 在Spring下 如果出现2个重名的bean, 则后读取到的会覆盖前面
   // 在SpringBoot 在这里设置了不允许覆盖， 当出现2个重名的bean 会抛出异常
   if (beanFactory instanceof DefaultListableBeanFactory) {
      ((DefaultListableBeanFactory) beanFactory)
            .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
   }
   // 设置当前spring容器是不是要将所有的bean设置为懒加载
   if (this.lazyInitialization) {
      context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
   }
   // Load the sources
   Set<Object> sources = getAllSources();
   Assert.notEmpty(sources, "Sources must not be empty");
   // 读取主启动类,将它注册为BD、就像我们以前register(启动类);一个意思 （因为后续要根据配置类解析配置的所有bean)
   load(context, sources.toArray(new Object[0]));
   //4.读取完配置类后发送ApplicationPreparedEvent。
   listeners.contextLoaded(context);
}

总结：
1、初始化SpringApplication 从spring.factories 读取 listener ApplicationContextInitializer

2、运行run方法
3、读取 环境变量 配置信息…
4、创建springApplication上下文:ServletWebServerApplicationContext
5、预初始化上下文 ： 读取启动类
6、调用refresh 加载ioc容器

加载所有的自动配置类
创建servlet容器

ps： 在这个过程中springboot会调用很多监听器对外进行扩展。

使用外部Servlet容器

外部servlet容器：

  • 服务器、本机 安装tomcat 环境变量…
  • 部署： war—运维—>tomcat webapp startup.sh 启动
  • 开发： 将开发绑定本地tomcat
  • 开发 、 运维 服务器配置 war

内嵌servlet容器：

  • 部署： jar—> 运维—java -jar 启动

使用：

1、下载tomcat服务
2、设置当前maven项目的打包方式

<!--打包方式  默认是jar-->
<packaging>war</packaging>

3、让tomcat相关的依赖不参与打包部署 ，因为外置tomcat服务器已经有这些jar包

<!--让它不参与打包部署，或者排除内嵌tomcat-->
<dependency>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <groupId>org.springframework.boot</groupId>
    <scope>provided</scope>
</dependency>

4、为了让它支持springboot需要加上： 才能启动springboot应用

public class TomcatStartSpringBoot extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(Application.class);
    }
}

5、在idea中运行
在这里插入图片描述
在这里插入图片描述

外部Servlet容器启动SpringBoot应用原理

tomcat—> web.xml–filter servlet listener 3.0+

tomcat不会主动去启动springboot应用 ，， 所以tomcat启动的时候肯定调用了SpringBootServletInitializer的SpringApplicationBuilder ， 就会启动springboot。

public class TomcatStartSpringBoot extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder (SpringApplicationBuilder builder) {
        return builder.sources(Application.class);
    }
}

servlet3.0 规范官方文档： 8.2.4
在这里插入图片描述

什么是SPI

SPI ，全称为 Service Provider Interface(服务提供者接口)，是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件，自动加载文件里所定义的类。

大概： 当servlet容器启动时候 就会去META-INF/services 文件夹中找到javax.servlet.ServletContainerInitializer, 这个文件里面肯定绑定一个ServletContainerInitializer. 当servlet容器启动时候就会去该文件中找到ServletContainerInitializer的实现类，从而创建它的实例调用onstartUp。

1、@HandlesTypes(WebApplicationInitializer.class).

  • @HandlesTypes传入的类为ServletContainerInitializer感兴趣的
  • 容器会自动在classpath中找到 WebApplicationInitializer，会传入到onStartup方法的webAppInitializerClasses中
  • Set<Class<?>> webAppInitializerClasses这里面也包括之前定义的TomcatStartSpringBoot
@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {

@Override
public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
      throws ServletException {

   List<WebApplicationInitializer> initializers = new LinkedList<>();

   if (webAppInitializerClasses != null) {
      for (Class<?> waiClass : webAppInitializerClasses) {
        // 如果不是接口 不是抽象 跟WebApplicationInitializer有关系  就会实例化
         if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
               WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
            try {
               initializers.add((WebApplicationInitializer)
                     ReflectionUtils.accessibleConstructor(waiClass).newInstance());
            }
            catch (Throwable ex) {
               throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
            }
         }
      }
   }

   if (initializers.isEmpty()) {
      servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
      return;
   }

   servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
   // 排序
   AnnotationAwareOrderComparator.sort(initializers);
   for (WebApplicationInitializer initializer : initializers) {
      initializer.onStartup(servletContext);
   }
}

在这里插入图片描述

@Override
public void onStartup(ServletContext servletContext) throws ServletException {
   // Logger initialization is deferred in case an ordered
   // LogServletContextInitializer is being used
   this.logger = LogFactory.getLog(getClass());
   WebApplicationContext rootApplicationContext = createRootApplicationContext(servletContext);
   if (rootApplicationContext != null) {
      servletContext.addListener(new SpringBootContextLoaderListener(rootApplicationContext, servletContext));
   }
   else {
      this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not "
            + "return an application context");
   }
}

2、SpringBootServletInitializer

  • 之前定义的TomcatStartSpringBoot 就是继承它
protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
   SpringApplicationBuilder builder = createSpringApplicationBuilder();
   builder.main(getClass());
   ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
   if (parent != null) {
      this.logger.info("Root context already created (using as parent).");
      servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
      builder.initializers(new ParentContextApplicationContextInitializer(parent));
   }
   builder.initializers(new ServletContextApplicationContextInitializer(servletContext));
   builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);
   // 调用configure
   builder = configure(builder);
   builder.listeners(new WebEnvironmentPropertySourceInitializer(servletContext));
   SpringApplication application = builder.build();
   if (application.getAllSources().isEmpty()
         && MergedAnnotations.from(getClass(), SearchStrategy.TYPE_HIERARCHY).isPresent(Configuration.class)) {
      application.addPrimarySources(Collections.singleton(getClass()));
   }
   Assert.state(!application.getAllSources().isEmpty(),
         "No SpringApplication sources have been defined. Either override the "
               + "configure method or add an @Configuration annotation");
   // Ensure error pages are registered
   if (this.registerErrorPageFilter) {
      application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
   }
   application.setRegisterShutdownHook(false);
   return run(application);
}

3、当调用configure就会来到TomcatStartSpringBoot .configure

  • 将Springboot启动类传入到builder.source
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
    return builder.sources(Application.class);
}

// 调用SpringApplication application = builder.build(); 就会根据传入的Springboot启动类来构建一个SpringApplication

public SpringApplication build(String... args) {
   configureAsChildIfNecessary(args);
   this.application.addPrimarySources(this.sources);
   return this.application;
}

// 调用 return run(application); 就会帮我启动springboot应用

protected WebApplicationContext run(SpringApplication application) {
   return (WebApplicationContext) application.run();
}

它就相当于我们的：

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

在这里插入图片描述
其实这2个实现类就是帮我创建ContextLoaderListener 和DispatcherServlet。

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--全局参数：spring配置文件-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-core.xml</param-value>
</context-param>


<!--前端调度器servlet-->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--设置配置文件的路径-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <!--设置启动即加载-->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

在这里插入图片描述

萧 炎
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringBoot系列（二）--web应用之jsp篇
MaxElephant的博客
11-14 717
一、引入依赖<!--WEB支持--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency><!--jsp页面使用jstl标签--> <dependency> <groupId>javax.se
《SpringBoot篇》02.SpringBoot程序的打包与运行（jar包的运行原理）
陈老老老板的博客
09-13 4123
视频链接：黑马SpringBoot视频​ 刚开始做开发学习的小伙伴可能在有一个知识上面有错误的认知，我们天天写程序是在Idea下写的，运行也是在Idea下运行的。 ​ 但是实际开发完成后，我们的项目是不可能运行在自己的电脑上的。我们以后制作的程序是运行在专用的服务器上的，简单说就是将你做的程序放在一台独立运行的电脑上，这台电脑要比你开发使用的计算机更专业，并且安全等级各个方面要远超过你现在的电脑。这里面就存在两个过程，一个是打包的过程，另一个是运行的过程。注：​ 企业项目上线为了保障环境适配性会采用下
SpringBoot项目和传统Tomcat项目有什么区别
最新发布
m0_73410230的博客
04-30 221
总的来说，Spring Boot 通过简化配置、提供依赖管理、自动装配等功能，使得项目开发更加快速和便捷。传统的 Tomcat 项目则需要更多手动配置和管理，相对而言更为繁琐。
SpringBoot项目jar、war包启动解析
2301_76607156的博客
04-18 3134
JarLauncher会将BOOT-INF/classes下的类文件和BOOT-INF/lib下依赖的jar加入到classpath下，然后调用META-INF/MANIFEST.MF文件Start-Class属性完成应用程序的启动。按照java官方文档规定，java -jar命令引导的具体启动类必须配置在MANIFEST.MF中的Main-class属性中，该值代表应用程序执行入口类也就是包含main方法的类。，然后将war包放入Web服务器下，Web服务器通过回调引导应用启动类方法启动应用。
给你的SpringBoot工程打的jar包瘦瘦身
弹指天下
05-31 9653
Spring boot默认方式打包，由于打的是全量依赖包（也称为fat包），不但打包慢，体积大，传输也慢，今天教大家给spring boot瘦瘦身。 背景 现在微服务架构越来越流行，一个项目10多个基于spring boot的服务模块很常见。假设一个服务模块打成jar包是100M，那么一次全量发布可能就需要上传1G的文件。在网络情况好的时候可能还没多大感觉，但如果是代码需要拷贝到内网发布，或者上传到某些国外服务器上, 将严重影响工作效率。 那么，有没有什么办法给我们打的spring boot的jar包瘦.
springboot部署到服务器 启动_超详细-腾讯云服务器(CentOS7)部署一个简单的springboot应用且公网可以访问...
weixin_39695374的博客
11-20 1661
本文默认读者有一定linux基础。如果不会，就看得很费劲。准备工作：1.一个springboot jar包2.上传jar包到腾讯云服务器的工具，如WinSCP（没有请自己下载安装）3.登录腾讯云服务器终端的工具如xshell(没有请自己下载安装。可选，腾讯云服务器有提供web终端，可以在web终端输入命令进行操作)主要步骤：1.腾讯云服务器安装jdk2.准备springboot jar包2.上传j...
SpringBoot打成jar包方式和注意事项
david2000999的博客
10-22 1493
springboot的打包方式有很多种。有打成war的，有打成jar的，也有直接提交到github，通过jekins进行打包部署的。这里主要介绍如何打成jar进行部署。 不推荐用war，因为springboot适合前后端分离，打成jar进行部署更合适。 首先需要在application.properties当中配置端口 server.port=8080 # http://localhost:8088/swagger-ui.html marven的配置文件 <?xml version="1.0" en
SpringBoot如何取消内置Tomcat启动并改用外接Tomcat
08-25
SpringBoot如何取消内置Tomcat启动并改用外接Tomcat SpringBoot框架默认情况下会将Tomcat作为内置容器，然而在某些情况下，我们需要取消内置Tomcat启动并改用外接Tomcat。那么，如何实现这一点呢？下面我们将通过...
SpringBoot启动后启动内嵌浏览器的方法
08-25
本文详细介绍了 SpringBoot 启动后启动内嵌浏览器的方法，提供了详细的示例代码和解决问题的方法。通过这篇文章，我们可以轻松地在 SpringBoot 应用程序中启动内嵌浏览器，并实现自动跳转到指定页面的功能。
Spring Boot启动过程（五）之Springboot内嵌Tomcat对象的start教程详解
08-30
Spring Boot启动过程（五）之Springboot内嵌Tomcat对象的start教程详解 Spring Boot启动过程（五）之Springboot内嵌Tomcat对象的start教程详解是Spring Boot启动过程的重要组件之一，本文将详细介绍Springboot内嵌...
Spring Boot启动过程（四）之Spring Boot内嵌Tomcat启动
08-30
Spring Boot启动过程（四）之Spring Boot内嵌Tomcat启动 本文主要介绍了Spring Boot启动过程（四）之Spring Boot内嵌Tomcat启动的相关知识点，用于帮助开发者更好地理解Spring Boot的启动过程。 一、...
springboot - 2.1.2realease版本jar包
01-30
springboot - 2.1.2realease版本jar包。用于maven无法联网时下载
一张图SpringBoot加载内嵌tomcat
08-01
SpringBoot启动内嵌容器，启动时自动加载tomcat原理，tomcat内嵌集成实现
SpringBoot 使用外部Tomcat方法及启动原理
m0_67403073的博客
04-25 1360
SpringBoot 使用外部Tomcat方法及启动原理 基于 SpringBoot 2.x 方法 一、必须是一个war项目，利用IDEA可以直接创建，或者是修改pom.xml文件 war 二、将内置Tomcat的作用范围修改成provided dependency> org.springframework.boot spring-boot-starter-tomcat provided 三、自定义一个类继承 SpringBootServletInitializer 重写其confi
SpringBoot项目运行jar包启动
iijik55的博客
03-29 4331
人工智能，零基础入门！http://www.captainbed.net/inner SpringBoot项目在开发中，方便快捷，有一点原因就是SpringBoot项目可以打jar包运行：把jar包直接扔服务器上，然后运行jar包就能访问项目接口了。下面介绍SpringBoot项目打jar包运行的步骤流程： 一、我们所熟悉的是在开发环境下，直接用开发工具来运行那个启动类，然后就能启动这个项目： 开发环境下启动项目 二、 SpringBoot项目打jar包方法： 【1】在cmd界面中，进入项目的本地存储.
Springboot 优雅启动-可执行jar
Mr_Wanter
12-27 1223
先贴官网：https://docs.spring.io/spring-boot/docs/current/reference/html/deployment.html#deployment.installing除了使用java -jar运行 Spring Boot 应用，制作在 Unix 系统完全可执行的应用也是可能的，这会简化常见生产环境 Spring Boot 应用的安装和管理。在 Maven 中添加以下 plugin 配置可以创建一个"完全可执行"jar：
springboot jar包启动流程
XiWangDeFengChe的博客
12-07 836
springboot jar启动原理
精尽Spring Boot源码分析 - Jar 包的启动实现
2301_79099416的博客
04-05 621
Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！
maven 外部tomcat_Spring+内嵌式tomcat启动(去XML)
weixin_39814378的博客
01-19 193
SpringBoot的Tomcat是内嵌的,SSM的话一般都是由外部Tomcat启动Apache它是会发布一个tomcat-embed版本,用于内嵌启动,我们可以用这个内嵌的版本和SSM整合,就可以做到和SpringBoot一样的效果了添加Spring以及tomcat的jar包 xsi:schemaLocation="http://maven.apache.org/PO...
springboot内嵌tomcat和外部tomcat对比
03-31
Spring Boot 内嵌 Tomcat 和外部 Tomcat 对比 Spring Boot 是一个非常方便的框架，它可以快速创建一个独立的 Spring 应用程序，并且内嵌了 Tomcat，Jetty 或者 Undertow 等 Web 容器，可以通过简单的配置来启动和停止 Web 服务器。 与外部 Tomcat 相比，Spring Boot 内嵌 Tomcat 的优点主要有以下几点： 1. 快速启动 Spring Boot 内嵌 Tomcat 可以快速启动应用程序，不需要安装和配置外部 Tomcat 服务器，这使得开发人员更加专注于应用程序开发，节省了时间和精力。 2. 简单配置 Spring Boot 内嵌 Tomcat 的配置非常简单，只需要在 application.properties 或 application.yml 配置文件中定义相关的配置参数，就可以轻松地启动和停止 Web 服务器。 3. 简化部署 使用 Spring Boot 内嵌 Tomcat 可以将应用程序打包成一个独立的可执行的 JAR 文件，这样可以方便地进行部署和维护，也可以方便地进行版本控制和升级。 4. 更好的可移植性 Spring Boot 内嵌 Tomcat 可以在不同的操作系统和环境中运行，这使得应用程序更加可移植和易于部署。 虽然 Spring Boot 内嵌 Tomcat 有很多优点，但是与外部 Tomcat 相比，还是存在一些缺点： 1. 硬件资源消耗 由于内嵌 Tomcat 需要占用一定的硬件资源，所以对于大型的应用程序来说，可能需要更多的硬件资源才能保证其正常运行。 2. 自定义性 内嵌 Tomcat 的功能相对简单，对于一些需要自定义的功能，可能需要使用外部 Tomcat 来实现。 3. 集成其他应用程序 如果需要与其他应用程序进行集成，可能需要使用外部 Tomcat 来实现。 总之，Spring Boot 内嵌 Tomcat 和外部 Tomcat 都有各自的优缺点，应该根据具体的应用场景来选择合适的方案。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值