1.4 Tomcat 应用场景

文档摘要

1.4 Tomcat 应用场景 1.4 Tomcat 应用场景在深入了解 Tomcat 的架构和组件之后，本节将聚焦于 Tomcat 的核心价值——应用场景。Tomcat 作为一款成熟且广泛使用的 Servlet 容器和 JSP 引擎，其应用场景十分广泛。理解 Tomcat 的应用场景，有助于我们更好地选择和配置 Tomcat，发挥其最大效能。 1.4.1 基础 Web 应用：静态资源与动态内容场景描述: 最基础的应用场景莫过于部署和运行 Web 应用程序，这些应用可能包含静态资源（HTML、CSS、JavaScript、图片等）以及动态内容（JSP、Servlet 生成的页面）。Tomcat 天生就是为这类应用而设计的。

1.4 Tomcat 应用场景

在深入了解 Tomcat 的架构和组件之后，本节将聚焦于 Tomcat 的核心价值——应用场景。Tomcat 作为一款成熟且广泛使用的 Servlet 容器和 JSP 引擎，其应用场景十分广泛。理解 Tomcat 的应用场景，有助于我们更好地选择和配置 Tomcat，发挥其最大效能。

1.4.1 基础 Web 应用：静态资源与动态内容

场景描述:

最基础的应用场景莫过于部署和运行 Web 应用程序，这些应用可能包含静态资源（HTML、CSS、JavaScript、图片等）以及动态内容（JSP、Servlet 生成的页面）。Tomcat 天生就是为这类应用而设计的。

Tomcat 的优势:

Servlet 容器: Tomcat 完美实现了 Servlet 规范，可以高效地处理 Servlet 请求，并管理 Servlet 的生命周期。
JSP 引擎: Tomcat 内置 JSP 引擎，能够将 JSP 页面编译成 Servlet，并执行生成动态内容。
静态资源服务: Tomcat 也具备处理静态资源的能力，可以直接从 Web 应用的指定目录（如 webapp 目录）提供静态文件访问。
易于部署: 将 Web 应用打包成 WAR 文件，简单地复制到 Tomcat 的 webapps 目录下即可完成部署。

代码实践:

1. Servlet 示例 (SimpleServlet.java):


package com.example;
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;
@WebServlet("/hello")
public class SimpleServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        PrintWriter out = resp.getWriter();
        out.println("<html><body>");
        out.println("<h1>Hello, World! from Tomcat Servlet</h1>");
        out.println("</body></html>");
    }
}

代码详解:

@WebServlet("/hello"): Servlet 3.0 注解，将 SimpleServlet 映射到 /hello URL 路径。
doGet() 方法：处理 HTTP GET 请求。
resp.setContentType("text/html"): 设置响应内容类型为 HTML。
PrintWriter out = resp.getWriter(): 获取输出流，用于向客户端写入响应内容。
out.println(...): 向客户端输出 HTML 内容。

2. JSP 示例 (index.jsp):


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP Example</title>
</head>
<body>
    <h1>Hello from JSP!</h1>
    <%
        String currentTime = new java.util.Date().toString();
        out.println("<p>Current time: " + currentTime + "</p>");
    %>
</body>
</html>

代码详解:

<%@ page ... %>: JSP 指令，设置页面属性，如内容类型和编码。
<h1>Hello from JSP!</h1>: 静态 HTML 内容。
<% ... %>: JSP Scriptlet，用于嵌入 Java 代码。
String currentTime = new java.util.Date().toString();: 获取当前时间。
out.println(...): 使用 JSP 内置对象 out 向页面输出动态内容。

部署与访问:

将 SimpleServlet.java 编译成 SimpleServlet.class，并将其放置在 WEB-INF/classes/com/example 目录下 (假设你的 Web 应用结构正确)。
将 index.jsp 放置在 Web 应用的根目录下。
将 Web 应用打包成 WAR 文件（例如 webapp.war）。
将 webapp.war 复制到 Tomcat 的 webapps 目录下。
启动 Tomcat。
在浏览器中访问 http://localhost:8080/webapp/hello (Servlet) 和 http://localhost:8080/webapp/index.jsp (JSP)。

原理详解:

当用户访问 /webapp/hello 或 /webapp/index.jsp 时：

Tomcat 接收到 HTTP 请求。
Tomcat 的 Connector 组件解析请求，确定请求的 Web 应用（webapp）和路径（/hello 或 /index.jsp）。
Tomcat 的 Container 组件（通常是 Catalina）根据请求路径，找到对应的 Servlet 或 JSP 文件。
对于 Servlet 请求 (/hello):
- Tomcat 创建或复用 SimpleServlet 实例。
- Tomcat 调用 SimpleServlet 的 service() 方法（根据 HTTP 方法，最终调用 doGet()、doPost() 等）。
- SimpleServlet 生成动态内容，并通过 response 对象返回给 Tomcat。
对于 JSP 请求 (/index.jsp):
- 如果 JSP 文件是首次被请求，Tomcat 的 JSP 引擎（Jasper）会将 index.jsp 编译成一个 Servlet 类。
- Tomcat 创建或复用编译后的 Servlet 实例。
- Tomcat 调用 Servlet 的 service() 方法。
- Servlet 执行 JSP 页面中的 Java 代码，并生成动态 HTML 内容，通过 response 对象返回给 Tomcat。
Tomcat 将响应返回给客户端浏览器。

图表 (mermaid):

总结:

Tomcat 在基础 Web 应用场景中扮演着核心角色，它作为 Servlet 容器和 JSP 引擎，能够有效地处理静态资源和动态内容请求，为构建和部署简单的 Web 应用程序提供了坚实的基础。

1.4.2 企业级 Web 应用：框架集成与复杂业务逻辑

场景描述:

企业级 Web 应用通常具有更复杂的业务逻辑、更高的并发需求以及更严格的安全要求。这些应用往往会采用各种成熟的 Java Web 框架（如 Spring MVC、Struts 2、JSF 等）来提高开发效率和代码可维护性。Tomcat 作为流行的 Servlet 容器，自然也成为这些框架的首选部署平台。

Tomcat 的优势:

良好的框架兼容性: Tomcat 与主流的 Java Web 框架都具有良好的兼容性，可以无缝集成。
成熟稳定: Tomcat 经过多年的发展和迭代，已经非常成熟和稳定，能够支撑企业级应用的长期运行。
性能优化: Tomcat 提供了多种性能优化配置选项，可以根据企业级应用的实际需求进行调优，提升性能和吞吐量。
安全特性: Tomcat 提供了多种安全特性，如 SSL/TLS 支持、安全角色管理、Web 应用安全约束等，可以增强企业级应用的安全性。
集群和负载均衡支持: Tomcat 可以通过集群和负载均衡技术，实现高可用和横向扩展，满足企业级应用的高并发需求。

代码实践 (Spring MVC 示例):

1. Spring MVC Controller (HelloController.java):


package com.example.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class HelloController {
    @GetMapping("/spring-hello")
    public String hello(Model model) {
        model.addAttribute("message", "Hello from Spring MVC and Tomcat!");
        return "hello"; // 返回 hello.jsp 视图
    }
}

2. Spring MVC 视图 (hello.jsp):


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Spring MVC Example</title>
</head>
<body>
    <h1>${message}</h1>
</body>
</html>

3. Spring MVC 配置 (dispatcher-servlet.xml):


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <context:component-scan base-package="com.example.controller"/>
    <mvc:annotation-driven/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

代码详解:

HelloController.java: Spring MVC Controller，使用 @Controller 注解标记，@GetMapping("/spring-hello") 映射请求到 hello() 方法。Model 对象用于传递数据到视图，返回字符串 "hello" 表示视图名称。
hello.jsp: 简单的 JSP 视图，使用 ${message} EL 表达式显示从 Controller 传递过来的数据。
dispatcher-servlet.xml: Spring MVC 配置文件，配置组件扫描、注解驱动、视图解析器等。
- <context:component-scan base-package="com.example.controller"/>: 扫描 com.example.controller 包下的组件（Controller）。
- <mvc:annotation-driven/>: 启用 Spring MVC 注解驱动。
- InternalResourceViewResolver: 配置 JSP 视图解析器，指定视图文件的前缀和后缀。

部署与访问:

将上述 Java 代码编译，并将 dispatcher-servlet.xml 放置在 WEB-INF 目录下，hello.jsp 放置在 WEB-INF/views 目录下（创建 views 目录）。
配置 web.xml (或使用 Servlet 3.0 注解) 注册 DispatcherServlet:


<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

将 Web 应用打包成 WAR 文件，部署到 Tomcat。
启动 Tomcat。
在浏览器中访问 http://localhost:8080/webapp/spring-hello.

原理详解:

当使用 Spring MVC 框架时，Tomcat 主要扮演 Servlet 容器的角色，负责接收和转发请求，以及运行 Spring MVC 框架。

请求到达 Tomcat: 用户请求 http://localhost:8080/webapp/spring-hello。
DispatcherServlet 拦截请求: DispatcherServlet 是 Spring MVC 的核心组件，它在 web.xml 中配置，拦截所有匹配的请求 (/).
Spring MVC 处理请求:
- DispatcherServlet 接收请求，并根据配置的 HandlerMapping (通常是基于注解的 RequestMappingHandlerMapping) 查找处理请求的 Handler (Controller)。
- 找到 HelloController 的 hello() 方法。
- Spring MVC 调用 hello() 方法，并将 Model 对象传递给它。
- hello() 方法处理业务逻辑，并将数据添加到 Model 中，返回视图名称 "hello"。
- DispatcherServlet 根据视图名称 "hello" 和配置的 ViewResolver (InternalResourceViewResolver) 找到对应的视图文件 (/WEB-INF/views/hello.jsp)。
- Spring MVC 渲染视图，将 Model 中的数据填充到 JSP 页面中，生成 HTML 响应。
Tomcat 返回响应: Tomcat 将 Spring MVC 生成的 HTML 响应返回给客户端浏览器。

图表 (mermaid):

总结:

在企业级 Web 应用场景中，Tomcat 仍然是重要的 Servlet 容器，它与各种 Java Web 框架协同工作，共同构建复杂的企业级应用。Tomcat 的成熟稳定、性能优化和安全特性使其成为企业级应用部署的理想选择。

1.4.3 RESTful API 和 Web 服务

场景描述:

随着前后端分离架构的流行，构建 RESTful API 和 Web 服务成为重要的应用场景。Tomcat 可以作为部署 RESTful API 和 Web 服务的容器，例如使用 JAX-RS 规范或 Spring WebFlux 等框架构建的 API 服务。

Tomcat 的优势:

轻量级: 相对于完整的 Java EE 应用服务器，Tomcat 更加轻量级，启动速度快，资源占用少，适合部署独立的 API 服务。
Servlet 规范支持: RESTful API 通常也基于 HTTP 协议，Servlet 规范为处理 HTTP 请求提供了标准化的 API，Tomcat 对 Servlet 规范的良好支持使其能够胜任 API 容器的角色。
易于集成 RESTful 框架: Tomcat 可以方便地集成各种 RESTful 框架，如 Jersey (JAX-RS 参考实现)、Apache CXF、Spring WebFlux 等。
性能表现: Tomcat 在处理 HTTP 请求方面具有良好的性能表现，可以满足大部分 API 服务的性能需求。

代码实践 (JAX-RS 示例 - Jersey):

1. JAX-RS Resource (HelloResource.java):


package com.example.resource;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Path("/api")
public class HelloResource {
    @GET
    @Path("/hello")
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from JAX-RS REST API on Tomcat!";
    }
}

2. JAX-RS Application (JaxRsApplication.java):


package com.example;
import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;
import java.util.HashSet;
import java.util.Set;
@ApplicationPath("/")
public class JaxRsApplication extends Application {
    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> resources = new HashSet<>();
        resources.add(com.example.resource.HelloResource.class);
        return resources;
    }
}

3. web.xml 配置 Jersey Servlet:


<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>jersey-servlet</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>javax.ws.rs.Application</param-name>
            <param-value>com.example.JaxRsApplication</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>jersey-servlet</servlet-name>
        <url-pattern>/api/*</url-pattern>
    </servlet-mapping>
</web-app>

代码详解:

HelloResource.java: JAX-RS Resource 类，使用 @Path("/api") 定义根路径，@GET 和 @Path("/hello") 组合定义 /api/hello GET 请求处理方法。@Produces(MediaType.TEXT_PLAIN) 指定响应内容类型为纯文本。
JaxRsApplication.java: JAX-RS Application 类，使用 @ApplicationPath("/") 定义应用根路径，getClasses() 方法返回所有 Resource 类的集合。
web.xml: 配置 Jersey Servlet (ServletContainer)，并指定 JAX-RS Application 类。<servlet-mapping> 将 /api/* 路径的请求映射到 Jersey Servlet。

部署与访问:

将 Jersey 相关的 JAR 包添加到 Web 应用的 WEB-INF/lib 目录下 (例如 jersey-container-servlet-core.jar, jersey-server.jar, jersey-common.jar 等)。
将上述 Java 代码编译，并将 web.xml 放置在 WEB-INF 目录下。
将 Web 应用打包成 WAR 文件，部署到 Tomcat。
启动 Tomcat。
在浏览器或使用 REST 客户端访问 http://localhost:8080/webapp/api/hello.

原理详解:

当使用 JAX-RS (Jersey) 构建 RESTful API 时，Tomcat 仍然作为 Servlet 容器，Jersey Servlet 负责处理 REST 请求。

请求到达 Tomcat: 用户请求 http://localhost:8080/webapp/api/hello.
Jersey Servlet 拦截请求: ServletContainer (Jersey Servlet) 在 web.xml 中配置，拦截 /api/* 路径的请求。
Jersey 框架处理请求:
- ServletContainer 接收请求，并根据 JAX-RS 注解 (@Path, @GET, @Produces 等) 路由请求到对应的 Resource 方法 (HelloResource.hello()).
- HelloResource.hello() 方法处理请求，返回字符串 "Hello from JAX-RS REST API on Tomcat!".
- Jersey 框架将返回的字符串转换为 HTTP 响应，设置 Content-Type 为 text/plain。
Tomcat 返回响应: Tomcat 将 Jersey 生成的 HTTP 响应返回给客户端。

图表 (mermaid):

总结:

Tomcat 可以有效地支持 RESTful API 和 Web 服务的部署。其轻量级、Servlet 规范支持和良好的性能表现，使其成为构建和运行 API 服务的理想容器。结合 JAX-RS (Jersey) 或 Spring WebFlux 等框架，可以快速构建高效的 RESTful API 服务。

1.4.4 微服务架构中的 Tomcat

场景描述:

在微服务架构中，应用程序被拆分成多个小型、独立的服务。每个服务可以独立部署、扩展和维护。Tomcat 由于其轻量级和启动速度快的特点，也常被用于部署微服务。

Tomcat 的优势:

轻量级和快速启动: 在微服务架构中，服务需要频繁部署和重启。Tomcat 的轻量级和快速启动特性使其非常适合微服务环境。
资源占用少: 微服务通常需要部署大量的服务实例。Tomcat 资源占用少，可以降低服务器成本。
易于容器化: Tomcat 可以很容易地容器化 (例如使用 Docker)，并部署到容器编排平台 (如 Kubernetes)。这使得微服务的部署和管理更加便捷。
成熟的 Servlet 容器: 即使在微服务架构中，很多服务仍然基于 HTTP 协议进行通信，Servlet 容器仍然是处理 HTTP 请求的基础。Tomcat 作为成熟的 Servlet 容器，仍然发挥着重要作用。

实践建议:

轻量级化 Tomcat: 在微服务环境中，可以对 Tomcat 进行轻量级化配置，例如禁用不必要的功能模块，减少内存占用，加快启动速度。
容器化部署: 将 Tomcat 应用容器化，使用 Dockerfile 构建镜像，并部署到 Kubernetes 或其他容器编排平台。
服务注册与发现: 与服务注册与发现中心 (如 Eureka, Consul, Nacos) 集成，实现微服务的自动注册和发现。
监控与日志: 集成监控系统 (如 Prometheus, Grafana) 和日志系统 (如 ELK Stack, Graylog)，对微服务进行监控和日志管理。

图表 (mermaid):

总结:

Tomcat 在微服务架构中仍然可以发挥重要作用，尤其是在构建轻量级、基于 HTTP 协议的微服务时。其轻量级、快速启动、易于容器化等特性使其成为微服务部署的良好选择。通过容器化、服务注册与发现、监控与日志等技术，可以更好地在微服务环境中管理和运维 Tomcat 应用。

1.4.5 WebSocket 应用

场景描述:

WebSocket 是一种在客户端和服务器之间建立持久连接，实现双向通信的协议。Tomcat 从 7.0 版本开始支持 WebSocket 协议，可以用于构建实时性要求较高的 Web 应用，如在线聊天室、实时协作工具、在线游戏等。

Tomcat 的优势:

WebSocket 协议支持: Tomcat 实现了 Java WebSocket API (JSR 356)，可以方便地开发和部署 WebSocket 应用。
高性能 WebSocket 支持: Tomcat 在 WebSocket 连接管理和消息处理方面进行了优化，具有较好的性能表现。
与 Servlet 容器集成: WebSocket 应用可以与传统的 Servlet 应用部署在同一个 Tomcat 容器中，方便统一管理。
易于开发: Java WebSocket API 提供了简洁易用的编程模型，可以快速开发 WebSocket 应用。

代码实践 (WebSocket Server Endpoint):


package com.example.websocket;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
@ServerEndpoint("/websocket/chat")
public class ChatEndpoint {
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("WebSocket connection opened: " + session.getId());
    }
    @OnMessage
    public void onMessage(String message, Session session) throws IOException {
        System.out.println("Received message from session " + session.getId() + ": " + message);
        // Echo back the message to the client
        session.getBasicRemote().sendText("Server received: " + message);
    }
    @OnError
    public void onError(Session session, Throwable throwable) {
        System.err.println("WebSocket error for session " + session.getId() + ": " + throwable.getMessage());
    }
    @OnClose
    public void onClose(Session session, CloseReason closeReason) {
        System.out.println("WebSocket connection closed for session " + session.getId() + ". Reason: " + closeReason.getReasonPhrase());
    }
}

作者与出处

原作者：灏天文库

来源：灏天文库

原文： https://aiknowledge.cn/collection/182-tomcat-web%E6%9C%8D%E5%8A%A1%E5%99%A8%E9%85%8D%E7%BD%AE%E4%B8%8E%E7%AE%A1%E7%90%86

整理：灏天文库整理

由灏天文库平台收录，内容或由平台用户上传，仅供学习交流