24. Spring Boot中的内嵌服务器是什么？如何选择和配置不同的内嵌服务器（如Tomcat、Jetty、Undertow）？

Spring Boot 中的内嵌服务器指的是将 Web 服务器（如 Tomcat、Jetty、Undertow）作为应用程序的一部分打包进 JAR 文件中，使得应用能够以独立的方式运行，无需依赖外部的 Web 服务器。这种方式特别适合微服务架构和 DevOps 流程，因为它简化了应用的部署和管理。

1. Spring Boot 默认的内嵌服务器

Spring Boot 默认使用 Apache Tomcat 作为内嵌服务器。当你创建一个 Spring Boot Web 项目时，spring-boot-starter-web 依赖会自动引入 Tomcat 作为内嵌服务器。

2. 如何选择和配置不同的内嵌服务器

Spring Boot 还支持其他内嵌服务器，如 Jetty 和 Undertow。你可以根据需求选择不同的内嵌服务器，并进行配置。

2.1 使用 Tomcat（默认）

Tomcat 是 Spring Boot 的默认内嵌服务器。通常情况下，你不需要做任何额外的配置。Spring Boot 会自动配置好 Tomcat，并且你可以通过以下方式进行自定义配置。

示例：在 application.properties 中自定义 Tomcat 配置

server.port=8081
server.tomcat.max-threads=200
server.tomcat.uri-encoding=UTF-8

• server.port：配置 Tomcat 的端口号。
• server.tomcat.max-threads：配置 Tomcat 的最大线程数。
• server.tomcat.uri-encoding：配置 URI 编码。

2.2 使用 Jetty

要使用 Jetty 作为内嵌服务器，你需要排除 Tomcat 依赖，并添加 Jetty 依赖。

步骤 1：排除 Tomcat 依赖并引入 Jetty 依赖

Maven 配置：

<dependencies>
    <!-- 排除Tomcat -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    
    <!-- 引入Jetty -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
</dependencies>

Gradle 配置：

implementation('org.springframework.boot:spring-boot-starter-web') {
    exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat'
}
implementation 'org.springframework.boot:spring-boot-starter-jetty'

步骤 2：配置 Jetty

Jetty 的配置方式与 Tomcat 类似，你可以在 application.properties 或 application.yml 中配置 Jetty 参数。

示例：

server.port=8082
server.jetty.threads.max=200
server.jetty.acceptors=2

• server.port：配置 Jetty 的端口号。
• server.jetty.threads.max：配置 Jetty 的最大线程数。
• server.jetty.acceptors：配置 Jetty 的接收器数量。

2.3 使用 Undertow

与 Jetty 类似，使用 Undertow 作为内嵌服务器时，需要排除 Tomcat 依赖，并添加 Undertow 依赖。

步骤 1：排除 Tomcat 依赖并引入 Undertow 依赖

Maven 配置：

<dependencies>
    <!-- 排除Tomcat -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!-- 引入Undertow -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-undertow</artifactId>
    </dependency>
</dependencies>

Gradle 配置：

implementation('org.springframework.boot:spring-boot-starter-web') {
    exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat'
}
implementation 'org.springframework.boot:spring-boot-starter-undertow'

步骤 2：配置 Undertow

可以通过 application.properties 或 application.yml 配置 Undertow。

示例：

server.port=8083
server.undertow.threads.io=4
server.undertow.threads.worker=20

• server.port：配置 Undertow 的端口号。
• server.undertow.threads.io：配置 Undertow 的 IO 线程数。
• server.undertow.threads.worker：配置 Undertow 的工作线程数。

3. 自定义内嵌服务器配置

除了在 application.properties 或 application.yml 中配置外，你还可以通过 Java 代码进一步定制内嵌服务器的行为。

示例：自定义 Tomcat 配置

import org.apache.catalina.connector.Connector;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TomcatConfig {

    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> customizer() {
        return factory -> {
            Connector connector = new Connector(TomcatServletWebServerFactory.DEFAULT_PROTOCOL);
            connector.setPort(9090);
            factory.addAdditionalTomcatConnectors(connector);
        };
    }
}

示例：自定义 Jetty 配置

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.springframework.boot.web.embedded.jetty.JettyServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JettyConfig {

    @Bean
    public WebServerFactoryCustomizer<JettyServletWebServerFactory> customizer() {
        return factory -> {
            QueuedThreadPool threadPool = new QueuedThreadPool(200, 10, 60);
            factory.setThreadPool(threadPool);
        };
    }
}

4. 选择内嵌服务器的考虑因素

• Tomcat：默认的内嵌服务器，广泛使用，兼容性好，适合大多数应用。
• Jetty：轻量级，启动速度快，适合资源受限的环境或嵌入式应用。
• Undertow：性能高，支持非阻塞 IO 和 WebSocket，适合高并发场景。

5. 总结

• 内嵌服务器 是 Spring Boot 的一大特性，使得应用能够独立运行，无需依赖外部 Web 服务器。
• 默认内嵌服务器 是 Tomcat，但 Spring Boot 也支持 Jetty 和 Undertow，开发者可以根据需要选择合适的服务器。
• 配置和自定义：可以通过 application.properties 或 application.yml 文件进行简单配置，也可以通过 Java 代码进行更高级的定制。
• 选择合适的服务器：根据应用的具体需求，如性能、启动速度、兼容性等，选择合适的内嵌服务器。

通过灵活选择和配置内嵌服务器，Spring Boot 应用可以更好地满足不同场景下的需求。