一篇文章讲明白 Servlet Tomcat 和 JSP：Java Web 是怎么跑起来的

上一篇 Maven 文章里，我们讲到 jar、war、classpath、scope=provided，也提到传统 Java Web 项目会把 war 包部署到 Tomcat。

但这里还有一串新问题：

Tomcat 到底是什么？
Servlet 是什么？
JSP 又是什么？
为什么 war 要放进 Tomcat？
浏览器访问一个 URL 后，Java 代码是怎么被执行的？
Spring Boot 里说的内嵌 Tomcat，和传统 Tomcat 部署有什么关系？

这篇文章就专门讲清楚这条 Java Web 主线。

你可以先记住一句话：

Tomcat 接收 HTTP 请求，Servlet 处理请求，JSP 生成动态页面，Maven 把项目打成 war，浏览器最终看到响应结果。

---

一、先理解 Web 请求

在讲 Tomcat、Servlet、JSP 之前，先看浏览器访问网页到底发生了什么。

假设你在浏览器输入：

这个 URL 可以拆成几部分：

http        协议，表示使用 HTTP 通信
localhost   主机，表示访问本机
8080        端口，表示访问本机的 8080 端口
demo        Web 应用名，也常叫 context path
hello       应用内部的请求路径

也就是说：

浏览器要通过 HTTP 协议，
访问本机 8080 端口上的 demo 这个 Web 应用，
请求 demo 应用里的 /hello 这个功能。

浏览器发出去的是 HTTP 请求。

请求里通常包含：

请求方法：GET、POST 等
请求路径：/demo/hello
请求参数：name=Tom
请求头：浏览器类型、Cookie、Content-Type 等
请求体：POST 表单或 JSON 数据

服务器处理完后，会返回 HTTP 响应。

响应里通常包含：

状态码：200、404、500 等
响应头：Content-Type、Set-Cookie 等
响应体：HTML、JSON、图片、文件等

最简单的流程是：

浏览器
  ↓ HTTP 请求
服务器
  ↓ HTTP 响应
浏览器显示结果

Java Web 要解决的就是：

服务器收到 HTTP 请求后，如何让 Java 代码来处理它？

答案就是 Tomcat 和 Servlet。

---

二、Tomcat 是什么

Tomcat 可以先这样理解：

Tomcat 是一个 Web 服务器，也是一个 Servlet 容器。

这句话里有两个身份。

1. Tomcat 作为 Web 服务器

Web 服务器的工作是和浏览器打交道。

Tomcat 会做这些事：

监听端口，比如 8080
接收浏览器发来的 HTTP 请求
解析请求路径、请求参数、请求头
把请求交给对应的 Web 应用
把处理结果包装成 HTTP 响应
返回给浏览器

所以当你启动 Tomcat 后，浏览器访问：

浏览器其实就是在访问 Tomcat 监听的 8080 端口。

2. Tomcat 作为 Servlet 容器

Tomcat 不只是接 HTTP 请求。它还知道如何运行 Servlet。

这就是它的第二个身份：

Tomcat 是 Servlet 容器。

容器的意思是：

它提供一个运行环境，把 Servlet 放进去运行，并负责管理 Servlet。

你的 Servlet 类不是自己启动的，也不是自己监听端口的。

真正监听端口、接收请求、创建 Servlet、调用 Servlet 方法的是 Tomcat。

3. 为什么传统 Java Web 项目要把 war 放进 Tomcat

传统 Java Web 项目最终会打成 war：

demo.war

你把它放到：

Tomcat/webapps/demo.war

Tomcat 会做几件事：

解压 demo.war
读取里面的 WEB-INF/web.xml 或扫描注解
加载应用里的 class 和 jar
注册 URL 到 Servlet 的映射关系
开始接收浏览器请求

所以 war 不是直接双击运行的程序。它更像是：

一个交给 Tomcat 运行的 Java Web 应用包。

---

三、Servlet 是什么

Servlet 可以先这样理解：

Servlet 是运行在 Servlet 容器里的 Java Web 组件，用来接收请求、处理业务、返回响应。

它本质上还是 Java 类，但不是普通 Java 类。

普通 Java 类通常由你自己 new，自己调用方法。

Servlet 通常由 Tomcat 创建、管理和调用。

1. 一个最小 Servlet 示例

现代 Servlet 常见写法是继承 HttpServlet：

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;import java.io.IOException;@WebServlet("/hello")
public class HelloServlet extends HttpServlet {    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {        response.setContentType("text/plain;charset=UTF-8");
        response.getWriter().write("Hello Servlet");
    }
}

这段代码的意思是：

当浏览器请求 /hello 时，
Tomcat 找到 HelloServlet，
然后调用它的 doGet 方法，
最后把 Hello Servlet 返回给浏览器。

如果部署的应用名是 demo，浏览器访问：

就会看到：

Hello Servlet

2. doGet 和 doPost

HTTP 请求有不同方法，最常见的是 GET 和 POST。

浏览器直接访问 URL，通常是 GET：

GET /demo/hello

提交表单、提交 JSON 数据时，常见的是 POST：

POST /demo/login

在 Servlet 里，对应的方法是：

protected void doGet(HttpServletRequest request, HttpServletResponse response)
protected void doPost(HttpServletRequest request, HttpServletResponse response)

例如：

@WebServlet("/login")
public class LoginServlet extends HttpServlet {    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws IOException {        String username = request.getParameter("username");
        String password = request.getParameter("password");        if ("admin".equals(username) && "123456".equals(password)) {
            response.getWriter().write("login success");
        } else {
            response.getWriter().write("login failed");
        }
    }
}

这里：

request  表示浏览器发来的请求
response 表示服务器要返回给浏览器的响应

3. Servlet 和普通 Java 类的区别

Servlet 也是 Java 类，但它有几个特殊点：

它运行在 Tomcat 这样的 Servlet 容器里
它处理的是 HTTP 请求和 HTTP 响应
它的生命周期由容器管理
它通常通过 URL 映射被浏览器访问

普通 Java 类可以这样调用：

UserService service = new UserService();
service.login(username, password);

Servlet 通常不是你手动调用，而是：

浏览器请求 URL
  ↓
Tomcat 找到对应 Servlet
  ↓
Tomcat 调用 doGet/doPost

---

四、Servlet 容器是什么意思

“容器”这个词一开始听起来有点抽象。

你可以这样理解：

Servlet 容器就是运行和管理 Servlet 的环境。

Tomcat 是最常见的 Servlet 容器之一。

容器负责的事情包括：

启动 Web 应用
加载 Servlet 类
创建 Servlet 对象
调用 Servlet 初始化方法
根据 URL 找到对应 Servlet
为每次请求准备 request 和 response
调用 doGet/doPost
管理 Servlet 销毁

1. Servlet 生命周期

Servlet 大致有三个生命阶段：

初始化
  ↓
处理请求
  ↓
销毁

对应到方法：

public void init()
protected void doGet(...)
protected void doPost(...)
public void destroy()

Tomcat 会在合适的时候调用这些方法。

你不需要在 main 方法里写：

new HelloServlet().doGet(...)

因为这些事情由 Tomcat 负责。

2. 为什么 Servlet API 通常是 provided

在 Maven 里，Servlet API 依赖经常这样写：

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.0.0</version>
    <scope>provided</scope>
</dependency>

provided 的意思是：

编译时需要它，但运行时由环境提供。

为什么？

因为你写代码时需要这些类：

HttpServlet
HttpServletRequest
HttpServletResponse

所以编译时必须有 Servlet API。

但是运行时，Tomcat 自己已经带了 Servlet API。如果你再把一份 Servlet API 打进 war，可能会和 Tomcat 自带的版本冲突。

所以 Servlet API 一般用：

scope=provided

一句话：

Servlet API 编译时 Maven 提供，运行时 Tomcat 提供。

---

五、web.xml 和注解映射

浏览器请求一个 URL 时，Tomcat 怎么知道该调用哪个 Servlet？

关键是映射关系：

URL -> Servlet

这个映射可以用传统 web.xml 配，也可以用注解配。

1. 传统 web.xml 映射

早期 Java Web 项目常用 web.xml。

目录位置通常是：

src/main/webapp/WEB-INF/web.xml

示例：

<web-app>
    <servlet>
        <servlet-name>helloServlet</servlet-name>
        <servlet-class>com.example.HelloServlet</servlet-class>
    </servlet>    <servlet-mapping>
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

意思是：

/hello 这个 URL 交给 com.example.HelloServlet 处理。

2. 注解映射

后来 Servlet 支持注解，可以直接写：

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    ...
}

这和 web.xml 的本质一样：

把 /hello 映射到 HelloServlet。

3. 两种方式怎么选

可以简单理解：

web.xml     更传统，集中配置，老项目常见
@WebServlet 更现代，写法简单，小项目和示例常见

不管哪种方式，本质都是：

Tomcat 需要知道某个 URL 应该交给哪个 Servlet。

---

六、JSP 是什么

JSP 全称是：

Java Server Pages

你可以先这样理解：

JSP 是一种写动态 HTML 页面的技术。

Servlet 更像是 Java 代码里拼响应：

response.getWriter().write("<html>");
response.getWriter().write("<body>");
response.getWriter().write("Hello");
response.getWriter().write("</body>");
response.getWriter().write("</html>");

这样写页面很痛苦。

JSP 的目标就是让你更像写 HTML：

<%@ page contentType="text/html;charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <title>Hello JSP</title>
</head>
<body>
    <h1>Hello, ${username}</h1>
</body>
</html>

这里的：

${username}

表示从请求、会话或其他作用域里取一个叫 username 的值，然后渲染到页面上。

1. JSP 会被翻译成 Servlet

这是理解 JSP 的关键：

JSP 最终会被 Tomcat 翻译成 Servlet。

也就是说，你写的是：

hello.jsp

Tomcat 运行时会把它转换成类似：

hello_jsp.java

再编译成：

hello_jsp.class

最终它仍然是 Servlet 体系的一部分。

所以 JSP 不是绕开 Servlet，而是：

一种更适合写页面的 Servlet 表达方式。

2. 一个 Servlet 转发到 JSP 的例子

Servlet 可以处理请求，然后把数据交给 JSP 展示。

@WebServlet("/profile")
public class ProfileServlet extends HttpServlet {    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {        request.setAttribute("username", "Alice");
        request.getRequestDispatcher("/WEB-INF/views/profile.jsp")
               .forward(request, response);
    }
}

JSP 页面：

<%@ page contentType="text/html;charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <title>Profile</title>
</head>
<body>
    <h1>用户：${username}</h1>
</body>
</html>

浏览器访问：

流程是：

Tomcat 调用 ProfileServlet
ProfileServlet 设置 username=Alice
ProfileServlet 转发到 profile.jsp
JSP 生成 HTML
Tomcat 把 HTML 返回浏览器

3. 一个简单表单例子

JSP 也可以写表单：

<%@ page contentType="text/html;charset=UTF-8" %>
<!DOCTYPE html>
<html>
<body>
    <form action="${pageContext.request.contextPath}/login" method="post">
        <input type="text" name="username" placeholder="用户名">
        <input type="password" name="password" placeholder="密码">
        <button type="submit">登录</button>
    </form>
</body>
</html>

提交后会请求：

POST /demo/login

然后由 /login 对应的 Servlet 处理。

---

七、Servlet、Tomcat、JSP 的关系

现在把三者关系串起来。

Tomcat 是运行环境。
Servlet 是处理请求的 Java 组件。
JSP 是偏页面展示的动态模板，最终也会变成 Servlet。

流程图可以这样看：

浏览器
  ↓ HTTP 请求
Tomcat
  ↓ 根据 URL 找应用和映射
Servlet
  ↓ 处理业务、准备数据
JSP
  ↓ 生成 HTML
Tomcat
  ↓ HTTP 响应
浏览器显示页面

如果请求的是纯 Servlet 接口，也可以不经过 JSP：

浏览器
  ↓
Tomcat
  ↓
Servlet
  ↓
返回 JSON 或文本

如果请求的是 JSP 页面，也可能直接由 JSP 生成响应：

浏览器
  ↓
Tomcat
  ↓
JSP 转成的 Servlet
  ↓
返回 HTML

所以它们不是彼此替代关系，而是不同层次：

Tomcat 负责运行和分发
Servlet 负责控制和处理
JSP 负责页面展示

---

八、传统 Java Web 项目结构

一个传统 Maven Java Web 项目可能长这样：

demo-web/
├── pom.xml
└── src/
    └── main/
        ├── java/
        │   └── com/example/HelloServlet.java
        ├── resources/
        └── webapp/
            ├── index.jsp
            └── WEB-INF/
                ├── web.xml
                └── views/
                    └── profile.jsp

重点是：

src/main/java       Java 代码，比如 Servlet、Service、DAO
src/main/resources  配置文件
src/main/webapp     Web 资源，比如 JSP、HTML、CSS、JS
WEB-INF             Web 应用的受保护目录
web.xml             传统 Web 应用配置文件

1. WEB-INF 有什么特殊

WEB-INF 是一个特殊目录。

浏览器不能直接访问它下面的文件。

例如：

src/main/webapp/index.jsp

可能可以直接访问：

但：

src/main/webapp/WEB-INF/views/profile.jsp

不能直接通过 URL 访问。

它通常只能通过 Servlet 转发访问：

request.getRequestDispatcher("/WEB-INF/views/profile.jsp")
       .forward(request, response);

这样做的好处是：

页面必须经过 Servlet 控制逻辑后才能展示。

2. war 包内部结构

Maven 打成 war 后，内部大概是：

demo.war
├── index.jsp
├── WEB-INF/
│   ├── web.xml
│   ├── classes/
│   │   └── com/example/HelloServlet.class
│   └── lib/
│       ├── commons-lang3-3.14.0.jar
│       └── other-lib.jar
└── static/
    └── app.css

其中：

WEB-INF/classes  放项目自己编译出来的 class
WEB-INF/lib      放项目依赖的 jar
web.xml          放 Web 应用配置

注意，如果某个依赖是 provided，通常不会被打进 WEB-INF/lib。

例如 Servlet API 由 Tomcat 提供，所以不应该打进去。

---

九、Maven 如何构建 Java Web 项目

如果一个 Maven 项目要打成 war，需要在 pom.xml 里写：

<packaging>war</packaging>

一个简化版 POM 可能是：

<project>
    <modelVersion>4.0.0</modelVersion>    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>    <dependencies>
        <dependency>
            <groupId>jakarta.servlet</groupId>
            <artifactId>jakarta.servlet-api</artifactId>
            <version>6.0.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.4.0</version>
            </plugin>
        </plugins>
    </build>
</project>

然后执行：

mvn clean package

Maven 会：

清理 target
编译 Java 代码
处理 webapp 资源
运行测试
使用 maven-war-plugin 打包
生成 target/demo-1.0.0.war

javax.servlet 和 jakarta.servlet

你可能会看到两种包名：

javax.servlet.*
jakarta.servlet.*

简单理解：

老项目、老版本 Tomcat 常见 javax.servlet
新项目、新版本 Jakarta EE / Tomcat 10+ 常见 jakarta.servlet

这两个不能随便混用。

如果代码里写：

import jakarta.servlet.http.HttpServlet;

那依赖和 Tomcat 版本也要支持 jakarta.servlet。

如果代码里写：

import javax.servlet.http.HttpServlet;

那通常是老 Servlet API 和老 Tomcat 体系。

对初学者来说，先记住：

代码 import、Maven 依赖、Tomcat 版本要匹配。

---

十、部署到 Tomcat 的过程

传统部署流程是：

Maven 打 war
  ↓
把 war 放进 Tomcat/webapps
  ↓
Tomcat 解压 war
  ↓
Tomcat 加载 Web 应用
  ↓
浏览器访问应用

具体一点：

mvn clean package

生成：

target/demo-1.0.0.war

把它复制到：

Tomcat/webapps/demo.war

启动 Tomcat 后，Tomcat 会解压：

Tomcat/webapps/demo/

然后浏览器访问：

这里的 demo 通常来自 war 包名：

demo.war -> /demo

请求进入 Tomcat 后：

Tomcat 收到 /demo/hello
Tomcat 找到 demo 应用
Tomcat 在 demo 应用里找 /hello 映射
Tomcat 找到 HelloServlet
Tomcat 调用 doGet/doPost
Servlet 生成响应
Tomcat 返回给浏览器

这就是 war 放进 Tomcat 后发生的核心过程。

---

十一、JSP、Servlet 和 MVC

早期 Java Web 项目常用 JSP + Servlet 组合。

为了让代码不混乱，后来大家形成了 MVC 思想。

MVC 是：

Model      模型，负责数据和业务
View       视图，负责页面展示
Controller 控制器，负责接收请求、调用业务、决定返回哪个页面

在传统 JSP + Servlet 项目里，可以这样对应：

Servlet          Controller
JSP              View
JavaBean/Service Model 或业务逻辑

比如登录流程：

浏览器提交登录表单
  ↓
LoginServlet 接收 username/password
  ↓
LoginServlet 调用 UserService
  ↓
UserService 判断用户名密码
  ↓
LoginServlet 把结果放到 request
  ↓
转发到 success.jsp 或 login.jsp

Servlet 适合写控制逻辑：

接收参数
调用 Service
处理跳转
决定返回 JSON 还是 JSP

JSP 适合写页面展示：

HTML
表单
动态展示数据

Service 适合写业务逻辑：

登录校验
订单计算
用户查询
数据保存

这样分层后，代码会比“所有 Java 代码都写在 JSP 里”清楚很多。

---

十二、和 Spring MVC / Spring Boot 的关系

现代 Java Web 项目里，你可能很少直接写原生 Servlet 或 JSP。

但 Spring MVC 和 Spring Boot 并不是凭空出现的。它们仍然和 Servlet 体系有很深关系。

1. Spring MVC 的 DispatcherServlet

Spring MVC 的核心入口是：

DispatcherServlet

它本身就是一个 Servlet。

传统 Servlet 项目里，可能是：

/hello -> HelloServlet
/login -> LoginServlet
/order -> OrderServlet

Spring MVC 里，常见模式是：

所有请求先进入 DispatcherServlet
DispatcherServlet 再分发给不同 Controller 方法

流程类似：

浏览器请求 /users/1
  ↓
Tomcat
  ↓
DispatcherServlet
  ↓
UserController.getUser()
  ↓
返回 JSON 或页面

所以你在 Spring MVC 里写：

@GetMapping("/hello")
public String hello() {
    return "hello";
}

底层仍然离不开 Servlet 容器。

2. Spring Boot 内嵌 Tomcat

传统部署是：

先安装 Tomcat
把 demo.war 放进 Tomcat/webapps
启动 Tomcat

Spring Boot 常见部署是：

打成 app.jar
java -jar app.jar

为什么 jar 可以直接运行 Web 应用？

因为 Spring Boot 可以把 Tomcat 内嵌到 jar 里。

也就是说：

传统方式：外部 Tomcat 运行你的 war
Spring Boot：你的 jar 里带着一个内嵌 Tomcat

对比一下：

传统 Java Web：
Tomcat -> 加载 demo.war -> 运行应用Spring Boot：
java -jar app.jar -> 启动内嵌 Tomcat -> 运行应用

所以 Spring Boot 不是不需要 Tomcat，而是：

Tomcat 被打进应用内部，由 Spring Boot 自动启动。

3. 为什么还要学 Servlet、Tomcat、JSP

即使现代项目很少直接写 JSP 和原生 Servlet，理解它们仍然很有价值。

因为很多 Spring Web 问题底层仍然是这些概念：

端口为什么是 8080
请求为什么是 404
为什么 Controller 没被调用
为什么上传文件大小受限制
为什么 Filter 能拦截请求
为什么 Session、Cookie 能工作
为什么内嵌 Tomcat 可以启动 Web 服务

学 Servlet、Tomcat、JSP，不是为了永远写老式项目，而是为了看懂 Java Web 的地基。

---

十三、常见问题和排错

Java Web 初学时，经常遇到这些问题。

1. 404 Not Found

404 表示：

服务器收到了请求，但找不到对应资源或映射。

常见原因：

应用名写错
URL 路径写错
Servlet 映射写错
war 没部署成功
访问了 WEB-INF 下的 JSP
Tomcat 没加载到你的应用

例如你的 war 叫：

demo.war

Servlet 映射是：

@WebServlet("/hello")

正确访问通常是：

如果你访问：

可能就会 404，因为少了应用名 /demo。

2. 500 Internal Server Error

500 表示：

服务器内部出错了。

常见原因：

Servlet 代码抛异常
JSP 编译失败
空指针异常
数据库连接失败
依赖缺失

排查时要看 Tomcat 控制台或日志。

不要只看浏览器上的 500 页面，真正原因通常在服务端异常栈里。

3. 8080 端口被占用

如果 Tomcat 启动失败，提示端口占用，说明已有程序占用了 8080。

解决方式：

关闭占用 8080 的程序
或者修改 Tomcat 端口

Tomcat 端口通常在：

conf/server.xml

类似：

<Connector port="8080" protocol="HTTP/1.1" />

可以改成：

<Connector port="8081" protocol="HTTP/1.1" />

然后访问：

4. javax.servlet 和 jakarta.servlet 冲突

如果你看到类似错误：

ClassNotFoundException: javax.servlet.http.HttpServlet
ClassNotFoundException: jakarta.servlet.http.HttpServlet

要检查三件事：

代码 import 是 javax 还是 jakarta
Maven 依赖是 javax.servlet-api 还是 jakarta.servlet-api
Tomcat 版本支持哪一套

简单规则：

Tomcat 9 及以前常见 javax.servlet
Tomcat 10+ 使用 jakarta.servlet

不要代码用 javax，依赖用 jakarta，Tomcat 又是另一个版本。三者要一致。

5. JSP 修改不生效

可能原因：

浏览器缓存
Tomcat 缓存
IDE 没重新部署
war 没重新打包
访问的不是你以为的那个 Tomcat

可以尝试：

刷新浏览器
重启 Tomcat
清理 Tomcat work 目录
重新 mvn clean package
重新部署 war
确认访问路径和部署路径一致

6. war 部署后没有生效

常见原因：

war 名字和访问路径不一致
Tomcat 没启动成功
war 解压失败
项目缺依赖
Servlet API 版本和 Tomcat 不匹配

排查顺序可以是：

看 Tomcat 是否启动
看 webapps 下 war 是否解压
看 logs 里是否有异常
确认访问路径
确认 Servlet 映射
确认依赖和 Tomcat 版本

---

十四、把整条 Java Web 主线串起来

最后，我们把 Servlet、Tomcat、JSP 串成一条线。

你写 Java Web 项目时，源码可能是：

Servlet
Service
JSP
HTML/CSS/JS
配置文件

Maven 把它们打成：

demo.war

你把 demo.war 放进 Tomcat：

Tomcat/webapps/demo.war

Tomcat 启动后：

解压 war
加载 class
加载依赖 jar
读取 web.xml 或扫描 @WebServlet
建立 URL 到 Servlet 的映射
监听 8080 端口

浏览器访问：

请求流程是：

浏览器发 HTTP 请求
  ↓
Tomcat 接收请求
  ↓
Tomcat 找到 demo 应用
  ↓
Tomcat 根据 /hello 找到 HelloServlet
  ↓
HelloServlet 处理请求
  ↓
可能转发到 JSP
  ↓
JSP 生成 HTML
  ↓
Tomcat 返回 HTTP 响应
  ↓
浏览器显示页面

如果用 Spring Boot，流程看起来变了：

java -jar app.jar

但底层仍然有：

内嵌 Tomcat
Servlet 容器
DispatcherServlet
Controller
HTTP 请求和响应

所以你可以这样总结：

Tomcat 是 Java Web 应用的运行环境。
Servlet 是处理 HTTP 请求的 Java 组件。
JSP 是生成动态 HTML 的页面技术，最终也会变成 Servlet。
Maven 负责把项目打成 war。
浏览器通过 HTTP 请求访问 Tomcat，Tomcat 再调用你的 Java 代码。

---

十五、学习路线

如果你想真正掌握 Java Web，可以按这个顺序学：

第一步，理解 HTTP：

请求
响应
GET
POST
状态码
请求头
请求体

第二步，理解 Tomcat：

监听端口
部署 war
context path
webapps
logs

第三步，理解 Servlet：

HttpServlet
doGet
doPost
request
response
@WebServlet

第四步，理解 JSP：

动态 HTML
EL 表达式
Servlet 转发
WEB-INF

第五步，理解 Maven 和 war：

packaging=war
maven-war-plugin
scope=provided
target/demo.war

第六步，理解 MVC：

Servlet 做 Controller
JSP 做 View
Service/JavaBean 做业务和数据

第七步，再看 Spring MVC / Spring Boot：

DispatcherServlet
Controller
内嵌 Tomcat
可执行 jar

学到这里，你再看 Spring Boot Web 项目，就不会只觉得它是魔法。你会知道：它只是把传统 Java Web 里的很多配置和部署细节自动化了，但底层主线仍然是 HTTP、Tomcat、Servlet 和请求响应。

---

最后一句话

Servlet、Tomcat、JSP 这三个概念看起来老，但它们是 Java Web 的地基。

抓住这一条就够了：

浏览器发请求，
Tomcat 接请求，
Servlet 处理请求，
JSP 生成页面，
Tomcat 返回响应。

理解这条线，你就真正知道 Java Web 是怎么跑起来的了。