现场还原

这个问题最开始看起来有点反直觉。

日志里报的是:

Error querying database.  Cause: java.sql.SQLException: No operations allowed after statement closed.
The error occurred while setting parameters
SQL: SELECT COUNT(*)
     FROM tmp_pz_parse_20260616

SQL 本身很朴素,甚至没有 ? 占位符:

SELECT COUNT(*)
FROM tmp_pz_parse_20260616

如果只盯着这条 SQL,很容易想不通:既然没有参数,为什么错误会发生在 setting parameters?为什么 statement 已经关闭了,MyBatis 还会去设置参数?

这篇笔记就顺着这个问题,把 MyBatis 执行一条 mapper SQL 的关键机制捋一遍。

先说结论

这次问题不是 COUNT(*) 语法错,也不是临时表名不存在。

更准确地说,它是一个执行链问题:

动态表名 SQL
  -> 默认走 PreparedStatement
  -> MyBatis 仍然进入参数设置流程
  -> 项目中的连接池 / 拦截器 / statement 包装对象参与执行
  -> 某个 PreparedStatement 生命周期已经结束
  -> 后续仍触发 setParameters
  -> No operations allowed after statement closed

所以最后的修复方向是:对这几条已经经过严格校验、且没有真实绑定参数的动态表名查询,改成普通 Statement 执行,避开 PreparedStatement 的参数绑定阶段。

对应 mapper 配置是:

<select id="countTotal"
        resultType="long"
        useCache="false"
        flushCache="true"
        statementType="STATEMENT">
    SELECT COUNT(*)
    FROM ${tableName}
</select>

这个改法不是说 STATEMENT 比 PREPARED 更好,而是说这类动态表名 SQL 本来就没法用 #{} 绑定表名,既然最终 SQL 已经是完整文本,并且表名已经在 Service 层白名单校验过,用 STATEMENT 反而更贴合它的执行形态。

MyBatis 执行一条 XML SQL 时到底做了什么

平时写 mapper XML,直觉上像是在写 SQL:

<select id="countTotal" resultType="long">
    SELECT COUNT(*)
    FROM ${tableName}
</select>

但 MyBatis 真正执行时,中间会拆出几层对象。

MappedStatement:一条 mapper 方法的元信息

MyBatis 启动时会解析 XML。每个 <select>、<update>、<insert>、<delete> 最后都会变成一个 MappedStatement。

它里面保存的不是单纯 SQL 字符串,而是一整套执行信息:

namespace + id
SQL 类型,是 SELECT 还是 UPDATE
参数映射规则
返回值映射规则
缓存配置
statementType
超时时间
fetchSize

例如:

<select id="countTotal" resultType="long">

最后对应的 statement id 大概是:

cn.quinlanxie.mapper.ITmpPzSpecCleanMapper.countTotal

业务代码调用:

tmpPzSpecCleanMapper.countTotal(tableName);

本质上就是 MyBatis 根据这个 statement id 找到对应的 MappedStatement,然后进入执行器。

BoundSql:动态 SQL 解析后的结果

XML 里的 SQL 还不是最终 SQL。

比如这里用了:

FROM ${tableName}

当参数传入:

tableName = "tmp_pz_parse_20260616"

MyBatis 会把它解析成 BoundSql:

SELECT COUNT(*)
FROM tmp_pz_parse_20260616

BoundSql 可以理解为“这一次调用真正要执行的 SQL”。

它通常包含两部分:

最终 SQL 文本
参数映射 parameterMappings

如果 XML 是这样:

WHERE id = #{id}

解析后 SQL 会变成:

WHERE id = ?

同时 parameterMappings 里会记录这个 ? 对应的是 id。

但如果 XML 是这样:

FROM ${tableName}

解析后 SQL 直接变成:

FROM tmp_pz_parse_20260616

它不会产生 ?,也就没有真正需要 JDBC 绑定的参数。

这也是这次问题让人别扭的地方:最终 SQL 没有 ?,但默认执行流程还是 PreparedStatement 那套流程。

${} 和 #{} 的区别,不只是 SQL 注入

很多人讲 ${} 和 #{},会直接总结成:

${} 有 SQL 注入风险
#{} 可以防 SQL 注入

这个说法没错,但还不够。

它们真正的区别是:

${} 是文本替换
#{} 是参数绑定

${}:先拼成完整 SQL

例如:

FROM ${tableName}

传入:

tmp_pz_parse_20260616

最终 SQL:

FROM tmp_pz_parse_20260616

这就是纯文本替换。

它适合用在 SQL 结构本身必须动态变化的地方,比如:

动态表名
动态列名
动态排序字段

但它必须配合白名单校验。

比如这次 Service 层限制表名:

^tmp_pz_parse_[0-9]{8}$

这就把可输入内容限制死了,只允许类似:

tmp_pz_parse_20260616
tmp_pz_parse_20260617

这类值。

#{}:交给 JDBC 参数绑定

例如:

WHERE id = #{id}

最终 SQL:

WHERE id = ?

然后 MyBatis 会调用 JDBC:

preparedStatement.setLong(1, id);

这就是参数绑定。

它适合用在值的位置:

id
name
status
create_time
amount

但它不能用来绑定表名。

下面这种写法是不成立的:

FROM #{tableName}

因为 JDBC 只会把它当成一个字符串值,而不是 SQL 标识符。最终类似于:

FROM 'tmp_pz_parse_20260616'

数据库不会把字符串当表名用。

所以动态表名只能走 ${},关键是要把输入校验做好。

默认的 statementType 是 PREPARED

MyBatis 的 statementType 有三个常见值:

STATEMENT
PREPARED
CALLABLE

默认是:

PREPARED

也就是使用 JDBC 的 PreparedStatement。

平时大多数 SQL 都应该用默认值,因为它有几个好处:

支持参数绑定
减少 SQL 注入风险
数据库可以复用执行计划
和 MyBatis 参数映射机制配合最好

默认流程大概是:

Executor
  -> StatementHandler.prepare(connection)
  -> connection.prepareStatement(sql)
  -> ParameterHandler.setParameters(preparedStatement)
  -> StatementHandler.query/update
  -> ResultSetHandler 处理结果
  -> close statement

这条链里有一个很关键的步骤:

ParameterHandler.setParameters

只要走 PreparedStatement,MyBatis 就会有这个参数设置阶段。

哪怕这次 SQL 最终没有 ?,执行链仍然是围绕 PreparedStatement 建起来的。

这次为什么会在 setParameters 阶段异常

从日志看,异常发生在:

The error occurred while setting parameters

而不是:

Error executing SQL
Error mapping results

这说明数据库还没真正开始执行,问题出在 MyBatis 准备 statement 的过程中。

正常情况下,即使没有参数,setParameters 也不会有事。它最多发现没有 parameter mappings,然后什么都不做。

但这个项目里执行链并不只有 MyBatis 自己。

还有几个参与者:

Druid 连接池
MyBatis-Plus
自定义 StatisticsInterceptor
自定义 UpdateDataInterceptor
MyBatis 插件代理链

其中比较值得注意的是 StatisticsInterceptor。

它拦截的是:

StatementHandler.prepare(Connection.class, Integer.class)

也就是说,它插在 statement 准备阶段。

插件内部还会自己构造统计 SQL,然后手动做参数绑定:

PreparedStatement statement = connection.prepareStatement(countSql);
DefaultParameterHandler parameterHandler =
        new DefaultParameterHandler(mappedStatement, boundSql.getParameterObject(), boundSql);
parameterHandler.setParameters(statement);

这类代码在普通分页查询里可能没事,但遇到动态 SQL、动态表名、分页参数改写、无参数 SQL 时,风险会变高。

因为它复用了原始的:

MappedStatement
BoundSql
parameterObject

同时又自己创建了另一个 PreparedStatement。

如果 SQL 被插件改过、参数映射列表被删改过、statement 被 Druid 包装过,或者某个分支提前关闭了 statement,后面再进入 setParameters,就可能拿到一个生命周期已经结束的 statement。

这时 MySQL JDBC driver 会直接抛:

No operations allowed after statement closed.

所以这次报错不是说 SQL 文本需要参数却没设置,而是说“参数设置阶段拿到的 JDBC statement 已经不能用了”。

Druid 包装后的 statement 会让问题更隐蔽

项目里使用的是 Druid。

Druid 不会把原生 JDBC 对象直接裸露出来,它会包一层,比如:

DruidPooledConnection
DruidPooledPreparedStatement
DruidPooledStatement

这些包装对象会做连接池管理、监控、慢 SQL 记录、防火墙检查、statement 缓存等事情。这本来是正常的。

但问题是,MyBatis 插件如果通过反射去拿底层 statement,或者自己在 prepare 阶段额外创建 statement,就很容易出现“上层对象还在,底层真实 statement 已经 close”的情况。

项目里的 UpdateDataInterceptor 就有类似代码:

String originalSql =
    SystemMetaObject
        .forObject(((DruidPooledStatement) statement).getStatement())
        .getValue("statement")
        .toString();

这种写法不是一定有问题,但它说明项目里的 SQL 执行链确实不是单纯的 MyBatis 默认链路,而是有不少对 statement 的包装、拆包和反射访问。

在这种环境下,动态表名 SQL 继续走 PreparedStatement,就更容易撞上生命周期边界。

为什么改成 STATEMENT 能解决

修改后:

statementType="STATEMENT"

MyBatis 会使用 JDBC 的普通 Statement。

执行形态变成:

Executor
  -> StatementHandler.prepare(connection)
  -> connection.createStatement()
  -> StatementHandler.query
  -> statement.execute(sql)

关键差异是:不再有 PreparedStatement 的参数绑定阶段。

也就是不会再走:

parameterHandler.setParameters(preparedStatement);

而这次异常正好发生在这个阶段。

所以 STATEMENT 的作用不是“修复数据库”,而是让这类已经完整拼好的 SQL 不再走不必要的参数绑定链路。

对于这三类 SQL 尤其合适:

SELECT COUNT(*)
FROM ${tableName}

SELECT COUNT(*)
FROM ${tableName}
WHERE short_spec_clean IS NULL

SELECT id, short_spec_raw
FROM ${tableName}
WHERE short_spec_clean IS NULL
ORDER BY id
LIMIT ${batchSize}

这些 SQL 的动态部分都不是值参数,而是 SQL 结构的一部分。

表名必须拼进去。

LIMIT 数字也已经在 Service 层限制过:

batchSize > 0
batchSize <= MAX_BATCH_SIZE

因此用 STATEMENT 是合理的。

useCache 和 flushCache 又在这里做了什么

这次还配了:

useCache="false"
flushCache="true"

它们跟 statement closed 不是同一个层面的问题,但放在这类动态表名临时表操作里比较稳。

useCache=“false”

表示这个 select 不使用 MyBatis 二级缓存。

MyBatis 一级缓存是 SqlSession 级别,二级缓存是 namespace 级别。

这类清洗任务会反复做:

countTotal
countRemaining
selectBatchToClean
updateCleanById
countRemaining

而且表名是动态的:

tmp_pz_parse_20260616
tmp_pz_parse_20260617

这种场景最不希望缓存掺和进来。每次 count 都应该看数据库当前状态。

所以:

useCache="false"

意思就是:这条查询别读二级缓存。

flushCache=“true”

表示执行这条语句时刷新缓存。

正常情况下,select 的 flushCache 默认是 false,insert/update/delete 默认是 true。

这里对查询也设成 true,是为了更明确地告诉 MyBatis:

这几条临时表清洗 SQL 不要依赖缓存状态

尤其是在同一个接口里先 update 再 count,宁愿多查一次数据库,也不要拿到旧值。

为什么没有把 update 也改成 STATEMENT

更新语句仍然保留:

<update id="updateCleanById" flushCache="true">
    UPDATE ${tableName}
    SET short_spec_clean = #{shortSpecClean}
    WHERE id = #{id}
</update>

这里不能轻易改成 STATEMENT。

原因是 shortSpecClean 是清洗后的字符串,虽然它来自原始规格字段,不是用户直接输入,但它仍然是一个“值”。

值就应该用 #{} 绑定。

例如清洗结果里如果出现特殊字符、空字符串、null 处理、类型转换,交给 PreparedStatement 更稳。

所以这次修复只动了查询:

动态表名 count
动态表名 select batch

没有把 update 一起改掉。

这是一个边界:

SQL 结构动态,用 ${},前提是白名单校验
SQL 值动态,用 #{}

一个更根本的方向:少让插件碰到这类 SQL

这次用 STATEMENT 是针对当前报错的直接修复。

如果要把这块做得更干净,可以考虑再加一层保护:让统计类插件跳过临时表清洗 mapper。

例如在 StatisticsInterceptor 里判断 statement id:

String statementId = mappedStatement.getId();
if (statementId.startsWith("cn.quinlanxie.mapper.ITmpPzSpecCleanMapper.")) {
    return invocation.proceed();
}

因为这个清洗接口不是普通分页列表,也不需要页面 footer 统计。

它是一个批处理工具接口。

让分页统计插件参与进来,收益很低,风险更高。

不过这个改法影响的是公共插件,范围比 mapper XML 更大,需要更小心测试。

当前先在 mapper 层把这几条 SQL 的执行方式收窄,是更克制的处理。

复盘一下这个问题的判断路径

这类问题不能只看最后一条 SQL。

当看到:

The error occurred while setting parameters

第一反应应该是去看 MyBatis 执行链,而不是只看 SQL 语法。

排查顺序可以是:

1. 这条 SQL 有没有 #{}
2. 最终 SQL 有没有 ?
3. mapper 有没有动态表名、动态列名、动态排序
4. statementType 是不是默认 PREPARED
5. 项目里有没有 MyBatis 拦截器
6. 拦截器有没有手动 prepareStatement / setParameters
7. 连接池有没有 statement 包装或缓存
8. 是否存在批处理、循环调用、同线程上下文残留

这次刚好几个条件都碰上了:

动态表名
临时表批处理
默认 PreparedStatement
Druid statement 包装
自定义 MyBatis 插件
异常发生在 setParameters

所以最后才会出现看似奇怪的现象:

一条没有参数的 COUNT SQL,却在设置参数阶段报 statement closed

一些经验判断和必要事项

大多数业务 SQL,继续用默认 PREPARED,也就是 #{} 参数绑定。

但如果遇到下面这种 SQL:

表名动态
列名动态
排序字段动态
分表名动态
临时表名动态

就要意识到:这些部分不是 JDBC 参数,它们是 SQL 结构。

这时要做两件事:

第一,输入必须白名单校验
第二,确认是否真的需要 PreparedStatement

如果最终 SQL 已经是完整文本,且没有需要绑定的值参数,那么 statementType="STATEMENT" 反而可能更简单、更少踩执行链上的坑。

这不是鼓励到处用 ${} 和 STATEMENT。

恰恰相反,只有在边界足够清楚的时候才这么做。

这次的边界是:

表名:^tmp_pz_parse_[0-9]{8}$
batchSize:Service 层限制为正整数且不超过最大批次
查询 SQL:没有用户值参数
更新 SQL:仍然使用 #{}

在这个前提下,修复是成立的。

Logo

汇聚全球AI编程工具,助力开发者即刻编程。

更多推荐