罗罗编程学习记录
本页内容 展开查看

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 那样的一级/二级缓存体系。

原理流程

  1. 表定义同时被 DSL(列表达式)和 DAO(实体属性映射)复用。
  2. DAO 查询入口在伴随对象上(findById、find、all),内部仍构造 DSL 查询并把结果行装配成实体。
  3. 修改实体属性后,提交事务时按脏状态生成 update。
  4. 需要聚合、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 索引离散写入更容易产生页分裂。

原理流程

  1. 表继承对应 IdTable,主键列由基类提供,名为 id。
  2. 实体 EntityID<ID> 包装主键值,外键引用其他实体时保存 entityId。
  3. 新建实体时自增列在 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 通过它把结果行装配为实体。实体必须在事务内被读取和修改,脱离事务后访问未加载属性的行为需结合具体实现判断(待确认)。

原理流程

  1. 表定义列。
  2. 实体类声明 var x by 表.x,委托由 Exposed 生成读写桥。
  3. 伴随对象 EntityClass 负责 new、find、findById 等入口。
  4. 插入走 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 缓存。

原理流程

  1. 进入事务时创建事务级实体上下文。
  2. 查询装配实体前先查缓存,命中则复用。
  3. 未命中则执行 SQL 并登记。
  4. 事务提交或回滚后缓存随上下文丢弃。

代码或图示

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 无过滤条件。结果装配是惰性还是即时取决于调用终止操作,遍历时才真正物化。

原理流程

  1. 伴随对象把方法调用转成 DSL 查询。
  2. 查询执行后逐行映射为实体并登记到事务缓存。
  3. 单条结果为空时返回 null;多条结果按序列返回。
  4. 调用方在事务内读取属性,离开事务后行为需谨慎(待确认跨事务属性访问是否报错)。

代码或图示

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 语句先落库、实体脏值后覆盖的顺序问题。

原理流程

  1. 两者复用同一 Table 元数据与同一事务连接。
  2. DAO 修改进入实体脏集合;DSL 语句即时排队执行。
  3. 提交时按 Exposed 内部顺序刷脏(具体刷脏时机待确认)。
  4. 混用时建议一条业务路径只选一种风格,需要交叉时先 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 源码为准(待确认)。

原理流程

  1. 实体装配时列值从结果行写入。
  2. 属性赋值委托把列加入脏集合。
  3. flush 或提交时对有脏列的实体生成 update。
  4. 无脏列的实体不产生 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() 二义性方法,新增与修改入口分离。

原理流程

  1. new 创建未持久化实体,块内赋值。
  2. 提交时实体进入 insert 流程并回填主键。
  3. 已加载实体属性赋值进入脏集合,提交生成 update。
  4. delete() 登记删除,提交执行 DELETE。

代码或图示

transaction {
    val u = UserEntity.new { name = "tom"; age = 20 }
    u.age = 21          // 更新
    // u.delete()       // 删除
}

常见误区

  • 以为 new 后立即拿到数据库生成的自增主键:主键回填时机与 flush 时机相关,跨步骤使用前需确认(待确认)。
  • 在事务外调用 delete():没有连接上下文,无法执行。

追问

  • 批量插入为什么不循环 new?答:循环 new 每条一次 insert;大批量走 DSL batchInsert 减少往返。
  • 删除被外键引用的实体怎么办?答:先处理子表或依赖数据库外键策略,违反约束会抛数据库异常。

06.8.3.2-009 实体生命周期有哪几个状态?

一句话结论

可粗略分为新建未持久化、已加载持久化、脏已修改、已删除四种状态;Exposed 没有像 JPA 那样开放标准化的状态枚举,状态由实体内部标记与数据库行共同决定。

概念解释

新建来自 new,尚未 insert;已加载来自查询,与库中行对应;脏表示属性被修改待 flush;已删除表示 delete() 已调用。状态迁移发生在事务内,事务回滚后内存实体与库的对应关系需要重新加载。

原理流程

  1. new → 新建状态。
  2. 提交 insert 后 → 持久化状态。
  3. 赋值 → 脏状态。
  4. 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 的主要来源之一。

原理流程

  1. 本实体行加载时外键值已读入。
  2. 访问 entity.manager 时按 entityId 查询被引用实体。
  3. 被引用实体在当前事务缓存中命中则复用。
  4. 仅需要 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 } 获取。结合事务缓存可减少重复查询,但仍是显式查询。

原理流程

  1. 父实体加载。
  2. 业务代码按父 ID 查询子表。
  3. 子实体装配后在内存组成集合返回。
  4. 多父实体场景先批量取子表再分组,避免循环查询。

代码或图示

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 或在事务外报错;实体字段名与库列耦合,表结构改动会直接影响接口。领域对象与传输对象分离也便于做版本演进与字段裁剪。

原理流程

  1. Controller 拿到实体。
  2. 序列化器反射访问属性,懒引用触发查询。
  3. 内部字段、审计字段一并被带出。
  4. 表结构变更外溢为接口变更。

代码或图示

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,不要在业务层强制非空断言。

原理流程

  1. 表定义列是否可空。
  2. 实体委托类型与列一致。
  3. insert/update 按值类型绑定参数。
  4. 数据库 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 存储体积小但枚举顺序调整会错位。

原理流程

  1. 定义枚举类。
  2. 表列选择存储类型并声明转换。
  3. 实体属性类型为枚举,读写时在 name/ordinal 与库值之间转换。
  4. 未知枚举值反序列化时需要兜底策略。

代码或图示

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 中未见等价标准实现,使用前需核实文档(待确认)。

原理流程

  1. 表增加 version 整数列。
  2. 读取实体时拿到当前版本。
  3. 更新语句带旧版本号条件。
  4. 影响行数 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 需对照文档确认(待确认)。

概念解释

事务内先锁定行再读取修改,其他事务阻塞等待或按锁策略跳过。适合强竞争下的资金扣减、库存扣减等必须串行化的短临界区。锁持有时间受事务长度影响,长事务会放大阻塞。

原理流程

  1. 事务开启,隔离级别确定锁语义。
  2. 查询时声明 FOR UPDATE,数据库对命中行加排他锁。
  3. 当前事务完成修改并提交,锁释放。
  4. 其他等待事务获得锁后继续。

代码或图示

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 谓词扩展由团队封装。

原理流程

  1. 表增加可空时间戳列 deletedAt。
  2. 删除操作把当前时间写入该列,不执行物理 delete。
  3. 所有查询谓词追加 deletedAt isNull。
  4. 唯一索引在软删除场景需要拼接删除时间或使用部分唯一索引(方言支持)。

代码或图示

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 基类或实体工厂里统一赋值;数据库方案靠列默认值与触发器/方言更新子句。两种方案不要混用导致值来源不一致。

原理流程

  1. 表声明两个时间戳列。
  2. 新建路径写入当前时间到两列。
  3. 更新路径刷新 updatedAt。
  4. 查询展示与审计问题排查时按时间字段追溯。

代码或图示

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 以文档为准(待确认)。不同数据库方言在冲突子句语法上有差异。

原理流程

  1. 表上存在目标唯一索引。
  2. 批量 insert 携带多行。
  3. 冲突时按子句更新指定列。
  4. 受影响行数与冲突行为在方言层落地。

代码或图示

// 意图示例:冲突时更新名称与更新时间;子句 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) 组合)作为条件,直接定位起点,避免跳过大量行。游标要求排序键唯一且稳定。

原理流程

  1. offset:SELECT ... ORDER BY id LIMIT n OFFSET m。
  2. 游标:WHERE id < lastId ORDER BY id DESC LIMIT n。
  3. 排序键需唯一,避免同值翻页漏数据。
  4. 总数展示另走 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 分组拼装。

原理流程

  1. 打开 SQL 日志,观察一次请求内 select 条数。
  2. 定位循环内访问的引用属性。
  3. 收集父实体外键集合。
  4. 批量查询子实体并分组,业务层组装。

代码或图示

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 指纹与关键参数(脱敏后)。

原理流程

  1. 应用日志或数据库慢日志捕获耗时 SQL。
  2. 复制语句与参数到库内 EXPLAIN。
  3. 检查 type/rows/key/Extra,定位全表扫描或文件排序。
  4. 补索引或改写查询,复测执行计划。

代码或图示

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 需对照文档确认(待确认)。

原理流程

  1. 分析查询条件、排序、分组字段。
  2. 按等值在前、范围在后设计组合列顺序。
  3. 在表定义与迁移脚本同步声明。
  4. 上线后用执行计划验证命中。

代码或图示

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 事务持有连接期间不释放,事务长度直接占用连接。

原理流程

  1. 请求进入事务,从池借连接。
  2. 事务内所有 DAO/DSL 复用该连接。
  3. 事务提交或回滚后归还连接。
  4. 池监控活跃连接、等待线程与超时计数。

代码或图示

// 参数名与配置方式以 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。

原理流程

  1. 事务开始记录起点。
  2. 执行中超过阈值,框架或数据库终止语句。
  3. 回滚未提交变更。
  4. 异常向上抛出,上层处理。

代码或图示

transaction(transactionIsolation = DbIsolationLevel.READ_COMMITTED) {
    // 事务超时配置按连接池/框架能力设置,具体入口待确认
    UserEntity.findById(1)
}

常见误区

  • 超时后误以为已提交:必须以回滚结果为准。
  • 把 RPC 调用放进数据库事务,超时被外部响应拖长。

追问

  • 哪些操作必须留在事务内?答:多行读写一致性要求的操作;只读计算、外部通知移出事务。
  • 事务超时与语句超时区别?答:语句超时控制单条 SQL,事务超时控制整体事务,两者层级不同。

06.8.3.2-026 只读事务与只读连接怎么用?

一句话结论

明确只读的路径声明只读事务,数据库可据此做优化(如避免 undo 准备、路由只读副本);Exposed 事务配置与连接路由能力以当前版本文档为准(待确认)。

概念解释

只读事务不产生写意图,部分数据库与驱动允许把只读连接路由到从库。声明只读也是一种意图约束:代码评审时可阻止只读路径误写。只读副本延迟带来的读一致性问题需要业务评估。

原理流程

  1. 业务方法标注只读语义。
  2. 事务开启时设置只读标志。
  3. 连接池/路由层选择只读连接。
  4. 路径内出现写操作时按策略报错或告警。

代码或图示

// 只读标志的设置 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 实例。跨数据源的实体不能在同一事务里直接关联查询,分布式一致性需另设计。

原理流程

  1. 初始化多个 Database 连接。
  2. 业务路径选择目标数据源开启事务。
  3. 事务内 DAO/DSL 使用该连接。
  4. 跨库关联在应用层聚合。

代码或图示

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 约定。

原理流程

  1. 启动阶段 Flyway 连接数据库,按版本顺序执行未应用脚本。
  2. 迁移完成后 Exposed 连接初始化。
  3. DAO/DSL 操作既有 schema。
  4. 表结构变更先写迁移脚本,再调整 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 以版本号脚本线性排列。团队按既有技术栈选择,不要在同一项目混用两套迁移工具。

原理流程

  1. 编写 changeset 描述建表/加列。
  2. 启动时 Liquibase 校验 changeset 并执行未应用项。
  3. Exposed 映射既有结构。
  4. 变更回滚依赖 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。自动补列不会评估数据回填、索引与约束影响,也缺乏版本记录。多人并行开发时,本地库结构可能与团队迁移历史脱节。

原理流程

  1. 框架读取表定义元数据。
  2. 对比数据库现有表/列。
  3. 生成并执行建表/加列语句。
  4. 生产关闭该路径,只走迁移工具。

代码或图示

// 仅本地开发使用;生产环境禁止调用
SchemaUtils.createMissingTablesAndColumns(Users, Orders)

常见误区

  • 把自动建表脚本挂到生产启动流程,结构漂移无人知晓。
  • 用自动补列替代迁移评审,加列默认值直接影响存量数据。

追问

  • 本地开发怎么保持 schema 最新?答:本地库也跑迁移脚本,自动建表只用于快速原型。
  • 怎么防止生产误调用?答:按环境 profile 隔离启动配置,生产代码路径不引用 SchemaUtils 写操作。

06.8.3.2-031 加列并设为非空,上线流程怎么设计?

一句话结论

分阶段:先加可空列并回填历史数据,再补默认值或数据迁移,最后切非空约束;每阶段一个可独立发布、可回滚的迁移步骤,避免大事务锁表。

概念解释

直接给存量大表加非空列并带默认值,可能锁表或长时间持有元数据锁。正确顺序是加可空列 → 回填(分批)→ 校验数据完整 → 再加非空约束。应用代码先兼容新旧两种状态。

原理流程

  1. 迁移一:加可空列。
  2. 应用发布:写入新列,读取兼容 null。
  3. 迁移二:分批回填历史数据。
  4. 迁移三:数据校验后改为非空。

代码或图示

-- 步骤 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 变更遵循向前兼容:先扩展结构、再切代码、最后清理旧结构;回滚依赖可逆向的变更与备份,破坏性变更必须提前演练回滚步骤。

概念解释

数据库变更难以像代码那样快速回滚。兼容演进让新旧版本应用可以并存:加列不影响旧代码,废弃列先双写观察再删。回滚分语句可逆(加列可删列)与不可逆(删数据、改类型)两类,后者靠备份恢复。

原理流程

  1. 评估变更对在途发布与回滚的影响。
  2. 按扩展-迁移-清理顺序安排脚本。
  3. 发布期间保留旧结构兼容。
  4. 上线后观察,再执行清理脚本。

代码或图示

扩展:新增列/新表(旧代码忽略)
切换:新代码读写新结构
清理:确认无回滚需求后删除旧列/旧表

常见误区

  • 发布同时删旧列,旧版本实例回滚后找不到字段。
  • 不演练回滚,故障时临时拼恢复方案。

追问

  • 大表结构变更怎么降低风险?答:低峰执行、分批、准备备份与回滚脚本,监控锁等待与复制延迟。
  • 迁移脚本谁评审?答:DBA 或资深后端评审 DDL 影响面,脚本与代码同 MR 评审。

06.8.3.2-033 迁移在 CI 与测试环境怎么应用?

一句话结论

CI 构建阶段跑静态检查与单元测试;集成测试环境启动前自动执行迁移到最新 schema;禁止在 CI 里手动改库结构,迁移脚本本身要可重复校验。

概念解释

测试库 schema 由迁移脚本创建并演进,保证测试覆盖真实结构。每个集成测试环境可独立建库、跑 migrate。迁移脚本纳入版本管理,与代码同仓库评审。脚本失败会阻断流水线。

原理流程

  1. CI 拉起临时数据库容器。
  2. 执行迁移工具到最新版本。
  3. 运行集成测试。
  4. 测试结束销毁容器,不保留脏数据。

代码或图示

CI 阶段:编译 → 单元测试 → 起数据库容器 → 迁移 → 集成测试 → 构建镜像

常见误区

  • 测试库长期复用,结构与脚本历史脱节,测试通过但生产迁移失败。
  • 测试依赖手工准备的数据,迁移脚本未被验证。

追问

  • 迁移很慢影响 CI 怎么办?答:评估脚本效率、并行化测试库准备;不要跳过迁移验证。
  • 多套数据库方言怎么办?答:按生产方言准备测试环境,方言差异在迁移脚本里显式处理。

06.8.3.2-034 不同数据库方言在 Exposed 抽象下要注意什么?

一句话结论

Exposed 屏蔽大部分标准 SQL 差异,但方言特定函数、分页语法、冲突子句、类型映射仍需显式处理;切换数据库前要用目标方言跑集成测试验证。

概念解释

方言差异包括自增/序列、字符串拼接、日期函数、布尔类型、upsert 语法、大小写敏感等。表定义的通用类型在不同方言上映射目标列类型可能不同。生产用 MySQL/PostgreSQL,测试却用 H2 时尤其要注意方言偏差。

原理流程

  1. 识别 SQL 中方言相关片段。
  2. 按方言条件分支或使用数据库兼容写法。
  3. 在目标方言库上跑集成测试。
  4. 记录不兼容点与替代写法。

代码或图示

// 示例:日期/字符串函数在不同方言下行为不同,避免假设函数名通用
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 文档为准(待确认)。

原理流程

  1. 表列声明时间类型。
  2. 实体属性使用对应 java.time 类型。
  3. 写入时统一时钟源获取当前时间。
  4. 读取后在 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 结构,读写走序列化转换。

原理流程

  1. 表列声明 JSON 类型。
  2. 实体属性为对应 data class。
  3. 写入时序列化为 JSON 文本,读取时反序列化。
  4. 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)按方言选择。

原理流程

  1. 评估大字段访问频率与主表查询列集。
  2. 热字段留主表,冷字段拆扩展表或外部存储。
  3. 查询主列表时不 select 大字段。
  4. 详情页按需二次加载。

代码或图示

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 列集)。防止手段是悲观锁或乐观锁。

原理流程

  1. 两事务读取同一行。
  2. 各自在内存实体上修改。
  3. 提交时按脏列生成 update。
  4. 无并发控制时后写覆盖先写。

代码或图示

// 无保护:两事务并发扣减可能丢更新
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 意味着每次请求默认重新查库,热点数据需要外部缓存层。缓存与数据库一致性、失效策略由业务层负责。框架内置缓存若有也仅限事务上下文,不能当作长期缓存使用。

原理流程

  1. 请求进入,事务内查库装配实体。
  2. 事务结束,事务缓存释放。
  3. 下一请求重新查库。
  4. 热点数据在应用层加缓存,按 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 一条语句更新匹配集合,往返次数大幅下降。大批量更新要分批,避免长事务、大锁范围与主从延迟。

原理流程

  1. 按业务条件圈定批量范围。
  2. DSL 构造 update(...).set(...) 语句。
  3. 范围大时按主键区间分批。
  4. 每批独立事务,记录进度便于续跑。

代码或图示

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 命中被引用行时抛约束异常。软删除场景下「删除」只是标记,外键仍保留。

原理流程

  1. 确认目标行被哪些子表引用。
  2. 按外键策略先删子表或级联。
  3. 分批删除主表行。
  4. 验证影响行数与残留数据。

代码或图示

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 直接读行投影。

原理流程

  1. 查询按主键有序,便于分批定位。
  2. 每批取有限行数处理。
  3. 处理完释放引用,进入下一批。
  4. 全程控制单批内存与事务长度。

代码或图示

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 走索引。大表精确总数成本高,常见折中:只算前几页、用游标不返回总数,或缓存近似值。

原理流程

  1. 分析 count 语句执行计划。
  2. 过滤条件建匹配索引。
  3. 无法优化时评估产品形态:隐藏总数或返回粗估。
  4. 缓存 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' 无法利用前缀索引;组合索引跳过前导列;数据分布使优化器认为全表更便宜。

原理流程

  1. 写查询时检查索引列是否被包裹函数。
  2. 核对参数类型与列类型一致。
  3. 组合索引条件顺序对齐最左前缀。
  4. 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 问题。

原理流程

  1. 记录请求时间线:等连接、执行 SQL、应用处理分段耗时。
  2. 池指标看活跃连接与排队长度。
  3. 慢日志看单语句执行时间。
  4. 按分段定位瓶颈。

代码或图示

请求耗时 = 等连接 + 事务内 SQL + 应用处理 + 其他 IO

常见误区

  • 接口慢就加索引,实际是连接池被长事务占满。
  • 只看总响应时间,不拆分段。

追问

  • 池耗尽常见原因?答:长事务、慢 SQL、RPC 混入事务、池配置过小。
  • 怎么监控?答:接入连接池指标(活跃/空闲/等待)与 SQL 耗时直方图,见 06.8.5.2。

06.8.3.2-046 读写分离下 DAO 怎么路由到主库与从库?

一句话结论

按事务语义路由:写事务与写后立即读走主库,只读查询走从库;路由决策在连接获取前完成,DAO 代码不感知数据源。

概念解释

从库复制延迟会导致刚写后读不到数据。强一致读请求必须走主库。路由通常由数据源抽象或拦截层按方法/注解判定,DAO 实体不绑定具体库。多数据源初始化基础见 06.8.3.1。

原理流程

  1. 业务入口标注读写意图。
  2. 路由层选择主或从数据源开启事务。
  3. DAO 使用该事务连接。
  4. 读路径评估复制延迟容忍度。

代码或图示

transaction(db = orderDb.primary) { /* 写 */ }
transaction(db = orderDb.replica) { /* 只读 */ }

常见误区

  • 写后立刻读走从库,读到旧数据。
  • 路由规则散落在 Repository 内部,难以审计。

追问

  • 复制延迟怎么监控?答:看主从延迟指标,延迟超阈值时读请求回退主库。
  • 读写分离对 DAO 代码有侵入吗?答:实体与表定义无侵入,侵入点在事务获取连接层。

06.8.3.2-047 事务内调用外部 RPC 或发消息有什么反模式?

一句话结论

数据库事务内阻塞等待外部 RPC、MQ 确认会拉长事务、占连接与锁,外部故障还会把事务拖住;应把外部调用移到事务提交之后。

概念解释

事务持锁期间调用外部服务,响应慢或超时直接延长锁持有时间。常见问题:事务内发 MQ 等待 ack、调用下游校验、等待缓存刷新。正确做法是事务先提交,再通过事务后回调或本地消息表触发外部动作。

原理流程

  1. 事务内只做数据库读写。
  2. 提交成功后执行外部调用。
  3. 需要可靠性时用本地消息表/事件表,异步投递。
  4. 外部失败走重试与补偿。

代码或图示

val order = transaction {
    OrderEntity.new { /* ... */ }
}.also { /* 事务提交后再发事件 */ }
publishEvent(order)

常见误区

  • 事务内同步等待下游响应,下游抖动直接传导为数据库锁等待。
  • 未提交就发消息,消费者读到未生效数据。

追问

  • 怎么保证库提交后事件一定发出?答:本地消息表:事务内写消息记录,提交后后台任务投递,投递成功再标记。
  • 事务后回调有哪些实现方式?答:提交钩子、应用事件、异步任务;具体机制按框架选择。

06.8.3.2-048 长事务为什么危险,怎么识别?

一句话结论

长事务长时间持有连接与锁、阻塞其他写入并放大死锁概率;识别靠事务持续时间监控与慢日志,治理靠缩短事务边界、移出外部调用与批量拆分。

概念解释

事务从开启到提交期间持有行锁与连接。事务越长,锁等待链越容易形成,回滚段/undo 压力增大,连接池被占用。常见诱因:事务内夹带循环处理、RPC、文件操作、人工等待。

原理流程

  1. 监控事务开启到提交的时长。
  2. 定位事务内耗时操作清单。
  3. 把非数据库操作移出事务。
  4. 大批量操作拆成短事务批次。

代码或图示

反模式:一个事务里循环调用下游、逐条写库
推荐:短事务完成核心写入,后置处理异步化

常见误区

  • 把「一个用例」等同于「一个事务」,用例内所有读写塞进单一事务。
  • 长事务无人监控,故障时才发现锁等待堆积。

追问

  • 跨多个聚合的写怎么保证一致?答:拆成本地短事务 + 最终一致补偿;强一致跨聚合需求重新评估边界划分。
  • 事务时长指标怎么埋?答:在事务拦截层记录开始/结束时间与 SQL 条数。

06.8.3.2-049 死锁怎么排查和处理?

一句话结论

死锁是多个事务互相持有并等待对方锁资源;排查靠数据库死锁日志与等待链,处理靠统一加锁顺序、缩短事务、降低锁粒度。

概念解释

不同事务以不同顺序更新同一组行,形成循环等待。数据库检测到死锁后回滚其中一个事务。应用需要捕获死锁异常并重试。排查要看死锁日志中涉及的事务、持有与等待的行。

原理流程

  1. 数据库记录死锁日志(双方事务、行锁、语句)。
  2. 分析加锁顺序差异。
  3. 统一多行更新的排序规则(如按主键升序)。
  4. 缩短事务、减少锁交叉范围。

代码或图示

// 统一按主键升序加锁,避免交叉等待
ids.sorted().forEach { id ->
    StockEntity.findById(id, lock = LockType.FOR_UPDATE) // 锁 API 待确认
}

常见误区

  • 死锁异常直接暴露给用户,没有重试。
  • 多个入口更新同一批数据时顺序不一致。

追问

  • 死锁重试安全吗?答:短事务、幂等操作可重试;非幂等写要先确认事务已回滚再重试。
  • 锁粒度怎么缩小?答:条件精确到目标行,避免大范围 FOR UPDATE 扫描加锁。

06.8.3.2-050 连接泄漏怎么识别?

一句话结论

连接泄漏指连接借出后未归还,表现为活跃连接持续增长直至池耗尽;识别靠池监控(活跃数不下降、等待超时增多)与代码审查事务是否正常关闭。

概念解释

事务未提交/回滚、异常路径未关闭连接,都会导致连接不归还。框架事务通常在闭包结束时自动归还,绕过闭包手动管理连接才容易泄漏。监控连接获取与归还计数差值最直接。

原理流程

  1. 观察池活跃连接随时间是否单调上升。
  2. 对比获取/归还计数,差值持续扩大即泄漏。
  3. 审查手动获取连接、未在 finally 关闭的路径。
  4. 压测复现并抓借出时堆栈定位。

代码或图示

// 推荐:闭包式事务自动归还
transaction {
    UserEntity.findById(1)
}

常见误区

  • 池耗尽才发现泄漏,此前无监控。
  • 以为重启能解决:泄漏路径仍在,重启后复发。

追问

  • 怎么记录借出堆栈?答:连接池支持泄漏检测时开启,超时未归还打印借出位置;具体配置按池实现。
  • 协程场景要注意什么?答:连接不要跨协程长期持有,事务边界与协程生命周期对齐(协程集成 API 待确认)。

06.8.3.2-051 字符集与排序规则在迁移时要注意什么?

一句话结论

库、表、列字符集与排序规则统一规划,避免中文/emoji 乱码、比较规则不一致导致 join 与索引异常;迁移脚本显式声明,不依赖默认值。

概念解释

字符集决定能存什么字符(如 utf8mb4 支持 emoji),排序规则决定大小写、口音比较与索引顺序。库默认值会被新表继承,历史表可能与新表规则不同,join 时规则冲突报错。

原理流程

  1. 建库/建表脚本显式写字符集与排序规则。
  2. 新表与既有表规则对齐。
  3. 应用连接字符集与库一致。
  4. 历史不一致表单独评估转换脚本。

代码或图示

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 状态码识别,转换为业务层可处理的冲突结果。

原理流程

  1. 业务键建唯一索引。
  2. 插入时冲突抛重复键异常。
  3. 应用按异常类型映射为「已存在」错误或执行冲突更新。
  4. 上层决定提示用户或合并处理。

代码或图示

try {
    transaction { UserEntity.new { name = input } }
} catch (e: DuplicateKeyException) {
    // 转为业务冲突;具体异常类型按数据库/驱动确认
    throw BusinessConflict("name already exists")
}

常见误区

  • 先 select 再 insert,并发下仍然冲突。
  • 把数据库异常直接抛到接口层,错误码不友好。

追问

  • 业务键可修改怎么办?答:唯一索引跟随业务键变更,变更时校验新键唯一性。
  • 软删除记录与唯一键冲突?答:见软删除唯一索引题目,用部分索引或拼接策略。

06.8.3.2-053 乐观锁冲突重试怎么设计?

一句话结论

冲突后按业务幂等性做有限次重试,带退避;非幂等操作不能盲目重试,需要先确认回滚状态。

概念解释

乐观锁冲突说明数据被他人改过,重试要重新读取最新版本再走业务逻辑。重试次数与间隔上限明确,避免活锁。涉及资金、库存等关键操作,重试前校验业务条件是否仍满足。

原理流程

  1. 捕获版本冲突异常。
  2. 判断当前操作是否幂等可重试。
  3. 重新加载数据、重新计算。
  4. 超过次数上限则失败并提示。

代码或图示

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 等待其他事务释放行锁,超过超时阈值即报错。锁等待超时与事务超时、语句超时分属不同层级。超时异常需要与业务异常区分,避免误判为数据问题。

原理流程

  1. 数据库配置锁等待超时阈值。
  2. 事务加锁时排队等待。
  3. 超时未获得锁,语句中断回滚当前事务部分操作。
  4. 上层记录并处理。

代码或图示

-- 方言相关:锁等待超时参数按数据库配置
-- 应用侧:捕获锁等待超时异常,区分于普通业务异常

常见误区

  • 锁等待超时被当成系统错误告警,实际是并发竞争信号。
  • 临界区过大导致锁等待频繁,只靠调大超时缓解。

追问

  • 怎么降低锁等待?答:缩短临界区、减少加锁行数、优化竞争热点。
  • 锁等待与死锁区别?答:等待超时是单向等待过久,死锁是循环互相等待被检测回滚。

06.8.3.2-055 软删除场景下唯一索引怎么避免冲突?

一句话结论

普通唯一索引无法区分已删除记录,需要方言支持的部分唯一索引,或把删除时间/删除标记拼入唯一键;具体方案按数据库能力选择。

概念解释

同一业务键软删除多条后,新记录无法再插入。PostgreSQL 可建 WHERE deleted_at IS NULL 的部分唯一索引;MySQL 不支持部分索引,常用生成列把业务键与删除标记组合进唯一列,或改用归档策略。

原理流程

  1. 评估方言是否支持部分/条件索引。
  2. 支持则建条件唯一索引。
  3. 不支持则设计组合唯一列。
  4. 应用删除流程配合维护该列。

代码或图示

-- PostgreSQL 部分唯一索引示例
CREATE UNIQUE INDEX uk_active_user_name
  ON users(name) WHERE deleted_at IS NULL;

常见误区

  • 软删除后唯一索引反复冲突,业务被迫物理删历史。
  • 组合列设计不完整,已删除记录仍占用业务键。

追问

  • 多条同键已删记录怎么办?答:部分索引只约束未删除行;组合方案中把删除时间纳入键以区分多条。
  • 业务键变更历史怎么追溯?答:靠审计表保存历史映射,不依赖唯一索引。

06.8.3.2-056 审计字段由应用层写还是数据库默认值写?

一句话结论

推荐应用层统一写入并注入时钟与操作人上下文;数据库默认值只兜底创建时间,更新时间刷新通常需要触发器或应用层覆盖,口径要在项目内统一。

概念解释

应用层写可控性强,能带上操作人、请求上下文;数据库默认值不依赖应用代码,但跨写入入口(手工脚本、迁移回填)容易口径不一。触发器在部分团队被谨慎使用,调试与迁移成本高。

原理流程

  1. 约定审计字段来源:应用层负责写入。
  2. 写入口(Repository 基类/工厂)统一赋值。
  3. 数据库默认值作为新行兜底。
  4. 定期核对审计字段完整性。

代码或图示

fun newOrder(now: Instant, operator: Long) = OrderEntity.new {
    createdAt = now
    updatedAt = now
    createdBy = operator
}

常见误区

  • 部分入口应用层写、部分入口依赖默认值,字段口径混杂。
  • 操作人取自线程上下文,异步链路丢失后审计字段为空。

追问

  • 批量回填谁来写审计字段?答:迁移脚本显式写系统操作人标识,避免留空。
  • 审计字段需要独立审计表吗?答:关键变更用历史表记录前后值,实体时间戳只做粗粒度追溯。

06.8.3.2-057 迁移脚本的命名与版本顺序怎么约定?

一句话结论

脚本按工具约定前缀与版本号线性排序(如 V1、V2),版本号单调递增,描述清晰;已发布脚本不可修改,新变更追加新脚本。

概念解释

版本顺序决定执行先后,历史数据回填依赖前面的结构变更。命名包含版本、描述、作者或日期便于追溯。工具校验已应用脚本的 checksum,改动旧脚本会导致校验失败。

原理流程

  1. 新变更按当前最大版本号递增编号。
  2. 脚本描述写明变更内容。
  3. 评审后合入主干。
  4. 环境按版本顺序执行。

代码或图示

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。

原理流程

  1. 评估存量库结构现状。
  2. 设置基线版本与描述。
  3. 工具记录基线已应用。
  4. 后续增量脚本按版本执行。

代码或图示

baselineOnMigrate = true
baselineVersion = 1
-- 存量库结构视为 V1 已存在,V2 起为增量

常见误区

  • 基线版本低于实际结构版本,工具尝试重跑历史 DDL。
  • 新环境不设基线,与存量库历史口径不一致。

追问

  • 全新环境怎么办?答:从初始脚本完整执行,不需要基线标记。
  • 基线后发现漏了历史表怎么办?答:新增增量脚本补结构,不要回改基线。

06.8.3.2-059 测试库 schema 重建策略怎么选?

一句话结论

集成测试库每次启动重建或迁移到最新,测试间数据隔离;常用策略有 drop-create、迁移重建与事务回滚,按测试类型与速度选择。

概念解释

单元测试不碰库;集成测试需要真实 schema。每次跑测试重建库保证起点干净,迁移脚本同时被验证。事务回滚只隔离写操作,不适合跨事务用例。复用容器可加速,但要清理残留数据。

原理流程

  1. 测试启动拉起数据库。
  2. 执行迁移到最新版本。
  3. 测试用例准备自有数据。
  4. 用例间按事务回滚或清表隔离。

代码或图示

Testcontainers 起库 → migrate → 装配测试数据 → 执行用例 → 清理/销毁容器

常见误区

  • 测试库长期不重建,依赖手工残留数据,用例偶发失败。
  • 用例间共享数据,顺序变化导致结果不稳定。

追问

  • 重建太慢怎么办?答:复用容器、并行分库,或按测试套件分层;不要跳过 schema 校验。
  • 怎么保证测试数据不泄漏?答:每个用例自建数据,结束清理;禁用跨用例共享静态数据。

06.8.3.2-060 生产迁移发布的窗口与顺序怎么安排?

一句话结论

结构变更与应用发布按兼容顺序推进:先发布兼容旧结构的代码,再执行迁移,最后启用新结构使用;危险变更避开高峰并准备回滚预案。

概念解释

应用与数据库变更要双向兼容:新代码能读旧结构,迁移后旧代码也能容忍新列。顺序错配会导致发布瞬间报错。大表变更低峰执行,监控锁等待与复制延迟。

原理流程

  1. 代码版本兼容新旧结构。
  2. 低峰执行迁移脚本。
  3. 发布应用版本。
  4. 观察指标,确认稳定后再清理旧结构。

代码或图示

兼容代码上线 → 迁移执行 → 新代码启用新列 → 观察 → 清理旧列

常见误区

  • 迁移与发布同时进行,回滚时结构与代码不匹配。
  • 大表变更在业务高峰执行,锁等待影响线上。

追问

  • 迁移失败怎么办?答:按预案停止后续步骤,保留现场,评估回滚或修复后重试。
  • 谁来执行生产迁移?答:按发布流程由部署流水线或值班人员执行,脚本预先评审。

06.8.3.2-061 Exposed 版本升级时 schema 与 API 要注意什么?

一句话结论

升级先看 changelog 的 breaking changes,表定义/DAO API 改名或行为变化逐项对照;在预发用目标 schema 跑全量测试,数据库结构不因框架升级自动变更。

概念解释

框架版本升级影响的是代码 API 与生成 SQL,不直接改库结构。0.4x→0.5x 的 API 命名、包结构可能调整,具体变更点以官方 changelog 为准(待确认)。升级在小版本范围内灰度,先升测试环境。

原理流程

  1. 阅读版本 changelog 与迁移说明。
  2. 升级依赖版本,编译修复 API 调用。
  3. 预发跑迁移与集成测试。
  4. 观察 SQL 行为差异后灰度上线。

代码或图示

changelog → 依赖升级 → 编译适配 → 集成测试 → 预发观察 → 灰度

常见误区

  • 只升依赖不跑测试,运行时 API 报错。
  • 假设生成 SQL 与旧版本完全一致,执行计划发生变化未察觉。

追问

  • 升级后 SQL 变了怎么验证?答:对比关键接口的语句与执行计划,回归性能基线。
  • 不确定 API 是否变更怎么办?答:标注待确认点,对照当前版本源码与文档验证后再定稿。

06.8.3.2-062 表重命名、列重命名怎么安全迁移?

一句话结论

重命名采用「新结构并行 → 双写/兼容读取 → 切流 → 删旧」的扩展方式,避免新旧版本应用同时引用不同名称导致断链。

概念解释

直接改名会让未更新的应用版本找不到表/列。兼容方案:新增目标名称结构,代码兼容新旧读取,迁移数据后切换写入,观察稳定再删旧对象。ORM 表定义与迁移脚本同步调整。

原理流程

  1. 新增新表/新列。
  2. 迁移数据,应用双写或兼容读取。
  3. 读流量切到新结构。
  4. 确认无回滚需求后删除旧对象。

代码或图示

-- 意图:新增列后回填,切换后再删旧列(分步脚本)
ALTER TABLE users ADD COLUMN full_name VARCHAR(100) NULL;

常见误区

  • 直接 RENAME,滚动发布期间旧实例报错。
  • 重命名后外键、索引、视图未同步更新。

追问

  • 表重命名外键怎么办?答:外键引用名随迁移同步调整,分步评估依赖对象。
  • 回滚窗口内旧名还要保留吗?答:保留到观察期结束,再执行清理脚本。

06.8.3.2-063 历史数据回填怎么做分批更新?

一句话结论

回填按主键区间分批,每批小事务提交,控制节奏避开高峰;记录批次进度,失败可续跑,并先在小范围验证。

概念解释

一次性 update 全量历史会长事务、大锁、主从延迟。分批按主键滑动窗口,每批独立提交。回填脚本要可重复执行(幂等),避免重复回填造成错误覆盖。

原理流程

  1. 圈定主键范围与每批大小。
  2. 循环按区间查询待回填行。
  3. 小事务内更新并提交。
  4. 间隔控速,记录进度。

代码或图示

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 建索引默认不阻塞写(并发建索引)。具体方言能力需按生产数据库确认。

原理流程

  1. 分析待加索引的表大小与写入量。
  2. 低峰选择在线 DDL 方式。
  3. 监控复制延迟、锁等待与磁盘空间。
  4. 索引建成后验证执行计划命中。

代码或图示

-- 意图:并发建索引;具体语法按方言确认
CREATE INDEX CONCURRENTLY idx_orders_user ON orders(user_id);

常见误区

  • 高峰直接建大索引,锁等待拖垮在线写入。
  • 只在小表验证过耗时,忽略生产数据量级。

追问

  • 索引建错了能删吗?答:普通索引可在线删除,删除同样评估锁与复制影响。
  • 空间不足怎么办?答:提前评估磁盘余量,索引体积与表数据量相关。

06.8.3.2-065 DAO 实体与领域模型为什么要分离?

一句话结论

实体是持久化模型,与表结构和框架耦合;领域模型表达业务语义,不依赖 ORM。Repository 出口完成两者转换,让核心业务逻辑可脱离数据库框架测试。

概念解释

实体委托属性、主键包装、懒引用都属于持久层细节。领域模型用纯 Kotlin data class/sealed class 表达状态与行为。分离后表结构调整只影响映射层,业务规则不受框架版本绑架。

原理流程

  1. 数据层返回实体。
  2. Repository 把实体转换为领域模型。
  3. Service 只操作领域模型。
  4. 持久化时再转回实体。

代码或图示

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),而不是暴露通用查询拼接。

原理流程

  1. Service 调用 Repository 语义化方法。
  2. Repository 在事务内用 DAO/DSL 取数。
  3. 实体转换为领域模型返回。
  4. 持久化时模型转回实体。

代码或图示

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。

原理流程

  1. 确定主实体表。
  2. DSL join 取主表列与关联投影列。
  3. 主表行装配实体,关联值填入 DTO。
  4. 不在 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 脱离类型安全,字段名与类型需自行核对。

原理流程

  1. 编写带占位符的原生 SQL。
  2. 参数绑定传入。
  3. 执行后逐行读取列。
  4. 映射为业务模型。

代码或图示

// 原生 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 表达式中调用,过程调用走原生语句。

原理流程

  1. 确认逻辑是否必须放数据库侧。
  2. 函数调用纳入表达式或原生 SQL。
  3. 过程调用用参数化语句执行。
  4. 结果映射为业务模型。

代码或图示

-- 调用意图示例;具体 Exposed 调用封装以文档为准
SELECT calculate_discount(?, ?);

常见误区

  • 在存储过程里写复杂业务规则,与应用层逻辑双份维护。
  • 过程返回多结果集时未处理游标映射。

追问

  • 为什么新项目不推荐存储过程?答:版本评审、测试覆盖、跨库移植与人员维护都弱于应用层代码。
  • 已有存储过程怎么演进?答:逐步把逻辑迁到应用层,过程保留为兼容入口。

06.8.3.2-070 数据库函数与表达式在 DSL 里怎么使用?

一句话结论

DSL 列表达式可包装方言函数生成 SQL 片段;跨方言通用的函数优先用框架表达式,方言特有函数需要确认兼容性。

概念解释

聚合、日期、字符串函数在 DSL 中以表达式形式参与 select/where。函数生成的 SQL 随方言翻译。团队封装常用表达式扩展,避免散落原生片段。具体函数列表以 0.5x 文档为准(待确认)。

原理流程

  1. 在 select/where 中构造函数表达式。
  2. 框架按方言生成对应 SQL。
  3. 结果按列类型读取。
  4. 方言特有函数标注兼容范围。

代码或图示

// 意图示例:聚合表达式;具体函数 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 实体假设一行对应一个可持久化对象,聚合结果只有部分列或计算值。把聚合行硬塞实体,属性未加载、脏检查语义错位。报表、看板、统计接口应使用只读投影模型。

原理流程

  1. 确定统计口径与维度。
  2. DSL slice 选择分组列与聚合表达式。
  3. 结果行映射为统计 DTO。
  4. 不在聚合结果上调用实体写方法。

代码或图示

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 直接影响去重结果。

原理流程

  1. 确认实体相等性实现依据主键还是引用。
  2. 集合使用前明确身份口径。
  3. 跨事务实体不要作为缓存键。
  4. 需要值比较时转换为领域 data class。

代码或图示

// 领域模型用 data class 值相等
data class OrderView(val id: Long, val status: String)

常见误区

  • 同一行两个事务加载的实体放入同一集合,因相等性口径不一致重复出现。
  • 未持久化实体 hashCode 不稳定导致集合行为异常。

追问

  • 实体需要自定义 equals 吗?答:如框架默认不按主键比较,可按主键实现;优先在领域模型上做值比较。
  • 跨实体类型能相等吗?答:不应跨类型比较,集合按类型分组使用。

06.8.3.2-073 实体在 List/Set 中要注意什么?

一句话结论

实体进入集合前先明确是否需要身份去重;DAO 实体引用与脏状态可能随事务变化,集合不应跨请求持有实体引用。

概念解释

事务内加载的实体集合在事务结束后引用仍在,但懒加载属性与缓存已失效。长生命周期集合持有实体是内存泄漏与脏读来源。返回给上层的应是转换后的 DTO/领域模型集合。

原理流程

  1. 查询得到实体列表。
  2. 业务处理在事务内完成。
  3. 出口转换为不可变模型集合。
  4. 实体引用随事务释放。

代码或图示

val views = transaction {
    OrderEntity.all().limit(50).toList().map { it.toView() }
}

常见误区

  • 把实体列表缓存到成员变量,跨请求复用。
  • 集合内实体被后续修改污染,上层拿到意外状态。

追问

  • 批量结果怎么控制大小?答:分页或分批,禁止无界 toList()。
  • 不可变集合有必要吗?答:领域模型返回只读 List,避免上层原地修改。

06.8.3.2-074 实体引用循环会导致什么序列化问题?

一句话结论

双向引用形成循环,序列化器递归遍历会栈溢出或输出冗余嵌套;实体不应直接序列化,引用方向单向化并在 DTO 层切断循环。

概念解释

父持有子集合、子回引父,JSON 序列化时相互引用递归无法终止。即使不爆栈,输出也会嵌套膨胀。DAO 关联默认单向导航,建模时避免双向都暴露给序列化层。

原理流程

  1. 检查实体引用方向是否双向。
  2. DTO 只保留必要单向字段。
  3. 序列化在 DTO 上执行。
  4. 循环关系在内存业务层按需拼装。

代码或图示

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(如挂起函数版本)以当前版本为准。

原理流程

  1. 协程切到 IO 调度器。
  2. 在事务闭包内执行阻塞 JDBC 操作。
  3. 事务结束归还连接。
  4. 结果返回协程上下文。

代码或图示

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 池容量影响并发数据库访问上限,与连接池大小匹配。

原理流程

  1. 业务协程在默认调度器编排。
  2. 进入数据访问段切 IO 调度器。
  3. 阻塞事务执行。
  4. 返回结果后回到原上下文。

代码或图示

suspend fun placeOrder(req: OrderRequest) = withContext(Dispatchers.IO) {
    transaction { orderRepository.save(req.toEntity()) }
}

常见误区

  • 阻塞调用不切调度器,事件循环被卡住。
  • IO 调度器线程数远大于连接池,等待连接的线程堆积。

追问

  • 怎么统计阻塞耗时?答:数据访问段单独埋点,区分协程等待与线程阻塞。
  • 异步事务 API 缺失时的折中?答:阻塞调用隔离在 IO 层,上层保持协程编排。

06.8.3.2-077 连接获取超时怎么配置,超时说明什么?

一句话结论

获取连接超时指等待池分配连接的最长时间,超时抛获取异常;它说明池被占满或事务过长,而不是单条 SQL 慢。

概念解释

线程先等连接再执行 SQL。获取超时阈值通常短于请求整体超时。超时计数持续上升意味着池容量与事务持有时间不匹配,需要调池大小或缩短事务,而不是只放大超时时间。

原理流程

  1. 请求进入,尝试从池借连接。
  2. 池无空闲连接则排队等待。
  3. 超过获取超时阈值抛异常。
  4. 监控等待队列长度与获取超时次数。

代码或图示

连接池指标:active / idle / pending waiters / acquisition timeout count

常见误区

  • 把获取超时调很大,线程长时间挂住,请求堆积雪崩。
  • 混淆获取超时与 SQL 执行超时,排查方向跑偏。

追问

  • 池满了先调大池吗?答:先看占用原因(长事务/慢 SQL/泄漏),盲目加连接会压垮数据库。
  • 获取连接与执行 SQL 指标分开埋吗?答:分开记录,便于定位等待段。

06.8.3.2-078 连接空闲回收与最大生命周期怎么设置?

一句话结论

空闲超时回收闲置连接,最大生命周期避免连接长期持有出现隐性失效;参数按数据库与驱动的连接有效期设定,回收由池负责,业务无感知。

概念解释

连接长期空闲可能被数据库或中间件断开,池内保留失效连接会导致首次使用报错。最大生命周期强制重建连接。空闲连接数保留到最小空闲值,兼顾响应速度与资源占用。具体参数名按连接池实现确认。

原理流程

  1. 池按空闲超时回收超出最小空闲的连接。
  2. 连接存活超过最大生命周期后关闭重建。
  3. 借出时做有效性校验(按池配置)。
  4. 业务侧不感知连接重建。

代码或图示

// 参数名以 HikariCP 为准;示例表达语义
hikari {
    minimumIdle = 5
    idleTimeout = 600_000
    maxLifetime = 1_800_000
}

常见误区

  • maxLifetime 长于数据库侧连接超时,池内持有已被服务端关闭的连接。
  • 空闲回收过激进,高峰频繁建连增加抖动。

追问

  • 连接有效性怎么校验?答:池配置测试查询或驱动 ping;具体开关按池实现确认。
  • 建连开销大怎么办?答:保留合理最小空闲连接,预热池。

06.8.3.2-079 压测时连接池水位怎么调优?

一句话结论

压测先固定业务场景与事务耗时,观察活跃连接、等待队列、CPU 与数据库负载,找到「池利用率高但无排队、数据库未过载」的水位区间。

概念解释

池大小不是越大越好:过大挤占数据库连接、增加上下文切换;过小请求排队。压测记录不同并发下的活跃连接数、等待数、SQL 耗时与数据库 CPU,确定最优配置。事务耗时变长时同样并发需要更多连接。

原理流程

  1. 基线压测记录各指标。
  2. 逐步提升并发,观察排队出现拐点。
  3. 调整池大小与数据库容量匹配。
  4. 回归验证接口 P99 与错误率。

代码或图示

并发 ↑ → 活跃连接 ↑ → 等待队列出现 → 数据库 CPU/锁等待 → 拐点定池大小

常见误区

  • 按经验公式定池,不结合实际事务耗时压测。
  • 压测数据量与生产差距大,水位结论失真。

追问

  • 多个服务实例共享数据库怎么算总连接?答:单实例池大小 × 实例数,不超过数据库最大连接预留。
  • 池指标在哪看?答:接入 Micrometer 暴露池指标,见 06.8.5.2。

06.8.3.2-080 怎么监控 SQL 执行指标?

一句话结论

至少记录语句耗时、执行次数、慢语句指纹与错误数;通过连接池/框架埋点或数据库侧慢日志采集,按接口与 SQL 指纹聚合。

概念解释

单条 SQL 日志便于排查,聚合指标才能发现趋势问题。指标维度包括接口、SQL 指纹(去掉参数)、耗时区间。慢日志抓长尾,直方图看整体分布。具体 Exposed 拦截/埋点扩展点待确认。

原理流程

  1. 在数据访问层或池层拦截语句执行。
  2. 记录开始/结束时间与 SQL 指纹。
  3. 上报耗时指标与计数。
  4. 慢语句明细进入日志供下钻。

代码或图示

指标:sql.latency{fingerprint=..., table=...} 直方图
日志:慢 SQL 指纹、参数脱敏、耗时、调用接口

常见误区

  • 只记总耗时,不按 SQL 指纹聚合,定位不到热点语句。
  • 日志打印完整敏感参数,违反脱敏要求。

追问

  • SQL 指纹怎么生成?答:归一化字面量参数后取语句模板;具体实现按框架/中间件能力。
  • 慢阈值设多少?答:按接口 SLO 分层设定,核心写路径阈值更严。

06.8.3.2-081 慢 SQL 日志怎么开启?

一句话结论

应用侧通过框架/连接池日志配置输出执行语句与耗时,数据库侧开启慢查询日志;两边配合才能同时拿到语句指纹与库内执行画像。具体 logger 开关名称以 0.5x 与数据库文档为准(待确认)。

概念解释

应用日志带接口上下文与参数(脱敏),数据库慢日志带执行计划相关统计。开发环境可开完整语句日志,生产按采样或阈值输出,避免日志量爆炸。

原理流程

  1. 配置框架/驱动日志级别输出 SQL。
  2. 数据库设置慢查询阈值。
  3. 两边日志按时间与 traceId 关联。
  4. 定期 review 慢语句清单。

代码或图示

应用日志:traceId、SQL 模板、绑定参数(脱敏)、耗时
数据库慢日志:语句、扫描行数、执行时长、锁等待

常见误区

  • 生产开全量 SQL 日志,日志体积与磁盘 IO 压垮服务。
  • 只看应用侧耗时,不查库内执行计划。

追问

  • 参数要打印吗?答:敏感字段脱敏,必要参数用于复现;禁止打印密钥与隐私字段。
  • 日志级别运行时可调吗?答:按日志框架能力动态调整,见 06.8.5.2。

06.8.3.2-082 预编译语句缓存有什么作用?

一句话结论

预编译缓存复用语句执行计划,减少重复解析与编译开销;JDBC 驱动与连接池层可配置缓存,跨连接复用策略按驱动实现确认(待确认)。

概念解释

相同结构 SQL 只参数不同时,预编译缓存保留语句解析结果。缓存命中降低数据库 CPU。Exposed 生成语句结构稳定,利于命中缓存。缓存大小与方言特性需结合驱动配置。

原理流程

  1. 首次执行语句,数据库解析生成执行计划。
  2. 缓存登记语句模板。
  3. 同模板后续执行复用计划。
  4. 缓存失效按驱动策略清理。

代码或图示

重复执行:WHERE user_id = ?  →  模板缓存命中,仅绑定新参数

常见误区

  • 每条语句拼接不同字面量,模板无法复用,缓存失效。
  • 误以为缓存解决执行计划本身低效的问题。

追问

  • 语句模板不稳定怎么优化?答:参数走占位符,不拼字面量;排序/分组字段白名单选择。
  • 缓存占内存吗?答:配置缓存上限,监控内存占用。

06.8.3.2-083 参数绑定为什么能防 SQL 注入?

一句话结论

参数绑定把值与语句结构分开传输,值永远作为数据处理,不会被解析成 SQL 语法;拼接字面量进语句才存在注入风险。

概念解释

绑定参数由驱动按类型转义下发,数据库先固定语句结构再填值。用户输入即使含 SQL 片段也只作为字符串值。ORM/DSL 生成语句默认走绑定,原生 SQL 必须显式占位符绑定。

原理流程

  1. 语句模板与参数分离。
  2. 驱动/数据库预编译模板。
  3. 参数按类型安全绑定。
  4. 输入中的特殊字符不参与语法解析。

代码或图示

// 安全:参数绑定
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 组合表达式,值部分绑定。表名、列名、排序方向不能来自输入,需映射到预定义枚举或列对象。

原理流程

  1. 接收查询参数并校验。
  2. 可选条件逐段加入表达式。
  3. 排序字段映射白名单。
  4. 生成最终 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 最清晰,写路径再走实体。

原理流程

  1. DSL 声明 join 与投影列。
  2. 行映射为 DTO 字段。
  3. 如需主实体,按结果主键二次查询。
  4. 避免在 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 次数,但把关联数据一并加载,字段与行数都可能膨胀。层级越深内存占用越高。按页面展示需要决定预取哪些关联,列表页不加载详情级关联。

原理流程

  1. 梳理接口返回需要的关联层级。
  2. 必要关联批量预取。
  3. 内存拼装视图模型。
  4. 无关关联延迟到详情接口。

代码或图示

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 安全编码或不透明令牌。

原理流程

  1. 首页返回最后一条排序键组成的 cursor。
  2. 下一页请求带 cursor,服务端解码校验。
  3. 按 cursor 值构造 WHERE key < lastKey 条件。
  4. 返回新 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。

原理流程

  1. 纯函数映射直接单测。
  2. Repository 方法在测试库起真实连接执行。
  3. 准备数据、执行、断言库中状态。
  4. 用例间清理隔离。

代码或图示

@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。区分「查不到是正常空态」与「查不到是数据异常」:前者返回空,后者抛业务异常。

原理流程

  1. 单条查询返回 Entity?。
  2. 业务判断缺失是否可接受。
  3. 列表方法保证返回空集合。
  4. 必须存在的记录缺失时抛异常并记录上下文。

代码或图示

val order = OrderEntity.findById(id) ?: throw NotFoundException("order $id")

常见误区

  • 列表方法返回 null,上层 map 时空指针。
  • 必须存在的记录缺失被静默当空态处理,问题延后爆发。

追问

  • 对外接口怎么表达空态?答:单条 404 或空对象结构按 API 约定;列表返回空数组。
  • 缓存未命中与库空怎么区分?答:缓存层区分空值标记,避免空结果反复打库。

06.8.3.2-090 数值列精度与小数类型怎么选择?

一句话结论

金额等精确计算用定点十进制类型,不用浮点类型;Kotlin 侧用 BigDecimal,避免二进制浮点误差累积。

概念解释

浮点数存在精度表示误差,累计计算后金额偏差。数据库定点列(如 DECIMAL/NUMERIC)存精确十进制,Kotlin 侧对应 BigDecimal。整数计数用整数类型。列精度与标度按业务最大位数设计。

原理流程

  1. 字段判断是否需要精确小数。
  2. 表声明定点类型与标度。
  3. 实体属性映射 BigDecimal。
  4. 计算使用定点运算,禁止转 double 参与金额计算。

代码或图示

object Orders : LongIdTable("orders") {
    val amount = decimal("amount", 12, 2)
}

常见误区

  • 金额用 double/float,对账出现分位误差。
  • 标度不够,四舍五入丢失精度。

追问

  • 汇率折算怎么处理?答:保存原值与汇率,折算规则在领域层明确,精度口径统一。
  • 展示层格式化?答:数据库存原值,展示按币种格式化,不在库内做四舍五入。

06.8.3.2-091 写入路径性能 checklist 有哪些?

一句话结论

写入检查:短事务、批量写入、索引数量受控、无循环 RPC、唯一约束兜底、批量分批与连接池匹配。

概念解释

写路径成本来自语句执行、索引维护、锁竞争与往返次数。逐条 insert 批量场景改为批量语句;事务内不夹带外部调用;监控写锁等待与慢更新。索引过多拖慢写入,定期清理冗余索引。

原理流程

  1. 检查事务边界是否最短。
  2. 批量场景用批量语句分批提交。
  3. 复核索引数量与写入放大。
  4. 监控更新耗时、锁等待与冲突重试。

代码或图示

写入 checklist:事务短 / 批量批处理 / 无循环外部调用 / 索引受控 / 约束完整 / 连接池匹配

常见误区

  • 循环单条 insert 却认为「数据量不大没问题」。
  • 索引只增不清理,写入成本持续上升。

追问

  • 批量写入批大小怎么定?答:压测单批行数与提交间隔,权衡往返次数与事务大小。
  • 写入慢先看什么?答:锁等待、索引维护、语句执行计划与连接池排队。

06.8.3.2-092 读取路径性能 checklist 有哪些?

一句话结论

读取检查:只取需要列、分页限流、索引命中、无 N+1、count 可控、大字段按需加载、结果集不超内存。

概念解释

读路径问题多为全表扫描、关联 N+1、大结果集与大字段带出。列表接口限定返回字段与行数,关联批量预取,统计走投影。执行计划定期复核索引命中。

原理流程

  1. 检查查询条件与索引匹配。
  2. 复核投影列是否必要。
  3. 关联读取批量预取。
  4. 分页/游标限制结果大小。

代码或图示

读取 checklist:索引命中 / 投影精简 / 分页限流 / 批量预取 / 大字段按需 / count 优化

常见误区

  • 列表接口返回实体全字段,大文本一并带出。
  • 不限制行数,异常参数导致全表拉取。

追问

  • 读路径缓存怎么加?答:读多写少结果加缓存,注意失效与一致性。
  • 慢读怎么定位?答:SQL 日志 + 执行计划 + 接口耗时分段,见慢查询题目。

06.8.3.2-093 数据访问层异常怎么分类处理?

一句话结论

异常分数据问题(未找到、冲突、约束)、基础设施问题(连接、超时、库不可用)与编程问题(类型映射、语句错误);分层映射,不在上层暴露数据库原生异常细节。

概念解释

数据库异常经过 Repository 出口翻译为业务异常或基础设施异常。未找到、唯一冲突、外键约束属于可预期业务结果;连接失败、超时属于基础设施故障;映射错误多为代码缺陷。异常携带上下文信息便于排查。

原理流程

  1. 捕获底层异常并识别 SQL 状态码/类型。
  2. 映射为领域异常或数据访问异常。
  3. 上层按异常类型决定提示、重试或告警。
  4. 原始堆栈保留在日志。

代码或图示

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 事务内只读校验与写操作的边界怎么划?

一句话结论

需要与写入一致读取的校验在同一事务内做,可延后的校验与通知移出事务;先做不依赖库的参数校验,再进事务做一致性校验。

概念解释

业务校验分三类:纯参数格式校验(进事务前)、依赖当前数据状态的一致性校验(事务内)、外部规则校验(尽量事务外)。事务内校验读到的行在锁保护下判断,避免校验后被他人修改。

原理流程

  1. 入口校验参数格式与权限。
  2. 事务内读取并做一致性判断。
  3. 写入后提交。
  4. 后置通知/异步处理在提交后执行。

代码或图示

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 多环境数据库配置有哪些差异需要注意?

一句话结论

各环境数据库方言、连接参数、池大小、迁移目标应通过配置区分;结构由迁移脚本统一保证,环境差异只体现在连接与性能参数上。

概念解释

开发、测试、预发、生产的库地址、账号、池容量、超时阈值不同,但表结构口径一致。环境配置从环境变量或配置文件读取,不硬编码。测试环境可使用容器化目标数据库保证方言一致。

原理流程

  1. 连接信息按环境注入。
  2. 迁移脚本在各环境执行到对应版本。
  3. 池与超时参数按环境容量调整。
  4. 生产禁用自动建表与调试日志。

代码或图示

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(具体函数名、参数名)。验证方式:查官方文档、跑最小示例、对照依赖版本源码。

原理流程

  1. 列出代码中使用的 Exposed API。
  2. 对照当前版本文档核对签名。
  3. 最小工程编译运行验证。
  4. 无法确认的标注待确认与验证步骤。

代码或图示

待确认类别:锁参数名 / JSON 列类型 / exec 原生 SQL / 协程模块 / 只读标志 / 索引 DSL
验证点:依赖版本号、官方文档版本、最小可运行示例

常见误区

  • 凭旧版本记忆写 API 名,编译才发现签名变化。
  • 把第三方教程的旧写法当成当前版本行为。

追问

  • 怎么查当前依赖版本?答:查构建文件依赖版本与发布说明,以实际引入版本为准。
  • 文档与源码不一致时信哪个?答:以实际运行的源码行为为准,记录差异反馈。

06.8.3.2-097 数据访问层怎么做安全审计?

一句话结论

审计点包括:参数绑定防注入、敏感字段脱敏、权限校验前置、最小权限数据库账号、操作留痕;代码评审与静态扫描覆盖拼接 SQL 与明文敏感数据。

概念解释

数据层安全不只防注入,还包括账号权限范围、敏感列访问与操作记录。数据库账号只授予业务所需表与操作;敏感字段查询与导出有审批与日志。审计字段记录关键变更人。

原理流程

  1. 检查 SQL 构造全部绑定参数。
  2. 数据库账号按最小权限配置。
  3. 敏感字段访问与导出记录审计日志。
  4. 静态扫描拦截拼接 SQL 与明文密钥。

代码或图示

审计清单:绑定参数 / 账号最小权限 / 敏感列脱敏 / 操作留痕 / 无硬编码凭据

常见误区

  • 应用账号拥有 DDL 或全库读写权限,泄露后影响面过大。
  • 导出接口不记录操作人,事后无法追溯。

追问

  • 密码/密钥列怎么存?答:加盐哈希存储,不可逆;不在日志与响应中出现。
  • 审计日志放哪?答:独立审计记录,不依赖业务表软删除。

06.8.3.2-098 数据访问层如何做容量与增长规划?

一句话结论

按表数据量增长、写入速率与查询模式评估索引、归档与分表边界;容量规划结合历史增长曲线与业务预期,定期复核慢查询与空间使用。

概念解释

单表数据量过大后索引维护、查询与备份成本上升。规划包括冷热数据归档、大表拆分评估、索引容量预估。写入热点(自增主键、热点行)也要识别。容量指标定期复盘,不一次设计过度。

原理流程

  1. 统计各表行数、增量、写入 QPS 与慢查询。
  2. 评估单表阈值与归档策略。
  3. 识别热点行与大事务。
  4. 达到阈值前启动拆分/归档方案。

代码或图示

容量指标:行数 / 日增 / 索引体积 / 写入 QPS / 慢查询 / 主从延迟

常见误区

  • 只在性能出问题后考虑扩容,归档方案来不及落地。
  • 过度设计分片,业务复杂度提前上升。

追问

  • 历史数据怎么归档?答:冷数据迁归档表/存储,主表保留近期窗口;归档脚本分批执行。
  • 分表键怎么选?答:按高频查询维度选择,避免跨分片查询;分布式方案见 09 分册。

06.8.3.2-099 面试题:订单模块需要调整库存并写订单,数据访问层怎么设计?

一句话结论

短事务内完成库存扣减与订单写入,并发控制用原子扣减或悲观/乐观锁;外部通知移出事务,冲突与超卖靠唯一约束与库存校验兜底。

概念解释

核心是一致性与并发:扣库存与建订单要么都成功要么都回滚。热点商品库存竞争激烈,优先数据库原子表达式扣减;冲突重试有限次。订单与库存分表时评估跨表事务边界,必要时最终一致。

原理流程

  1. 参数与权限校验在事务外。
  2. 事务内锁定/读取库存,校验可用量。
  3. 原子扣减并写订单。
  4. 提交后发事件通知下游。

代码或图示

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 检查扫描行数与索引;检查循环内关联查询与大字段;必要时压测复核。结论要落到具体语句与索引/改写措施。

原理流程

  1. 监控定位慢在等待连接、SQL 还是应用段。
  2. 抓 SQL 模板与参数,脱敏后复现。
  3. EXPLAIN 看 type/rows/key/Extra。
  4. 检查 N+1、投影列、分页与 count。
  5. 改写或补索引后复测执行计划与 P99。

代码或图示

分段耗时 → SQL 指纹 → 执行计划 → 索引/条件 → N+1/结果集 → 改写复测

常见误区

  • 不看分段直接加索引,瓶颈其实在连接池或应用序列化。
  • 测试环境数据量小,执行计划结论与生产不符。

追问

  • 慢只在偶发流量出现?答:结合锁等待、连接池排队与下游依赖时间线定位并发因素。
  • 优化后怎么确认有效?答:对比优化前后 SQL 次数、扫描行数与接口 P99,观察慢日志清单下降。

参考来源

待整理清单

  • [ ] 核对 Exposed 0.5x 中悲观锁参数名、JSON 列辅助 API、原生 SQL 执行入口与协程集成模块的准确签名
  • [ ] 核实 0.5x 是否提供内置乐观锁版本号注解或实体生命周期回调扩展点
  • [ ] 补充当前版本索引声明 DSL 的准确方法名与可空/默认值列定义写法
  • [ ] 整理 MySQL 与 PostgreSQL 在部分唯一索引、并发建索引、upsert 方言差异的对照案例
  • [ ] 补充连接池(HikariCP)与 Exposed 连接配置的当前版本参数示例
  • [ ] 待确认:0.5x 跨事务访问未加载实体属性的实际行为与异常类型