一、起源: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 &lt;&gt; 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),其中的实体处于"托管"状态。它的直接后果有三点:

  1. 同一上下文内,按主键查询同一实体会返回同一个对象实例,第二次查询不会发出 SQL。
  2. 实体属性的修改会被记录,无需显式调用保存方法。
  3. 上下文的生命周期与事务(或 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 优先更可控。
  • 两种形态并存 → 混合使用,但需明确边界。

混合使用的边界建议:

  1. 同一实体只由一条路线写入。若 JPA 与 MyBatis 同时写同一张表,JPA 的持久化上下文与二级缓存无法感知 MyBatis 的写入,会出现"查到的还是旧对象"的现象。
  2. 写入与读取按聚合根划分,不要按方法划分。例如写路径统一走 JPA,报表查询统一走 MyBatis 原生 SQL,且报表查询不参与实体上下文。
  3. 避免在同一事务内用两种方式操作同一行数据,这会使脏检查生成的 UPDATE 覆盖手写 SQL 的结果。
  4. 混用时统一事务管理器,两条路线共用同一个 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() 取到这个已绑定的连接,而不是从池中重新借出。

这一机制带来三个可观察的结论:

  1. 同一事务内的多个 Mapper 调用共用一条连接,不会各自占用池内连接。
  2. 同一事务内的多个 DAO 调用看到的是同一份未提交数据,不存在跨连接的一致性问题。
  3. 事务的嵌套深度不等于连接数的增长——只有 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 函数会影响索引使用

时间类型的三个实践约定:

  1. 统一使用 LocalDateTime 系列(java.time),避免混用 java.util.Date 与 Timestamp。
  2. 存储层统一时区:使用 DATETIME 存储固定时区(如东八区)或不带时区的 UTC,并在 JDBC 连接参数中固定 serverTimezone;TIMESTAMP 会随服务器时区变化转换,跨时区部署时容易产生偏移。
  3. 精度与长度对齐: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 失败重试与幂等的配合

重试必须在事务之外进行,且被重试的操作必须幂等:

  1. 重试位置:在事务方法外层重试。若在事务内重试,失败的语句会标记事务回滚,后续重试都在同一个已标记回滚的事务中执行,无法提交。
  2. 重试触发条件:只对可恢复异常重试(连接超时、死锁回滚、乐观锁冲突),不对业务校验失败重试。
  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 上线前经过索引与执行计划的核对;连接池的活跃、等待、持有时间与数据库侧指标对照观测。这些边界的共同点是把不可见的资源占用变为可观测、可核算的量,而不是等到接口超时后再回溯原因。