06.8.3.2 DAO、迁移与性能优化
所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.8 Kotlin 后端 / 06.8.3 Exposed 与数据访问
本节要解决的问题
本节聚焦 Exposed 0.5x 的 DAO API、实体生命周期、锁与审计字段、Flyway/Liquibase 协作迁移,以及 N+1、批量写入、分页游标、慢查询与连接池等性能话题。DSL 查询构建、事务边界与连接池基础已在 06.8.3.1 覆盖,本篇不复述;版本敏感的 API 命名在 0.4x→0.5x 可能调整,涉及处标注「待确认」并给出验证点。
06.8.3.2-001 Exposed 的 DAO API 与 DSL API 各自定位是什么?
一句话结论
DSL 是类型安全的表表达式与查询构建器,面向「写 SQL 结构」;DAO 是把表映射成实体类、按对象引用操作的轻量 ORM,面向「按领域对象存取」。两者可以在同一事务内混用。
概念解释
DSL 层直接用 Table 子类与 Query 表达式描述 select/insert/update/delete,结果以行或投影返回;DAO 层在 DSL 之上提供 Entity 子类、EntityClass 伴随对象与实例方法,实体属性对应表列,读取关联时再触发查询。Exposed 不做自动关联预加载,也没有 JPA 那样的一级/二级缓存体系。
原理流程
- 表定义同时被 DSL(列表达式)和 DAO(实体属性映射)复用。
- DAO 查询入口在伴随对象上(
findById、find、all),内部仍构造 DSL 查询并把结果行装配成实体。 - 修改实体属性后,提交事务时按脏状态生成 update。
- 需要聚合、join 投影或批量统计时,通常回到 DSL 写表达式。
代码或图示
// DSL:直接拿投影
val rows = Users.select { Users.age greaterEq 18 }.map { it[Users.name] }
// DAO:拿实体对象
val user = transaction { UserEntity.findById(1) }
user?.let { it.name = "new"; it.flush() }
常见误区
- 以为 DAO 像 JPA/Hibernate 一样有完整缓存与关联预加载:Exposed DAO 只在事务内做实体复用,跨事务不缓存。
- 以为两套 API 不能同时出现:允许混用,但同一写入路径建议统一风格,避免脏状态认知不一致。
追问
- 什么场景优先选 DSL?答:多表 join、聚合统计、动态条件、避免实体装配开销的读路径。
- 什么场景优先选 DAO?答:写路径以单实体增删改为主、对象结构清晰的业务模块。
06.8.3.2-002 IntIdTable、LongIdTable、UUIDTable 怎么选型?
一句话结论
主键自增整数用 IntIdTable,自增长整数用 LongIdTable,分布式无自增需求或对外暴露标识用 UUIDTable;选型主要看主键生成策略、索引体积与是否需要不可枚举的对外 ID。
概念解释
三类表分别把主键列类型固定为 Int、Long、UUID,对应实体基类为 IntEntity、LongEntity、UUIDEntity。自增主键由数据库生成,UUID 通常由应用层生成后写入。整数主键索引体积小、B+ 树紧凑,UUID 索引离散写入更容易产生页分裂。
原理流程
- 表继承对应 IdTable,主键列由基类提供,名为
id。 - 实体
EntityID<ID>包装主键值,外键引用其他实体时保存entityId。 - 新建实体时自增列在 insert 后回填;UUID 表在
new块内赋值或由默认生成策略处理(具体默认行为待确认,以 0.5x 文档为准)。
代码或图示
object Users : LongIdTable("users") {
val name = varchar("name", 100)
}
class UserEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<UserEntity>(Users)
var name by Users.name
}
常见误区
- 对外暴露自增 ID 导致可枚举爬取:敏感实体应使用 UUID 或对外代理 ID。
- 用 UUID 做主键却又建大量二级索引:需评估索引体积与写入放大。
追问
- 外键列怎么声明?答:
reference("manager_id", Users),保存的是被引用实体的entityId。 - 已有 int 主键的表能否后期换 UUID?答:属于 schema 演进,需新增列、回填、切读再切写,不能在线直接改主键类型。
06.8.3.2-003 DAO 实体类的基本结构与构造约束是什么?
一句话结论
实体继承对应 *Entity 基类,伴随对象继承 *EntityClass 并绑定表,属性用 by 表.列 委托;构造函数接收 EntityID,不要在业务代码里直接 new 实体。
概念解释
实体属性委托把读操作映射到当前实体行的列值,写操作标记实体脏状态。伴随对象既是查询工厂也是元数据持有者,Exposed 通过它把结果行装配为实体。实体必须在事务内被读取和修改,脱离事务后访问未加载属性的行为需结合具体实现判断(待确认)。
原理流程
- 表定义列。
- 实体类声明
var x by 表.x,委托由 Exposed 生成读写桥。 - 伴随对象
EntityClass负责new、find、findById等入口。 - 插入走
new { ... }块,删除走实体delete(),更新走属性赋值加flush或事务提交。
代码或图示
class OrderEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<OrderEntity>(Orders)
var status by Orders.status
var amount by Orders.amount
}
transaction {
OrderEntity.new { status = "PAID"; amount = 99 }
}
常见误区
- 在实体类主构造里写业务逻辑:实体应是薄的数据载体,业务规则放 Service。
- 直接调用实体构造函数创建实例:绕过
new不会走插入流程。
追问
- 实体能加自定义方法吗?答:可以加派生方法或只读计算属性,但不要在其中直接触发远程调用。
- 实体属性必须是 var 吗?答:表列需要可写时用 var;只读映射可用 val,但与插入流程的兼容性需按文档验证(待确认)。
06.8.3.2-004 entityCache 是什么,生命周期到哪里?
一句话结论
DAO 在一次事务内维护实体缓存:同一主键多次加载返回同一实例,避免事务内重复装配;缓存随事务结束释放,不跨事务、不充当二级缓存。
概念解释
在事务边界内,Exposed 把已加载实体按主键登记,再次 findById 命中缓存时直接返回实例,保证事务内对象身份一致。缓存条目、是否按表隔离以及显式清理 API 的名称在 0.5x 需对照官方文档确认(待确认),不要把它理解为应用级 L2 缓存。
原理流程
- 进入事务时创建事务级实体上下文。
- 查询装配实体前先查缓存,命中则复用。
- 未命中则执行 SQL 并登记。
- 事务提交或回滚后缓存随上下文丢弃。
代码或图示
transaction {
val a = UserEntity.findById(1)
val b = UserEntity.findById(1)
// a === b 在同一事务内成立
}
常见误区
- 把事务内缓存当应用级缓存长期持有:跨请求拿到的实体可能已与库不一致。
- 以为缓存会自动同步外部修改:其他事务改库后,本事务缓存仍返回旧实例。
追问
- 长事务里缓存堆积怎么办?答:缩短事务边界,大结果集走 DSL 流式读取,不要在长事务中加载大批实体。
- 需要跨请求缓存用什么?答:接入 Redis 或本地缓存组件,而不是依赖 Exposed 实体缓存。
06.8.3.2-005 DAO 的 findById、find、all 查询入口怎么用?
一句话结论
findById 按主键取单条,find { 表达式 } 按 DSL 条件取实体序列,all() 取全表实体;三者都在伴随对象上调用,且必须位于事务内。
概念解释
findById 返回可空实体;find 接收 Table 列表达式谓词,返回 EntityResult 风格的惰性序列;all 无过滤条件。结果装配是惰性还是即时取决于调用终止操作,遍历时才真正物化。
原理流程
- 伴随对象把方法调用转成 DSL 查询。
- 查询执行后逐行映射为实体并登记到事务缓存。
- 单条结果为空时返回 null;多条结果按序列返回。
- 调用方在事务内读取属性,离开事务后行为需谨慎(待确认跨事务属性访问是否报错)。
代码或图示
transaction {
val one = UserEntity.findById(42L)
val adults = UserEntity.find { Users.age greaterEq 18 }
val all = UserEntity.all()
adults.map { it.name }
}
常见误区
- 在事务外调用
findById后再访问属性:连接已归还,行为不可靠。 - 对
all()不加分页直接全量遍历:大表会把结果集一次性拉进内存。
追问
- 条件复杂时
find写不下怎么办?答:复杂多表或聚合走 DSL 查询,结果再按需装配。 - 怎么判断结果是惰性的?答:以返回类型与终止操作为准,避免链式中间操作触发全表加载;具体惰性语义以 0.5x 实现为准(待确认)。
06.8.3.2-006 DAO 与 DSL 混用时要注意哪些边界?
一句话结论
混用是允许的,共享同一表定义与事务连接;要注意的是脏状态一致性:DAO 实体的未提交修改与 DSL 直接写库语句在同一事务内的可见性,以及退出事务前刷新顺序。
概念解释
DSL 的 update/delete 直接下发 SQL,不经过实体脏检查;DAO 的赋值先改内存实体,提交或 flush 时生成 update。同一事务内先改实体再执行 DSL 写语句,可能出现 DSL 语句先落库、实体脏值后覆盖的顺序问题。
原理流程
- 两者复用同一
Table元数据与同一事务连接。 - DAO 修改进入实体脏集合;DSL 语句即时排队执行。
- 提交时按 Exposed 内部顺序刷脏(具体刷脏时机待确认)。
- 混用时建议一条业务路径只选一种风格,需要交叉时先
flush再执行 DSL。
代码或图示
transaction {
val u = UserEntity.findById(1)!!
u.name = "A"
u.flush() // 先落实体改动
Users.update({ Users.id eq 1 }) { it[Users.name] = "B" } // 再走 DSL
}
常见误区
- 以为改完实体后 DSL 能看到内存新值:DSL 语句直接打库,不读实体内存。
- 混用导致同一行被两套逻辑重复更新,排查困难。
追问
- 项目里怎么统一?答:写路径用 DAO 表达业务对象,读路径报表类查询用 DSL,边界在 Repository 收口。
- 混用会破坏事务吗?答:不会破坏事务边界,但会增加顺序与一致性认知成本。
06.8.3.2-007 Exposed DAO 的脏检查是怎么实现的?
一句话结论
实体属性委托在赋值时记录被修改的列,事务提交(或显式 flush)时只为脏列生成 update;未变化的属性不会进 update 语句。
概念解释
每个委托属性在实体内部保存当前值与脏标记。读取委托返回当前值,写入委托更新值并标记对应列脏。Exposed 提交时遍历脏列生成 UPDATE ... SET ... WHERE id = ?。具体脏集合数据结构与是否支持列级脏追踪,以 0.5x 源码为准(待确认)。
原理流程
- 实体装配时列值从结果行写入。
- 属性赋值委托把列加入脏集合。
flush或提交时对有脏列的实体生成 update。- 无脏列的实体不产生 update 语句。
代码或图示
transaction {
val u = UserEntity.findById(1)!!
u.name = "renamed" // 标记 name 脏
// 提交时仅更新 name 列
}
常见误区
- 每次赋值都认为会全列 update:实际只更新脏列。
- 把外部对象(列表、Map)原地修改后期望被追踪:引用类型内部变更不会自动触发脏标记。
追问
- 引用类型字段怎么感知内部变更?答:整体重新赋值,或在应用层标记;数组/集合列需整体替换。
- 想强制刷新实体状态怎么做?答:重新
findById或在事务内重新加载,具体刷新 API 名称待确认。
06.8.3.2-008 DAO 的插入、更新、删除分别走什么入口?
一句话结论
插入用伴随对象 new { } 块;更新直接给实体属性赋值;删除调用实体 delete();批量场景可结合 DSL 的 batchInsert。
概念解释
new 块内完成字段赋值后立即登记待插入实体,事务提交时执行 insert。更新在实体上赋值,删除在实体上调用方法。DAO 没有显式 save() 二义性方法,新增与修改入口分离。
原理流程
new创建未持久化实体,块内赋值。- 提交时实体进入 insert 流程并回填主键。
- 已加载实体属性赋值进入脏集合,提交生成 update。
delete()登记删除,提交执行DELETE。
代码或图示
transaction {
val u = UserEntity.new { name = "tom"; age = 20 }
u.age = 21 // 更新
// u.delete() // 删除
}
常见误区
- 以为
new后立即拿到数据库生成的自增主键:主键回填时机与 flush 时机相关,跨步骤使用前需确认(待确认)。 - 在事务外调用
delete():没有连接上下文,无法执行。
追问
- 批量插入为什么不循环
new?答:循环new每条一次 insert;大批量走 DSLbatchInsert减少往返。 - 删除被外键引用的实体怎么办?答:先处理子表或依赖数据库外键策略,违反约束会抛数据库异常。
06.8.3.2-009 实体生命周期有哪几个状态?
一句话结论
可粗略分为新建未持久化、已加载持久化、脏已修改、已删除四种状态;Exposed 没有像 JPA 那样开放标准化的状态枚举,状态由实体内部标记与数据库行共同决定。
概念解释
新建来自 new,尚未 insert;已加载来自查询,与库中行对应;脏表示属性被修改待 flush;已删除表示 delete() 已调用。状态迁移发生在事务内,事务回滚后内存实体与库的对应关系需要重新加载。
原理流程
new→ 新建状态。- 提交 insert 后 → 持久化状态。
- 赋值 → 脏状态。
delete()→ 待删除,提交后行移除。
代码或图示
transaction {
val u = UserEntity.new { name = "x" } // 新建
u.name = "y" // 脏
u.delete() // 待删除
}
常见误区
- 事务回滚后继续使用旧实体:内存对象仍是旧状态,不能代表回滚后的数据库。
- 跨事务持有实体引用并继续修改:脱离事务上下文不可靠。
追问
- 怎么把实体重新与库对齐?答:在新事务内重新查询加载。
- 实体状态能对外暴露吗?答:领域层应转换为 DTO,不要把内部实体状态泄漏到接口层。
06.8.3.2-010 引用其他实体时 entityId 与实体引用有什么区别?
一句话结论
外键列保存的是被引用实体的 EntityID(值对象),通过引用属性拿到的是实体对象;访问实体对象才会触发关联查询,直接拿 entityId 不触发额外 SQL。
概念解释
表上 reference("manager_id", Users) 在外键列存主键值;实体侧属性类型为被引用实体。Exposed 不会自动 join 预加载,第一次访问引用实体时按外键值查询,这是 N+1 的主要来源之一。
原理流程
- 本实体行加载时外键值已读入。
- 访问
entity.manager时按entityId查询被引用实体。 - 被引用实体在当前事务缓存中命中则复用。
- 仅需要 ID 时直接读
entity.managerId一类属性(属性命名以表定义为准,待确认)。
代码或图示
class EmployeeEntity(id: EntityID<Long>) : LongEntity(id) {
companion object : LongEntityClass<EmployeeEntity>(Employees)
var manager = reference<EmployeeEntity>("manager_id", Employees)
}
常见误区
- 遍历列表时逐个访问
manager,每条触发一次 select,形成 N+1。 - 以为引用属性在加载主实体时一起 join 出来。
追问
- 想避免 N+1 怎么办?答:先收集外键值,批量
find { id inList ids }后在内存拼装,或改 DSL join 投影。 - 外键值为 null 怎么表达?答:
reference(...).nullable(),引用属性可空。
06.8.3.2-011 一对多关联在 DAO 层怎么表达?
一句话结论
一对多没有直接的集合导航属性:一方实体持有多个外键指向它的子实体,访问时用子表伴随对象按父 ID 查询;需要集合视图在应用层拼装。
概念解释
Exposed DAO 不提供 val children: List<Child> 这样的自动集合映射。父实体加载后,子列表通过 Child.find { Child.parentId eq parent.id } 获取。结合事务缓存可减少重复查询,但仍是显式查询。
原理流程
- 父实体加载。
- 业务代码按父 ID 查询子表。
- 子实体装配后在内存组成集合返回。
- 多父实体场景先批量取子表再分组,避免循环查询。
代码或图示
val orders = OrderEntity.find { Orders.userId eq user.id }
val orderItems = OrderItemEntity.find { OrderItems.orderId inList orders.map { it.id } }
.groupBy { it.orderId }
常见误区
- 期望声明一个集合属性就自动加载全部子实体。
- 循环内按父 ID 查子表,放大成 N+M。
追问
- 复杂关联读路径推荐什么?答:DSL join 直接投影成只读 DTO,不经过实体导航。
- 子表数据量大怎么办?答:分页按父维度查询,不要一次性拉全量子集合。
06.8.3.2-012 DAO 实体为什么不建议直接作为 API 响应返回?
一句话结论
实体携带持久化状态、委托属性与可能的懒加载引用,直接序列化容易触发懒查询、暴露内部字段,还会把数据库结构耦合到对外契约;应在边界转换为 DTO。
概念解释
JSON 序列化器遍历属性时可能访问尚未加载的引用实体,触发额外 SQL 或在事务外报错;实体字段名与库列耦合,表结构改动会直接影响接口。领域对象与传输对象分离也便于做版本演进与字段裁剪。
原理流程
- Controller 拿到实体。
- 序列化器反射访问属性,懒引用触发查询。
- 内部字段、审计字段一并被带出。
- 表结构变更外溢为接口变更。
代码或图示
data class OrderDto(val id: Long, val status: String, val amount: Int)
fun OrderEntity.toDto() = OrderEntity... // 由映射层逐字段转换
常见误区
- 为省事让序列化直接输出实体,后期脱敏与字段裁剪无处下手。
- 在实体上加序列化注解,把持久层模型当成 API 模型维护。
追问
- 映射手写还是用框架?答:字段简单可手写,字段多可考虑 MapStruct 等映射方案;Kotlin data class 与实体字段对齐时注意可空性。
- 实体能转成领域模型吗?答:可以,Repository 出口返回领域模型,实体只留在数据层。
06.8.3.2-013 可空列在实体属性上怎么映射?
一句话结论
表列声明 .nullable() 后,实体对应属性类型为可空 T?;非空列映射为非空 T,插入时未赋值会在数据库或框架层报错(以实际校验为准,待确认)。
概念解释
可空性由表列定义决定,实体委托按列类型推导。插入 new 块内非空列必须赋值,否则提交时数据库约束拦截。可空属性读取得到 null,不要在业务层强制非空断言。
原理流程
- 表定义列是否可空。
- 实体委托类型与列一致。
- insert/update 按值类型绑定参数。
- 数据库 NOT NULL 约束作为最后防线。
代码或图示
object Users : LongIdTable("users") {
val nickname = varchar("nickname", 100).nullable()
}
class UserEntity(id: EntityID<Long>) : LongEntity(id) {
var nickname: String? by Users.nickname
}
常见误区
- 列可空而属性写成非空,读取 null 时空指针风险上移到业务层。
- 把可空业务字段误建成非空,后续补数据困难。
追问
- 布尔可空与默认值怎么处理?答:列上给默认值,实体层按非空设计;历史 null 数据先回填。
- 枚举可空映射见后续题目。
06.8.3.2-014 枚举列怎么映射到 Kotlin enum?
一句话结论
Exposed 提供枚举列辅助把数据库字符串或整数列映射为 Kotlin enum class;存储类型(name 还是 ordinal)要在表定义时明确,避免换序导致语义错位。
概念解释
常见做法是列声明为 varchar 再用枚举转换函数绑定,或使用框架提供的 enumeration 类列辅助(辅助 API 名称在 0.5x 需对照文档确认,待确认)。按 name 存储可读性好,按 ordinal 存储体积小但枚举顺序调整会错位。
原理流程
- 定义枚举类。
- 表列选择存储类型并声明转换。
- 实体属性类型为枚举,读写时在 name/ordinal 与库值之间转换。
- 未知枚举值反序列化时需要兜底策略。
代码或图示
enum class OrderStatus { PAID, SHIPPED, CLOSED }
object Orders : LongIdTable("orders") {
val status = varchar("status", 20)
}
// 实体侧读写时显式 valueOf / name 转换;枚举列辅助 API 以文档为准
常见误区
- 按 ordinal 存储后调整枚举顺序,历史数据语义错乱。
- 新增枚举值未同步数据库约束或校验,写入未知值。
追问
- 数据库有 CHECK 约束时怎么办?答:迁移脚本里定义 CHECK,应用层枚举与约束保持同步。
- 反序列化遇到旧值怎么处理?答:保留未知值通道(如兜底枚举或字符串字段),不要直接抛异常打断读路径。
06.8.3.2-015 乐观锁在 Exposed DAO 下怎么落地?
一句话结论
Exposed 0.5x 是否提供内置版本号注解待确认;常见落地是手动加 version 列,更新时在 WHERE 条件带上版本号并检查受影响行数,冲突后重试或报错。
概念解释
乐观锁假设冲突少见,提交时检查数据未被他人改过。手动方案:表存版本号,update 条件为 id = ? AND version = ?,成功后版本加一;受影响行数为 0 说明并发冲突。框架内置的 @Version 式能力在 Exposed 中未见等价标准实现,使用前需核实文档(待确认)。
原理流程
- 表增加
version整数列。 - 读取实体时拿到当前版本。
- 更新语句带旧版本号条件。
- 影响行数 0 → 抛并发冲突,上层决定重试或返回提示。
代码或图示
val updated = Orders.update({ Orders.id eq id and (Orders.version eq currentVersion) }) {
it[status] = nextStatus
it[version] = currentVersion + 1
}
if (updated == 0) throw ConcurrentModificationException("order $id modified")
常见误区
- 只在应用层比对象版本,不带进 WHERE 条件,并发下仍然覆盖写。
- 冲突后无限重试:需要最大重试次数与退避。
追问
- 什么场景用乐观锁?答:冲突概率低、读多写少的账户类更新。
- 高冲突场景呢?答:评估悲观锁或串行化业务分片。
06.8.3.2-016 悲观锁怎么在 Exposed 里使用?
一句话结论
悲观锁通过 SELECT ... FOR UPDATE 锁定命中行,在 Exposed 中可在 DAO 查询或 DSL 查询上指定锁类型;具体参数名称与方言支持在 0.5x 需对照文档确认(待确认)。
概念解释
事务内先锁定行再读取修改,其他事务阻塞等待或按锁策略跳过。适合强竞争下的资金扣减、库存扣减等必须串行化的短临界区。锁持有时间受事务长度影响,长事务会放大阻塞。
原理流程
- 事务开启,隔离级别确定锁语义。
- 查询时声明
FOR UPDATE,数据库对命中行加排他锁。 - 当前事务完成修改并提交,锁释放。
- 其他等待事务获得锁后继续。
代码或图示
transaction {
val stock = StockEntity.findById(skuId, lock = LockType.FOR_UPDATE) // 参数名待确认
?: error("stock not found")
stock.quantity = stock.quantity - 1
}
常见误区
- 把悲观锁用在长事务或跨 RPC 临界区,锁等待堆积。
- 误以为加了锁就不需要业务唯一性校验:约束与锁要配合。
追问
- 锁等待超时怎么配置?答:数据库方言层配置锁等待超时,应用层捕获超时异常并降级;Exposed 侧不单独管理锁等待。
- 不同数据库锁语法差异?答:
FOR UPDATE主流关系库支持,其他锁定语法以方言为准。
06.8.3.2-017 软删除怎么设计,查询时怎么统一过滤?
一句话结论
软删除用 deletedAt(或 isDeleted)列标记,不物理删除;查询入口统一带上未删除条件,可在 Repository 封装谓词或通过视图隔离。
概念解释
软删除保留历史数据便于审计与恢复,代价是唯一约束需要考虑已删除记录、查询条件必须处处带过滤。Exposed 没有全局软删除拦截器,过滤条件要在查询构造时显式加入;是否有可复用的 DSL 谓词扩展由团队封装。
原理流程
- 表增加可空时间戳列
deletedAt。 - 删除操作把当前时间写入该列,不执行物理 delete。
- 所有查询谓词追加
deletedAt isNull。 - 唯一索引在软删除场景需要拼接删除时间或使用部分唯一索引(方言支持)。
代码或图示
object Users : LongIdTable("users") {
val deletedAt = datetime("deleted_at").nullable()
}
val active = UserEntity.find { Users.deletedAt.isNull() }
常见误区
- 漏掉某个查询的删除过滤,把已删数据读出。
- 软删除后普通唯一索引冲突:同业务键多条已删记录无法再新建。
追问
- 部分唯一索引哪些数据库支持?答:PostgreSQL 支持部分索引;MySQL 5.x/8.0 不支持等价语法,需用生成列或业务键拼接方案,按方言确认。
- 软删除数据怎么归档?答:定期把历史记录迁到归档表,主表保持瘦身。
06.8.3.2-018 审计字段 createdAt、updatedAt 怎么自动填充?
一句话结论
常见做法是在表上声明时间戳列,插入与更新时在应用层统一赋值;也可借助数据库默认值与 ON UPDATE 机制。Exposed 本身不提供 JPA 式审计注解,自动填充需要团队封装(待确认 0.5x 是否有回调扩展点)。
概念解释
createdAt 只在插入时写一次,updatedAt 每次更新刷新。应用层方案在 Repository 基类或实体工厂里统一赋值;数据库方案靠列默认值与触发器/方言更新子句。两种方案不要混用导致值来源不一致。
原理流程
- 表声明两个时间戳列。
- 新建路径写入当前时间到两列。
- 更新路径刷新
updatedAt。 - 查询展示与审计问题排查时按时间字段追溯。
代码或图示
object Orders : LongIdTable("orders") {
val createdAt = datetime("created_at")
val updatedAt = datetime("updated_at")
}
OrderEntity.new {
createdAt = Clock.System.now()
updatedAt = createdAt
}
常见误区
updatedAt只在部分写路径刷新,排查变更时间不可信。- 用应用服务器本地时钟与数据库时钟混用,时间偏差导致排序错乱,统一用同一时钟源。
追问
- 操作人审计(创建人/修改人)怎么落?答:加用户 ID 列,在写入口从上下文带入;不要在实体里直接取请求上下文。
- 时钟用什么抽象?答:注入
Clock便于测试替换,避免直接调用系统时钟。
06.8.3.2-019 批量 upsert 在 Exposed 里怎么写?
一句话结论
按主键或唯一键冲突做 upsert,走 DSL 的 insert 冲突子句(onDuplicateUpdate 一类);DAO 循环 new 不具备批量冲突语义,大批量写入优先 DSL 批量语句。
概念解释
upsert 即存在则更新、不存在则插入,依赖唯一索引识别冲突。Exposed DSL 提供冲突更新表达,具体子句名称与列映射方式在 0.5x 以文档为准(待确认)。不同数据库方言在冲突子句语法上有差异。
原理流程
- 表上存在目标唯一索引。
- 批量 insert 携带多行。
- 冲突时按子句更新指定列。
- 受影响行数与冲突行为在方言层落地。
代码或图示
// 意图示例:冲突时更新名称与更新时间;子句 API 名称以 0.5x 文档为准
Products.batchInsert(list) { p ->
this[Products.sku] = p.sku
this[Products.name] = p.name
}.onDuplicateUpdate(Products.name to Products.name)
常见误区
- 没有唯一索引就指望 upsert:冲突识别依赖数据库唯一约束。
- 跨方言复用同一 upsert 写法,方言不支持时 SQL 报错。
追问
- upsert 与先查后写哪个好?答:并发下先查后写有竞态,upsert 靠数据库原子完成;但冲突更新策略要想清楚覆盖哪些列。
- 大批量 upsert 注意什么?答:分批提交、控制单批行数,避免长事务与大锁范围。
06.8.3.2-020 分页用 limit/offset 还是游标,各自代价是什么?
一句话结论
offset 分页实现简单但深页码扫描成本高;游标(keyset)按上一页最后值定位,深分页稳定,适合大数据量列表接口。
概念解释
limit n offset m 要求数据库扫描前 m+n 行再丢弃前 m 行,页码越深越慢。游标分页用上一页最后一条的排序键(如 ID 或 (createdAt, id) 组合)作为条件,直接定位起点,避免跳过大量行。游标要求排序键唯一且稳定。
原理流程
- offset:
SELECT ... ORDER BY id LIMIT n OFFSET m。 - 游标:
WHERE id < lastId ORDER BY id DESC LIMIT n。 - 排序键需唯一,避免同值翻页漏数据。
- 总数展示另走 count,或不展示总数。
代码或图示
// 游标:按 id 倒序,传入上一页最小 id
val page = Items.select { Items.id lessThan lastId }
.orderBy(Items.id to SortOrder.DESC)
.limit(pageSize)
常见误区
- 排序字段有重复值,游标翻页丢数据或重复。
- 深页码仍用 offset,接口 P99 随页码恶化。
追问
- 需要跳页(第 1、10、100 页)怎么办?答:offset 只适合浅页;深跳页通常用搜索条件收敛结果集,或产品上限制页码范围。
- 总数 count 慢怎么办?答:见后续 count 性能题目。
06.8.3.2-021 N+1 问题在 DAO 层怎么定位和消除?
一句话结论
N+1 指先查 N 条主记录,再循环逐条查关联,产生 1+N 次 SQL;定位靠开启 SQL 日志数语句数,消除靠批量预取后内存拼装或 DSL join 投影。
概念解释
DAO 导航属性默认不预加载,遍历列表访问关联就逐条查询。典型表现是接口返回几十条数据却执行几百条 SQL。批量预取先收集外键值,一次 inList 查出全部关联,再按 ID 分组拼装。
原理流程
- 打开 SQL 日志,观察一次请求内 select 条数。
- 定位循环内访问的引用属性。
- 收集父实体外键集合。
- 批量查询子实体并分组,业务层组装。
代码或图示
val users = UserEntity.all().limit(50).toList()
val ids = users.map { it.id }
val orders = OrderEntity.find { Orders.userId inList ids }.groupBy { it.userId }
val view = users.map { it to orders[it.id].orEmpty() }
常见误区
- 只优化主查询,忽略循环内关联查询。
- 批量预取时
inList集合过大,单条 SQL 条件过长,需分批。
追问
- 一对多层级联预取怎么做?答:逐层批量查询并在内存建树,控制层级深度。
- 怎么在代码评审里卡住 N+1?答:禁止在循环内做 Repository 调用,关联读取在出口一次性组装。
06.8.3.2-022 慢查询怎么定位?
一句话结论
先开 SQL 日志拿到完整语句与参数,再到数据库执行 EXPLAIN 看扫描行数、访问类型与索引命中;结合接口耗时分布判断是 SQL 慢还是连接等待慢。
概念解释
慢查询来源包括缺索引、索引失效、回表过多、join 顺序差、大事务与锁等待。Exposed 侧能拿到生成 SQL 与参数,执行计划由数据库解释。应用日志要记录耗时、SQL 指纹与关键参数(脱敏后)。
原理流程
- 应用日志或数据库慢日志捕获耗时 SQL。
- 复制语句与参数到库内
EXPLAIN。 - 检查 type/rows/key/Extra,定位全表扫描或文件排序。
- 补索引或改写查询,复测执行计划。
代码或图示
EXPLAIN SELECT id, name FROM users WHERE status = 'ACTIVE' ORDER BY created_at DESC LIMIT 20;
-- 关注:是否命中索引、rows 扫描量、是否 Using filesort / Using temporary
常见误区
- 只看接口超时,不区分是等待连接、应用处理还是数据库执行慢。
- 盲目加索引,不评估写入放大与索引重复。
追问
- Exposed 怎么打印 SQL?答:通过框架或连接池的日志配置开启语句输出,具体 logger 名称与开关以 0.5x 文档为准(待确认)。
- 慢 SQL 复现不了怎么办?答:抓生产执行计划快照、统计信息与数据量差异,在预发造同规模数据复现。
06.8.3.2-023 索引设计在 Exposed 表定义里怎么声明?
一句话结论
表定义中通过索引声明辅助方法声明普通索引、唯一索引与组合索引;线上真实索引以迁移脚本为准,表定义与迁移必须保持一致。
概念解释
Exposed 表定义可以描述索引元数据,用于文档化或 SchemaUtils 建表;生产环境通常由 Flyway/Liquibase 迁移脚本管理 DDL。组合索引列顺序遵循最左前缀,唯一索引兜底业务唯一约束。索引声明 API 的方法名在 0.5x 需对照文档确认(待确认)。
原理流程
- 分析查询条件、排序、分组字段。
- 按等值在前、范围在后设计组合列顺序。
- 在表定义与迁移脚本同步声明。
- 上线后用执行计划验证命中。
代码或图示
object Orders : LongIdTable("orders") {
val userId = long("user_id")
val status = varchar("status", 20)
val createdAt = datetime("created_at")
// 索引声明 API 名称以文档为准;迁移脚本中同步 CREATE INDEX
index("idx_user_status", userId, status)
}
常见误区
- 索引列顺序与查询条件不匹配,最左前缀失效。
- 重复索引、冗余索引无人清理,拖慢写入。
追问
- 回表成本高怎么办?答:高频覆盖查询考虑覆盖索引,把 select 列纳入索引;评估索引体积。
- 唯一索引与普通索引怎么选?答:业务唯一性用唯一索引兜底,仅加速查询用普通索引。
06.8.3.2-024 连接池参数怎么配合 DAO 使用?
一句话结论
连接池决定并发可用连接数,DAO 每次事务从池借连接;池大小、空闲回收、连接超时与事务超时需要按数据库承载能力和业务并发共同设定,不是越大越好。连接池基础配置在 06.8.3.1 已覆盖,本篇只讲与 DAO/事务相关的配合点。
概念解释
池过小导致请求排队等连接,池过大压垮数据库并增加上下文切换。常用 HikariCP,关键参数包括最大池大小、最小空闲、连接生命周期、空闲超时、获取连接超时。DAO 事务持有连接期间不释放,事务长度直接占用连接。
原理流程
- 请求进入事务,从池借连接。
- 事务内所有 DAO/DSL 复用该连接。
- 事务提交或回滚后归还连接。
- 池监控活跃连接、等待线程与超时计数。
代码或图示
// 参数名与配置方式以 HikariCP / Exposed 连接配置为准(待确认当前 API)
Database.connect(
url = jdbcUrl,
driver = driverClassName,
pool = hikari {
maximumPoolSize = 20
minimumIdle = 5
connectionTimeout = 30_000
}
)
常见误区
- 把池大小设成与 CPU 核数无关的大数,数据库连接数被打满。
- 事务里夹杂 RPC、sleep,连接被长时间占用。
追问
- 池大小经验值?答:结合数据库最大连接数、实例数与事务耗时压测确定,不套用固定公式。
- 等连接超时报什么错?答:连接池获取超时异常,与 SQL 执行超时要区分排查。
06.8.3.2-025 事务超时怎么设置,超时后行为是什么?
一句话结论
事务超时限制事务整体持有时长,超时后中断当前操作并回滚;可在事务声明处或数据库/池层配置,具体配置入口在 0.5x 需对照文档确认(待确认)。
概念解释
事务超时防止长事务长时间持锁与占用连接。超时触发后未提交的修改回滚,连接归还。应用层需要区分超时异常与普通业务异常,决定重试还是快速失败。事务隔离级别与传播行为基础见 06.8.3.1。
原理流程
- 事务开始记录起点。
- 执行中超过阈值,框架或数据库终止语句。
- 回滚未提交变更。
- 异常向上抛出,上层处理。
代码或图示
transaction(transactionIsolation = DbIsolationLevel.READ_COMMITTED) {
// 事务超时配置按连接池/框架能力设置,具体入口待确认
UserEntity.findById(1)
}
常见误区
- 超时后误以为已提交:必须以回滚结果为准。
- 把 RPC 调用放进数据库事务,超时被外部响应拖长。
追问
- 哪些操作必须留在事务内?答:多行读写一致性要求的操作;只读计算、外部通知移出事务。
- 事务超时与语句超时区别?答:语句超时控制单条 SQL,事务超时控制整体事务,两者层级不同。
06.8.3.2-026 只读事务与只读连接怎么用?
一句话结论
明确只读的路径声明只读事务,数据库可据此做优化(如避免 undo 准备、路由只读副本);Exposed 事务配置与连接路由能力以当前版本文档为准(待确认)。
概念解释
只读事务不产生写意图,部分数据库与驱动允许把只读连接路由到从库。声明只读也是一种意图约束:代码评审时可阻止只读路径误写。只读副本延迟带来的读一致性问题需要业务评估。
原理流程
- 业务方法标注只读语义。
- 事务开启时设置只读标志。
- 连接池/路由层选择只读连接。
- 路径内出现写操作时按策略报错或告警。
代码或图示
// 只读标志的设置 API 以 0.5x 文档为准(待确认)
transaction {
// 仅查询,不产生写入
UserEntity.find { Users.status eq "ACTIVE" }.map { it.name }
}
常见误区
- 只读路径里夹带缓存回填、发消息等副作用,破坏只读假设。
- 只读副本延迟敏感场景(刚写后读)误用从库。
追问
- 读写分离在应用层怎么做?答:按事务语义路由数据源,写走主库,只读走从库;具体多数据源配置见 06.8.3.1。
- 只读事务能跑 DDL 吗?答:不能,DDL 走迁移流程,不在业务事务内。
06.8.3.2-027 多数据源下 DAO 实体怎么绑定数据源?
一句话结论
每个数据源对应独立 Database 连接实例,事务在指定连接上开启;表与实体不绑定数据源,DAO 操作使用当前事务连接。多数据源路由与基础配置在 06.8.3.1 覆盖,这里讲实体侧注意点。
概念解释
Exposed 表定义是元数据,真正的连接由当前事务上下文决定。切换数据源意味着切换事务绑定的 Database 实例。跨数据源的实体不能在同一事务里直接关联查询,分布式一致性需另设计。
原理流程
- 初始化多个
Database连接。 - 业务路径选择目标数据源开启事务。
- 事务内 DAO/DSL 使用该连接。
- 跨库关联在应用层聚合。
代码或图示
transaction(db = orderDatabase) {
OrderEntity.findById(id)
}
常见误区
- 以为表声明时指定了数据库实例。
- 在一个事务里访问两个数据源的表,连接与事务语义混乱。
追问
- 跨库数据一致性怎么办?答:避免强一致跨库事务,用业务补偿、事件最终一致;必要时评估分库边界。
- 数据源路由放哪一层?答:在 Service 入口或 Repository 工厂层决定,不在实体内部判断。
06.8.3.2-028 Flyway 与 Exposed 怎么协作?
一句话结论
生产 schema 由 Flyway 迁移脚本管理版本演进,Exposed 只做运行时 ORM 映射;应用启动时先执行 Flyway migrate,再初始化 Exposed 连接,不要让 Exposed 自动建表。
概念解释
Flyway 用版本化 SQL 脚本管理 DDL,可追溯、可回滚评估;Exposed 的 SchemaUtils.createMissingTablesAndColumns 适合本地开发。两套机制并存时,以迁移脚本为准,表定义保持与脚本一致。脚本命名、位置与基线配置按 Flyway 约定。
原理流程
- 启动阶段 Flyway 连接数据库,按版本顺序执行未应用脚本。
- 迁移完成后 Exposed 连接初始化。
- DAO/DSL 操作既有 schema。
- 表结构变更先写迁移脚本,再调整 Exposed 表定义。
代码或图示
db/migration/
V1__init_users.sql
V2__add_user_nickname.sql
V3__create_orders.sql
常见误区
- 开发库用自动建表、生产用迁移,两套 schema 漂移。
- 修改已执行的迁移脚本:Flyway 校验失败,新增脚本而不是改旧脚本。
追问
- 迁移脚本在测试环境怎么跑?答:集成测试启动时自动 migrate 到最新 schema,保证测试与结构一致。
- Flyway 失败怎么排查?答:查
flyway_schema_history与报错脚本,修复后重试;失败脚本不要反复改版本号绕过校验。
06.8.3.2-029 Liquibase 与 Exposed 协作方式与 Flyway 有何不同?
一句话结论
Liquibase 用 changeset(SQL/XML/YAML/JSON)管理变更,同样在应用启动前执行;与 Exposed 也是「迁移管 schema、框架管映射」的分工,差别在变更表达方式与回滚能力。
概念解释
Liquibase changeset 有 id/author 标识,支持 rollback 指令与变更日志组织;Flyway 以版本号脚本线性排列。团队按既有技术栈选择,不要在同一项目混用两套迁移工具。
原理流程
- 编写 changeset 描述建表/加列。
- 启动时 Liquibase 校验 changeset 并执行未应用项。
- Exposed 映射既有结构。
- 变更回滚依赖 changeset 的 rollback 定义或备份策略。
代码或图示
# 意图示例:changeset 增加列;具体标签以 Liquibase 文档为准
- changeSet:
id: 2-add-user-nickname
author: team
changes:
- addColumn:
tableName: users
columns:
- column: { name: nickname, type: varchar(100), nullable: true }
常见误区
- 同时引入 Flyway 与 Liquibase,迁移历史双写不一致。
- changeset 修改已发布内容,checksum 校验失败。
追问
- 回滚怎么落地?答:危险变更靠备份与反向脚本,Liquibase rollback 仅用于可安全逆操作的变更;生产回滚方案要提前演练。
- 选哪个?答:团队已有约定则跟随;纯 SQL 脚本偏好 Flyway,需要结构化变更与回滚描述可评估 Liquibase。
06.8.3.2-030 createMissingTablesAndColumns 什么时候能用,生产为什么禁用?
一句话结论
该工具按表定义补建缺失表与缺失列,仅适合本地开发或演示环境;生产环境 schema 必须由版本化迁移管理,自动补列可能造成不可逆结构变更与不可控默认值。
概念解释
SchemaUtils 系列方法对比定义与库结构并生成 DDL。自动补列不会评估数据回填、索引与约束影响,也缺乏版本记录。多人并行开发时,本地库结构可能与团队迁移历史脱节。
原理流程
- 框架读取表定义元数据。
- 对比数据库现有表/列。
- 生成并执行建表/加列语句。
- 生产关闭该路径,只走迁移工具。
代码或图示
// 仅本地开发使用;生产环境禁止调用
SchemaUtils.createMissingTablesAndColumns(Users, Orders)
常见误区
- 把自动建表脚本挂到生产启动流程,结构漂移无人知晓。
- 用自动补列替代迁移评审,加列默认值直接影响存量数据。
追问
- 本地开发怎么保持 schema 最新?答:本地库也跑迁移脚本,自动建表只用于快速原型。
- 怎么防止生产误调用?答:按环境 profile 隔离启动配置,生产代码路径不引用
SchemaUtils写操作。
06.8.3.2-031 加列并设为非空,上线流程怎么设计?
一句话结论
分阶段:先加可空列并回填历史数据,再补默认值或数据迁移,最后切非空约束;每阶段一个可独立发布、可回滚的迁移步骤,避免大事务锁表。
概念解释
直接给存量大表加非空列并带默认值,可能锁表或长时间持有元数据锁。正确顺序是加可空列 → 回填(分批)→ 校验数据完整 → 再加非空约束。应用代码先兼容新旧两种状态。
原理流程
- 迁移一:加可空列。
- 应用发布:写入新列,读取兼容 null。
- 迁移二:分批回填历史数据。
- 迁移三:数据校验后改为非空。
代码或图示
-- 步骤 1:加可空列
ALTER TABLE users ADD COLUMN level INT NULL;
-- 步骤 3:回填完成后
ALTER TABLE users ALTER COLUMN level SET NOT NULL;
常见误区
- 一步到位加非空带默认值,大表上线锁等待。
- 应用未兼容 null 就读取新列,老数据报错。
追问
- 回填怎么做不压库?答:分批按主键区间更新,控制每批大小与间隔,避开高峰。
- 默认值由数据库给还是应用给?答:新行由应用写入或列默认值,历史行走回填,两者口径统一。
06.8.3.2-032 schema 演进与回滚策略怎么制定?
一句话结论
schema 变更遵循向前兼容:先扩展结构、再切代码、最后清理旧结构;回滚依赖可逆向的变更与备份,破坏性变更必须提前演练回滚步骤。
概念解释
数据库变更难以像代码那样快速回滚。兼容演进让新旧版本应用可以并存:加列不影响旧代码,废弃列先双写观察再删。回滚分语句可逆(加列可删列)与不可逆(删数据、改类型)两类,后者靠备份恢复。
原理流程
- 评估变更对在途发布与回滚的影响。
- 按扩展-迁移-清理顺序安排脚本。
- 发布期间保留旧结构兼容。
- 上线后观察,再执行清理脚本。
代码或图示
扩展:新增列/新表(旧代码忽略)
切换:新代码读写新结构
清理:确认无回滚需求后删除旧列/旧表
常见误区
- 发布同时删旧列,旧版本实例回滚后找不到字段。
- 不演练回滚,故障时临时拼恢复方案。
追问
- 大表结构变更怎么降低风险?答:低峰执行、分批、准备备份与回滚脚本,监控锁等待与复制延迟。
- 迁移脚本谁评审?答:DBA 或资深后端评审 DDL 影响面,脚本与代码同 MR 评审。
06.8.3.2-033 迁移在 CI 与测试环境怎么应用?
一句话结论
CI 构建阶段跑静态检查与单元测试;集成测试环境启动前自动执行迁移到最新 schema;禁止在 CI 里手动改库结构,迁移脚本本身要可重复校验。
概念解释
测试库 schema 由迁移脚本创建并演进,保证测试覆盖真实结构。每个集成测试环境可独立建库、跑 migrate。迁移脚本纳入版本管理,与代码同仓库评审。脚本失败会阻断流水线。
原理流程
- CI 拉起临时数据库容器。
- 执行迁移工具到最新版本。
- 运行集成测试。
- 测试结束销毁容器,不保留脏数据。
代码或图示
CI 阶段:编译 → 单元测试 → 起数据库容器 → 迁移 → 集成测试 → 构建镜像
常见误区
- 测试库长期复用,结构与脚本历史脱节,测试通过但生产迁移失败。
- 测试依赖手工准备的数据,迁移脚本未被验证。
追问
- 迁移很慢影响 CI 怎么办?答:评估脚本效率、并行化测试库准备;不要跳过迁移验证。
- 多套数据库方言怎么办?答:按生产方言准备测试环境,方言差异在迁移脚本里显式处理。
06.8.3.2-034 不同数据库方言在 Exposed 抽象下要注意什么?
一句话结论
Exposed 屏蔽大部分标准 SQL 差异,但方言特定函数、分页语法、冲突子句、类型映射仍需显式处理;切换数据库前要用目标方言跑集成测试验证。
概念解释
方言差异包括自增/序列、字符串拼接、日期函数、布尔类型、upsert 语法、大小写敏感等。表定义的通用类型在不同方言上映射目标列类型可能不同。生产用 MySQL/PostgreSQL,测试却用 H2 时尤其要注意方言偏差。
原理流程
- 识别 SQL 中方言相关片段。
- 按方言条件分支或使用数据库兼容写法。
- 在目标方言库上跑集成测试。
- 记录不兼容点与替代写法。
代码或图示
// 示例:日期/字符串函数在不同方言下行为不同,避免假设函数名通用
Users.select { Users.createdAt greaterEq threshold }
常见误区
- 用 H2 测过就认为 MySQL/PostgreSQL 行为一致。
- 方言特定语法写进通用 DSL 表达式,换库报错。
追问
- H2 适合做集成测试吗?答:可用于快速单元级验证;关键路径建议 Testcontainers 起目标数据库(见 06.8.5.3)。
- 类型映射差异怎么查?答:对照各方言列类型文档与实际
SHOW CREATE TABLE/information_schema。
06.8.3.2-035 时间类型在 Kotlin 与数据库之间怎么映射?
一句话结论
优先用 java.time 类型(Instant、LocalDateTime 等)与列类型对应,统一存储 UTC 或明确时区;避免旧式 Date/Timestamp 混用导致时区漂移。
概念解释
数据库时间列有时区语义差异(TIMESTAMP 与时区转换、DATETIME 无时区)。Kotlin 侧用 Instant 表达时间点,展示层再按时区格式化。Exposed 列类型与 java.time 的绑定方式以 0.5x 文档为准(待确认)。
原理流程
- 表列声明时间类型。
- 实体属性使用对应
java.time类型。 - 写入时统一时钟源获取当前时间。
- 读取后在 API 层做时区格式化。
代码或图示
object Orders : LongIdTable("orders") {
val createdAt = datetime("created_at") // 绑定方式以文档为准
}
常见误区
- 数据库存本地时间、应用按 UTC 解读,跨时区部署后排序与展示错乱。
- 混合使用
Date与LocalDateTime,转换链路隐式丢时区。
追问
- 时序字段用哪个类型?答:存时间点用
Instant/TIMESTAMP WITH TIME ZONE;仅日期用LocalDate。 - 夏令时问题怎么规避?答:服务端统一 UTC 存储,展示层转换,避免依赖本地时区。
06.8.3.2-036 JSON 列怎么映射到 Kotlin 类型?
一句话结论
JSON 列在数据库存文本,Exposed 提供 JSON 列类型辅助把序列化对象绑定到列;序列化库、空对象与 schema 演进要在应用层约定,具体 JSON 列辅助 API 名称在 0.5x 需对照文档确认(待确认)。
概念解释
结构化子文档适合放 JSON 列,避免为少量可变字段拆宽表。代价是 JSON 内部字段难以建索引(方言支持表达式索引除外),查询能力弱于关系列。Kotlin 侧用 data class 表达 JSON 结构,读写走序列化转换。
原理流程
- 表列声明 JSON 类型。
- 实体属性为对应 data class。
- 写入时序列化为 JSON 文本,读取时反序列化。
- JSON 结构变更保持向后兼容,未知字段按策略忽略。
代码或图示
data class Address(val city: String, val street: String)
object Users : LongIdTable("users") {
val profile = jsonb("profile", Address::class) // 列类型 API 待确认
}
常见误区
- 把需要关联查询、聚合统计的数据塞进 JSON 列。
- JSON 结构随意演进,旧数据反序列化失败。
追问
- JSON 字段要做条件查询怎么办?答:方言支持时用表达式索引;高频查询字段提升为关系列。
- JSON 列可空与默认空对象怎么选?答:优先默认空对象结构,避免读取处反复判空。
06.8.3.2-037 大字段与二进制数据在表设计上要注意什么?
一句话结论
大文本、图片、文件流不应与高频访问的主行放在同一行频繁读取;大字段拆分到扩展表或对象存储,主表只存引用。
概念解释
宽表把大字段一并读出会放大 IO 与内存占用。二进制文件通常走对象存储,数据库只存 URL 或对象键。数据库内的大文本(备注、详情)按访问频率决定是否拆表。列类型(text/blob)按方言选择。
原理流程
- 评估大字段访问频率与主表查询列集。
- 热字段留主表,冷字段拆扩展表或外部存储。
- 查询主列表时不 select 大字段。
- 详情页按需二次加载。
代码或图示
object UserProfiles : LongIdTable("user_profiles") {
val userId = reference("user_id", Users)
val bio = text("bio")
}
常见误区
- 列表接口把大文本一起查出,带宽与内存浪费。
- 数据库库存图片二进制,备份与传输体积膨胀。
追问
- 分片/分页对大字段有效吗?答:分页减少行数,但单行大字段仍需按需取列。
- 二进制走数据库有什么场景?答:小体积、强事务一致的凭证类数据;文件类资源不建议入库。
06.8.3.2-038 并发更新同一实体时会发生什么?
一句话结论
两个事务同时加载同一实体再各自提交,后提交的覆盖先提交的修改;不加锁或版本号时,丢失更新不会被数据库主动拦截。
概念解释
实体内存副本与数据库行分离,读时快照、写时覆盖。并发交错:事务 A、B 读到同一版本,A 改字段一提交,B 改字段二提交,B 的 update 可能覆盖 A 的字段一(取决于 update 列集)。防止手段是悲观锁或乐观锁。
原理流程
- 两事务读取同一行。
- 各自在内存实体上修改。
- 提交时按脏列生成 update。
- 无并发控制时后写覆盖先写。
代码或图示
// 无保护:两事务并发扣减可能丢更新
transaction {
val s = StockEntity.findById(sku)!!
s.quantity = s.quantity - 1
}
常见误区
- 以为对象级赋值天然线程安全:实体不是并发同步组件。
- 只在一个字段上加乐观锁,其他字段仍可被覆盖。
追问
- 计数类更新怎么避免读改写?答:用数据库原子表达式
quantity = quantity - 1,不带入内存旧值。 - 多字段组合校验怎么做?答:把需要校验的条件带入 update WHERE,检查影响行数。
06.8.3.2-039 Exposed 有没有二级缓存?
一句话结论
Exposed DAO 没有 JPA 风格的应用级二级缓存;事务内实体复用之外,跨请求缓存需要自行接入 Redis 或本地缓存组件,不要依赖框架内建缓存(当前版本能力以官方文档为准,待确认)。
概念解释
无 L2 意味着每次请求默认重新查库,热点数据需要外部缓存层。缓存与数据库一致性、失效策略由业务层负责。框架内置缓存若有也仅限事务上下文,不能当作长期缓存使用。
原理流程
- 请求进入,事务内查库装配实体。
- 事务结束,事务缓存释放。
- 下一请求重新查库。
- 热点数据在应用层加缓存,按 TTL 或事件失效。
代码或图示
// 业务层缓存示意:缓存 key 与失效策略由业务定义
fun getOrder(id: Long) = cache.getOrPut("order:$id") {
transaction { OrderEntity.findById(id)?.toDomain() }
}
常见误区
- 误以为框架缓存了热点实体,数据库压力无法下降。
- 缓存实体引用跨事务复用,脏状态与懒加载问题外溢。
追问
- 缓存什么数据?答:读多写少、可容忍短暂不一致的字典、配置、聚合视图。
- 缓存穿透/击穿怎么处理?答:空值缓存、互斥重建、热点预热,通用缓存策略见 09 分册。
06.8.3.2-040 批量更新怎么写才快?
一句话结论
批量更新用 DSL 按条件分组 update,避免循环逐条改实体;控制单批行数与事务大小,必要时分批提交。
概念解释
循环加载实体、逐条赋值提交会产生 N 次 select + N 次 update。DSL 条件 update 一条语句更新匹配集合,往返次数大幅下降。大批量更新要分批,避免长事务、大锁范围与主从延迟。
原理流程
- 按业务条件圈定批量范围。
- DSL 构造
update(...).set(...)语句。 - 范围大时按主键区间分批。
- 每批独立事务,记录进度便于续跑。
代码或图示
Orders.update({ Orders.status eq "PAID" and (Orders.updatedAt olderThan cutoff) }) {
it[Orders.status] = "CLOSED"
}
常见误区
- 一条 update 扫全表更新,锁范围过大。
- 批量更新不复核影响行数,静默漏更新。
追问
- 分批键怎么选?答:用主键区间或有序时间字段,保证不重不漏。
- 批量更新需要回滚粒度吗?答:按批次设计,失败批次重跑,避免整批大事务。
06.8.3.2-041 批量删除与外键约束要注意什么?
一句话结论
批量删除前确认子表关联与外键策略;数据库外键约束会阻止违反引用完整性的删除,应用层应先清子表或按级联策略处理。
概念解释
外键 ON DELETE 行为有 restrict、cascade、set null 等,由 schema 定义决定。批量 delete 命中被引用行时抛约束异常。软删除场景下「删除」只是标记,外键仍保留。
原理流程
- 确认目标行被哪些子表引用。
- 按外键策略先删子表或级联。
- 分批删除主表行。
- 验证影响行数与残留数据。
代码或图示
OrderItems.deleteWhere { OrderItems.orderId inList ids }
Orders.deleteWhere { Orders.id inList ids }
常见误区
- 直接删主表,被外键拦截后部分失败。
- 物理删除审计需要的历史数据,应评估软删除。
追问
- 级联删除好还是应用层删好?答:强一致关系可由数据库级联;跨服务、跨库数据只能应用层补偿。
- 大表批量删除空间回收?答:删除不自动回收空间,按方言做空间维护,避免频繁碎片。
06.8.3.2-042 大结果集怎么流式读取而不撑爆内存?
一句话结论
大数据量导出/批处理应使用游标或分批读取,避免把全部实体装配进内存;Exposed 结果集的流式与批处理 API 名称在 0.5x 需对照文档确认(待确认)。
概念解释
一次性 findAll 并 toList() 会把所有行读入 JVM 堆。流式处理保持游标,逐行或小批处理后释放。实体装配本身有内存成本,超大批处理可考虑 DSL 直接读行投影。
原理流程
- 查询按主键有序,便于分批定位。
- 每批取有限行数处理。
- 处理完释放引用,进入下一批。
- 全程控制单批内存与事务长度。
代码或图示
var lastId = 0L
while (true) {
val batch = transaction {
ItemEntity.find { Items.id greaterThan lastId }
.orderBy(Items.id to SortOrder.ASC).limit(batchSize).toList()
}
if (batch.isEmpty()) break
process(batch)
lastId = batch.last().id.value
}
常见误区
- 批处理仍在一个长事务内,连接与锁长期占用。
- 分批条件不稳定,漏数据或重复处理。
追问
- 导出文件怎么写?答:边读边写流式输出,避免全量收集;导出任务见后台任务相关章节。
- 批处理失败怎么续跑?答:记录已处理位点,重跑从位点继续。
06.8.3.2-043 分页总数 count 慢怎么优化?
一句话结论
深条件 count 与分页查询同样走过滤条件,慢在扫描行数;优化靠覆盖索引、精简条件,或产品上不展示精确总数、用「是否有下一页」替代。
概念解释
COUNT(*) 带复杂 where 同样需要扫描匹配行。索引能覆盖过滤条件时 count 走索引。大表精确总数成本高,常见折中:只算前几页、用游标不返回总数,或缓存近似值。
原理流程
- 分析 count 语句执行计划。
- 过滤条件建匹配索引。
- 无法优化时评估产品形态:隐藏总数或返回粗估。
- 缓存 count 结果并设置短 TTL。
代码或图示
-- 观察 count 扫描量
EXPLAIN SELECT COUNT(*) FROM orders WHERE user_id = 100 AND status = 'PAID';
常见误区
- 每页都实时 count 全量条件,列表接口双份查询成本。
- 用
SELECT COUNT(*)拿近似值却当成精确总数展示。
追问
- 高并发列表 count 缓存什么粒度?答:按查询条件维度缓存,注意条件组合导致缓存膨胀。
- 大数据量搜索场景用什么?答:搜索引擎承担检索与计数,数据库只存明细。
06.8.3.2-044 索引失效有哪些常见场景?
一句话结论
常见失效包括:对索引列做函数/计算、隐式类型转换、前导通配模糊查询、违反最左前缀、低区分度列优化器选择全表扫描。
概念解释
索引列参与函数运算后 B+ 树有序性无法直接使用;字符串与数字比较发生隐式转换;LIKE '%xx' 无法利用前缀索引;组合索引跳过前导列;数据分布使优化器认为全表更便宜。
原理流程
- 写查询时检查索引列是否被包裹函数。
- 核对参数类型与列类型一致。
- 组合索引条件顺序对齐最左前缀。
EXPLAIN复核访问类型与命中索引。
代码或图示
-- 失效:对列做函数
WHERE DATE(created_at) = '2026-11-19'
-- 推荐:范围条件
WHERE created_at >= '2026-11-19 00:00:00' AND created_at < '2026-11-20 00:00:00'
常见误区
- 建了索引就认为必然命中,不看执行计划。
- 索引列类型与传入参数类型不一致,驱动隐式转换。
追问
- 区分度低的列怎么建索引?答:与高频等值列组合成联合索引,不要单列建低区分度索引。
- ORM 生成语句怎么检查?答:开 SQL 日志拿到真实语句再做执行计划分析。
06.8.3.2-045 慢 SQL 与连接池等待怎么区分?
一句话结论
连接池等待时间花在借不到连接上,SQL 执行时间花在数据库内;分别看池等待指标与语句耗时,两者根因与解法不同。
概念解释
请求慢可能是:等连接(池耗尽)→ 借到后 SQL 慢 → 应用处理慢。连接池活跃数、等待线程数与获取超时计数反映前者;慢日志与执行计划反映后者。混在一起会把池问题误判成 SQL 问题。
原理流程
- 记录请求时间线:等连接、执行 SQL、应用处理分段耗时。
- 池指标看活跃连接与排队长度。
- 慢日志看单语句执行时间。
- 按分段定位瓶颈。
代码或图示
请求耗时 = 等连接 + 事务内 SQL + 应用处理 + 其他 IO
常见误区
- 接口慢就加索引,实际是连接池被长事务占满。
- 只看总响应时间,不拆分段。
追问
- 池耗尽常见原因?答:长事务、慢 SQL、RPC 混入事务、池配置过小。
- 怎么监控?答:接入连接池指标(活跃/空闲/等待)与 SQL 耗时直方图,见 06.8.5.2。
06.8.3.2-046 读写分离下 DAO 怎么路由到主库与从库?
一句话结论
按事务语义路由:写事务与写后立即读走主库,只读查询走从库;路由决策在连接获取前完成,DAO 代码不感知数据源。
概念解释
从库复制延迟会导致刚写后读不到数据。强一致读请求必须走主库。路由通常由数据源抽象或拦截层按方法/注解判定,DAO 实体不绑定具体库。多数据源初始化基础见 06.8.3.1。
原理流程
- 业务入口标注读写意图。
- 路由层选择主或从数据源开启事务。
- DAO 使用该事务连接。
- 读路径评估复制延迟容忍度。
代码或图示
transaction(db = orderDb.primary) { /* 写 */ }
transaction(db = orderDb.replica) { /* 只读 */ }
常见误区
- 写后立刻读走从库,读到旧数据。
- 路由规则散落在 Repository 内部,难以审计。
追问
- 复制延迟怎么监控?答:看主从延迟指标,延迟超阈值时读请求回退主库。
- 读写分离对 DAO 代码有侵入吗?答:实体与表定义无侵入,侵入点在事务获取连接层。
06.8.3.2-047 事务内调用外部 RPC 或发消息有什么反模式?
一句话结论
数据库事务内阻塞等待外部 RPC、MQ 确认会拉长事务、占连接与锁,外部故障还会把事务拖住;应把外部调用移到事务提交之后。
概念解释
事务持锁期间调用外部服务,响应慢或超时直接延长锁持有时间。常见问题:事务内发 MQ 等待 ack、调用下游校验、等待缓存刷新。正确做法是事务先提交,再通过事务后回调或本地消息表触发外部动作。
原理流程
- 事务内只做数据库读写。
- 提交成功后执行外部调用。
- 需要可靠性时用本地消息表/事件表,异步投递。
- 外部失败走重试与补偿。
代码或图示
val order = transaction {
OrderEntity.new { /* ... */ }
}.also { /* 事务提交后再发事件 */ }
publishEvent(order)
常见误区
- 事务内同步等待下游响应,下游抖动直接传导为数据库锁等待。
- 未提交就发消息,消费者读到未生效数据。
追问
- 怎么保证库提交后事件一定发出?答:本地消息表:事务内写消息记录,提交后后台任务投递,投递成功再标记。
- 事务后回调有哪些实现方式?答:提交钩子、应用事件、异步任务;具体机制按框架选择。
06.8.3.2-048 长事务为什么危险,怎么识别?
一句话结论
长事务长时间持有连接与锁、阻塞其他写入并放大死锁概率;识别靠事务持续时间监控与慢日志,治理靠缩短事务边界、移出外部调用与批量拆分。
概念解释
事务从开启到提交期间持有行锁与连接。事务越长,锁等待链越容易形成,回滚段/undo 压力增大,连接池被占用。常见诱因:事务内夹带循环处理、RPC、文件操作、人工等待。
原理流程
- 监控事务开启到提交的时长。
- 定位事务内耗时操作清单。
- 把非数据库操作移出事务。
- 大批量操作拆成短事务批次。
代码或图示
反模式:一个事务里循环调用下游、逐条写库
推荐:短事务完成核心写入,后置处理异步化
常见误区
- 把「一个用例」等同于「一个事务」,用例内所有读写塞进单一事务。
- 长事务无人监控,故障时才发现锁等待堆积。
追问
- 跨多个聚合的写怎么保证一致?答:拆成本地短事务 + 最终一致补偿;强一致跨聚合需求重新评估边界划分。
- 事务时长指标怎么埋?答:在事务拦截层记录开始/结束时间与 SQL 条数。
06.8.3.2-049 死锁怎么排查和处理?
一句话结论
死锁是多个事务互相持有并等待对方锁资源;排查靠数据库死锁日志与等待链,处理靠统一加锁顺序、缩短事务、降低锁粒度。
概念解释
不同事务以不同顺序更新同一组行,形成循环等待。数据库检测到死锁后回滚其中一个事务。应用需要捕获死锁异常并重试。排查要看死锁日志中涉及的事务、持有与等待的行。
原理流程
- 数据库记录死锁日志(双方事务、行锁、语句)。
- 分析加锁顺序差异。
- 统一多行更新的排序规则(如按主键升序)。
- 缩短事务、减少锁交叉范围。
代码或图示
// 统一按主键升序加锁,避免交叉等待
ids.sorted().forEach { id ->
StockEntity.findById(id, lock = LockType.FOR_UPDATE) // 锁 API 待确认
}
常见误区
- 死锁异常直接暴露给用户,没有重试。
- 多个入口更新同一批数据时顺序不一致。
追问
- 死锁重试安全吗?答:短事务、幂等操作可重试;非幂等写要先确认事务已回滚再重试。
- 锁粒度怎么缩小?答:条件精确到目标行,避免大范围
FOR UPDATE扫描加锁。
06.8.3.2-050 连接泄漏怎么识别?
一句话结论
连接泄漏指连接借出后未归还,表现为活跃连接持续增长直至池耗尽;识别靠池监控(活跃数不下降、等待超时增多)与代码审查事务是否正常关闭。
概念解释
事务未提交/回滚、异常路径未关闭连接,都会导致连接不归还。框架事务通常在闭包结束时自动归还,绕过闭包手动管理连接才容易泄漏。监控连接获取与归还计数差值最直接。
原理流程
- 观察池活跃连接随时间是否单调上升。
- 对比获取/归还计数,差值持续扩大即泄漏。
- 审查手动获取连接、未在 finally 关闭的路径。
- 压测复现并抓借出时堆栈定位。
代码或图示
// 推荐:闭包式事务自动归还
transaction {
UserEntity.findById(1)
}
常见误区
- 池耗尽才发现泄漏,此前无监控。
- 以为重启能解决:泄漏路径仍在,重启后复发。
追问
- 怎么记录借出堆栈?答:连接池支持泄漏检测时开启,超时未归还打印借出位置;具体配置按池实现。
- 协程场景要注意什么?答:连接不要跨协程长期持有,事务边界与协程生命周期对齐(协程集成 API 待确认)。
06.8.3.2-051 字符集与排序规则在迁移时要注意什么?
一句话结论
库、表、列字符集与排序规则统一规划,避免中文/emoji 乱码、比较规则不一致导致 join 与索引异常;迁移脚本显式声明,不依赖默认值。
概念解释
字符集决定能存什么字符(如 utf8mb4 支持 emoji),排序规则决定大小写、口音比较与索引顺序。库默认值会被新表继承,历史表可能与新表规则不同,join 时规则冲突报错。
原理流程
- 建库/建表脚本显式写字符集与排序规则。
- 新表与既有表规则对齐。
- 应用连接字符集与库一致。
- 历史不一致表单独评估转换脚本。
代码或图示
CREATE TABLE users (
id BIGINT PRIMARY KEY,
name VARCHAR(100)
) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
常见误区
- 用不支持 4 字节字符的字符集,emoji 写入报错或截断。
- 两表排序规则不同,join 报 collation 冲突。
追问
- 历史表转字符集怎么做?答:低峰分批转换,先备份,验证长度与索引重建。
- 排序规则影响业务哪些行为?答:字符串排序、唯一索引去重大小写敏感与否。
06.8.3.2-052 唯一约束冲突的重复键异常怎么处理?
一句话结论
依赖唯一索引兜底业务唯一性,捕获重复键异常后转为业务错误或走 upsert;不要先查再插指望避免竞态。
概念解释
先查询不存在再插入存在并发竞态:两请求同时查不到,先后插入都触发唯一约束。数据库唯一索引是最终防线。异常按 SQL 状态码识别,转换为业务层可处理的冲突结果。
原理流程
- 业务键建唯一索引。
- 插入时冲突抛重复键异常。
- 应用按异常类型映射为「已存在」错误或执行冲突更新。
- 上层决定提示用户或合并处理。
代码或图示
try {
transaction { UserEntity.new { name = input } }
} catch (e: DuplicateKeyException) {
// 转为业务冲突;具体异常类型按数据库/驱动确认
throw BusinessConflict("name already exists")
}
常见误区
- 先 select 再 insert,并发下仍然冲突。
- 把数据库异常直接抛到接口层,错误码不友好。
追问
- 业务键可修改怎么办?答:唯一索引跟随业务键变更,变更时校验新键唯一性。
- 软删除记录与唯一键冲突?答:见软删除唯一索引题目,用部分索引或拼接策略。
06.8.3.2-053 乐观锁冲突重试怎么设计?
一句话结论
冲突后按业务幂等性做有限次重试,带退避;非幂等操作不能盲目重试,需要先确认回滚状态。
概念解释
乐观锁冲突说明数据被他人改过,重试要重新读取最新版本再走业务逻辑。重试次数与间隔上限明确,避免活锁。涉及资金、库存等关键操作,重试前校验业务条件是否仍满足。
原理流程
- 捕获版本冲突异常。
- 判断当前操作是否幂等可重试。
- 重新加载数据、重新计算。
- 超过次数上限则失败并提示。
代码或图示
repeat(maxRetry) { attempt ->
try {
return service.update(id)
} catch (e: ConcurrentModificationException) {
if (attempt == maxRetry - 1) throw e
backoff(attempt)
}
}
常见误区
- 无限重试或重试间隔为 0,冲突加剧。
- 重试时基于旧快照再次提交,冲突重复发生。
追问
- 哪些操作不适合重试?答:非幂等且副作用已发生的操作,需补偿而非重试。
- 冲突率高说明什么?答:乐观锁不适合高竞争场景,评估悲观锁或业务分片。
06.8.3.2-054 悲观锁等待超时怎么配置和处理?
一句话结论
锁等待超时由数据库/方言层控制,超时后语句中断并抛锁等待异常;应用捕获后按业务重试或快速失败,不要让线程长时间阻塞。
概念解释
FOR UPDATE 等待其他事务释放行锁,超过超时阈值即报错。锁等待超时与事务超时、语句超时分属不同层级。超时异常需要与业务异常区分,避免误判为数据问题。
原理流程
- 数据库配置锁等待超时阈值。
- 事务加锁时排队等待。
- 超时未获得锁,语句中断回滚当前事务部分操作。
- 上层记录并处理。
代码或图示
-- 方言相关:锁等待超时参数按数据库配置
-- 应用侧:捕获锁等待超时异常,区分于普通业务异常
常见误区
- 锁等待超时被当成系统错误告警,实际是并发竞争信号。
- 临界区过大导致锁等待频繁,只靠调大超时缓解。
追问
- 怎么降低锁等待?答:缩短临界区、减少加锁行数、优化竞争热点。
- 锁等待与死锁区别?答:等待超时是单向等待过久,死锁是循环互相等待被检测回滚。
06.8.3.2-055 软删除场景下唯一索引怎么避免冲突?
一句话结论
普通唯一索引无法区分已删除记录,需要方言支持的部分唯一索引,或把删除时间/删除标记拼入唯一键;具体方案按数据库能力选择。
概念解释
同一业务键软删除多条后,新记录无法再插入。PostgreSQL 可建 WHERE deleted_at IS NULL 的部分唯一索引;MySQL 不支持部分索引,常用生成列把业务键与删除标记组合进唯一列,或改用归档策略。
原理流程
- 评估方言是否支持部分/条件索引。
- 支持则建条件唯一索引。
- 不支持则设计组合唯一列。
- 应用删除流程配合维护该列。
代码或图示
-- PostgreSQL 部分唯一索引示例
CREATE UNIQUE INDEX uk_active_user_name
ON users(name) WHERE deleted_at IS NULL;
常见误区
- 软删除后唯一索引反复冲突,业务被迫物理删历史。
- 组合列设计不完整,已删除记录仍占用业务键。
追问
- 多条同键已删记录怎么办?答:部分索引只约束未删除行;组合方案中把删除时间纳入键以区分多条。
- 业务键变更历史怎么追溯?答:靠审计表保存历史映射,不依赖唯一索引。
06.8.3.2-056 审计字段由应用层写还是数据库默认值写?
一句话结论
推荐应用层统一写入并注入时钟与操作人上下文;数据库默认值只兜底创建时间,更新时间刷新通常需要触发器或应用层覆盖,口径要在项目内统一。
概念解释
应用层写可控性强,能带上操作人、请求上下文;数据库默认值不依赖应用代码,但跨写入入口(手工脚本、迁移回填)容易口径不一。触发器在部分团队被谨慎使用,调试与迁移成本高。
原理流程
- 约定审计字段来源:应用层负责写入。
- 写入口(Repository 基类/工厂)统一赋值。
- 数据库默认值作为新行兜底。
- 定期核对审计字段完整性。
代码或图示
fun newOrder(now: Instant, operator: Long) = OrderEntity.new {
createdAt = now
updatedAt = now
createdBy = operator
}
常见误区
- 部分入口应用层写、部分入口依赖默认值,字段口径混杂。
- 操作人取自线程上下文,异步链路丢失后审计字段为空。
追问
- 批量回填谁来写审计字段?答:迁移脚本显式写系统操作人标识,避免留空。
- 审计字段需要独立审计表吗?答:关键变更用历史表记录前后值,实体时间戳只做粗粒度追溯。
06.8.3.2-057 迁移脚本的命名与版本顺序怎么约定?
一句话结论
脚本按工具约定前缀与版本号线性排序(如 V1、V2),版本号单调递增,描述清晰;已发布脚本不可修改,新变更追加新脚本。
概念解释
版本顺序决定执行先后,历史数据回填依赖前面的结构变更。命名包含版本、描述、作者或日期便于追溯。工具校验已应用脚本的 checksum,改动旧脚本会导致校验失败。
原理流程
- 新变更按当前最大版本号递增编号。
- 脚本描述写明变更内容。
- 评审后合入主干。
- 环境按版本顺序执行。
代码或图示
V1__init.sql
V2__add_users_nickname.sql
V3__backfill_user_level.sql
V4__orders_add_status_index.sql
常见误区
- 多人并行开发版本号冲突,合并后顺序错乱。
- 修改已执行脚本的内容绕过 checksum 校验。
追问
- 版本号冲突怎么协调?答:合并前 rebase 到最新脚本尾部编号,CI 校验编号唯一有序。
- 描述写什么?答:一句话说明结构变更与影响表,不写实现细节。
06.8.3.2-058 基线迁移(baseline)怎么理解?
一句话结论
基线是把已有生产库的当前结构标记为起点,后续增量脚本从基线版本之后开始执行;用于项目接入迁移工具时存量库的初始化。
概念解释
老库接入 Flyway/Liquibase 时,不需要为历史结构补写全部建表脚本,而是设置基线版本,工具认为该版本之前的结构已存在。基线之后的变更才纳入版本管理。基线设置错误会导致重复执行历史 DDL。
原理流程
- 评估存量库结构现状。
- 设置基线版本与描述。
- 工具记录基线已应用。
- 后续增量脚本按版本执行。
代码或图示
baselineOnMigrate = true
baselineVersion = 1
-- 存量库结构视为 V1 已存在,V2 起为增量
常见误区
- 基线版本低于实际结构版本,工具尝试重跑历史 DDL。
- 新环境不设基线,与存量库历史口径不一致。
追问
- 全新环境怎么办?答:从初始脚本完整执行,不需要基线标记。
- 基线后发现漏了历史表怎么办?答:新增增量脚本补结构,不要回改基线。
06.8.3.2-059 测试库 schema 重建策略怎么选?
一句话结论
集成测试库每次启动重建或迁移到最新,测试间数据隔离;常用策略有 drop-create、迁移重建与事务回滚,按测试类型与速度选择。
概念解释
单元测试不碰库;集成测试需要真实 schema。每次跑测试重建库保证起点干净,迁移脚本同时被验证。事务回滚只隔离写操作,不适合跨事务用例。复用容器可加速,但要清理残留数据。
原理流程
- 测试启动拉起数据库。
- 执行迁移到最新版本。
- 测试用例准备自有数据。
- 用例间按事务回滚或清表隔离。
代码或图示
Testcontainers 起库 → migrate → 装配测试数据 → 执行用例 → 清理/销毁容器
常见误区
- 测试库长期不重建,依赖手工残留数据,用例偶发失败。
- 用例间共享数据,顺序变化导致结果不稳定。
追问
- 重建太慢怎么办?答:复用容器、并行分库,或按测试套件分层;不要跳过 schema 校验。
- 怎么保证测试数据不泄漏?答:每个用例自建数据,结束清理;禁用跨用例共享静态数据。
06.8.3.2-060 生产迁移发布的窗口与顺序怎么安排?
一句话结论
结构变更与应用发布按兼容顺序推进:先发布兼容旧结构的代码,再执行迁移,最后启用新结构使用;危险变更避开高峰并准备回滚预案。
概念解释
应用与数据库变更要双向兼容:新代码能读旧结构,迁移后旧代码也能容忍新列。顺序错配会导致发布瞬间报错。大表变更低峰执行,监控锁等待与复制延迟。
原理流程
- 代码版本兼容新旧结构。
- 低峰执行迁移脚本。
- 发布应用版本。
- 观察指标,确认稳定后再清理旧结构。
代码或图示
兼容代码上线 → 迁移执行 → 新代码启用新列 → 观察 → 清理旧列
常见误区
- 迁移与发布同时进行,回滚时结构与代码不匹配。
- 大表变更在业务高峰执行,锁等待影响线上。
追问
- 迁移失败怎么办?答:按预案停止后续步骤,保留现场,评估回滚或修复后重试。
- 谁来执行生产迁移?答:按发布流程由部署流水线或值班人员执行,脚本预先评审。
06.8.3.2-061 Exposed 版本升级时 schema 与 API 要注意什么?
一句话结论
升级先看 changelog 的 breaking changes,表定义/DAO API 改名或行为变化逐项对照;在预发用目标 schema 跑全量测试,数据库结构不因框架升级自动变更。
概念解释
框架版本升级影响的是代码 API 与生成 SQL,不直接改库结构。0.4x→0.5x 的 API 命名、包结构可能调整,具体变更点以官方 changelog 为准(待确认)。升级在小版本范围内灰度,先升测试环境。
原理流程
- 阅读版本 changelog 与迁移说明。
- 升级依赖版本,编译修复 API 调用。
- 预发跑迁移与集成测试。
- 观察 SQL 行为差异后灰度上线。
代码或图示
changelog → 依赖升级 → 编译适配 → 集成测试 → 预发观察 → 灰度
常见误区
- 只升依赖不跑测试,运行时 API 报错。
- 假设生成 SQL 与旧版本完全一致,执行计划发生变化未察觉。
追问
- 升级后 SQL 变了怎么验证?答:对比关键接口的语句与执行计划,回归性能基线。
- 不确定 API 是否变更怎么办?答:标注待确认点,对照当前版本源码与文档验证后再定稿。
06.8.3.2-062 表重命名、列重命名怎么安全迁移?
一句话结论
重命名采用「新结构并行 → 双写/兼容读取 → 切流 → 删旧」的扩展方式,避免新旧版本应用同时引用不同名称导致断链。
概念解释
直接改名会让未更新的应用版本找不到表/列。兼容方案:新增目标名称结构,代码兼容新旧读取,迁移数据后切换写入,观察稳定再删旧对象。ORM 表定义与迁移脚本同步调整。
原理流程
- 新增新表/新列。
- 迁移数据,应用双写或兼容读取。
- 读流量切到新结构。
- 确认无回滚需求后删除旧对象。
代码或图示
-- 意图:新增列后回填,切换后再删旧列(分步脚本)
ALTER TABLE users ADD COLUMN full_name VARCHAR(100) NULL;
常见误区
- 直接 RENAME,滚动发布期间旧实例报错。
- 重命名后外键、索引、视图未同步更新。
追问
- 表重命名外键怎么办?答:外键引用名随迁移同步调整,分步评估依赖对象。
- 回滚窗口内旧名还要保留吗?答:保留到观察期结束,再执行清理脚本。
06.8.3.2-063 历史数据回填怎么做分批更新?
一句话结论
回填按主键区间分批,每批小事务提交,控制节奏避开高峰;记录批次进度,失败可续跑,并先在小范围验证。
概念解释
一次性 update 全量历史会长事务、大锁、主从延迟。分批按主键滑动窗口,每批独立提交。回填脚本要可重复执行(幂等),避免重复回填造成错误覆盖。
原理流程
- 圈定主键范围与每批大小。
- 循环按区间查询待回填行。
- 小事务内更新并提交。
- 间隔控速,记录进度。
代码或图示
var lastId = 0L
while (true) {
val batch = transaction {
Items.find { Items.id greaterThan lastId and (Items.newCol.isNull()) }
.orderBy(Items.id to SortOrder.ASC).limit(batchSize).toList()
}
if (batch.isEmpty()) break
transaction { batch.forEach { it.newCol = derive(it) } }
lastId = batch.last().id.value
}
常见误区
- 回填脚本不可重复执行,重跑覆盖新值。
- 不控速,回填抢占在线业务 IO。
追问
- 回填期间新数据怎么办?答:写入路径同步写新列,回填只补历史。
- 怎么验证回填完整?答:校验残留 null 数量为 0,抽样比对值。
06.8.3.2-064 大表加索引在线策略是什么?
一句话结论
大表加索引要评估锁表风险与复制延迟,选择在线 DDL 方式低峰执行;先在预发验证耗时,应用侧不依赖新索引前不做相关查询优化上线。
概念解释
加索引会扫描全表并重建索引,期间锁策略依方言与工具而定。MySQL 有在线 DDL 与 pt-online-schema-change 一类方案,PostgreSQL 建索引默认不阻塞写(并发建索引)。具体方言能力需按生产数据库确认。
原理流程
- 分析待加索引的表大小与写入量。
- 低峰选择在线 DDL 方式。
- 监控复制延迟、锁等待与磁盘空间。
- 索引建成后验证执行计划命中。
代码或图示
-- 意图:并发建索引;具体语法按方言确认
CREATE INDEX CONCURRENTLY idx_orders_user ON orders(user_id);
常见误区
- 高峰直接建大索引,锁等待拖垮在线写入。
- 只在小表验证过耗时,忽略生产数据量级。
追问
- 索引建错了能删吗?答:普通索引可在线删除,删除同样评估锁与复制影响。
- 空间不足怎么办?答:提前评估磁盘余量,索引体积与表数据量相关。
06.8.3.2-065 DAO 实体与领域模型为什么要分离?
一句话结论
实体是持久化模型,与表结构和框架耦合;领域模型表达业务语义,不依赖 ORM。Repository 出口完成两者转换,让核心业务逻辑可脱离数据库框架测试。
概念解释
实体委托属性、主键包装、懒引用都属于持久层细节。领域模型用纯 Kotlin data class/sealed class 表达状态与行为。分离后表结构调整只影响映射层,业务规则不受框架版本绑架。
原理流程
- 数据层返回实体。
- Repository 把实体转换为领域模型。
- Service 只操作领域模型。
- 持久化时再转回实体。
代码或图示
data class Order(val id: Long, val status: OrderStatus, val amount: Int)
fun OrderEntity.toDomain() = Order(id.value, OrderStatus.valueOf(status), amount)
常见误区
- 直接把实体当领域模型,业务代码遍历 ORM API。
- 映射层漏字段,领域模型拿到不完整数据。
追问
- 简单项目也要分离吗?答:边界清晰的小服务可薄映射,但不要把实体暴露到 Web 层。
- 映射放哪一层?答:Repository 出口或独立 mapper,Service 不感知实体。
06.8.3.2-066 Repository 封装 DAO 的边界在哪里?
一句话结论
Repository 负责数据存取与实体/模型转换,不承载业务规则;查询条件可由上层传入或由 Repository 提供语义化方法,跨表编排回到 Service。
概念解释
Repository 对外暴露领域模型读写接口,内部使用 Exposed DAO/DSL。业务判断(状态流转、校验)留在 Service。Repository 方法命名表达业务意图(findActiveByUser),而不是暴露通用查询拼接。
原理流程
- Service 调用 Repository 语义化方法。
- Repository 在事务内用 DAO/DSL 取数。
- 实体转换为领域模型返回。
- 持久化时模型转回实体。
代码或图示
class OrderRepository(private val db: Database) {
fun findById(id: Long): Order? = transaction(db) {
OrderEntity.findById(id)?.toDomain()
}
}
常见误区
- Repository 方法里写业务规则,Service 变薄壳。
- 把 DSL 表达式暴露给上层,上层直接拼表查询。
追问
- 一个聚合一个 Repository 吗?答:按业务聚合划分,跨聚合数据通过接口协作。
- 事务边界划在哪?答:Repository 方法或 Service 用例层开启事务,保持一致约定。
06.8.3.2-067 DSL 视图或多表结果怎么映射回实体?
一句话结论
多表 join 的结果不强制装配成实体;需要实体时按伴随对象的查询入口取主表实体,关联数据走投影 DTO,不要从 join 行手工拼实体状态。
概念解释
实体装配依赖伴随对象与表元数据,join 行包含多表列,手工构造实体容易漏状态。常见做法:主表实体走 DAO 查询,关联字段用 DSL 投影单独取,内存拼装。只读复杂视图直接映射 DTO。
原理流程
- 确定主实体表。
- DSL join 取主表列与关联投影列。
- 主表行装配实体,关联值填入 DTO。
- 不在 join 结果上伪造完整实体。
代码或图示
val rows = Orders.leftJoin(Users).select { Orders.id eq id }
.map { OrderDto(it[Orders.id].value, it[Users.name]) }
常见误区
- 手工 new 实体塞部分列值,脏检查与后续更新行为不可预期。
- 为复用实体模型强行 join 出全部列,查询变重。
追问
- 关联实体批量取回怎么做?答:见 N+1 题目,批量按外键查询后分组。
- 视图能映射实体吗?答:只读视图可定义对应表元数据做查询映射,写入不支持;是否有视图专用 API 待确认。
06.8.3.2-068 原生 SQL 查询结果怎么映射?
一句话结论
Exposed 支持执行原生 SQL 并读取结果行,按列名取值手工映射;复杂报表或方言特有语句可走原生 SQL,但要保留参数绑定防止注入。
概念解释
DSL 表达不了的语句(特殊函数、复杂报表)可用原生 SQL。结果行通过行访问器取列值,再转成 DTO/实体。原生 SQL 脱离类型安全,字段名与类型需自行核对。
原理流程
- 编写带占位符的原生 SQL。
- 参数绑定传入。
- 执行后逐行读取列。
- 映射为业务模型。
代码或图示
// 原生 SQL 执行 API 名称以 0.5x 文档为准(待确认)
val rows = transaction {
exec("SELECT id, name FROM users WHERE status = ?") { rs ->
// 按 ResultSet 读取并映射
}
}
常见误区
- 字符串拼接参数进 SQL,产生注入风险。
- 原生 SQL 方言写死,换库不可移植。
追问
- 原生 SQL 还能走实体装配吗?答:通常手工映射;需要实体时优先回到 DAO 查询入口。
- 报表查询放哪一层?答:独立查询服务/读模型,不混入写路径 Repository。
06.8.3.2-069 存储过程与数据库函数怎么调用?
一句话结论
Exposed 对存储过程的支持有限,常见做法是原生 SQL 调用过程或函数并读取结果;是否有专用 API 以当前版本文档为准(待确认),复杂过程逻辑建议上移到应用层。
概念解释
存储过程把业务逻辑封在数据库内,测试、版本管理与排障成本高。新项目倾向应用层承载逻辑,数据库只做存取。必要的数据库函数(计算、加密)可在 DSL 表达式中调用,过程调用走原生语句。
原理流程
- 确认逻辑是否必须放数据库侧。
- 函数调用纳入表达式或原生 SQL。
- 过程调用用参数化语句执行。
- 结果映射为业务模型。
代码或图示
-- 调用意图示例;具体 Exposed 调用封装以文档为准
SELECT calculate_discount(?, ?);
常见误区
- 在存储过程里写复杂业务规则,与应用层逻辑双份维护。
- 过程返回多结果集时未处理游标映射。
追问
- 为什么新项目不推荐存储过程?答:版本评审、测试覆盖、跨库移植与人员维护都弱于应用层代码。
- 已有存储过程怎么演进?答:逐步把逻辑迁到应用层,过程保留为兼容入口。
06.8.3.2-070 数据库函数与表达式在 DSL 里怎么使用?
一句话结论
DSL 列表达式可包装方言函数生成 SQL 片段;跨方言通用的函数优先用框架表达式,方言特有函数需要确认兼容性。
概念解释
聚合、日期、字符串函数在 DSL 中以表达式形式参与 select/where。函数生成的 SQL 随方言翻译。团队封装常用表达式扩展,避免散落原生片段。具体函数列表以 0.5x 文档为准(待确认)。
原理流程
- 在 select/where 中构造函数表达式。
- 框架按方言生成对应 SQL。
- 结果按列类型读取。
- 方言特有函数标注兼容范围。
代码或图示
// 意图示例:聚合表达式;具体函数 API 以文档为准
Orders.select { Orders.status eq "PAID" }
.slice(Orders.id.count())
常见误区
- 假设某函数所有方言行为一致,日期/字符串边界差异未测试。
- 表达式过度嵌套,生成 SQL 难读难排查。
追问
- 聚合结果怎么取?答:用
slice投影到标量或 DTO,不要套实体。 - 自定义函数怎么注册?答:按框架表达式扩展机制封装,方言分支显式处理。
06.8.3.2-071 聚合查询为什么不适合走 DAO 实体?
一句话结论
聚合(count、sum、group by、平均)返回的是标量或投影行,不是完整实体;走 DSL 投影直接取结果,装配成实体反而浪费内存并掩盖真实查询形态。
概念解释
DAO 实体假设一行对应一个可持久化对象,聚合结果只有部分列或计算值。把聚合行硬塞实体,属性未加载、脏检查语义错位。报表、看板、统计接口应使用只读投影模型。
原理流程
- 确定统计口径与维度。
- DSL
slice选择分组列与聚合表达式。 - 结果行映射为统计 DTO。
- 不在聚合结果上调用实体写方法。
代码或图示
val stats = Orders.selectAll()
.slice(Orders.status, Orders.id.count())
.groupBy(Orders.status)
.map { StatusStat(it[Orders.status], it[Orders.id.count()]) }
常见误区
- 先查出全部实体再在内存分组统计,数据量大时内存与往返双高。
- 聚合 DTO 与写模型混用,后续误调用持久化方法。
追问
- 复杂统计放哪一层?答:独立读模型/查询服务,必要时引入缓存或搜索组件。
- 聚合要关联多表怎么办?答:DSL join 后投影,不经过实体导航。
06.8.3.2-072 实体的 equals 与 hashCode 依据什么?
一句话结论
实体身份通常以主键判断;Exposed 实体默认相等性行为以源码为准(待确认),业务集合中使用时不要把未持久化实体与已持久化实体混放。
概念解释
有主键的实体与库中行对应,同主键视为同一身份;未持久化实体没有稳定主键。依赖默认引用相等还是值相等,需要结合具体实现确认。放入 Set 或作为 Map 键时,相等性与 hashCode 直接影响去重结果。
原理流程
- 确认实体相等性实现依据主键还是引用。
- 集合使用前明确身份口径。
- 跨事务实体不要作为缓存键。
- 需要值比较时转换为领域 data class。
代码或图示
// 领域模型用 data class 值相等
data class OrderView(val id: Long, val status: String)
常见误区
- 同一行两个事务加载的实体放入同一集合,因相等性口径不一致重复出现。
- 未持久化实体 hashCode 不稳定导致集合行为异常。
追问
- 实体需要自定义 equals 吗?答:如框架默认不按主键比较,可按主键实现;优先在领域模型上做值比较。
- 跨实体类型能相等吗?答:不应跨类型比较,集合按类型分组使用。
06.8.3.2-073 实体在 List/Set 中要注意什么?
一句话结论
实体进入集合前先明确是否需要身份去重;DAO 实体引用与脏状态可能随事务变化,集合不应跨请求持有实体引用。
概念解释
事务内加载的实体集合在事务结束后引用仍在,但懒加载属性与缓存已失效。长生命周期集合持有实体是内存泄漏与脏读来源。返回给上层的应是转换后的 DTO/领域模型集合。
原理流程
- 查询得到实体列表。
- 业务处理在事务内完成。
- 出口转换为不可变模型集合。
- 实体引用随事务释放。
代码或图示
val views = transaction {
OrderEntity.all().limit(50).toList().map { it.toView() }
}
常见误区
- 把实体列表缓存到成员变量,跨请求复用。
- 集合内实体被后续修改污染,上层拿到意外状态。
追问
- 批量结果怎么控制大小?答:分页或分批,禁止无界
toList()。 - 不可变集合有必要吗?答:领域模型返回只读 List,避免上层原地修改。
06.8.3.2-074 实体引用循环会导致什么序列化问题?
一句话结论
双向引用形成循环,序列化器递归遍历会栈溢出或输出冗余嵌套;实体不应直接序列化,引用方向单向化并在 DTO 层切断循环。
概念解释
父持有子集合、子回引父,JSON 序列化时相互引用递归无法终止。即使不爆栈,输出也会嵌套膨胀。DAO 关联默认单向导航,建模时避免双向都暴露给序列化层。
原理流程
- 检查实体引用方向是否双向。
- DTO 只保留必要单向字段。
- 序列化在 DTO 上执行。
- 循环关系在内存业务层按需拼装。
代码或图示
data class OrderDto(val id: Long, val items: List<OrderItemDto>)
data class OrderItemDto(val id: Long, val title: String) // 不回引订单
常见误区
- 在实体上加
@JsonIgnore切断循环,持久模型与序列化注解耦合。 - 循环引用只在部分接口暴露,问题偶发难复现。
追问
- 业务需要双向导航怎么办?答:领域模型内双向,导出 DTO 时单向化。
- 序列化报错怎么快速定位?答:看栈溢出位置的引用链,找到循环起点。
06.8.3.2-075 协程环境下 Exposed 事务怎么使用?
一句话结论
Exposed 基于阻塞 JDBC,事务内执行的是阻塞 IO;在协程中调用要注意调度器与线程绑定,避免在事件循环线程上阻塞。协程集成模块与 API 在 0.5x 的名称需对照文档确认(待确认)。
概念解释
JDBC 连接与线程绑定,事务闭包在调用线程上阻塞执行。协程里直接调用阻塞事务会占用当前线程,若跑在 IO 密集调度器上需评估线程池容量。是否提供协程友好的异步 API(如挂起函数版本)以当前版本为准。
原理流程
- 协程切到 IO 调度器。
- 在事务闭包内执行阻塞 JDBC 操作。
- 事务结束归还连接。
- 结果返回协程上下文。
代码或图示
suspend fun loadOrder(id: Long): Order? = withContext(Dispatchers.IO) {
transaction { OrderEntity.findById(id)?.toDomain() }
}
常见误区
- 在 CPU/事件循环调度器上跑阻塞事务,拖慢其他协程。
- 事务闭包内启动新协程并使用同一连接,连接跨线程不安全。
追问
- 连接能跨协程复用吗?答:事务连接绑定线程与事务上下文,不要跨协程传递使用。
- 异步非阻塞驱动有支持吗?答:Exposed 主流仍是 JDBC 阻塞模型;非阻塞 SQL 驱动生态另选方案,待确认版本支持情况。
06.8.3.2-076 阻塞 IO 与协程调度器怎么配合?
一句话结论
数据库访问属于阻塞 IO,应在 IO 调度器上执行;不要在默认调度器上长时间阻塞,也不要把阻塞调用包装成挂起函数却不切线程。
概念解释
Kotlin 协程挂起函数本身不阻塞线程,但 JDBC 调用是阻塞的。withContext(Dispatchers.IO) 切到 IO 线程池执行阻塞段。IO 池容量影响并发数据库访问上限,与连接池大小匹配。
原理流程
- 业务协程在默认调度器编排。
- 进入数据访问段切 IO 调度器。
- 阻塞事务执行。
- 返回结果后回到原上下文。
代码或图示
suspend fun placeOrder(req: OrderRequest) = withContext(Dispatchers.IO) {
transaction { orderRepository.save(req.toEntity()) }
}
常见误区
- 阻塞调用不切调度器,事件循环被卡住。
- IO 调度器线程数远大于连接池,等待连接的线程堆积。
追问
- 怎么统计阻塞耗时?答:数据访问段单独埋点,区分协程等待与线程阻塞。
- 异步事务 API 缺失时的折中?答:阻塞调用隔离在 IO 层,上层保持协程编排。
06.8.3.2-077 连接获取超时怎么配置,超时说明什么?
一句话结论
获取连接超时指等待池分配连接的最长时间,超时抛获取异常;它说明池被占满或事务过长,而不是单条 SQL 慢。
概念解释
线程先等连接再执行 SQL。获取超时阈值通常短于请求整体超时。超时计数持续上升意味着池容量与事务持有时间不匹配,需要调池大小或缩短事务,而不是只放大超时时间。
原理流程
- 请求进入,尝试从池借连接。
- 池无空闲连接则排队等待。
- 超过获取超时阈值抛异常。
- 监控等待队列长度与获取超时次数。
代码或图示
连接池指标:active / idle / pending waiters / acquisition timeout count
常见误区
- 把获取超时调很大,线程长时间挂住,请求堆积雪崩。
- 混淆获取超时与 SQL 执行超时,排查方向跑偏。
追问
- 池满了先调大池吗?答:先看占用原因(长事务/慢 SQL/泄漏),盲目加连接会压垮数据库。
- 获取连接与执行 SQL 指标分开埋吗?答:分开记录,便于定位等待段。
06.8.3.2-078 连接空闲回收与最大生命周期怎么设置?
一句话结论
空闲超时回收闲置连接,最大生命周期避免连接长期持有出现隐性失效;参数按数据库与驱动的连接有效期设定,回收由池负责,业务无感知。
概念解释
连接长期空闲可能被数据库或中间件断开,池内保留失效连接会导致首次使用报错。最大生命周期强制重建连接。空闲连接数保留到最小空闲值,兼顾响应速度与资源占用。具体参数名按连接池实现确认。
原理流程
- 池按空闲超时回收超出最小空闲的连接。
- 连接存活超过最大生命周期后关闭重建。
- 借出时做有效性校验(按池配置)。
- 业务侧不感知连接重建。
代码或图示
// 参数名以 HikariCP 为准;示例表达语义
hikari {
minimumIdle = 5
idleTimeout = 600_000
maxLifetime = 1_800_000
}
常见误区
maxLifetime长于数据库侧连接超时,池内持有已被服务端关闭的连接。- 空闲回收过激进,高峰频繁建连增加抖动。
追问
- 连接有效性怎么校验?答:池配置测试查询或驱动 ping;具体开关按池实现确认。
- 建连开销大怎么办?答:保留合理最小空闲连接,预热池。
06.8.3.2-079 压测时连接池水位怎么调优?
一句话结论
压测先固定业务场景与事务耗时,观察活跃连接、等待队列、CPU 与数据库负载,找到「池利用率高但无排队、数据库未过载」的水位区间。
概念解释
池大小不是越大越好:过大挤占数据库连接、增加上下文切换;过小请求排队。压测记录不同并发下的活跃连接数、等待数、SQL 耗时与数据库 CPU,确定最优配置。事务耗时变长时同样并发需要更多连接。
原理流程
- 基线压测记录各指标。
- 逐步提升并发,观察排队出现拐点。
- 调整池大小与数据库容量匹配。
- 回归验证接口 P99 与错误率。
代码或图示
并发 ↑ → 活跃连接 ↑ → 等待队列出现 → 数据库 CPU/锁等待 → 拐点定池大小
常见误区
- 按经验公式定池,不结合实际事务耗时压测。
- 压测数据量与生产差距大,水位结论失真。
追问
- 多个服务实例共享数据库怎么算总连接?答:单实例池大小 × 实例数,不超过数据库最大连接预留。
- 池指标在哪看?答:接入 Micrometer 暴露池指标,见 06.8.5.2。
06.8.3.2-080 怎么监控 SQL 执行指标?
一句话结论
至少记录语句耗时、执行次数、慢语句指纹与错误数;通过连接池/框架埋点或数据库侧慢日志采集,按接口与 SQL 指纹聚合。
概念解释
单条 SQL 日志便于排查,聚合指标才能发现趋势问题。指标维度包括接口、SQL 指纹(去掉参数)、耗时区间。慢日志抓长尾,直方图看整体分布。具体 Exposed 拦截/埋点扩展点待确认。
原理流程
- 在数据访问层或池层拦截语句执行。
- 记录开始/结束时间与 SQL 指纹。
- 上报耗时指标与计数。
- 慢语句明细进入日志供下钻。
代码或图示
指标:sql.latency{fingerprint=..., table=...} 直方图
日志:慢 SQL 指纹、参数脱敏、耗时、调用接口
常见误区
- 只记总耗时,不按 SQL 指纹聚合,定位不到热点语句。
- 日志打印完整敏感参数,违反脱敏要求。
追问
- SQL 指纹怎么生成?答:归一化字面量参数后取语句模板;具体实现按框架/中间件能力。
- 慢阈值设多少?答:按接口 SLO 分层设定,核心写路径阈值更严。
06.8.3.2-081 慢 SQL 日志怎么开启?
一句话结论
应用侧通过框架/连接池日志配置输出执行语句与耗时,数据库侧开启慢查询日志;两边配合才能同时拿到语句指纹与库内执行画像。具体 logger 开关名称以 0.5x 与数据库文档为准(待确认)。
概念解释
应用日志带接口上下文与参数(脱敏),数据库慢日志带执行计划相关统计。开发环境可开完整语句日志,生产按采样或阈值输出,避免日志量爆炸。
原理流程
- 配置框架/驱动日志级别输出 SQL。
- 数据库设置慢查询阈值。
- 两边日志按时间与 traceId 关联。
- 定期 review 慢语句清单。
代码或图示
应用日志:traceId、SQL 模板、绑定参数(脱敏)、耗时
数据库慢日志:语句、扫描行数、执行时长、锁等待
常见误区
- 生产开全量 SQL 日志,日志体积与磁盘 IO 压垮服务。
- 只看应用侧耗时,不查库内执行计划。
追问
- 参数要打印吗?答:敏感字段脱敏,必要参数用于复现;禁止打印密钥与隐私字段。
- 日志级别运行时可调吗?答:按日志框架能力动态调整,见 06.8.5.2。
06.8.3.2-082 预编译语句缓存有什么作用?
一句话结论
预编译缓存复用语句执行计划,减少重复解析与编译开销;JDBC 驱动与连接池层可配置缓存,跨连接复用策略按驱动实现确认(待确认)。
概念解释
相同结构 SQL 只参数不同时,预编译缓存保留语句解析结果。缓存命中降低数据库 CPU。Exposed 生成语句结构稳定,利于命中缓存。缓存大小与方言特性需结合驱动配置。
原理流程
- 首次执行语句,数据库解析生成执行计划。
- 缓存登记语句模板。
- 同模板后续执行复用计划。
- 缓存失效按驱动策略清理。
代码或图示
重复执行:WHERE user_id = ? → 模板缓存命中,仅绑定新参数
常见误区
- 每条语句拼接不同字面量,模板无法复用,缓存失效。
- 误以为缓存解决执行计划本身低效的问题。
追问
- 语句模板不稳定怎么优化?答:参数走占位符,不拼字面量;排序/分组字段白名单选择。
- 缓存占内存吗?答:配置缓存上限,监控内存占用。
06.8.3.2-083 参数绑定为什么能防 SQL 注入?
一句话结论
参数绑定把值与语句结构分开传输,值永远作为数据处理,不会被解析成 SQL 语法;拼接字面量进语句才存在注入风险。
概念解释
绑定参数由驱动按类型转义下发,数据库先固定语句结构再填值。用户输入即使含 SQL 片段也只作为字符串值。ORM/DSL 生成语句默认走绑定,原生 SQL 必须显式占位符绑定。
原理流程
- 语句模板与参数分离。
- 驱动/数据库预编译模板。
- 参数按类型安全绑定。
- 输入中的特殊字符不参与语法解析。
代码或图示
// 安全:参数绑定
Users.select { Users.name eq inputName }
// 危险:字符串拼接(禁止)
// "SELECT * FROM users WHERE name = '" + inputName + "'"
常见误区
- 用 DSL 但排序字段/表名通过输入拼接,结构部分仍可注入。
- 认为参数化能防所有注入,动态标识符(列名、表名)需要白名单。
追问
- 动态排序字段怎么安全处理?答:字段名映射到白名单列对象,不直接拼输入。
- 原生 SQL 怎么自查?答:代码评审检查占位符使用,扫描字符串拼接 SQL。
06.8.3.2-084 动态查询条件怎么拼接才安全?
一句话结论
条件由 DSL 表达式组合,用户输入只作为绑定值;动态标识符走白名单映射,禁止把输入片段直接拼进 SQL 文本。
概念解释
多条件组合(可选过滤、排序、分页)常见于查询接口。DSL 用 and/or/op 组合表达式,值部分绑定。表名、列名、排序方向不能来自输入,需映射到预定义枚举或列对象。
原理流程
- 接收查询参数并校验。
- 可选条件逐段加入表达式。
- 排序字段映射白名单。
- 生成最终 DSL 查询执行。
代码或图示
var cond = Users.deletedAt.isNull()
if (status != null) cond = cond and (Users.status eq status)
if (keyword != null) cond = cond and (Users.name like "%$keyword%")
Users.select { cond }
常见误区
like拼接通配符未转义,特殊字符匹配范围失控。- 排序方向直接接收字符串拼进 orderBy。
追问
- 模糊查询性能怎么保证?答:前缀匹配可用索引,通配在前无法用索引;大范围模糊走搜索组件。
- 条件组合复杂怎么维护?答:抽查询构造器,按参数对象组装表达式。
06.8.3.2-085 join 后结果怎么映射到实体与 DTO?
一句话结论
join 查询按投影列直接映射 DTO;需要主表实体时单独按主键查询,不在 join 结果行上手工构造实体。
概念解释
join 行跨多表列,实体装配需要完整主表列与伴随对象元数据。混合映射容易漏列或混入关联列。读模型接口直接投影 DTO 最清晰,写路径再走实体。
原理流程
- DSL 声明 join 与投影列。
- 行映射为 DTO 字段。
- 如需主实体,按结果主键二次查询。
- 避免在 join 行上伪造实体。
代码或图示
val result = Orders.join(Users, JoinType.INNER)
.select { Orders.status eq "PAID" }
.map { OrderWithUserDto(it[Orders.id].value, it[Users.name]) }
常见误区
- join 多表后
selectAll,传输与映射多余列。 - 关联表字段可空时未判空,映射 NPE。
追问
- 一对多 join 行数膨胀怎么处理?答:主表与子表分开批量查询后内存拼装,避免 join 笛卡尔膨胀。
- 映射代码放哪?答:查询层私有 mapper,跟随 Repository 方法。
06.8.3.2-086 关联数据预加载的性能权衡是什么?
一句话结论
预加载用额外批量查询换取消解 N+1,代价是多取数据与内存占用;按接口实际需要决定预加载层级,不做无差别全量关联拉取。
概念解释
批量预取减少 SQL 次数,但把关联数据一并加载,字段与行数都可能膨胀。层级越深内存占用越高。按页面展示需要决定预取哪些关联,列表页不加载详情级关联。
原理流程
- 梳理接口返回需要的关联层级。
- 必要关联批量预取。
- 内存拼装视图模型。
- 无关关联延迟到详情接口。
代码或图示
val orders = orderRepo.findRecent(userId, limit)
val items = itemRepo.findByOrderIds(orders.map { it.id }) // 批量预取
常见误区
- 为「可能用到」预加载全部关联,列表接口内存翻倍。
- 预取
inList集合过大,拆批又遗漏分组。
追问
- 预取层级多深合适?答:通常一到两层;更深关联走独立详情接口。
- 怎么评估收益?答:对比预取前后 SQL 次数、内存与接口耗时。
06.8.3.2-087 游标分页接口的 cursor 怎么编码与解析?
一句话结论
cursor 编码上一页最后一条的排序键值,服务端解析后作为下一页起点;编码要防篡改、不暴露内部敏感信息,并处理排序键组合。
概念解释
cursor 本质是 keyset 定位条件的序列化。直接暴露主键简单,组合排序键(时间+ID)需编码多字段。cursor 不应携带过滤条件以外的状态,篡改后按非法 cursor 处理。编码可用 URL 安全编码或不透明令牌。
原理流程
- 首页返回最后一条排序键组成的 cursor。
- 下一页请求带 cursor,服务端解码校验。
- 按 cursor 值构造
WHERE key < lastKey条件。 - 返回新 cursor。
代码或图示
data class PageCursor(val lastId: Long, val lastCreatedAt: Instant)
// 编码为 URL 安全字符串;解码失败返回第一页或报错
常见误区
- cursor 里塞入业务参数,翻页时条件被篡改。
- 排序键不唯一,cursor 翻页漏/重数据。
追问
- cursor 要签名吗?答:防止篡改可加签名或服务端记录;内部低风险场景可只做格式校验。
- 支持跳页吗?答:游标分页不支持跳页,跳页场景回到 offset 或搜索条件收敛。
06.8.3.2-088 数据访问层单元测试怎么组织?
一句话结论
纯映射与条件构造逻辑可单测;真实 SQL 行为用集成测试连目标数据库(或 Testcontainers)验证,不应该用 mock 掉 Repository 后假装验证了数据访问。
概念解释
单测覆盖 DTO 映射、条件组装、业务规则;SQL 正确性、约束行为、索引命中必须在真实库上验证。H2 等内存库只做局部快速验证,方言差异用目标库容器兜底。测试分层整体见 06.8.5.3。
原理流程
- 纯函数映射直接单测。
- Repository 方法在测试库起真实连接执行。
- 准备数据、执行、断言库中状态。
- 用例间清理隔离。
代码或图示
@Test
fun `save order persists status`() = integrationTest {
repo.save(Order(id = 1, status = "PAID"))
assertThat(repo.findById(1)?.status).isEqualTo("PAID")
}
常见误区
- mock 掉 DAO 返回值,断言的是 mock 行为而非真实持久化。
- 测试只在内存库通过,生产方言行为未验证。
追问
- 集成测试起库慢怎么办?答:复用 Testcontainers 容器、并行分库,见 06.8.5.3。
- 怎么测唯一约束冲突?答:真实库插入重复键,断言异常类型与错误码映射。
06.8.3.2-089 查询返回空结果时的处理约定是什么?
一句话结论
单条查询返回可空,调用方明确处理 null;列表空返回空集合而不是 null;业务上「必须存在」的记录缺失属于异常,显式报错而非静默返回空。
概念解释
可空返回迫使调用方判断缺失场景。列表返回 null 容易在上层引发 NPE。区分「查不到是正常空态」与「查不到是数据异常」:前者返回空,后者抛业务异常。
原理流程
- 单条查询返回
Entity?。 - 业务判断缺失是否可接受。
- 列表方法保证返回空集合。
- 必须存在的记录缺失时抛异常并记录上下文。
代码或图示
val order = OrderEntity.findById(id) ?: throw NotFoundException("order $id")
常见误区
- 列表方法返回 null,上层
map时空指针。 - 必须存在的记录缺失被静默当空态处理,问题延后爆发。
追问
- 对外接口怎么表达空态?答:单条 404 或空对象结构按 API 约定;列表返回空数组。
- 缓存未命中与库空怎么区分?答:缓存层区分空值标记,避免空结果反复打库。
06.8.3.2-090 数值列精度与小数类型怎么选择?
一句话结论
金额等精确计算用定点十进制类型,不用浮点类型;Kotlin 侧用 BigDecimal,避免二进制浮点误差累积。
概念解释
浮点数存在精度表示误差,累计计算后金额偏差。数据库定点列(如 DECIMAL/NUMERIC)存精确十进制,Kotlin 侧对应 BigDecimal。整数计数用整数类型。列精度与标度按业务最大位数设计。
原理流程
- 字段判断是否需要精确小数。
- 表声明定点类型与标度。
- 实体属性映射
BigDecimal。 - 计算使用定点运算,禁止转 double 参与金额计算。
代码或图示
object Orders : LongIdTable("orders") {
val amount = decimal("amount", 12, 2)
}
常见误区
- 金额用
double/float,对账出现分位误差。 - 标度不够,四舍五入丢失精度。
追问
- 汇率折算怎么处理?答:保存原值与汇率,折算规则在领域层明确,精度口径统一。
- 展示层格式化?答:数据库存原值,展示按币种格式化,不在库内做四舍五入。
06.8.3.2-091 写入路径性能 checklist 有哪些?
一句话结论
写入检查:短事务、批量写入、索引数量受控、无循环 RPC、唯一约束兜底、批量分批与连接池匹配。
概念解释
写路径成本来自语句执行、索引维护、锁竞争与往返次数。逐条 insert 批量场景改为批量语句;事务内不夹带外部调用;监控写锁等待与慢更新。索引过多拖慢写入,定期清理冗余索引。
原理流程
- 检查事务边界是否最短。
- 批量场景用批量语句分批提交。
- 复核索引数量与写入放大。
- 监控更新耗时、锁等待与冲突重试。
代码或图示
写入 checklist:事务短 / 批量批处理 / 无循环外部调用 / 索引受控 / 约束完整 / 连接池匹配
常见误区
- 循环单条 insert 却认为「数据量不大没问题」。
- 索引只增不清理,写入成本持续上升。
追问
- 批量写入批大小怎么定?答:压测单批行数与提交间隔,权衡往返次数与事务大小。
- 写入慢先看什么?答:锁等待、索引维护、语句执行计划与连接池排队。
06.8.3.2-092 读取路径性能 checklist 有哪些?
一句话结论
读取检查:只取需要列、分页限流、索引命中、无 N+1、count 可控、大字段按需加载、结果集不超内存。
概念解释
读路径问题多为全表扫描、关联 N+1、大结果集与大字段带出。列表接口限定返回字段与行数,关联批量预取,统计走投影。执行计划定期复核索引命中。
原理流程
- 检查查询条件与索引匹配。
- 复核投影列是否必要。
- 关联读取批量预取。
- 分页/游标限制结果大小。
代码或图示
读取 checklist:索引命中 / 投影精简 / 分页限流 / 批量预取 / 大字段按需 / count 优化
常见误区
- 列表接口返回实体全字段,大文本一并带出。
- 不限制行数,异常参数导致全表拉取。
追问
- 读路径缓存怎么加?答:读多写少结果加缓存,注意失效与一致性。
- 慢读怎么定位?答:SQL 日志 + 执行计划 + 接口耗时分段,见慢查询题目。
06.8.3.2-093 数据访问层异常怎么分类处理?
一句话结论
异常分数据问题(未找到、冲突、约束)、基础设施问题(连接、超时、库不可用)与编程问题(类型映射、语句错误);分层映射,不在上层暴露数据库原生异常细节。
概念解释
数据库异常经过 Repository 出口翻译为业务异常或基础设施异常。未找到、唯一冲突、外键约束属于可预期业务结果;连接失败、超时属于基础设施故障;映射错误多为代码缺陷。异常携带上下文信息便于排查。
原理流程
- 捕获底层异常并识别 SQL 状态码/类型。
- 映射为领域异常或数据访问异常。
- 上层按异常类型决定提示、重试或告警。
- 原始堆栈保留在日志。
代码或图示
try {
transaction { repo.save(entity) }
} catch (e: DuplicateKeyException) {
throw BusinessConflict("duplicate", e)
} catch (e: SQLException) {
throw DataAccessFailure("db error", e)
}
常见误区
- 直接把
SQLException抛到接口层,泄露库类型与语句细节。 - 所有异常都包装成同一类型,重试策略无法区分。
追问
- 哪些异常可重试?答:连接超时、死锁、锁等待等瞬时基础设施/并发异常;业务冲突不重试。
- 异常信息带哪些上下文?答:业务 ID、操作类型,不带敏感参数与完整 SQL。
06.8.3.2-094 事务内只读校验与写操作的边界怎么划?
一句话结论
需要与写入一致读取的校验在同一事务内做,可延后的校验与通知移出事务;先做不依赖库的参数校验,再进事务做一致性校验。
概念解释
业务校验分三类:纯参数格式校验(进事务前)、依赖当前数据状态的一致性校验(事务内)、外部规则校验(尽量事务外)。事务内校验读到的行在锁保护下判断,避免校验后被他人修改。
原理流程
- 入口校验参数格式与权限。
- 事务内读取并做一致性判断。
- 写入后提交。
- 后置通知/异步处理在提交后执行。
代码或图示
fun placeOrder(req: OrderRequest) {
validateRequest(req) // 事务外纯校验
transaction {
val stock = stockRepo.findById(req.sku) ?: error("no stock")
check(stock.quantity >= req.count)
stock.decrease(req.count)
}
publishEvent(...) // 提交后
}
常见误区
- 事务外读到旧数据做校验,进事务后状态已变。
- 把外部规则校验放事务内,拉长事务。
追问
- 校验失败回滚吗?答:事务内校验抛异常即回滚本次写入。
- 跨聚合一致性校验怎么做?答:接受最终一致或引入协调机制,不在单事务内跨库。
06.8.3.2-095 多环境数据库配置有哪些差异需要注意?
一句话结论
各环境数据库方言、连接参数、池大小、迁移目标应通过配置区分;结构由迁移脚本统一保证,环境差异只体现在连接与性能参数上。
概念解释
开发、测试、预发、生产的库地址、账号、池容量、超时阈值不同,但表结构口径一致。环境配置从环境变量或配置文件读取,不硬编码。测试环境可使用容器化目标数据库保证方言一致。
原理流程
- 连接信息按环境注入。
- 迁移脚本在各环境执行到对应版本。
- 池与超时参数按环境容量调整。
- 生产禁用自动建表与调试日志。
代码或图示
env: DB_URL / DB_USER / DB_POOL_SIZE / DB_TIMEOUT
结构:所有环境同一套迁移脚本
常见误区
- 本地库结构与迁移历史脱节,部署时才暴露问题。
- 生产沿用开发环境宽松超时与大池配置。
追问
- 环境配置怎么校验?答:启动时校验必填项与连接,缺失即失败,见 06.8.5.2。
- 方言在多环境不一致怎么办?答:生产方言为准,测试环境对齐;兼容写法在代码层处理。
06.8.3.2-096 Exposed 0.5x 中需要重点核实的 API 有哪些?
一句话结论
涉及锁类型参数、JSON 列辅助、原生 SQL 执行、协程集成、只读事务标志、索引声明方法等 API,在定稿前对照 0.5x 官方文档与源码核实,不确定处保留「待确认」与验证点。
概念解释
0.4x 到 0.5x 之间存在 API 命名与包结构调整,记忆中的方法名可能过时。面试回答时区分稳定概念(事务、缓存、锁、索引原理)与版本敏感 API(具体函数名、参数名)。验证方式:查官方文档、跑最小示例、对照依赖版本源码。
原理流程
- 列出代码中使用的 Exposed API。
- 对照当前版本文档核对签名。
- 最小工程编译运行验证。
- 无法确认的标注待确认与验证步骤。
代码或图示
待确认类别:锁参数名 / JSON 列类型 / exec 原生 SQL / 协程模块 / 只读标志 / 索引 DSL
验证点:依赖版本号、官方文档版本、最小可运行示例
常见误区
- 凭旧版本记忆写 API 名,编译才发现签名变化。
- 把第三方教程的旧写法当成当前版本行为。
追问
- 怎么查当前依赖版本?答:查构建文件依赖版本与发布说明,以实际引入版本为准。
- 文档与源码不一致时信哪个?答:以实际运行的源码行为为准,记录差异反馈。
06.8.3.2-097 数据访问层怎么做安全审计?
一句话结论
审计点包括:参数绑定防注入、敏感字段脱敏、权限校验前置、最小权限数据库账号、操作留痕;代码评审与静态扫描覆盖拼接 SQL 与明文敏感数据。
概念解释
数据层安全不只防注入,还包括账号权限范围、敏感列访问与操作记录。数据库账号只授予业务所需表与操作;敏感字段查询与导出有审批与日志。审计字段记录关键变更人。
原理流程
- 检查 SQL 构造全部绑定参数。
- 数据库账号按最小权限配置。
- 敏感字段访问与导出记录审计日志。
- 静态扫描拦截拼接 SQL 与明文密钥。
代码或图示
审计清单:绑定参数 / 账号最小权限 / 敏感列脱敏 / 操作留痕 / 无硬编码凭据
常见误区
- 应用账号拥有 DDL 或全库读写权限,泄露后影响面过大。
- 导出接口不记录操作人,事后无法追溯。
追问
- 密码/密钥列怎么存?答:加盐哈希存储,不可逆;不在日志与响应中出现。
- 审计日志放哪?答:独立审计记录,不依赖业务表软删除。
06.8.3.2-098 数据访问层如何做容量与增长规划?
一句话结论
按表数据量增长、写入速率与查询模式评估索引、归档与分表边界;容量规划结合历史增长曲线与业务预期,定期复核慢查询与空间使用。
概念解释
单表数据量过大后索引维护、查询与备份成本上升。规划包括冷热数据归档、大表拆分评估、索引容量预估。写入热点(自增主键、热点行)也要识别。容量指标定期复盘,不一次设计过度。
原理流程
- 统计各表行数、增量、写入 QPS 与慢查询。
- 评估单表阈值与归档策略。
- 识别热点行与大事务。
- 达到阈值前启动拆分/归档方案。
代码或图示
容量指标:行数 / 日增 / 索引体积 / 写入 QPS / 慢查询 / 主从延迟
常见误区
- 只在性能出问题后考虑扩容,归档方案来不及落地。
- 过度设计分片,业务复杂度提前上升。
追问
- 历史数据怎么归档?答:冷数据迁归档表/存储,主表保留近期窗口;归档脚本分批执行。
- 分表键怎么选?答:按高频查询维度选择,避免跨分片查询;分布式方案见 09 分册。
06.8.3.2-099 面试题:订单模块需要调整库存并写订单,数据访问层怎么设计?
一句话结论
短事务内完成库存扣减与订单写入,并发控制用原子扣减或悲观/乐观锁;外部通知移出事务,冲突与超卖靠唯一约束与库存校验兜底。
概念解释
核心是一致性与并发:扣库存与建订单要么都成功要么都回滚。热点商品库存竞争激烈,优先数据库原子表达式扣减;冲突重试有限次。订单与库存分表时评估跨表事务边界,必要时最终一致。
原理流程
- 参数与权限校验在事务外。
- 事务内锁定/读取库存,校验可用量。
- 原子扣减并写订单。
- 提交后发事件通知下游。
代码或图示
transaction {
val updated = Stocks.update({ Stocks.sku eq sku and (Stocks.quantity geq count) }) {
it[quantity] = quantity - count
}
if (updated == 0) throw OutOfStockException(sku)
OrderEntity.new { /* ... */ }
}
常见误区
- 先读后写非原子扣减,超卖。
- 事务内等待支付/通知,拉长锁持有。
追问
- 库存为预热缓存怎么同步?答:缓存扣减与数据库扣减一致性靠消息对账,热点方案见缓存章节。
- 订单与库存跨服务怎么办?答:本地消息表 + 最终一致,补偿回滚库存。
06.8.3.2-100 面试题:列表接口响应慢,数据访问层如何系统排查?
一句话结论
按「指标分段 → SQL 日志 → 执行计划 → 数据与索引 → 代码关联」逐层定位:先区分等连接、SQL 慢还是应用处理慢,再拿语句做执行计划分析,最后检查 N+1 与结果集大小。
概念解释
排查顺序避免一上来加索引:先看接口耗时分段与池指标,确认瓶颈段;再取 SQL 指纹看慢日志;EXPLAIN 检查扫描行数与索引;检查循环内关联查询与大字段;必要时压测复核。结论要落到具体语句与索引/改写措施。
原理流程
- 监控定位慢在等待连接、SQL 还是应用段。
- 抓 SQL 模板与参数,脱敏后复现。
EXPLAIN看 type/rows/key/Extra。- 检查 N+1、投影列、分页与 count。
- 改写或补索引后复测执行计划与 P99。
代码或图示
分段耗时 → SQL 指纹 → 执行计划 → 索引/条件 → N+1/结果集 → 改写复测
常见误区
- 不看分段直接加索引,瓶颈其实在连接池或应用序列化。
- 测试环境数据量小,执行计划结论与生产不符。
追问
- 慢只在偶发流量出现?答:结合锁等待、连接池排队与下游依赖时间线定位并发因素。
- 优化后怎么确认有效?答:对比优化前后 SQL 次数、扫描行数与接口 P99,观察慢日志清单下降。
参考来源
- Exposed 官方文档:DAO 实体与表定义 — DAO API、Entity/EntityClass 与查询入口说明。
- Exposed 官方文档:DSL 与事务 — 查询表达式、事务与批量写入的 DSL 用法。
- Exposed 官方 Wiki:迁移与 SchemaUtils — 表结构工具与方言支持说明(具体条目以当前版本目录为准)。
- Flyway 官方文档 — 版本化迁移脚本、baseline 与校验机制。
- Liquibase 官方文档 — changeset、回滚与结构化变更管理。
待整理清单
- [ ] 核对 Exposed 0.5x 中悲观锁参数名、JSON 列辅助 API、原生 SQL 执行入口与协程集成模块的准确签名
- [ ] 核实 0.5x 是否提供内置乐观锁版本号注解或实体生命周期回调扩展点
- [ ] 补充当前版本索引声明 DSL 的准确方法名与可空/默认值列定义写法
- [ ] 整理 MySQL 与 PostgreSQL 在部分唯一索引、并发建索引、upsert 方言差异的对照案例
- [ ] 补充连接池(HikariCP)与 Exposed 连接配置的当前版本参数示例
- [ ] 待确认:0.5x 跨事务访问未加载实体属性的实际行为与异常类型