JavaWeb 核心深度解析：Servlet 全家桶（原理 + 实战 + 踩坑）

原创于 2025-12-08 23:45:49 发布 · 672 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#servlet

1-Java基础同时被 2 个专栏收录

15 篇文章

订阅专栏

2-Java Web

11 篇文章

订阅专栏

作为 JavaWeb 的底层基石，Servlet 及周边组件的细节、原理、坑点直接决定了后端代码的稳定性。本文从底层原理、实战进阶、踩坑指南三个维度，把这些知识点讲透，覆盖企业开发的核心需求。

一、Servlet 配置：不止是 “贴名牌”，更是 “规则博弈”

Servlet 的配置核心是URL 映射规则——Tomcat 如何根据请求路径找到对应的 Servlet，这是极易踩坑的细节。

1. URL 映射的 3 种规则（及优先级）

Tomcat 的 URL 匹配遵循精确匹配 > 路径匹配 > 扩展名匹配的优先级，实战中必须明确：

精确匹配：路径完全一致，比如@WebServlet("/user")，仅匹配/user；
路径匹配：以/*结尾，比如@WebServlet("/user/*")，匹配/user/1、/user/detail；
扩展名匹配：以.xxx结尾，比如@WebServlet("*.do")，匹配/login.do、/order.do；
默认匹配：@WebServlet("/")，匹配所有未被其他规则匹配的请求（注意：会覆盖 Tomcat 默认的静态资源处理器，导致 CSS/JS 无法访问）。

2. 进阶配置：提前加载 Servlet

默认情况下，Servlet 在第一次请求时才会实例化，但可以通过load-on-startup让 Servlet 在 Tomcat 启动时就加载（适合初始化耗时的组件，比如加载配置文件）：

java

运行

// 注解版：loadOnStartup值越小，优先级越高（≥0）
@WebServlet(value = "/init", loadOnStartup = 1)
public class InitServlet extends HttpServlet {
    @Override
    public void init() throws ServletException {
        // Tomcat启动时执行：加载全局配置、初始化连接池等
        System.out.println("Tomcat启动时，我就初始化了！");
    }
}

// web.xml版：
<servlet>
    <servlet-name>InitServlet</servlet-name>
    <servlet-class>com.yourpackage.InitServlet</servlet-class>
    <load-on-startup>1</load-on-startup> <!-- 启动时加载 -->
</servlet>

3. 实战踩坑：URL 匹配冲突

如果同时配置了@WebServlet("/user/*")和@WebServlet("/user/detail")，请求/user/detail会匹配哪个？→ 优先匹配精确匹配的/user/detail，而非路径匹配的/user/*。

二、Servlet 生命周期：从 “出生” 到 “死亡” 的底层逻辑

Servlet 的生命周期由Tomcat 容器管理，核心是 “单例多线程”—— 一个 Servlet 类仅实例化一次，多请求共享同一个对象（因此 Servlet 类不能有线程不安全的成员变量）。

1. 生命周期的 4 个阶段（深化版）

阶段	触发时机	核心方法 & 作用
加载实例化	Tomcat 启动（load-on-startup）或第一次请求	调用构造方法：创建 Servlet 对象（仅 1 次）
初始化	实例化后立即执行	调用`init(ServletConfig config)`：初始化资源（如连接池），`ServletConfig`可获取配置参数
服务	每次请求	调用`service(HttpServletRequest req, HttpServletResponse resp)`：分发到`doGet/doPost`
销毁	Tomcat 关闭或应用卸载	调用`destroy()`：释放资源（如关闭连接池）

2. 进阶：通过 ServletConfig 获取配置参数

可以给 Servlet 配置专属参数，在init中通过ServletConfig获取：

java

运行

// 注解版：
@WebServlet(value = "/config", initParams = {
    @WebInitParam(name = "maxCount", value = "100"),
    @WebInitParam(name = "timeout", value = "5000")
})
public class ConfigServlet extends HttpServlet {
    private int maxCount;
    private int timeout;

    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config); // 必须调用父类方法，否则getServletConfig()会返回null
        // 获取初始化参数
        maxCount = Integer.parseInt(config.getInitParameter("maxCount"));
        timeout = Integer.parseInt(config.getInitParameter("timeout"));
        System.out.println("maxCount=" + maxCount + ", timeout=" + timeout);
    }
}

3. 实战踩坑：Servlet 的线程安全

错误写法（线程不安全）：

java

运行

@WebServlet("/unsafe")
public class UnsafeServlet extends HttpServlet {
    // 成员变量：多线程共享，会被并发修改
    private String username;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        username = req.getParameter("name");
        // 模拟耗时操作，此时其他请求可能修改username
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        resp.getWriter().write("Hello " + username);
    }
}

→ 正确做法：避免成员变量，用局部变量或ThreadLocal存储请求专属数据。

三、请求 & 响应：HTTP 协议的 “具象化”

HttpServletRequest/HttpServletResponse 是对 HTTP 协议的封装，底层是TCP 连接中的字节流——Tomcat 帮我们解析了 HTTP 报文，封装成对象。

1. 请求的进阶用法：处理复杂参数

（1）多值参数（复选框）：`getParameterMap`

java

运行

// 前端表单：<input type="checkbox" name="hobby" value="篮球">篮球
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    // 获取多值参数（返回Map<String, String[]>）
    Map<String, String[]> paramMap = req.getParameterMap();
    String[] hobbies = paramMap.get("hobby");
    if (hobbies != null) {
        String hobbyStr = String.join(",", hobbies);
        resp.getWriter().write("你的爱好：" + hobbyStr);
    }
}

（2）请求体数据（JSON/XML）：`getReader`

如果前端传的是 JSON（而非表单），需要读取请求体：

java

运行

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    // 读取请求体（JSON字符串）
    BufferedReader reader = req.getReader();
    String line;
    StringBuilder json = new StringBuilder();
    while ((line = reader.readLine()) != null) {
        json.append(line);
    }
    System.out.println("前端传的JSON：" + json); // 如：{"name":"张三","age":20}
}

2. 响应的进阶用法：状态码 & 文件下载

（1）手动设置状态码

java

运行

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    String id = req.getParameter("id");
    if (id == null) {
        resp.setStatus(400); // 400：请求参数错误
        resp.getWriter().write("缺少id参数");
        return;
    }
    // 其他逻辑...
}

（2）文件下载响应

java

运行

@WebServlet("/download")
public class DownloadServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // 1. 设置响应头：告诉浏览器这是文件下载
        resp.setContentType("application/octet-stream");
        resp.setHeader("Content-Disposition", "attachment;filename=test.txt");

        // 2. 读取服务器文件，写入响应流
        ServletContext context = getServletContext();
        InputStream in = context.getResourceAsStream("/WEB-INF/test.txt");
        OutputStream out = resp.getOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        while ((len = in.read(buffer)) != -1) {
            out.write(buffer, 0, len);
        }
        in.close();
    }
}

3. 底层原理：请求 / 响应的生命周期

请求对象（HttpServletRequest）：每个请求对应一个新的对象，请求结束后被 Tomcat 回收；
响应对象（HttpServletResponse）：与请求一一对应，响应完成后（out.close()）不能再操作，否则会抛IllegalStateException。

四、转发 & 重定向：底层流程与场景抉择

这是面试高频题，核心是 **“一次请求” vs “两次请求”** 的底层差异。

1. 底层流程对比（可视化）

操作	流程	数据传递
转发（Forward）	客户端→Tomcat→ServletA→Tomcat 内部转发→ServletB→Tomcat→客户端	request 域（同一个请求对象）
重定向（Redirect）	客户端→Tomcat→ServletA→Tomcat 返回 302 + 新地址→客户端→Tomcat→ServletB→客户端	Session/URL 参数（新请求对象）

2. 实战场景抉择

用转发：需要传递大量数据（用 request 域）、跳转后地址栏不变（比如表单提交后跳转到结果页，避免刷新重复提交）；
用重定向：表单提交成功后跳转（避免刷新重复提交）、跳转到外部网站、需要清空 request 域（比如登录成功后跳首页）。

3. 进阶：重定向的 URL 编码（解决中文乱码）

如果重定向的 URL 包含中文，需要编码：

java

运行

String name = "张三";
// 编码中文参数
String encodedName = URLEncoder.encode(name, "UTF-8");
// 重定向
resp.sendRedirect(req.getContextPath() + "/index.jsp?name=" + encodedName);

// 接收时解码：
String name = URLDecoder.decode(req.getParameter("name"), "UTF-8");

五、过滤器：“链式拦截” 的执行逻辑与高级用法

过滤器（Filter）是AOP 思想的底层实现，核心是 “对请求 / 响应进行预处理 / 后处理”。

1. 过滤器链的执行顺序

过滤器链的执行顺序由配置顺序决定：

web.xml 版：按<filter-mapping>的配置顺序执行；
注解版：按类名字母顺序执行（比如AFilter比BFilter先执行）。

代码示例（过滤器链）：

java

运行

// Filter1：
@WebFilter("/*")
public class Filter1 implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Filter1：请求前处理");
        chain.doFilter(request, response); // 放行到下一个过滤器/Servlet
        System.out.println("Filter1：响应后处理");
    }
}

// Filter2：
@WebFilter("/*")
public class Filter2 implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Filter2：请求前处理");
        chain.doFilter(request, response);
        System.out.println("Filter2：响应后处理");
    }
}

执行结果：

plaintext

Filter1：请求前处理
Filter2：请求前处理
（Servlet处理逻辑）
Filter2：响应后处理
Filter1：响应后处理

2. 高级用法：防止 XSS 攻击的过滤器

XSS 攻击是前端注入恶意脚本，过滤器可以对请求参数进行转义：

java

运行

@WebFilter("/*")
public class XssFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 包装request，重写getParameter方法
        XssHttpServletRequestWrapper wrapper = new XssHttpServletRequestWrapper((HttpServletRequest) request);
        chain.doFilter(wrapper, response);
    }

    // 自定义Request包装类，转义参数
    static class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
        public XssHttpServletRequestWrapper(HttpServletRequest request) {
            super(request);
        }

        @Override
        public String getParameter(String name) {
            String value = super.getParameter(name);
            return value == null ? null : escape(value);
        }

        // 转义HTML特殊字符
        private String escape(String value) {
            value = value.replaceAll("<", "&lt;");
            value = value.replaceAll(">", "&gt;");
            return value;
        }
    }
}

3. 实战踩坑：过滤静态资源

如果过滤器配置了/*，会过滤 CSS/JS/ 图片等静态资源，导致页面样式失效。解决方法：在过滤器中排除静态资源：

java

运行

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    String path = req.getRequestURI().toLowerCase();
    // 排除静态资源
    if (path.endsWith(".css") || path.endsWith(".js") || path.endsWith(".png")) {
        chain.doFilter(request, response);
        return;
    }
    // 其他过滤逻辑...
}

六、监听器：“事件驱动” 的全场景覆盖

监听器（Listener）是观察者模式的实现，覆盖 Web 应用的所有核心事件。

1. 常用监听器分类

监听器类型	作用场景	核心方法示例
ServletContextListener	应用启动 / 销毁时执行（加载配置、初始化连接池）	`contextInitialized(ServletContextEvent e)`
ServletRequestListener	每个请求的创建 / 销毁时执行（记录请求日志）	`requestInitialized(ServletRequestEvent e)`
HttpSessionListener	Session 创建 / 销毁时执行（统计在线人数）	`sessionCreated(HttpSessionEvent e)`
HttpSessionAttributeListener	Session 属性增 / 删 / 改时执行（监控用户状态）	`attributeAdded(HttpSessionBindingEvent e)`

2. 实战：用 ServletContextListener 加载全局配置

应用启动时加载config.properties文件到 ServletContext 域：

java

运行

@WebListener
public class ConfigListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext context = sce.getServletContext();
        // 读取WEB-INF下的配置文件
        InputStream in = context.getResourceAsStream("/WEB-INF/config.properties");
        Properties props = new Properties();
        try {
            props.load(in);
            // 存到ServletContext域（全局共享）
            context.setAttribute("config", props);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 其他Servlet中获取配置：
Properties props = (Properties) getServletContext().getAttribute("config");
String dbUrl = props.getProperty("db.url");

七、Cookie&Session：状态管理的 “底层逻辑与坑点”

HTTP 是无状态协议，Cookie 和 Session 是解决 “状态丢失” 的核心方案，但二者的安全、性能、分布式问题是企业开发的重点。

1. Cookie 的底层限制与安全

Cookie 的本质是 “客户端浏览器存储的文本文件”，存在以下限制：

大小限制：每个 Cookie≤4KB；
数量限制：每个域名下≤20 个 Cookie（不同浏览器略有差异）；
跨域限制：Cookie 默认不跨域（可通过setDomain设置主域名共享，比如setDomain(".example.com")让a.example.com和b.example.com共享）；
安全限制：
- setHttpOnly(true)：禁止 JS 读取 Cookie，防止 XSS 攻击；
- setSecure(true)：仅在 HTTPS 协议下传输 Cookie，防止明文泄露。

2. Session 的底层实现与分布式问题

Session 的本质是 “服务器端的内存对象”，通过Cookie 中的 JSESSIONID关联客户端：

plaintext

客户端请求 → Tomcat生成Session（内存中）→ 向客户端写Cookie：JSESSIONID=XXXX → 客户端后续请求携带JSESSIONID → Tomcat根据JSESSIONID找到对应的Session

（1）Session 的超时配置

web.xml 版：

xml

<session-config>
    <session-timeout>30</session-timeout> <!-- 单位：分钟 -->
</session-config>

代码版：

java

运行

HttpSession session = req.getSession();
session.setMaxInactiveInterval(1800); // 单位：秒（30分钟）

（2）分布式 Session 问题

如果项目部署在多台 Tomcat（集群），默认情况下 Session 不共享（每台 Tomcat 的 Session 是独立的），导致用户在 A 服务器登录后，访问 B 服务器又需要重新登录。

解决方案：

Session 复制：Tomcat 集群开启 Session 复制（性能低，仅适用于小规模集群）；
Redis 共享 Session：将 Session 序列化后存储到 Redis（主流方案，比如 Spring Session 框架）；
Token 替代 Session：用 JWT 等 Token 机制，完全脱离 Session。

3. 实战踩坑：Cookie 中文乱码

Cookie 不支持直接存储中文，需要编码：

java

运行

// 编码：
String value = URLEncoder.encode("中文内容", "UTF-8");
Cookie cookie = new Cookie("key", value);
resp.addCookie(cookie);

// 解码：
Cookie[] cookies = req.getCookies();
if (cookies != null) {
    for (Cookie cookie : cookies) {
        if ("key".equals(cookie.getName())) {
            String value = URLDecoder.decode(cookie.getValue(), "UTF-8");
        }
    }
}

八、JSP：从 “翻译为 Servlet” 到 “现代替代方案”

JSP 的本质是 “Servlet 的模板”——Tomcat 会将 JSP 文件翻译为.java 文件，再编译为.class 文件执行。

1. JSP 的翻译过程（可视化）

比如index.jsp：

jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
    Hello <%= request.getParameter("name") %>
</body>
</html>

Tomcat 会将其翻译为index_jsp.java，核心代码是：

java

运行

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase {
    public void _jspService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        response.setContentType("text/html;charset=UTF-8");
        javax.servlet.jsp.JspWriter out = pageContext.getOut();
        out.write("<html>\n<body>\n    Hello ");
        out.print( request.getParameter("name") );
        out.write("\n</body>\n</html>");
    }
}

2. JSP 的 9 大内置对象（自动创建，直接使用）

内置对象名	类型	作用
request	HttpServletRequest	请求对象
response	HttpServletResponse	响应对象
session	HttpSession	会话对象
application	ServletContext	应用全局对象
pageContext	PageContext	页面上下文（域对象，作用域最小）
out	JspWriter	输出流（替代 resp.getWriter ()）
page	Object	当前 JSP 对应的 Servlet 对象（极少用）
config	ServletConfig	Servlet 配置对象
exception	Throwable	异常对象（仅在`page errorPage="true"`时可用）

3. 现代替代方案：模板引擎

JSP 的缺点是 “前后端代码混编”、“性能低”，现在企业开发更多用Thymeleaf（SpringBoot 默认）、Freemarker 等模板引擎，比如 Thymeleaf 的语法：

html

预览

<!-- Thymeleaf替代JSP的EL表达式 -->
<div th:text="${user.name}">用户名</div>
<ul>
    <li th:each="item : ${list}" th:text="${item}"></li>
</ul>

总结：JavaWeb 的 “底层逻辑” 与 “实战落地”

Servlet 及周边组件是 JavaWeb 的 “地基”——SpringMVC 的@Controller本质是 Servlet 的封装，SpringBoot 的自动配置本质是简化了 web.xml/ServletConfig 的配置。

掌握本文的原理、进阶用法、踩坑指南，不仅能独立开发传统 JavaWeb 项目，更能理解框架的底层逻辑，在遇到问题时快速定位根因。

最后，给新手的建议：先写原生 Servlet 项目，再用框架—— 框架是 “工具”，底层原理是 “内功”，内功扎实才能用好工具。

1 条评论

好学且牛逼的马 2025.12.17
以下是10道Servlet面试题的详细参考答案，覆盖基础概念、核心原理、高级特性到性能优化，精准拆解考点：基础层（1-3题） 1. 什么是Servlet？Servlet的核心作用是什么？它与Java普通类的区别是什么？ - Servlet定义：Servlet是运行在服务器端的Java程序，遵循Servlet规范，用于处理客户端（浏览器）的HTTP请求并返回响应，是Java Web开发的核心组件。 - 核心作用： 1. 接收客户端的HTTP请求（如GET/POST）； 2. 处理请求数据（参数解析、业务逻辑处理）； 3. 生成HTTP响应（HTML页面、JSON数据、重定向等）； 4. 与数据库、其他Java组件交互，完成动态内容生成。 - 与Java普通类的区别： 1. 必须实现 javax.servlet.Servlet 接口（或继承 HttpServlet 抽象类），遵循Servlet规范； 2. 由Servlet容器（如Tomcat）实例化、管理生命周期，而非手动 new 创建； 3. 运行在服务器端的JVM中，依赖Servlet容器提供的运行环境（如请求/响应对象、会话管理）； 4. 具备处理HTTP请求的能力，普通Java类无此特性。 2. 简述Servlet的完整生命周期（包含关键方法及调用时机），并说明 init() 方法的重载形式及区别。 Servlet的生命周期完全由Servlet容器管理，核心分为4个阶段： 1. 加载与实例化：容器启动时（或首次请求时），加载Servlet类并创建实例（默认单例，整个容器中只有一个实例）； 2. 初始化（init()）：实例创建后立即调用 init() ，仅执行一次，用于初始化资源（如数据库连接池、配置文件加载）； 3. 请求处理（service()）：每次客户端请求时调用，根据请求方法（GET/POST）分发到 doGet() / doPost() 等方法，多线程并发执行； 4. 销毁（destroy()）：容器关闭时调用，仅执行一次，用于释放资源（如关闭数据库连接、清理缓存）。 init()方法的重载形式及区别： - 无参 init() ：继承自 HttpServlet ，开发者可重写此方法实现初始化逻辑； - 带参 init(ServletConfig config) ：Servlet规范定义的核心方法，容器调用时传入 ServletConfig （包含Servlet配置信息），默认实现会调用无参 init() ，若重写此方法需手动调用 super.init(config) ，否则 getServletConfig() 会返回null。 3. Servlet与JSP的区别和联系是什么？JSP的本质是什么？特性 Servlet JSP 编写方式纯Java代码，嵌入HTML需用 out.print() HTML中嵌入Java代码（ <% %> 标签）角色定位侧重业务逻辑处理侧重页面展示执行效率编译后直接执行，效率高首次运行需编译为Servlet，效率略低适用场景处理请求、业务逻辑、数据交互动态页面生成、前端展示联系： 1. JSP的本质是Servlet（JSP首次被访问时，容器会将其编译为继承 HttpJspBase 的Servlet类，生成 .java 和 .class 文件）； 2. 两者协同工作：Servlet处理业务逻辑，JSP负责展示结果（Servlet通过请求转发将数据传递给JSP）； 3. 均遵循Servlet规范，运行在Servlet容器中，共享请求/响应、会话等对象。核心原理层（4-6题） 4. 简述 ServletRequest 和 ServletResponse 的作用，以及常用的获取/设置数据的方法（各列举3个）； request.getParameter() 和 request.getAttribute() 的区别是什么？ - ServletRequest作用：封装客户端的HTTP请求数据（参数、头信息、请求体等），提供获取请求数据的方法；常用方法： 1. String getParameter(String name) ：获取请求参数（如URL查询字符串、表单提交数据）； 2. String[] getParameterValues(String name) ：获取多值参数（如复选框）； 3. Object getAttribute(String name) ：获取请求域中的属性值； 4. void setAttribute(String name, Object value) ：设置请求域中的属性。 - ServletResponse作用：封装服务器的HTTP响应数据，提供设置响应内容、状态码、响应头的方法；常用方法： 1. PrintWriter getWriter() ：获取字符输出流，用于输出HTML/文本内容； 2. ServletOutputStream getOutputStream() ：获取字节输出流，用于输出图片/文件； 3. void setContentType(String type) ：设置响应内容类型（如 text/html;charset=UTF-8 ）； 4. void setStatus(int sc) ：设置HTTP响应状态码（如200、302、404）。 request.getParameter()和request.getAttribute()的区别：特性 getParameter() getAttribute() 数据来源客户端提交的请求参数（URL/表单）服务器端设置的请求域属性数据类型仅返回String类型返回Object类型（支持任意Java对象）作用域仅当前请求的参数解析请求域（一次请求内有效）可设置性只读（无法通过此方法设置）可通过 setAttribute() 设置 5. Servlet中如何实现会话管理？Cookie和Session的区别（存储位置、生命周期、安全性、数据大小），以及Session的销毁方式有哪些？ - 会话管理实现方式：Cookie、Session、URL重写、隐藏表单域，核心是Cookie+Session（主流方案）。 Cookie和Session的区别：特性 Cookie Session 存储位置客户端浏览器（本地文件）服务器端（内存/数据库/Redis）生命周期可设置过期时间（持久Cookie），默认会话结束后销毁（临时Cookie）默认30分钟无活动后销毁，可手动设置安全性存储在客户端，易被篡改/窃取，安全性低存储在服务器端，安全性高数据大小单个Cookie≤4KB，总数≤20个无大小限制（受服务器内存限制）数据类型仅支持String类型支持任意Java对象 Session的销毁方式： 1. 超时销毁：容器默认30分钟（可通过 web.xml 的 <session-timeout> 配置）无请求则销毁； 2. 手动销毁：调用 session.invalidate() 方法（如用户退出登录）； 3. 容器销毁：Servlet容器（Tomcat）关闭或重启时； 4. 内存不足：服务器内存紧张时，容器主动清理过期Session。 6. 转发（ request.getRequestDispatcher().forward() ）和重定向（ response.sendRedirect() ）的核心区别（请求次数、URL地址、数据共享、跳转范围），分别适用于什么场景？特性转发（forward）重定向（redirect）请求次数 1次请求（服务器内部跳转） 2次请求（客户端重新发起请求） URL地址地址栏显示原请求URL，不变化地址栏显示新URL，发生变化数据共享共享请求域数据（request.getAttribute()）不共享请求域数据（两次独立请求）跳转范围仅能跳转到当前Web应用内部资源可跳转到任意URL（跨应用/跨域）响应状态码 200（成功） 302（临时重定向）适用场景： - 转发：Servlet处理完业务逻辑后，跳转到JSP展示结果（需传递请求域数据）、同一应用内的页面跳转； - 重定向：用户登录成功后跳转到首页（防止表单重复提交）、跳转到外部网站、跨应用跳转。高级特性层（7-8题） 7. 什么是Servlet过滤器（Filter）？Filter的核心作用和生命周期是什么？如何配置Filter拦截特定URL？请举例说明Filter的典型应用场景（至少3个）。 - Filter定义：运行在服务器端的Java组件，位于客户端和Servlet之间，用于拦截请求和响应，实现统一的预处理/后处理逻辑。 - 核心作用： 1. 拦截请求：预处理请求（如编码设置、登录验证、权限控制）； 2. 拦截响应：后处理响应（如添加响应头、数据压缩）； 3. 过滤链：多个Filter按顺序执行，形成过滤链。 - Filter生命周期： 1. 初始化（init()）：容器启动时调用，仅执行一次，用于初始化资源； 2. 过滤（doFilter()）：每次请求/响应时调用，核心方法，通过 FilterChain.doFilter() 传递请求到下一个Filter或Servlet； 3. 销毁（destroy()）：容器关闭时调用，仅执行一次，用于释放资源。 - Filter配置方式： 1. 注解配置（Servlet 3.0+）： @WebFilter(urlPatterns = {"/user/*", "/admin/*"}) // 拦截/user和/admin下的所有URL public class LoginFilter implements Filter { ... } 2. XML配置（web.xml）： <filter> <filter-name>LoginFilter</filter-name> <filter-class>com.test.LoginFilter</filter-class> </filter> <filter-mapping> <filter-name>LoginFilter</filter-name> <url-pattern>/user/*</url-pattern> </filter-mapping> - 典型应用场景： 1. 编码过滤：统一设置请求/响应的字符编码（ request.setCharacterEncoding("UTF-8") ）； 2. 登录验证：拦截未登录用户的请求，跳转到登录页面； 3. 权限控制：根据用户角色拦截特定URL（如普通用户无法访问/admin路径）； 4. 日志记录：记录请求的URL、IP、访问时间等信息； 5. 数据压缩：对响应内容进行Gzip压缩，提升传输速度。 8. Servlet监听器（Listener）有哪些类型？分别监听什么事件？ServletContextListener的作用是什么？如何实现一个监听应用启动/销毁的监听器？ - Servlet监听器分类（按监听对象）： 1. ServletContext相关： - ServletContextListener ：监听ServletContext（应用上下文）的创建/销毁； - ServletContextAttributeListener ：监听ServletContext域中属性的添加/删除/修改； 2. HttpSession相关： - HttpSessionListener ：监听Session的创建/销毁； - HttpSessionAttributeListener ：监听Session域中属性的添加/删除/修改； - HttpSessionBindingListener ：监听对象绑定到Session/从Session解绑； 3. ServletRequest相关： - ServletRequestListener ：监听Request的创建/销毁； - ServletRequestAttributeListener ：监听Request域中属性的添加/删除/修改。 - ServletContextListener的作用：监听Web应用的启动和销毁，用于在应用启动时初始化全局资源（如数据库连接池、加载配置文件），应用销毁时释放资源。 - 实现监听应用启动/销毁的监听器步骤： 1. 实现 ServletContextListener 接口，重写 contextInitialized() （应用启动）和 contextDestroyed() （应用销毁）方法； 2. 配置监听器（注解或XML）；代码示例： // 1. 实现接口 @WebListener // 注解配置（Servlet 3.0+） public class MyAppListener implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent sce) { // 应用启动时执行：初始化数据库连接池 ServletContext context = sce.getServletContext(); context.setAttribute("dbPool", new DBPool()); System.out.println("应用启动，数据库连接池初始化完成"); } @Override public void contextDestroyed(ServletContextEvent sce) { // 应用销毁时执行：关闭数据库连接池 DBPool pool = (DBPool) sce.getServletContext().getAttribute("dbPool"); pool.close(); System.out.println("应用销毁，数据库连接池已关闭"); } } // 2. XML配置（web.xml，可选） <listener> <listener-class>com.test.MyAppListener</listener-class> </listener> 深度原理与优化层（9-10题） 9. Servlet是线程安全的吗？为什么？如何解决Servlet的线程安全问题？请列举至少3种解决方案并说明优缺点。 - Servlet是否线程安全：默认非线程安全。 - 原因：Servlet容器默认创建单个Servlet实例（单例模式），多个客户端请求会触发多个线程同时调用 service() / doGet() 等方法，若Servlet中定义了成员变量，会导致多线程并发访问同一变量，引发数据错乱（如计数器值错误、用户信息混淆）。示例： public class CountServlet extends HttpServlet { private int count = 0; // 成员变量，非线程安全 @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) { count++; // 多线程并发修改，会导致计数错误 resp.getWriter().write("访问次数：" + count); } } - 解决方案及优缺点： 1. 避免使用成员变量（推荐）： - 做法：将变量定义在 doGet() / doPost() 等方法内部（局部变量，线程私有）； - 优点：简单高效，无性能损耗； - 缺点：无法存储全局共享数据。 2. 同步方法/代码块： - 做法：使用 synchronized 修饰 service() 方法或关键代码块； - 示例： synchronized (this) { count++; } ； - 优点：实现简单，能保证线程安全； - 缺点：多线程串行执行，性能低下（高并发场景不适用）。 3. 使用ThreadLocal： - 做法：将共享变量存储到 ThreadLocal 中（每个线程拥有独立副本）； - 示例： private ThreadLocal<Integer> count = ThreadLocal.withInitial(() -> 0); ； - 优点：线程安全，性能优于同步； - 缺点：增加内存消耗，需手动清理 ThreadLocal （防止内存泄漏）。 4. 配置Servlet为多实例： - 做法：在 web.xml 中设置 <load-on-startup> 为负数，或使用 SingleThreadModel 接口（已废弃）； - 优点：每个请求对应一个Servlet实例，天然线程安全； - 缺点：频繁创建/销毁实例，性能极差，不推荐使用。 10. Servlet容器（如Tomcat）接收到HTTP请求后，如何找到对应的Servlet并执行？Servlet 3.0的核心新特性有哪些？生产环境中如何优化Servlet性能？（1）Servlet容器处理HTTP请求的流程： 1. 客户端发送HTTP请求到Tomcat的Connector（如8080端口），Connector解析请求为 HttpServletRequest 对象； 2. Connector将请求传递给Engine（引擎），Engine根据域名匹配Host（虚拟主机）； 3. Host根据请求URL（如 /user/login ）匹配Context（Web应用）； 4. Context通过 web.xml 或注解配置的 url-pattern 匹配对应的Servlet（如 /user/* 对应 UserServlet ）； 5. 若Servlet未实例化，容器创建Servlet实例并调用 init() 方法； 6. 容器创建线程调用Servlet的 service() 方法，根据请求方法分发到 doGet() / doPost() ； 7. Servlet处理完成后，生成 HttpServletResponse ，由Connector转换为HTTP响应返回给客户端。（2）Servlet 3.0核心新特性（2009年发布）： 1. 注解支持：无需 web.xml 配置，通过 @WebServlet 、 @WebFilter 、 @WebListener 注解声明组件； 2. 异步处理：支持异步Servlet（ @WebServlet(asyncSupported = true) ），解决Servlet线程阻塞问题（如长连接、慢请求处理）； 3. 可插拔性：通过 ServletContainerInitializer 实现插件化扩展（如Spring MVC的自动装配）； 4. 文件上传简化：内置 Part 接口，无需第三方组件（如Commons FileUpload）即可实现文件上传； 5. 动态注册组件：通过 ServletContext 动态添加Servlet、Filter、Listener（无需重启容器）。（3）生产环境中Servlet性能优化方案： 1. 减少Servlet线程阻塞： - 使用异步Servlet处理慢请求（如调用第三方API、数据库查询），释放容器线程； - 避免在 service() 方法中执行耗时操作（如文件IO、复杂计算）。 2. 优化会话管理： - 缩短Session超时时间（如设置为15分钟），减少服务器内存占用； - 使用Redis存储Session（分布式环境），替代服务器内存存储。 3. 资源复用： - 初始化全局资源（如数据库连接池、线程池）在 init() 方法中，避免每次请求重新创建； - 使用连接池管理数据库连接，减少TCP连接建立/关闭的开销。 4. 响应优化： - 启用Gzip压缩响应内容（通过Filter实现），减少网络传输量； - 设置响应缓存头（ Cache-Control 、 Expires ），缓存静态资源（如CSS、JS）。 5. 容器配置优化： - 调整Tomcat线程池参数（ maxThreads 、 minSpareThreads ），适配并发量； - 启用NIO/NIO2协议（替代BIO），提升IO处理效率； - 禁用不必要的组件（如默认Servlet、JSP引擎），减少资源占用。 6. 代码优化： - 避免使用成员变量，保证Servlet线程安全； - 减少请求域属性的使用，降低内存消耗； - 使用缓冲流（ BufferedWriter ）输出响应内容，提升IO效率。