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.
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
在分析 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
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();
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🎜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);
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(); }
spring-boot-autoconfigure
-Modul sehen, von denen einige wie folgt lauten🎜🎜# Automatische Konfiguration🎜Es stellt sich heraus, dass die Annotation
org.springframework.boot.autoconfigure.EnableAutoConfiguration =
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,🎜
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: 🎜EmbeddedServletContainer< verwendet wird /code >, der zum Erstellen eines eingebetteten Servlet-Containers verwendet wird. Es gibt nur eine <code>getEmbeddedServletContainer
-Methode in dieser Schnittstelle🎜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!