首页 文章 精选 留言 我的

精选列表

搜索[boot],共8309篇文章
优秀的个人博客,低调大师

《Spring Boot + JPA 实战》第10招 别总查完整Entity

那天周会上,小王把订单列表接口超时的问题摆出来。我是老李,在团队里负责后端性能优化。点开日志一看,一个 `/api/orders` 列表查询,SQL 拉出来 42 个字段,订单表、用户表、明细表、商品表、地址表全都 join 上。前端只需要订单号、状态、金额、创建时间四个字段,结果网络传输 1.8MB,接口响应 2.4 秒。这问题在列表页、报表和查询接口里非常普遍:为了拿一个订单编号,把整个 Entity Graph 都加载出来。为什么现在要讲?因为很多团队还在把 Controller 直接返回 JPA Entity 当成默认方案,功能是能跑,但接口越跑越慢,数据泄露、递归序列化、懒加载异常也跟着来。 ## 01、痛点 订单列表接口是典型的读多写少场景。前端表格往往只需要几个列,比如订单号、下单时间、支付状态、实付金额。可后端代码里,经常写成 `orderRepository.findAll()` 或者 `findByUserId(userId)`,方法返回 `List`。 `Order` 是一个 JPA 实体,它身上挂着很多关联:`@ManyToOne` 的 `User`,`@OneToMany` 的 `OrderItem`,`OrderItem` 里又关联 `Product`,`Product` 里还可能有 `Category`、`Shop`、`Supplier`。JPA 默认对 `@ManyToOne` 和 `@OneToOne` 是 EAGER 加载,对 `@OneToMany` 是 LAZY 加载,但一旦 Controller 把实体返回给 Spring MVC 做 JSON 序列化,序列化器会顺着 getter 一路往下读,懒加载的集合也会被触发。结果就是一个订单编号,背后触发了几十条 SQL,构造了成百上千个 Java 对象。 最麻烦的是,这个加载过程很多时候不是一次性完成的,而是在 Jackson 序列化过程中逐个触发的,产生的 N+1 查询非常隐蔽。你去看业务代码,只有一行 `findAll`,但看 SQL 日志,已经刷了几十页。每个订单拉出 `OrderItem` 列表,每个 `OrderItem` 又去加载 `Product`,如果 `Product` 再带出别的关联,性能就雪崩。 还有一个容易被忽视的问题:Controller 直接返回 Entity 时,实体仍然可能处于持久化上下文管理之中。某些配置下,延迟加载已经关闭,序列化时直接抛 `LazyInitializationException`;另一些场景下,实体被序列化后又回到持久化上下文,可能产生脏检查、意外更新甚至循环引用。即便这些问题都避开,实体通常包含内部字段、版本号、审计信息,甚至敏感数据,会不知不觉暴露给前端。 所以,订单列表接口的慢,不是数据库本身撑不住,而是我们让数据库和 ORM 做了一件很笨的事:为了查询几个展示字段,加载并维护了一个庞大的业务对象图。 ## 02、是什么 解决这个问题的核心思路,是把查询结果从 Entity 里解耦出来。JPA 提供的能力叫 Projection,也就是投影。简单说,就是只从表中选取需要的字段,把这些字段映射到一个轻量对象上,而不是把整行、整个关联图都塞进实体。 常见的 Projection 有三种形态。 第一种是 Interface Projection。定义一个接口,只声明需要暴露的 getter 方法,比如 `interface OrderSummary { String getOrderNo(); String getStatus(); java.math.BigDecimal getAmount(); }`。Spring Data JPA 会根据接口方法名去查询结果中匹配同名字段。这种投影可以用于实体查询,也可以用于 JPQL 查询。写法简单,适合快速出统计结果,缺点是接口必须暴露 getter,返回值字段比较固定,不容易附加额外逻辑。 第二种是 DTO Projection。定义一个普通的 DTO 类,在 JPQL 里使用构造函数表达式,比如 `select new com.example.dto.OrderListDTO(o.orderNo, o.status, o.amount, o.createdAt) from Order o where o.userId = :userId`。DTO 类只需要一个对应参数的构造函数。这种方式最可控,SQL 查什么字段,DTO 里就是什么字段,不会多查,也不会触发关联加载。 第三种是 Dynamic Projection。在 Repository 方法上增加一个 `Class type` 参数,同一个查询方法可以动态返回不同投影类型。比如 `List findByUserId(Long userId, Class type)`,调用时可以传 `OrderListDTO.class`,也可以传 `OrderSummary.class`。动态投影适合报表系统,同一个查询主体可以按不同终端需求返回不同形状的数据。 除了这三种形态,还有一个更根本的理论区分:事务写模型和查询读模型。事务写模型由 Entity 承担,它关心业务规则、状态变化、聚合一致性和持久化上下文。查询读模型由 Projection 承担,它只是一份结果快照,不参与事务状态管理,不需要被 ORM 追踪。把这两类模型分开,很多看似复杂的性能问题都会变得简单。 ## 03、为什么 投影带来的第一层收益,是 SQL 字段变少。一个实体查询可能 `select` 42 个字段,而投影查询只 `select` 4 个字段。字段数量减少,数据库扫描的数据页更少,网络传输更小,尤其是当订单表包含大字段、备注、扩展 JSON 之类列时,效果更明显。 第二层收益,是对象数量大幅下降。实体查询会构造 `Order`、`User`、`OrderItem`、`Product` 等大量对象,其中很多对象只是为了维持关联关系而存在。投影查询只构造需要的 DTO 或接口代理,假设订单列表返回 200 条数据,原来可能产生 1000 多个实体对象,投影只需要 200 个轻量对象。对象数量下降,堆内存占用降低,GC 压力也随之下降。 第三层收益,是序列化开销降低。Jackson 序列化实体时,要处理嵌套对象、懒加载代理、循环引用、双向关联等复杂情况。序列化一个 `Order` 实体,它可能带着 `User` 对象、`List`,而每个 `OrderItem` 又带着 `Product`,Product 再带别的关联,整个序列化过程会不断深入,甚至触发更多查询。投影对象一般是扁平的 DTO,字段都是简单类型,序列化成本几乎可以忽略。 第四层收益,是接口隔离开关更清晰。Controller 直接返回 Entity,意味着数据库表结构的任何变化都可能直接影响 API 响应。加一个内部字段、改一个关联关系,前端可能就收到一堆额外数据甚至报错。投影 DTO 可以只暴露对外承诺的字段,内部表结构变化不影响接口契约。 第五层收益,是避免持久化上下文带来的副作用。Entity 被序列化时,可能触发懒加载,也可能因为已经脱离持久化上下文而抛异常。投影对象没有这些问题,它天生就是游离的数据快照,不会触发懒加载,也不会被脏检查。 ## 04、架构 在架构层面,可以把 Entity 和 Projection 的边界看成一种轻量的读写分离,或者叫命令模型与查询模型的分离。 Entity 适合表达事务中的业务状态。一个订单在创建、支付、取消、发货这些流程中,需要维护状态变化,需要校验订单项、库存、用户余额,这时候 `Order` 实体就是业务核心。它必须是完整的聚合根,包含所有必要关联,受持久化上下文管理,让事务提交时能够正确更新数据库。 Projection 适合表达查询结果。订单列表页、报表、统计接口,本质上只需要读取数据,不需要改变任何状态。这些场景不应该进入 Entity 的生命周期管理。它们要的是不可变、扁平、稳定的数据形状。Projection 可以理解为数据库查询结果到应用层 DTO 的直接映射,它跟业务实体无关,只跟查询维度有关。 落到代码结构上,Controller 不应该直接接触 Entity,Service 层负责事务边界,Repository 层提供两类方法:一类返回 Entity,用于写操作;另一类返回 Projection,用于读操作。例如 `OrderRepository` 里既可以有 `Order save(Order order)`,也可以有 `List findOrderListByUserId(Long userId)`。 这样做还有一个好处:查询模型可以独立演化。订单列表需要增加一个优惠金额字段,只需要改 DTO 和 JPQL;订单统计需要换一种聚合口径,只需要新增一个 Projection。不会因为改查询而影响写模型,也不会因为改写模型而破坏已有查询接口。 从数据库视角看,Projection 本质上是把选择权从 ORM 手里拿回开发者手里。ORM 自动生成的实体查询,往往倾向于加载全部列和必要关联,而投影查询则明确指定列,数据库优化器更容易生成高效的执行计划,也更容易用上覆盖索引。 ## 05、实战 我们以订单系统为例,做三个投影改造。 第一个是订单列表接口。前端需要订单号、状态、实付金额、创建时间四个字段。原来的代码可能是这样: ```java @GetMapping("/api/orders") public List listOrders(@RequestParam Long userId) { return orderService.listOrders(userId); } ``` 现在我们定义一个新的 DTO: ```java public class OrderListProjection { private final String orderNo; private final String status; private final BigDecimal amount; private final LocalDateTime createdAt; public OrderListProjection(String orderNo, String status, BigDecimal amount, LocalDateTime createdAt) { this.orderNo = orderNo; this.status = status; this.amount = amount; this.createdAt = createdAt; } // getter 省略 } ``` 然后在 Repository 里增加一个投影查询方法: ```java @Query("select new com.example.dto.OrderListProjection(o.orderNo, o.status, o.amount, o.createdAt) " + "from Order o where o.user.id = :userId order by o.createdAt desc") List findOrderListByUserId(@Param("userId") Long userId); ``` Controller 改成返回 `List`。这样 SQL 只查询 `order_no`、`status`、`amount`、`created_at` 四列,不再加载用户、订单项、商品等关联。 第二个是订单统计接口。比如需要按天统计订单数和总金额。我们可以使用 Interface Projection: ```java public interface OrderDailyStat { LocalDate getOrderDate(); Long getOrderCount(); BigDecimal getTotalAmount(); } ``` Repository 方法可以用 JPQL 的 `group by` 查询: ```java @Query("select function('date', o.createdAt) as orderDate, count(o) as orderCount, sum(o.amount) as totalAmount " + "from Order o where o.createdAt >= :startDate and o.createdAt findDailyStat(@Param("startDate") LocalDateTime startDate, @Param("endDate") LocalDateTime endDate); ``` 这里的函数写法可能因数据库不同而略有差异,实际项目中可以用数据库方言支持的日期函数替代。Interface Projection 的好处是聚合查询可以直接映射到接口,不用额外写 DTO。 第三个是客户消费榜。这个接口有时需要按客户展示消费总额、订单数、最近下单时间,有时又只需要展示客户姓名和消费总额。这种多形状需求可以用 Dynamic Projection: ```java public interface CustomerRankProjection { String getCustomerName(); BigDecimal getTotalSpent(); Long getOrderCount(); } public interface CustomerSimpleProjection { String getCustomerName(); BigDecimal getTotalSpent(); } ``` Repository 方法可以这样定义: ```java @Query("select c.name as customerName, sum(o.amount) as totalSpent, count(o) as orderCount " + "from Order o join o.customer c group by c.name order by totalSpent desc") List findCustomerRank(Class type); ``` 调用时传具体类型即可。Spring Data JPA 会根据返回类型自动适配投影。 接下来我们对比一下 Entity 和 Projection 的开销。假设订单列表返回 200 条数据。 如果用 Entity 查询,每个 `Order` 实体会关联一个 `User`、一个 `Customer`、一个 `List`,每个 `OrderItem` 又关联一个 `Product`。即便部分关联是懒加载,在序列化时也会被触发。SQL 字段可能多达 42 列,对象数量可能达到 1000 个以上,序列化后的 JSON 可能超过 1.8MB。响应时间可能达到 2 秒以上。 用 DTO Projection 后,SQL 字段只有 4 列,对象数量就是 200 个轻量 DTO。没有关联加载,没有嵌套序列化,JSON 可能只有 80KB 左右。接口响应时间可能降到 300 毫秒以内。这个对比非常直观。 ## 06、洞见 很多人问:Controller 为什么不推荐直接返回 JPA Entity?最直接的原因是,Entity 不是为序列化而生的。它承担的是业务状态和持久化职责,而不是数据传输职责。 Entity 有一个重要特征:它是有状态的。它受持久化上下文管理,拥有版本号、懒加载代理、集合包装器等。这些特征在事务内部是优点,可以帮助我们维护业务一致性。但一旦 Entity 走出事务边界,进入 Controller 和序列化层,这些特征就变成了麻烦。懒加载可能失效,代理可能无法序列化,集合可能触发意外查询,双向关联可能造成循环引用。 另一个深一点的原因,是接口契约会变得脆弱。如果把 Entity 直接返回给前端,表结构的变化会直接影响 API 响应。你加了一个内部备注字段,前端就能看到;你改了一个关联关系,前端可能收到一大块意料之外的数据。这种隐式耦合会让前后端协作越来越困难。 Projection 的价值在于,它强制我们把查询需求显式化。订单列表要什么字段,DTO 里就写什么字段,JPQL 里就查什么字段。没有隐式关联扩散,没有意外序列化。Projection 是一个结果快照,它不参与事务,不维护状态,不触发懒加载。它和 Entity 的职责边界非常清楚。 所以更准确的表述是:Entity 更适合表达事务中的业务状态,Projection 更适合表达查询结果。写操作时用 Entity 维护业务规则,读操作时用 Projection 返回数据。两者可以共存于同一个 Repository,但不要混在一起。 这也可以理解为一种更务实的 CQRS。不是每个系统都要上事件溯源和终一致,但在应用层把读写模型分开,成本低,收益却很大。 ## 07、行动 如果你的订单列表接口目前还是直接返回 Entity,建议按下面步骤改造。 第一步,梳理接口真正需要的字段。跟前端确认表格列、筛选条件、排序字段,只保留必要字段。不要试图一次覆盖所有潜在需求,缺字段以后再加。 第二步,定义 DTO Projection。字段设置成 `private final`,通过构造函数注入。这样 DTO 是不可变的,语义上更接近查询快照。 第三步,在 Repository 里添加 JPQL 构造函数查询。注意 JPQL 里的 `new` 表达式必须使用全限定类名,构造函数参数顺序要和 DTO 构造函数一致。 第四步,Controller 改为返回 Projection,不再返回 Entity。Service 层如果之前返回 Entity,也一并调整。 第五步,打开 SQL 日志,对比改造前后的 SQL 语句。确认字段列减少,确认没有新增的关联查询。 第六步,做一次性能对比。可以用同一批测试数据,观察响应时间、SQL 次数、网络传输大小。把数据记录下来,方便评估改造成果。 改造过程中有几个坑要注意。一是 DTO 构造函数参数名在 JPQL 中不重要,但顺序必须对应。二是如果 DTO 字段是 `LocalDateTime` 或枚举,要确保数据库驱动和 JPA 类型映射正确。三是动态投影的 `Class` 参数如果传入 Entity 类,仍然会返回 Entity,开发者需要自己控制。四是投影查询返回的对象不会被持久化上下文管理,不要试图修改它并保存,那不会生效。 做完订单列表之后,可以顺手把报表、统计、消费榜这类读接口都排查一遍,逐个改成 Projection。改造动作不大,通常一个接口十几分钟就能完成,但性能和可维护性的提升会很明显。 ## 08、小结 列表页、报表和查询接口只需要少量字段,不应该为了一个订单编号加载整个 Entity Graph。Entity 是事务写模型的核心,Projection 是查询读模型的结果快照。两者分开,接口更快,对象更少,序列化更小,边界更清晰。 JPA 提供了 Interface Projection、DTO Projection 和 Dynamic Projection 三种能力,分别适合快速查询、精确控制和动态形状。实际项目中,DTO Projection 因为最可控,最常被用在列表和详情接口;Interface Projection 适合统计聚合;Dynamic Projection 适合多端复用的报表系统。 如果你现在还在 Controller 里返回 Entity,不妨先把订单列表接口改成 DTO Projection,看看 SQL 日志和响应时间的变化。读模型和写模型一旦分离,很多看似复杂的性能问题都会变得简单。 ## 09、链接与概念说明 本文涉及的主要概念如下: Entity:JPA 实体,代表业务状态,受持久化上下文管理,适合事务写操作。 Projection:投影,只选取查询结果中的部分字段,映射到轻量对象或接口。 DTO Projection:通过 JPQL 构造函数表达式将查询结果映射到普通 DTO 类。 Interface Projection:定义接口,通过 getter 方法匹配查询结果字段。 Dynamic Projection:Repository 方法接收一个 `Class` 参数,动态确定返回投影类型。 Entity Graph:JPA 用来控制实体关联加载策略的机制,和 Projection 是两个方向。Entity Graph 决定关联怎么加载,Projection 决定要哪些字段。 Persistence Context:持久化上下文,管理实体生命周期、懒加载和脏检查。Projection 不进入持久化上下文,因此没有这些副作用。 Closed Projection:接口投影中只暴露实体字段的投影方式,比如 `getOrderNo()`。 Open Projection:接口投影中使用 `@Value` 注解或默认方法做计算逻辑的投影方式,比如拼装完整地址。通常建议优先使用 Closed Projection,因为查询字段更明确。 关于官方文档,可以在 Spring Data JPA 官方参考文档中搜索 Projections 章节,了解接口投影、DTO 投影和动态投影的详细用法;也可以在 Jakarta Persistence 规范中查找构造函数表达式相关说明;Hibernate 官方用户指南中也有关于查询投影、DTO 映射和结果转换的详细介绍。阅读这些材料时,重点关注查询结果映射和事务边界部分。

优秀的个人博客,低调大师

《Spring Boot + JPA 实战》第11招 深分页为什么慢

## 01、痛点 上周凌晨,订单服务告警,SQL 慢查询堆成山。用户只是在管理后台点了最后一个分页按钮,第 50000 页,数据库 CPU 直接飙到 90%。开发第一反应是索引失效,结果 EXPLAIN 一看,索引走得好好的,可查询还是慢。慢在哪?慢在 `LIMIT 999980, 20`。MySQL 为了扔掉前 999980 行,需要扫描百万级数据,而这只是取 20 条记录。 更让人头疼的是,Java 这一端用的是 `Pageable`,参数看起来只是 `page=49999&size=20`,分页简单得像切蛋糕。但代码里返回 `Page` 的那一刻,底层还偷偷多执行了一条 `COUNT(*)`。这两件事叠加,一个小小分页接口就成了数据库杀手。 为什么现在要讲?因为这类问题不会在测试环境 1000 条数据时暴露,往往等到订单量上百万、接口超时、用户骂慢,才在线上被逼着复盘。分页看起来是 UI 问题,本质是数据库访问模式问题。 ## 02、是什么 先把几个词说清楚,否则后面容易混。 - `Pageable`:Spring Data 里的分页参数抽象,通常包含页码、每页大小和排序条件。它把分页代码简化成 `page/size`,但它不负责优化 SQL。 - `Page`:返回一页数据,同时返回总记录数和总页数。总记录数来自额外的 `COUNT` 查询。 - `Slice`:只返回当前页数据和“有没有下一页”,不查总记录数,因此不会触发额外 `COUNT`。 - `Sort`:排序条件。分页一旦有排序,就必须和索引配合,否则排序文件或临时表会让分页雪上加霜。 - `Count Query`:分页组件为了知道总条数执行的 `SELECT COUNT(*)`,在大表上不可忽略。 - `Offset Pagination`:也就是 `LIMIT offset, size`。页码越深,offset 越大,数据库需要扫描并丢弃的行越多。 - `Keyset/Seek Pagination`:也叫游标分页。用上一页最后一条记录的唯一游标,比如 `(created_at, id)`,直接 `WHERE` 到下一段数据,不依赖 offset。 这组概念最关键的区别在于:`Page` 需要总量,`Slice` 只表达相对位置;`Offset` 按行号跳,`Keyset` 按值跳。后面实战会看清楚两者的差距。 ## 03、为什么 为什么 `Page` 通常额外执行一条 COUNT SQL? 因为分页组件要渲染出“共 1000000 条、共 50000 页”,它就必须知道总行数。数据库不会在返回 20 条数据时顺手赠送一个准确的总数。`SELECT COUNT(*) FROM orders` 在 InnoDB 里没有放之四海皆准的 O(1) 魔法,它要扫描某个索引。即使优化器选了最短的二级索引,百万行也要付出几百毫秒。更糟的是,这条 `COUNT` 和分页 SQL 会同时打到库上,每一页都重复。 为什么 Feed、流水、消息列表很多时候根本不需要总页数? 用户的动作是往下滑、点“加载更多”,他们不关心“第 3000 页 / 共 8000 页”。在持续写入的场景里,总数本身也在变化,展示总页数甚至可能误导用户。移动端、信息流、聊天记录天然是连续滚动体验。此时真正的需求不是“跳到第 n 页”,而是“给我上一页最后一条之后的 20 条”。所以 `Slice` 或 Keyset 比 `Page` 更合适。 深 OFFSET 为什么会慢? `LIMIT 999980, 20` 的实现方式不是指哪打哪,而是从符合条件的第一行开始,一行一行读,读到 offset 位置后,再取 20 行。即便走索引,也至少要扫过 999980 个索引条目,还可能回表。页号越深,丢弃的数据越多,耗时接近线性增长。索引能帮的是排序和定位,但救不了“跳过大量行”这一步。 ## 04、架构 分页应该放在整个访问链路上看,而不是只改一个 SQL。我一般会把分页分成三层。 第一层是 API 契约。管理后台需要总页数,可以返回 `total`、`totalPages`、`page`、`size`。连续滚动场景则返回 `items` 和 `nextCursor`,不承诺总量。API 一旦承诺总页数,查询层就不得不做 COUNT。 第二层是查询层。Offset 分页适合有界数据、需要跳页、需要导出、数据量可控。Keyset 分页适合无界流、时间线、Feed、流水、消息列表。查询层要把游标翻译成稳定的 `WHERE` 条件,而不是继续套 `page/size`。 第三层是存储层。索引必须和排序条件对齐。常见订单列表按 `created_at DESC, id DESC` 排序,那就建 `KEY idx_created_id (created_at, id)`。如果游标不唯一,比如只用 `created_at`,同一毫秒订单可能重复,排序就会不稳定,数据可能丢或重。因此游标字段要带一个唯一键兜底,比如自增 `id`。如果 `id` 是无序 UUID,还可以考虑业务时间加单调序号,但首要原则是排序必须稳定。 架构上的取舍也很清晰:`Page` 方便,但代价是每次翻页都可能有 COUNT,深页不可控;`Slice` 少了 COUNT,但仍然基于 offset,深页问题没有根除;只有 Keyset 从索引值出发,才能把深页复杂度从 O(offset) 压到 O(size) 附近。 ## 05、实战 下面构造一个百万级订单表,看看不同分页方式差多少。 ```sql CREATE TABLE orders ( id BIGINT PRIMARY KEY AUTO_INCREMENT, order_no VARCHAR(32) NOT NULL, user_id BIGINT NOT NULL, amount DECIMAL(10,2) NOT NULL, created_at DATETIME(3) NOT NULL, KEY idx_created_id (created_at, id) ); ``` 先批量造数据。可以写一个脚本分批插入 100 万行,`created_at` 模拟过去一年的时间分布,避免集中在一个时间点。 第 1 页查询: ```sql SELECT id, order_no, amount, created_at FROM orders ORDER BY created_at DESC, id DESC LIMIT 0, 20; ``` 在联合索引上,这个查询能直接命中前 20 条,执行很快,通常在亚毫秒到几毫秒量级。 第 50000 页查询: ```sql SELECT id, order_no, amount, created_at FROM orders ORDER BY created_at DESC, id DESC LIMIT 999980, 20; ``` `offset = (50000 - 1) * 20 = 999980`。InnoDB 需要从索引末尾往前数,扫过约 100 万行,再丢掉前 999980 行。实测这个查询会从几毫秒变成数百毫秒,甚至上秒。如果数据在缓冲池里、硬件较好,可能是 200~600 毫秒;一旦数据从磁盘冷读,情况更糟。 再执行一条 `Page` 场景下的 COUNT: ```sql SELECT COUNT(*) FROM orders; ``` 百万行表上,这条语句也需要扫索引,耗时通常和表大小、缓冲池相关,轻松达到数百毫秒。 换 Keyset 分页。假设上一页最后一条是: ```text created_at = '2025-01-15 10:20:30.123' id = 789012 ``` 下一页查询写成: ```sql SELECT id, order_no, amount, created_at FROM orders WHERE (created_at items; private Long nextId; private LocalDateTime nextCreatedAt; } ``` 查询层把 `nextId` 和 `nextCreatedAt` 作为下一页游标。不要返回 `total`,避免 COUNT。 简单对比: | 方式 | SQL 额外成本 | 第 1 页 | 第 50000 页 | |---|---:|---:|---:| | Offset | 无 COUNT | 约 1ms | 约 500ms | | Page + COUNT | 多一次 COUNT | 约 400ms | 约 1000ms | | Keyset | 无 COUNT | 约 1ms | 约 1ms | 数字只是量级,不是标准值,但趋势是确定的:Offset 越深越慢,Keyset 基本稳定。 ## 06、洞见 分页首先是数据库访问模式问题,其次才是 UI 问题。 很多项目是先设计一个带页码的分页条,再让后端返回 `Page`,数据库就开始多跑 COUNT,深页就开始 `OFFSET` 爆炸。这个顺序是反的。正确做法是先问三个问题:数据有没有明显边界?用户需要跳页还是连续加载?数据是否频繁增长? 管理后台订单列表有边界,需要按条件筛选、跳到第几页、看总数,那就用 `Page`。Feed、流水、消息列表没有边界,用户几乎是“向下滑”,只关心接下来有没有内容,那就用 Keyset 或 `Slice`。在这些场景里强调“共多少页”不仅浪费数据库资源,有时候还是一种产品设计上的噪声。 关键还要理解索引。分页优化不是改一个参数叫 `pageable` 就能完成的。真正起作用的是排序字段和唯一键构成联合索引,让数据库可以用范围扫描替代大偏移。数据库访问模式选错,前端怎么设计都是补救;访问模式选对,分页才能稳定。 ## 07、行动 第一,管理后台继续用 `Page`,但要有保护措施。例如限制最大可跳页数,或者用近似总数、缓存 COUNT,避免每翻一页都执行全量 COUNT。100 万的表不是不能 COUNT,但 5000 万、1 亿行时,每次 COUNT 都可能成为慢查询。 第二,连续滚动场景不要再返回 `Page`。返回 `Slice` 或者自定义 `nextCursor`。接口可以是: ```text GET /orders/stream?createdAt=2025-01-15T10:20:30.123&id=789012&size=20 ``` 后端把 `createdAt` 和 `id` 组合成联合索引游标,SQL 写成等值加小于条件的组合。 第三,如果列表还需要支持条件筛选,Keyset 仍然可用,但游标必须在新的排序语义下保持稳定。例如筛选某个用户订单,索引可能是 `(user_id, created_at, id)`,游标要携带 `user_id`、`created_at`、`id`。查询条件需要保证同一排序键下不会漏数据。 第四,每次分页改造后,用 `EXPLAIN` 验证执行计划。关注 `type` 是否是 `range`,`rows` 是否接近页大小而不是全表。不要把“感觉快了”当依据。 ## 08、小结 `Pageable` 简化了 Java 分页代码,但没有消除 MySQL `OFFSET` 和 `COUNT` 的执行成本。`Page` 会为了总页数执行额外 COUNT,`Offset` 会在深页时扫描并丢弃大量行。对于管理后台这种有界、需要跳页的场景,可以继续忍受这些成本;对于 Feed、流水、消息列表这类连续滚动场景,Keyset Pagination 是更合理的默认解。记住一点:分页不是给数据库套一层 `page/size`,而是先想清楚数据访问模式和索引。 ## 09、链接与概念说明 - `Pageable`:Spring Data 分页参数抽象,把页码、页大小和排序传给查询层。 - `Page`:带总记录数和总页数的返回结构,通常触发额外 COUNT。 - `Slice`:不带总记录数,只说明是否有下一页,适合连续滚动。 - `Count Query`:为了获得总条数执行的 SQL,常见为 `SELECT COUNT(*) FROM ...`。 - `Offset Pagination`:`LIMIT offset, size` 模式,深页扫描代价高。 - `Keyset/Seek Pagination`:基于上一页游标的有序遍历范围查询。 - 联合索引:例如 `(created_at, id)`,是 Keyset 稳定的前提。 - 可参考 MySQL 官方文档《LIMIT Query Optimization》和 Spring Data Commons 中 `Pageable`、`Slice` 的说明。

优秀的个人博客,低调大师

《Spring Boot + JPA 实战》第17招 数据变更要留痕

## 01、痛点 我是老李,早上刚坐下,运营群里就炸出一条消息:订单 O20241120001 十分钟前还是待支付,现在怎么变成已发货了?钱到底有没有收到?客服查了后台,只看到 status=SHIPPED,update_time=2024-11-20 14:32:11。至于之前是什么状态、谁点的发货、为什么点发货,全都不见了。 这不是个例。很多业务系统做到最后,订单表里只有一个 updated_at,勉强知道它最近被动过;有的加上了 updated_by,但只在少数入口写,批量脚本、定时任务、支付回调经常漏掉;更麻烦的是状态被覆盖后,旧值被直接冲掉,想还原现场得靠猜。结果就是系统知道自己“现在是什么”,却不知道“谁在什么时候把它改成这样”,更不知道“为什么这样改”。 等出了问题再翻 binlog、翻日志、找 DBA 还原,往往已经错过最佳处理时间。于是我们开始思考:到底要补齐哪些机制,才能让订单的创建、支付、发货全过程都可追溯? ## 02、是什么 先厘清几个容易混淆的概念。 Spring Data Auditing 提供了一组字段级注解:@CreatedDate、@LastModifiedDate、@CreatedBy、@LastModifiedBy。它们配合 JPA 的实体监听器,在插入和更新时自动填充创建时间、修改时间、创建人、修改人。注意,它只维护当前行上的字段,一旦 UPDATE 执行,旧值就被覆盖,历史版本不会保留。 Envers 是 Hibernate 的审计模块。用 @Audited 标注实体后,Envers 会自动生成对应的 _AUD 表,每次提交事务时写入一个修订版本。它能记录每一次变更前后的快照,还能通过 REVINFO 知道变更发生的时间和修订号。Envers 回答的是“这个实体在某一刻长什么样”。 业务历史表则是团队自己设计的领域流水表,通常叫 order_status_history 或类似名字。每发生一次关键状态变化,就插入一条记录,包含 from_status、to_status、reason、operator、event_type、occurred_at 等。它不追求保留整行的所有字段,而是保留业务动作的含义。 三者放在一起看:Spring Data Auditing 管当前行的审计元数据;Envers 管实体的版本快照;业务历史表管业务状态变迁的原因。前两者偏技术,最后一个偏领域。 ## 03、为什么 你可能会问:只加 updated_at、updated_by 不够吗?为什么还要 Envers 和业务历史表? 先看一个真实场景:支付回调把订单从 CREATED 改成 PAID,仓储系统十分钟后把订单从 PAID 改成 SHIPPED。订单表只留下 updated_at 和 updated_by,你能看到的只是最后修改人是 wms_system,时间是 14:32:11。可是如果客户投诉“我没收到货,订单却显示已发货”,你无法知道支付回调是否成功、订单是否经过 PAID、是否有人从 CREATED 直接跳到 SHIPPED。 Envers 可以帮你还原:假设订单被改了三次,Envers 里会有三个版本,你能看到 CREATED 的版本、PAID 的版本、SHIPPED 的版本。但 Envers 仍然回答不了“为什么从 PAID 到 SHIPPED”——是仓储正常发货,还是客服手工强制发货?是用户修改了地址后重新发货,还是系统误触发?这些业务意图,藏在当时操作人的脑袋里,或者藏在另一张工单、另一条日志里。 业务历史表的必要性就在这里。订单状态变化不只是数据更新,而是一个业务事件。事件需要记录触发原因、操作类型、操作人、来源系统、关联单号。比如 PAID 的原因可能是“支付宝异步通知,交易号 2024112000123456”;SHIPPED 的原因可能是“仓库 WMS 出库单 OUT202411200099”。有了这些信息,排障、合规、客服对客解释都能快速完成。 一句话:技术审计让你知道“谁改过”,领域审计让你知道“为什么变”。真实系统如果只有前者,业务追溯会非常痛苦。 ## 04、架构 要把审计做好,不能只靠一个工具。我的建议是三层组合。 第一层,实体审计字段。订单表等核心实体增加 created_at、updated_at、created_by、updated_by 四个字段,由 Spring Data Auditing 自动填充。这一层成本最低,先解决“当前行是谁最后碰过”的问题。 第二层,实体版本审计。对 orders 主表开启 Envers,自动生成 orders_AUD 和 REVINFO。这样任何一次 UPDATE 都会留下历史快照,用于回溯纠纷、恢复误操作、检查字段变更轨迹。 第三层,领域状态历史。为订单状态机单独建 order_status_history 表,每次状态变化写入一条带原因的事件。注意,状态历史表不要试图保存整个订单的所有字段,它只记录业务状态流转的上下文。 数据库 Trigger 放在哪里?Trigger 可以在数据库层无侵入地记录行级变更,适合旧系统、多写入口、无法统一改造应用层的场景。但 Trigger 的缺点是只能看到数据变化,不知道业务意图,还容易造成性能开销和隐蔽逻辑。JPA Auditing 适合应用层能统一管理的系统,业务审计表适合需要表达领域语义的场景。 可以用一个简单对比理解: - 数据库 Trigger:适合兜底、跨应用、快速上线;弱点是业务语义弱、维护成本高。 - JPA Auditing:适合统一应用入口、需要轻量审计字段;弱点是只有当前值,无历史版本。 - Envers:适合实体变更历史、版本回溯;弱点是偏技术快照,缺少业务原因。 - 业务审计表:适合状态机、关键业务流转;弱点是需要业务建模和代码纪律。 真实架构通常不是四选一,而是按需组合:关键表三层都上,普通表只用审计字段,旧系统用 Trigger 兜底。 ## 05、实战 下面以 Order 为例,把创建人、修改人、创建时间、更新时间和订单状态历史补齐。 第一步,给订单实体加审计字段。 ```java @Entity @Table(name = "orders") @EntityListeners(AuditingEntityListener.class) public class Order { @Id private String orderNo; @Enumerated(EnumType.STRING) private OrderStatus status; @CreatedDate private LocalDateTime createdAt; @LastModifiedDate private LocalDateTime updatedAt; @CreatedBy private String createdBy; @LastModifiedBy private String updatedBy; @Version private Long version; // 省略 getter/setter } ``` 第二步,开启审计并配置操作人来源。 ```java @Configuration @EnableJpaAuditing(auditorAwareRef = "auditorProvider") public class JpaConfig { @Bean public AuditorAware auditorProvider() { return () -> Optional.ofNullable(SecurityContextHolder.getContext()) .map(ctx -> ctx.getAuthentication()) .map(auth -> auth.getName()) .or(() -> Optional.of(getDefaultUser())); } private String getDefaultUser() { return "system"; } } ``` 这里的 getDefaultUser 可以在定时任务、支付回调等没有登录用户的场景返回系统账号。 第三步,定义订单状态和事件类型。 ```java public enum OrderStatus { CREATED, PAID, SHIPPED, CANCELLED } public enum OrderEventType { CREATE, PAY, SHIP, CANCEL } ``` 第四步,建立订单状态历史表。 ```java @Entity @Table(name = "order_status_history") public class OrderStatusHistory { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String orderNo; @Enumerated(EnumType.STRING) private OrderStatus fromStatus; @Enumerated(EnumType.STRING) private OrderStatus toStatus; @Enumerated(EnumType.STRING) private OrderEventType eventType; private String reason; private String operator; private LocalDateTime occurredAt; // 省略 getter/setter } ``` 第五步,把状态变更收敛到一个服务里,保证状态历史与状态变更同事务。 ```java @Service public class OrderStateService { private final OrderRepository orderRepository; private final OrderStatusHistoryRepository historyRepository; public OrderStateService(OrderRepository orderRepository, OrderStatusHistoryRepository historyRepository) { this.orderRepository = orderRepository; this.historyRepository = historyRepository; } @Transactional public void ship(String orderNo, String operator, String reason) { Order order = orderRepository.findByOrderNo(orderNo) .orElseThrow(); OrderStatus fromStatus = order.getStatus(); if (fromStatus != OrderStatus.PAID) { throw new IllegalStateException(); } order.setStatus(OrderStatus.SHIPPED); orderRepository.save(order); OrderStatusHistory history = new OrderStatusHistory(); history.setOrderNo(orderNo); history.setFromStatus(fromStatus); history.setToStatus(OrderStatus.SHIPPED); history.setEventType(OrderEventType.SHIP); history.setReason(reason); history.setOperator(operator); history.setOccurredAt(LocalDateTime.now()); historyRepository.save(history); } } ``` 关键点不是保存动作本身,而是把状态变更和历史写入放在同一个事务里。这样一旦历史写失败,订单状态也会回滚,不会出现状态变了但历史没记的情况。 第六步,查询订单全链路。 ```sql SELECT from_status, to_status, event_type, reason, operator, occurred_at FROM order_status_history WHERE order_no = 'O20241120001' ORDER BY occurred_at ASC; ``` 预期结果: ``` CREATED -> PAID | PAY | 支付宝回调,交易号 2024112000123456 | payment_gateway | 2024-11-20 14:20:11 PAID -> SHIPPED | SHIP | 仓库 WMS 出库单 OUT202411200099 | wms_system | 2024-11-20 14:32:11 ``` 这样从 CREATED 到 PAID 再到 SHIPPED 的全过程,每一步都有操作人、原因和时间,追溯链路完整。 ## 06、洞见 技术审计和领域审计的分界线,常常被忽视。 技术审计回答“谁改了记录”。例如 updated_by=wangwu,updated_at=2024-11-20 14:32:11,这只能说明王五最后碰过这条记录。至于他为什么改,是客户投诉、领导指令、系统自动触发还是误操作,技术审计本身不提供答案。 领域审计回答“为什么业务状态发生改变”。它把状态变化建模成事件:从什么到什么,由哪个业务动作触发,关联了哪些单据,原因是什么。比如“PAID -> CANCELLED,原因是用户申请退款,退款单 R123,客服 wangwu 审批通过”。这条信息不只是审计证据,更是业务知识。 如果只做技术审计,系统会在排障时频繁出现“改了但不知道为什么改”的情况。更糟糕的是,随着时间推移,当事人离职、记忆模糊,历史原因就彻底丢失。领域审计的价值之一,就是把这些业务上下文沉淀下来,变成可查询的资产。 订单状态尤其典型。CREATED、PAID、SHIPPED 不只是数据库字段值,它们对应商务流程的关键节点。付款、发货、取消,每个节点的原因都可能涉及资金、库存、客户承诺。因此,订单状态历史应该按事件建模,而不是只记一个修改痕迹。 ## 07、行动 要让订单从 CREATED 到 PAID 再到 SHIPPED 全过程可追溯,我建议按下面顺序动手。 第一,先给订单表补上 created_at、updated_at、created_by、updated_by 四个字段。存量数据如果无法准确回填,可以先统一置为 system,后续再逐步修正。 第二,开启 Spring Data Auditing 和 AuditorAware,把当前登录用户、系统来源接入进来。支付回调、仓储回传、定时任务必须显式传入系统账号,不能留空。 第三,用 Envers 给 orders 表开启审计,生成版本快照。这样即使状态历史表漏记,也还有实体快照可以回溯。 第四,设计 order_status_history 表。字段至少包含 order_no、from_status、to_status、event_type、reason、operator、occurred_at,最好再加 request_id 或 trace_id,方便关联整条调用链。 第五,把订单状态变更全部收敛到 OrderStateService,不允许在业务代码里直接 update 状态。所有入口先校验状态机,再更新订单,最后写历史,保证同一事务。 第六,对支付、发货、取消等关键节点,逐一补上业务原因。不要只写一个“系统操作”,要写清楚来源单号、通知流水号、操作依据。 第七,加一条端到端测试:创建订单后支付、再发货,断言 status 为 SHIPPED,且 order_status_history 中恰好有 CREATED->PAID 和 PAID->SHIPPED 两条记录。这样以后谁把状态机写坏,测试会直接失败。 第八,如果老系统短期改不动,可以先用数据库 Trigger 记录行级变更兜底。但要明确 Trigger 只是过渡方案,业务语义最终还是要靠领域审计表。 ## 08、小结 审计不是给开发增加负担,而是给系统增加可解释性。 created_at 和 updated_at 告诉你记录的生命周期;created_by 和 updated_by 告诉你最后是谁碰过它;Envers 让你能回看任意历史版本;order_status_history 则让你知道订单为什么从一个状态走到另一个状态。四样东西放在一起,才是一条完整的追溯链。 真实业务系统不能只知道“现在是什么”,还要知道“谁在什么时候把它改成这样”,更要知道“为什么这样改”。技术审计和领域审计不是替代关系,而是搭档关系。前者负责记录事实,后者负责解释业务。 ## 09、链接与概念说明 - Spring Data Auditing:Spring Data 提供的基础能力,可通过 @CreatedDate、@LastModifiedDate、@CreatedBy、@LastModifiedBy 与 AuditorAware 自动填充审计字段。详细用法见 Spring Data JPA 官方文档。 - Envers:Hibernate ORM 的实体审计模块。使用 @Audited 后自动生成 _AUD 历史表和 REVINFO 修订表,适合做实体版本快照。详细配置见 Hibernate Envers 官方指南。 - 业务历史表:由团队按业务状态机设计的流水表,核心字段建议包含 from_status、to_status、event_type、reason、operator、occurred_at、request_id。 - 数据库触发器:数据库级别的自动动作,可在 INSERT、UPDATE、DELETE 时触发,适合旧系统或跨应用的行级变更兜底。缺点是业务语义弱,通常不作为主要领域审计方案。 - 技术审计与领域审计:技术审计关注记录和字段的修改事实;领域审计关注业务状态变化的触发原因与上下文。本文用订单状态历史展示两者如何协同。

优秀的个人博客,低调大师

《Spring Boot + JPA 实战》第23招 什么时候别用JPA

上周,运营同事在群里贴了一张截图:订单统计报表接口耗时 43 秒,页面一直转圈。我点开日志一看,这个接口为了拿到按天分组的几条汇总数据,硬是用 JPA 把最近 30 天所有订单实体都查出来,在内存里用 Java 流做分组求和。我是老李,做后端十几年,这种场景不是第一次见。团队当初为了“技术统一”,规定所有数据访问必须走 JPA,结果复杂查询越写越别扭,报表越来越慢,批量导入动不动就内存溢出。今天我想聊聊一个反直觉但很重要的观点:真正掌握 JPA 的标志,不是所有数据访问都用 JPA,而是知道什么时候应该离开 JPA。 ## 01、痛点 很多团队在引入 JPA 后,会陷入一种“幸福”的错觉:所有 SQL 都不用写了,实体一映射,Repository 一继承,增删改查就完成了。刚开始确实很爽,但随着业务发展,问题开始出现。订单项目里,一个简单的列表页需要按十几个条件组合筛选,团队用 Specification 拼了 200 行代码,可读性极差,每次加条件都要小心翼翼,生怕关联表出现笛卡尔积。另一个统计报表,需要按天、按区域、按渠道聚合订单金额和退款金额,数据量超过 3000 万行,用 JPA 的实体查询把一堆无关字段也加载进来,内存占用飙升,GC 频繁,接口响应时间从几百毫秒退化到几十秒。还有一个月度批量导入任务,十万条订单明细需要落库,用 saveAll 一条条插入,事务开得很大,执行到一半就超时,数据库连接池被打满。 ## 02、是什么 要解决这个问题,得先建立一个清晰的数据访问工具梯度。它不是谁替代谁,而是根据不同场景选择最合适的工具。这个梯度大致是:JpaRepository → Projection → Specification → Native SQL → JdbcClient/JdbcTemplate → jOOQ。 最左边,JpaRepository 适合最标准的单表 CRUD,通过方法名派生查询,简单直接。当只需要实体中的某几列时,使用 Projection 可以避免加载整个实体,减少数据传输和对象构造开销。当查询条件动态变化、组合较多但主要是等值过滤和简单范围判断时,Specification 可以动态拼接条件,但它的表达能力有限,遇到复杂连接、子查询、窗口函数就会力不从心。 再往后,Native SQL 允许直接写数据库方言 SQL,解决 ORM 生成的 SQL 不够高效的问题。JdbcClient/JdbcTemplate 是 Spring 提供的轻量级数据访问工具,直接执行 SQL 并映射结果,没有持久化上下文,非常适合批量操作和复杂查询。最右边,jOOQ 提供类型安全的 SQL 构建能力,既能写复杂 SQL,又有编译期检查,适合大量复杂查询且需要可维护性的场景。 这个梯度不是线性的等级划分,而是按“领域复杂度”和“查询复杂度”两个维度扩展。掌握 JPA,就是能在这个梯度上自由游走,而不是死守某一点。 ## 03、为什么 为什么为了技术统一而强迫所有查询走 ORM 反而可能增加复杂度?原因有三个。 第一,ORM 是抽象,抽象是有代价的。JPA 隐藏了 SQL 细节,但复杂查询恰恰需要掌控这些细节。比如统计报表需要 GROUP BY、HAVING、窗口函数、CTE,JPA 的 JPQL 和 Criteria API 要么不支持,要么写法极其别扭,最后生成的 SQL 往往不是最优的,还要额外调优。团队花在调优 ORM 上的时间,可能比直接写 SQL 还多。 第二,对象-关系阻抗失配在复杂查询和批量场景下被放大。JPA 的实体有生命周期和持久化上下文,查询时会把不需要的关联也加载进来,造成 N+1 或内存浪费;批量更新时逐条脏检查,性能极差。为了统一而统一,等于让所有数据访问都背上实体映射的包袱。 第三,技术统一不等于架构简单。真正简单的架构,是每类问题都有清晰的解决方案,而不是所有问题都用一个工具硬扛。当团队被迫用 Specification 去实现一个报表查询时,代码复杂度反而上升,维护成本更高。 ## 04、架构 在架构层面,我们需要一个显式的决策框架,而不是默认“全部用 JPA”。这个框架有两个输入:领域复杂度和查询复杂度,两个约束:数据规模和性能要求。 领域复杂度指业务规则的多少和事务边界:简单的增删改查、单表或少量关联,复杂度低;多表关联、聚合、批量处理,复杂度高。查询复杂度指 SQL 本身的复杂度:单表过滤、简单连接、动态条件、复杂统计、窗口函数等。数据规模和性能要求则决定是否需要数据库级别的优化,如索引、分区、物化视图、批量写入。 把这些维度映射到前面的梯度:简单领域和简单查询用 JpaRepository;简单领域但需要部分字段用 Projection;中等查询用 Specification;复杂查询或性能敏感用 Native SQL 或 JdbcClient/JdbcTemplate;复杂查询且要求类型安全和可维护性用 jOOQ。这不是绝对的,但给出了默认选择。 更重要的是,每个项目应该明确“默认方案”和“退出条件”。比如订单项目,普通 CRUD 默认 JpaRepository,一旦出现聚合、批量、复杂连接,就退出 JPA,切换到 JdbcClient 或 jOOQ。这样既保留了 JPA 在简单场景的高效开发,又避免了它在复杂场景下的短板。 ## 05、实战 下面用订单项目的四个典型场景具体说明。 **普通 CRUD:订单主表、用户表、商品表的基础增删改查。** 默认使用 Spring Data JPA 的 JpaRepository,实体映射关系简单,通过方法名派生查询即可,比如 findByOrderNo、findByUserIdAndStatus。这里不需要任何退出,因为这是 JPA 最擅长的领域。注意避免在实体上使用 EAGER 加载不必要的关联,保持懒加载即可。 **复杂搜索:运营后台需要按订单号、用户手机号、下单时间、支付状态、订单来源等十几个条件组合查询。** 默认使用 Specification 动态拼接条件,条件之间是 AND 关系,偶尔有 OR,能覆盖大多数场景。但如果出现以下情况:需要关联 4 张以上的表、需要子查询或 EXISTS、需要复杂排序和分组,就退出 Specification,改用 JdbcClient 直接执行原生 SQL,或者用 jOOQ 构建类型安全的复杂查询。关键判断点是:Specification 拼出的代码是否明显比 SQL 还难读。 **千万级统计报表:按天、区域、渠道统计订单金额、退款金额、客单价,数据量 3000 万行。** 默认不使用 JPA。直接从汇总表或明细表用 JdbcClient 执行聚合 SQL,配合数据库索引和分区表,能控制在秒级。如果需要实时计算,可以借助物化视图或定时任务提前聚合。千万不要用 JPA 把明细行加载到内存再计算,那是性能灾难。 **十万级批量导入:每月导入渠道对账单,十万条明细。** 默认使用 JdbcTemplate 的 batchUpdate 方法,分批提交,每批 1000 条,注意控制事务粒度,避免长事务。如果数据量更大或需要极速导入,可以考虑数据库自带的批量加载工具(如 MySQL 的 LOAD DATA INFILE),或者使用 Spring Batch 的分块处理。JPA 的 saveAll 不适合这个场景,因为实体状态管理会带来大量开销。 ## 06、洞见 好的架构不是只使用一个工具,而是保持统一原则下的合理多样性。这句话的重点不是“多样性”,而是“统一原则”。很多人误解为可以随意引入各种数据访问技术,导致项目变成大杂烩。实际上,多样性是在统一原则约束下的:所有数据访问必须通过统一的仓库层接口暴露,事务边界在服务层统一控制,异常转换统一处理,日志和监控统一埋点。 订单项目里,我们允许 JPA、JdbcClient、jOOQ 并存,但要求所有数据访问都封装在 repository 包内,对外暴露的是领域仓库接口,而不是具体实现。这样上层服务完全感知不到底层用的是哪种工具,切换或优化时不影响业务逻辑。统一原则提供秩序,多样性提供效率,二者缺一不可。 ## 07、行动 如果现在就让你为订单项目落地这套方案,可以按以下步骤操作。 第一步,梳理项目现有的数据访问场景,分成四类:简单 CRUD、动态查询、统计报表、批量写入。逐一标注当前的实现方式和性能表现。 第二步,为每一类场景制定默认方案和退出条件。比如: - 简单 CRUD:默认 JpaRepository;退出条件:单表超过 20 个字段且大部分查询只取几个字段,启用 Projection。 - 动态查询:默认 Specification;退出条件:拼接代码超过 100 行、需要子查询/窗口函数/CTE、关联表超过 4 张,切换到 JdbcClient 或 jOOQ。 - 统计报表:默认 JdbcClient + 原生 SQL;退出条件:报表需要实时且频繁,考虑物化视图或预聚合表;极其复杂的多源合并,考虑引入 jOOQ 保持可维护性。 - 批量导入:默认 JdbcTemplate batchUpdate;退出条件:数据量超过 50 万或需要事务内部分批,使用 Spring Batch 或数据库批量加载工具。 第三步,把这些规则写进团队的数据访问规范,并在代码评审中检查。尤其要关注那些“用 Specification 硬写复杂查询”的代码,推动及时切换到更合适的工具。 第四步,定期回顾,根据实际性能和开发效率微调退出条件的阈值。 ## 08、小结 回到开头那个 43 秒的报表接口,我们把实现改成 JdbcClient 执行聚合 SQL,加了合适索引后,响应时间降到 800 毫秒。团队也慢慢接受了“JPA 不是银弹”的想法。真正掌握 JPA,不是把它用到极致,而是知道它的边界在哪里。工具梯度提供了一个清晰的决策路径,让团队从“非此即彼”的争论中解脱出来,把精力放回业务本身。 ## 09、链接与概念说明 本文提到的几个关键概念说明如下: - JPA:Java Persistence API,一套 ORM 标准,Hibernate 是其最常用实现,提供实体映射和持久化管理。 - Spring Data JPA:Spring 生态中简化 JPA 使用的模块,通过 Repository 接口自动实现数据访问。 - Projection:在 Spring Data JPA 中只查询实体的部分属性,可以用接口或 DTO 投影,减少数据加载。 - Specification:一种基于 Criteria API 的动态查询封装,可以按条件组合查询谓词。 - Native SQL:直接使用数据库方言 SQL 执行查询,绕过 ORM 生成 SQL 的优化限制。 - JdbcClient:Spring 6.1 引入的轻量级 JDBC 封装,提供流畅的 SQL 执行和结果映射。 - JdbcTemplate:Spring 经典的 JDBC 操作模板,简化资源管理和异常处理。 - jOOQ:一个 Java 数据库访问库,通过 DSL 生成类型安全的 SQL,适合复杂查询。 建议进一步阅读各工具的官方文档,尤其是 jOOQ 的“为什么不用 JPA”章节,以及 Spring Data JPA 的投影和规范查询部分。

优秀的个人博客,低调大师

LiteAPI 轻量落地:lite-boot × Vben Admin 的务实组合

为什么选 LiteAPI +Vben Admin 工程化到位:基于Vue 3 + Vite + TypeScript,内置动态路由、权限校验、多环境配置、主题与国际化,拿来即用,减少脚手架搭建与配置成本。 颜值在线:布局清爽、交互一致,表格与表单组件齐全,支持暗黑/明亮主题切换,适合对外观与效率都有要求的团队。 权限灵活:支持前端控制 / 后端控制 / 混合模式,路由守卫与菜单自动联动,按钮级权限也能轻松落地。 生态活跃:文档与示例丰富,社区更新快,遇到问题容易找到参考与解决方案。 开箱即用的对接要点 接口约定:统一用RESTful,返回结构保持统一。 本地开发:Vite 代理到后端地址,环境变量设置VITE_GLOB_API_URL=/api,联调无需改业务代码。 登录与会话:登录成功拿到token,Axios 拦截器自动注入;支持多标签页、KeepAlive、登录态过期自动跳转。 菜单模式:先用静态路由跑通,再平滑切换到后端动态菜单,权限变更无需前端发版。 表格与表单:列表用分页+搜索表单,新增/编辑用弹窗表单,字段校验用rules,统一错误与成功提示。 功能落地清单 组织与权限 组织机构 机构管理 部门管理 岗位管理 用户管理 审计与运维 日志管理 登录日志 操作日志 配置中心 导航管理 系统参数分类 系统参数 配置中心 🚀 快速体验 访问我们的在线演示地址立即体验全新版本的功能! 5 步跑通第一个模块 建表与后端接口:以“用户管理”为例,准备分页查询/新增/编辑/删除接口,统一返回{ code, data, message }。 页面骨架:复用 Vben 的CRUD 模板,替换接口地址与字段,表单用rules做校验。 列表与分页:接入分页表格与搜索区,支持重置与导出。 登录与权限:登录后保存token,Axios 拦截器注入;菜单先用静态,后续切到后端动态。 日志与配置:登录/操作日志列表展示与筛选;参数配置键值对管理。

资源下载

更多资源
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题,腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构,目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称,一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux

Rocky Linux(中文名:洛基)是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版,作为CentOS稳定版停止维护后与RHEL(Red Hat Enterprise Linux)完全兼容的开源替代方案,由社区拥有并管理,支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性,采用模块化包装和SELinux安全架构,默认包含GNOME桌面环境及XFS文件系统,支持十年生命周期更新。

Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能,例如代码缩略图,Python的插件,代码段等。还可自定义键绑定,菜单和工具栏。Sublime Text 的主要功能包括:拼写检查,书签,完整的 Python API , Goto 功能,即时项目切换,多选择,多窗口等等。Sublime Text 是一个跨平台的编辑器,同时支持Windows、Linux、Mac OS X等操作系统。

用户登录
用户注册