10
0
2

第03章-Servlet6.0核心

2026-11-02

第 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 类,专门负责三件事:

  1. 接收客户端发来的 HTTP 请求
  2. 在服务端执行业务逻辑,例如校验参数、查询数据库
  3. 生成动态 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 的工作流程

  浏览器发出请求后,容器内部的处理顺序:

  1. Tomcat 监听端口收到请求,根据请求 URI 找到匹配的 Servlet
  2. 若该 Servlet 还没实例化,先创建对象并执行初始化
  3. 容器把请求数据封装成 HttpServletRequest 对象,同时创建一个空的 HttpServletResponse 对象
  4. 调用 Servlet 的服务方法,方法内从 request 取数据、向 response 写结果
  5. 容器从 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 新建工程步骤

  1. 在 IDEA 欢迎页选择 New Project
  2. 左侧选择 Jakarta EE(部分版本在 Generators 中选 Web Application),JDK 选择 21
  3. Template 选择 Web application,实现服务器选择 Tomcat 10
  4. 勾选 Servlet 依赖,创建后在 pom.xml 中确认依赖坐标
  5. 若使用纯 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 并部署

  1. 点击右上角 Add Configuration(添加运行配置)
  2. 点击加号,选择 Tomcat Server、Local
  3. 在 Application server 处选择本地 Tomcat 10 解压目录
  4. HTTP port 默认 8080,可按需修改
  5. 切换到 Deployment 标签页,点击加号选择 Artifact
  6. 选择 javaweb-demo:war exploded,下方 Application context 设置为 /demo(即访问路径前缀)
  7. 回到 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

  1. getParameter("name")​ 获取 ​Bam​;​getParameter("age")​ 获取 ​20
  2. getParameterValues("hobby")​ 拿到数组 ​["阅读","跑步"],循环遍历输出
  3. 请求方式是 GET,​req.setCharacterEncoding("utf-8") 对 GET 不起作用,这里中文正常是因为 Tomcat 默认编码 / 浏览器传参没有乱码
  4. 多次同名参数 ​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:

  1. 表单设置 ​method="post",参数封装在请求体中,地址栏不会拼接参数;
  2. req.setCharacterEncoding("utf-8") 对 POST 请求生效,避免中文乱码;
  3. getParameter()​ 获取单个参数 name、age;​getParameterValues() 获取同名复选框 hobby 的数组;
  4. getRequestURI()​ 获取资源路径 ​/user2​,​getRequestURL() 获取完整访问地址;
  5. 提交方式为 POST,进入 Servlet 的​doPost 方法处理请求;
  6. 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": ["阅读","跑步"]
对象 花括号包裹的键值对集合
"info": {
    "username": "Bam",
    "city": "广州",
    "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":"张三"}
  1. Java 对象中的普通属性​name​、​age​成功转换为 JSON 键值对;字符串数组​hobbies​成功转换为 JSON 数组格式​["阅读","跑步"]。
  2. 输出 JSON 中的键顺序为 age、hobbies、name,是 Fastjson2 默认按照字段名字典序排序的结果,和代码中 set 赋值顺序不一致。
  3. 中文 “阅读”“跑步” 显示正常,没有出现中文乱码,​application/json; charset=utf-8 配置生效。
  4. 浏览器识别返回数据为 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 验证实验结果

  1. 登录 PostMan 后,选择左边的 Post

  1. ① 在请求地址栏填写接口地址:​http://localhost:8080/deserialize​,请求方法保持为 ​POST。

    ② 切换到 ​Body​ 标签页,选择 ​raw​,右侧下拉框数据格式选择 JSON。

    ③ 在下方编辑框内填入测试 JSON 报文:

    {
        "name":"张三",
        "age":18,
        "hobbies":["阅读","跑步"]
    }
    

    ④ 确认配置无误后,点击右上角蓝色 ​Send 按钮发送请求,查看下方响应区域的返回结果,同时观察 IDEA 控制台输出。

‍

  1. 运行结果

    发送 POST 请求后:

    ① Postman 响应区(页面返回)

    反序列化结果:张三,18岁
    爱好:阅读
    爱好:跑步
    

    后端读取 JSON 里的 name、age、hobbies。

    ② IDEA 控制台会打印 ​User 对象:

    User{name='张三', age=18, hobbies=[阅读, 跑步]}
    

    代表 Fastjson2 已经成功把 JSON 字符串,转换成了 Java 的 User 实体对象。

    ③ 状态码成功时返回 200 OK,代表请求正常处理。

‍


3.8 上机实操

实验一:创建并部署 Web 工程

  实验目的:跑通工程创建、Tomcat 配置、启动访问的完整链路。

  步骤:

  1. 按 3.2 节创建 javaweb-demo 工程,使用 3.2.3 的完整 pom.xml
  2. 在 webapp 下保留 index.jsp,内容如下:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
    <h1>工程部署成功</h1>
</body>
</html>
  1. 按 3.2.4 配置 Tomcat,Application context 设为 /demo
  2. 点击绿色运行按钮,等待控制台输出启动成功
  3. 浏览器访问:
http://localhost:8080/demo/

  预期结果:浏览器显示 “工程部署成功”。

实验二:第一个注解 Servlet

  实验目的:验证注解路径映射和字符输出流。

  步骤:

  1. 新建 HelloServlet,使用 3.3.1 的完整代码
  2. 重启应用,浏览器访问:
http://localhost:8080/demo/hello

  预期结果:页面显示红色标题 “你好,Servlet”。

  控制台同时输出 GET 请求的访问记录,状态码为 200。

实验三:生命周期观察

  实验目的:通过日志确认四个阶段的执行时机和次数。

  步骤:

  1. 新建 LifeServlet,使用 3.4.2 的代码,配置 loadOnStartup 为 1
  2. 重启 Tomcat,先不访问任何页面,观察控制台

  启动阶段预期输出:

1. 实例化:构造方法执行
2. 初始化:init 方法执行
  1. 浏览器连续刷新三次:
http://localhost:8080/demo/life

  预期输出:doGet 日志出现三次,构造方法和 init 不再执行。

  1. 正常停止 Tomcat,预期输出:
4. 销毁:destroy 方法执行

  结论:实例化和初始化只执行一次,服务方法每次请求都执行,销毁在容器关闭时执行一次。

实验四:请求参数获取

  实验目的:掌握单值、多值参数和请求信息的获取方式。

  步骤:

  1. 新建 UserServlet,使用 3.5.3 的代码
  2. 浏览器直接访问以下地址:
http://localhost:8080/demo/user?name=张三&age=20&hobby=阅读&hobby=跑步

  页面预期结果:

姓名:张三
年龄:20
爱好:阅读
爱好:跑步

  控制台预期结果:

URI:/demo/user
URL:http://localhost:8080/demo/user
方法:GET

实验五:JSON 序列化与反序列化

  实验目的:掌握 FastJSON2 的两个核心方法。

  序列化步骤:

  1. 新建实体类 User 和 JsonSerializeServlet,使用 3.7.3、3.7.4 的代码
  2. 浏览器访问:
http://localhost:8080/demo/serialize

  预期结果(字段顺序可能不同,内容一致即可):

{"id":1,"name":"张三","age":22}

  反序列化步骤:

  1. 新建 JsonDeserializeServlet,使用 3.7.5 的代码
  2. 使用接口测试工具或 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

支持与分享

如果这篇文章对你有帮助,欢迎分享给更多人或者给予支持!

第03章-Servlet6.0核心
/archives/post-1793595347161
作者
Bam
发布于
2026-11-02
许可协议
CC BY-NC-SA 4.0

评论