SpringBoot WebServer启动与监听器原理深度解析

薪火铺子2026-05-02 12:59

SpringBoot WebServer启动与监听器原理深度解析

目录

  1. 引言
  2. WebServerFactory接口体系
  3. WebServer初始化完整时序
  4. Tomcat核心组件架构
  5. Undertow与Jetty架构对比
  6. WebServerManager生命周期管理
  7. WebServerInitializedEvent事件机制
  8. 端口配置与多服务器
  9. SSL/TLS与HTTP2配置
  10. Tomcat线程模型与优化
  11. 健康检查与优雅关闭
  12. 自定义WebServerFactoryCustomizer
  13. 实战：动态调整服务器配置
  14. 总结

引言

Spring Boot的嵌入式Web服务器是其最核心的特性之一。从Tomcat到Undertow、Jetty，Spring Boot通过抽象的工厂接口体系，让开发者可以无缝切换不同的Web服务器实现。

本文将从源码层面深入剖析WebServer的启动流程、组件架构、事件机制，以及如何在生产环境中进行深度定制和优化。

1. WebServerFactory接口体系

1.1 接口层次结构

<<interface>>
WebServerFactory
+setTempDir(Path tempDir)
<<interface>>
ConfigurableWebServerFactory
+setPort(int port)
+setAddress(InetAddress address)
+setSsl(Ssl ssl)
+setHttp2(Http2 http2)
+setCompression(Compression compression)
+addInitializers(ServletContextInitializer... initializers)
<<abstract>>
AbstractConfigurableWebServerFactory
-int port
-InetAddress address
-Ssl ssl
-Http2 http2
-Compression compression
+getPort() : int
+getAddress() : InetAddress
TomcatServletWebServerFactory
-Tomcat tomcat
-int backgroundProcessorDelay
-List<Valve> engineValves
-List<TomcatContextCustomizer> contextCustomizers
+getWebServer(ServletContextInitializer...) : WebServer
+addConnectorCustomizers(ConnectorCustomizer...)
+addAdditionalTomcatConnectors(Connector...)
JettyServletWebServerFactory
-Server server
-List<JettyServerCustomizer> serverCustomizers
-int acceptors
-int selectors
+getWebServer(ServletContextInitializer...) : WebServer
+addServerCustomizers(JettyServerCustomizer...)
UndertowServletWebServerFactory
-Builder builder
-List<UndertowBuilderCustomizer> builderCustomizers
-File tempDir
+getWebServer(ServletContextInitializer...) : WebServer
+addBuilderCustomizers(UndertowBuilderCustomizer...)

1.2 WebServer接口定义

<<interface>>
WebServer
+start()
+stop()
+getPort() : int
+getAddress() : InetAddress
TomcatWebServer
-Tomcat tomcat
-boolean autoStart
-int port
+start()
+stop()
+getTomcat() : Tomcat
+getPort() : int
JettyWebServer
-Server server
-ServletContext servletContext
+start()
+stop()
+getServer() : Server
UndertowWebServer
-XnioWorker worker
-int port
-boolean running
+start()
+stop()
+getPort() : int

1.3 自动配置机制

存在 Tomcat
存在 Undertow
存在 Jetty
WebServerFactoryAutoConfiguration
检测类路径
TomcatWebServerFactoryCustomizer
UndertowWebServerFactoryCustomizer
JettyWebServerFactoryCustomizer
注册 TomcatServletWebServerFactory
注册 UndertowServletWebServerFactory
注册 JettyServletWebServerFactory
WebServerFactoryCustomizerBeanPostProcessor
beforeBeanCreation

调用 customize 方法
afterSingletonsInstantiated

创建 WebServer 实例

1.4 WebServerFactoryCustomizer接口

java 复制代码 
public interface WebServerFactoryCustomizer<T extends WebServerFactory> {
    /**
     * 自定义WebServerFactory配置
     */
    void customize(T factory);
}

TomcatWebServerFactoryCustomizer源码：

java 复制代码 
class TomcatWebServerFactoryCustomizer implements 
        WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
    
    private final Environment environment;
    
    @Override
    public void customize(TomcatServletWebServerFactory factory) {
        // 1. 配置端口
        ServerProperties.Tomcat properties = getServerProperties();
        if (!getPort().isPresent()) {
            factory.setPort(getPortValue(properties.getPort()));
        }
        
        // 2. 配置SSL
        if (properties.getSsl() != null && properties.getSsl().isEnabled()) {
            factory.setSsl(properties.getSsl());
        }
        
        // 3. 配置压缩
        if (properties.getCompression() != null) {
            factory.setCompression(properties.getCompression());
        }
        
        // 4. 配置连接器
        factory.addConnectorCustomizers(
            new TomcatConnectorCustomizer(properties)
        );
        
        // 5. 配置访问日志
        if (properties.getAccesslog().isEnabled()) {
            factory.addContextValves(createAccessLogValve(properties));
        }
    }
}

2. WebServer初始化完整时序

2.1 Spring Boot启动链路

ApplicationListener WebServer WebServerFactory WebServerManager ApplicationContext SpringApplication ApplicationListener WebServer WebServerFactory WebServerManager ApplicationContext SpringApplication ServletWebServerApplicationContext.onRefresh() publishEvent(WebServerInitializedEvent) run() → refresh(context) prepareBeanFactory() invokeBeanFactoryPostProcessors() registerBeanPostProcessors() initMessageSource() initApplicationEventMulticaster() onRefresh() onRefresh() getWebServerFactory() getWebServer(initializers) new TomcatWebServer(tomcat) webServer实例 finishBeanFactoryInitialization() finishRefresh() webServer.start() start() WebServerInitializedEvent 监听器处理

2.2 WebServerManager核心逻辑

否
是
stop
onRefresh
是否存在WebServerFactory?
创建默认Factory
获取WebServerFactory
调用customize方法
收集ServletContextInitializer
调用getWebServer方法
创建WebServer实例
finishRefresh
webServer.start
publish WebServerInitializedEvent
LifecycleProcessor处理
webServer.stop

2.3 ServletWebServerApplicationContext刷新流程

java 复制代码 
// ServletWebServerApplicationContext.java
@Override
protected void onRefresh() {
    super.onRefresh();
    
    // 1. 创建WebServer
    createWebServer();
    
    // 2. 初始化Servlet上下文
    initServletContext();
}

private void createWebServer() {
    // 1. 如果WebServer已存在，先停止
    if (this.webServer != null) {
        this.webServer.stop();
    }
    
    // 2. 获取WebServerFactory
    WebServerFactory factory = getWebServerFactory();
    
    // 3. 获取ServletContextInitializer
    ServletContextInitializer initializers = getServletContextInitializers();
    
    // 4. 创建WebServer
    this.webServer = factory.getWebServer(initializers);
    
    // 5. 注册到ServletContext
    this.webServer.getServletContext();
}

2.4 getWebServerFactory获取逻辑

java 复制代码 
private WebServerFactory getWebServerFactory() {
    // 1. 获取所有WebServerFactory类型的Bean
    List<WebServerFactory> factories = 
        getBeanFactory().getBeansOfType(WebServerFactory.class).values()
            .stream()
            .sorted(annotationAwareComparator)
            .collect(Collectors.toList());
    
    // 2. 断言至少存在一个
    Assert.state(!factories.isEmpty(), 
        "No WebServerFactory customizer has been defined. " +
        "Requires a class of type WebServerFactory.");
    
    // 3. 返回第一个（非延迟）
    return factories.get(0);
}

3. Tomcat核心组件架构

3.1 Tomcat组件层次结构

Tomcat
-Server server
-Service service
-Connector connector
-Engine engine
-Host host
-Context context
+getServer() : Server
+getService() : Service
+getConnector() : Connector
+getEngine() : Engine
<<javax.xml.server>>
Server
+getPort() : int
+await() : 监听关闭命令
Service
-String name
-Container container
-Connector[] connectors
+addConnector(Connector)
+setContainer(Container)
Connector
-String protocol
-int port
-ProtocolHandler handler
+setPort(int)
+getProtocolHandler() : ProtocolHandler
Engine
-String name
-Host defaultHost
-Realm realm
+addChild(Host)
Host
-String name
-String appBase
-Container[] children
+addContext(Context)
Context
-String path
-String docBase
-Pipeline pipeline
+addServlet(ServletWrapper)
<<interface>>
ProtocolHandler
+bind()
+start()
+stop()

3.2 Tomcat启动初始化流程

Context Host Engine Connector Tomcat实例 TomcatServletWebServerFactory Context Host Engine Connector Tomcat实例 TomcatServletWebServerFactory 创建临时目录 启动后台线程 backgroundProcessorDelay new Tomcat() setBaseDir() getConnector() new Connector(protocol) setPort(port) getHost() new StandardHost() setName(hostname) setAppBase() addChild(Host) addContext("") new StandardContext() setPath("") setDocBase() addChild(Context) start() start() start() start() start()

3.3 连接器初始化详解

HTTP/1.1
APR
AJP
Connector构造
protocol类型
Http11Protocol

NIO
Http11AprProtocol

APR/native
AjpProtocol

AJP connector
创建NioEndpoint
AprEndpoint
AjpProtocol
配置线程池
配置SSL

如果启用
Poller配置
Acceptor配置
bind端口监听

3.4 NioEndpoint线程模型

NioEndpoint
-ServerSocketChannel serverSocket
-NioSelectorPool selectorPool
-Acceptor[] acceptors
-Poller[] pollers
-Executor executor
+startAcceptorThreads()
+initServerSocket()
<<implements Runnable>>
Acceptor
-ServerSocketChannel serverSocket
+run()
+accept()
<<implements Runnable>>
Poller
-Selector selector
-Queue<SocketChannel> events
+register(socket)
+processKey()
+run()
<<implements Runnable>>
SocketProcessor
-SocketWrapper socket
+run() → process()
<<java.util.concurrent.Executor>>
Executor

3.5 三种服务器对比

特性 Tomcat Undertow Jetty
默认端口 8080 8080 8080
线程模型 BIO/NIO XNIO(NIO) NIO
内存占用 较高 较低 较低
并发性能 一般 优秀 优秀
WebSocket 支持 支持 支持
懒加载 不支持 支持 支持
启动速度 较慢 快 快
HTTP/2 需配置 原生支持 原生支持
最小依赖 ~1.5MB ~1MB ~1MB

4. Undertow与Jetty架构对比

4.1 Undertow架构

UndertowServletWebServerFactory
-Builder builder
-XnioWorker worker
-UndertowDeploymentInfo deploymentInfo
+getWebServer() : UndertowWebServer
UndertowWebServer
-XnioWorker worker
-int port
-boolean running
-CountDownLatch latch
+start()
+stop()
Builder
+addHttpListener(int port, String host)
+setServerOption(Option, Object)
+build() : XnioWorker
XnioWorker
-Selector selector
+createAcceptingChannel()
+start()
AcceptingChannel
+resumeAccepts()
+suspendAccepts()

4.2 Jetty架构

JettyServletWebServerFactory
-Server server
-QueuedThreadPool threadPool
-List<JettyServerCustomizer> customizers
-int acceptors
-int selectors
+getWebServer() : JettyWebServer
JettyWebServer
-Server server
-ServletContextHandler context
-boolean started
+start()
+stop()
Server
-ThreadPool threadPool
-Connector[] connectors
-Handler[] handlers
+addConnector(Connector)
+setHandler(Handler)
+start()
QueuedThreadPool
-int minThreads
-int maxThreads
-int queueSize
Connector
-ServerSocketChannel channel
-EndPointManager manager
ServletContextHandler
-String contextPath
-ServletHandler servletHandler
+addServlet(ServletHolder)

4.3 启动流程对比

Jetty启动流程
Server实例
ThreadPool配置
Connector配置
Handler链配置
start启动
Undertow启动流程
Builder实例
addHttpListener
setServerOption配置
XNIO Worker创建
启动AcceptingChannel
Tomcat启动流程
TOMCAT实例
设置BaseDir
创建Connector
配置Engine/Host/Context
start启动

5. WebServerManager生命周期管理

5.1 WebServerManager状态机

构造函数
onRefresh()
finishRefresh() → webServer.start()
start完成
shutdown触发
stop完成
启动异常
Created
Initialized
Starting
Started
Stopping
Stopped
Failed
容器刷新

Bean初始化完成
服务可用

接受请求
优雅关闭

处理存量请求

5.2 WebServerManager源码

java 复制代码 
class WebServerManager {
    
    private final WebServerFactory webServerFactory;
    private volatile WebServer webServer;
    private final List<ServletContextInitializer> initializers;
    
    // 容器刷新时调用
    void onRefresh() {
        // 1. 收集所有ServletContextInitializer
        this.initializers = getServletContextInitializers();
        
        // 2. 创建WebServer（不启动）
        this.webServer = this.webServerFactory.getWebServer(this.initializers);
    }
    
    // 容器刷新完成时调用
    void start() throws WebServerException {
        if (this.webServer != null) {
            synchronized (this.monitor) {
                if (this.webServer != null) {
                    this.webServer.start();
                }
            }
        }
    }
    
    // 容器关闭时调用
    void stop() throws WebServerException {
        if (this.webServer != null) {
            synchronized (this.monitor) {
                if (this.webServer != null) {
                    this.webServer.stop();
                }
            }
        }
    }
}

5.3 WebServerFactoryCustomizerBeanPostProcessor

TomcatServletWebServerFactory List<WebServerFactoryCustomizer> ConfigurableBeanFactory WebServerFactoryCustomizerBeanPostProcessor TomcatServletWebServerFactory List<WebServerFactoryCustomizer> ConfigurableBeanFactory WebServerFactoryCustomizerBeanPostProcessor loop [所有BeanPostProcessor] loop [每个WebServerFactory] 此时factory已完全配置 准备创建WebServer afterSingletonsInstantiated() 获取所有WebServerFactoryCustomizer List<WebServerFactoryCustomizer> 排序customizers 获取所有WebServerFactory Bean List<WebServerFactory> 查找对应的customizer customize(factory) 配置应用到factory

6. WebServerInitializedEvent事件机制

6.1 事件发布时机

ApplicationListener WebServerInitializedEvent LifecycleProcessor ApplicationContext ApplicationListener WebServerInitializedEvent LifecycleProcessor ApplicationContext 启动所有Lifecycle Bean 包括WebServerManager finishRefresh() initLifecycleProcessor() onRefresh() getLifecycleBeans() startBeans() WebServer启动完成 publishEvent() new WebServerInitializedEvent() 事件广播 onApplicationEvent()

6.2 事件体系结构

<<abstract>>
ApplicationEvent
-Object source
-long timestamp
WebServerInitializedEvent
-WebServer webServer
-Namespace namespace
ServletWebServerInitializedEvent
-ServletWebServer webServer
ReactiveWebServerInitializedEvent
-ReactiveWebServer webServer
TomcatWebServerInitializedEvent
+getTomcat() : Tomcat
UndertowWebServerInitializedEvent
+getUndertow() : Undertow
JettyWebServerInitializedEvent
+getJetty() : Server

6.3 事件监听器使用模式

java 复制代码 
// 模式1：通用监听器
@Component
public class GenericServerListener 
        implements ApplicationListener<WebServerInitializedEvent> {
    
    @Override
    public void onApplicationEvent(WebServerInitializedEvent event) {
        WebServer webServer = event.getWebServer();
        // 通用的服务器信息获取
        System.out.println("Server started on port: " + webServer.getPort());
    }
}

// 模式2：类型特定监听器
@Component
public class TomcatSpecificListener 
        implements ApplicationListener<TomcatWebServerInitializedEvent> {
    
    @Override
    public void onApplicationEvent(TomcatWebServerInitializedEvent event) {
        Tomcat tomcat = event.getTomcat();
        // 获取Tomcat特定信息
        MBeanRegistry.getMBeanServer();
    }
}

// 模式3：使用@EventListener
@Component
public class EventListenerExample {
    
    @EventListener
    public void onServerStart(WebServerInitializedEvent event) {
        // Spring 5.x+ 推荐方式
    }
}

6.4 与Spring Boot 1.x的差异

Spring Boot 2.x
WebServerInitializedEvent
getWebServer() 获取WebServer
泛型支持

TomcatWebServerInitializedEvent等
Spring Boot 1.x
EmbeddedServletContainerInitializedEvent
getPort() 直接返回端口
getContainer() 返回容器

7. 端口配置与多服务器

7.1 端口配置决策流程

application.yml
命令行参数
环境变量
代码设置
是
否
是
否
端口配置请求
配置来源
server.port
--server.port
SERVER_PORT
factory.setPort
值为0?
随机分配端口
使用指定端口
端口是否占用?
抛出异常

Port already in use
绑定端口成功

7.2 多端口配置

java 复制代码 
@Configuration
public class MultiPortConfiguration 
        implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
    
    @Override
    public void customize(TomcatServletWebServerFactory factory) {
        // 主连接器已在factory中配置
        
        // 添加额外的连接器（管理端口）
        Connector adminConnector = new Connector();
        adminConnector.setPort(8443);
        adminConnector.setProtocol("HTTP/1.1");
        adminConnector.setSecure(true);
        adminConnector.setScheme("https");
        
        factory.addAdditionalTomcatConnectors(adminConnector);
    }
}

7.3 Unix Socket配置

Unix Domain Socket
应用场景
Nginx反向代理

性能优化
本地进程通信

低延迟
配置步骤
创建/tmp目录
设置权限
配置server.tomcat.unix-socket

properties 复制代码 
# application.properties
server.tomcat.basedir=/tmp/tomcat
server.tomcat.unix-socket=/tmp/tomcat/app.sock

7.4 禁用服务器

禁用Web服务器
方式
spring.main.web-application-type=none
代码设置
排除自动配置
无WebServer启动
可使用

ApplicationRunner

CommandLineRunner

8. SSL/TLS与HTTP2配置

8.1 SSL配置体系

配置到Connector
配置到Protocol
Ssl
-boolean enabled
-String keyStore
-String keyStorePassword
-String keyStoreType
-String keyAlias
-String trustStore
-String trustStorePassword
-ClientAuth clientAuth
-String[] enabledProtocols
Http2
-boolean enabled
TomcatConnectorCustomizer
+customize(Connector)

8.2 SSL/TLS完整配置流程

SSLContext Connector TomcatServletWebServerFactory Ssl配置 SSLContext Connector TomcatServletWebServerFactory Ssl配置 配置ProtocolHandler SSLEnabled SSLCertificateFile SSLCertificateKeyFile setSsl(Ssl对象) customizeSsl() new Connector(protocol) 创建SSLContext load keystore load truststore setSsl(true) setSecure(true)

8.3 双向SSL配置

java 复制代码 
@Configuration
public class MutualSslConfig {
    
    @Bean
    public ConfigurableServletWebServerFactory servletWebServerFactory() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        
        Ssl ssl = new Ssl();
        ssl.setEnabled(true);
        ssl.setKeyStore("keystore.p12");
        ssl.setKeyStorePassword("changeit");
        ssl.setKeyStoreType("PKCS12");
        ssl.setTrustStore("truststore.p12");
        ssl.setTrustStorePassword("changeit");
        ssl.setClientAuth(ClientAuth.WANT);  // WANT/NEED/NONE
        
        factory.setSsl(ssl);
        return factory;
    }
}

8.4 HTTP/2配置

HTTP/2支持
HTTP/2类型
HTTP/2 over TLS

h2
HTTP/2 over TCP

h2c
需启用SSL
明文传输
配置SSL
启用ALPN
Protocol配置

Http2Protocol

properties 复制代码 
# application.properties
server.ssl.enabled=true
server.ssl.enabled-protocols=TLSv1.2,TLSv1.3
server.http2.enabled=true

9. Tomcat线程模型与优化

9.1 Tomcat线程池架构

使用线程池
线程
线程
TomcatExecutor
-int minSpareThreads
-int maxThreads
-int maxConnections
-int acceptCount
+execute(Runnable)
ThreadPoolExecutor
-BlockingQueue<Runnable> workQueue
-RejectedExecutionHandler handler
+prestartAllCoreThreads()
NioEndpoint
-Acceptor[] acceptors
-Poller[] pollers
-Executor executor
+startInternal()
Acceptor
Poller

9.2 请求处理流程

Servlet 业务线程 线程池 Poller线程 Acceptor线程 客户端 Servlet 业务线程 线程池 Poller线程 Acceptor线程 客户端 TCP连接请求 accept() 注册到Selector 建立连接 HTTP请求 select() processKey() submit(SocketProcessor) 分配线程 解析请求 调用service() 处理响应 HTTP响应

9.3 优化参数配置

性能参数
enable-lingering

延迟关闭
maxKeepAliveRequests

最大KeepAlive
keepAliveTimeout

KeepAlive超时
compression

压缩配置
线程池参数
max-threads

最大线程数
min-spare-threads

最小空闲线程
threadPriority

线程优先级
max-queue-capacity

队列容量
连接器参数
max-connections

最大连接数
accept-count

等待队列长度
connection-timeout

连接超时
max-http-header-size

最大头大小

properties 复制代码 
# 连接器优化
server.tomcat.max-connections=10000
server.tomcat.accept-count=200
server.tomcat.connection-timeout=20000
server.tomcat.max-http-header-size=65536

# 线程池优化
server.tomcat.threads.max=300
server.tomcat.threads.min-spare=20

# 性能优化
server.tomcat.max-keep-alive-requests=100
server.tomcat.keep-alive-timeout=60000
server.compression.enabled=true
server.compression.mime-types=text/html,text/xml,text/plain,text/css,application/javascript

10. 健康检查与优雅关闭

10.1 健康检查体系

<<interface>>
HealthIndicator
+health() : Health
WebServerHealthIndicator
+health() : Health
DiskSpaceHealthIndicator
+health() : Health
DataSourceHealthIndicator
+health() : Health

10.2 自定义健康检查

java 复制代码 
@Component
public class CustomHealthIndicator implements HealthIndicator {
    
    @Override
    public Health health() {
        try {
            // 执行健康检查
            boolean healthy = checkSomething();
            
            if (healthy) {
                return Health.up()
                    .withDetail("timestamp", System.currentTimeMillis())
                    .build();
            } else {
                return Health.down()
                    .withDetail("error", "检查失败原因")
                    .build();
            }
        } catch (Exception e) {
            return Health.down()
                .withException(e)
                .build();
        }
    }
    
    private boolean checkSomething() {
        // 实际检查逻辑
        return true;
    }
}

10.3 优雅关闭流程

客户端 业务线程 Connector Tomcat 操作系统 客户端 业务线程 Connector Tomcat 操作系统 停止接受新连接 loop [处理存量请求] graceful shutdown完成 SIGTERM信号 shutdown钩子触发 pause() 等待存量请求处理 继续处理请求 请求完成 stop() destroy()

10.4 优雅关闭配置

properties 复制代码 
# 优雅关闭配置
server.shutdown=graceful

# 等待时间
server.tomcat.shutdown.timeout=30s

# 等待存量请求完成
server.tomcat.connection-timeout=10s

11. 自定义WebServerFactoryCustomizer

11.1 Customizer执行时机

WebServer WebServerFactory Customizer2 Customizer1 BeanFactoryPostProcessor Spring容器启动 WebServer WebServerFactory Customizer2 Customizer1 BeanFactoryPostProcessor Spring容器启动 按@Order排序执行 执行BeanFactoryPostProcessor WebServerFactoryCustomizerBeanPostProcessor afterSingletonsInstantiated() customize(factory) afterSingletonsInstantiated() customize(factory) getWebServer()

11.2 完整Customizer示例

java 复制代码 
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class PerformanceCustomizer 
        implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
    
    @Value("${app.thread-pool.max:200}")
    private int maxThreads;
    
    @Value("${app.thread-pool.min:10}")
    private int minThreads;
    
    @Override
    public void customize(TomcatServletWebServerFactory factory) {
        // 1. 添加访问日志Valve
        factory.addContextValves(createAccessLogValve());
        
        // 2. 自定义线程池
        factory.addConnectorCustomizers(connector -> {
            ProtocolHandler handler = connector.getProtocolHandler();
            if (handler instanceof Http11NioProtocol) {
                NioEndpoint endpoint = ((Http11NioProtocol) handler).getEndpoint();
                endpoint.setMaxThreads(maxThreads);
                endpoint.setMinSpareThreads(minThreads);
            }
        });
        
        // 3. 添加额外连接器
        factory.addAdditionalTomcatConnectors(createManagementConnector());
    }
    
    private AccessLogValve createAccessLogValve() {
        AccessLogValve valve = new AccessLogValve();
        valve.setDirectory("/var/logs");
        valve.setPrefix("access");
        valve.setSuffix(".log");
        valve.setPattern("%h %l %u %t %r %s %b %D");
        return valve;
    }
    
    private Connector createManagementConnector() {
        Connector connector = new Connector();
        connector.setPort(8443);
        connector.setSecure(true);
        connector.setScheme("https");
        return connector;
    }
}

12. 实战：动态调整服务器配置

12.1 通过Actuator动态获取端口

bash 复制代码 
# 添加Actuator依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

# 暴露端点
management.endpoints.web.exposure.include=serverports,health,info
bash 复制代码 
# 获取当前端口
curl http://localhost:8080/actuator/serverports

12.2 动态端口监听器

java 复制代码 
@Component
public class DynamicPortListener {
    
    private final AtomicInteger actualPort = new AtomicInteger();
    
    @EventListener
    public void onWebServerInitialized(WebServerInitializedEvent event) {
        actualPort.set(event.getWebServer().getPort());
        System.out.println("服务器启动在端口: " + actualPort.get());
    }
    
    public int getActualPort() {
        return actualPort.get();
    }
}

12.3 动态获取服务器信息

java 复制代码 
@Service
public class ServerInfoService {
    
    @Autowired
    private ApplicationContext context;
    
    public void printServerDetails() {
        WebServerManager manager = context.getBean(WebServerManager.class);
        WebServer webServer = manager.getWebServer();
        
        if (webServer instanceof TomcatWebServer) {
            Tomcat tomcat = ((TomcatWebServer) webServer).getTomcat();
            
            for (Connector connector : tomcat.getService().findConnectors()) {
                System.out.println("协议: " + connector.getProtocolHandlerClassName());
                System.out.println("端口: " + connector.getPort());
                System.out.println("状态: " + connector.getState());
            }
        }
    }
}

总结

核心要点

接口体系设计：
WebServerFactory
ConfigurableWebServerFactory
AbstractConfigurableWebServerFactory
TomcatServletWebServerFactory
UndertowServletWebServerFactory
JettyServletWebServerFactory
TomcatWebServer
UndertowWebServer
JettyWebServer

启动流程：

  1. SpringApplication.run() → refresh(context)
  2. onRefresh() → createWebServer()
  3. WebServerFactoryCustomizer 自定义配置
  4. getWebServer() 创建服务器实例
  5. finishRefresh() → webServer.start()
  6. publishEvent(WebServerInitializedEvent)

定制方式：

  • WebServerFactoryCustomizer - 启动前自定义
  • ApplicationListener<WebServerInitializedEvent> - 启动后获取信息
  • ServletContextInitializer - Servlet上下文初始化

优化方向：

  • 线程池参数调优
  • 连接器配置优化
  • SSL/HTTP2配置
  • 优雅关闭配置
  • 健康检查指标
相关推荐
KmSH8umpK3 小时前
SpringBoot 分布式锁实战：从单机锁到Redis分布式锁全覆盖，解决超卖、重复下单、幂等并发问题
spring boot·redis·分布式
时空系3 小时前
第2篇：数据与数据类型——存储信息的小盒子 Rust中文编程
开发语言·后端·rust
SamDeepThinking4 小时前
如何让订单系统和营销系统解耦
java·后端·架构
jay神4 小时前
基于团队模式的C程序设计课程辅助教学管理系统
java·spring boot·vue·web开发·管理系统
薪火铺子4 小时前
Shiro权限框架深度解析
java·后端
1.14(java)4 小时前
Spring AOP核心概念与实战指南
java·后端·spring
jieyucx4 小时前
# Go 语言指针零基础入门详解
开发语言·后端·golang
时空系5 小时前
第3篇：数据的运算——让数据动起来 Rust中文编程
开发语言·后端·rust
Shadow（⊙ｏ⊙）5 小时前
智能指针、循环引用、锁、删除器
开发语言·c++·后端·visual studio
热门推荐
01要裂开了！ChatGPT要手机号验证了？注册Codex要求验证电话号码怎么办？2026年登陆Codex要手机号验证的解决办法02GitHub 镜像站点03裂开！ChatGPT 居然开始要手机号验证，附详细解决方法04【AI】2026 年具身智能模型和世界模型总结05Codex 接入 DeepSeek API 完整配置文档062026年4月AI大事件深度解读：大模型竞争进入“深水区“07实测可用｜小米 MiMo 百万亿 Token 免费领，开发者速冲082026年AI前瞻：量子AI、具身智能与科学发现的新纪元09零基础教你claude code 接入 deepseek V410在Windows 11上安装Docker的踩坑记录