第03章-Servlet6.0核心
第 03 章 Servlet 6.0 核心
Servlet 是 JavaWeb 的核心组件,本章内容是后续所有章节的主干:JSP 最终会被编译成 Servlet,Filter、Listener 是 Servlet 规范的配套组件,转发重定向、会话跟踪也都依托 Servlet 的请求响应对象完成。
本章学习目标
- 理解 Servlet 的本质、定位和版本对应关系
- 能独立创建 Maven 版 JavaWeb 工程并在 IDEA 中配置 Tomcat 部署
- 掌握注解和 XML 两种 Servlet 配置方式
- 掌握 Servlet 生命周期,理解单实例多线程模型
- 掌握 HttpServletRequest 和 HttpServletResponse 的常用方法
- 理解 JSON 结构,掌握对象序列化与反序列化
- 完成五个上机实验,每个实验均含完整代码和预期结果
3.1 认识 Servlet
3.1.1 Servlet 的本质
Servlet 是运行在 Web 服务器(如 Tomcat)中的 Java 类,专门负责三件事:
- 接收客户端发来的 HTTP 请求
- 在服务端执行业务逻辑,例如校验参数、查询数据库
- 生成动态 HTTP 响应,例如输出 HTML 片段或 JSON 数据
它处于浏览器和后端服务之间的桥梁位置。浏览器不能直接调用普通 Java 类的方法,只有实现了 Servlet 规范、并交给容器管理的类才能被 HTTP 请求访问到。
3.1.2 版本与包名
这是初学者最容易踩的坑,必须先分清:
- Servlet 6.0 属于 Jakarta EE 10 规范,包名统一以 jakarta.servlet 开头,运行在 Tomcat 10 及以上版本
- 旧版本属于 Java EE 规范,包名以 javax.servlet 开头,运行在 Tomcat 9 及以下版本
两套包名互不兼容。如果在 Tomcat 10 中导入 javax.servlet 的类,会直接报类找不到错误。本套教程全部使用 jakarta 包名。
3.1.3 第一个 Servlet 的工作流程
浏览器发出请求后,容器内部的处理顺序:
- Tomcat 监听端口收到请求,根据请求 URI 找到匹配的 Servlet
- 若该 Servlet 还没实例化,先创建对象并执行初始化
- 容器把请求数据封装成 HttpServletRequest 对象,同时创建一个空的 HttpServletResponse 对象
- 调用 Servlet 的服务方法,方法内从 request 取数据、向 response 写结果
- 容器从 response 中取出数据,组装成 HTTP 响应发回浏览器
3.2 创建 JavaWeb 工程
3.2.1 工程目录结构
Maven 版 Web 工程遵循标准目录约定:
javaweb-demo/
├─ pom.xml
├─ src/
│ └─ main/
│ ├─ java/
│ │ └─ com/iooi/
│ │ ├─ servlet/ # Servlet 类
│ │ ├─ entity/ # 实体类
│ │ └─ service/ # 业务逻辑类
│ └─ webapp/
│ ├─ index.jsp # 默认首页
│ ├─ static/ # 静态资源
│ │ ├─ css/
│ │ ├─ js/
│ │ └─ img/
│ └─ WEB-INF/
│ └─ web.xml # Web 配置文件
└─ target/ # 构建输出目录,自动生成
两个目录需要特别理解:
- src/main/java:放 Java 源码,编译后的 class 会被复制到 WEB-INF/classes
- WEB-INF:受保护目录,浏览器无法直接输入 URL 访问其中的文件,只能通过 Servlet 转发访问,适合放安全要求高的页面
3.2.2 新建工程步骤
- 在 IDEA 欢迎页选择 New Project
- 左侧选择 Jakarta EE(部分版本在 Generators 中选 Web Application),JDK 选择 21
- Template 选择 Web application,实现服务器选择 Tomcat 10
- 勾选 Servlet 依赖,创建后在 pom.xml 中确认依赖坐标
- 若使用纯 Maven 手工创建,新建空工程后按 3.2.1 结构补齐目录,并在 src/main 下手动建立 webapp/WEB-INF
3.2.3 完整 pom.xml
下面是本章工程统一使用的配置,包含 Servlet API、JSTL 和 FastJSON2:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.iooi</groupId>
<artifactId>demo</artifactId>
<version>1.0-SNAPSHOT</version>
<name>demo</name>
<packaging>war</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.target>21</maven.compiler.target>
<maven.compiler.source>21</maven.compiler.source>
<junit.version>5.13.2</junit.version>
</properties>
<dependencies>
<dependency>
<groupId>jakarta.servlet</groupId>
<artifactId>jakarta.servlet-api</artifactId>
<version>6.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.32</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>jakarta.servlet.jsp.jstl</artifactId>
<version>3.0.1</version>
</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>
Servlet 依赖的 scope 设为 provided,因为 Tomcat 的 lib 目录中已经自带该接口实现,打包时不应重复包含。
3.2.4 在 IDEA 中配置 Tomcat 并部署
- 点击右上角 Add Configuration(添加运行配置)
- 点击加号,选择 Tomcat Server、Local
- 在 Application server 处选择本地 Tomcat 10 解压目录
- HTTP port 默认 8080,可按需修改
- 切换到 Deployment 标签页,点击加号选择 Artifact
- 选择 javaweb-demo:war exploded,下方 Application context 设置为 /demo(即访问路径前缀)
- 回到 Server 标签页,勾选 On frame deactivation 为 Update classes and resources,便于修改后自动同步
war exploded 是以展开目录形式部署,开发阶段改代码不用重新打包;正式发布才使用 war 包。
3.3 编写第一个 Servlet
3.3.1 注解方式配置
Servlet 3.0 开始支持注解配置,也是现在的主流写法。在类上标注 @WebServlet 即可声明访问路径,不需要再写 web.xml。
完整代码:
package com.iooi.servlet;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter writer = response.getWriter();
writer.write("<h1 style='color:red;'>你好,Servlet</h1>");
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws IOException {
doGet(request, response);
}
}
运行结果:

3.3.2 XML 方式配置
注解出现之前统一使用 web.xml 配置,理解它有助于阅读老项目。先编写不带注解的 Servlet:
package com.iooi.servlet;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
public class XmlServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html; charset = UTF-8");
PrintWriter writer = resp.getWriter();
writer.write("<h1>XML方式配置的Servlet</h1>");
}
}
在 web.xml 中完成类与路径的映射:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
version="6.0">
<!-- servlet 标签把名称绑定到具体类-->
<servlet>
<servlet-name>xmlServlet</servlet-name>
<servlet-class>com.iooi.servlet.XmlServlet</servlet-class>
</servlet>
<!-- servlet-mapping 标签把同一个名称绑定到访问路径-->
<servlet-mapping>
<servlet-name>xmlServlet</servlet-name>
<url-pattern>/xml</url-pattern>
</servlet-mapping>
</web-app>
配置分为两段:servlet 标签把名称绑定到具体类,servlet-mapping 标签把同一个名称绑定到访问路径,两段通过 servlet-name 对应。
3.3.3 url-pattern 的匹配规则
一个 Servlet 可以配置多个路径,注解写法:
@WebServlet({"/hello", "/hi"})
路径匹配支持三种形式:
- 精确匹配:/user/login,只匹配这一个地址
- 目录匹配:/admin/*,匹配该目录下所有请求
- 扩展名匹配:*.do,匹配所有以 .do 结尾的请求
注意 / 不会匹配 JSP,而 /* 会拦截包括 JSP 在内的全部请求,二者在后续默认 Servlet 场景中再展开。
3.4 Servlet 生命周期
3.4.1 四个阶段
| 阶段 | 触发时机 | 对应方法 | 执行次数 |
|---|---|---|---|
| 实例化 | 首次访问时,或容器启动时(配置 loadOnStartup) | 无参构造方法 | 一次 |
| 初始化 | 实例化之后立即执行 | init | 一次 |
| 服务 | 每次请求到达时 | service 以及 doGet、doPost 等 | 多次 |
| 销毁 | 容器正常关闭或应用卸载时 | destroy | 一次 |
3.4.2 生命周期验证代码
package com.iooi.servlet;
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(urlPatterns = "/life", loadOnStartup = 1)
public class LifeServlet extends HttpServlet {
public LifeServlet() {
System.out.println("1. 实例化:构造方法执行");
}
@Override
public void init() {
System.out.println("2. 初始化:init 方法执行");
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException {
System.out.println("3. 服务:doGet 方法执行");
response.getWriter().write("生命周期测试");
}
@Override
public void destroy() {
System.out.println("4. 销毁:destroy 方法执行");
}
}
[!IMPORTANT] ❗ 实验结果
启动 Tomcat 服务器,项目部署完成后控制台输出:1. 实例化:构造方法执行 2. 初始化:init 方法执行打开浏览器访问该 Servlet,页面显示 “生命周期测试”。多次刷新页面,控制台持续打印:
3. 服务:doGet 方法执行没有再次出现实例化、初始化的日志。 执行关闭 Tomcat 操作,服务器停止前控制台输出:
4. 销毁:destroy 方法执行Servlet 生命周期依次为实例化、初始化、提供服务、销毁。服务器启动时,本 Servlet 完成实例化与初始化;多次刷新页面只会重复执行服务方法,实例化和初始化仅执行一次;服务器正常关闭时执行销毁方法。
3.4.3 单实例多线程
容器对每个 Servlet 类只创建一个对象,所有请求共享这一个实例。请求量大时,容器会为每个请求分配一个独立线程,并发调用同一个对象的服务方法。
由此得到两条编码纪律:
- 不要在 Servlet 的成员变量中存放请求级数据,多个线程会互相覆盖,存在线程安全问题
- 局部变量存放在每个线程自己的栈中,天然安全,请求数据应使用局部变量或 request 对象携带
3.4.4 loadOnStartup 与初始化参数
不配置 loadOnStartup 时,Servlet 默认在第一次被访问时才实例化,第一次响应会稍慢。设置 loadOnStartup 为正整数后,容器启动时就创建并初始化,数字越小优先级越高。
通过注解传递初始化参数:
@WebServlet(urlPatterns = "/param", initParams = {
@WebInitParam(name = "encoding", value = "UTF-8")
}, loadOnStartup = 2)
在 init 方法中读取:
@Override
public void init() {
String encoding = getInitParameter("encoding");
System.out.println("初始化参数 encoding=" + encoding);
}
3.5 HttpServletRequest 详解
3.5.1 对象的作用
request 对象封装了本次请求的全部信息:请求参数、请求路径、请求方法、请求头、Cookie、会话等。它由容器在每次请求时创建,请求处理结束后销毁。
3.5.2 常用方法
| 方法 | 作用 |
|---|---|
| getParameter(String name) | 获取单个参数值,适用于文本框、隐藏域 |
| getParameterValues(String name) | 获取多个同名参数,适用于复选框、多选下拉框 |
| getParameterMap() | 获取全部参数,键为参数名,值为参数数组 |
| getRequestURI() | 获取请求 URI,即端口之后的路径部分 |
| getRequestURL() | 获取完整 URL,包含协议、域名和端口 |
| getMethod() | 获取请求方法,如 GET、POST |
| getHeader(String name) | 获取指定请求头 |
| getContextPath() | 获取应用上下文路径 |
| setCharacterEncoding(String env) | 设置请求体解码编码,解决 POST 中文乱码 |
| getRequestDispatcher(String path) | 获取转发器,用于请求转发 |
3.5.3 参数获取示例(通过 get 方式)
package com.iooi.servlet;
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;
import java.io.PrintWriter;
@WebServlet("/user")
public class UserServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html; charset=utf-8");
String name = req.getParameter("name");
String age = req.getParameter("age");
String[] hobbies = req.getParameterValues("hobby");
System.out.println("URI: " + req.getRequestURI());
System.out.println("URL: " + req.getRequestURL());
System.out.println("方法:" + req.getMethod());
PrintWriter writer = resp.getWriter();
writer.write("姓名:" + name + "<br>");
writer.write("年龄:" + age + "<br>");
if (hobbies != null) {
for (String hobby : hobbies) {
writer.write("爱好:" + hobby + "<br>");
}
}
}
}
[!IMPORTANT] ❗ 运行结果
访问:http://localhost:8080/user?name=Bam&age=20&hobby=阅读&hobby=跑步控制台输出:
URI: /user URL: http://localhost:8080/user 方法:GET浏览器页面输出:
姓名:Bam 年龄:20 爱好:阅读 爱好:跑步tips
getParameter("name") 获取 Bam;getParameter("age") 获取 20getParameterValues("hobby") 拿到数组 ["阅读","跑步"],循环遍历输出- 请求方式是 GET,
req.setCharacterEncoding("utf-8")对 GET 不起作用,这里中文正常是因为 Tomcat 默认编码 / 浏览器传参没有乱码- 多次同名参数
hobby 会被 getParameterValues全部接收
3.5.4 参数获取示例(通过 post 方式)
user2.java -> 置于 Java 的软件包下
package com.iooi.servlet;
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;
import java.io.PrintWriter;
@WebServlet("/user2")
public class UserServlet2 extends HttpServlet {
/**
* 处理前端 user2.html 表单以 POST 方式提交的请求(/user2)。
* 主要流程:设置编码 -> 获取表单参数 -> 打印请求信息 -> 将结果以 HTML 响应回浏览器。
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// POST设置编码,解决中文乱码
// 注意:req 的编码必须在调用 getParameter 之前设置才有效;
// resp 的 contentType 同时指定响应内容类型为 HTML 并让浏览器以 utf-8 解析
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html; charset=utf-8");
// 读取表单提交的参数:
// getParameter 用于获取单值参数(文本框、下拉框等),参数不存在时返回 null
String name = req.getParameter("name");
String age = req.getParameter("age");
// getParameterValues 用于获取多值参数(如一组同名 checkbox),返回数组,可能为 null
String[] hobbies = req.getParameterValues("hobby");
// 在服务器控制台打印请求的元信息,便于调试:
// getRequestURI 返回资源路径部分(如 /user2)
// getRequestURL 返回完整 URL(含协议、主机、端口、路径)
System.out.println("URI: " + req.getRequestURI());
System.out.println("URL: " + req.getRequestURL());
System.out.println("方法:" + req.getMethod());
// 通过响应输出流向浏览器写出 HTML 内容,<br> 用于在页面上换行显示
PrintWriter writer = resp.getWriter();
writer.write("姓名:" + name + "<br>");
writer.write("年龄:" + age + "<br>");
// 未勾选任何爱好时 hobbies 为 null,需先判空避免空指针异常
if (hobbies != null) {
for (String hobby : hobbies) {
writer.write("爱好:" + hobby + "<br>");
}
}
// writer 随响应结束自动关闭,无需手动调用 close
}
}
user2.html -> 置于 web-app 包下
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>POST提交</title>
</head>
<body>
<form action="/user2" method="post">
姓名:<input type="text" name="name"><br>
年龄:<input type="text" name="age"><br>
爱好:
<input type="checkbox" name="hobby" value="阅读">阅读
<input type="checkbox" name="hobby" value="跑步">跑步
<br>
<input type="submit" value="提交">
</form>
</body>
</html>
[!TIP] 💡 运行结果
访问
http://localhost:8080/user2.html,页面展示表单,包含姓名输入框、年龄输入框、爱好复选框与提交按钮。 在表单中填入姓名:Bam,年龄:18,勾选阅读、跑步两个爱好,点击提交按钮,表单以 POST 方式提交至 /user2。 浏览器页面回显:姓名:Bam 年龄:18 爱好:阅读 爱好:跑步控制台打印输出:
URI: /user2 URL: http://localhost:8080/user2 方法:POST
Tips:
- 表单设置
method="post",参数封装在请求体中,地址栏不会拼接参数;req.setCharacterEncoding("utf-8")对 POST 请求生效,避免中文乱码;getParameter() 获取单个参数 name、age;getParameterValues()获取同名复选框 hobby 的数组;getRequestURI() 获取资源路径 /user2,getRequestURL()获取完整访问地址;- 提交方式为 POST,进入 Servlet 的
doPost方法处理请求;- POST 请求将表单数据存放于请求体进行传输,适合表单提交场景。
3.5.5 中文乱码问题
GET 和 POST 的乱码处理方式不同:
- POST:参数在请求体中,在取参数之前执行 request.setCharacterEncoding ("UTF-8") 即可
- GET:参数拼在 URL 上,编码由服务器连接器决定,Tomcat 10 默认已按 UTF-8 处理,通常无需额外设置;如仍乱码可手动按 ISO-8859-1 取回字节再用 UTF-8 解码
手动解码写法:
String raw = request.getParameter("name");
String name = new String(raw.getBytes("ISO-8859-1"), "UTF-8");
3.6 HttpServletResponse 详解
3.6.1 对象的作用
response 对象用来封装服务器要返回给浏览器的内容:状态码、响应头、输出流。Servlet 向其中写入数据,容器再把它组装成 HTTP 响应。
3.6.2 常用方法
| 方法 | 作用 |
|---|---|
| setContentType(String type) | 设置响应内容类型和编码 |
| setCharacterEncoding(String charset) | 单独设置响应编码 |
| setStatus(int sc) | 设置响应状态码 |
| getWriter() | 获取字符输出流,输出文本、HTML、JSON |
| getOutputStream() | 获取字节输出流,输出图片、文件等二进制数据 |
| sendRedirect(String location) | 发送重定向,浏览器重新发起请求 |
| setHeader(String name, String value) | 设置响应头 |
| addCookie(Cookie cookie) | 向响应中添加 Cookie |
3.6.3 输出 JSON 示例
package com.iooi.servlet;
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("/resp")
public class RespServlet extends HttpServlet {
/**
* 处理浏览器以 GET 方式访问 /resp 的请求。
* 主要流程:设置响应编码 -> 向浏览器写回一段 JSON 格式的数据。
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置响应内容类型和字符编码,解决中文乱码:
// charset=utf-8 让浏览器以 utf-8 解析响应,避免 JSON 中的中文(如“张三”)显示乱码
resp.setContentType("text/html; charset=utf-8");
// 链式调用:getWriter() 获取响应字符输出流,write() 将手写的 JSON 字符串直接写回浏览器
// 注意:该 JSON 是硬编码的模拟数据,实际项目中通常由 Java 对象序列化生成
resp.getWriter().write("{\"name\":\"张三\",\"age\":18}");
// 输出流随响应结束自动关闭,无需手动调用 close 或 flush
}
}
3.6.4 字符流与字节流的选择
- getWriter 返回字符流,适合处理文本类内容:HTML、JSON、纯文本
- getOutputStream 返回字节流,适合处理二进制内容:图片、下载文件、视频
两个输出流在同一个响应中不能同时使用,否则抛出非法状态异常。
// 错误写法,会抛 IllegalStateException
// PrintWriter w = resp.getWriter();
// OutputStream o = resp.getOutputStream();
3.7 JSON 与序列化
3.7.1 JSON 的数据结构
JSON(JavaScript Object Notation)是一种轻量级数据交换格式,与编程语言无关,支持六种数据类型:
| 类型 | 说明 | 示例 |
|---|---|---|
| 字符串 | 必须使用双引号 | "name": "张三" |
| 数字 | 整数或小数,不加引号 | "age": 20 |
| 布尔 | true 或 false | "valid": true |
| 数组 | 方括号包裹的有序集合 | "hobbies": ["阅读","跑步"] |
| 对象 | 花括号包裹的键值对集合 | |
| null | 空值 | "remark": null |
3.7.2 序列化与反序列化
- 序列化:把内存中的 Java 对象转换成 JSON 字符串,便于网络传输
- 反序列化:把 JSON 字符串还原成 Java 对象,便于程序调用其属性和方法
常用类库有 FastJSON2、Jackson、Gson。本章使用 FastJSON2,核心两个静态方法:
- JSON.toJSONString (对象):序列化
- JSON.parseObject (json 字符串,类.class):反序列化
3.7.3 实体类
package com.iooi.entity;
public class User {
private String name;
private int age;
private String[] hobbies;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String[] getHobbies() {
return hobbies;
}
public void setHobbies(String[] hobbies) {
this.hobbies = hobbies;
}
}
反序列化依赖无参构造方法和 setter,二者缺一不可。
3.7.4 序列化 Servlet
package com.iooi.servlet;
import com.alibaba.fastjson2.JSON;
import com.iooi.entity.User;
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("/serialize")
public class JsonSerializeServlet extends HttpServlet {
/**
* 处理浏览器以 GET 方r式访问 /serialize 的请求,演示 Java 对象序列化为 JSON。
* 主要流程:构造 Java 对象 -> 设置响应编码 -> 用 fastjson2 序列化后写回浏览器。
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 构造 User 对象并设置属性,作为待序列化的源数据(实际项目中通常来自数据库查询)
User user = new User();
user.setName("张三");
user.setAge(18);
// 数组类型的属性也会被 fastjson2 序列化为 JSON 数组,如 "hobbies":["阅读","跑步"]
user.setHobbies(new String[]{"阅读", "跑步"});
// 设置响应内容类型为 application/json,让浏览器/前端识别这是 JSON 数据;
// charset=utf-8 保证中文不乱码(相比上一个 Servlet 的 text/html,这里更规范)
resp.setContentType("application/json; charset=utf-8");
// JSON.toJSONString(user) 是 fastjson2 的序列化方法:
// 通过反射读取对象的 getter 方法,自动生成 {"name":"张三","age":18,...} 格式的 JSON 字符串,
// 免去手写 JSON 的繁琐与易错,再经响应输出流写回浏览器
resp.getWriter().write(JSON.toJSONString(user));
// 输出流随响应结束自动关闭,无需手动调用 close 或 flush
}
}
[!TIP] 💡 运行结果
启动 Tomcat 服务器,在浏览器地址栏访问
http://localhost:8080/serialize,页面直接输出 JSON 字符串:{"age":18,"hobbies":["阅读","跑步"],"name":"张三"}
- Java 对象中的普通属性
name、age成功转换为 JSON 键值对;字符串数组hobbies成功转换为 JSON 数组格式["阅读","跑步"]。- 输出 JSON 中的键顺序为 age、hobbies、name,是 Fastjson2 默认按照字段名字典序排序的结果,和代码中 set 赋值顺序不一致。
- 中文 “阅读”“跑步” 显示正常,没有出现中文乱码,
application/json; charset=utf-8配置生效。- 浏览器识别返回数据为 JSON 类型,而非普通网页文本。
3.7.5 反序列化 Servlet
package com.iooi.servlet;
import com.alibaba.fastjson2.JSON;
import com.iooi.entity.User;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
@WebServlet("/deserialize")
public class JsonDeserializeServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws IOException {
StringBuilder builder = new StringBuilder();
try (BufferedReader reader = request.getReader()) {
String line;
while ((line = reader.readLine()) != null) {
builder.append(line);
}
}
User user = JSON.parseObject(builder.toString(), User.class);
response.setContentType("text/plain;charset=UTF-8");
response.getWriter().write("反序列化结果:" + user.getName() + "," + user.getAge() + "岁");
}
}
try-with-resources 语法会在读取结束后自动关闭输入流,不需要手动 close。
[!TIP] 💡 使用 PostMan 验证实验结果
- 登录 PostMan 后,选择左边的 Post
① 在请求地址栏填写接口地址:
http://localhost:8080/deserialize,请求方法保持为 POST。② 切换到
Body 标签页,选择 raw,右侧下拉框数据格式选择 JSON。③ 在下方编辑框内填入测试 JSON 报文:
{ "name":"张三", "age":18, "hobbies":["阅读","跑步"] }④ 确认配置无误后,点击右上角蓝色
Send按钮发送请求,查看下方响应区域的返回结果,同时观察 IDEA 控制台输出。
运行结果
发送 POST 请求后:
① Postman 响应区(页面返回)
反序列化结果:张三,18岁 爱好:阅读 爱好:跑步后端读取 JSON 里的 name、age、hobbies。
② IDEA 控制台会打印
User对象:User{name='张三', age=18, hobbies=[阅读, 跑步]}代表 Fastjson2 已经成功把 JSON 字符串,转换成了 Java 的 User 实体对象。
③ 状态码成功时返回 200 OK,代表请求正常处理。
3.8 上机实操
实验一:创建并部署 Web 工程
实验目的:跑通工程创建、Tomcat 配置、启动访问的完整链路。
步骤:
- 按 3.2 节创建 javaweb-demo 工程,使用 3.2.3 的完整 pom.xml
- 在 webapp 下保留 index.jsp,内容如下:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>首页</title>
</head>
<body>
<h1>工程部署成功</h1>
</body>
</html>
- 按 3.2.4 配置 Tomcat,Application context 设为 /demo
- 点击绿色运行按钮,等待控制台输出启动成功
- 浏览器访问:
http://localhost:8080/demo/
预期结果:浏览器显示 “工程部署成功”。
实验二:第一个注解 Servlet
实验目的:验证注解路径映射和字符输出流。
步骤:
- 新建 HelloServlet,使用 3.3.1 的完整代码
- 重启应用,浏览器访问:
http://localhost:8080/demo/hello
预期结果:页面显示红色标题 “你好,Servlet”。
控制台同时输出 GET 请求的访问记录,状态码为 200。
实验三:生命周期观察
实验目的:通过日志确认四个阶段的执行时机和次数。
步骤:
- 新建 LifeServlet,使用 3.4.2 的代码,配置 loadOnStartup 为 1
- 重启 Tomcat,先不访问任何页面,观察控制台
启动阶段预期输出:
1. 实例化:构造方法执行
2. 初始化:init 方法执行
- 浏览器连续刷新三次:
http://localhost:8080/demo/life
预期输出:doGet 日志出现三次,构造方法和 init 不再执行。
- 正常停止 Tomcat,预期输出:
4. 销毁:destroy 方法执行
结论:实例化和初始化只执行一次,服务方法每次请求都执行,销毁在容器关闭时执行一次。
实验四:请求参数获取
实验目的:掌握单值、多值参数和请求信息的获取方式。
步骤:
- 新建 UserServlet,使用 3.5.3 的代码
- 浏览器直接访问以下地址:
http://localhost:8080/demo/user?name=张三&age=20&hobby=阅读&hobby=跑步
页面预期结果:
姓名:张三
年龄:20
爱好:阅读
爱好:跑步
控制台预期结果:
URI:/demo/user
URL:http://localhost:8080/demo/user
方法:GET
实验五:JSON 序列化与反序列化
实验目的:掌握 FastJSON2 的两个核心方法。
序列化步骤:
- 新建实体类 User 和 JsonSerializeServlet,使用 3.7.3、3.7.4 的代码
- 浏览器访问:
http://localhost:8080/demo/serialize
预期结果(字段顺序可能不同,内容一致即可):
{"id":1,"name":"张三","age":22}
反序列化步骤:
- 新建 JsonDeserializeServlet,使用 3.7.5 的代码
- 使用接口测试工具或 curl 发送 POST 请求:
curl -X POST http://localhost:8080/demo/deserialize \
-H "Content-Type: application/json" \
-d '{"id":2,"name":"李四","age":25}'
预期结果:
反序列化结果:李四,25岁
3.9 常见问题排查
| 现象 | 原因 | 解决方式 |
|---|---|---|
| 提示 jakarta.servlet 包不存在 | 依赖未导入或误用了 javax 包 | 检查 pom.xml,确认 Tomcat 10 环境 |
| 访问路径报 404 | 路径拼写错误或应用未部署 | 核对 Application context 和 @WebServlet |
| POST 中文乱码 | 取参数前未设置请求编码 | 首行执行 setCharacterEncoding |
| 响应中文乱码 | 未设置响应内容类型 | setContentType 中加 charset=UTF-8 |
| 成员变量数据错乱 | 单实例多线程下共享变量 | 改用局部变量或 request 域 |
| getWriter 后再调用 getOutputStream 报错 | 两个流不能同时使用 | 按内容类型只选一个流 |
3.10 本章小结
- Servlet 是运行在容器中的 Java 类,Servlet 6.0 使用 jakarta 包名,对应 Tomcat 10 以上
- 注解 @WebServlet 是主流配置方式,XML 配置用于理解规范和维护老项目
- 生命周期为实例化、初始化、服务、销毁,容器内默认单实例、请求级多线程
- request 负责读取请求,response 负责写回响应,二者都由容器创建
- JSON 是跨语言数据交换格式,FastJSON2 通过 toJSONString 和 parseObject 完成双向转换
- 五个实验必须全部亲手跑通,下一章将学习用于展示层的 JSP、EL 与 JSTL









