跳到主要内容
约 12 分钟5 张卡

JPA

JPA(Java Persistence API,现名 Jakarta Persistence)是 Java 的对象持久化规范,规定实体怎样映射到数据库表、怎样参与读写。它的核心是持久化上下文:一块记录着「哪些对象正被跟踪、它们的字段有没有变化」的工作区。

用 JPA 时遇到的不少「奇怪现象」都能用持久化上下文解释:为什么只调用 setter 就更新了数据库,为什么换个请求再改对象就不生效了,为什么访问关联时抛出 LazyInitializationException。所以先弄清对象处于什么状态、被哪个上下文管着、什么时候同步到数据库,脏检查、懒加载和乐观锁就能顺着推出来。

本文面向 Spring Boot 2.7 与 3.x,分别对应常用的 Hibernate 5.6 与 6.x,规范术语以 Jakarta Persistence 3.1 为参照。

1. 面试核心​

先记住这几条,再读正文
  • 受管实体的字段变化由脏检查在 flush 时同步到数据库,事务在 commit 时才提交;flush 之后事务仍然可以回滚。卡 · 持久化上下文与实体身份
  • 默认的 AUTO 模式要求查询考虑会影响结果的待写变化,COMMIT 模式对提交前的查询能否看到这些变化未作规定;两者都不保证每次查询前一定 flush。卡 · FlushMode 与查询可见性
  • merge 把脱管对象的状态复制到一个受管实例并返回它,传入的脱管对象仍然脱管,后续要修改返回值。卡 · merge 的状态复制与返回值
  • LAZY 是按需加载的提示,EAGER 要求加载关联,具体用 join 还是额外查询由 JPA 实现决定;cascade 管操作传播,mappedBy 标出关系的拥有方。卡 · 懒加载与上下文
  • @Version 在更新时校验版本,检测其他事务造成的并发覆盖;JPQL 批量 DML 绕过受管实体,不会同步已加载对象,也不走普通的版本校验。卡 · 批量修改与上下文同步

2. 持久化上下文与实体身份​

EntityManager 是操作实体的接口,每个 EntityManager 关联一个持久化上下文。在同一个上下文里,实体类型加主键确定一个持久化身份,同一个身份只对应一个受管对象:

Order first = entityManager.find(Order.class, 101L);
Order second = entityManager.find(Order.class, 101L);

assert first == second;

第二次 find 不会再造一个新对象,而是返回上下文里已有的那个,所以 first == second 成立。这种身份映射减少了重复加载,也是框架能跟踪对象变化和关联关系的基础。它只在当前上下文里有效:上下文关闭后,这些对象就脱离了管理。

EntityManager 和它的上下文是为单线程设计的,应该按一次业务工作来创建和关闭,不要让多个线程同时访问。

3. 实体状态​

字段修改能不能写进数据库,取决于对象当前处于哪种状态。JPA 实体有四种状态:

  • new(新建):对象刚 new 出来,还没有和持久化上下文关联。
  • managed(受管):对象由当前上下文跟踪,字段变化会在 flush 时同步到数据库。
  • detached(脱管):对象有持久化身份,但已经离开了管理它的上下文,修改只影响这个 Java 对象。
  • removed(待删除):对象已被标记删除,删除语句在同步时执行。

这些状态通过实体操作转换:

  • persist 把新实体交给上下文管理,进入 managed。
  • find 或实体查询返回的是 managed 对象,后续修改由上下文跟踪。
  • detach 让指定对象脱管;clear 或关闭上下文让其中所有实体脱管。
  • remove 把受管实体标记为 removed,等待执行删除。

4. 脏检查与 flush​

脏检查是找出受管实体哪些字段变了,flush 是把这些变化以 SQL 的形式发给数据库。有了这两步,下面的代码只改了对象,也能完成更新:

@Transactional
public void rename(long id, String name) {
Customer customer = entityManager.find(Customer.class, id);
customer.rename(name);
}

find 拿到的 customer 是受管的。事务提交前会执行 flush,Hibernate 发现名称变了,就生成对应的 update 语句。所以在同一个事务里修改受管实体,不需要每次 setter 之后再调 save 或 merge。

Hibernate 发现变化有两种方式:一种是在加载时保存一份字段快照,flush 时逐个比较新旧值;另一种是字节码增强,在字段被修改时直接记录下来。用哪种由实现和配置决定。

flush 和 commit 是两件事。flush 之后,SQL 已经发给数据库,但事务还没提交,仍然可以回滚。insert 何时执行还受主键生成策略影响;查询之前会不会先同步,则由 FlushMode 和查询类型决定,见下一节。

5. FlushMode 与查询可见性​

修改了受管实体后马上查询,查询能不能看到刚才的修改?这由 FlushMode 决定,默认是 AUTO。

AUTO 模式下,只要在事务内、且持久化上下文已经加入事务,规范就要求查询结果反映相关受管实体的更新。实现可以通过先 flush 来满足,也可以用别的方式,所以 AUTO 并不等于「每次查询前都 flush」。

COMMIT 模式要求在提交时 flush,但也允许实现提前同步。提交之前,内存里的修改会不会影响查询结果,规范没有规定。如果代码需要一个确定的同步点,就显式调用 flush:

entityManager.setFlushMode(FlushModeType.COMMIT);
customer.rename("new-name");
entityManager.flush();

假设 customer 已经受管,这里的 flush() 会先把新名称同步到数据库,之后的查询就能看到它。但事务仍要 commit 才算提交,在那之前仍然可以回滚。

6. merge 的状态复制与返回值​

脱管对象上的修改,需要重新交给上下文跟踪时,可以调用 merge。要注意的是,它返回的才是受管对象:

Order detached = previousOrder; // 来自已关闭的上下文
Order managed = entityManager.merge(detached);

merge 先根据持久化身份找到受管目标,再把传入对象的状态复制过去。目标可能是上下文里已有的实例,也可能是 JPA 实现(例如 Hibernate)新建的受管副本。

复制完以后,原来的 detached 仍然是脱管的。如果之后继续改 detached,这些修改不会被跟踪,也就不会写入数据库,所以后续应该修改返回的 managed。如果传入的对象本来就是受管的,返回的就是它自己。换句话说,merge 会不会新建副本,取决于对象状态和当前上下文。

7. 事务与上下文边界​

对象能被跟踪多久,要同时看事务和持久化上下文的生命周期。在 Spring 中关闭 OSIV、使用事务范围的上下文时,事务结束上下文就关闭,实体随之脱管。(OSIV 会把上下文保留到 Web 响应阶段,后面单独说明。)另有一种扩展上下文,可以跨越多个事务。

服务方法应该在一个明确的事务里完成读取、校验和修改。还要注意,事务回滚只回滚数据库,Java 对象的字段不保证恢复成数据库里的旧值。所以重试时要开新事务、重新读取实体,再完整执行一遍业务判断。

如果把实体长期放进 HTTP Session、缓存或消息里,脱管对象就会流到别的请求或线程。这时对象里的版本号和关联状态都来自之前的上下文,版本冲突和关联能否加载都更难判断。

8. 懒加载与上下文​

懒加载把关联的查询推迟到真正访问关联数据的时候。Hibernate 用代理对象或持久化集合占住关联的位置,访问到尚未初始化的内容时再去查询:

Order order = repository.findById(id).orElseThrow();
return order.getItems().size();

size() 要访问订单明细集合。如果集合还没加载,而 Hibernate Session(Hibernate 管理持久化上下文的接口)已经关闭,默认配置下就会抛出 LazyInitializationException,因为已经没有上下文可以替它执行查询。已经加载过的字段在关闭后仍然可以访问。

上下文还开着也有问题:如果直接把实体序列化成响应,序列化器调用 getter 时会触发尚未加载的关联查询,查询数量变得不可控;双向关联没有设好序列化边界,还会来回递归。反过来把所有关联都设成 EAGER,又会让每次查询固定加载一大堆数据,并引入额外的次级查询。

比较稳妥的做法是在服务层的事务内,按用例加载所需数据,再映射成 DTO,也就是只包含响应所需字段的数据对象。这样查询发生在哪里、发生了几次都很清楚。具体的抓取方式见 N+1 查询。

9. OSIV 的上下文范围​

OSIV(Open EntityManager in View)把持久化上下文保留到 Web 响应阶段,所以序列化时访问未加载的关联,仍然能查出来,不会抛 LazyInitializationException。但它延长的只是上下文,原来的业务事务已经结束了。

这带来两个问题。一是这些额外查询发生在 Controller 或序列化阶段,在业务事务之外,数据一致性和错误处理都要另外考虑。二是查询散落在服务方法之外,很难统计一次业务操作到底查了多少次。

要不要开 OSIV,要看应用的响应方式。API 服务可以在服务事务内完成查询和 DTO 映射,让响应只使用已经准备好的数据。测试也要覆盖真实的序列化过程,确认额外查询发生在哪里、有几次。

10. 关联所有权、级联与抓取​

关联关系涉及三个问题:关系怎样写入数据库、关联怎样加载、父子对象什么时候一起保存或删除。它们由不同的配置控制,要分开理解。

拥有方(owning side)是双向关系中决定数据库里关系怎样写入的一侧,通常就是持有外键的那一侧;另一侧用 mappedBy 指向拥有方的字段。比如 Order 和 OrderItem 是一对多,外键在 OrderItem 上,OrderItem.order 是拥有方,Order.items 上写 mappedBy = "order"。只往 order.getItems() 里加一个 item,而不设置 item.setOrder(order),外键可能不会按预期写入。所以应用要同时维护两侧的引用,让内存里的对象关系和数据库一致。

cascade 控制实体操作是否传播到关联对象,比如保存父对象时要不要一起保存子对象;fetch 控制关联的加载要求。前者管生命周期操作,后者管读取时机,互不替代。

JPA 关联的默认加载方式:

  • ManyToOne 和 OneToOne 默认 EAGER,要求关联被加载。
  • OneToMany 和 ManyToMany 默认 LAZY,提示按需加载。
  • LAZY 只是提示,实现可以提前加载;EAGER 也可以用额外的次级查询来加载。所以两者都没有规定必须用 join。

orphanRemoval 适用于 OneToOne 和 OneToMany:受管的子实体从关系中移除后,会在 flush 时被删除。它适合只属于父对象的子实体。被多个对象共享的实体应该单独管理生命周期,否则随父对象级联 REMOVE,会把别人还在引用的对象也删掉。

11. 乐观锁与版本校验​

两个事务同时读到同一个实体、各自修改后提交,后提交的会把先提交的修改覆盖掉。@Version 用版本号识别这种冲突:

@Version
private long version;

更新时,Hibernate 会把读取时的版本号放进 where 条件,更新成功后版本号加一。比如两个事务都读到 version = 3,先提交的那个执行 ... where id = ? and version = 3,成功后版本变成 4;后提交的那个条件还是 version = 3,匹配不到任何行,Hibernate 就抛出乐观锁异常。脏检查负责发现本地的变化,版本校验负责发现别人的并发修改。

发生冲突后,业务可以提示用户、重新合并修改或者重试。重试时要重新读取实体、完整执行一遍业务判断;只重发最后那条 update,等于沿用了基于旧数据做出的判断。

12. 批量修改与上下文同步​

JPQL 是面向实体编写查询的语言,它的批量 update/delete 直接修改数据库,不经过逐个受管实体。所以已经加载的对象仍然保持旧值,普通的实体版本校验也被绕过了。

如果批量修改也需要防止并发覆盖,就要在语句或业务逻辑里自己写明版本条件、版本递增和冲突检查。上下文里已经有受管实体时,按「同步、执行、刷新」的顺序处理:

  1. 先 flush,把需要保留的内存修改同步到数据库。
  2. 再执行批量 DML,也就是批量更新或删除语句。
  3. 执行后用 clear 清空上下文,或用 refresh 重新读取需要的实体。

顺序不能乱:提前 clear 会把还没同步的修改丢掉。另外,@Version 冲突可能到 flush 或 commit 时才暴露,所以要以事务最终的结果判断是否成功。出现冲突后,结束当前事务,在新的上下文里重新读取并判断。

13. 面试题卡片​

14. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明