Mit welcher Methode integriert SpringBoot Tomcat?

Spring Boot unterstützt aktuelle Mainstream-Servlet-Container, einschließlich Tomcat, Jetty und Undertow. Diese Servlet-Container können problemlos in unsere Projekte integriert werden, wodurch der Arbeitsaufwand für Entwicklung, Betrieb und Wartung reduziert wird. Herkömmliche Anwendungsentwicklung erfordert komplizierte Schritte: Tomcat-Konfiguration ändern –> Tomcat starten –> Anwendungen. Nach der Einführung von Spring Boot wird alles so einfach, dass Sie nur noch ein JAR-Paket benötigen, um es nach Belieben bereitzustellen und zu installieren.

SPI

Bevor wir den Quellcode analysieren, wollen wir zunächst den SPI-Mechanismus von Spring verstehen. Wir wissen, dass JDK eine Standard-SPI-Implementierung (ServiceLoader) bereitstellt, um die Anwendungserweiterung zu erleichtern, und Dubbo verfügt auch über eine eigene SPI. Dasselbe gilt für Spring. Es stellt uns SpringFactoriesLoader zur Verfügung, der es Entwicklern ermöglicht, die Datei META-INF/spring.factories zu erweitern. Hier ist ein Beispiel zum leichteren Verständnis SpringFactoriesLoader，允许开发人员通过META-INF/spring.factories文件进行扩展，下面举一个例子方便理解

假如，我想要往 spring 容器中添加一个ApplicationContextInitializer做一些初始化工作，我们可以借助 spring 提供的这个 SPI 功能完成这个需求。

首先，在项目中创建META-INF/spring.factories文件，文件内容如下所示：

org.springframework.context.ApplicationContextInitializer=

我们再写个 test case，便可以通过 SPI 的方式获取我们定义的ApplicationContextInitializer。看似很简单的一个功能，但是 spring boot 正是利用这个强大的扩展点，在 spring framework 的基础上为我们集成了常用的开源框架

@Test
public void testSpringSpi() {
    List<ApplicationListener> listeners = SpringFactoriesLoader.loadFactories( ApplicationListener.class, 
            ClassUtils.getDefaultClassLoader() );
    System.out.println( listeners );

我们再来看看这个SpringFactoriesLoader，关键代码如下所示，它通过读取META-INF/spring.factories文件，并且查找方法参数指定的 class，然后创建对应的实例对象，并且返回。此外，还支持排序，可以使用以下几种方式进行排序

• org.springframework.core.Ordered：实现该接口

• org.springframework.core.annotation.Order：注解

• javax.annotation.Priority：注解

public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
    List<String> factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
    List<T> result = new ArrayList<T>(factoryNames.size());
    for (String factoryName : factoryNames) {
        result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
    }
    AnnotationAwareOrderComparator.sort(result);
    return result;

接下来，我们来分析下 spring boot 是如何利用 SPI 机制集成 tomcat

SpringBoot for Tomcat

在分析 tomcat 集成的源码之前，我们先来了解下 EmbeddedServletContainer

EmbeddedServletContainer：

spring 用EmbeddedServletContainer封装了内嵌的 servlet 容器，提供了start、stop等接口用于控制容器的生命周期，并且 spring 内置了 tomcat、jetty、undertow 容器的实现，类图所下所示

我们再来看看 spring boot 中最常用的SpringBootApplication注解，原来是多个注解的综合体，而这个EnableAutoConfiguration便是 spring boot 用做自动化配置的注解

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    // code......

我们在spring-boot-autoconfigure模块可以看到大量的 SPI 配置，部分如下所示

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,

原来EnableAutoConfiguration注解引入了EmbeddedServletContainerAutoConfiguration，而这个便是内嵌 servlet 容器的配置类，tomcat、jetty、undertow 都在这个类上面，通过@ConditionalOnClass注解加载不同的 servlet 容器。但是，这个类仅仅是注册了TomcatEmbeddedServletContainerFactory，不足以帮助我们解除所有的困惑。不要急，我们先来看看TomcatEmbeddedServletContainerFactory的类图。

由上面的类图可知，它实现了以下接口：

• EmbeddedServletContainerFactory：它是一个工厂模式，用于创建EmbeddedServletContainer，即用于创建一个内嵌的 Servlet 容器，这个接口里面只有一个getEmbeddedServletContainer方法

• ConfigurableEmbeddedServletContainer：用于配置EmbeddedServletContainer，比如说端口、上下文路径等

分析了上面两个接口，原来创建 servlet 容器的工作是由EmbeddedServletContainerFactory完成的，看下getEmbeddedServletContainer方法的调用栈。在EmbeddedWebApplicationContext中重写了GenericWebApplicationContext#onRefresh()方法，并且调用getEmbeddedServletContainer

Wenn ich dem Spring-Container einen ApplicationContextInitializer hinzufügen möchte, um einige Initialisierungsarbeiten durchzuführen, können wir die von Spring bereitgestellte SPI-Funktion verwenden, um diese Anforderung zu erfüllen.

Erstellen Sie zunächst die Datei META-INF/spring.factories im Projekt. Der Dateiinhalt lautet wie folgt:

org.springframework.context.ApplicationContextInitializer=🎜

🎜us Indem wir einen weiteren Testfall schreiben, können wir den ApplicationContextInitializer erhalten, den wir über SPI definiert haben. Es scheint eine sehr einfache Funktion zu sein, aber Spring Boot nutzt diesen leistungsstarken Erweiterungspunkt, um häufig verwendete Open-Source-Frameworks für uns auf der Basis des Spring Frameworks zu integrieren🎜

EmbeddedWebApplicationContext.java
@Override
protected void onRefresh() {
    super.onRefresh();
    createEmbeddedServletContainer();
}
private void createEmbeddedServletContainer() {
    EmbeddedServletContainer localContainer = this.embeddedServletContainer;
    ServletContext localServletContext = getServletContext();
    if (localContainer == null && localServletContext == null) {
        // 从容器中获取bean，如果使用tomcat则返回TomcatEmbeddedServletContainerFactory
        EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
        this.embeddedServletContainer = containerFactory.getEmbeddedServletContainer(getSelfInitializer());
    }
    else if (localServletContext != null) {
        getSelfInitializer().onStartup(localServletContext);
    }
    initPropertySources();

🎜Werfen wir einen Blick auf diesen SpringFactoriesLoader</code > lautet der Schlüsselcode wie folgt: Er liest die Datei <code>META-INF/spring.factories, findet die durch den Methodenparameter angegebene Klasse, erstellt dann das entsprechende Instanzobjekt und gibt es zurück. Darüber hinaus wird auch das Sortieren unterstützt und kann auf folgende Arten sortiert werden🎜

• 🎜org.springframework.core.Ordered: Implementieren Sie diese Schnittstelle🎜
• 🎜org.springframework.core.annotation.Order: Annotation🎜
• 🎜javax.annotation.Priority: Annotation🎜

TomcatEmbeddedServletContainerFactory.java
@Override
public EmbeddedServletContainer getEmbeddedServletContainer(
        ServletContextInitializer... initializers) {
    Tomcat tomcat = new Tomcat();   // 实例化 apache Tomcat 
    File baseDir = (this.baseDirectory != null ? this.baseDirectory
            : createTempDir("tomcat"));
    tomcat.setBaseDir(baseDir.getAbsolutePath());
    // 创建 Connector 组件，默认使用org.apache.coyote.http11.Http11NioProtocol
    Connector connector = new Connector(this.protocol); 
    tomcat.getService().addConnector(connector);
    // 支持对 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 getTomcatEmbeddedServletContainer(tomcat);

🎜Als nächstes analysieren wir, wie Spring Boot funktioniert SPI-Mechanismus zur Integration von Tomcat🎜🎜SpringBoot für Tomcat🎜🎜Bevor wir den Quellcode der Tomcat-Integration analysieren, wollen wir zunächst den EmbeddedServletContainer🎜🎜EmbeddedServletContainer verstehen: 🎜🎜spring verwendet EmbeddedServletContainer, um den eingebetteten Servlet-Container zu kapseln Schnittstellen wie start und stop zur Steuerung des Lebenszyklus des Containers, und Spring verfügt über integrierte Implementierungen von Tomcat-, Jetty- und Undertow-Containern, wie in der Klasse gezeigt Diagramm 🎜🎜 Schauen wir uns die am häufigsten verwendete SpringBootApplication-Annotation in Spring Boot an. Es stellt sich heraus, dass es sich um einen Komplex aus mehreren Annotationen handelt, und diese EnableAutoConfiguration ist die verwendete Annotation von Spring Boot für die automatisierte Konfiguration🎜

public TomcatEmbeddedServletContainer(Tomcat tomcat, boolean autoStart) {
    Assert.notNull(tomcat, "Tomcat Server must not be null");
    this.tomcat = tomcat;
    this.autoStart = autoStart;
    initialize();
}
private void initialize() throws EmbeddedServletContainerException {
    synchronized (this.monitor) {
        addInstanceIdToEngineName();
        // Remove service connectors to that protocol binding doesn't happen yet
        removeServiceConnectors();
        // Start the server to trigger initialization listeners
        this.tomcat.start();
        // We can re-throw failure exception directly in the main thread
        rethrowDeferredStartupExceptions();
        Context context = findContext();
        ContextBindings.bindClassLoader(context, getNamingToken(context),
                    getClass().getClassLoader());
        // Unlike Jetty, all Tomcat threads are daemon threads. We create a
        // blocking non-daemon to stop immediate shutdown
        startDaemonAwaitThread();
    }

🎜Wir können eine große Anzahl von SPI-Konfigurationen im spring-boot-autoconfigure-Modul sehen, von denen einige wie folgt lauten🎜

🎜# Automatische Konfiguration
org.springframework.boot.autoconfigure.EnableAutoConfiguration =
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,🎜

🎜Es stellt sich heraus, dass die Annotation EnableAutoConfiguration < einführt code>EmbeddedServletContainerAutoConfiguration, und dies ist eingebettet. Die Konfigurationsklassen des Servlet-Containers, einschließlich Tomcat, Jetty und Undertow, befinden sich alle in dieser Klasse. Verschiedene Servlet-Container werden über @ConditionalOnClass geladen Anmerkung. Allerdings registriert diese Klasse nur TomcatEmbeddedServletContainerFactory, was nicht ausreicht, um alle Verwirrungen zu beseitigen. Keine Sorge, werfen wir zunächst einen Blick auf das Klassendiagramm von TomcatEmbeddedServletContainerFactory. 🎜🎜Wie aus dem obigen Klassendiagramm ersichtlich ist, implementiert es die folgende Schnittstelle: 🎜

• 🎜EmbeddedServletContainerFactory: Es handelt sich um ein Factory-Muster, das zum Erstellen von EmbeddedServletContainer< verwendet wird /code >, der zum Erstellen eines eingebetteten Servlet-Containers verwendet wird. Es gibt nur eine <code>getEmbeddedServletContainer-Methode in dieser Schnittstelle🎜
• 🎜ConfigurableEmbeddedServletContainer: wird zum Konfigurieren von EmbeddedServletContainer</ verwendet. code>Zum Beispiel Ports, Kontextpfade usw. 🎜</li></ul>🎜 Nach der Analyse der beiden oben genannten Schnittstellen stellt sich heraus, dass die Arbeit zum Erstellen eines Servlet-Containers durch <code>EmbeddedServletContainerFactory</ abgeschlossen wird code>. Schauen Sie sich <code>getEmbeddedServletContainer< /code>Die Aufrufliste der Methode an. Die Methode <code>GenericWebApplicationContext#onRefresh() wird in EmbeddedWebApplicationContext umgeschrieben und die Methode getEmbeddedServletContainer wird aufgerufen, um einen Servlet-Container zu erstellen. Wir werden diese Erstellung analysieren als nächstes verarbeiten. 🎜🎜Der Schlüsselcode lautet wie folgt (Ausnahmebehandlung weggelassen): 🎜rrreee🎜Zeichnen wir zuerst das Hauptflussdiagramm🎜

  

  由上图可知，EmbeddedWebApplicationContext在执行onRefresh方法的时候，首先调用父类的onRefresh，然后从容器中获取EmbeddedServletContainerFactory的实现类。由于我们在 classpath 下面可以获取 tomcat 的 jar 包，因此EmbeddedServletContainerAutoConfiguration会在 spring 容器中注册TomcatEmbeddedServletContainerFactory这个 bean。然后，由它创建TomcatEmbeddedServletContainer，我们来看看具体的创建过程，代码如下所示：

  TomcatEmbeddedServletContainerFactory.java
  @Override
  public EmbeddedServletContainer getEmbeddedServletContainer(
          ServletContextInitializer... initializers) {
      Tomcat tomcat = new Tomcat();   // 实例化 apache Tomcat 
      File baseDir = (this.baseDirectory != null ? this.baseDirectory
              : createTempDir("tomcat"));
      tomcat.setBaseDir(baseDir.getAbsolutePath());
      // 创建 Connector 组件，默认使用org.apache.coyote.http11.Http11NioProtocol
      Connector connector = new Connector(this.protocol); 
      tomcat.getService().addConnector(connector);
      // 支持对 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 getTomcatEmbeddedServletContainer(tomcat);

  首先是实例化Tomcat对象，然后创建Connector组件，并且对Connector进行相关的参数设置，同时也允许我们通过TomcatConnectorCustomizer接口进行自定义的设置。OK，创建了Tomcat实例之后，需要创建TomcatEmbeddedServletContainer，它依赖Tomcat对象，在构造方法中便会启动 Tomcat 容器，从而完成各个组件的启动流程

  public TomcatEmbeddedServletContainer(Tomcat tomcat, boolean autoStart) {
      Assert.notNull(tomcat, "Tomcat Server must not be null");
      this.tomcat = tomcat;
      this.autoStart = autoStart;
      initialize();
  }
  private void initialize() throws EmbeddedServletContainerException {
      synchronized (this.monitor) {
          addInstanceIdToEngineName();
          // Remove service connectors to that protocol binding doesn't happen yet
          removeServiceConnectors();
          // Start the server to trigger initialization listeners
          this.tomcat.start();
          // We can re-throw failure exception directly in the main thread
          rethrowDeferredStartupExceptions();
          Context context = findContext();
          ContextBindings.bindClassLoader(context, getNamingToken(context),
                      getClass().getClassLoader());
          // Unlike Jetty, all Tomcat threads are daemon threads. We create a
          // blocking non-daemon to stop immediate shutdown
          startDaemonAwaitThread();
      }

  Das obige ist der detaillierte Inhalt vonMit welcher Methode integriert SpringBoot Tomcat?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!