通过代码获取Tomcat的所有参数

SE_Yang

2026-1-21

通过代码一次性获取 Tomcat 的所有核心参数（线程池、连接管理、超时、编码、性能优化等），核心逻辑是：先获取 Tomcat 底层的 Connector 和 ProtocolHandler 实例，再通过其提供的 getter 方法遍历读取所有公开参数，最终封装为统一格式返回。以下是覆盖 Spring Boot 内嵌 Tomcat 和 外置 Tomcat 的完整实现，包含参数分类、完整代码和验证方式。

核心前提

Tomcat 的参数主要分为两类：

Connector 层级：端口、编码、压缩、IP 解析等通用配置；
ProtocolHandler 层级：线程池、连接管理、超时、限流等核心业务配置（NIO 模型对应 Http11NioProtocol）。

所有参数均可通过这两个实例的 getter 方法获取，无隐藏参数（公开参数均有对应的 getter）。

一、Spring Boot 内嵌 Tomcat 场景（最全版本）

以下代码会分类获取 Tomcat 所有公开参数（线程池、连接、超时、编码、性能、限流等），并封装为结构化 JSON 返回，可直接集成到项目中：

java

运行

import org.apache.catalina.connector.Connector;
import org.apache.coyote.http11.Http11NioProtocol;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.embedded.tomcat.TomcatWebServer;
import org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

/**
 * Spring Boot 内嵌 Tomcat 获取所有核心参数（分类展示）
 */
@RestController
public class TomcatAllParamsController {

    @Autowired
    private ServletWebServerApplicationContext applicationContext;

    @GetMapping("/tomcat/allParams")
    public Map<String, Object> getAllTomcatParams() {
        // 最终返回的所有参数（按类别分组）
        Map<String, Object> allParams = new HashMap<>();
        try {
            // 1. 获取 Tomcat 核心实例
            TomcatWebServer tomcatWebServer = (TomcatWebServer) applicationContext.getWebServer();
            org.apache.catalina.Service service = tomcatWebServer.getTomcat().getService();
            // 获取默认的 HTTP Connector（8080 端口）
            Connector connector = service.getConnectors()[0];
            // 强转为 NIO 协议处理器（核心：所有参数的入口）
            Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();

            // ========== 1. 基础信息 ==========
            Map<String, Object> basicInfo = new HashMap<>();
            basicInfo.put("port", connector.getPort()); // 监听端口
            basicInfo.put("protocol", connector.getProtocol()); // 协议类型
            basicInfo.put("scheme", connector.getScheme()); // 协议方案（http/https）
            basicInfo.put("secure", connector.getSecure()); // 是否开启 HTTPS
            basicInfo.put("URIEncoding", connector.getURIEncoding()); // URI 编码
            basicInfo.put("enableLookups", connector.getEnableLookups()); // 是否反向解析 IP 主机名
            allParams.put("基础信息", basicInfo);

            // ========== 2. 线程池参数 ==========
            Map<String, Object> threadPool = new HashMap<>();
            threadPool.put("maxThreads", protocol.getMaxThreads()); // 最大工作线程数
            threadPool.put("minSpareThreads", protocol.getMinSpareThreads()); // 核心常驻线程数
            threadPool.put("acceptCount", protocol.getAcceptCount()); // 请求等待队列长度
            threadPool.put("threadPriority", protocol.getThreadPriority()); // 线程优先级（1-10）
            threadPool.put("maxIdleTime", protocol.getMaxIdleTime()); // 空闲线程超时销毁时间（ms）
            threadPool.put("daemon", protocol.isDaemon()); // 线程是否为守护线程
            allParams.put("线程池参数", threadPool);

            // ========== 3. 连接管理参数 ==========
            Map<String, Object> connection = new HashMap<>();
            connection.put("maxConnections", protocol.getMaxConnections()); // 最大并发连接数
            connection.put("maxKeepAliveRequests", protocol.getMaxKeepAliveRequests()); // 单个长连接最大请求数
            connection.put("keepAliveTimeout", protocol.getKeepAliveTimeout()); // 长连接空闲超时（ms）
            connection.put("connectionTimeout", protocol.getConnectionTimeout()); // 连接超时（ms）
            connection.put("tcpNoDelay", protocol.isTcpNoDelay()); // 是否禁用 Nagle 算法
            connection.put("soKeepAlive", protocol.isSoKeepAlive()); // 是否开启 TCP 保活
            connection.put("soLinger", protocol.getSoLinger()); // TCP 延迟关闭时间（s）
            connection.put("soTimeout", protocol.getSoTimeout()); // Socket 读取超时（ms）
            connection.put("reuseAddress", protocol.isReuseAddress()); // 是否复用端口
            allParams.put("连接管理参数", connection);

            // ========== 4. 压缩参数 ==========
            Map<String, Object> compression = new HashMap<>();
            compression.put("compression", connector.getCompression()); // 压缩模式（on/off/force）
            compression.put("compressionMinSize", connector.getCompressionMinSize()); // 触发压缩的最小响应大小（字节）
            compression.put("compressibleMimeTypes", connector.getCompressibleMimeTypes()); // 可压缩的 MIME 类型
            allParams.put("压缩参数", compression);

            // ========== 5. 限流参数 ==========
            Map<String, Object> limit = new HashMap<>();
            limit.put("limitRequestLine", protocol.getLimitRequestLine()); // 请求行最大长度
            limit.put("limitRequestFields", protocol.getLimitRequestFields()); // 请求头字段最大个数
            limit.put("limitRequestFieldSize", protocol.getLimitRequestFieldSize()); // 请求头字段最大长度
            limit.put("limitRequestParams", protocol.getLimitRequestParams()); // 请求参数最大个数
            allParams.put("限流参数", limit);

            // ========== 6. SSL 参数（若开启 HTTPS） ==========
            Map<String, Object> ssl = new HashMap<>();
            ssl.put("sslEnabled", connector.getSslEnabled()); // 是否开启 SSL
            ssl.put("sslProtocol", protocol.getSslProtocol()); // SSL 协议版本
            allParams.put("SSL 参数", ssl);

            // ========== 7. 性能优化参数 ==========
            Map<String, Object> performance = new HashMap<>();
            performance.put("acceptorThreadCount", protocol.getAcceptorThreadCount()); // 接受连接的线程数
            performance.put("pollerThreadCount", protocol.getPollerThreadCount()); // NIO 轮询线程数
            performance.put("selectorTimeout", protocol.getSelectorTimeout()); // 选择器超时（ms）
            allParams.put("性能优化参数", performance);

        } catch (Exception e) {
            allParams.put("错误信息", "获取参数失败：" + e.getMessage());
            e.printStackTrace();
        }
        return allParams;
    }
}

测试访问

启动 Spring Boot 应用后，访问 http://localhost:8080/tomcat/allParams，返回示例（结构化 JSON）：

json

{
  "基础信息": {
    "port": 8080,
    "protocol": "org.apache.coyote.http11.Http11NioProtocol",
    "URIEncoding": "UTF-8",
    "enableLookups": false
  },
  "线程池参数": {
    "maxThreads": 800,
    "minSpareThreads": 50,
    "acceptCount": 500
  },
  "连接管理参数": {
    "maxConnections": 20000,
    "keepAliveTimeout": 30000,
    "connectionTimeout": 30000
  },
  "压缩参数": {
    "compression": "on",
    "compressionMinSize": 2048
  }
}

二、外置 Tomcat 场景（WAR 包部署）

以下代码适配外置 Tomcat，可获取所有参数并返回结构化 JSON，需注意依赖和包名适配：

步骤 1：添加依赖（仅编译时）

xml

<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-catalina</artifactId>
    <version>9.0.80</version> <!-- 与你的 Tomcat 版本一致 -->
    <scope>provided</scope>
</dependency>
<!-- 用于 JSON 格式化（可选） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.32</version>
</dependency>

步骤 2：编写 Servlet 获取所有参数

java

运行

import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardServer;
import org.apache.coyote.http11.Http11NioProtocol;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

/**
 * 外置 Tomcat 获取所有核心参数
 */
@WebServlet("/tomcat/allParams")
public class TomcatAllParamsServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("application/json;charset=UTF-8");
        PrintWriter out = response.getWriter();
        Map<String, Object> allParams = new HashMap<>();

        try {
            // 1. 获取 Tomcat StandardServer 实例
            StandardServer server = (StandardServer) getServletContext()
                    .getAttribute("org.apache.catalina.core.StandardServer.INSTANCE");
            // 2. 获取默认 Service（Catalina）
            org.apache.catalina.Service service = server.findService("Catalina");
            
            // 3. 筛选 8080 端口的 HTTP Connector（排除 AJP 连接器）
            Connector connector = null;
            for (Connector c : service.getConnectors()) {
                if (c.getPort() == 8080 && c.getProtocolHandler() instanceof Http11NioProtocol) {
                    connector = c;
                    break;
                }
            }
            if (connector == null) {
                allParams.put("错误", "未找到 8080 端口的 HTTP Connector");
                out.write(com.alibaba.fastjson.JSON.toJSONString(allParams));
                return;
            }

            // 4. 获取协议处理器并读取所有参数
            Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();

            // ========== 分类封装参数（和 Spring Boot 一致） ==========
            // 基础信息
            Map<String, Object> basicInfo = new HashMap<>();
            basicInfo.put("port", connector.getPort());
            basicInfo.put("URIEncoding", connector.getURIEncoding());
            allParams.put("基础信息", basicInfo);

            // 线程池参数
            Map<String, Object> threadPool = new HashMap<>();
            threadPool.put("maxThreads", protocol.getMaxThreads());
            threadPool.put("acceptCount", protocol.getAcceptCount());
            allParams.put("线程池参数", threadPool);

            // 连接参数、压缩参数等（参考 Spring Boot 版本补充）

        } catch (Exception e) {
            allParams.put("错误", "获取参数失败：" + e.getMessage());
            e.printStackTrace(out);
        }

        // 输出 JSON 结果
        out.write(com.alibaba.fastjson.JSON.toJSONString(allParams, true)); // true 格式化输出
        out.close();
    }
}

测试访问

将 WAR 包部署到外置 Tomcat 后，访问 http://localhost:8080/[你的应用名]/tomcat/allParams，即可获取所有参数的结构化 JSON。

三、Tomcat 所有参数的 Getter 方法全表

以下是 Http11NioProtocol 和 Connector 提供的所有公开 getter 方法（覆盖 99% 的常用参数），可按需扩展：

所属实例	Getter 方法	参数说明
Connector	getPort()	监听端口
Connector	getProtocol()	协议类型（如 Http11NioProtocol）
Connector	getURIEncoding()	URI 编码
Connector	getEnableLookups()	是否反向解析 IP 主机名
Connector	getCompression()	压缩模式（on/off/force）
Connector	getCompressionMinSize()	触发压缩的最小字节数
Connector	getCompressibleMimeTypes()	可压缩的 MIME 类型
Connector	getSslEnabled()	是否开启 SSL
Http11NioProtocol	getMaxThreads()	最大工作线程数
Http11NioProtocol	getMinSpareThreads()	核心常驻线程数
Http11NioProtocol	getAcceptCount()	请求等待队列长度
Http11NioProtocol	getMaxConnections()	最大并发连接数
Http11NioProtocol	getKeepAliveTimeout()	长连接空闲超时（ms）
Http11NioProtocol	getConnectionTimeout()	连接超时（ms）
Http11NioProtocol	getMaxKeepAliveRequests()	单个长连接最大请求数
Http11NioProtocol	getLimitRequestLine()	请求行最大长度
Http11NioProtocol	isTcpNoDelay()	是否禁用 Nagle 算法
Http11NioProtocol	getAcceptorThreadCount()	接受连接的线程数
Http11NioProtocol	getPollerThreadCount()	NIO 轮询线程数
Http11NioProtocol	getThreadPriority()	线程优先级（1-10）
Http11NioProtocol	getMaxIdleTime()	空闲线程超时销毁时间（ms）

四、关键注意事项

参数默认值：若配置文件中未显式配置某个参数，getter 方法会返回 Tomcat 内置默认值（如 maxThreads 默认 200）；
多 Connector 场景：若 Tomcat 配置了多个 Connector（如 8080/8443），需通过 connector.getPort() 筛选目标 Connector；
HTTPS 参数：若开启 HTTPS，可通过 connector.getSslHostConfig() 获取 SSL 相关参数（如证书路径、协议版本）；
版本兼容性：Tomcat 8/9 的 API 完全兼容，Tomcat 10 需将 javax.servlet 改为 jakarta.servlet；
参数实时性：getter 方法获取的是运行时实时值，若通过代码动态修改了参数，会立即返回新值。

总结

通过代码获取 Tomcat 所有参数的核心步骤：

获取核心实例：Spring Boot 从 ServletWebServerApplicationContext 获取，外置 Tomcat 从 StandardServer 获取；
筛选 Connector：找到目标端口的 HTTP Connector（排除 AJP 连接器）；
强转协议处理器：将 ProtocolHandler 强转为 Http11NioProtocol（NIO 模型）；
分类读取参数：通过 getter 方法按「基础、线程池、连接、压缩、限流」等类别读取所有参数；
结构化返回：封装为 JSON 格式，便于前端 / 监控系统使用。