SSR-JSP-EL
[TOC]
概述
EL(Expression Language,表达式语言)最初随 JSP 2.0 规范引入,并在 JSP 2.1 中与 JSF 表达式语言合并为 Unified EL(统一表达式语言),后续演进为独立的 Jakarta Expression Language 规范。它的核心目标是取代 JSP 页面中繁琐的 Java 脚本片段与脚本表达式,让视图层以声明式语法直接读取作用域数据、JavaBean 属性与集合元素,从而降低视图代码与业务逻辑之间的耦合。
EL 与 JSP 脚本表达式对比
在引入 EL 之前,JSP 页面通常依赖 <%= ... %> 输出后端存入作用域的对象。当对象嵌套层级较深或属性可能缺失时,页面中充斥着强制类型转换和判空分支。EL 将这类高频数据读取逻辑下沉到容器解析层,对比如下:
| 对比维度 | JSP 脚本表达式 <%= ... %> | EL 表达式 ${ ... } |
|---|---|---|
| 数据获取方式 | 需显式调用 request.getAttribute 等方法 | 直接通过属性名自动检索四大作用域 |
| 类型转换 | 返回 Object,访问属性前必须手动强转 | 解析器自动完成类型推导与必要类型转换 |
null 值处理 | 直接输出字面量 "null",链式调用触发 NullPointerException | 遇到 null 自动静默转为空字符串 "",不抛空指针异常 |
| 视图整洁度 | 混入大量 Java 代码,维护成本高 | 语法紧凑,贴合 HTML 标签编写习惯 |
定界符语法
Unified EL 定义了两种求值定界符,分别对应不同的求值时机与读写能力。
立即求值
立即求值使用 ${expr} 语法。当 JSP 页面响应请求并渲染到该表达式所在位置时,容器立即计算表达式结果并将其写入输出流。在普通 JSP 模板文本与标准标签属性中,${expr} 仅执行单向读取操作,是 JSP 开发中最常用的形式。
延迟求值
延迟求值使用 #{expr} 语法,主要面向 JSF 等具有多阶段请求生命周期的组件框架。页面初次编译或渲染时并不会立刻求值,而是将表达式封装为 ValueExpression 或 MethodExpression 对象传递给组件,由框架在合适的生命周期阶段按需调用读取或写回方法。在纯 JSP 模板文本中直接书写 #{expr} 会触发转译期语法错误,仅允许出现在显式声明接收延迟表达式的自定义标签属性中。
作用域查找顺序
当 EL 表达式中出现未带作用域前缀的标识符(如 ${role})时,容器会按照作用域范围由小到大的顺序依次检索,并在首次命中时立即返回:
pageScope:当前 JSP 页面有效,对应PageContext.PAGE_SCOPE。requestScope:单次 HTTP 请求及转发链路内有效,对应PageContext.REQUEST_SCOPE。sessionScope:单次浏览器会话内有效,对应PageContext.SESSION_SCOPE。applicationScope:整个 Web 应用全局有效,对应PageContext.APPLICATION_SCOPE。
如果四个作用域中均不存在该属性,表达式求值结果为 null,输出到页面时会被自动转换为空字符串 ""。当多个作用域存在同名属性且需要绕过默认优先级时,可以通过显式作用域前缀(如 ${sessionScope.role})精确定位。
运行期转译与求值流程
JSP 页面中的 EL 表达式并非由浏览器解析,而是在服务端经由 JSP 引擎(如 Tomcat 的 Jasper)转译为 Java 代码,并在运行期委托给 EL 引擎求值。整个过程可分为以下阶段:
Jasper 在将
.jsp转译为 Servlet 源码时,识别模板文本或标签属性中的${...}片段,并生成对容器内部求值入口(如 Tomcat 的PageContextImpl.proprietaryEvaluate)的调用代码。请求到达后,求值入口通过当前应用的
JspApplicationContext获取ExpressionFactory,并从当前PageContext取得关联的ELContext。ExpressionFactory将表达式字符串解析为ValueExpression实例(底层缓存抽象语法树以避免重复词法分析)。调用
ValueExpression的求值方法时,驱动ELContext内部的CompositeELResolver责任链逐级解析变量名与对象属性,最终将结果转换为目标类型并输出到JspWriter。

以 Tomcat 的 Jasper 为例,JSP 中的 用户名:${user.username} 在生成的 Servlet _jspService 方法中会被转译为类似如下的调用代码:
// 1. 输出静态 HTML 模板文本
out.write("用户名:");
// 2. 将 ${user.username} 转译为运行期 EL 求值调用
out.write((String) PageContextImpl.proprietaryEvaluate(
"${user.username}",
String.class,
(PageContext) _jspx_page_context,
null
));EL 解析开关配置
在现代 Servlet 2.4 及以上版本的 Web 应用中,JSP 容器默认开启 EL 解析。但在早期基于 Servlet 2.3 DTD 的 web.xml 配置中,EL 默认处于关闭状态。此外,当 JSP 页面中内嵌了使用 ${...} 语法的 JavaScript 模板字符串时,需要有选择地屏蔽 EL 解析,防止容器误将其当作服务端表达式处理。
反斜杠转义
如果仅需让单个表达式按纯文本原样输出,直接在 $ 前添加反斜杠即可,例如 \${user.username} 在页面渲染后会输出字面量 ${user.username}。这是粒度最细、对页面其余表达式影响最小的方式。
page 指令配置
在当前 JSP 页面顶部通过 page 指令的 isELIgnored 属性设为 true,可以关闭整个页面的 EL 解析:
<%-- 1. 仅在当前 JSP 页面中关闭 EL 表达式解析 --%>
<%@ page contentType="text/html; charset=UTF-8" isELIgnored="true" %>
<%-- 2. 关闭后以下内容将作为纯文本原样输出 --%>
<p>模板字面量:${user.username}</p>web.xml 全局配置
若需要按路径规则批量禁用多个 JSP 页面的 EL 解析,可在 web.xml 中配置 <jsp-property-group>。需要注意的是,单页 page 指令中的 isELIgnored 优先级高于 web.xml 中的全局配置。
<!-- 1. 配置匹配规则,批量禁用指定路径下的 EL 解析 -->
<jsp-config>
<jsp-property-group>
<url-pattern>/legacy/*.jsp</url-pattern>
<el-ignored>true</el-ignored>
</jsp-property-group>
</jsp-config>示例: JSP 中使用 EL 读取作用域数据
下面通过一个最小化的 Servlet 与 JSP 协作示例,演示 EL 如何读取 JavaBean 属性、按优先级解析同名作用域属性以及安全处理缺失属性。
首先在 Servlet 中分别向 request 和 session 作用域写入数据,并转发至视图页面:
package com.example.web;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 1. 准备视图数据并分别存入 request 与 session 作用域
@WebServlet("/profile")
public class ProfileServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 2. 构造 JavaBean 并放入请求作用域
User user = new User("zhangsan", "工程师");
req.setAttribute("user", user);
req.setAttribute("role", "访客");
// 3. 在会话作用域存入同名属性,用于验证查找优先级
req.getSession().setAttribute("role", "管理员");
// 4. 转发至 JSP 页面交由 EL 渲染输出
req.getRequestDispatcher("/profile.jsp").forward(req, resp);
}
}随后在 profile.jsp 中直接使用 EL 渲染数据,无需编写任何 Java 脚本片段:
<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<body>
<%-- 1. 自动按作用域顺序查找 user 并读取其 JavaBean 属性 --%>
<p>用户名:${user.username}</p>
<%-- 2. 未指定作用域前缀时优先命中 requestScope,输出“访客” --%>
<p>默认角色:${role}</p>
<%-- 3. 指定 sessionScope 前缀以绕过 requestScope 同名属性,输出“管理员” --%>
<p>会话角色:${sessionScope.role}</p>
<%-- 4. 访问不存在的属性时安全输出空字符串,不抛出异常 --%>
<p>备注信息:${remark}</p>
</body>
</html>对象属性访问
EL 提供了点号(.)和中括号([])两种属性导航运算符,用于统一读取 JavaBean 属性、Map 键值、List 元素与数组元素。开发者无需关注底层集合的具体实现类型,也无需编写显式类型转换代码,容器会在运行期根据目标对象的实际类型自动分派对应的解析策略。
属性访问运算符
在语义层面,${expr.prop} 等价于 ${expr['prop']},但两者在词法合法性与动态求值能力上存在明确边界。
点号运算符
点号运算符(.)语法紧凑,适用于属性名或键名在编写页面时已经确定、且符合 Java 标识符命名规范的场景(由字母、数字、下划线或 $ 组成,且不能以数字开头)。例如 ${user.username} 或 ${order.customer.city}。如果右侧属性名包含连字符、空格、点号,或者以数字开头,使用点号运算符会在 JSP 转译或表达式解析阶段直接报错。
中括号运算符
中括号运算符([])是属性访问的通用形式,既支持字符串字面量,也支持数字索引与子表达式动态求值。以下三类场景必须使用中括号运算符:
包含特殊字符的键名:当
Map的键或请求头名称包含-、.等非法 Java 标识符字符时,必须用单引号或双引号包裹,例如${header['user-agent']}或${config['api.timeout']}。数组与
List的索引访问:下标为非负整数时不能接在点号之后,必须写作${items[0]}或${items['0']}。动态属性名求值:当中括号内不加引号时,EL 会先按作用域顺序解析括号内的变量,再将求值结果作为属性名或键名去访问左侧对象。例如
${user[fieldName]}会先取出变量fieldName的值(假设为"email"),再等价执行${user.email}。
| 访问场景 | 点号运算符(.) | 中括号运算符([]) |
|---|---|---|
| 标准 JavaBean 属性 | 支持,推荐优先使用 | 支持,需加引号,如 ${user['name']} |
含 -、. 或数字开头的键名 | 不支持,触发语法错误 | 支持,如 ${map['first-name']} |
数组与 List 下标索引 | 不支持,触发语法错误 | 支持,如 ${list[0]} |
| 运行期动态变量作为属性名 | 不支持,字面量固定 | 支持,不加引号,如 ${map[keyVar]} |
对象类型解析
当 EL 对 ${base.prop} 或 ${base[prop]} 求值时,引擎先确定左侧 base 对象,再根据 base 的运行时类型匹配对应的解析规则。

JavaBean
访问 JavaBean 属性时,EL 并不会通过反射直接读取类的 private 成员变量,而是遵循标准 JavaBean 内省规范(java.beans.Introspector),将属性名映射为对应的 public 读取方法(getXxx() 或 isXxx()):
常规属性:将属性名首字母大写并拼接
get前缀。例如${account.username}实际调用account.getUsername(),即使类中根本不存在名为username的字段,只要存在符合签名的getUsername()方法即可正常读取。布尔属性:当 getter 返回基本类型
boolean时,EL 同时支持isXxx()与getXxx();若返回包装类型Boolean,按标准 JavaBean 规范仅识别getXxx(),定义isXxx()会导致找不到属性。连续大写前缀:当 getter 去除
get后前两个字母均为大写时,内省器会保持原大小写而不将首字母转为小写。例如getURL()对应的合法属性名是URL,而非uRL。
// 1. 定义符合 JavaBean 规范的实体类
public class Account {
private String username;
private boolean active;
private String url;
// 2. 对应 EL 表达式 ${account.username}
public String getUsername() {
return username;
}
// 3. 基本类型 boolean 的 getter 对应 ${account.active}
public boolean isActive() {
return active;
}
// 4. 方法名前两个字母均为大写,EL 属性名为 URL 而非 uRL
public String getURL() {
return url;
}
}Map
当 base 实现了 java.util.Map 接口时,EL 直接以右侧属性名或表达式结果作为键调用 map.get(key):
<%-- 1. 合法标识符键名可直接用点号或中括号访问 --%>
<p>应用名:${config.appName}</p>
<%-- 2. 包含连字符或点号的键名必须使用中括号包裹字符串字面量 --%>
<p>接口地址:${config['api-host']}</p>
<%-- 3. 中括号内不加引号时,先解析变量 targetKey 的值再作为 Map 键查找 --%>
<p>动态读取:${config[targetKey]}</p>使用 Map 时需特别注意数值键类型失配问题:EL 中的整数字面量在词法解析阶段默认生成 Long 类型。如果后端向作用域放入的是 Map<Integer, String>,在页面书写 ${statusMap[1]} 时,EL 会传入 Long.valueOf(1) 执行 get 查找;由于 Long 与 Integer 的 equals 结果为 false,最终会返回 null。工程实践中应优先使用 String 作为面向视图层的 Map 键,或在放入作用域前统一键类型。
List
当 base 实现了 java.util.List 接口时,中括号内的表达式会被自动强制转换为 int 索引,并委托调用 list.get(index)。如果索引为数字字符串(如 ${items['1']}),EL 同样会自动完成字符串到整数的转换;若无法转换为有效整数(如 ${items['abc']}),则会抛出 IllegalArgumentException。
需要注意,java.util.Set 未实现 List 接口且不具备有序下标语义,因此不能使用 ${mySet[0]} 按索引取值。尝试对 Set 执行下标访问时,解析链会将其降级交给 JavaBean 解析器处理,最终因找不到对应属性而抛出 PropertyNotFoundException。
数组
当 base 为 Java 数组(包括引用类型数组与基本类型数组)时,EL 同样将索引值转换为 int 并读取 Array.get(base, index)。对于基本类型数组(如 int[]),EL 会自动完成装箱操作后参与后续运算或字符串输出。
嵌套属性访问
点号与中括号可以在同一表达式中自由组合,实现任意深度的对象图导航,例如 ${order.items[0].product.tags['primary']}。
在多级嵌套求值过程中,EL 内置了链式空值短路保护:只要链路上任意一个中间节点求值为 null,EL 就会立刻终止后续属性查找,直接返回 null(输出到页面时表现为空字符串 ""),不会抛出 NullPointerException。例如 ${user.address.city} 中即便 user 或 user.address 为 null,页面依然能够平稳渲染。
缺失属性处理边界
虽然 EL 对空值高度宽容,但“静默返回 null”与“直接抛出异常”之间存在严格边界,排查页面 500 错误时必须区分目标对象类型:
| 访问情形 | 运行期行为 | 页面渲染结果 |
|---|---|---|
顶层作用域变量不存在(如 ${unknown}) | 返回 null | 输出空字符串 "" |
链式访问中间节点为 null(如 ${nullUser.name}) | 短路返回 null | 输出空字符串 "" |
Map 中键不存在(如 ${map.missingKey}) | map.get 返回 null | 输出空字符串 "" |
List 或数组下标越界(如 ${list[99]}、${arr[-1]}) | 捕获越界并返回 null | 输出空字符串 "" |
JavaBean 属性不存在或缺少 public getter | 抛出 PropertyNotFoundException | 触发 HTTP 500 错误 |
List 或数组传入非数字索引(如 ${list['abc']}) | 整数转换失败,抛出 IllegalArgumentException | 触发 HTTP 500 错误 |
方法调用语法
自 EL 2.2(随 JSP 2.2 / Tomcat 7 发布)起,EL 不再局限于隐式调用 JavaBean 的 getter,而是允许通过点号与括号直接调用目标对象的任意 public 实例方法,并支持传入常量或动态表达式参数:
<%-- 1. 调用无参方法 --%>
<p>大写用户名:${user.username.toUpperCase()}</p>
<%-- 2. 调用带参方法,EL 自动完成必要参数类型转换 --%>
<p>昵称前缀:${user.username.substring(0, 3)}</p>
<%-- 3. 直接获取集合长度,无需引入 JSTL fn 函数库 --%>
<p>商品总数:${cartItems.size()}</p>调用对象方法时,EL 会根据方法名、参数个数及参数类型自动匹配重载方法,并在调用前执行必要的类型转换。若目标方法返回值为 void,表达式合法执行但不会向页面输出任何内容。需要控制边界的是,视图层仅应调用只读的格式化或查询辅助方法,不应在 EL 中触发修改业务状态或操作数据库的副作用方法。
示例: 多类型对象属性访问
下面通过一个订单详情展示场景,串联演示嵌套 JavaBean、含特殊字符键名的 Map、动态键名变量、List、数组以及下标越界的完整运行效果。
首先在 Servlet 中构造各类数据模型并绑定到请求作用域:
package com.example.web;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 1. 装配 JavaBean、Map、List 与数组数据并转发至视图层
@WebServlet("/order/detail")
public class OrderDetailServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 2. 构造嵌套 JavaBean(收货地址为嵌套对象)
Address address = new Address("合肥市", "蜀山区");
Customer customer = new Customer("李明", address);
// 3. 构造包含特殊字符键名的 Map
Map<String, String> meta = new HashMap<>();
meta.put("pay-channel", "支付宝");
meta.put("orderType", "普通订单");
// 4. 构造 List 与数组
List<String> items = Arrays.asList("机械键盘", "无线鼠标");
String[] tags = {"加急", "电子发票"};
// 5. 绑定作用域属性与动态键名变量
req.setAttribute("customer", customer);
req.setAttribute("meta", meta);
req.setAttribute("items", items);
req.setAttribute("tags", tags);
req.setAttribute("activeKey", "orderType");
// 6. 转发至 JSP 页面渲染
req.getRequestDispatcher("/order_detail.jsp").forward(req, resp);
}
}随后在 order_detail.jsp 中组合使用点号、中括号与方法调用读取各项数据:
<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<body>
<%-- 1. 嵌套 JavaBean 属性访问 --%>
<p>收货人:${customer.name}</p>
<p>收货城市:${customer.address.city}</p>
<%-- 2. Map 特殊键名与动态变量键名访问 --%>
<p>支付渠道:${meta['pay-channel']}</p>
<p>订单类型:${meta[activeKey]}</p>
<%-- 3. List 与数组按索引访问,越界时安全返回空字符串 --%>
<p>首件商品:${items[0]}(共 ${items.size()} 件)</p>
<p>主标签:${tags[0]}</p>
<p>越界标签:${tags[9]}</p>
<%-- 4. 访问缺失的 Map 键不会报错,输出为空 --%>
<p>优惠券:${meta.couponCode}</p>
</body>
</html>EL 隐式对象
JSP EL 规范内置了 11 个隐式对象(Implicit Objects)。除了 pageContext 暴露为真实的 javax.servlet.jsp.PageContext 实例外,其余 10 个对象在底层均被容器包装为 java.util.Map 接口实现。隐式对象的引入解决了视图层对 HTTP 请求上下文、会话、应用全局配置以及 Cookie 等高频资源的免脚本访问需求。
隐式对象分类与设计意图
在 JSP 脚本片段中,容器提供了 request、response、session 等 9 个隐式变量。而在 EL 中,由于其设计初衷是彻底消除 Java 脚本,EL 并未直接暴露底层的 Servlet API 对象(除 pageContext 外),而是将 HTTP 上下文数据抽象为只读的 Map 容器。
EL 11 个隐式对象按职责划分为以下六类:
| 职责分类 | 隐式对象名称 | 底层 Java 类型 | 核心作用说明 |
|---|---|---|---|
| 核心上下文 | pageContext | javax.servlet.jsp.PageContext | JSP 页面上下文桥梁,可级联访问 Request、Response、Session、ServletContext 等原生 Servlet API |
| 作用域映射 | pageScope | java.util.Map<String, Object> | 限定在 Page 作用域检索属性 |
requestScope | java.util.Map<String, Object> | 限定在 Request 作用域检索属性 | |
sessionScope | java.util.Map<String, Object> | 限定在 Session 作用域检索属性 | |
applicationScope | java.util.Map<String, Object> | 限定在 Application 作用域检索属性 | |
| 请求参数 | param | java.util.Map<String, String> | 获取单个 HTTP 请求参数,等价于 request.getParameter(name) |
paramValues | java.util.Map<String, String[]> | 获取多值 HTTP 请求参数,等价于 request.getParameterValues(name) | |
| 请求头信息 | header | java.util.Map<String, String> | 获取单个 HTTP 请求头,等价于 request.getHeader(name) |
headerValues | java.util.Map<String, String[]> | 获取多值 HTTP 请求头,等价于 request.getHeaders(name) | |
| 客户端 Cookie | cookie | java.util.Map<String, Cookie> | 获取客户端携带的 Cookie 对象映射,值类型为 javax.servlet.http.Cookie |
| 初始化参数 | initParam | java.util.Map<String, String> | 获取 Web 应用全局初始化参数,等价于 servletContext.getInitParameter(name) |

在求值解析链中,EL 解析器(ImplicitObjectELResolver)会优先拦截这 11 个保留关键字。如果表达式标识符匹配其中之一,则直接返回对应的隐式对象,而不会去常规作用域中检索同名属性。
作用域映射对象
pageScope、requestScope、sessionScope 和 applicationScope 封装了四大作用域中的属性集合。
当页面存在属性命名冲突或需要优化检索性能时,显式使用作用域映射对象具有重要意义:
<%-- 1. 未指定作用域时,按 page -> request -> session -> application 顺序盲目查找 --%>
<p>默认检索:${user}</p>
<%-- 2. 存在同名属性时,精准读取特定作用域属性 --%>
<p>请求层用户:${requestScope.user}</p>
<p>会话层用户:${sessionScope.user}</p>
<%-- 3. 规避属性不存在时的多级查找性能损耗 --%>
<p>全局统计:${applicationScope.sysCounter}</p>
<%-- 4. 配合中括号访问包含特殊字符或动态变量的属性名 --%>
<p>动态属性:${requestScope[attrName]}</p>请求参数映射对象
Web 容器在处理 HTTP 请求时,将请求参数封装为 param 和 paramValues 两个 Map 对象。
param
param 适用于单值参数。访问 ${param.username} 等价于调用 request.getParameter("username")。如果请求参数不存在,返回 null(页面输出为空字符串),避免了脚本代码中的 null 校验。
paramValues
paramValues 适用于复选框、多选下拉框等同名多值参数。访问 ${paramValues.hobby} 返回 String[] 数组。如果直接输出 ${paramValues.hobby},会输出数组的 toString() 字符串(如 [Ljava.lang.String;@...),因此通常结合索引访问单个元素:
<%-- 1. 获取单值查询参数 --%>
<p>搜索关键字:${param.keyword}</p>
<%-- 2. 获取多值参数数组中的特定索引元素 --%>
<p>首选爱好:${paramValues.hobby[0]}</p>
<p>次选爱好:${paramValues.hobby[1]}</p>
<%-- 3. 即使参数不存在,索引访问也不会抛出 ArrayIndexOutOfBoundsException,而是返回 null --%>
<p>备选爱好:${paramValues.hobby[5]}</p>请求头映射对象
header 与 headerValues 分别用于提取 HTTP 请求头中的单值与多值信息。
由于大多数 HTTP 请求头名称包含连字符(如 User-Agent、Accept-Language),在 EL 中必须使用中括号运算符加引号进行访问,直接使用点号(如 ${header.User-Agent})会被解析器误判为减法运算而导致报错:
<%-- 1. 读取包含连字符的请求头,必须使用中括号 --%>
<p>浏览器标识:${header['User-Agent']}</p>
<%-- 2. 读取普通请求头,点号与中括号均可 --%>
<p>接受编码:${header['Accept-Encoding']}</p>
<%-- 3. 读取多值请求头 --%>
<p>首选语言:${headerValues['Accept-Language'][0]}</p>Cookie 映射对象
cookie 隐式对象返回的是 Map<String, javax.servlet.http.Cookie>。
需要特别注意:${cookie.name} 返回的是 Cookie 实体对象,而非 Cookie 的字符串值。要获取 Cookie 存储的文本内容,必须访问其 value 属性,即 ${cookie.name.value}:
<%-- 1. 错误写法:直接输出 Cookie 对象本身,会调用 Cookie.toString() --%>
<p>错误输出:${cookie.sessionId}</p>
<%-- 2. 正确写法:访问 value 属性获取 Cookie 值 --%>
<p>会话 Cookie 值:${cookie.sessionId.value}</p>
<%-- 3. 访问 Cookie 对象的其他 JavaBean 属性 --%>
<p>Cookie 有效期:${cookie.userCookie.maxAge}</p>
<p>Cookie 适用路径:${cookie.userCookie.path}</p>全局初始化参数对象
initParam 提供对 Web 应用全局初始化参数(在 web.xml 的 <context-param> 中配置)的便捷读取能力,避免了在页面中调用 application.getInitParameter(...):
<%-- 1. 读取 web.xml 中配置的全局上下文参数 --%>
<p>客服邮箱:${initParam['supportEmail']}</p>
<p>系统版本:${initParam.appVersion}</p>核心上下文对象 pageContext
pageContext 是 EL 中唯一的非 Map 隐式对象,其实际类型为 javax.servlet.jsp.PageContext。通过遵循 JavaBean 规范的 getter 方法,pageContext 成为连接 EL 与 Servlet 核心 API 的枢纽:
<%-- 1. 获取应用上下文根路径(JSP 开发中最常用的经典用法) --%>
<a href="${pageContext.request.contextPath}/index.jsp">返回首页</a>
<%-- 2. 获取请求的 URI 与客户端 IP 地址 --%>
<p>请求路径:${pageContext.request.requestURI}</p>
<p>客户端 IP:${pageContext.request.remoteAddr}</p>
<%-- 3. 获取 HTTP 会话标识 --%>
<p>会话 ID:${pageContext.session.id}</p>
<%-- 4. 获取 Servlet 容器基本信息 --%>
<p>服务器信息:${pageContext.servletContext.serverInfo}</p>
<%-- 5. 获取当前请求的 HTTP 方法 --%>
<p>请求方式:${pageContext.request.method}</p>示例: 隐式对象综合应用
下面通过一个真实的用户控制台场景,演示四大作用域、请求参数、请求头、Cookie、应用初始化参数以及 pageContext 级联访问的联合使用。
首先在 web.xml 中配置应用级初始化参数:
<!-- 1. 配置全局上下文初始化参数 -->
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" version="3.1">
<context-param>
<param-name>supportEmail</param-name>
<param-value>support@example.com</param-value>
</context-param>
</web-app>编写 DashboardServlet 预置请求上下文、Session 会话以及客户端 Cookie:
package com.example.web;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 1. 初始化用户会话、设置 Cookie 并转发
@WebServlet("/dashboard")
public class DashboardServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 2. 写入客户端 Cookie
Cookie themeCookie = new Cookie("user_theme", "dark_mode");
themeCookie.setMaxAge(3600);
resp.addCookie(themeCookie);
// 3. 预置 Session 作用域属性
req.getSession().setAttribute("user_role", "高级管理员");
// 4. 预置 Request 作用域属性
req.setAttribute("page_title", "系统管理控制台");
// 5. 转发至 JSP 视图层
req.getRequestDispatcher("/dashboard.jsp").forward(req, resp);
}
}在 dashboard.jsp 中,通过 EL 隐式对象全面提取所需信息:
<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head>
<%-- 1. 使用 pageContext 动态生成资源绝对路径 --%>
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/style.css">
<title>${requestScope.page_title}</title>
</head>
<body>
<%-- 2. 访问作用域映射对象 --%>
<h2>当前页面:${requestScope.page_title}</h2>
<p>用户权限:${sessionScope.user_role}</p>
<%-- 3. 访问 Cookie 映射对象 --%>
<p>主题偏好:${cookie.user_theme.value}</p>
<%-- 4. 访问请求参数与请求头 --%>
<p>当前激活页签:${param.tab}</p>
<p>首选语言:${headerValues['Accept-Language'][0]}</p>
<p>浏览器:${header['User-Agent']}</p>
<%-- 5. 访问全局初始化参数 --%>
<p>系统客服:${initParam.supportEmail}</p>
<%-- 6. pageContext 级联访问请求信息 --%>
<p>访问来源 IP:${pageContext.request.remoteAddr}</p>
<p>请求协议:${pageContext.request.protocol}</p>
</body>
</html>EL 运算符
EL 提供了算术、关系、逻辑、判空、条件与字符串拼接等常用运算符,使 JSP 页面无需借助 Java 脚本即可完成基本的视图展示计算与状态判断。与 Java 相比,EL 运算符针对模板渲染场景做了大量容错与简化设计,例如提供 XML 安全的字母别名、内置空值兜底以及自动类型转换,但也因此存在若干容易踩坑的语义差异。
算术运算符
EL 支持五种基础算术运算符,其中除法与取模同时提供符号和字母别名两种形式:
| 运算符 | 字母别名 | 说明 | 示例 | 结果 |
|---|---|---|---|---|
+ | 无 | 数值加法(仅作数值运算,不拼接字符串) | ${10 + 20} | 30 |
- | 无 | 减法或一元取负 | ${20 - 5} | 15 |
* | 无 | 乘法 | ${3 * 4} | 12 |
/ | div | 除法(默认浮点除法) | ${5 div 2} | 2.5 |
% | mod | 取模(求余数) | ${10 mod 3} | 1 |
使用 EL 算术运算符时需注意三个核心差异:
+不具备字符串拼接能力:与 Java 不同,EL 中的+会强制将左右两侧操作数转换为数值再相加。${'10' + '20'}的结果是30而非"1020";若操作数无法解析为数字(如${'abc' + 1}),运行期会直接抛出NumberFormatException。/默认执行浮点除法:无论操作数是否为整数,/和div默认转为Double进行运算,因此${5 / 2}输出2.5。当除数为0时,浮点除法不会抛出ArithmeticException,而是输出Infinity(0 / 0输出NaN);但% 0或mod 0仍会抛出ArithmeticException。**
null被视为0**:参与算术运算的变量若为null或作用域中不存在,会被自动当作0处理,不会引发空指针异常。
<%-- 1. 加号仅执行数值加法,数字字符串会被自动转为数值 --%>
<p>字符串相加结果:${'10' + '20'}</p>
<%-- 2. 除法默认执行浮点运算,5 / 2 输出 2.5 而非 2 --%>
<p>商品均价:${totalPrice div itemCount}</p>
<%-- 3. 取模运算支持 % 与 mod 两种写法 --%>
<p>余数判定:${index mod 2}</p>
<%-- 4. 缺失变量为 null 时,在算术运算中被视为 0 --%>
<p>加上未知变量:${100 + unknownDiscount}</p>关系运算符
关系运算符用于比较两个表达式的大小或相等性,求值结果恒为布尔值 true 或 false。为了兼容 XML 格式的 JSP 文档(JSPX)及防止尖括号与 HTML/标签语法冲突,所有关系运算符均配有对应的字母别名:
| 运算符 | 字母别名 | 说明 | 示例 |
|---|---|---|---|
== | eq | 等于 | ${status eq 'PAID'} |
!= | ne | 不等于 | ${role ne 'GUEST'} |
< | lt | 小于 | ${stock lt 10} |
> | gt | 大于 | ${price gt 100} |
<= | le | 小于等于 | ${age le 18} |
>= | ge | 大于等于 | ${score ge 60} |
关系运算符在对象相等性与空值处理上与 Java 存在显著不同:
==按值语义比较:对于字符串与普通对象,EL 的==底层委托调用equals()方法而非比较内存引用地址,因此可以直接使用${user.role == 'ADMIN'}判断字符串内容是否一致。**大小比较遇
null恒为false**:在<、<=、>、>=运算中,若任意一侧操作数为null,表达式直接返回false,并不会将null转为0。而在==比较中,null == null返回true,一侧为null另一侧非null返回false。
<%-- 1. 字符串比较底层调用 equals,而非比较对象引用地址 --%>
<p>角色匹配:${user.role == 'ADMIN'}</p>
<%-- 2. 在标签属性或 XML 文档中优先使用字母别名避免尖括号冲突 --%>
<p>库存充足:${product.stock ge 10}</p>
<p>价格区间:${product.price lt 100}</p>
<%-- 3. 任意一侧为 null 时,大小比较结果恒为 false --%>
<p>空值比较:${missingScore gt 0}</p>逻辑运算符
逻辑运算符用于组合或反转布尔条件,同样提供 XML 友好的字母别名(避免 & 在 XML 中被解析为实体引用):
| 运算符 | 字母别名 | 说明 | 行为特征 | | ------ | -------- | ------ | ----------------------------------------- | ------ | ---------------------------------------- | | && | and | 逻辑与 | 支持短路求值,左侧为 false 时不计算右侧 | | | | | or | 逻辑或 | 支持短路求值,左侧为 true 时不计算右侧 | | ! | not | 逻辑非 | 一元运算,将操作数转为布尔值后取反 |
当操作数不是布尔类型时,EL 会先将其强制转换为布尔值:null 转为 false,字符串按忽略大小写规则将 "true" 转为 true(其余字符串均为 false)。
<%-- 1. 组合多条件判断,左侧为 false 时触发短路 --%>
<p>允许下单:${user.active and product.stock gt 0}</p>
<%-- 2. 使用 or 与 not 提高模板可读性 --%>
<p>免运费资格:${user.vip or order.amount ge 99}</p>
<p>账号未锁定:${not user.locked}</p>empty 运算符
empty 是 EL 特有的一元前缀运算符,专门用于判断目标对象是否“不存在或无内容”,常与 JSTL 条件标签配合控制页面区块的显示与隐藏。
当操作数满足以下任意一种情况时,${empty expr} 返回 true,否则返回 false:
| 操作数类型 | 返回 true 的判定条件 | 反例(返回 false) |
|---|---|---|
| 任意引用 | 对象为 null 或作用域中不存在该变量 | 非空对象实例 |
String | 长度为 0 的空字符串 "" | 含空格字符串 " " |
| 数组 | 长度为 0 的空数组(length == 0) | 至少含一个元素的数组(哪怕元素为 null) |
Collection | 集合为空(isEmpty() == true) | 含至少一个元素的 List 或 Set |
Map | 映射为空(isEmpty() == true) | 含至少一个键值对的 Map |
需要注意,数值 0 和布尔值 false 不属于空值,${empty 0} 与 ${empty false} 的求值结果均为 false。判断非空时通常写作 ${not empty list} 或 ${!empty list}。
<%-- 1. 判断集合是否为空或为 null --%>
<p>购物车为空:${empty cartItems}</p>
<%-- 2. 结合 not 判断非空后决定是否渲染提示 --%>
<p>存在错误消息:${not empty errorMsg}</p>
<%-- 3. 数值 0 与空白字符串均不属于空值,结果均为 false --%>
<p>零值判空:${empty 0}</p>
<p>空白字符串判空:${empty ' '}</p>条件运算符
EL 支持与 Java 相同的三元条件运算符 A ? B : C。先对条件 A 进行布尔求值,为 true 时仅计算并返回 B,为 false 时仅计算并返回 C。在 JSP 视图中,它广泛用于动态切换 CSS 样式类和为缺失字段提供默认展示文本:
<%-- 1. 根据状态动态切换 HTML 元素的样式类 --%>
<li class="${currentTab eq 'orders' ? 'active' : ''}">我的订单</li>
<%-- 2. 配合 empty 运算符为缺失数据提供默认兜底文案 --%>
<p>昵称:${not empty user.nickname ? user.nickname : '默认用户'}</p>字符串拼接运算符
针对早期 EL 无法使用 + 拼接字符串的痛点,EL 3.0(随 JSP 2.3 / Servlet 3.1 引入,Tomcat 8 及以上版本原生支持)新增了专用的字符串拼接运算符 +=。
+= 会先将左右两侧操作数强制转换为 String(若为 null 则转为空字符串 ""),然后执行字符串连接,不会触发数值解析异常。
<%-- 1. EL 3.0 使用 += 拼接字符串,自动将两侧转为字符串 --%>
<p>订单标识:${'ORD_' += order.id}</p>
<%-- 2. 拼接目标包含 null 时自动转为空字符串 --%>
<p>完整称呼:${user.title += user.name}</p>
<%-- 3. 低版本容器(EL 2.x)可直接在模板中相邻书写多个表达式 --%>
<p>兼容写法:ORD_${order.id}</p>运算符优先级
当单个 EL 表达式中混用多种运算符时,解析器按以下优先级从高到低执行计算(同一行优先级相同):
| 优先级 | 运算符 | 结合性 | | ---------- | -------------------------------------------- | -------- | ------- | -------- | | 1(最高) | []、. | 从左到右 | | 2 | ()(分组括号) | 从左到右 | | 3 | -(一元负号)、not、!、empty | 从右到左 | | 4 | *、/、div、%、mod | 从左到右 | | 5 | +、-(二元减法) | 从左到右 | | 6 | += | 从左到右 | | 7 | <、>、<=、>=、lt、gt、le、ge | 从左到右 | | 8 | ==、!=、eq、ne | 从左到右 | | 9 | &&、and | 从左到右 | | 10 | | |、or | 从左到右 | | 11(最低) | ? : | 从右到左 |
在复杂组合表达式中(尤其是混用 and/or、关系比较与三元运算符时),建议显式添加圆括号 () 明确求值顺序,避免因优先级误判产生展示错误。
隐式类型转换
EL 表达式不要求操作数具备严格一致的静态类型,引擎在求值阶段会依据当前运算符的目标类型执行隐式类型转换(Type Coercion):
转为字符串(
String):null转换为"";其余对象调用其toString()方法。转为数值(
Long/Double/BigDecimal):null和""转换为0;Character转为对应 Unicode 码点;String按数字格式解析,若格式非法则抛出ELException(包装NumberFormatException)。转为布尔值(
Boolean):null和""转换为false;String调用Boolean.valueOf(str);其他非布尔对象在需要布尔上下文时会触发转换异常。
不同运算符对 null 的转换策略对比如下:
| 运算上下文 | null 的处理方式 | 示例 | 结果 |
|---|---|---|---|
页面直接输出 / += | 转为 "" | ${'ID:' += nullVar} | "ID:" |
| 算术运算 | 转为 0 | ${nullVar + 5} | 5 |
| 逻辑运算 | 转为 false | ${not nullVar} | true |
相等比较(==) | 按空引用比对 | ${nullVar == null} | true |
大小比较(>、< 等) | 直接返回 false | ${nullVar >= 0} | false |
示例: 购物车结算状态渲染
下面通过购物车结算页面的渲染流程,综合演示算术、关系、逻辑、empty、条件与 += 运算符的协同用法。
首先在 Servlet 中准备结算数据并放入请求作用域:
package com.example.web;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 1. 准备购物车结算数据并转发至 JSP 页面
@WebServlet("/cart/checkout")
public class CheckoutServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 2. 构造商品列表与单价数量信息
List<String> cartItems = Arrays.asList("机械键盘", "人体工学椅");
double subtotal = 88.0;
double shippingFee = 12.0;
// 3. 设置用户会员标识与优惠码(模拟未填写优惠码)
boolean isVip = false;
String couponCode = "";
// 4. 将视图数据写入请求作用域
req.setAttribute("cartItems", cartItems);
req.setAttribute("subtotal", subtotal);
req.setAttribute("shippingFee", shippingFee);
req.setAttribute("isVip", isVip);
req.setAttribute("couponCode", couponCode);
// 5. 转发至结算视图页面
req.getRequestDispatcher("/checkout.jsp").forward(req, resp);
}
}随后在 checkout.jsp 中使用 EL 运算符完成状态判定、运费计算与文本拼接:
<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<body>
<%-- 1. 使用 empty 与三元运算符判定购物车是否为空 --%>
<p>购物车状态:${empty cartItems ? '暂无商品' : '共 ' += cartItems.size() += ' 件商品'}</p>
<%-- 2. 使用逻辑运算符与关系运算符计算免运费资格 --%>
<p>运费状态:${(isVip or subtotal ge 99) ? '免运费' : '需付运费 ' += shippingFee += ' 元'}</p>
<%-- 3. 使用算术运算符计算实付总额与件均价格 --%>
<p>实付总额:${(isVip or subtotal ge 99) ? subtotal : (subtotal + shippingFee)} 元</p>
<p>件均价格:${subtotal div cartItems.size()} 元</p>
<%-- 4. 判空优惠码并输出兜底文案 --%>
<p>优惠码:${not empty couponCode ? couponCode : '未使用'}</p>
</body>
</html>EL 自定义函数
EL 内置运算符仅涵盖基础的算术、比较与判空逻辑,面对手机号脱敏、金额格式化、HTML 转义、字符串截断等高频视图处理需求时,单靠属性访问难以表达。EL 自定义函数允许开发者将无状态的 Java 静态方法通过标签库描述文件(TLD)注册为带命名空间前缀的函数,在 JSP 中以 ${prefix:funcName(args)} 形式调用,既保持了视图层零脚本的整洁度,又能复用后端工具类逻辑。JSTL 提供的 fn 函数库(如 ${fn:length(list)})底层采用的正是同一套扩展机制。
静态方法约束
并非任意 Java 方法都能注册为 EL 自定义函数。EL 规范对目标 Java 类与方法施加了严格约束:
类访问级别:定义函数的工具类必须声明为
public顶级类(或public static嵌套类),确保 JSP 转译生成的 Servlet 跨包可见。方法修饰符:目标方法必须同时具备
public和static修饰符。EL 函数本质上是无状态的工具调用,容器不会在调用前实例化该工具类。方法重载限制:同一个 TLD 命名空间内,不允许将两个同名函数名(
<name>)映射到不同的重载方法。若 Java 工具类中存在多个重载方法,必须在 TLD 中分别赋予不同的 EL 函数名。空参数防御:当 EL 表达式传入不存在的作用域变量(求值为
null)且方法形参类型为String时,EL 会先将null隐式转换为空字符串""再传入方法;而对于引用类型参数则保留null。因此自定义函数实现中应同时做好null与空字符串的边界校验。
TLD 函数映射
EL 函数无法直接通过全限定类名在 JSP 2.x 中调用,必须借助 TLD(Tag Library Descriptor,.tld)文件完成“EL 函数名”到“Java 静态方法”的元数据绑定。核心配置元素说明如下:
| TLD 元素 | 所属层级 | 作用说明 |
|---|---|---|
<tlib-version> | <taglib> | 声明函数库版本号(如 1.0) |
<short-name> | <taglib> | 建议的默认前缀名称(如 myfn) |
<uri> | <taglib> | 函数库的唯一逻辑标识,供 JSP taglib 指令引用 |
<name> | <function> | 在 EL 表达式中调用的函数名 |
<function-class> | <function> | 工具类的全限定类名 |
<function-signature> | <function> | 静态方法的返回类型、方法名与形参类型列表 |
<function-signature> 的语法格式要求极为严格:
引用类型必须写全限定名:即使属于
java.lang包,也必须显式写出java.lang.String、java.lang.Object等完整包名,简写为String会在 JSP 转译期报错。基本类型与数组格式:基本类型直接使用关键字(如
int、boolean),数组类型使用[]后缀(如java.lang.String[])。禁止出现形参名与泛型:签名中只能包含类型名,不能附加变量名,且集合与泛型类型须使用擦除后的原始类型(如
java.util.Collection,不能写java.util.Collection<java.lang.String>)。
在 JSP 2.0 及以上版本的容器中,Web 应用启动时会自动扫描 /WEB-INF/ 目录(及其子目录)以及 WEB-INF/lib/*.jar 中 META-INF/ 目录下的 .tld 文件,并自动建立 <uri> 到 TLD 文件的映射关系,通常无需在 web.xml 中手动声明 <taglib> 节点。
运行期解析流程
EL 自定义函数在 JSP 转译期完成元数据解析,并在请求运行期通过 FunctionMapper 完成反射定位与执行:
JSP 引擎(如 Tomcat 的 Jasper)解析
<%@ taglib %>指令,根据uri定位对应的.tld文件并读取<function>定义。转译生成 Servlet 源码时,Jasper 为页面用到的函数生成静态的
ProtectedFunctionMapper实例(FunctionMapper的容器实现),预先将prefix:name与目标Class、方法名及参数类型数组绑定,避免每次请求重复解析 XML。请求到达
_jspService方法时,容器将该FunctionMapper实例注入本次求值使用的ELContext。EL 求值引擎识别到
${prefix:funcName(args)}语法节点后,调用FunctionMapper解析出对应的java.lang.reflect.Method对象。引擎先对实参列表逐一执行 EL 隐式类型转换,再以
null作为目标实例反射调用静态方法,并将返回值继续参与外层表达式计算或直接输出到页面。

以 Tomcat 的 Jasper 为例,页面中调用 ${myfn:maskPhone(user.phone)} 后,转译生成的 Servlet 关键代码如下:
// 1. JSP 转译期静态初始化函数映射器,绑定前缀函数名与反射方法
private static org.apache.jasper.runtime.ProtectedFunctionMapper _jspx_fnmap;
static {
// 2. 注册 myfn:maskPhone 对应的类、方法名与参数类型数组
_jspx_fnmap = org.apache.jasper.runtime.ProtectedFunctionMapper.getMapForFunction(
"myfn:maskPhone",
com.example.el.MaskUtils.class,
"maskPhone",
new Class[] { java.lang.String.class }
);
}
// 3. 请求处理阶段将函数映射器传入 EL 求值入口
out.write((String) PageContextImpl.proprietaryEvaluate(
"${myfn:maskPhone(user.phone)}",
String.class,
(PageContext) _jspx_page_context,
_jspx_fnmap
));EL 3.0 静态方法调用
自 EL 3.0(随 JSP 2.3 / Servlet 3.1 引入,Tomcat 8 及以上版本支持)起,规范新增了 ImportHandler 组件,允许在表达式中直接通过“类名 + 点号”调用静态字段与静态方法,不再强制依赖 TLD 文件。
默认情况下,java.lang 包下的所有类已自动导入,页面可直接书写 ${Math.max(a, b)} 或 ${Boolean.TRUE}。对于自定义工具类,可以在应用启动监听器中向 JspApplicationContext 注册 ELContextListener 完成全局类导入:
package com.example.listener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.jsp.JspFactory;
// 1. 应用启动时注册 ELContextListener,向 EL 3.0 导入工具类
@WebListener
public class ElImportListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
// 2. 获取当前应用的 JspApplicationContext 并监听 ELContext 创建事件
JspFactory.getDefaultFactory()
.getJspApplicationContext(sce.getServletContext())
.addELContextListener(event -> {
// 3. 导入自定义工具类,使 JSP 无需 TLD 即可直接调用其静态方法
event.getELContext().getImportHandler().importClass("com.example.el.MaskUtils");
});
}
}导入完成后,JSP 页面无需引入 taglib 即可直接调用:
<%-- 1. java.lang 包下的静态方法默认已导入,可直接调用 --%>
<p>较大值:${Math.max(priceA, priceB)}</p>
<%-- 2. 调用通过 ImportHandler 注册的自定义工具类静态方法 --%>
<p>脱敏手机号:${MaskUtils.maskPhone(user.phone)}</p>尽管 EL 3.0 简化了静态方法调用,但在传统 JSP 项目中,基于 TLD 的自定义函数依然具备明显优势:一方面兼容低版本容器,另一方面通过白名单显式声明暴露的方法签名,避免了将整个工具类或敏感静态方法无差别暴露给视图层。
常见配置错误
开发与维护 EL 自定义函数时,绝大多数报错发生在 JSP 转译阶段,典型问题如下:
| 常见错误 | 典型报错表现 | 修正方式 |
|---|---|---|
<function-signature> 省略 java.lang. | ClassNotFoundException: String | 补全全限定类名 java.lang.String |
| 签名中包含形参名或泛型参数 | JasperException: Invalid syntax | 仅保留擦除后的类型名,删除变量名与尖括号 |
目标方法缺少 static 或 public 修饰符 | ELException 或 NoSuchMethodException | 确保类与方法均为 public static |
JSP 中 taglib 的 uri 与 TLD 不一致 | Cannot resolve absolute uri | 核对 TLD 文件路径与 <uri> 文本完全一致 |
| 调用实参个数与签名不匹配 | 转译期提示参数数量错误 | 保持调用参数数量与 <function-signature> 严格一致 |
示例: 手机号脱敏与格式化函数
下面通过一个完整的用户信息卡片场景,演示如何从零编写 Java 静态工具类、注册 TLD 描述文件并在 JSP 页面中调用自定义函数。
首先编写无状态的静态工具类 MaskUtils:
package com.example.el;
// 1. 定义对外暴露给 EL 的工具类,类与方法均须声明为 public static
public class MaskUtils {
// 2. 手机号脱敏:需同时兼容 null 与空字符串(EL 会将 null 强转为 "")
public static String maskPhone(String phone) {
// 3. 长度不足时原样返回,避免下标越界异常
if (phone == null || phone.length() < 7) {
return phone == null ? "" : phone;
}
// 4. 保留前三位与后四位,中间使用星号脱敏
return phone.substring(0, 3) + "****" + phone.substring(phone.length() - 4);
}
// 5. 超长文本截断并追加省略号
public static String truncate(String text, int maxLength) {
// 6. 防御性校验输入参数与最大长度边界
if (text == null || maxLength <= 0) {
return "";
}
// 7. 未超出阈值时直接返回原文
if (text.length() <= maxLength) {
return text;
}
// 8. 截取指定前缀并拼接省略号
return text.substring(0, maxLength) + "...";
}
}在 /WEB-INF/tlds/mask.tld 中注册上述两个静态方法:
<?xml version="1.0" encoding="UTF-8"?>
<taglib 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-jsptaglibrary_2_1.xsd"
version="2.1">
<tlib-version>1.0</tlib-version>
<short-name>myfn</short-name>
<uri>http://example.com/jsp/tlds/mask</uri>
<!-- 1. 注册手机号脱敏函数,引用类型必须使用全限定类名 -->
<function>
<name>maskPhone</name>
<function-class>com.example.el.MaskUtils</function-class>
<function-signature>java.lang.String maskPhone(java.lang.String)</function-signature>
</function>
<!-- 2. 注册文本截断函数,基本类型直接使用 int -->
<function>
<name>truncate</name>
<function-class>com.example.el.MaskUtils</function-class>
<function-signature>java.lang.String truncate(java.lang.String, int)</function-signature>
</function>
</taglib>最后在 user_card.jsp 中引入 TLD 并通过前缀调用自定义函数:
<%@ page contentType="text/html; charset=UTF-8" %>
<%-- 1. 通过 TLD 中声明的 URI 引入自定义函数库并指定前缀 --%>
<%@ taglib prefix="myfn" uri="http://example.com/jsp/tlds/mask" %>
<!DOCTYPE html>
<html>
<body>
<p>用户名:${user.username}</p>
<%-- 2. 调用自定义手机号脱敏函数 --%>
<p>联系电话:${myfn:maskPhone(user.phone)}</p>
<%-- 3. 调用自定义文本截断函数并传入常量参数 --%>
<p>个人简介:${myfn:truncate(user.bio, 20)}</p>
<%-- 4. 传入缺失变量时,EL 将 null 转为 "" 后传入方法,不会抛出空指针异常 --%>
<p>备用电话:${myfn:maskPhone(user.backupPhone)}</p>
</body>
</html>API: FunctionMapper【待补充】
ELResolver 解析链
在 JSP 2.0 时代,EL 通过 VariableResolver 处理顶层变量查找,通过 PropertyResolver 处理对象属性导航,两套接口职责割裂且难以扩展。自 JSP 2.1 引入 Unified EL 后,规范将两者统一抽象为单一的 ELResolver,并基于组合模式与责任链模式构建可插拔的解析流水线。无论是读取隐式对象、Map 键值、List 下标、JavaBean 属性,还是按四大作用域检索顶层变量,底层全部由同一套 ELResolver 解析链驱动完成。
责任链架构
ELResolver 将“顶层标识符解析”与“对象属性导航”收敛到了统一的 (context, base, property) 参数模型中,通过 base 是否为 null 区分当前求值阶段:
顶层变量解析(
base == null):解析表达式最左侧的根标识符(例如${user.address.city}中的user,或${param.id}中的param)。此时property传入标识符名称,只有负责顶层查找的解析器(如ImplicitObjectELResolver、ScopedAttributeELResolver)会响应。属性导航解析(
base != null):对上一步得到的非空对象执行下钻读取(例如base为User实例、property为"address")。此时各类型专属解析器会检查base的运行时类型,匹配则提取属性,不匹配则静默放行。
整个解析链围绕 ELContext 中的 propertyResolved 布尔标记协作。链上任何一个 ELResolver 一旦确认当前 (base, property) 归自己处理,就会调用 context.setPropertyResolved(true) 并返回结果,从而通知外层调度器立即终止后续遍历。

CompositeELResolver
CompositeELResolver 本身也是 ELResolver 的子类,它内部维护一个按注册顺序排列的子解析器集合,充当整条解析链的统一入口与调度器。
每当 EL 引擎需要对一对 (base, property) 执行读、写、类型推导或方法调用时,都会向顶层 CompositeELResolver 发起请求,其核心调度步骤如下:
将当前
ELContext的propertyResolved标记重置为false,清除上一次解析遗留的状态。按照子解析器在内部数组中的先后顺序,逐一委派调用对应方法。
每次子解析器调用返回后,立刻检查
context.isPropertyResolved()。一旦检测到标记为
true,立即短路返回该子解析器的结果,不再继续调用排在后面的解析器。若遍历完所有子解析器后标记仍为
false,则向调用方返回null(写操作或严格上下文可能据此触发异常)。

CompositeELResolver 内部的委派与短路逻辑可概括为如下核心代码:
// 1. 每次进入链式解析前,先重置当前上下文的解析命中标记
context.setPropertyResolved(false);
// 2. 按注册顺序遍历子解析器数组
for (int i = 0; i < size; i++) {
Object value = resolvers[i].getValue(context, base, property);
// 3. 任一子解析器将标记置为 true 时,立刻短路返回结果
if (context.isPropertyResolved()) {
return value;
}
}
// 4. 整条链路均未认领该属性,返回 null
return null;JSP 默认解析链顺序
JSP 规范对容器装配的默认 CompositeELResolver 顺序做出了强制约定(以 Tomcat 8+ / JSP 2.3 / EL 3.0 实现为例)。解析顺序直接决定了同名标识符与混合类型对象的匹配优先级:
| 顺序 | 解析器名称 | 响应条件 | 核心职责 |
|---|---|---|---|
| 1 | ImplicitObjectELResolver | base == null | 拦截 11 个 JSP 隐式对象关键字 |
| 2 | 自定义 ELResolver | 由业务代码决定 | 通过 JspApplicationContext 注册的应用级扩展解析器 |
| 3 | StreamELResolver | base 为流或集合(EL 3.0) | 支持 EL 3.0 集合流式操作 |
| 4 | StaticFieldELResolver | base 为 ELClass(EL 3.0) | 解析已导入类的静态字段与静态方法 |
| 5 | MapELResolver | base instanceof Map | 以 property 为键读写 Map 条目 |
| 6 | ResourceBundleELResolver | base instanceof ResourceBundle | 读取国际化资源包键值 |
| 7 | ListELResolver | base instanceof List | 将 property 转为整数下标读写 List 元素 |
| 8 | ArrayELResolver | base.getClass().isArray() | 将 property 转为整数下标读写数组元素 |
| 9 | BeanELResolver | base != null(任意对象) | 遵循 JavaBean 内省规范调用 getter/setter |
| 10 | ScopedAttributeELResolver | base == null | 按 page -> request -> session -> application 顺序检索属性 |
需要留意该顺序的两个架构设计意图:一是 ImplicitObjectELResolver 永远排在第一位,确保自定义解析器和作用域属性无法劫持 pageContext、param 等核心内置关键字;二是 BeanELResolver 位于 Map、List、数组解析器之后,确保集合对象优先按容器语义取值,而不是误把键名或下标当作 JavaBean 属性去反射查找 getter。
ImplicitObjectELResolver
仅当 base == null 且 property 精确匹配 11 个内置隐式对象名称之一时生效。命中后直接从当前 PageContext 构造或取出对应的只读对象,并将 propertyResolved 设为 true。由于位于链首,即便开发者向 request 作用域存入名为 "param" 的属性,${param} 依然会优先命中隐式对象。
StreamELResolver
自 EL 3.0 引入,负责响应集合上的 .stream() 方法调用以及后续的 filter、map、sorted、toList 等流式管道操作。在 EL 2.x 容器中不存在该节点。
StaticFieldELResolver
自 EL 3.0 引入,配合 ImportHandler 工作。当表达式访问已导入类的静态常量或静态方法(如 ${Math.PI})时,由该解析器定位对应 Class 上的 public static 成员并完成读取或调用。
MapELResolver
当 base != null 且 base 实现了 java.util.Map 接口时生效。读操作直接返回 map.get(property),即使目标键不存在、返回值为 null,该解析器依然会将 propertyResolved 置为 true 以结束链路。这正是 ${map.missingKey} 不会继续落入下游 BeanELResolver 而抛出 PropertyNotFoundException 的根本原因。
ResourceBundleELResolver
当 base 为 java.util.ResourceBundle 实例时生效,用于读取国际化资源文件中的文案键。如果键不存在,它会直接返回 "???" + property + "???" 格式的占位提示文本,并将 propertyResolved 置为 true,防止页面渲染中断。
ListELResolver
当 base 实现了 java.util.List 接口时生效。它先将 property 强制转换为 int 索引;若转换失败(如传入非数字字符串)会直接抛出 IllegalArgumentException。如果索引越界(小于 0 或大于等于集合长度),读操作会捕获越界情况并设置 propertyResolved 为 true 后返回 null。
ArrayELResolver
当 base != null 且 base.getClass().isArray() 返回 true 时生效。其索引类型转换与越界静默返回 null 的行为与 ListELResolver 保持完全一致,底层通过 java.lang.reflect.Array 完成元素读取与基本类型自动装箱。
BeanELResolver
当 base != null 且前面所有集合与特殊类型解析器均未命中时,作为对象属性导航的兜底节点生效。它借助 java.beans.Introspector 查找目标类对应的 PropertyDescriptor(缓存于弱引用或软引用结构中以降低反射开销),然后调用其 public 读取方法。若目标类中不存在对应属性或缺少 public getter,则会抛出 PropertyNotFoundException。
ScopedAttributeELResolver
排在整条链路的末尾,专门负责 base == null 的兜底顶层变量解析。当 ImplicitObjectELResolver 与自定义解析器均未认领当前变量名时,它调用 pageContext.findAttribute((String) property),按 page -> request -> session -> application 顺序逐级查找。无论最终是否找到匹配属性,它都会将 propertyResolved 置为 true(未找到时返回 null,由页面输出为空字符串)。
多段表达式求值路径
对于包含多级导航的复合表达式,EL 引擎并非一次性走完解析链,而是按从左到右的语法树节点,每解析一段就完整触发一次 CompositeELResolver 调度。以上一节解析过的嵌套订单表达式 ${order.items[0].price} 为例,完整求值路径分为四轮:
第一轮(
base = null, property = "order"):ImplicitObjectELResolver未命中;自定义解析器未命中;Map、List、数组与Bean解析器因base == null全部跳过;最终由链尾的ScopedAttributeELResolver命中,从request作用域取出Order对象返回。第二轮(
base = orderObj, property = "items"):ImplicitObjectELResolver因base != null跳过;Map、List、数组解析器类型不匹配跳过;最终由BeanELResolver命中,调用orderObj.getItems()返回List<OrderItem>。第三轮(
base = itemsList, property = 0L):跳过Map与ResourceBundle解析器后,由ListELResolver命中,将0L转为int索引0,调用itemsList.get(0)返回首个OrderItem实例。第四轮(
base = itemObj, property = "price"):依次跳过集合类解析器,由BeanELResolver命中,调用itemObj.getPrice()返回最终价格结果。
如果在任意中间轮次(例如第二轮 orderObj.getItems())返回了 null,EL 引擎会在进入下一轮前直接短路退出,返回 null,不再继续把 base = null 传给后续属性段。
自定义解析器扩展约束
当应用需要向所有 JSP 页面暴露统一的只读配置、动态字典或领域对象解析规则,又不希望每次请求都在过滤器或 Controller 中手动向作用域 setAttribute 时,可以通过继承 ELResolver 扩展解析链。编写与注册自定义解析器需遵循以下约束:
注册时机限制:必须通过
ServletContextListener在 Web 应用启动阶段调用JspApplicationContext完成注册。一旦应用开始接收并处理首个 HTTP 请求,容器会锁定解析链结构,此时再调用注册方法会抛出IllegalStateException。**严格控制
propertyResolved**:仅当(base, property)确实属于当前解析器的处理范围时,才允许调用context.setPropertyResolved(true)。若在未命中分支误设为true,会直接阻断下游所有内置解析器,导致常规属性全部失效。高频调用性能意识:由于自定义解析器插在
ImplicitObjectELResolver之后、所有内置类型解析器之前,页面中每一个 EL 片段的每一段导航都会经过它。因此判定条件必须轻量(优先判断base == null或具体目标类型),严禁在未命中路径中执行数据库查询、远程调用或重型反射。多解析器相对顺序:若注册了多个自定义
ELResolver,容器严格按照注册先后顺序依次调用,先注册者优先级更高。
示例: 只读环境配置 ELResolver
下面实现一个只读环境配置解析器 EnvConfigELResolver,使所有 JSP 页面无需任何后端预置代码,即可通过 ${env['app.mode']} 读取全局应用环境配置,并复用了下游 MapELResolver 完成键值提取。
首先编写继承自 ELResolver 的自定义解析器:
package com.example.el;
import java.beans.FeatureDescriptor;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import javax.el.ELContext;
import javax.el.ELResolver;
// 1. 自定义只读环境配置解析器,拦截顶层标识符 env 及其配置键读取
public class EnvConfigELResolver extends ELResolver {
private static final String ROOT_KEY = "env";
private final Map<String, String> configMap;
// 2. 初始化只读配置映射表
public EnvConfigELResolver() {
Map<String, String> init = new HashMap<>();
init.put("app.mode", "production");
init.put("app.region", "cn-east");
this.configMap = Collections.unmodifiableMap(init);
}
// 3. 核心取值逻辑:仅在命中自身职责时将 propertyResolved 置为 true
@Override
public Object getValue(ELContext context, Object base, Object property) {
if (context == null) {
throw new NullPointerException();
}
// 4. 顶层解析(base == null)时拦截名为 env 的标识符,返回只读配置 Map
if (base == null && ROOT_KEY.equals(property)) {
context.setPropertyResolved(true);
return configMap;
}
// 5. 未命中时保持 propertyResolved 为 false,交由下游解析器继续处理
return null;
}
// 6. 声明该自定义解析器提供的配置为只读,禁止写入修改
@Override
public boolean isReadOnly(ELContext context, Object base, Object property) {
if (base == null && ROOT_KEY.equals(property)) {
context.setPropertyResolved(true);
return true;
}
return false;
}
@Override
public Class<?> getType(ELContext context, Object base, Object property) {
return null;
}
@Override
public void setValue(ELContext context, Object base, Object property, Object value) {
}
@Override
public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext context, Object base) {
return null;
}
@Override
public Class<?> getCommonPropertyType(ELContext context, Object base) {
return String.class;
}
}随后通过 ServletContextListener 在应用启动阶段将其挂载到 JspApplicationContext:
package com.example.listener;
import com.example.el.EnvConfigELResolver;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.jsp.JspApplicationContext;
import javax.servlet.jsp.JspFactory;
// 1. 在 Web 应用启动阶段向容器注册自定义 ELResolver
@WebListener
public class AppELConfigListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
// 2. 获取当前应用的 JspApplicationContext 实例
ServletContext servletContext = sce.getServletContext();
JspApplicationContext jspAppContext =
JspFactory.getDefaultFactory().getJspApplicationContext(servletContext);
// 3. 将自定义解析器加入解析链(紧跟在 ImplicitObjectELResolver 之后)
jspAppContext.addELResolver(new EnvConfigELResolver());
}
}注册完成后,任意 JSP 页面即可直接读取 env 配置,同时不影响常规作用域属性的解析:
<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<body>
<%-- 1. 顶层 env 由 EnvConfigELResolver 返回 Map,键名再交由下游 MapELResolver 解析 --%>
<p>运行模式:${env['app.mode']}</p>
<p>部署区域:${env['app.region']}</p>
<%-- 2. 未命中 env 的常规属性继续透传至 ScopedAttributeELResolver 正常解析 --%>
<p>当前用户:${user.username}</p>
</body>
</html>API: ELResolver【待补充】
API: CompositeELResolver【待补充】
API: JspApplicationContext【待补充】
EL 注入安全问题
EL 注入(Expression Language Injection)是指攻击者构造的不可信输入被服务端当作 EL 表达式语法片段交由 EL 引擎解析执行,从而越权读取服务端内存数据甚至实现远程代码执行(RCE)的高危漏洞。由于 EL 2.2 开放了任意对象实例方法调用、EL 3.0 进一步引入了静态方法调用与 Lambda 表达式,一旦不可信数据跨过数据与代码的边界进入求值引擎,危害往往直接升级为服务器失陷。
漏洞成因
普通 JSP 页面中的 ${param.name} 并不会触发 EL 注入。当用户传入参数 name=${1+1} 时,EL 引擎仅在首次求值中读取参数值,得到字面字符串 "${1+1}" 后直接写入响应流,不会对该结果再次解析。
EL 注入的本质是不可信数据被拼入了表达式代码本身,通常表现为以下两种形态:
直接拼接执行:服务端业务代码将用户输入直接拼入字符串,随后显式调用
ExpressionFactory或ELProcessor对拼接结果求值。二次求值(Double Evaluation):第一层组件解析或提取出包含用户输入的字符串,第二层标签库、校验框架或模板引擎误将该字符串当作 EL 表达式模板再次送入求值器解析。

常见触发场景
显式动态求值拼接
部分系统为了实现动态文案渲染、可配置报表公式或灵活条件判断,会在 Java 代码中直接调用 ELProcessor 或 ExpressionFactory。若未将用户输入与表达式模板隔离,攻击者即可通过闭合引号或注入运算符逃逸出原始语境:
// 1. 危险示范:直接将外部请求参数拼接到 EL 表达式中
String userInput = req.getParameter("keyword");
String expr = "'" + userInput + "'";
// 2. 攻击者传入闭合引号的载荷即可逃逸字符串字面量并执行任意表达式
ELProcessor processor = new ELProcessor();
Object result = processor.eval(expr);Bean Validation 消息模板插值
这是 Java Web 应用中最典型的 EL 注入高发区。遵循 JSR 303 / JSR 380 规范的 Hibernate Validator 在渲染校验失败提示消息时,默认会使用 EL 引擎解析消息模板中的 ${...} 占位符。
当开发者编写自定义 ConstraintValidator 时,如果为了在报错信息中回显非法输入,直接将用户输入拼接进 buildConstraintViolationWithTemplate 的参数中,就会直接触发 EL 注入:
// 1. 危险示范:自定义校验器将用户输入直接拼入异常消息模板
public class SafeCodeValidator implements ConstraintValidator<ValidCode, String> {
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
// 2. 禁用默认模板,准备构造自定义提示信息
context.disableDefaultConstraintViolation();
// 3. 错误做法:直接拼接用户输入,Hibernate Validator 默认会用 EL 解析模板
String message = "非法的编码格式:" + value;
context.buildConstraintViolationWithTemplate(message)
.addConstraintViolation();
return false;
}
}JSP 标签库二次求值
在早期 Spring Framework(如 CVE-2011-2730)及其他支持表达式属性的自定义 JSP 标签库中,如果容器本身已在 JSP 2.1+ 层面完成了一次 EL 求值,而标签实现类内部又调用框架自带的表达式求值器对属性值执行了第二次解析,当页面编写 <spring:message code="${param.msg}" /> 时,用户传入的 ${...} 内容就会在第二轮求值中被真正执行。
攻击利用链
EL 注入的实际破坏力取决于容器支持的 EL 规范版本以及当前 ELContext 中暴露的隐式对象与解析器。
敏感上下文探测
即便在不支持方法调用的早期 EL 2.1 环境中,攻击者依然可以通过隐式对象和属性导航探测服务端状态与敏感配置:
验证注入存在:输入
${7 * 7}或#{7 * 7},若页面回显49而非原始字符串,即可确认存在 EL 解析入口。窃取运行时机密:访问
${applicationScope}、${sessionScope}、${initParam}或${pageContext.servletContext},批量转储全局配置、会话凭证与数据库连接信息。
反射与命令执行
在 EL 2.2 及以上版本(Tomcat 7+)中,由于支持直接调用任意 public 实例方法,攻击者无需依赖任何特定业务对象,仅凭任意字符串或上下文对象的 getClass() 即可沿反射链突破视图边界:
EL 2.2 反射链:通过任意对象调用
.getClass().forName(...)加载java.lang.Runtime或javax.script.ScriptEngineManager,再结合反射方法触发系统命令执行或脚本引擎求值。EL 3.0 静态访问与构造:EL 3.0 的
StaticFieldELResolver与内联构造能力进一步缩短了利用路径,若ELContext未加限制,甚至可直接构造ScriptEngineManager或调用运行时类执行任意 JVM 代码。
EL 注入与 XSS 区别
在 JSP 开发中,EL 注入与跨站脚本攻击(XSS)常发生在同一套页面输入输出流程里,但两者的执行位置、成因与防御手段完全不同:
| 对比维度 | EL 注入 | XSS(跨站脚本) |
|---|---|---|
| 代码执行位置 | 服务端 JVM(由容器 EL 引擎求值) | 客户端浏览器(由浏览器 JS 引擎执行) |
| 触发前提 | 用户输入被拼入 EL 表达式或触发二次求值 | ${param.x} 输出到 HTML 时未做字符转义 |
| 典型危害 | 泄露服务端作用域与配置、反射执行系统命令 | 窃取浏览器 Cookie、劫持用户前端会话 |
| 核心防御手段 | 数据与表达式模板分离、禁用非必要 EL 插值 | 输出编码,使用 <c:out> 或 fn:escapeXml |
例如,在 JSP 中直接书写 ${param.keyword} 虽然不会导致 EL 注入,但如果用户提交 <script>...</script>,未经转义的原始输出仍会引发反射型 XSS,需借助 JSTL <c:out> 完成 HTML 实体编码:
<%-- 1. 直接输出不会触发 EL 注入,但未做 HTML 转义,存在反射型 XSS 风险 --%>
<p>搜索词:${param.keyword}</p>
<%-- 2. 使用 JSTL c:out(默认 escapeXml="true")对输出进行 HTML 实体转义 --%>
<p>安全输出:<c:out value="${param.keyword}" /></p>防御措施
表达式与数据分离
防范 EL 注入的根本原则与防范 SQL 注入一致——严格分离表达式代码与外部数据。表达式模板字符串必须由服务端硬编码或来自受信任的静态配置,所有外部输入只能以变量或 Bean 的形式绑定到 ELContext、VariableMapper 或作用域中,绝不允许通过字符串拼接进入表达式文本。
Bean Validation 安全插值
针对 Hibernate Validator 的消息模板注入风险,可按业务需求采取两种加固方案:
- 使用参数化消息绑定:保持模板字符串为静态常量,通过
HibernateConstraintValidatorContext的addMessageParameter绑定不可信输入,框架在替换命名占位符时不会对其内容执行 EL 解析:
// 1. 禁用默认模板并转为 Hibernate 扩展上下文
context.disableDefaultConstraintViolation();
HibernateConstraintValidatorContext hibernateContext =
context.unwrap(HibernateConstraintValidatorContext.class);
// 2. 通过参数绑定传入不可信输入,框架不会对参数值执行 EL 解析
hibernateContext.addMessageParameter("invalidValue", value);
// 3. 模板字符串保持静态常量,仅引用命名占位符
hibernateContext.buildConstraintViolationWithTemplate("非法的编码格式:{invalidValue}")
.addConstraintViolation();- 全局替换为非 EL 插值器:若项目校验消息完全不需要 EL 计算能力,在构建
ValidatorFactory时显式指定ParameterMessageInterpolator,彻底关闭校验消息中的 EL 求值通道。
容器与框架配置加固
关闭旧标签库冗余 EL 支持:在运行于 JSP 2.1+ 容器的传统 Spring MVC 项目中,于
web.xml配置<context-param>将springJspExpressionSupport显式设为false,避免 Spring 标签库对容器已求值的结果执行二次解析。及时升级基础依赖:保持 Servlet 容器(Tomcat / Jetty)、Hibernate Validator 与 Web 框架处于官方维护版本,修复历史已知的二次求值与沙箱绕过缺陷。
自定义 ELResolver 沙箱限制
若系统确实需要支持受控的动态表达式求值,不应直接将完整的默认解析链暴露给外部输入。可以在自定义 ELResolver 链首插入安全拦截节点,拦截对 Class、ClassLoader、Runtime、ProcessBuilder 与 ScriptEngineManager 等危险类型的属性访问与方法调用,并仅通过白名单开放允许访问的只读 DTO 对象;在 Spring 技术栈中,则应优先改用具备内置沙箱能力的 SpEL SimpleEvaluationContext。
示例: ELProcessor 参数绑定防注入
下面通过一个问候语格式化服务,演示如何利用 ELProcessor 的变量绑定能力将不可信输入限制在纯数据层面,从而从根源上杜绝 EL 注入:
package com.example.security;
import javax.el.ELProcessor;
// 1. 通过变量绑定隔离代码与数据,防止动态 EL 求值注入
public class SafeElEvalService {
public String formatGreeting(String userInput) {
// 2. 初始化 ELProcessor 实例
ELProcessor processor = new ELProcessor();
// 3. 将外部不可信输入作为数据对象绑定到上下文,而非拼接进表达式字符串
processor.defineBean("rawName", userInput);
// 4. 表达式模板保持静态常量,仅引用已绑定变量名
// 即使 userInput 含引号或 EL 语法片段,也只会被当作纯字符串数据读取
Object result = processor.eval("'欢迎访问:' += rawName.trim()");
return String.valueOf(result);
}
}