一文带你看懂Tomcat

原创 于 2025-09-09 15:57:54 发布 · 1.2k 阅读 · 27 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#tomcat #java

Tomcat技术详解

目录

Tomcat简介

什么是Tomcat

Apache Tomcat是一个开源的Java Servlet容器，实现了Java Servlet、JavaServer Pages (JSP)、Java Expression Language (EL)和WebSocket技术规范。它是Apache软件基金会的一个项目，是目前最流行的Java Web应用服务器之一。

核心特性

  • Servlet容器：完全实现Java Servlet 4.0规范
  • JSP支持：支持JavaServer Pages 2.3规范
  • 轻量级：相比完整的应用服务器，Tomcat更加轻量
  • 可扩展性：支持集群和负载均衡
  • 跨平台：支持Windows、Linux、macOS等操作系统
  • 开源免费：Apache许可证，完全免费使用

版本历史

版本发布时间Java版本Servlet规范JSP规范重要特性
10.x2021Java 8+5.03.0Jakarta EE
9.x2017Java 8+4.02.3HTTP/2支持
8.x2014Java 7+3.12.3WebSocket
7.x2011Java 6+3.02.2注解支持

Tomcat架构

整体架构

层次结构图
Tomcat Server
├── Service 1
│   ├── Connector (HTTP:8080)
│   ├── Connector (AJP:8009)
│   └── Engine
│       ├── Host (localhost)
│       │   ├── Context (/app1)
│       │   ├── Context (/app2)
│       │   └── Context (/manager)
│       └── Host (example.com)
│           └── Context (/)
└── Service 2 (可选)
    ├── Connector (HTTPS:8443)
    └── Engine
        └── Host (secure.example.com)
请求处理流程图
Web应用
Tomcat Server
Servlet
Connector
Engine
Host
Context
Wrapper
客户端请求
响应

核心组件

组件作用说明包含关系
ServerTomcat的顶级组件代表整个Tomcat实例，负责启动和关闭整个服务器包含一个或多个Service
Service服务组件将Connector和Engine关联起来，提供完整的服务包含多个Connector和一个Engine
Engine请求处理引擎接收来自Connector的请求，进行路由和处理包含一个或多个Host
Host虚拟主机代表一个域名，处理特定域名的请求包含一个或多个Context
ContextWeb应用上下文对应一个Web应用程序，管理应用的生命周期包含多个Wrapper
Connector连接器处理客户端连接，支持多种协议独立组件，与Engine配合工作
Wrapper包装器包装单个Servlet，管理Servlet的生命周期被Context包含

组件详细说明

Server（服务器）
  • 职责：Tomcat的顶级容器，管理整个服务器的生命周期
  • 配置：在 server.xml的根元素中定义
  • 端口：默认监听8005端口用于关闭命令
Service（服务）
  • 职责：将Connector和Engine组合成完整的服务
  • 特点：一个Server可以包含多个Service
  • 配置：在 server.xml中通过 <Service>元素定义
Engine（引擎）
  • 职责：请求处理的核心，负责请求路由和响应生成
  • 特点：每个Service只能有一个Engine
  • 配置：通过 defaultHost属性指定默认主机
Host（虚拟主机）
  • 职责：处理特定域名的请求
  • 特点：支持多个虚拟主机，通过域名区分
  • 配置：通过 appBase属性指定应用部署目录
Context（应用上下文）
  • 职责：管理单个Web应用的生命周期
  • 特点：每个Context对应一个Web应用
  • 配置：可以独立配置，支持热部署
Connector（连接器）
  • 职责：处理客户端连接，支持多种协议
  • 协议：HTTP/1.1、HTTP/2、AJP、HTTPS
  • 配置：可以配置多个Connector监听不同端口

Tomcat安装与配置

安装方式

1. 二进制安装
# 下载Tomcat
wget https://archive.apache.org/dist/tomcat/tomcat-9/v9.0.xx/bin/apache-tomcat-9.0.xx.tar.gz

# 解压
tar -xzf apache-tomcat-9.0.xx.tar.gz

# 移动到目标目录
sudo mv apache-tomcat-9.0.xx /opt/tomcat

# 设置权限
sudo chown -R tomcat:tomcat /opt/tomcat
sudo chmod +x /opt/tomcat/bin/*.sh
2. 包管理器安装
# Ubuntu/Debian
sudo apt-get install tomcat9

# CentOS/RHEL
sudo yum install tomcat

# 使用systemd管理
sudo systemctl start tomcat
sudo systemctl enable tomcat
3. Docker安装
# Dockerfile
FROM tomcat:9.0-jdk11-openjdk
COPY myapp.war /usr/local/tomcat/webapps/
EXPOSE 8080

# 运行容器
docker run -d -p 8080:8080 --name my-tomcat tomcat:9.0

目录结构

tomcat/
├── bin/                    # 可执行文件
│   ├── startup.sh         # 启动脚本
│   ├── shutdown.sh        # 关闭脚本
│   ├── catalina.sh        # 核心脚本
│   └── setenv.sh          # 环境变量设置
├── conf/                  # 配置文件
│   ├── server.xml         # 主配置文件
│   ├── web.xml            # 全局Web配置
│   ├── context.xml        # 上下文配置
│   └── logging.properties # 日志配置
├── lib/                   # 共享库文件
├── logs/                  # 日志文件
│   ├── catalina.out       # 控制台输出
│   ├── localhost.log      # 应用日志
│   └── manager.log        # 管理日志
├── temp/                  # 临时文件
├── webapps/               # Web应用目录
│   ├── ROOT/              # 根应用
│   ├── manager/           # 管理应用
│   └── host-manager/      # 主机管理
└── work/                  # 工作目录

Tomcat使用方式

基本操作

1. 启动Tomcat
# 方式1：使用startup脚本
./bin/startup.sh

# 方式2：使用catalina脚本
./bin/catalina.sh start

# 方式3：后台启动
nohup ./bin/startup.sh &

# 方式4：使用systemd（如果已安装为服务）
sudo systemctl start tomcat
2. 停止Tomcat
# 方式1：使用shutdown脚本
./bin/shutdown.sh

# 方式2：使用catalina脚本
./bin/catalina.sh stop

# 方式3：强制停止
./bin/catalina.sh stop -force

# 方式4：使用systemd
sudo systemctl stop tomcat
3. 重启Tomcat
# 方式1：先停止再启动
./bin/shutdown.sh && ./bin/startup.sh

# 方式2：使用catalina脚本
./bin/catalina.sh restart

# 方式3：使用systemd
sudo systemctl restart tomcat

部署Web应用

1. 静态部署
# 将WAR文件复制到webapps目录
cp myapp.war /opt/tomcat/webapps/

# 或者解压到目录
mkdir /opt/tomcat/webapps/myapp
unzip myapp.war -d /opt/tomcat/webapps/myapp/
2. 动态部署
# 使用Tomcat Manager
curl -X PUT "http://localhost:8080/manager/text/deploy?path=/myapp" \
     -F "deploy=@myapp.war"

# 使用Tomcat Manager Web界面
# 访问 http://localhost:8080/manager/html
3. 热部署
<!-- 在server.xml中配置 -->
<Context path="/myapp" docBase="/path/to/myapp" reloadable="true" />

配置文件管理

server.xml配置示例
<?xml version="1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
    <Service name="Catalina">
        <!-- HTTP连接器 -->
        <Connector port="8080" 
                   protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443"
                   maxThreads="200"
                   minSpareThreads="10"
                   maxSpareThreads="50"
                   acceptCount="100" />
      
        <!-- AJP连接器 -->
        <Connector port="8009" 
                   protocol="AJP/1.3"
                   redirectPort="8443" />
      
        <!-- 引擎 -->
        <Engine name="Catalina" defaultHost="localhost">
            <Host name="localhost" 
                  appBase="webapps"
                  unpackWARs="true"
                  autoDeploy="true">
                <Context path="/myapp" 
                         docBase="/path/to/myapp" 
                         reloadable="true" />
            </Host>
        </Engine>
    </Service>
</Server>

Tomcat参数调优

JVM参数调优

1. 内存设置
# 在setenv.sh中设置
export CATALINA_OPTS="$CATALINA_OPTS -Xms2g -Xmx4g"
export CATALINA_OPTS="$CATALINA_OPTS -XX:MetaspaceSize=256m"
export CATALINA_OPTS="$CATALINA_OPTS -XX:MaxMetaspaceSize=512m"
2. 垃圾回收优化
# G1垃圾回收器
export CATALINA_OPTS="$CATALINA_OPTS -XX:+UseG1GC"
export CATALINA_OPTS="$CATALINA_OPTS -XX:MaxGCPauseMillis=200"
export CATALINA_OPTS="$CATALINA_OPTS -XX:G1HeapRegionSize=16m"

# 或者使用Parallel GC
export CATALINA_OPTS="$CATALINA_OPTS -XX:+UseParallelGC"
export CATALINA_OPTS="$CATALINA_OPTS -XX:ParallelGCThreads=4"
3. 性能监控
# 启用JMX监控
export CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote"
export CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote.port=9999"
export CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote.authenticate=false"
export CATALINA_OPTS="$CATALINA_OPTS -Dcom.sun.management.jmxremote.ssl=false"

连接器参数调优

1. HTTP连接器优化
<Connector port="8080" 
           protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           maxThreads="200"           <!-- 最大工作线程数 -->
           minSpareThreads="10"       <!-- 最小空闲线程数 -->
           maxSpareThreads="50"       <!-- 最大空闲线程数 -->
           acceptCount="100"          <!-- 等待队列长度 -->
           maxConnections="8192"      <!-- 最大连接数 -->
           compression="on"           <!-- 启用压缩 -->
           compressionMinSize="2048"  <!-- 压缩最小大小 -->
           compressableMimeType="text/html,text/xml,text/plain,text/css,text/javascript,application/javascript,application/json"
           enableLookups="false"      <!-- 禁用DNS查询 -->
           URIEncoding="UTF-8" />     <!-- URI编码 -->
2. NIO连接器配置
<Connector port="8080" 
           protocol="org.apache.coyote.http11.Http11NioProtocol"
           connectionTimeout="20000"
           maxThreads="200"
           minSpareThreads="10"
           maxSpareThreads="50"
           acceptCount="100"
           maxConnections="8192"
           acceptorThreadCount="2"    <!-- 接收线程数 -->
           pollerThreadCount="2"      <!-- 轮询线程数 -->
           selectorTimeout="1000" />  <!-- 选择器超时 -->

应用级优化

1. 会话管理优化
<!-- 在context.xml中配置 -->
<Context>
    <Manager className="org.apache.catalina.session.StandardManager"
             maxActiveSessions="1000"
             maxInactiveInterval="1800"
             sessionIdLength="32" />
</Context>
2. 静态资源优化
<!-- 在web.xml中配置 -->
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.css</url-pattern>
</servlet-mapping>

<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.js</url-pattern>
</servlet-mapping>

与其他容器对比

主流Java应用服务器对比

特性TomcatJettyUndertowWildFlyWebLogic
类型Servlet容器Servlet容器Servlet容器完整应用服务器商业应用服务器
大小轻量级极轻量级轻量级重量级重量级
启动速度快很快很快慢很慢
内存占用中等少少多很多
配置复杂度简单简单简单复杂复杂
集群支持需要额外配置需要额外配置需要额外配置内置内置
管理界面基础基础无丰富丰富
许可证Apache 2.0Apache 2.0Apache 2.0LGPL商业
学习曲线平缓平缓平缓陡峭陡峭

详细对比分析

1. Tomcat vs Jetty

Tomcat优势：

  • 更成熟稳定
  • 社区支持更好
  • 文档更完善
  • 与Spring生态集成更好

Jetty优势：

  • 启动更快
  • 内存占用更少
  • 嵌入式部署更简单
  • 异步处理性能更好
// Jetty嵌入式示例
public class JettyServer {
    public static void main(String[] args) throws Exception {
        Server server = new Server(8080);
        ServletContextHandler context = new ServletContextHandler();
        context.setContextPath("/");
        context.addServlet(HelloServlet.class, "/hello");
        server.setHandler(context);
        server.start();
    }
}
2. Tomcat vs Undertow

Tomcat优势：

  • 更广泛使用
  • 配置更灵活
  • 管理功能更丰富

Undertow优势：

  • 性能更高
  • 内存占用更少
  • 支持HTTP/2
  • 异步处理能力强
// Undertow配置示例
public class UndertowServer {
    public static void main(String[] args) {
        Undertow server = Undertow.builder()
            .addHttpListener(8080, "localhost")
            .setHandler(exchange -> {
                exchange.getResponseHeaders().put(Headers.CONTENT_TYPE, "text/plain");
                exchange.getResponseSender().send("Hello World");
            }).build();
        server.start();
    }
}
3. 选择建议

选择Tomcat的情况：

  • 传统Web应用
  • 需要稳定可靠的服务
  • 团队对Tomcat更熟悉
  • 需要丰富的管理功能

选择Jetty的情况：

  • 嵌入式应用
  • 微服务架构
  • 对启动速度要求高
  • 资源受限环境

选择Undertow的情况：

  • 高并发应用
  • 对性能要求极高
  • 需要HTTP/2支持
  • 异步处理场景

Spring Boot集成Tomcat

默认集成

Spring Boot默认内嵌Tomcat，无需额外配置即可使用。

<!-- Maven依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

// Spring Boot应用
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Tomcat配置

1. 基本配置
# application.yml
server:
  port: 8080
  servlet:
    context-path: /myapp
  tomcat:
    threads:
      max: 200
      min-spare: 10
    max-connections: 8192
    accept-count: 100
    connection-timeout: 20000
    compression:
      enabled: true
      min-response-size: 2048
      mime-types: text/html,text/xml,text/plain,text/css,text/javascript,application/javascript,application/json
2. 高级配置
server:
  tomcat:
    uri-encoding: UTF-8
    max-http-form-post-size: 2MB
    max-swallow-size: 2MB
    processor-cache: 200
    additional-tld-skip-patterns: "*.jar"
    remote-ip-header: x-forwarded-for
    protocol-header: x-forwarded-proto
    port-header: x-forwarded-port
3. 自定义Tomcat配置
@Configuration
public class TomcatConfig {
  
    @Bean
    public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
        return new TomcatServletWebServerFactory() {
            @Override
            protected void postProcessContext(Context context) {
                // 自定义上下文配置
                context.setSessionTimeout(30);
                context.setSessionCookieName("JSESSIONID");
            }
        };
    }
  
    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> tomcatCustomizer() {
        return factory -> {
            factory.addConnectorCustomizers(connector -> {
                Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
                protocol.setMaxThreads(200);
                protocol.setMinSpareThreads(10);
                protocol.setMaxSpareThreads(50);
                protocol.setAcceptCount(100);
                protocol.setMaxConnections(8192);
            });
        };
    }
}

替换为其他容器

1. 替换为Jetty
<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>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
2. 替换为Undertow
<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>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

性能优化配置

1. JVM参数优化
# 启动参数
java -Xms2g -Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 \
     -jar myapp.jar
2. 应用配置优化
spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 20000
      idle-timeout: 300000
      max-lifetime: 1200000
  jpa:
    hibernate:
      ddl-auto: none
    show-sql: false
    properties:
      hibernate:
        jdbc:
          batch_size: 20
        order_inserts: true
        order_updates: true

性能监控与故障排查

监控工具

1. JMX监控
@Configuration
public class JmxConfig {
  
    @Bean
    public MBeanServer mBeanServer() {
        return ManagementFactory.getPlatformMBeanServer();
    }
  
    @Bean
    public TomcatMetrics tomcatMetrics() {
        return new TomcatMetrics();
    }
}
2. Actuator监控
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  endpoint:
    health:
      show-details: always
  metrics:
    export:
      prometheus:
        enabled: true
3. 自定义监控
@Component
public class TomcatMonitor {
  
    private final MeterRegistry meterRegistry;
  
    public TomcatMonitor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
  
    @EventListener
    public void handleRequest(RequestEvent event) {
        Timer.Sample sample = Timer.start(meterRegistry);
        // 处理请求
        sample.stop(Timer.builder("tomcat.request.duration")
            .tag("method", event.getRequest().getMethod())
            .register(meterRegistry));
    }
}

常见问题排查

1. 内存泄漏
# 生成堆转储
jmap -dump:format=b,file=heap.hprof <pid>

# 分析堆转储
jhat heap.hprof
2. 线程问题
# 查看线程状态
jstack <pid>

# 查看线程CPU使用
top -H -p <pid>
3. 连接问题
# 查看网络连接
netstat -an | grep :8080

# 查看连接数
ss -tuln | grep :8080

日志配置

1. 访问日志
<!-- 在server.xml中配置 -->
<Valve className="org.apache.catalina.valves.AccessLogValve"
       directory="logs"
       prefix="localhost_access_log"
       suffix=".txt"
       pattern="%h %l %u %t "%r" %s %b %D" />
2. 应用日志
logging:
  level:
    org.apache.catalina: INFO
    org.apache.coyote: INFO
    org.apache.tomcat: INFO
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
  file:
    name: logs/application.log
    max-size: 100MB
    max-history: 30

最佳实践

1. 生产环境配置

安全配置
<!-- 禁用不必要的方法 -->
<security-constraint>
    <web-resource-collection>
        <web-resource-name>Disable TRACE</web-resource-name>
        <url-pattern>/*</url-pattern>
        <http-method>TRACE</http-method>
    </web-resource-collection>
    <auth-constraint/>
</security-constraint>
性能配置
server:
  tomcat:
    threads:
      max: 200
      min-spare: 10
    max-connections: 8192
    accept-count: 100
    connection-timeout: 20000
    compression:
      enabled: true
      min-response-size: 2048

2. 集群配置

负载均衡配置
<!-- 在server.xml中配置 -->
<Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster">
    <Manager className="org.apache.catalina.ha.session.DeltaManager"
             expireSessionsOnShutdown="false"
             notifyListenersOnReplication="true"/>
    <Channel className="org.apache.catalina.tribes.group.GroupChannel">
        <Membership className="org.apache.catalina.tribes.membership.McastService"
                    address="228.0.0.4"
                    port="45564"
                    frequency="500"
                    dropTime="3000"/>
        <Receiver className="org.apache.catalina.tribes.transport.nio.NioReceiver"
                  address="auto"
                  port="4000"
                  autoBind="100"
                  selectorTimeout="5000"
                  maxThreads="6"/>
        <Sender className="org.apache.catalina.tribes.transport.ReplicationTransmitter">
            <Transport className="org.apache.catalina.tribes.transport.nio.PooledParallelSender"/>
        </Sender>
        <Interceptor className="org.apache.catalina.tribes.group.interceptors.TcpFailureDetector"/>
        <Interceptor className="org.apache.catalina.tribes.group.interceptors.MessageDispatch15Interceptor"/>
    </Channel>
    <Valve className="org.apache.catalina.ha.tcp.ReplicationValve"
           filter=""/>
    <Valve className="org.apache.catalina.ha.session.JvmRouteBinderValve"/>
    <Deployer className="org.apache.catalina.ha.deploy.FarmWarDeployer"
              tempDir="/tmp/war-temp/"
              deployDir="/tmp/war-deploy/"
              watchDir="/tmp/war-listen/"
              watchEnabled="false"/>
    <ClusterListener className="org.apache.catalina.ha.session.JvmRouteSessionIDBinderListener"/>
    <ClusterListener className="org.apache.catalina.ha.session.ClusterSessionListener"/>
</Cluster>

3. 监控告警

健康检查
@Component
public class TomcatHealthIndicator implements HealthIndicator {
  
    @Override
    public Health health() {
        try {
            // 检查Tomcat状态
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            ObjectName objectName = new ObjectName("Catalina:type=Server");
            String state = (String) server.getAttribute(objectName, "stateName");
          
            if ("STARTED".equals(state)) {
                return Health.up()
                    .withDetail("tomcat", "running")
                    .withDetail("state", state)
                    .build();
            } else {
                return Health.down()
                    .withDetail("tomcat", "not running")
                    .withDetail("state", state)
                    .build();
            }
        } catch (Exception e) {
            return Health.down()
                .withDetail("tomcat", "error")
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

4. 部署策略

蓝绿部署
#!/bin/bash
# 蓝绿部署脚本

# 停止旧版本
./bin/shutdown.sh

# 备份当前版本
cp -r webapps/myapp webapps/myapp.backup.$(date +%Y%m%d_%H%M%S)

# 部署新版本
cp new-version.war webapps/myapp.war

# 启动新版本
./bin/startup.sh

# 健康检查
sleep 30
if curl -f http://localhost:8080/myapp/health; then
    echo "Deployment successful"
else
    echo "Deployment failed, rolling back"
    ./bin/shutdown.sh
    rm -rf webapps/myapp
    mv webapps/myapp.backup.$(date +%Y%m%d_%H%M%S) webapps/myapp
    ./bin/startup.sh
fi

总结

Tomcat作为最流行的Java Servlet容器，具有以下优势：

主要优势

  1. 成熟稳定：经过多年发展，非常稳定可靠
  2. 轻量级：相比完整应用服务器，资源占用较少
  3. 易于配置：配置简单，学习成本低
  4. 社区支持：活跃的社区和丰富的文档
  5. Spring集成：与Spring Boot完美集成

适用场景

  • 传统Web应用
  • 微服务架构
  • 开发和测试环境
  • 中小型企业应用
  • Spring Boot应用

选择建议

  • 新项目：推荐使用Spring Boot + 内嵌Tomcat
  • 传统项目：可以继续使用独立Tomcat
  • 高并发场景：考虑Undertow或Jetty
  • 企业级应用：考虑WildFly或WebLogic

学习建议

  1. 从基础配置开始，逐步深入
  2. 关注性能调优和监控
  3. 了解集群和负载均衡
  4. 掌握故障排查技能
  5. 关注新版本特性和最佳实践
new_daimond
关注
Tomcat安装和配置（超详细）
weixin_70078784的博客
04-09 12万+
tomcat下载安装和配置，环境变量的配置 ，启动闪退问题 ，修改端口号
一文弄懂 Apache Tomcat
程序员进阶之路
07-26 1972
Tomcat的两个重要身份 1. **http服务器** 2. **Tomcat是⼀个Servlet容器**
Web服务器简述以及Tomcat
Pinker_Q
09-11 477
文章目录Web服务器TomcatTomcat概述 Web服务器 Web服务器的作用是接收客户端的请求，给客户端作出响应。   对于JavaWeb程序而言，还需要有JSP/Servlet容器，JSP/Servlet容器的基本功能是把动态资源转换成静态资源。   我们需要使用的是Web服务器和JSP/Servlet容器，通常这两者会集于一身。 下面是对JavaWeb服务器： Tomcat（Apache）：当前应用最广的JavaWeb服务器； JBoss（Redhat红帽）：支持Java
Tomcat详细介绍和使用总结
拾年一剑 的专栏
07-09 6139
文章目录TomcatTomcat作为Servlet容器的基本功能Tomcat的组成结构Tomcat配置需要配置的环境变量Tomcat启动与关闭文件配置 Oracle公司现在作为Java语言的开发和发布者，是当仁不让的标准接口的制定者。Oracle公司不仅制定了Web应用与Web服务器进行协作的一系列标准Java接口（统称为Java Servlet API），还对Web服务器发布以及运行Web应用的一些细节做了规约。 Oracle公司把这一系列标准Java接口和规约统称为Servlet规范。Servlet规范
Tomcat通俗讲解
08-22
该文档用通俗的话以及一些网络介绍资源来介绍tomcat的内部原理与应用
图解 Tomcat 体系结构
09-10
Apache Tomcat 是一款非常著名的开源 Servlet/JSP 容器。 Apache Tomcat 是一款非常著名的开源 Servlet/JSP 容器，被用做 Java Servlet 和 JavaServer Pages 技术的官方参考实现。如果您要了解这两种技术的细节可以查阅参考资料。 让我们先来浏览一下 Tomcat 体系结构中的六个主要概念： Server Service Engine Host Connector Context
TOMCAT
ljc666666的专栏
08-16 3668
 第一章  Tomcat概述  一、Tomcat简介 1、Tomcat    Tomcat在严格意义上并不是一个真正的应用服务器，它只是一个可以支持运行Serlvet/JSP的Web容器，不过Tomcat也扩展了一些应用服务器的功能，如JNDI，数据库连接池，用户事务处理等等。Tomcat是Apache组织下Jakarta项目下的一个子项目，目前Tomcat被非常广
一文带你搞懂JVM虚拟机的内存区域划分
weixin_62238621的博客
12-04 1857
一文带你搞懂JVM虚拟机的内存区域划分
别再只会背八股了！一文带你彻底搞懂UNION与UNION ALL的区别
最新发布
孤芳不自赏
09-05 814
社招面试中，SQL的UNION与UNION ALL常常是面试官的“陷阱题”。很多人只会背“一个去重一个不去重”，但要拿高分，得从性能、执行原理和场景选择聊开。今天小米用亲身经历，带你彻底吃透这个面试高频考点！
一文能看懂的2020最新版Mondrian3.x+MySql5.7教程
12-14
启动Tomcat服务器，通过浏览器访问配置好的URL执行查询，显示分析结果。 在配置过程中可能会遇到与Oracle数据库相关的错误，因为大多数示例使用Oracle。但只要按照教程中的指导进行调整，适应MySQL数据库，问题就...
【重发】一文带你轻松阅读Dynamic-tp全部源码！:L
weixin_43757056的博客
11-14 1227
之前我有写过一篇文章，讲述的是怎么使用Dynamic-TP做一些节省开发的一些问题，但是我感觉不能就直接这么算了，我还想看一下这个框架的一些内部逻辑，避免鸽太久自己以及忘了这回事情或者是还要花比较大的学习成本重新看一下源码，所以我打算花点时间狠狠的看下源码，整理一下自己认为有用的信息，毕竟要知其然更要知其所以然嘛~我阅读的Dtp源码是1.1.9之前使用Dynamic-TP所以我也打算从以下几个方面看下相关的一些源码。
Tomcat的使用（详细流程）
OnlyLove_longshao的博客
11-06 9万+
1、JavaWeb概念 Java web，是用java技术来解决相关web互联网领域的技术的总称。web包括：web服务器和web客户端两部分。 java在最早web客户端的应用有java applet程序，不过这种技术在很久之前就已经被淘汰了。java在服务器端的应用非常丰富， 比如Servlet，jsp和第三方框架等等。java技术对web领域的发展注入了强大的动力 简单的说，就是
Tomcat详解
m0_53127809的博客
12-11 976
本篇文章借鉴的是B站上黑马程序员关于Tomcat的详解 一、基础解释 首先解释几个基本概念，以方便后面的学习 1、服务器： 安装了服务器软件的计算机 2、服务器软件： 接受用户请求，处理请求，做出响应（简单来说，可以把服务器软件想象成一个黑盒，给他提供相应的请求，他就能给你做出解释） 3、web服务器软件： 具有服务器软件相同的基本功能，同时支持在web服务器上部署web项目，让用户通过浏览器来访问这些项目（也就是说，相比于服务器软件，web服务器软件可以支持我们把我们自己写的程序放进这
学习Tomcat这一篇就够了
热门推荐
轻松的小希
11-25 11万+
Tomcat 第一章 Tomcat概述 1.1、Tomcat概述 Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成。由于有了Sun 的参与和支持，最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现，Tomcat 5支持最新的Servlet 2.4 和JSP 2.0 规范。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并
快速入门这一篇就够了！Apache Tomcat 简单理解其原理以及使用
Specif1c的博客
10-29 4174
有了坚持不一定成功;但没有坚持，就注定失败。对于成功，坚持的塑造必不可少! 一、概念 Tomcat 服务器是一个开源的轻量级Web应用服务器，在中小型系统和并发量小的场合下被普遍使用，是开发和调试Servlet、JSP 程序的首选。 二、原理 Tomcat结构图： Tomcat主要组件：服务器Server，服务Service，连接器Connector、容器Container， 连接器Connector和容器Container是Tomcat的核心。 一个Container容器和一个或多个Con.
图解tomcat
博风_刺耳的博客（网络记事本）
07-19 749
Server：指Tomcat本身 从上图看，Server是最外层元素，在Service中通过不同的Connector来连接Engine。Engine中包括多个Host，而Host又可以配置多个Context。 1．Server：该元素是server.xml中最重要的元素，他代表了整个JVM，也代表了Tomcat服务器，启动后将在端口8005出等待关闭命令，如果收到“SHU...
一文带你彻底搞懂红黑树
03-03
### 红黑树概念 红黑树是一种特殊的二叉搜索树，具有特定的颜色属性来保持树的近似平衡状态。这种特性使得红黑树能够在插入、删除和查找操作上提供较好的时间复杂度[^1]。 #### 性质描述 每棵红黑树都遵循以下五...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值