一、起源:Java 应用访问数据库的层次问题
Java 代码与关系型数据库之间隔着四层距离:通信协议、连接开销、数据结构、事务边界。持久层框架的价值,就在于把其中若干层封装掉,代价是引入新的抽象与新的失效方式。
1.1 协议与驱动的差异
数据库对外暴露的是各自的二进制通信协议。MySQL 的协议与 PostgreSQL、Oracle 互不相同,同一家产品的不同大版本之间也可能变化。
Java 侧的应对方式是 JDBC(Java Database Connectivity):由 JDK 定义一组接口(java.sql 包),由各数据库厂商提供实现类(驱动)。上层代码只依赖接口,具体通信过程由驱动完成。
这层抽象并没有抹平数据库的差异,只是把差异集中到了两个位置:
| 差异维度 | 具体表现 | 对上层的影响 |
|---|---|---|
| 连接串格式 | jdbc:mysql://host:3306/db、jdbc:postgresql://host:5432/db | 由配置承担,可切换 |
| 分页语法 | MySQL 用 LIMIT offset, size,Oracle 12c 以前用 ROWNUM 嵌套 | 由框架的方言层承担 |
| 函数与类型 | 日期函数、字符函数、自增主键、BOOLEAN 的支持程度不同 | 手写 SQL 时会外溢到业务代码 |
| 预处理能力 | 服务端预处理是否默认开启、游标是否默认支持 | 影响参数绑定与流式查询的行为 |
| 驱动版本 | 驱动与数据库版本存在兼容矩阵,驱动过旧会不支持新特性 | 升级数据库时需要同步升级驱动 |
驱动是持久层最底层也最容易被忽略的一环。同一段业务 SQL 在更换数据库后能否执行,取决于这条链路上每一层对语法的容忍度。
1.2 连接成本
一次数据库连接从建立到可用,需要完成以下步骤:
建立连接的成本构成
1. TCP 三次握手(跨机房时单程 RTT 可达数毫秒)
2. 协议握手与认证(用户名口令校验、认证插件协商)
3. 会话初始化(字符集、时区、隔离级别、会话变量)
4. 服务端资源分配(线程、内存、会话状态)
对比:
一次简单查询的执行时间 约 0.1 ~ 1 ms
一次完整建连的耗时 约 5 ~ 50 ms(跨机房更高)
建连成本比查询本身高一到两个数量级。若每个请求都新建连接,数据库的连接建立与销毁会成为主要开销,同时服务端会话数量随并发线性增长,很快触达 max_connections。
连接池就是针对这一矛盾的解法:进程启动时预建若干连接,请求到达时借出,请求结束归还,物理连接始终复用。
1.3 映射负担
JDBC 返回的是 ResultSet,一种面向行的游标结构;业务代码需要的是对象。两者之间的转换只能逐字段书写:
// 手工映射的典型形态
List<User> users = new ArrayList<>();
try (PreparedStatement ps = conn.prepareStatement("SELECT id, name, created_at FROM t_user");
ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
User user = new User();
user.setId(rs.getLong("id"));
user.setName(rs.getString("name"));
// 时间类型转换
Timestamp ts = rs.getTimestamp("created_at");
user.setCreatedAt(ts == null ? null : ts.toLocalDateTime());
users.add(user);
}
}
这类代码的问题在于:字段与列名的对应关系、类型转换、空值处理、列名拼写错误都只能靠人工保证;表增加一列就需要修改所有相关映射;查询语句与映射代码分散在两个地方,重构时容易遗漏。
映射负担是 ORM 与半自动映射框架存在的直接理由。
1.4 事务边界
数据库事务由 BEGIN、COMMIT、ROLLBACK 三条语句界定,但业务上的一次"操作"往往由多个方法协作完成。事务边界放在哪一层,是持久层设计的核心问题之一:
- 放在 DAO/Mapper 层:每个数据库操作各自成事务,业务方法无法保证多条语句的原子性。
- 放在 Service 层:一个业务方法对应一个事务,是主流做法,但要求事务上下文能跨越多个 DAO 调用传递。
- 放在更外层(如 Web 层):事务持续时间过长,连接被长期占用。
事务上下文跨方法传递意味着"当前线程正在使用哪个连接"必须可被框架感知。这正是 Spring 事务管理器与线程绑定机制要解决的问题。
数据库侧的事务原理、隔离级别、MVCC 与锁机制,见 mysql: 事务与锁。本篇讨论的是 Java 侧的事务边界划定、传播行为与连接绑定,不重复数据库侧的原理推导。
1.5 两条路线:ORM 与 SQL 优先
持久层框架的选择最终归结为两种取向:
| 取向 | 代表 | 中心 | 生成 SQL 的责任方 |
|---|---|---|---|
| ORM(对象关系映射) | JPA / Hibernate | 对象模型 | 框架 |
| SQL 优先(半自动映射) | MyBatis、Spring JdbcTemplate | SQL 语句 | 开发人员 |
ORM 把"表到对象"的转换做成框架能力,简单增删改查无需书写 SQL;代价是复杂查询需要绕回 JPQL 或原生 SQL,且框架生成的 SQL 不可见,性能问题需要理解框架内部机制才能定位。
SQL 优先把 SQL 的书写权保留在开发人员手中,框架只承担参数绑定与结果映射;代价是简单 CRUD 也需要重复书写,且 SQL 与代码分散维护。
两条路线在同一个系统中并非互斥,实际项目中常见按场景分工的做法,其边界与风险见 2.5 节。
二、原理
2.1 JDBC 的抽象层次
JDBC 用少量接口覆盖了"连接—执行—取结果"的完整链路。
2.1.1 核心接口
| 接口 | 职责 | 关键实现/说明 |
|---|---|---|
Driver | 识别连接串前缀,创建 Connection | 由厂商实现,通过 SPI 自动注册 |
DataSource | 连接的工厂与来源抽象 | 由池实现(HikariCP、Druid 等)提供 |
Connection | 一次数据库会话,事务的载体 | 池化后由池代理,close() 归还而非销毁 |
Statement | 执行静态 SQL | 字符串拼接 SQL,无参数绑定 |
PreparedStatement | 执行带参数的 SQL | 参数以占位符 ? 传入,支持预编译 |
CallableStatement | 调用存储过程 | 处理出参与结果集 |
ResultSet | 结果集游标 | 默认单向只读 |
SQLException | 受检异常 | 承载 SQL 状态码与错误码 |
驱动注册在 JDBC 4.0 之后由 SPI 完成:驱动 jar 内的 META-INF/services/java.sql.Driver 文件声明实现类,DriverManager 启动时自动加载,Class.forName("com.mysql.cj.jdbc.Driver") 的写法属于旧版本遗留。
DriverManager.getConnection() 每次调用都会新建物理连接,不具备复用能力;生产代码应通过 DataSource 获取连接,由池承担复用。
2.1.2 预处理语句与参数绑定
PreparedStatement 的取值在于两点:参数绑定与执行计划复用。
-- 参数绑定:SQL 结构在编译期确定,参数运行期传入
SELECT id, name FROM t_user WHERE id = ?
参数值以数据类型和值的身份发送给数据库,不参与 SQL 语句的语法解析,因此无法改变语句结构,从机制上阻断了注入。而字符串拼接式 SQL 中,参数值会成为语句文本的一部分:
// 拼接方式:输入中的引号可以改变语句语义
String sql = "SELECT * FROM t_user WHERE name = '" + name + "'";
// 输入 name = "x' OR '1'='1" 时条件恒真
在 MyBatis 中,#{} 编译为 ? 占位符并走参数绑定,${} 则是直接文本替换,两者的差异就是上述两种方式的差异。${} 只应用于无法参数化的位置(如动态表名、动态排序字段),且必须经过白名单校验。
MySQL 侧的预编译需要连接参数 useServerPrepStmts=true 才在服务端完成;即使沿用客户端侧的转义实现,参数绑定的防注入效果依然成立。
2.1.3 结果集映射的手工成本
ResultSet 的读取有三个容易出错的点:
| 问题 | 表现 | 处理方式 |
|---|---|---|
| 列名与字段名不一致 | user_name 映射不到 userName | 起别名或在映射配置中声明下划线转驼峰 |
| 类型转换 | DECIMAL 读成 double 导致精度丢失 | 按目标类型选择 getBigDecimal 等方法 |
| 空值语义 | 基本类型读取 NULL 得到 0 或 false | 使用包装类型,配合 rs.wasNull() 判断 |
| 结果集规模 | 大结果集一次性装入内存导致 OOM | 使用游标/流式读取,见 3.1 节 |
2.1.4 资源关闭与泄漏
Connection、Statement、ResultSet 都持有操作系统或服务端资源,必须显式关闭,且关闭顺序为 ResultSet → Statement → Connection。
// try-with-resources 保证异常路径下也能关闭
try (Connection conn = dataSource.getConnection();
PreparedStatement ps = conn.prepareStatement(sql)) {
ps.setLong(1, id);
try (ResultSet rs = ps.executeQuery()) {
// 处理结果
}
}
池化之后,close() 的语义变为"归还连接到池"。若代码路径遗漏了关闭(例如提前 return 或抛出异常未走 finally),连接会一直被持有,池内可用连接逐步减少,最终表现为获取连接超时。这类问题被称为连接泄漏,其判定方式见 2.2 节的池参数部分。
Spring 还做了一层异常转译:SQLException 被转换为 DataAccessException 体系(如 BadSqlGrammarException、DuplicateKeyException、CannotAcquireLockException、QueryTimeoutException),使上层能够按语义而非数据库错误码做处理。
2.2 连接池
2.2.1 池化的收益与代价
收益来自复用:省去建连开销,同时把并发连接数控制在可控范围,保护数据库不被瞬时并发压垮。
代价来自共享:连接成为被争用的有限资源,池的参数配置直接决定了"高峰期是排队等待还是快速失败"。当一个连接上还残留着未提交的事务或未清理的会话变量时,下一个借用者会继承这份状态,因此归还前的状态重置是池的必要动作(多数池通过 rollback 与变量重置实现)。
2.2.2 关键参数
以 HikariCP(Spring Boot 默认)与 Druid 为例,参数可分为四组:
| 分组 | HikariCP | Druid | 作用 |
|---|---|---|---|
| 容量 | minimum-idle、maximum-pool-size | initial-size、min-idle、max-active | 池内连接数量的下限与上限 |
| 获取等待 | connection-timeout | max-wait | 无可用连接时的最长等待时间,超时抛出异常 |
| 空闲回收 | idle-timeout | time-between-eviction-runs-millis、min-evictable-idle-time-millis、max-evictable-idle-time-millis | 回收长期空闲连接,避免占用数据库会话 |
| 存活与检测 | max-lifetime、keepalive-time、validation-timeout | phy-timeout-millis、keep-alive、validation-query、test-while-idle、test-on-borrow | 控制连接存活时长并剔除失效连接 |
几组参数之间存在强制关系:
max-lifetime必须小于数据库侧的wait_timeout(MySQL 默认 28800 秒)。否则连接可能已被服务端单方面关闭,而池仍认为其可用,借用后报出通信链路异常。keepalive-time用于在空闲期发送探测,配合前一项共同避免该问题。minimum-idle与maximum-pool-size相等时,池规模恒定;不等时池会在流量低谷回收连接、高峰再建连,适合波动明显的负载。validation-query在支持 JDBC 4 的驱动上可省略(驱动提供isValid实现),配置了反而增加一次往返。connection-timeout是"快速失败"的开关。设置为数秒可以在过载时尽早暴露问题,而不是让请求线程长时间挂起。
2.2.3 池大小与数据库承载能力的关系
池大小不是越大越好。每个连接在数据库侧对应一个线程与会话状态,连接数增加会带来上下文切换、内存占用与锁竞争的上升。
容量约束是一个全局等式:
所有应用实例的池上限之和 + 其他连接来源 + 管理预留 ≤ 数据库 max_connections
示例:
应用实例数 8 × 单实例 max-pool-size 20 = 160
后台任务与运维连接预留 20
数据库 max_connections 500
→ 余量 320,可满足扩容或临时排查需要
若实例数扩到 30:8 → 30 时,30 × 20 = 600 > 500
→ 新实例会因无法建立连接而启动失败或在运行中报错
这个等式说明:横向扩容应用实例数与单实例池上限是耦合的,扩容前必须重新核算数据库侧的连接上限。经验公式 连接数 ≈ CPU 核数 × 2 + 磁盘数 只适用于单实例且以计算为主的场景,实际取值应以压测中"吞吐不再随连接数增长"的拐点为依据。
- 高危:调大
maximum-pool-size(或max-active)会同步抬高数据库侧的并发会话数,可能触达max_connections上限,并因锁竞争与内存占用上升使整体吞吐反而下降;多实例部署时该影响会被实例数放大。执行前必须核算"实例数 × 池上限 + 预留 ≤ max_connections",确认数据库 CPU、内存与锁等待指标有余量,并在业务低峰期分批(按实例灰度)调整。回滚方式:将参数改回原值并重启或触发配置刷新,池会按新上限回收多余空闲连接;若已触达数据库上限,需先在数据库侧定位异常连接来源,必要时终止空闲会话释放连接。
2.2.4 连接泄漏的判定
泄漏的表现具有可识别的特征:
| 观察点 | 泄漏特征 | 说明 |
|---|---|---|
| 池内活跃连接数 | 长期等于或贴近池上限,且不随流量回落 | 连接被借出后未归还 |
| 空闲连接数 | 持续为 0 | 池内无可复用连接 |
| 获取连接等待 | 等待线程数增长,等待时间抬升,最终超时 | 请求线程排队 |
| 借出时长 | 单个连接的持有时间远超业务最长耗时 | 与泄漏直接相关 |
| 数据库侧会话 | Threads_connected 高但 Threads_running 低 | 连接被占用却不在执行 SQL |
定位手段有三种:开启池的泄漏检测阈值(HikariCP 的 leak-detection-threshold、Druid 的 remove-abandoned 与 remove-abandoned-timeout),超时后打印借用点堆栈;对应用进程做线程栈采样,查找阻塞在连接获取上的线程;在数据库侧用 SHOW PROCESSLIST 观察会话状态与执行时间。
2.3 MyBatis 的工作方式
MyBatis 定位为半自动映射框架:SQL 由人书写,参数绑定与结果映射由框架完成。
2.3.1 执行链路
SqlSessionFactoryBuilder → SqlSessionFactory → SqlSession
│
├── Configuration
│ ├── Environment(数据源 + 事务工厂)
│ ├── MapperRegistry(接口 → 代理工厂)
│ └── MappedStatement(id → SQL + 映射规则)
│
└── Executor → StatementHandler → ParameterHandler
→ ResultSetHandler
SqlSession 本身不是线程安全的,Spring 集成使用 SqlSessionTemplate 对其进行包装,把 SqlSession 与事务绑定:同一事务内共享同一个 SqlSession,事务结束时统一提交或回滚并关闭。
Mapper 接口没有实现类,调用时由 JDK 动态代理拦截,按"接口全限定名 + 方法名"定位到 MappedStatement,再交由 Executor 执行。接口方法的参数与返回值由映射规则解释,这也是 Mapper 方法重载不被支持的原因——方法名是唯一标识。
动态代理如何拦截接口调用,见 反射。
2.3.2 映射的两种载体
| 载体 | 适用 | 局限 |
|---|---|---|
注解(@Select、@Insert、@Results) | 简单语句、单个参数的短查询 | 动态 SQL 表达能力弱,字符串拼接可读性差 |
| XML 映射文件 | 动态 SQL、复杂关联映射、可复用 SQL 片段 | 与接口分离,需保证命名空间与 id 一致 |
参数侧的映射规则:
| 写法 | 机制 | 使用约束 |
|---|---|---|
#{prop} | 生成 ? 占位符并绑定值 | 默认写法,适用于所有参数位置 |
${prop} | 文本替换 | 仅用于表名、列名、排序字段等结构位置,需白名单校验 |
@Param | 为多参数命名,形成参数映射表 | 多参数方法必须使用,否则只能按 arg0/param1 引用 |
| 单参数对象 | 直接按属性名引用 | 无需 @Param |
结果侧的映射规则:
| 写法 | 机制 | 适用 |
|---|---|---|
resultType | 按列名与属性名自动映射,配合下划线转驼峰 | 列名与属性名规则一致 |
resultMap | 显式声明列与属性的对应,支持嵌套与鉴别器 | 列名与属性名差异大、存在关联对象 |
| 自动映射级别 | NONE / PARTIAL / FULL | 控制嵌套结果的自动映射范围 |
2.3.3 动态 SQL
动态 SQL 是 MyBatis 相对注解式与模板式方案的主要优势。标签在 SQL 文本层面组合,最终产出完整语句:
<select id="selectByCondition" resultMap="userResultMap">
SELECT id, user_name, status, create_time
FROM t_user
<where>
<if test="userName != null and userName != ''">
AND user_name LIKE CONCAT('%', #{userName}, '%')
</if>
<choose>
<when test="statusList != null and statusList.size() > 0">
AND status IN
<foreach collection="statusList" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</when>
<otherwise>
AND status <> 9
</otherwise>
</choose>
</where>
ORDER BY create_time DESC
</select>
需要留意的两点:一是 <if> 条件不成立时可能产出不完整的 SQL 片段,<where>、<set>、<trim> 标签负责裁剪多余的连接词;二是动态 SQL 会产出数量不定的语句形态,每一种形态在执行计划上都可能不同,慢 SQL 定位时需要按实际参数还原语句。
2.3.4 缓存的作用范围与失效
MyBatis 有两级缓存,作用范围差异很大:
| 层级 | 存储位置 | 作用范围 | 默认状态 | 共享范围 |
|---|---|---|---|---|
| 一级缓存 | SqlSession 内的 PerpetualCache(HashMap) | 同一个 SqlSession,即同一事务 | 开启 | 单事务内 |
| 二级缓存 | namespace 对应的缓存对象(可插拔) | 同一 namespace,跨 SqlSession | 关闭,需显式声明 | 同一 JVM 内 |
失效规则:
- 一级缓存:任何
insert、update、delete都会清空当前SqlSession的一级缓存;local-cache-scope=statement可将作用域降为单条语句,等同于关闭。 - 二级缓存:同一 namespace 内发生写操作时清空该 namespace 的缓存;跨 namespace 的写操作不会清除其他 namespace 的缓存,这是关联查询下的经典不一致来源。
- 二级缓存的写入时机在事务提交之后(通过事务性缓存包装),避免回滚后缓存中留下未提交的数据。
- 二级缓存要求实体可序列化(
Serializable),使用集中式缓存(如 Redis)时序列化方式会影响兼容性。
序列化的机制与选型,见 序列化与反序列化。
多实例部署下,二级缓存位于各自 JVM 内,节点间的写操作无法互相失效,读到旧数据的窗口会一直存在。因此生产环境通常关闭 MyBatis 二级缓存,改用外部分布式缓存并自行管理失效。
- 高危:清空缓存(关闭二级缓存后调用清理、或在运行中批量清空 JPA 二级缓存/分布式缓存)会使后续请求全部回源到数据库,瞬时压力按缓存命中率成比例放大;在多实例场景中还会造成清空时刻不一致,出现部分请求读到新数据、部分读到旧数据的窗口。执行前需确认数据库侧的容量余量与限流降级策略就位,按 key 前缀或 namespace 分批清理,并在清理期间观察数据库 QPS 与连接池等待指标。回滚方式:缓存内容可由数据库重建,但重建期间的容量压力无法回退,只能通过限流与降级承接;若为误清,需按业务补偿流程重新预热热点数据。
2.3.5 插件与拦截器的作用面
MyBatis 允许通过 Interceptor 拦截四个接口的方法调用:
| 拦截目标 | 可干预的内容 | 典型用途 |
|---|---|---|
Executor | update、query、commit、rollback | 分页改写、SQL 审计、缓存扩展 |
StatementHandler | prepare、parameterize、query | 分页中的 count 语句派生、SQL 改写 |
ParameterHandler | setParameters | 参数加密、类型适配 |
ResultSetHandler | handleResultSets | 结果解密、字段脱敏 |
插件以责任链方式层层包装目标对象,只能包装不能替换,且多个插件的执行顺序由注册顺序决定。分页插件的工作原理正是在 Executor.query 处拦截,读取分页参数后改写 SQL 并追加一次 count 查询——这也意味着"分页"发生在框架层,SQL 是否能被正确改写取决于原语句的形态,复杂语句(多表、子查询、UNION)容易出现 count 结果失准或改写失败。
2.3.6 与手写 SQL 的契合度
MyBatis 不隐藏 SQL:执行日志中可以直接看到语句与参数,EXPLAIN 的对象就是源码中的语句,性能优化不需要穿透框架。代价是它不承担 SQL 质量的责任——索引是否被使用、是否存在全表扫描、是否存在隐式转换,全部由开发人员保证。SQL 治理的相关清单见 3.7 节。
2.4 JPA 与 Hibernate
JPA 是规范,Hibernate 是其主要实现。与 MyBatis 的根本差别在于:JPA 维护一份内存中的实体状态,并以这份状态为准生成 SQL。
2.4.1 实体与表映射
@Entity
@Table(name = "t_user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "user_name", nullable = false, length = 64)
private String userName;
@Enumerated(EnumType.STRING)
@Column(name = "status")
private UserStatus status;
@Column(name = "create_time", updatable = false)
private LocalDateTime createTime;
@Version
private Integer version;
}
映射的元信息覆盖主键生成策略、列名与类型、枚举存储方式、乐观锁版本字段。@GeneratedValue 的策略选择会影响插入行为:IDENTITY 依赖数据库自增,无法批量插入时合并语句;SEQUENCE 可在插入前获得主键,便于 JDBC 批量提交,但需要数据库支持序列。
2.4.2 持久化上下文与一级缓存
EntityManager 持有一个持久化上下文(PersistenceContext),其中的实体处于"托管"状态。它的直接后果有三点:
- 同一上下文内,按主键查询同一实体会返回同一个对象实例,第二次查询不会发出 SQL。
- 实体属性的修改会被记录,无需显式调用保存方法。
- 上下文的生命周期与事务(或
EntityManager)绑定,越界访问会抛异常。
一级缓存的范围是单个 EntityManager,在 Spring 中通常等价于单个事务。这意味着同一事务内的重复查询被合并,而不同事务之间不共享。
2.4.3 脏检查与延迟加载
脏检查(dirty checking):实体加载时会保存一份快照,flush 时将当前状态与快照逐字段比较,差异生成 UPDATE。flush 的触发时机包括事务提交前、执行 JPQL 查询前(取决于 FlushMode)、显式调用 flush()。
这里存在一个需要留意的行为:如果更新语句只修改了部分字段,刷新时生成的 UPDATE 可能包含全部字段(取决于实现与配置),因此"查询后修改一个字段"的写法可能覆盖其他字段的并发修改。批量更新语句(@Modifying 的 JPQL)绕过持久化上下文直接作用于数据库,会使上下文中的实体与数据库不一致,需要配合 clearAutomatically 清理。
延迟加载(lazy loading):关联对象在首次访问属性时才发出查询,实现方式是代理对象。
| 关联 | 默认抓取策略 |
|---|---|
@ManyToOne、@OneToOne | EAGER |
@OneToMany、@ManyToMany | LAZY |
延迟加载的两个失败模式:
- 在上下文关闭后访问代理属性,抛出
LazyInitializationException。典型场景是把实体直接返回给上层,序列化或视图渲染时上下文已关闭。 - 在循环中访问关联,触发 N+1 查询。查询 N 条主记录后,逐条访问关联对象或集合,产生 N 次额外查询。
N+1 的成因可以归纳为一句话:框架在编译期不知道后续会访问哪些关联,只能按需逐条加载。解法有三类:
| 手段 | 机制 | 代价 |
|---|---|---|
JOIN FETCH / @EntityGraph | 一条 SQL 连表取回关联数据 | 一对多连接会产生结果集膨胀,分页与连接同时使用时可能出错 |
批量抓取(default_batch_fetch_size) | 按主键集合批量加载,把 N 次查询压成 N/批次数 | 需要额外配置,仍非单条查询 |
| 二级缓存 | 关联数据从缓存命中 | 缓存一致性成本 |
2.4.4 JPQL 与原生 SQL
| 查询方式 | 面向对象 | 特点 |
|---|---|---|
| JPQL | 实体与属性名 | 与数据库解耦,由框架翻译为 SQL;不支持所有数据库特性 |
| Criteria API | 实体与属性名 | 类型安全,适合动态条件,可读性差 |
| 原生 SQL | 表与列名 | 能力等同手写 SQL,结果需手动映射,与实体上下文需自行同步 |
JPQL 的翻译结果不一定最优:JOIN 与子查询的写法差异、SELECT 投影的范围、ORDER BY 与分页的组合,都可能生成扫描行数偏大的语句。使用 JPA 时观察实际执行语句是必要的。
2.4.5 缓存层次
| 层次 | 范围 | 开关 | 说明 |
|---|---|---|---|
| 一级缓存 | EntityManager / 事务 | 无开关,始终存在 | 持久化上下文本身 |
| 二级缓存 | EntityManagerFactory / 应用级 | @Cacheable + 缓存提供者 | 跨事务共享,按实体粒度配置 |
| 查询缓存 | 应用级 | hibernate.cache.use_query_cache | 键为查询语句与参数及表的版本,依赖二级缓存;写操作会使受影响表的查询缓存失效 |
二级缓存与 MyBatis 二级缓存面临同样的问题:在多实例部署下是各自 JVM 内的缓存,节点间无法互相失效。JPA 二级缓存适合读多写少、且变更集中在单一节点的数据(如字典类数据),不适合频繁变更的业务数据。
2.5 两种路线的取舍
| 维度 | MyBatis | JPA / Hibernate |
|---|---|---|
| SQL 控制权 | 完全由开发人员掌握 | 框架生成,复杂场景回退到 JPQL 或原生 SQL |
| 简单 CRUD 成本 | 每条语句都需要书写与维护 | 通用方法直接可用,样板代码少 |
| 复杂查询与报表 | 直接书写 SQL,优化手段直观 | 需理解翻译规则,多表聚合与窗口函数支持有限 |
| 性能可预测性 | 高,执行语句与代码一致 | 依赖对脏检查、抓取策略、刷新的理解 |
| 学习成本 | 低(会 SQL 即可上手) | 高(持久化上下文、缓存、抓取策略为必学项) |
| 数据库可移植性 | 低,SQL 与方言绑定 | 较高,JPQL 屏蔽大部分方言差异 |
| 团队维护成本 | 映射与 SQL 集中,人员更替时依赖 SQL 规范 | 模型驱动,约定多,隐性行为需要文档沉淀 |
| 主要风险 | SQL 质量参差、映射文件重复 | N+1、意外全量更新、上下文与数据库不一致 |
选定路线的判断依据,是业务查询的形态分布:
- 以单表增删改查为主、领域模型相对稳定 → ORM 收益更大。
- 存在大量多表关联、聚合统计、批量处理 → SQL 优先更可控。
- 两种形态并存 → 混合使用,但需明确边界。
混合使用的边界建议:
- 同一实体只由一条路线写入。若 JPA 与 MyBatis 同时写同一张表,JPA 的持久化上下文与二级缓存无法感知 MyBatis 的写入,会出现"查到的还是旧对象"的现象。
- 写入与读取按聚合根划分,不要按方法划分。例如写路径统一走 JPA,报表查询统一走 MyBatis 原生 SQL,且报表查询不参与实体上下文。
- 避免在同一事务内用两种方式操作同一行数据,这会使脏检查生成的
UPDATE覆盖手写 SQL 的结果。 - 混用时统一事务管理器,两条路线共用同一个
DataSource与连接,事务边界才能一致。
2.6 Spring 事务管理
2.6.1 事务管理器抽象
Spring 用 PlatformTransactionManager 统一了不同持久化技术的事务操作:
| 方法 | 职责 |
|---|---|
getTransaction(TransactionDefinition) | 按定义开启或加入事务,返回事务状态 |
commit(TransactionStatus) | 提交 |
rollback(TransactionStatus) | 回滚 |
常见实现与技术栈的对应关系:
| 底层技术 | 事务管理器 | 备注 |
|---|---|---|
| JDBC、MyBatis | DataSourceTransactionManager | 直接操作连接的自动提交与提交回滚 |
| JPA | JpaTransactionManager | 同时管理持久化上下文与连接事务 |
| Hibernate | HibernateTransactionManager | 直接使用原生 SessionFactory 时 |
| 多数据源 / JTA | JtaTransactionManager | 配合 XA 资源管理器实现分布式事务 |
事务管理器与数据源绑定。存在多个数据源时,每个数据源对应一个事务管理器,@Transactional 需通过 transactionManager 属性指定,未指定时使用默认(通常是主数据源)——这一点是"多数据源下事务未生效"的常见原因。
2.6.2 声明式与编程式
| 方式 | 形态 | 适用 |
|---|---|---|
| 声明式 | @Transactional 注解,或 XML 配置 | 主流方式,事务边界与业务方法对齐 |
编程式(TransactionTemplate) | 在代码块中显式执行,回调式 API | 需要动态分片提交、需要按条件决定是否回滚 |
// 编程式:以编程方式控制边界,适合循环分批提交
transactionTemplate.execute(status -> {
for (Batch batch : batches) {
mapper.insertBatch(batch);
}
return null;
});
两种方式的底层机制相同,都是通过事务管理器开启事务并把连接绑定到线程。声明式的优势是边界清晰、不易遗漏提交;编程式的优势是可以在同一个方法内表达多段独立事务。
2.6.3 传播行为
传播行为定义了"事务方法被另一个事务方法调用时,事务边界如何组合"。七种取值与对应场景:
| 传播行为 | 行为 | 真实场景 |
|---|---|---|
REQUIRED(默认) | 有事务则加入,无则新建 | 绝大多数业务方法 |
REQUIRES_NEW | 始终新建独立事务,外层事务挂起 | 审计日志、操作流水等"即使主流程失败也必须留存"的记录 |
SUPPORTS | 有事务则加入,无则以非事务方式执行 | 查询类方法,可被事务内或事务外调用 |
NOT_SUPPORTED | 以非事务方式执行,挂起外层事务 | 事务内需要执行不支持事务的操作(如某些 DDL、跨库写入) |
MANDATORY | 必须已存在事务,否则抛异常 | 强制要求被事务包裹的内部方法,防止误调用 |
NEVER | 必须无事务,否则抛异常 | 明确禁止事务包裹的操作 |
NESTED | 存在外层事务时开启保存点,无外层时等同 REQUIRED | 子操作失败仅回滚子操作(需驱动支持 Savepoint) |
REQUIRED 与 NESTED 的差别在于回滚范围:REQUIRED 下内层抛出异常标记整个事务回滚,外层捕获异常也无法挽救已标记回滚的事务;NESTED 下内层回滚只回退到保存点,外层可继续。REQUIRES_NEW 与 NESTED 的差别在于是否新开连接:前者需要额外占用一条连接,后者复用外层连接。
- 高危:把
REQUIRED改为REQUIRES_NEW会为内层方法额外占用一条独立连接,并挂起外层事务。在嵌套层级较深或并发较高的场景下,连接占用按(外层 1 + 内层 1)× 并发数增长,可能耗尽池容量并形成互相等待(外层持连接等内层、内层等不到空闲连接);若内层操作的数据库改动能被外层回滚后的补偿逻辑重复执行,还会产生数据重复。变更前需核算池上限是否容纳"嵌套层数 × 并发"的连接需求,确认内层操作与外层数据不存在依赖顺序,并先在低峰期单实例灰度。回滚方式:将传播行为改回REQUIRED并发布重启;已产生的重复数据需按内层操作的幂等键比对后清理,清理前先冻结相关的重试与补偿任务。
2.6.4 隔离级别与只读事务
@Transactional(isolation = ...) 支持 DEFAULT、READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ、SERIALIZABLE。DEFAULT 表示沿用数据库默认值(MySQL 的 InnoDB 默认为 REPEATABLE_READ)。隔离级别的语义与现象对照见 mysql: 事务与锁,这里只说明 Java 侧的约束:
- 隔离级别的实际效果由数据库实现,框架仅是传递设置。
- 事务已开启后再修改隔离级别不会生效。
- 提高隔离级别会加重锁竞争,降低会削弱一致性保护,取舍应在数据库侧评估。
readOnly = true 的语义分两层:框架层会把连接标记为只读,并提示 ORM 跳过脏检查(Hibernate 会设置 FlushMode.MANUAL);数据库层是否利用该标记做优化,取决于数据库实现,MySQL 的收益有限。因此只读事务的主要价值是语义声明与框架层优化,而不是性能开关。
2.6.5 回滚规则
默认回滚条件:方法抛出 RuntimeException 或 Error 时回滚;受检异常(非 RuntimeException 的 Exception 子类)不回滚。这一规则源于早期 EJB 的约定,与直觉不符,是"事务没有回滚"问题的常见来源。
| 场景 | 是否回滚 | 说明 |
|---|---|---|
抛出 RuntimeException | 是 | 默认行为 |
| 抛出受检异常 | 否 | 需 rollbackFor = Exception.class 显式扩大 |
方法内 try-catch 吞掉异常 | 否 | 异常未传播到代理,框架判定为正常返回 |
手动 status.setRollbackOnly() | 是 | 编程式指定回滚 |
| 提交阶段抛异常(如约束冲突) | 是 | 提交失败会抛出,事务已无法提交 |
实践上有两条对应措施:一是统一使用运行时异常承载业务错误(例如自定义 BusinessException extends RuntimeException);二是对确实需要传播受检异常的方法显式声明 rollbackFor。而对于吞异常导致不回滚的情况,正确做法是在捕获后重新抛出,或调用 setRollbackOnly,而不是依赖框架猜测意图。
回滚行为在测试中同样受边界约束:测试事务只覆盖同一线程、同一连接内由容器管理的操作,异步线程与外部副作用不受其回滚保护,见 Java 测试体系 的事务回滚与数据隔离一节。
2.6.6 自调用失效
@Transactional 通过代理实现,代理只拦截外部对目标对象的调用。若类内方法 A 直接调用 this.methodB(),调用会绕过代理,methodB 上的事务注解不生效。同一原因也会导致 @Async、@Cacheable 等基于代理的注解在自调用时失效。
| 处理方式 | 做法 | 说明 |
|---|---|---|
| 自注入 | 把自身 Bean 注入本类,通过注入的引用调用 | 简单直接,需注意循环依赖 |
AopContext.currentProxy() | 取出当前代理对象再调用 | 需开启 exposeProxy |
| 拆分 Bean | 把需要独立事务的方法移到另一个 Bean | 最清晰,推荐用于事务语义不同的方法 |
| 编程式事务 | 在方法内部使用 TransactionTemplate | 不依赖代理,边界明确 |
此外,@Transactional 只在 public 方法上生效;final、static、private 方法无法被代理,注解会被忽略且不报错。
动态代理的两种实现与内部调用失效的机制,见 Spring Framework 核心体系 中"动态代理与内部调用失效"一节。
2.7 事务与连接的绑定关系
2.7.1 同一事务内连接复用
Spring 把当前事务使用的资源保存在 TransactionSynchronizationManager 中,底层是 ThreadLocal。事务开启时,DataSourceTransactionManager 从数据源取出连接、关闭自动提交,并以 ConnectionHolder 的形式绑定到当前线程;此后同一线程内的所有数据库操作都通过 DataSourceUtils.getConnection() 取到这个已绑定的连接,而不是从池中重新借出。
这一机制带来三个可观察的结论:
- 同一事务内的多个 Mapper 调用共用一条连接,不会各自占用池内连接。
- 同一事务内的多个 DAO 调用看到的是同一份未提交数据,不存在跨连接的一致性问题。
- 事务的嵌套深度不等于连接数的增长——只有
REQUIRES_NEW、NOT_SUPPORTED等会挂起外层事务的传播行为才需要额外连接。
事务结束时,连接被提交或回滚,随后解绑并归还池。若事务过程中线程被中断或异常处理不当,连接未能解绑,就会出现连接泄漏。
2.7.2 多数据源下的事务边界
每个数据源有独立的事务管理器与独立的连接绑定,一个事务只能绑定一个数据源。由此产生两条结论:
- 同一方法内对两个数据源的写操作不在同一事务中,其中一个失败时另一个不会自动回滚。
- 跨数据源的原子性需要 XA/JTA 或最终一致性方案,而 XA 的代价(两阶段提交、协调者、性能损耗)需要评估。
跨库一致性的处理方式(本地消息表、事务消息、补偿)属于分布式事务范畴,通常由消息中间件方案承担。
消息侧的事务消息与最终一致性实现,见 消息一致性:事务消息与最终一致性。
2.7.3 事务与异步、新线程的交互
事务上下文依赖 ThreadLocal,不随线程切换传播,因此:
| 场景 | 结果 |
|---|---|
事务方法内调用 @Async 方法 | 异步方法在另一个线程执行,不加入外层事务;新线程内若有 @Transactional,会开启独立事务 |
| 异步方法抛异常导致事务回滚 | 不回滚外层事务,外层无法感知(除非通过 Future 获取结果或监听回调) |
| 异步方法需要读取外层未提交数据 | 读不到,因为不同连接、不同事务 |
| 新线程申请连接 | 从池中额外借出;若外层事务已占用大量连接且池已满,异步任务会阻塞在获取连接上,形成"外层等异步结果、异步等空闲连接"的互相等待 |
由此得到两条实践要求:一是事务内不做异步派发,需要异步执行的操作应在事务提交后触发(借助事务同步回调,在提交完成后执行);二是异步任务与事务方法共用连接池时必须评估容量,池上限至少要覆盖"事务并发数 + 异步任务并发数"。
另外,使用线程池时线程是复用的,若业务代码自行维护了 ThreadLocal 变量而在任务结束时未清理,下一个任务可能读到上一个任务的数据。事务相关的 ThreadLocal 由框架在事务结束时清理,业务自定义的则需自行在 finally 中移除。
线程与
ThreadLocal的内存模型与可见性问题,见 Java 并发编程。
三、实现
3.1 配置与实践
3.1.1 数据源与连接池配置
以 Spring Boot 的 application.yml 为例,HikariCP 的典型配置形态:
spring:
datasource:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/app?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true&allowMultiQueries=false
username: app
password: ${DB_PASSWORD}
hikari:
pool-name: app-pool
# 容量:下限与上限
minimum-idle: 8
maximum-pool-size: 16
# 获取等待:3 秒快速失败,避免请求线程长时间挂起
connection-timeout: 3000
# 空闲回收:10 分钟未使用的连接释放
idle-timeout: 600000
# 存活时间必须小于数据库 wait_timeout
max-lifetime: 1700000
# 空闲期探测,避免使用已被服务端关闭的连接
keepalive-time: 300000
# 泄漏检测,超过阈值打印借用点堆栈
leak-detection-threshold: 60000
jackson:
date-format: yyyy-MM-dd HH:mm:ss
time-zone: Asia/Shanghai
mybatis:
mapper-locations: classpath*:mapper/**/*.xml
type-aliases-package: com.example.app.model.entity
configuration:
map-underscore-to-camel-case: true
# 关闭单条语句以上范围的一级缓存,避免长事务内的陈旧视图
local-cache-scope: statement
default-statement-timeout: 5
配置项与数据库侧的对应关系需要在部署时核对:
| 应用侧 | 数据库侧 | 关系 |
|---|---|---|
maximum-pool-size × 实例数 | max_connections | 前者之和须留有余量 |
max-lifetime | wait_timeout | 前者须小于后者 |
connection-timeout | 连接建立与认证耗时 | 前者须大于正常建连耗时 |
default-statement-timeout | max_execution_time | 二者共同约束单条语句时长 |
Spring Boot 的自动装配会从 spring.datasource.* 推导数据源与事务管理器,引入 MyBatis 或 JPA 的 Starter 后还会自动配置对应的 SqlSessionFactory 与 EntityManagerFactory。自定义数据源、多数据源与事务管理器的配置方式,见 Spring Boot 企业级项目实践指导手册;配置文件的分层与多环境组织方式,见 Spring Boot application.yml 核心配置。
3.1.2 日志与慢 SQL 打印
| 手段 | 输出内容 | 适用阶段 |
|---|---|---|
MyBatis 日志(logging.level.<mapper 包>=DEBUG) | 语句、参数、返回行数 | 开发与联调 |
| 池的监控日志 | 池大小、活跃、等待 | 运行期抽样 |
| 代理式 SQL 日志(p6spy 等) | 完整语句与耗时,含框架生成语句 | 定位 ORM 生成的语句 |
| 数据库慢查询日志 | 超过阈值的语句与扫描行数 | 生产常态 |
logging:
level:
com.example.app.mapper: debug
需要留意的是,打开调试级 SQL 日志会带来显著的日志量与性能开销,生产环境应通过动态日志级别按需短时开启,而不是常驻。数据库侧的慢查询日志与 performance_schema 是更合适的常态手段,相关指标与采集位置见 mysql: 性能诊断与调优。
3.1.3 批处理
批处理的性能取决于两个条件:语句是否合并、提交是否分批。
// JDBC 批量:配合 rewriteBatchedStatements=true,驱动会合并为多值语句
jdbcTemplate.batchUpdate(
"INSERT INTO t_order (id, user_id, amount) VALUES (?, ?, ?)",
orders,
500, // 批次大小
(ps, order) -> {
ps.setLong(1, order.getId());
ps.setLong(2, order.getUserId());
ps.setBigDecimal(3, order.getAmount());
});
MyBatis 的批处理通过 ExecutorType.BATCH 实现,需要独立的 SqlSessionTemplate:
@Bean
public SqlSessionTemplate batchSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
return new SqlSessionTemplate(sqlSessionFactory, ExecutorType.BATCH);
}
// 使用批量模板时,每条执行的返回值不代表实际影响行数
// 影响行数需要执行完成后调用 flushStatements 获取
批处理需要注意三点:批量大小以几百行为宜,过大会造成单次网络包过大与数据库侧的长事务;批处理必须在事务内提交才具备原子性,但事务过大又会带来锁与复制延迟问题(见 3.4 节);ExecutorType.BATCH 与一级缓存、结果映射的组合存在行为差异,返回自增主键的语句需谨慎使用。
3.1.4 流式查询
将大结果集一次性载入内存会引发堆内存压力,流式查询以游标方式逐条处理:
// MyBatis Cursor:整条链路保持在同一事务内
try (Cursor<Order> cursor = orderMapper.selectCursorByStatus(Status.PENDING)) {
for (Order order : cursor) {
// 逐条处理,避免全量装入内存
}
}
// JDBC 层:MySQL 需要将 fetchSize 设为 Integer.MIN_VALUE 才启用流式
PreparedStatement ps = conn.prepareStatement(sql);
ps.setFetchSize(Integer.MIN_VALUE);
流式查询的约束是整个读取过程必须保持连接与事务开启,这意味着连接被长时间占用。在大批量导出场景中,这种占用会与在线流量争抢连接池容量,通常需要为导出单独准备数据源或限制并发数。
3.2 映射与模型
3.2.1 实体与 DTO 的边界
| 类型 | 职责 | 是否持久化 | 典型位置 |
|---|---|---|---|
| Entity / PO | 与表结构一一对应 | 是 | 数据访问层 |
| DTO | 层间传输入参 | 否 | 服务层入参 |
| VO | 面向接口的输出视图 | 否 | 服务层出参 |
| Query 对象 | 承载查询条件 | 否 | 数据访问层入参 |
Entity 不应直接穿透到控制层:一是会把表结构暴露为接口契约,二是 JPA 实体携带持久化上下文语义,序列化时可能触发延迟加载(并抛出 LazyInitializationException),三是字段的增删会直接影响接口兼容性。转换动作放在服务层完成,具体分层约定见 Spring Boot 企业级项目实践指导手册。
3.2.2 字段类型与数据库类型的对应
| 数据库类型 | Java 类型 | 注意点 |
|---|---|---|
BIGINT | Long | 超过 2^53 时若经 JavaScript 处理会丢精度,对外可序列化为字符串 |
INT | Integer | 避免用 int 承载可空列 |
DECIMAL(p, s) | BigDecimal | 金额必须使用 BigDecimal,不可用 double;比较用 compareTo,运算需指定精度与舍入方式 |
VARCHAR / TEXT | String | 注意字符集与最大长度;超长文本单独考虑 |
DATETIME / TIMESTAMP | LocalDateTime | JDBC 4.2 起直接支持;TIMESTAMP 参与时区转换,DATETIME 不参与 |
DATE | LocalDate | 与 java.util.Date 的转换需显式声明时区 |
TIME | LocalTime | — |
TINYINT(1) | Boolean | MySQL 无原生布尔类型,TINYINT 的取值超出 0/1 时映射会报错 |
BIT(1) | Boolean | 驱动版本不同时映射行为有差异 |
JSON | String 或自定义 TypeHandler | 需要额外的类型处理器,查询条件中的 JSON 函数会影响索引使用 |
时间类型的三个实践约定:
- 统一使用
LocalDateTime系列(java.time),避免混用java.util.Date与Timestamp。 - 存储层统一时区:使用
DATETIME存储固定时区(如东八区)或不带时区的 UTC,并在 JDBC 连接参数中固定serverTimezone;TIMESTAMP会随服务器时区变化转换,跨时区部署时容易产生偏移。 - 精度与长度对齐:
BigDecimal的 scale 与列的 scale 一致,避免写入时被数据库静默截断。
Java 侧数值类型的取值范围与精度特性,见 java 完整手册。
3.2.3 逻辑删除与时间戳字段
逻辑删除通过标记字段代替物理删除:
-- 逻辑删除字段与唯一索引的组合
ALTER TABLE t_user ADD COLUMN deleted TINYINT NOT NULL DEFAULT 0 COMMENT '逻辑删除标记';
-- 唯一索引需包含删除标记或使用删除时间戳,避免删除后无法重建同名记录
CREATE UNIQUE INDEX uk_user_name ON t_user (user_name, deleted);
逻辑删除的三个连带影响:所有查询都必须带上 deleted = 0 条件,遗漏即产生"已删除数据仍被查出"的问题(框架的自动填充能力可以减少遗漏);唯一索引需要重新设计,否则历史数据的约束会阻止新数据写入;数据量会持续增长,需要考虑归档策略。
MyBatis-Plus 通过 @TableLogic 与全局配置把删除转为 UPDATE、把查询追加条件,减少了人工维护;使用该能力时需确认所有原生 SQL 也已带上条件。
时间戳字段的填充有三种方式:
| 方式 | 实现 | 适用 |
|---|---|---|
| 数据库默认值 | DEFAULT CURRENT_TIMESTAMP、ON UPDATE CURRENT_TIMESTAMP | 简单可靠,不受应用时区影响,效率最高 |
| 应用层填充 | MyBatis 拦截器、MetaObjectHandler、JPA 的 @PrePersist / 审计注解 | 需要记录操作人等其他审计信息时 |
| 数据库触发器 | 由触发器写入 | 一般不推荐,逻辑分散不易排查 |
同一条记录上不应同时使用数据库默认值与应用层填充,否则两者的时区或精度差异会造成写入值不一致。
乐观锁通过版本号字段实现:读取时取出 version,更新时以 WHERE version = #{version} 作为条件并自增版本,影响行数为 0 表示并发冲突,由业务决定重试或报错。乐观锁适合冲突概率低的场景,冲突概率高时会带来大量无效重试。
3.3 事务边界规范
3.3.1 事务只包裹数据库操作
事务持有连接与锁,其持续时间应等于数据库操作所需时间。以下操作不应放在事务内:
| 不应在事务内的操作 | 原因 |
|---|---|
| 远程调用(HTTP、RPC) | 耗时不可控,网络抖动会拉长事务,连接与锁被长期持有 |
| 消息发送 | 发送耗时与事务无关,且发送成功但事务回滚会造成数据不一致(应改为事务提交后发送) |
| 文件读写、大对象序列化 | 纯 CPU 或 IO 操作,与数据库无关 |
| 循环内的单条数据库操作 | 把 N 次操作拉进一个事务,事务规模与耗时随数据量增长 |
| 等待用户输入或外部回调 | 事务将被长时间挂起 |
正确的形态是"事务只包含数据库读写,外部交互在事务边界之外完成",并通过事务同步回调(提交后执行)来保证操作的先后顺序。
3.3.2 只读事务的声明
查询方法应声明 @Transactional(readOnly = true):框架层会跳过脏检查、把连接标记为只读,减少不必要的 flush 与状态维护。这对使用 JPA 的应用收益更明显。只读事务同样会占用连接,因此不必为每个查询都声明——单条查询本身已在数据库侧隐式事务内完成。
3.3.3 嵌套调用的传播行为选择
| 内层方法的语义 | 建议传播行为 |
|---|---|
| 与主流程同生共死 | REQUIRED(默认,无需声明) |
| 必须独立留存(日志、流水) | REQUIRES_NEW,并核算连接容量 |
| 失败可容忍、不影响主流程 | REQUIRES_NEW + 捕获异常,或在主流程外异步执行 |
| 只读查询 | SUPPORTS 或 readOnly = true |
| 明确不允许事务包裹 | NEVER |
REQUIRES_NEW 的使用需要额外核算连接占用(原因见 2.7.3 节),其变更的影响与回滚方式见 2.6.3 节的高危提示。
3.3.4 失败重试与幂等的配合
重试必须在事务之外进行,且被重试的操作必须幂等:
- 重试位置:在事务方法外层重试。若在事务内重试,失败的语句会标记事务回滚,后续重试都在同一个已标记回滚的事务中执行,无法提交。
- 重试触发条件:只对可恢复异常重试(连接超时、死锁回滚、乐观锁冲突),不对业务校验失败重试。
- 幂等保证:以业务唯一键或去重表约束重复执行。乐观锁的失败重试天然幂等(以版本条件更新);插入类操作依赖唯一索引保证幂等。
- 退避策略:重试需带退避与次数上限,且要区分死锁重试(可立即重试)与资源不足重试(需等待)。
幂等的实现手段(去重表、状态机、唯一约束)与重试策略设计,见 消息可靠性与幂等设计。
3.3.5 事务粒度的量化约束
事务边界免于主观判断需要有量化口径:
| 指标 | 建议口径 | 依据 |
|---|---|---|
| 单事务执行时长 | 控制在数十毫秒级,不超过语句超时时间 | 事务时长等于持锁时长 |
| 单事务涉及行数 | 批次以数百至数千行为界 | 批量操作的复制与锁开销 |
| 单事务内数据库交互次数 | 避免与数据量成正比的循环调用 | 减少往返 |
| 事务超时 | 显式设置 timeout 或语句超时 | 兜底,避免事务无限挂起 |
超时设置的实现方式取决于底层:JDBC 层的 setQueryTimeout 会在语句级别生效,@Transactional(timeout) 则由事务管理器尽力传递,MySQL 驱动对后者的支持有限,必要时在数据库侧设置 max_execution_time。
3.4 分页与批量
3.4.1 物理分页与内存分页
| 方式 | 机制 | 代价 |
|---|---|---|
| 物理分页 | SQL 追加 LIMIT offset, size,只取需要的数据 | 需按数据库方言生成,深分页时扫描量大 |
| 内存分页 | 查询全部满足条件的数据后在内存中截取 | 数据传输与对象构造的成本随结果集线性增长,大表上直接导致内存溢出 |
分页插件的常见实现是"ORM 参数分页"风格(如 RowBounds、Page 对象),本身属于内存分页;真正的物理分页来自插件在 SQL 层改写,二者需要通过是否生成 LIMIT 来区分。判断依据很简单:打开 SQL 日志,确认最终语句是否带 LIMIT。
分页查询通常伴随一次 count。count 的两种取舍:
- 精确
count:语义准确,但在大表与复杂条件下本身就是一次高成本查询。 - 近似或省略:只判断是否存在下一页(多取一条)、缓存总数、使用统计信息估算,适合列表类交互。
3.4.2 深分页的代价与优化
-- 深分页:需要扫描并丢弃 offset 之前的行
SELECT id, user_id, amount FROM t_order ORDER BY id LIMIT 1000000, 20;
-- 延迟关联:先在覆盖索引上定位主键,再回表取数据
SELECT o.id, o.user_id, o.amount
FROM t_order o
JOIN (SELECT id FROM t_order ORDER BY id LIMIT 1000000, 20) t ON o.id = t.id;
-- 游标分页:记录上一页最后一个主键或排序键,避免 offset
SELECT id, user_id, amount FROM t_order WHERE id > 1000000 ORDER BY id LIMIT 20;
深分页的代价在于 offset 的语义是"扫描并丢弃",成本与 offset 成正比。优化方向按优先级排列:改为游标/键集分页(只适用于顺序翻页)、延迟关联(减少回表但是仍要扫描索引)、限制可翻页深度并引导用户收窄条件。索引与执行计划的判读方式见 mysql: 索引与执行计划。
3.4.3 批量插入与更新
<!-- MyBatis 多值插入:一条语句插入多行 -->
<insert id="insertBatch">
INSERT INTO t_order (id, user_id, amount, create_time) VALUES
<foreach collection="list" item="item" separator=",">
(#{item.id}, #{item.userId}, #{item.amount}, #{item.createTime})
</foreach>
</insert>
<!-- MyBatis 批量更新:必须以主键条件限定影响行数 -->
<update id="updateBatchStatus">
UPDATE t_order
SET status = #{status}
WHERE id IN
<foreach collection="ids" item="id" open="(" separator="," close=")">
#{id}
</foreach>
</update>
批量操作的三条约束:
- 批量大小:单批控制在数百至数千行,过大则单条语句的网络包、解析时间与锁持有时间都会上升。
- 事务划分:批量整体放在一个事务里能保证原子性,但事务过大会带来锁等待与复制延迟;需要在原子性与事务规模之间取舍,通常按业务可容忍的部分成功来划分批次。
- 主键回填:多值插入无法逐行返回自增主键,需要主键时改用逐条插入或提前生成分布式主键。
-
高危:批量更新/删除(无主键范围限制的
UPDATE、DELETE,或一次影响数十万行)会在数据库中持有大量行锁甚至升级为表级锁,阻塞其他会话的读写;生成的单个大事务在 binlog 中以整笔事务分发,从库单线程回放时会形成分钟级的复制延迟;同时 undo 与 redo 日志量激增,可能撑高磁盘与缓冲池压力。执行前必须先用相同的WHERE条件做SELECT COUNT(*)与EXPLAIN评估影响行数与执行计划,选择业务低峰期执行,按主键范围分批(每批数千行并间隔短暂停顿),并提前确认主从延迟的容忍度与回滚方案。回滚方式:数据层面的回滚依赖执行前的备份或反向UPDATE(需要先留存受影响主键列表与原值);若只需中止,可直接终止执行会话并回滚未提交部分,已提交批次按反向语句处理。
3.5 常见故障与排查
| 故障现象 | 可能根因 | 排查手段 | 处置 |
|---|---|---|---|
| 获取连接超时、接口大量报错 | 连接泄漏;慢 SQL 占满连接;池上限过小;事务内做远程调用;嵌套 REQUIRES_NEW 使连接占用倍增 | 池的活跃/等待指标、泄漏检测堆栈、SHOW PROCESSLIST 观察会话状态与执行时长 | 先止损(扩容池需先核算数据库上限,见 3.6 节),再定位占用来源 |
| 请求长时间无响应、锁等待超时 | 事务未提交或未及时提交,持锁时间过长;长事务中包含耗时操作 | 数据库侧的锁等待视图与事务列表;应用侧的事务耗时统计 | 定位长事务方法,缩短其范围;必要时终止异常会话 |
| 接口耗时随结果集大小线性上升 | N+1 查询(JPA 的循环关联访问,或手工循环内的单条查询) | SQL 执行次数与业务方法调用次数的比例;开启 SQL 日志统计条数 | 改为连表查询、批量查询或配置批量抓取 |
LazyInitializationException | 在持久化上下文关闭后访问延迟加载属性 | 异常堆栈中的属性访问位置;序列化过程 | 在事务内完成实体到 DTO 的转换 |
| 读到旧数据 | 二级缓存跨节点无法失效;JPA 持久化上下文与批量更新不一致;缓存与数据库双写顺序问题 | 对比缓存与数据库的值;确认缓存刷新链路 | 关闭本地二级缓存或改用集中式缓存;批量更新后清理上下文 |
| 写入量不大但从库延迟高 | 批量操作生成大事务;单次影响行数过多 | 主从复制状态与延迟指标、binlog 事务大小 | 拆分批次,控制单事务规模 |
| 运行期偶发通信链路异常 | 连接被服务端按 wait_timeout 关闭,而池仍认为可用 | 报错时间与空闲时长的对应关系;max-lifetime 与 keepalive-time 配置 | 调整存活时间与探测参数 |
| 导出或统计接口把内存打满 | 一次性查询全部数据、内存分页、结果集未流式处理 | 堆内存与 GC 曲线;查询返回行数 | 改流式查询或分批查询 |
事务未提交导致锁等待的更深层原因(长事务对 MVCC 版本链、undo 空间与主从延迟的影响)见 mysql: 事务与锁;批量操作引起复制延迟的成因与治理见 mysql: 主从部署与运维实践;缓存与数据库不一致的处理策略见 缓存基础与一致性。
数据库侧的会话与锁的观察命令(SHOW PROCESSLIST、SHOW ENGINE INNODB STATUS、慢查询日志的开启与读取)见 mysql: 使用命令。
3.6 连接与事务的监控
3.6.1 连接池指标
| 指标 | 含义 | 异常判据 |
|---|---|---|
| 活跃连接数(active) | 已借出的连接数 | 长期贴近池上限 |
| 空闲连接数(idle) | 池内可复用的连接数 | 长期为 0 而流量不高 |
| 池内连接总数(total) | 已建立的物理连接数 | 波动剧烈说明容量估算偏差大 |
| 获取连接等待数(pending / wait) | 排队等待连接的线程数 | 大于 0 即需关注,持续增长表示容量不足或有泄漏 |
| 获取连接等待时间 | 借出连接的平均/最大等待时长 | P99 抬升先于接口超时出现 |
| 连接持有时间 | 连接从借出到归还的时长 | 远超业务最长耗时,指向泄漏或长事务 |
HikariCP 通过 JMX 暴露各池的指标(默认注册为 HikariPool-<序号> 的 MXBean),Druid 提供 StatFilter 与内置监控页面。采集这几个指标的成本很低,却能在接口超时前给出预警。
3.6.2 应用侧 SQL 指标
| 指标 | 采集方式 | 用途 |
|---|---|---|
| SQL 执行次数 | MyBatis 拦截器统计、APM 探针 | 识别 N+1(单请求 SQL 条数异常) |
| SQL 耗时分布(P95/P99) | 同上 | 定位慢语句 |
| 慢 SQL 计数与语句指纹 | 应用侧统计或数据库慢查询日志 | 归纳问题语句 |
| 事务耗时与回滚次数 | 事务事件监听、AOP 统计 | 定位长事务与异常提交 |
应用侧的统计与数据库侧的慢查询日志需要对照使用:应用侧能看到"哪次请求、哪个方法"调用了慢 SQL,数据库侧能看到"语句的执行计划与扫描行数"。
慢 SQL 导致的连接占用与线程阻塞在应用侧的表现、证据判读顺序,见 Java 应用诊断与部署调优。
3.6.3 与数据库侧指标的对照
| 应用侧指标 | 数据库侧指标 | 对照结论 |
|---|---|---|
| 池活跃连接数 | Threads_running | 活跃连接高但 Threads_running 低,说明连接被持有却未执行 SQL,指向长事务或事务内的非数据库操作 |
| 池内连接总数 | Threads_connected | 总连接数逼近 max_connections 时,扩容应用前必须先核算上限 |
| 获取连接等待时间 | 连接建立耗时 | 等待时间上升而数据库负载正常,说明瓶颈在应用侧(泄漏、长事务) |
| 事务耗时 | 行锁等待时间 | 两者同步上升说明是锁竞争;仅事务耗时上升而锁等待平稳,说明事务内包含非数据库操作 |
| 慢 SQL 计数 | 慢查询日志条数、扫描行数 | 两侧统计口径不一致时,需检查采样范围与阈值设置 |
监控体系的指标类型、采集模型与告警规则构成,见 linux: 监控与告警;容量趋势判断与容量规划方法同见该文第五节。
3.6.4 建议的告警规则
| 告警项 | 触发条件 | 级别 |
|---|---|---|
| 连接池等待超时 | 单位时间内超时次数 > 0 | 高 |
| 连接池使用率 | 活跃连接数 / 池上限 > 80% 持续若干分钟 | 高 |
| 连接池等待时长 | P99 等待时间超过阈值 | 中 |
| 慢 SQL 数量 | 慢查询条数较基线突增 | 中 |
| 事务耗时 | P99 超过阈值 | 中 |
| 主从延迟 | 延迟超过业务容忍度 | 中 |
3.7 SQL 治理
3.7.1 评审清单
上线前的 SQL 评审可按以下条目逐项确认:
语句层面
[ ] WHERE、ORDER BY、GROUP BY 涉及的条件列上有可用的索引
[ ] 未在索引列上使用函数或发生隐式类型转换(数字与字符串比较、字符集不一致)
[ ] 未使用 SELECT *,只取需要的列(覆盖索引可避免回表)
[ ] LIKE 的前缀不是通配符开头,或已确认无法使用索引且数据量可控
[ ] OR、NOT IN、!= 等条件已评估索引失效风险
[ ] 分页语句未出现大 offset,或已确认可接受
[ ] count 语句的代价已评估,是否可省略或近似
映射与参数
[ ] 参数使用占位符绑定,未使用文本替换(除非结构位置且已白名单校验)
[ ] 动态 SQL 的每种分支形态都能产出合法语句
[ ] 返回结果集的规模有上限约束
事务与并发
[ ] 事务范围只包含数据库操作,未包含远程调用与消息发送
[ ] 批量操作的批次大小与事务规模已评估
[ ] 事务超时与语句超时已设置
[ ] 并发更新同一行的场景已使用乐观锁或条件更新
上线与容量
[ ] 变更涉及的新索引已评估对写入的影响,大表加索引使用在线 DDL
[ ] 预计 QPS 与单次执行耗时相乘后的并发度,未超过连接池上限与数据库承载能力
[ ] 已准备回滚方案(语句级、配置级、数据级)
[ ] 上线后观测窗口与观测指标已明确
3.7.2 索引与执行计划的核对
执行计划是 SQL 质量的直接证据。核对时关注以下字段:
| 字段 | 关注点 |
|---|---|
type | 出现 ALL(全表扫描)、index(全索引扫描)需确认数据量与必要性 |
key | 实际使用的索引,为 NULL 说明未命中 |
rows | 预估扫描行数,与实际返回行数差异过大说明统计信息或条件选取性差 |
filtered | 过滤比例,过低说明条件对索引不友好 |
Extra | Using filesort、Using temporary 表示排序或临时表落盘;Using index 表示覆盖索引 |
执行计划的判读方法与索引设计规范见 mysql: 索引与执行计划。
3.7.3 上线前的容量与并发评估
容量评估把业务指标换算为数据库侧的并发压力:
并发度估算
单实例目标 QPS × 单次 SQL 平均耗时(秒) = 平均并发 SQL 数
叠加 P99 耗时与流量峰值系数 → 峰值并发 SQL 数
峰值并发 SQL 数 ≤ 连接池上限 × 实例数 且 ≤ 数据库可承载并发
示例
QPS 200 × 平均耗时 5 ms = 1(平均并发)
按 P99 50 ms 与峰值系数 3 → 峰值约 18
→ 单实例池上限 16 偏紧,需结合实例数与数据库侧余量调整
估算结果的用途有三:确定池大小下界、判断是否需要读写分离或缓存、识别必须优化的高耗时语句。压测方法与基线的建立方式见 linux: 压测与性能基线。
隔离级别、锁竞争与数据库侧并发承载能力的关系,属于数据库层的评估范围,见 mysql: 事务与锁。
四、总结
Java 持久层处理的是应用对象与关系数据之间的四重落差:通信协议需要驱动屏蔽,连接建立需要池化摊销,结果集需要映射转换,事务边界需要框架贯穿多个方法调用。
围绕这四重落差形成了两类技术路线。MyBatis 保留 SQL 的书写权,把参数绑定与结果映射交给框架,优势是执行语句与源码一致、优化路径直观,代价是简单操作的重复劳动与对开发人员 SQL 能力的依赖。JPA 与 Hibernate 以对象模型为中心,简单操作零 SQL、模型驱动清晰,代价是引入了持久化上下文这一额外状态——一级缓存、脏检查、延迟加载、N+1 都由它派生,理解成本相应更高。两条路线可以并存,但边界必须按聚合根的写入路径划分,避免同一份数据被两个视角同时管理。
事务是持久层最容易出问题也最容易被低估的部分。Spring 通过 PlatformTransactionManager 与线程绑定的 ConnectionHolder 把事务边界从 DAO 提升到 Service,使一个业务方法对应一个事务、多条语句共用一条连接。这套机制的失效方式也很集中:受检异常默认不回滚、内部调用绕过代理、新线程不继承事务上下文、多数据源无法共享事务、REQUIRES_NEW 会额外占用连接。它们共同说明一件事:事务是绑定在连接与线程上的资源,脱离这两个载体讨论传播行为没有意义。
落到工程实践,持久层的可靠性主要由几条边界守住:事务只包裹数据库操作;连接池上限与数据库承载能力对齐且随实例数重新核算;批量操作控制批次与事务规模;分页避免大偏移;SQL 上线前经过索引与执行计划的核对;连接池的活跃、等待、持有时间与数据库侧指标对照观测。这些边界的共同点是把不可见的资源占用变为可观测、可核算的量,而不是等到接口超时后再回溯原因。