Skip to content

SSR-JSP ​

[TOC]

概述 ​

JSP 本质 ​

JSP(Java Server Pages) 是建立在 Servlet 规范之上的服务端动态视图模板技术。在早期的 Java Web 开发中,如果直接使用 Servlet 生成动态网页,开发者必须在 Java 代码中通过 PrintWriter 逐行拼接 HTML 标签、CSS 样式与前端脚本:

java
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

// 1. 传统 Servlet 需在 Java 代码中硬编码拼接 HTML 标签
public class HtmlPrintServlet extends HttpServlet {

  // 2. 重写 doGet 方法处理客户端 GET 请求
  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    // 3. 设置响应内容类型与字符集,获取字符输出流逐行输出 HTML
    resp.setContentType("text/html;charset=UTF-8");
    PrintWriter out = resp.getWriter();
    out.println("<!DOCTYPE html>");
    out.println("<html><body>");
    out.println("<h1>欢迎访问系统</h1>");
    out.println("</body></html>");
  }
}

这种“在 Java 代码中嵌套 HTML 字符串”的方式存在明显的工程缺陷:

  1. 开发与维护成本高:复杂的 HTML 结构需要处理大量字符串拼接与双引号转义,页面结构微调就必须重新编译 Java 源码。

  2. 前后端职责耦合:页面排版设计与后端业务逻辑混杂在同一个 .java 文件中,难以分工协作。

JSP 通过反转代码组织方式解决了这一痛点,允许开发者以标准 HTML 结构为主体,在需要动态数据的位置嵌入 Java 脚本、指令或标签。从底层运行本质来看,JSP 就是一个 Servlet:当客户端首次请求某个 .jsp文件时,Servlet 容器会自动将该.jsp文件转译(Translate)为一个实现HttpJspPage接口的.java源文件,再将其编译(Compile)为.class 字节码并交由 JVM 加载执行。

环境搭建 ​

运行与开发 JSP 页面依赖两类基础环境:

  • 一是实现 JSP/Servlet 规范的 Web 容器(本文以兼容 javax.servlet.* 命名空间的 Tomcat 9 为例,若使用 Tomcat 10 及以上版本则需切换至 jakarta.servlet.* 依赖);
  • 二是编译期所需的 Servlet API 与 JSP API 类库。由于 Tomcat 容器的 lib 目录中已经内置了 servlet-api.jar 与 jsp-api.jar,在搭建工程时只需将这两个依赖用于编译期提示,严禁将其打包进应用的 WEB-INF/lib 目录,否则会与容器自带的类加载产生冲突。

Maven 搭建 ​

在 Maven 工程中,通过声明 war 打包方式并配置 provided 作用域的依赖,即可自动完成 JSP 编译期环境构建:

  1. 创建标准 Web 目录结构:在 Maven 项目中确保存在 src/main/webapp/ 根目录及 src/main/webapp/WEB-INF/web.xml 部署描述符,.jsp 页面直接存放于 src/main/webapp/ 或其子目录下。

  2. 配置 pom.xml 核心依赖:声明打包类型为 war,并引入 javax.servlet-api 与 javax.servlet.jsp-api 坐标,同时将两者的 <scope> 显式设置为 provided:

xml
<!-- 1. 声明打包方式为 war,构建标准 Java Web 应用 -->
<packaging>war</packaging>

<dependencies>
  <!-- 2. 引入 Servlet API,scope 设为 provided 避免与容器内置包冲突 -->
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
  </dependency>

  <!-- 3. 引入 JSP API,提供 HttpJspPage、PageContext、JspWriter 等编译期类型 -->
  <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.3</version>
    <scope>provided</scope>
  </dependency>
</dependencies>
  1. 关联 Tomcat 容器部署:在 IDE(如 IntelliJ IDEA)中配置本地 Tomcat 9 Server,在 Deployment 选项卡中添加当前项目的 war exploded 构建产物并设置上下文路径(Application context),启动容器后即可直接访问并调试 .jsp 页面。

手动搭建 ​

在不使用 Maven 等构建工具的传统 Java Web 工程中,可直接基于本地 Tomcat 安装包手动完成目录结构与类路径配置:

  1. 建立标准 Web 应用目录:创建普通 Java 模块后,在项目下添加 Web 支持(生成 web/ 资源根目录),确保具备以下标准结构:

    • src/:存放后端 Java 源码(Servlet、实体类、工具类等)。
    • web/:存放 .jsp 页面与前端静态资源(HTML、CSS、JS)。若希望禁止客户端通过 URL 直接访问某些视图页,可将其置于 web/WEB-INF/ 目录下,仅通过 Servlet 转发访问。
    • web/WEB-INF/web.xml:Web 应用核心部署描述符。
    • web/WEB-INF/lib/:存放项目运行期所需的第三方业务 JAR 包(如数据库驱动、JSTL 实现包等)。
  2. 手动引入编译期 JAR 依赖:打开项目模块依赖配置(如 IntelliJ IDEA 的 Project Structure -> Modules -> Dependencies),直接添加本地 Tomcat 实例对应的 Application Server Library,或手动指向 Tomcat 安装目录 lib/ 下的 servlet-api.jar 与 jsp-api.jar,并将其依赖范围勾选为 Provided(切勿复制到 web/WEB-INF/lib/ 目录中)。

  3. 配置 web.xml 部署描述符:在 web/WEB-INF/web.xml 中声明与 Tomcat 9 匹配的 Servlet 4.0 规范头及默认欢迎页:

xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- 1. 声明 Servlet 4.0 规范版本的 Web 应用根元素 -->
<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">

  <!-- 2. 配置应用默认欢迎页,访问根路径时自动匹配 index.jsp -->
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>
  1. 配置 Artifact 并启动 Tomcat:在项目 Artifacts 中确认已生成 Web Application: Exploded 输出结构(将 src/ 编译后的 .class 输出至 WEB-INF/classes/),随后在 Tomcat 运行配置中挂载该 Artifact 并启动服务即可验证 JSP 转译与运行效果。

JspServlet 请求处理流程 ​

在 Tomcat 等主流 Web 容器中,所有的 *.jsp 请求默认由容器内置的 JspServlet(全限定名为 org.apache.jasper.servlet.JspServlet)统一拦截并调度。容器在全局 conf/web.xml 中预先配置了该引擎的映射规则,当请求到达时,容器按以下步骤完成处理:

  1. 请求匹配与文件定位:客户端发起 *.jsp 请求,容器根据后缀映射匹配到 JspServlet,并根据请求 URI 定位 Web 应用目录下的物理 .jsp 文件(若文件不存在则直接返回 404 状态码)。

  2. 转译与编译检查:JspServlet 检查工作目录(如 Tomcat 的 work 目录)下是否已存在对应的 *_jsp.class 字节码文件,以及 .jsp 源文件的最后修改时间戳是否晚于已编译的字节码。

  3. 源码转译(Translation):若为首次访问或 .jsp 文件已发生修改,JSP 引擎(Jasper)解析 .jsp 文件中的 HTML 模板与 JSP 语法,生成对应的 *_jsp.java 源文件。

  4. 字节码编译(Compilation):容器调用 Java 编译器将 *_jsp.java 编译为 *_jsp.class 字节码文件。

  5. 类加载与实例化:容器通过类加载器将 *_jsp.class 加载至 JVM 内存,创建该 Servlet 实例并调用 _jspInit 完成初始化。

  6. 服务响应(Service):容器分配工作线程调用实例的 _jspService 方法,将静态 HTML 片段与动态计算结果写入 JspWriter 缓冲区,最终通过 HTTP 响应流返回给客户端浏览器。

image-20261119112037733

示例: 首个 JSP 动态页面 ​

下面通过一个标准的 hello.jsp 页面演示如何在 HTML 结构中嵌入动态 Java 表达式与内置对象调用:

jsp
<%-- 1. 声明页面响应类型、编码格式并导入 Date 类 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" import="java.util.Date" %>
<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <title>首个 JSP 页面</title>
</head>
<body>
  <h1>欢迎访问 JSP 动态视图</h1>

  <%-- 2. 实例化 Date 对象并输出服务端当前时间 --%>
  <p>当前服务器时间:<%= new Date() %></p>

  <%-- 3. 调用内置对象 request 获取客户端 IP 地址 --%>
  <p>客户端访问地址:<%= request.getRemoteAddr() %></p>
</body>
</html>

将该文件部署至 Web 应用根目录后启动容器,通过浏览器访问对应的 URL,JSP 引擎会自动将上述模板中的 HTML 静态标签转换为 out.write(...) 输出语句,并将 <%= ... %> 中的表达式计算结果拼接到响应流中,最终向浏览器输出完整的标准 HTML 文档。

HttpJspPage 转译生命周期 ​

HttpJspPage 继承体系 ​

JSP 规范在 javax.servlet.jsp 包下定义了专用的接口继承体系,使转译后的 JSP 类既能融入标准 Servlet 容器管理,又能遵循 JSP 特有的生命周期约定:

  1. JspPage 接口:继承自标准 javax.servlet.Servlet 接口,在保留 init、service、destroy 等底层生命周期方法的基础上,新增了面向 JSP 开发者的 jspInit() 与 jspDestroy() 两个生命周期方法。

  2. HttpJspPage 接口:继承自 JspPage 接口,专门针对 HTTP 协议定制,声明了核心抽象方法 _jspService(HttpServletRequest request, HttpServletResponse response)。方法名前缀的下划线 _ 表示该方法由 JSP 引擎转译时自动生成,开发者严禁在 JSP 页面中手动重写该方法。

  3. HttpJspBase 抽象基类:Tomcat 的 Jasper 引擎提供了 org.apache.jasper.runtime.HttpJspBase 抽象类,它同时继承了 HttpServlet 并实现了 HttpJspPage 接口。所有由 Tomcat 转译生成的 *_jsp 类均直接继承自 HttpJspBase。

HttpJspBase 内部采用模板方法模式,使用 final 关键字锁定了标准 Servlet 的 init、service 与 destroy 方法,防止转译子类意外破坏容器调度流程,并在内部将调用转发给 JSP 专属生命周期钩子:

java
package org.apache.jasper.runtime;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.HttpJspPage;
import java.io.IOException;

// 1. 继承 HttpServlet 并实现 HttpJspPage 接口的抽象基类
public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {

  // 2. 覆写 Servlet 标准 init 方法,末尾回调子类 _jspInit 钩子
  @Override
  public final void init(ServletConfig config) throws ServletException {
    super.init(config);
    jspInit();
    _jspInit();
  }

  // 3. 覆写标准 destroy 方法,依次触发 jspDestroy 与 _jspDestroy 清理逻辑
  @Override
  public final void destroy() {
    jspDestroy();
    _jspDestroy();
  }

  // 4. 将标准 HTTP 请求统一派发至转译生成的 _jspService 方法
  @Override
  public final void service(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    _jspService(request, response);
  }

  // 5. 提供空实现钩子,供子类按需覆写初始化与销毁逻辑
  public void jspInit() {}

  public void _jspInit() {}

  public void jspDestroy() {}

  public void _jspDestroy() {}

  // 6. 声明抽象服务方法,由 Jasper 转译生成的子类实现页面渲染
  @Override
  public abstract void _jspService(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException;
}

在 HttpJspBase 的设计中,jspInit() 与 jspDestroy() 供开发者在 JSP 声明脚本(<%! ... %>)中手动覆写,以执行自定义的数据库连接池预热或资源释放;而带下划线的 _jspInit() 与 _jspDestroy() 则留给 JSP 引擎在转译代码时自动注入标签库连接池、表达式引擎等底层组件的初始化与回收逻辑,二者互不干扰。

image-20261119112107498

JSP 生命周期阶段 ​

与普通 Servlet 直接从 .class 字节码启动不同,JSP 在进入标准 Servlet 生命周期之前,必须先经历容器主导的转译与编译阶段。完整的 JSP 生命周期包含以下六个阶段:

  1. 解析与转译阶段(Translation):当客户端首次访问 .jsp 页面,或容器检测到 .jsp 源文件时间戳更新时,JspServlet 调用 Jasper 引擎解析页面中的 HTML 静态结构与 JSP 指令、脚本,在容器工作目录(如 Tomcat 的 work/Catalina/<host>/<app>/org/apache/jsp/)下生成对应的 *_jsp.java 源文件。

  2. 字节码编译阶段(Compilation):Jasper 引擎调用内置的 Java 编译器(如 Eclipse JDT 编译器或系统 javac),将 *_jsp.java 编译为同名的 *_jsp.class 字节码文件。若编译期间出现语法错误,容器直接向客户端抛出 500 编译异常报告。

  3. 类加载与实例化阶段(Loading & Instantiation):容器通过专属的 JasperLoader 类加载器将 *_jsp.class 加载进 JVM 内存,并通过反射调用其无参构造方法创建唯一实例(遵循单实例多线程模型)。

  4. 初始化阶段(Initialization):容器调用实例的 init(ServletConfig) 方法。由父类 HttpJspBase 依次触发开发者覆写的 jspInit() 与引擎生成的 _jspInit()。该阶段在实例生命周期内仅执行一次。

  5. 请求服务阶段(Execution):每当客户端请求到达时,容器从线程池分配一个工作线程调用实例的 service 方法,并由 HttpJspBase 转发至 _jspService(HttpServletRequest, HttpServletResponse)。该方法在多线程环境下并发执行,负责初始化线程私有的内置对象并输出响应内容。

  6. 销毁阶段(Destruction):当 Web 应用卸载、容器关闭或 .jsp 文件被修改触发热替换时,容器调用旧实例的 destroy() 方法,由 HttpJspBase 依次触发 jspDestroy() 与 _jspDestroy() 完成资源释放。该阶段同样仅执行一次。

image-20261119112131391

_jspService 转译源码 ​

以第 1 章中的 hello.jsp 为例,Tomcat Jasper 引擎将其转译为 hello_jsp.java。剖析其核心转译源码,可以清晰看到 HTML 模板、JSP 表达式以及九大内置对象在底层的真实存在形态:

java
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.Date;

// 1. 转译生成的 Servlet 类继承自容器基类 HttpJspBase
public final class hello_jsp extends org.apache.jasper.runtime.HttpJspBase {

  // 2. 获取全局默认的 JspFactory 工厂实例
  private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();

  // 3. 容器加载实例后执行的初始化与销毁钩子
  @Override
  public void _jspInit() {}

  @Override
  public void _jspDestroy() {}

  // 4. 核心请求处理方法,每次客户端访问 JSP 时由容器线程调用
  @Override
  public void _jspService(final HttpServletRequest request, final HttpServletResponse response)
      throws java.io.IOException, ServletException {

    // 5. 校验 HTTP 请求方式,仅允许 GET、POST、HEAD 请求通过
    final String _jspx_method = request.getMethod();
    if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method)) {
      response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSP 只允许 GET、POST 或 HEAD");
      return;
    }

    // 6. 声明并初始化九大内置对象局部变量
    final PageContext pageContext;
    HttpSession session = null;
    final ServletContext application;
    final ServletConfig config;
    JspWriter out = null;
    final Object page = this;
    PageContext _jspx_page_context = null;

    try {
      // 7. 设置响应 MIME 类型,并通过 JspFactory 创建 PageContext 及关联内置对象
      response.setContentType("text/html;charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response, null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();

      // 8. 将静态 HTML 模板转为 out.write 输出,动态表达式转为 out.print 输出
      out.write("<!DOCTYPE html>\r\n");
      out.write("<html lang=\"zh-CN\">\r\n");
      out.write("<body>\r\n");
      out.write("  <h1>欢迎访问 JSP 动态视图</h1>\r\n");
      out.write("  <p>当前服务器时间:");
      out.print(new Date());
      out.write("</p>\r\n");
      out.write("  <p>客户端访问地址:");
      out.print(request.getRemoteAddr());
      out.write("</p>\r\n");
      out.write("</body>\r\n");
      out.write("</html>\r\n");
    } catch (Throwable t) {
      // 9. 捕获执行期异常,清理未提交缓冲区并交由 PageContext 统一处理
      if (!(t instanceof SkipPageException)) {
        out = _jspx_page_context.getOut();
        if (out != null && out.getBufferSize() != 0) {
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        }
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      // 10. 释放 PageContext 资源并归还至容器对象池
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

从 _jspService 的转译结构中可以提炼出三个关键底层特征:

  1. 内置对象的线程安全保障:request、response、pageContext、session、out 等内置对象全部是定义在 _jspService 方法栈帧内部的局部变量。每次请求线程进入该方法时都会通过 JspFactory.getDefaultFactory().getPageContext(...) 重新绑定当前请求的上下文,并在 finally 块中调用 releasePageContext 回收,从而在单实例多线程模型下保证了内置对象引用的线程隔离。

  2. 静态模板与动态表达式的输出差异:页面中的所有静态 HTML 标签与换行符均被转译为 out.write(String) 调用;而 <%= ... %> 表达式则被转译为 out.print(...) 重载方法调用,能够将任意基本数据类型或对象(自动调用 String.valueOf)转换为字符串写入 JspWriter 缓冲区。

  3. 集中式异常兜底与缓冲控制:整个页面渲染逻辑包裹在 try-catch-finally 块中。一旦动态脚本抛出未捕获异常且响应尚未提交(!response.isCommitted()),引擎会立即调用 out.clearBuffer() 清空已写入缓冲区的半截 HTML 内容,再通过 _jspx_page_context.handlePageException(t) 转发至错误页面,避免客户端浏览器渲染出残缺错乱的页面。

JSP 脚本元素 ​

JSP 脚本元素(Scripting Elements) 用于在 HTML 静态模板中嵌入 Java 代码。Jasper 引擎在转译 .jsp 文件时,会根据脚本标签的语法类型,将其内部的代码分别放置到 *_jsp.java 源文件的类体结构或 _jspService 方法体中,或直接在转译期忽略。

声明脚本 ​

声明脚本使用 <%! ... %> 标签表示,用于在 JSP 转译生成的 Servlet 类中定义类级别的成员。

在转译阶段,Jasper 引擎会将 <%! ... %> 内部的代码直接提取到 _jspService 方法外部,作为 *_jsp 类的成员属性、静态变量、成员方法、静态代码块或内部类。开发者还可以在声明脚本中显式重写 JspPage 接口定义的 jspInit() 与 jspDestroy() 生命周期钩子方法:

jsp
<%-- 1. 声明脚本:定义线程安全的并发访问计数器与工具方法 --%>
<%!
  private final java.util.concurrent.atomic.AtomicInteger visitCount =
      new java.util.concurrent.atomic.AtomicInteger();

  // 2. 定义转译类的成员方法,供页面表达式调用
  public String formatTitle(String rawTitle) {
    return "[" + rawTitle.trim().toUpperCase() + "]";
  }

  // 3. 覆写 JspPage 生命周期初始化钩子
  @Override
  public void jspInit() {
    System.out.println("JSP 实例初始化完成");
  }
%>

使用声明脚本时必须遵守以下两项底层约束:

  1. 禁止访问九大内置对象:request、response、session、out 等九大内置对象均是 _jspService 方法内部声明的局部变量,在类级别的成员方法或属性初始化表达式中并不存在,直接引用会导致编译失败。

  2. 成员变量并发安全问题:Servlet 容器默认采用单实例多线程模型运行 *_jsp 类,通过 <%! ... %> 声明的实例变量会被所有并发请求线程共享。若在声明脚本中定义非线程安全的可变成员变量(如普通 int 计数器或 ArrayList),在多线程并发读写时将引发数据竞争,因此应仅在声明脚本中定义无状态工具方法、只读常量或使用 AtomicInteger 等并发安全组件。

表达式脚本 ​

表达式脚本使用 <%= ... %> 标签表示,用于计算单个 Java 表达式的值并将其直接输出到当前 HTML 节点位置。

在转译阶段,Jasper 引擎会按照表达式在页面中出现的先后顺序,将其放入 _jspService 方法内部,并统一转换为 out.print(表达式) 调用:

jsp
<%-- 1. 调用声明脚本中的计数器与成员方法并直接输出结果 --%>
<p>页面累计访问次数:<%= visitCount.incrementAndGet() %></p>
<h2><%= formatTitle("user dashboard") %></h2>

<%-- 2. 调用 _jspService 内置对象获取当前 Web 应用上下文路径 --%>
<p>应用上下文路径:<%= request.getContextPath() %></p>

<%-- 3. 算术与逻辑运算表达式(注意末尾严禁添加分号) --%>
<p>单价合计:<%= 99.5 * 2 %></p>

使用表达式脚本时需注意两项语法边界:

  1. 表达式末尾严禁添加分号(;):由于 <%= expr %> 会被机械转译为 out.print(expr);,若在表达式末尾误加分号(如 <%= name; %>),转译后将变成 out.print(name;);,直接触发 Java 语法编译错误。

  2. 表达式必须具有返回值:out.print(...) 需要接收明确的入参,因此 <%= ... %> 内部不能调用返回值为 void 的方法。

代码脚本 ​

代码脚本(Scriptlet) 使用 <% ... %> 标签表示,用于在页面渲染过程中编写任意合法的 Java 执行语句(如局部变量声明、条件分支、循环遍历及内置对象调用)。

在转译阶段,<% ... %> 内部的 Java 代码会按页面自上而下的书写顺序,原封不动地复制到 _jspService 方法体内部。同一个 JSP 页面中分散的多个 <% ... %> 脚本块在转译后处于同一个 _jspService 方法作用域内,因此可以通过拆分代码脚本,使 Java 的 if-else 分支或 for 循环直接包裹静态 HTML 标签:

jsp
<%-- 1. 在 _jspService 局部作用域内声明集合与请求参数变量 --%>
<%
  java.util.List<String> modules = java.util.Arrays.asList("订单中心", "库存管理", "财务报表");
  String role = request.getParameter("role");

  // 2. 使用 if-else 分支跨脚本块控制 HTML 节点渲染
  if ("admin".equals(role)) {
%>
    <div class="alert">当前角色:系统管理员</div>
<%
  } else {
    // 3. 非管理员分支渲染访客提示
%>
    <div class="alert">当前角色:普通访客</div>
<%
  }
%>

<ul>
<%
  // 4. 使用 for 循环包裹 HTML 标签,动态生成列表项
  if (!modules.isEmpty()) {
    for (String moduleName : modules) {
%>
      <li>模块名称:<%= moduleName %></li>
<%
    }
  }
%>
</ul>

使用代码脚本时应明确其作用域与工程规范边界:

  1. 局部变量的线程隔离性:在 <% ... %> 中声明的变量会成为 _jspService 方法栈帧内的局部变量,每个请求线程各自拥有独立的栈空间,因此天然具备线程安全性。

  2. 禁止在代码脚本中定义方法:由于 <% ... %> 位于 _jspService 方法体内部,而 Java 语法不允许在方法内部嵌套定义普通方法,任何成员方法的声明都必须移至 <%! ... %> 声明脚本中。

JSP 注释 ​

在 .jsp 页面中可以同时使用三种注释语法,它们在转译、编译与HTTP 响应输出三个生命周期阶段具有截然不同的可见性:

  1. JSP 服务端注释(<%-- 注释内容 --%>):作用于转译阶段。Jasper 引擎在解析 .jsp 文件时会直接丢弃 <%-- ... --%> 及其内部包裹的所有内容,不会将其写入 *_jsp.java 源文件,可用于临时屏蔽页面中的 JSP 脚本、表达式或指令。

  2. Java 代码注释(// 单行注释、/* 多行注释 */):仅能书写在 <% ... %> 或 <%! ... %> 脚本块内部。它们会随 Java 代码一起转译进 *_jsp.java 源文件中,但在编译阶段被 Java 编译器剔除,不会进入 *_jsp.class 字节码。

  3. HTML 客户端注释(<!-- 注释内容 -->):在 JSP 引擎眼中属于普通静态 HTML 模板文本,在转译阶段会被转换为 out.write("<!-- 注释内容 -->");,并在请求服务阶段随 HTTP 响应流下发至客户端浏览器(在浏览器查看网页源代码时完全可见)。若在 <!-- ... --> 内部嵌套了 <%= ... %> 或 <% ... %>,被包裹的 Java 脚本依然会在服务端正常执行,并将执行结果填入 HTML 注释中返回给浏览器。

image-20261119112204391

示例: 脚本元素转译对比 ​

下面通过一个综合包含四类脚本与注释元素的 script_demo.jsp 页面,直观对比其与 Jasper 转译生成的 script_demo_jsp.java 源码之间的结构映射关系。

JSP 源文件(script_demo.jsp):

jsp
<%-- 1. JSP 服务端注释:转译阶段直接丢弃,不会进入 Java 源码 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>

<%-- 2. 声明脚本:转译为 script_demo_jsp 类的成员变量与成员方法 --%>
<%!
  private String siteName = "JavaWeb Learning Hub";

  public String getSiteName() {
    return this.siteName;
  }
%>

<%-- 3. HTML 客户端注释:作为普通静态字符串通过 out.write 输出到响应流 --%>
<!-- 页面主体开始 -->
<!DOCTYPE html>
<html>
<body>
  <%-- 4. 代码脚本与表达式脚本:全部按顺序转译进 _jspService 方法体内部 --%>
  <%
    String currentUser = "admin";
  %>
  <h1>欢迎来到 <%= getSiteName() %></h1>
  <p>当前登录用户:<%= currentUser.toUpperCase() %></p>
</body>
</html>

Jasper 转译后的 Java 源文件(script_demo_jsp.java 核心节选):

java
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

// 1. 转译生成的 Servlet 类(JSP 注释 <%-- ... --%> 已在转译期被彻底剔除)
public final class script_demo_jsp extends org.apache.jasper.runtime.HttpJspBase {

  // 2. 声明脚本 <%! ... %> 中的变量与方法直接成为类的成员属性与成员方法
  private String siteName = "JavaWeb Learning Hub";

  public String getSiteName() {
    return this.siteName;
  }

  // 3. 每次请求触发的 _jspService 核心服务方法
  @Override
  public void _jspService(final HttpServletRequest request, final HttpServletResponse response)
      throws java.io.IOException, ServletException {

    JspWriter out = null;
    // 省略内置对象初始化代码...

    // 4. HTML 注释与静态标签统一转译为 out.write 字符串输出
    out.write("<!-- 页面主体开始 -->\r\n");
    out.write("<!DOCTYPE html>\r\n<html>\r\n<body>\r\n  ");

    // 5. 代码脚本 <% ... %> 原样复制到 _jspService 方法体内部成为局部变量
    String currentUser = "admin";

    out.write("\r\n  <h1>欢迎来到 ");

    // 6. 表达式脚本 <%= ... %> 转译为 out.print 方法调用
    out.print(getSiteName());
    out.write("</h1>\r\n  <p>当前登录用户:");
    out.print(currentUser.toUpperCase());
    out.write("</p>\r\n</body>\r\n</html>\r\n");
  }
}

JSP 指令 ​

JSP 指令(Directive) 用于向 JSP 引擎(Jasper)提供转译期的控制信息,指示引擎如何将 .jsp 源文件转译为 *_jsp.java 类的结构、属性与方法调用。JSP 指令本身不会直接向客户端输出任何可见字符,其通用语法格式为 <%@ 指令名 属性名="属性值" %>。JSP 规范共定义了 page、include 与 taglib 三大编译指令。

image-20261119112235805

page ​

page 指令用于配置当前 JSP 页面的全局转译属性。一个 JSP 页面中可以出现多个 <%@ page %> 指令,但除 import 属性允许重复声明外,其余属性在同一页面中只能声明一次。按照底层转译作用的差异,常用属性可分为以下四类:

  1. 编码与响应类型控制(pageEncoding 与 contentType):

    • pageEncoding:声明 .jsp 物理源文件在磁盘上的保存字符集,指示 Jasper 引擎在转译读取文件时采用何种编码解码字节流。
    • contentType:转译为 _jspService 方法开头的 response.setContentType("...") 语句,控制 HTTP 响应头 Content-Type 及 JspWriter 输出流的字符编码。若两者仅配置其一,另一个属性会自动继承相同的字符集;若均未配置,默认采用 ISO-8859-1。
  2. 类结构与依赖导入(import):

    • import:直接转译为 *_jsp.java 顶部的 Java import 导包语句。多个包名之间可用逗号分隔,或拆分为多条 page 指令书写。Jasper 默认已自动导入 java.lang.*、javax.servlet.*、javax.servlet.http.* 与 javax.servlet.jsp.*。
  3. 内置对象与缓冲区开关(session、buffer、autoFlush、isELIgnored):

    • session:默认值为 true,控制是否在 _jspService 中生成 session = pageContext.getSession();。对于无需会话状态的公开页面,显式配置 session="false" 可避免容器创建多余的 HttpSession 实例。
    • buffer 与 autoFlush:buffer 默认值为 8kb,控制 JspWriter 字符缓冲区的容量;autoFlush 默认值为 true,表示缓冲区写满时自动刷写至底层响应流(若设为 false,缓冲区溢出时将抛出 IOException)。这两个属性最终转译为 _jspxFactory.getPageContext(...) 工厂方法的入参。
    • isELIgnored:在 Servlet 2.4 及以上版本中默认值为 false,表示由引擎自动解析页面中的 ${...} EL 表达式;若设为 true,EL 表达式将被视为普通静态文本原样输出。
  4. 异常路由与错误页标识(errorPage 与 isErrorPage):

    • errorPage:指定当前页面在运行期抛出未捕获异常时的转发目标路径,转译后作为参数传入 _jspxFactory.getPageContext(...)。当 _jspService 的 catch (Throwable t) 块捕获到异常时,由 _jspx_page_context.handlePageException(t) 在服务端自动将请求转发(forward)至该错误页。
    • isErrorPage:默认值为 false。当错误兜底页面将其显式声明为 true 时,Jasper 会在该页面的 _jspService 方法中额外声明并初始化第九个内置对象 Throwable exception,供页面提取异常堆栈信息。

下面通过一对业务页与错误页展示 page 指令的核心配置:

jsp
<%-- 1. 配置页面编码、导入依赖包、设置 16KB 缓冲区并指定异常兜底页面 --%>
<%@ page contentType="text/html;charset=UTF-8"
         pageEncoding="UTF-8"
         import="java.util.List, java.util.ArrayList"
         buffer="16kb"
         autoFlush="true"
         session="false"
         errorPage="/error.jsp" %>

<%-- 2. 模拟业务逻辑运行期抛出未捕获的算术异常 --%>
<%
  int result = 10 / 0;
%>

对应的错误兜底页面 /error.jsp 开启 isErrorPage="true" 后即可直接访问 exception 内置对象:

jsp
<%-- 1. 开启 isErrorPage 属性,指示引擎在 _jspService 中生成 exception 内置对象 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" isErrorPage="true" %>

<!DOCTYPE html>
<html>
<body>
  <%-- 2. 直接调用 exception 内置对象输出异常详情 --%>
  <h3>系统处理请求时发生异常</h3>
  <p>错误原因:<%= exception.getMessage() %></p>
</body>
</html>

include ​

include 指令用于在转译阶段将外部文件(如公共页眉、导航栏、页脚等 .jsp、.jspf 或 .html 片段)静态合并到当前 JSP 页面中,语法格式为 <%@ include file="相对路径" %>,通常称为静态包含。

当 Jasper 引擎解析主页面遇到 <%@ include %> 指令时,并不会在运行期发起动态调用,而是直接读取 file 属性指向的目标文件字符流,将其原封不动地内联插入到主页面当前位置,随后将合并后的完整文本统一转译为同一个 *_jsp.java 源文件:

jsp
<%-- 1. 声明主页面编码格式 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>

<%-- 2. 在主页面 _jspService 作用域内定义导航栏高亮变量 --%>
<%
  String currentNav = "订单管理";
%>
<!DOCTYPE html>
<html>
<body>
  <%-- 3. 转译期静态合并公共页眉片段(可直接共享主页面的 currentNav 变量) --%>
  <%@ include file="/common/header.jsp" %>

  <main>
    <p>当前是订单管理主列表区域</p>
  </main>

  <%-- 4. 转译期静态合并公共页脚片段 --%>
  <%@ include file="/common/footer.jsp" %>
</body>
</html>

使用 include 静态包含时必须注意以下四项底层约束:

  1. 单一 Servlet 实例:无论主页面通过 <%@ include %> 包含了多少个子文件,转译后只会生成一个 .java 文件并编译为一个 .class 字节码,运行期不产生额外的请求派发开销,执行效率高于动态包含。

  2. 局部变量作用域共享与命名冲突:由于被包含文件的代码直接内联进同一个 _jspService 方法体,子文件可以直接读取主页面在此之前声明的局部变量(如上例中的 currentNav);反之,若主页面与被包含文件中声明了同名的 Java 局部变量,转译后将因变量重复定义而导致编译失败。

  3. page 指令属性冲突检查:若被包含的 .jsp 子文件中也声明了 <%@ page contentType="..." %>,其属性值必须与主页面完全一致,否则 Jasper 会在转译期抛出属性冲突异常。

  4. 不支持运行期动态路径与参数传递:file 属性值必须是固定写死的相对路径字符串常量(以 / 开头时代表相对于当前 Web 应用上下文根目录),严禁使用 <%= ... %> 动态拼接路径,也不支持在路径末尾附加 ?key=value 查询参数。

taglib ​

taglib 指令用于在当前 JSP 页面中引入外部标签库(如 JSTL 标准标签库或开发者编写的自定义标签库),从而使用语义化的 XML 标签替代页面中散乱的 <% ... %> Java 脚本。其语法格式为 <%@ taglib uri="标签库唯一标识或TLD路径" prefix="标签前缀" %>。

Jasper 引擎在转译阶段处理 taglib 指令时,依次执行以下三步解析:

  1. uri 映射定位:引擎扫描当前 Web 应用的 WEB-INF/web.xml(<jsp-config> 配置)、WEB-INF/ 目录以及 WEB-INF/lib/ 下所有 JAR 包内的 META-INF/*.tld(Tag Library Descriptor,标签库描述符文件),根据指令中的 uri 匹配对应的 .tld 文件。

  2. prefix 命名空间绑定:将指令中声明的前缀(如 JSTL 核心库常用的 c、格式化库常用的 fmt)与该 .tld 文件绑定。

  3. 标签处理器代码转译:当引擎在页面主体中扫描到 <prefix:标签名> 节点时,会根据 .tld 文件中注册的 <tag-class> 全限定类名,在 _jspService 方法内部自动生成该标签处理器类的实例化、属性注入(setXxx)以及生命周期方法(如 doStartTag、doEndTag 或 doTag)调用代码。

jsp
<%-- 1. 声明页面编码格式 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>

<%-- 2. 引入 JSTL 核心标签库,绑定命名空间前缀为 c --%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<body>
  <%-- 3. 使用 c:if 标签替代传统 Java 代码脚本完成条件渲染 --%>
  <c:if test="${not empty sessionScope.loginUser}">
    <p>当前登录账号:${sessionScope.loginUser}</p>
  </c:if>
</body>
</html>

九大内置对象 ​

JSP 内置对象(Implicit Objects,又称隐式对象) 是 Jasper 引擎在转译生成 _jspService 方法时,自动在方法体开头声明并完成初始化的九个局部变量。开发者在 JSP 代码脚本(<% ... %>)与表达式脚本(<%= ... %>)中无需显式声明即可直接调用这些变量名。

内置对象转译映射 ​

由于九大内置对象均定义在 _jspService 方法的线程私有栈帧中,它们天然具备局部变量级别的线程隔离性。按照底层职责与初始化来源,九大内置对象可划分为以下四组:

  1. 请求响应与输出流对象(request、response、out):

    • request:类型为 javax.servlet.http.HttpServletRequest,直接对应 _jspService 方法的第一个入参,用于读取 HTTP 请求头、表单参数、客户端网络信息以及操作请求域属性。
    • response:类型为 javax.servlet.http.HttpServletResponse,直接对应 _jspService 方法的第二个入参,用于设置 HTTP 响应状态码、自定义响应头、添加 Cookie 或发起客户端重定向。
    • out:类型为 javax.servlet.jsp.JspWriter,通过 pageContext.getOut() 初始化。它是带有内部字符缓冲区的输出流,负责将页面中的静态 HTML 文本与动态表达式结果缓冲并输出至客户端。
  2. 上下文与会话域对象(pageContext、session、application):

    • pageContext:类型为 javax.servlet.jsp.PageContext,通过 JspFactory.getDefaultFactory().getPageContext(...) 创建。它是当前 JSP 页面执行的上下文中枢,内部持有其余八大内置对象的引用,并提供统一的跨作用域属性读写入口。
    • session:类型为 javax.servlet.http.HttpSession,通过 pageContext.getSession() 初始化,用于维护当前客户端浏览器的服务端会话状态。该变量仅在 <%@ page session="true" %>(默认开启)时才会在 _jspService 中生成;若显式配置 session="false",转译源码中不会声明 session 变量,在页面中引用将直接导致编译失败。
    • application:类型为 javax.servlet.ServletContext,通过 pageContext.getServletContext() 初始化,代表整个 Web 应用全局唯一的上下文实例。
  3. 实例与配置元数据对象(config、page):

    • config:类型为 javax.servlet.ServletConfig,通过 pageContext.getServletConfig() 初始化,用于在 JSP 中读取 web.xml 为当前 JSP Servlet 配置的 <init-param> 初始化参数。
    • page:类型为 java.lang.Object,在 _jspService 中固定转译为 final Object page = this;,指向当前 JSP 转译生成的 Servlet 实例引用本身。由于其编译期声明类型为 Object,若需在脚本中调用当前转译类的成员方法,通常直接使用 this 关键字。
  4. 错误页专属异常对象(exception):

    • exception:类型为 java.lang.Throwable,用于捕获并提取上一个页面抛出的未处理异常。该变量仅在页面顶部显式声明 <%@ page isErrorPage="true" %> 时,才会在 _jspService 中通过 JspRuntimeLibrary.getThrowable(request) 生成并初始化;普通 JSP 页面(默认 isErrorPage="false")中无法使用该对象。

四大域对象 ​

在九大内置对象中,pageContext、request、session 与 application 内部均维护了键值属性映射表(提供 setAttribute、getAttribute 与 removeAttribute 方法),被称为 JSP 的四大域对象。按照数据共享范围从小到大、生命周期从短到长依次排列如下:

  1. 页面域(pageContext / PageContext):

    • 有效边界:仅限当前单个 .jsp 页面内部。
    • 生命周期:当请求线程进入当前页面的 _jspService 方法时通过 JspFactory 初始化,在 _jspService 的 finally 块中调用 releasePageContext 清空属性并归还至容器对象池。无论发生服务端请求转发(forward)还是客户端重定向(sendRedirect),跳转后的目标页面都会创建自己独立的 PageContext 实例,无法读取原页面域中的数据。
  2. 请求域(request / HttpServletRequest):

    • 有效边界:同一次 HTTP 请求处理链。
    • 生命周期:客户端发起请求时由容器创建,服务器完成 HTTP 响应输出后销毁。当通过 RequestDispatcher.forward、<jsp:forward> 或 <jsp:include> 在服务端跨多个 Servlet 与 JSP 转发或包含时,整个调用链共享同一个 request 对象;若通过 response.sendRedirect 触发客户端重定向,浏览器会发起全新的第二次 HTTP 请求,原请求域中的数据随即失效。
  3. 会话域(session / HttpSession):

    • 有效边界:同一客户端浏览器窗口在单次会话期间发起的多次 HTTP 请求。
    • 生命周期:首次调用 getSession() 时在服务端内存创建,并借助 JSESSIONID Cookie 与客户端浏览器维持关联。在会话存续期间,即使历经多次客户端重定向,仍可跨请求共享用户登录凭证或购物车等会话级状态,直至会话超时过期、服务端显式调用 session.invalidate() 或 Web 应用重启时销毁。
  4. 应用域(application / ServletContext):

    • 有效边界:当前 Web 应用下的所有客户端用户与所有并发请求。
    • 生命周期:随 Web 应用部署启动而创建,随 Web 应用卸载或容器关闭而销毁。存放于应用域中的数据在全站范围内全局共享,若多个请求线程并发修改其中的可变属性,必须额外施加同步锁或采用并发容器以保障线程安全。

除了作为独立的页面域容器外,PageContext 还在 API 层面通过整数常量(PAGE_SCOPE、REQUEST_SCOPE、SESSION_SCOPE、APPLICATION_SCOPE)代理了其余三大作用域的属性读写,并提供了全域递进检索方法 findAttribute(String name)(这也是 EL 表达式 ${name} 在未指定作用域前缀时的底层实现机制)。

当调用 pageContext.findAttribute("key") 时,引擎会严格按照作用域由小到大的优先级依次查找:pageContext(页面域) -> request(请求域) -> session(会话域,仅当会话已存在时检索) -> application(应用域)。一旦在某个作用域中检索到非 null 属性值便立即终止查找并返回该结果;若四个作用域均未命中,则最终返回 null。

image-20261119112319077

JspWriter 与 PrintWriter ​

在 JSP 页面中向客户端输出字符文本有两种途径:一是直接使用内置对象 out(javax.servlet.jsp.JspWriter),二是调用 response.getWriter() 获取标准 Servlet 的字符流(java.io.PrintWriter)。虽然两者最终都将字符数据写入底层 HTTP 响应流,但它们在缓冲区层级结构上存在本质差异:

  1. 双层缓冲区串联结构:response.getWriter() 返回的 PrintWriter 直接绑定在容器底层的 Response 缓冲区上;而 JSP 内置对象 out(Tomcat 中实现类为 JspWriterImpl)则是在 PrintWriter 之上额外封装的一层 JSP 页面级字符缓冲区(默认容量由 <%@ page buffer="8kb" %> 控制)。

  2. 输出顺序倒置现象:在 _jspService 执行期间,所有静态 HTML 模板、<%= ... %> 表达式以及 out.write(...) / out.print(...) 调用,都会先将字符暂存到 JspWriter 内部的字符数组缓冲区中,并不会立即写入底层 Response 缓冲区。相反,若在代码脚本中直接调用 response.getWriter().write(...),数据会绕过 JspWriter 直接写入底层 Response 缓冲区。

  3. JspWriter 刷写触发时机:暂存在 JspWriter 缓冲区中的数据,只有满足以下三个条件之一时,才会被批量刷写到底层 PrintWriter(即进入 Response 缓冲区):

    • JspWriter 缓冲区容量写满(默认满 8KB),且 autoFlush="true" 触发自动刷写;
    • 在代码脚本中显式调用 out.flush();
    • _jspService 方法执行至末尾,在 finally 块调用 _jspxFactory.releasePageContext(_jspx_page_context) 时自动调用 out.flush() 将剩余字符全部推入底层响应流。

因此,若在同一个 JSP 页面中混用 out 与 response.getWriter() 且未手动调用 out.flush(),所有通过 response.getWriter() 输出的内容都会抢先出现在整个 HTML 文档的最顶部,造成页面 DOM 结构错乱:

jsp
<%-- 1. 声明页面编码并保持默认 8KB JspWriter 缓冲区 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
<%
  // 2. 写入 JspWriter 缓冲区(此时暂存于内存数组,尚未刷入底层 Response 缓冲区)
  out.println("<p>第一段:通过 JspWriter (out) 输出</p>");

  // 3. 绕过 JspWriter 直接写入底层 Response 缓冲区,在浏览器中会抢先显示在第一段之前
  response.getWriter().println("<p>第二段:通过 PrintWriter 直接输出</p>");

  // 4. 显式刷写 JspWriter 缓冲区,强制将第一段积压的内容立即推入底层 Response 缓冲区
  out.flush();

  // 5. 在 flush 之后再次调用 PrintWriter,此时输出顺序位于第一段之后
  response.getWriter().println("<p>第三段:flush 之后通过 PrintWriter 输出</p>");
%>

访问上述 JSP 页面时,客户端浏览器实际接收到的 HTML 渲染顺序依次为:第二段 -> 第一段 -> 第三段。在工程实践中,JSP 页面内部应始终使用内置对象 out 或表达式脚本完成字符输出,严禁在 JSP 中直接调用 response.getWriter()。

image-20261119112342768

示例: 四大域对象作用域验证 ​

下面通过 scope_set.jsp(写入属性并发起请求转发)与 scope_get.jsp(跨页读取属性并验证检索优先级)两个页面,验证四大域对象在跨页面流转时的存活边界与 findAttribute 的检索顺序。

属性写入与转发页(scope_set.jsp):

jsp
<%-- 1. 声明页面编码格式 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
<%
  // 2. 分别向四大域对象写入独立属性数据
  pageContext.setAttribute("pageMsg", "页面域数据 (仅当前页可见)");
  request.setAttribute("reqMsg", "请求域数据 (同一次转发链可见)");
  session.setAttribute("sessMsg", "会话域数据 (当前浏览器会话可见)");
  application.setAttribute("appMsg", "应用域数据 (全局所有用户可见)");

  // 3. 在请求域与会话域存入同名属性,用于验证 findAttribute 检索优先级
  request.setAttribute("priorityKey", "命中 Request 请求域");
  session.setAttribute("priorityKey", "命中 Session 会话域");

  // 4. 通过服务端请求转发跳转至目标读取页面
  request.getRequestDispatcher("/scope_get.jsp").forward(request, response);
%>

属性读取与检索验证页(scope_get.jsp):

jsp
<%-- 1. 声明目标页面编码格式 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<body>
  <h3>转发后四大域对象读取结果</h3>

  <%-- 2. 跨页面转发后原页面的 pageContext 已销毁回收,因此此处返回 null --%>
  <p>pageContext 页面域:<%= pageContext.getAttribute("pageMsg") %></p>

  <%-- 3. 转发处于同一次 HTTP 请求链,request、session、application 均可正常读取 --%>
  <p>request 请求域:<%= request.getAttribute("reqMsg") %></p>
  <p>session 会话域:<%= session.getAttribute("sessMsg") %></p>
  <p>application 应用域:<%= application.getAttribute("appMsg") %></p>

  <%-- 4. 调用 findAttribute 按由小到大顺序检索同名属性,优先命中 request 域 --%>
  <p>findAttribute 同名检索结果:<%= pageContext.findAttribute("priorityKey") %></p>
</body>
</html>

在浏览器中访问 /scope_set.jsp,服务端转发至 /scope_get.jsp 后,由于跨越了单个 JSP 页面边界,pageContext.getAttribute("pageMsg") 输出 null,而 request、session 与 application 中的属性均正常输出;同时 pageContext.findAttribute("priorityKey") 在页面域未命中后继续向请求域检索,立即命中并返回 "命中 Request 请求域"。若将第 15 行的请求转发改为客户端重定向 response.sendRedirect(request.getContextPath() + "/scope_get.jsp");,则由于浏览器发起了全新的第二次请求,request 域也将失效返回 null,此时 findAttribute("priorityKey") 将继续向上穿透并命中返回 "命中 Session 会话域"。

JSP 动作标签 ​

JSP 标准动作标签(Standard Action Tags)采用以 jsp: 为命名空间前缀的 XML 标签语法,用于在请求处理阶段(运行期)动态控制页面包含、服务端请求派发以及 JavaBean 组件的实例化与属性访问。与在转译期静态生效的 <%@ ... %> 编译指令不同,动作标签会被 Jasper 引擎转译为 _jspService 方法内部的 Java 执行语句,每次客户端请求到达时动态执行。

jsp:include ​

<jsp:include> 标签用于在请求运行期将目标资源(如另一个 .jsp 页面、Servlet 或静态 HTML 文件)的响应输出动态合并到当前页面的指定位置,通常称为动态包含。其核心语法为 <jsp:include page="相对路径" flush="true|false" />,其中 page 属性支持在运行期通过 <%= ... %> 或 EL 表达式动态计算路径,flush 属性(默认值为 false)表示在包含目标资源前是否先强制刷写当前页面的 JspWriter 缓冲区:

jsp
<%-- 1. 声明主页面编码格式 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>

<%-- 2. 运行期动态包含公共头部页面,并通过 jsp:param 传递导航栏高亮参数 --%>
<jsp:include page="/common/header.jsp" flush="false">
  <jsp:param name="activeMenu" value="product" />
</jsp:include>

<%-- 3. 主页面自身静态与动态视图内容 --%>
<main>
  <p>商品列表主视图内容</p>
</main>

在底层转译源码中,Jasper 引擎并不会读取 /common/header.jsp 的源文件进行代码合并,而是在主页面的 _jspService 方法中生成一行对 JspRuntimeLibrary.include(...) 的静态方法调用(底层封装了标准 Servlet 的 RequestDispatcher.include(request, response)):

java
// 1. Jasper 将 jsp:include 与嵌套的 jsp:param 转译为运行期工具类调用
org.apache.jasper.runtime.JspRuntimeLibrary.include(
  request,
  response,
  "/common/header.jsp"
    // 2. 将 jsp:param 键值对经过 URL 编码后拼接到包含目标路径末尾
    + "?"
    + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("activeMenu", request.getCharacterEncoding())
    + "="
    + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("product", request.getCharacterEncoding()),
  out,
  false);

对比第 4 章介绍的 <%@ include file="..." %> 静态包含指令,<jsp:include page="..." /> 动态包含在底层机制上具有以下四项核心差异:

  1. 生效时机与编译产物不同:静态包含在转译期将两个文件的源码合并,最终仅生成一个 .java 文件和一个 .class 字节码;动态包含在运行期发起调度,主页面与被包含的 .jsp 页面各自独立转译、编译为两个独立的 *_jsp.class Servlet 类。

  2. 局部变量作用域完全隔离:由于动态包含涉及两个独立的 Servlet 实例与各自的 _jspService 方法栈帧,被包含页面无法直接访问主页面中定义的 Java 局部变量,彻底避免了同名局部变量冲突问题。

  3. 共享同一个 request 请求上下文:运行期执行 JspRuntimeLibrary.include 时,容器会将主页面的 request 与封装后的 response(绑定主页面的 JspWriter 输出流)传递给被包含页面的 _jspService 方法。因此主页面与被包含页面可通过 request.setAttribute(...) 共享请求域数据,也可通过 <jsp:param> 传递附加请求参数。

  4. 支持动态路径与独立热更新:<jsp:include> 的 page 属性支持运行期动态表达式;且当被包含的子页面修改后,容器只需单独重新编译该子页面的 .class 文件,主页面无需重新转译。

image-20261119112411822

jsp:forward ​

<jsp:forward> 标签用于在服务端停止当前 JSP 页面的继续渲染,并将当前 HTTP 请求与响应控制权直接转发给应用内的另一个目标资源(JSP、Servlet 或 HTML)。由于转发过程完全在容器内部完成,客户端浏览器地址栏的 URL 不会发生任何变化:

jsp
<%-- 1. 声明页面编码格式 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
<%
  // 2. 读取请求参数校验访问凭证
  String token = request.getParameter("token");
  if (token == null || token.isEmpty()) {
%>
    <%-- 3. 未携带凭证时立即在服务端将请求转发至登录页,并附加来源参数 --%>
    <jsp:forward page="/login.jsp">
      <jsp:param name="from" value="checkout" />
    </jsp:forward>
<%
  }
%>

Jasper 引擎在转译 <jsp:forward> 标签时,会在 _jspService 方法中生成一段包裹在 if (true) 块内的 _jspx_page_context.forward(...) 调用(底层委托给 RequestDispatcher.forward):

java
// 1. 清空当前未提交的 JspWriter 缓冲区并调用 PageContext.forward 派发请求
if (true) {
  _jspx_page_context.forward(
      "/login.jsp"
          + "?"
          + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("from", request.getCharacterEncoding())
          + "="
          + org.apache.jasper.runtime.JspRuntimeLibrary.URLEncode("checkout", request.getCharacterEncoding()));

  // 2. 转发返回后立即 return 终止当前页面的 _jspService 方法(触发 finally 释放资源)
  return;
}

分析上述转译代码可以明确 <jsp:forward> 的三项运行期特征:

  1. 未提交缓冲区的自动清理:在调用 _jspx_page_context.forward(...) 时,若当前页面的 JspWriter 缓冲区尚未刷写到底层响应流(响应未提交),PageContext 会自动清空此前已写入缓冲区的静态 HTML 片段,随后由目标页面全权接管响应输出。

  2. 已提交响应的异常边界:如果在执行 <jsp:forward> 之前,页面已经显式调用了 out.flush(),或者输出内容已超过 buffer 容量触发了自动刷写(即 response.isCommitted() 为 true),此时执行 <jsp:forward> 将直接抛出 IllegalStateException。

  3. if (true) 与强制 return 机制:Jasper 特意使用 if (true) { ... return; } 包裹转发逻辑,一方面确保转发结束后立即退出当前页面的 _jspService 方法,另一方面避免 <jsp:forward> 标签之后的静态 HTML 转译代码(out.write(...))在编译期触发 Java 编译器的 Unreachable statement(不可达语句)报错。

jsp:param ​

<jsp:param> 标签用于在动态包含或服务端转发过程中向目标资源传递额外的请求参数,语法格式为 <jsp:param name="参数名" value="参数值" />。

该标签不能独立使用,必须作为子标签嵌套在 <jsp:include> 或 <jsp:forward> 标签内部。在转译阶段,Jasper 会通过 JspRuntimeLibrary.URLEncode(value, request.getCharacterEncoding()) 对参数名和参数值进行 URL 编码,并将其拼接到目标 page 路径的查询字符串中。容器在派发请求时会自动包装 HttpServletRequest 对象,使被包含或被转发的目标页面既能通过 request.getParameter("参数名") 读取 <jsp:param> 传递的新参数,也能继续读取客户端原始请求中的表单参数(若出现同名参数,<jsp:param> 传递的值优先排在 request.getParameterValues 数组首位)。

JavaBean 动作标签 ​

为减少 JSP 页面中的 <% ... %> 脚本数量,JSP 规范提供了三个专门用于操作标准 JavaBean 实体类的动作标签。被操作的 JavaBean 必须满足公共类、提供无参公共构造方法、属性私有化且遵循标准 Getter/Setter 命名规范。

jsp:useBean ​

<jsp:useBean> 用于在指定的域对象(scope)中查找或实例化一个 JavaBean 对象,语法格式为 <jsp:useBean id="变量名" class="全限定类名" scope="page|request|session|application" />(其中 scope 默认值为 page)。

在转译源码中,Jasper 会先根据 id 和 scope 调用 _jspx_page_context.getAttribute("id", Scope常量) 进行检索:

  1. 命中复用:若指定作用域中已存在同名属性,则直接将其强制类型转换并赋值给局部变量 id,不会重复创建对象。

  2. 未命中实例化:若指定作用域中返回 null,则通过反射(或 new 关键字)调用 class 指定类的无参构造方法创建新实例,并调用 _jspx_page_context.setAttribute("id", instance, Scope常量) 将其存入该作用域。

jsp:setProperty ​

<jsp:setProperty> 用于通过内省机制(Introspector)调用已声明 JavaBean 的 Setter 方法为其属性赋值,其中的 name 属性必须与 <jsp:useBean> 的 id 保持一致。该标签支持三种赋值模式:

  1. 全量表单参数自动绑定:<jsp:setProperty name="beanId" property="*" />,容器会自动遍历当前 request 中的所有请求参数,将参数名与 JavaBean 的属性名进行匹配,并自动完成字符串到基本数据类型(如 int、double、boolean)的转换与 Setter 注入。

  2. 指定单个请求参数绑定:<jsp:setProperty name="beanId" property="属性名" param="请求参数名" />,当表单字段名与 JavaBean 属性名不一致时,通过 param 指定数据来源参数。

  3. 显式字面量或表达式赋值:<jsp:setProperty name="beanId" property="属性名" value="固定值或表达式" />,直接使用指定的 value 覆盖目标属性。

jsp:getProperty ​

<jsp:getProperty> 用于调用指定 JavaBean 的 Getter 方法获取属性值,并将其转换为字符串直接写入 JspWriter 输出流(底层转译为 out.write(JspRuntimeLibrary.toString(bean.getXxx()))),作用等同于 <%= bean.getXxx() %>:

jsp
<%-- 1. 声明页面编码格式 --%>
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>

<%-- 2. 在 request 域中查找或反射创建 UserBean 实例 --%>
<jsp:useBean id="user" class="com.example.entity.UserBean" scope="request" />

<%-- 3. 自动匹配 HTTP 请求中的同名参数并批量注入 JavaBean 属性 --%>
<jsp:setProperty name="user" property="*" />

<%-- 4. 显式指定属性值覆盖注入 --%>
<jsp:setProperty name="user" property="role" value="VIP" />

<%-- 5. 调用 Getter 方法读取属性值并输出至页面 --%>
<p>用户账号:<jsp:getProperty name="user" property="username" /></p>
<p>会员等级:<jsp:getProperty name="user" property="role" /></p>