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

06.8.5.3 分层架构、测试、容器化与部署

所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.8 Kotlin 后端 / 06.8.5 服务端配套与工程实践

本节要解决的问题

本篇覆盖 Kotlin 服务端工程落地:Controller/Service/Repository 分层与领域模型、Gradle 模块化、测试分层与 Testcontainers、容器化镜像、K8s 探针与优雅停机、CI 流水线。RPC 契约层细节归 06.8.5.1,可观测性归 06.8.5.2;版本基线 Kotlin 2.x、Gradle 8.x、JDK 21、Testcontainers 1.x,不确定处标「待确认」。

06.8.5.3-001 Controller、Service、Repository 三层各负什么责?

一句话结论

Controller 负责协议适配(解析请求、返回响应),Service 负责业务用例编排与规则,Repository 负责数据存取;层间通过接口与模型传递,不互相越权。

概念解释

分层把协议、业务、数据三种关注点分离。Controller 不写业务规则,Service 不直接拼 SQL/HTTP 细节,Repository 不做业务判断。依赖方向向内:Controller 依赖 Service,Service 依赖 Repository 接口。层间模型独立,避免数据库实体直接出现在响应。

原理流程

  1. Controller 接收请求,校验入参,调用 Service。
  2. Service 执行业务规则与编排,调用 Repository。
  3. Repository 读写存储,返回领域模型。
  4. Service 结果经 Controller 映射为响应 DTO。

代码或图示

Controller(协议适配)→ Service(业务用例)→ Repository(数据存取)

常见误区

  • Controller 里写业务规则,Service 变薄壳。
  • Repository 方法名带业务动词,业务逻辑下沉到数据层。

追问

  • 三层够不够用?答:复杂领域可加领域层/端口适配器,见后续题目。
  • 跨层共享模型吗?答:各层模型独立映射,避免实体穿透到接口。

06.8.5.3-002 领域模型与 DTO 怎么映射?

一句话结论

领域模型表达业务概念与规则,DTO 表达接口契约;在边界层显式映射,不互相嵌套复用,避免领域模型被接口格式绑架。

概念解释

DTO 随 API 版本演进,领域模型随业务演进,两者变化原因不同。映射在 Controller/适配器层完成。领域模型不暴露给前端契约。映射可用手写函数或映射库,复杂转换单独组织。

原理流程

  1. 请求 DTO 入 Controller。
  2. 映射为领域模型调用 Service。
  3. Service 返回领域结果。
  4. 边界层映射为响应 DTO。

代码或图示

data class OrderDto(val id: Long, val status: String)
data class Order(val id: OrderId, val status: OrderStatus)
fun Order.toDto() = OrderDto(id.value, status.name)

常见误区

  • 数据库实体直接作为响应 DTO,字段与表结构耦合。
  • DTO 内嵌领域模型,接口变更牵动领域层。

追问

  • 映射库有必要吗?答:字段简单手写即可,复杂映射再评估映射库。
  • DTO 校验在哪做?答:入参校验在边界层,业务规则校验在领域层。

06.8.5.3-003 领域模型为什么不能依赖框架?

一句话结论

领域模型保持纯 Kotlin,不引入 Web/DB 框架注解与类型;保证业务规则可独立测试、可替换外层框架。

概念解释

框架依赖会让领域模型被注解、基类、序列化规则绑定。纯模型可在无容器环境单测。框架适配在边界层完成。领域对象只表达业务状态与行为。

原理流程

  1. 领域层只依赖 Kotlin 标准库与自身抽象。
  2. 框架注解/实体映射放适配层。
  3. 适配层把框架对象转为领域模型。
  4. 领域模型独立测试。

代码或图示

领域层:纯 data class / sealed class / 业务方法
适配层:Web DTO、DB Entity、映射

常见误区

  • 领域类加 ORM 注解,业务模型与表结构耦合。
  • 领域方法抛框架专有异常。

追问

  • 实体(Entity)算领域模型吗?答:DAO 实体是持久化适配模型,与领域模型区分。
  • 框架工具类能进领域层吗?答:通用纯函数可,带框架运行时依赖的不行。

06.8.5.3-004 Result 类型与异常边界怎么设计?

一句话结论

业务结果用 sealed/Result 类型显式表达成功与失败,异常只用于非预期错误;边界层把业务失败翻译为响应状态码,不把内部异常直接抛给接口。

概念解释

预期业务失败(状态冲突、参数非法)是结果的一部分,用返回类型表达;非预期错误用异常并在边界捕获。边界层统一错误翻译与日志。内部异常不直接暴露给调用方。Kotlin 可封装 sealed 结果类型或用 Result,具体方案按项目约定。

原理流程

  1. 用例返回业务结果类型。
  2. 预期失败携带错误类型。
  3. 边界层匹配结果翻译响应。
  4. 非预期异常在边界兜底处理。

代码或图示

sealed interface OrderResult {
    data class Success(val order: Order) : OrderResult
    data class Rejected(val reason: RejectReason) : OrderResult
}

常见误区

  • 所有业务失败都抛异常,控制流被异常打断。
  • 边界未兜底,内部异常堆栈直接返回响应。

追问

  • 异常和 Result 混用怎么收口?答:约定预期走结果类型,非预期走异常,边界统一翻译。
  • 错误码在哪定义?答:领域定义错误类型,边界映射对外错误码。

06.8.5.3-005 依赖方向规则是什么?

一句话结论

外层依赖内层抽象,内层不感知外层实现;依赖通过接口倒置,领域/用例层不依赖 Web、DB 等外层细节。

概念解释

分层架构依赖方向单向向内。外层定义实现,内层定义端口接口。更换框架/存储不改内层。依赖规则可用架构守护测试强制。反向依赖(领域引用 Web 类型)破坏隔离。

原理流程

  1. 内层定义端口接口。
  2. 外层实现接口。
  3. 组装时注入实现。
  4. 内层只依赖接口。

代码或图示

Web → Service 端口 ← Service 实现 → Repository 端口 ← Repository 实现

常见误区

  • 内层直接 import 外层框架类。
  • 接口定义在外层,内层反向依赖。

追问

  • 依赖倒置与 DI 关系?答:DI 负责组装注入,依赖倒置定义方向规则。
  • 怎么检查违规?答:架构守护测试扫描包/模块依赖。

06.8.5.3-006 端口适配器(六边形)在 Kotlin 下怎么落地?

一句话结论

核心用例定义入站/出站端口接口,Web、DB、消息等作为适配器实现端口;核心不感知适配器技术,可替换可独立测试。

概念解释

六边形架构把业务核心置于中心,外部能力通过端口接入。入站端口由适配器调用核心,出站端口由核心定义、适配器实现。Kotlin 用接口表达端口。适配器模块独立,核心模块不依赖适配器。

原理流程

  1. 核心定义用例端口与出站端口。
  2. Web/DB/MQ 适配器实现端口。
  3. 组装层连接核心与适配器。
  4. 替换适配器不改核心。

代码或图示

核心:OrderUseCase 接口 / OrderRepository 接口
适配器:Web 控制器实现入站;DB 实现 OrderRepository

常见误区

  • 端口接口里夹带框架类型。
  • 核心直接调用具体适配器实现。

追问

  • 与三层架构怎么对应?答:三层是六边形的简化,核心对应 Service/领域,适配器对应 Controller/Repository。
  • 端口接口放哪个模块?答:核心模块,适配器模块依赖核心。

06.8.5.3-007 Gradle 模块化怎么用 api 与 implementation?

一句话结论

implementation 只在本模块编译用,api 会传递给依赖本模块的模块;对外暴露的公共类型用 api,内部实现细节用 implementation。

概念解释

依赖声明影响编译传递与构建缓存。模块公共 API 用到的类型必须 api 暴露;内部实现依赖用 implementation 隔离。滥用 api 扩大编译面,拖慢构建并泄露内部。模块边界对应架构分层。

原理流程

  1. 划分模块与公共 API。
  2. 公共类型依赖标 api。
  3. 内部实现依赖标 implementation。
  4. 编译验证传递依赖正确。

代码或图示

dependencies {
    api("org.jetbrains.kotlinx:kotlinx-coroutines-core")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
}

常见误区

  • 全部 api,依赖关系网状扩散。
  • 公共 API 用 implementation,下游编译找不到类型。

追问

  • 怎么判断该用哪个?答:看该类型是否出现在本模块公开签名中。
  • 模块化对构建速度影响?答:隔离模块可增量编译,见后续构建题目。

06.8.5.3-008 模块契约 API 包怎么组织?

一句话结论

模块对外只暴露 api 包下的公共类型,内部实现放 internal/impl 包;依赖方只引用 API 包,实现可替换。

概念解释

模块契约即对外稳定面。公共接口、DTO、错误类型放 API 包;实现类、内部工具隐藏。Kotlin internal 限制模块内可见。API 包变更走兼容评审。模块间只依赖对方 API 包。

原理流程

  1. 定义模块对外 API 包。
  2. 实现类置于内部包。
  3. 组装层装配实现。
  4. 依赖方只引用 API。

代码或图示

order-api/   接口、DTO、错误类型
order-impl/  实现类、Repository、编排

常见误区

  • 实现类直接被外部引用,替换困难。
  • 内部工具类暴露到 API 包。

追问

  • 同一模块内分 API 子包可以吗?答:可以,强隔离则拆模块。
  • API 向后兼容怎么保证?答:新增兼容,废弃过渡,不破坏签名。

06.8.5.3-009 跨层直接调用有什么禁止规则?

一句话结论

禁止 Controller 直接访问 Repository、领域模型被外层穿透;调用沿分层/端口方向走,跨层需求通过用例编排暴露。

概念解释

跨层直调绕过业务规则,导致规则散落。Controller 需要数据时调用 Service 用例,不直达 Repository。数据组装由 Service 完成。规则强制由评审与架构测试守护。

原理流程

  1. 请求进入 Controller。
  2. Controller 调用用例端口。
  3. 用例编排 Repository。
  4. 结果逐层返回。

代码或图示

禁止:Controller → Repository
允许:Controller → Service → Repository

常见误区

  • 为省事 Controller 直接查库。
  • 多个 Repository 在 Controller 拼装数据。

追问

  • 只读查询也要走 Service 吗?答:走查询用例/端口,保持边界一致。
  • 违规怎么发现?答:架构守护测试扫描依赖方向。

06.8.5.3-010 Service 的事务边界怎么定?

一句话结论

事务边界设在用例(Service 方法)层,一个用例一个事务;Repository 只操作数据,不自行开事务。跨用例一致性通过分布式方案解决,不在单服务内跨方法套事务。

概念解释

事务包裹业务用例的完整读写单元。Repository 方法在事务内被调用。事务边界太细导致部分提交,太粗长事务占资源。编排多个用例时明确一致性策略。框架事务注解作用在用例层。

原理流程

  1. 用例方法定义事务边界。
  2. 方法内多次 Repository 调用同事务。
  3. 异常回滚。
  4. 跨服务一致性走消息/分布式事务。

代码或图示

@Transactional
fun createOrder(cmd: CreateOrder): OrderResult {
    // 多次 Repository 调用在同一事务内
}

常见误区

  • Repository 方法各自开事务,用例内多次提交不一致。
  • 长事务包裹远程调用,持锁过久。

追问

  • 事务能包住消息发送吗?答:注意事务与外部副作用顺序,见事务与消息一致性题目。
  • 只读用例要事务吗?答:只读可标注只读事务,按框架能力确认。

06.8.5.3-011 Controller 为什么不能写业务逻辑?

一句话结论

Controller 只做协议适配与参数校验,业务规则在 Service;否则规则被协议层绑死,难以复用与测试。

概念解释

Controller 易随 HTTP 框架变动,业务规则需要稳定独立。把规则放 Service,可被其他入口(消息、定时任务)复用。Controller 负责请求解析、调用用例、响应映射。业务判断不下放到接口层。

原理流程

  1. Controller 解析与校验请求。
  2. 构造命令调用用例。
  3. 映射结果为响应。
  4. 规则全部在 Service/领域。

代码或图示

@PostMapping("/orders")
fun create(@RequestBody req: CreateOrderRequest): ResponseEntity<OrderDto> {
    val result = orderService.create(req.toCommand())
    return result.toResponse()
}

常见误区

  • Controller 内写条件分支决定业务结果。
  • 业务规则只在 HTTP 入口实现,其他入口缺失。

追问

  • 参数校验算业务逻辑吗?答:格式/非空校验在边界,业务规则在领域。
  • Controller 能调多个 Service 吗?答:编排复杂时应由应用服务完成,Controller 不拼装。

06.8.5.3-012 Repository 层职责边界是什么?

一句话结论

Repository 只负责数据存取与存储模型到领域模型转换,不做业务规则判断;方法表达领域概念,不暴露存储细节。

概念解释

Repository 对上提供领域视角的存取接口,对下隔离具体存储。查询条件翻译为存储查询。业务规则(能否下单、状态流转)在领域/用例层。Repository 不返回框架实体给上层。

原理流程

  1. 上层按领域概念调用 Repository。
  2. Repository 翻译为存储查询/写入。
  3. 存储模型转换为领域模型。
  4. 返回领域结果。

代码或图示

interface OrderRepository {
    fun findById(id: OrderId): Order?
    fun save(order: Order)
}

常见误区

  • Repository 方法名是 SQL 操作名,泄露存储细节。
  • 业务规则在 Repository 判断后返回过滤结果。

追问

  • 复杂查询怎么放 Repository?答:查询用例通过 Repository 端口取数,规则在用例层。
  • Repository 返回实体还是模型?答:返回领域模型,实体为内部适配。

06.8.5.3-013 应用服务(用例编排)承担什么角色?

一句话结论

应用服务编排领域对象与外部能力,完成一个用例;它不写领域规则细节,但负责事务、权限、调用顺序与结果组装。

概念解释

应用服务是用例层入口:接收命令、调用领域对象执行规则、协调 Repository/消息/外部客户端。领域对象承载业务规则,应用服务负责流程编排。一个用例对应一个应用服务方法。

原理流程

  1. 应用服务接收命令。
  2. 加载领域对象执行规则。
  3. 协调存储与外部能力。
  4. 返回用例结果。

代码或图示

应用服务:校验命令 → 领域对象决策 → 持久化 → 发事件 → 结果

常见误区

  • 应用服务变成贫血模型的规则仓库。
  • 编排逻辑散落在 Controller。

追问

  • 应用服务与领域服务区别?答:应用服务编排流程,领域服务承载跨对象业务规则。
  • 用例很薄合理吗?答:规则在领域对象内,用例薄属正常。

06.8.5.3-014 为什么领域模型用不可变 data class?

一句话结论

领域状态用不可变值对象与 data class 表达,变更产生新实例;避免共享可变状态被意外修改,便于推理与测试。

概念解释

不可变模型在并发与多版本场景下更安全。状态流转通过返回新状态实现。data class 提供值语义与相等比较。可变集合暴露给外部要加只读视图。修改集中在明确的业务方法内。

原理流程

  1. 定义不可变领域值对象。
  2. 业务方法返回新状态实例。
  3. 外部持有引用不可改内部。
  4. 相等按值比较。

代码或图示

data class Order(val id: OrderId, val status: OrderStatus) {
    fun confirm(): Order = copy(status = OrderStatus.CONFIRMED)
}

常见误区

  • 领域对象带可变字段被各处修改。
  • 暴露内部可变集合引用。

追问

  • 大对象频繁 copy 性能?答:热点路径评估,值对象通常小;可变聚合根按场景权衡。
  • 不可变与 ORM 怎么调和?答:持久化实体可变,加载后转为不可变领域模型。

06.8.5.3-015 空安全怎么在层间传递?

一句话结论

类型系统显式表达可空,上层不假设下层返回非空;边界把外部不可信数据转为内部非空类型,禁止 !! 穿透。

概念解释

Kotlin 空安全靠类型标注。Repository 找不到返回可空,用例显式处理。边界外部输入校验后转非空。!! 绕过检查是隐患,评审拦截。跨层签名标注清楚可空性。

原理流程

  1. 边界校验外部输入。
  2. 内部类型标注可空/非空。
  3. 调用处显式处理 null。
  4. 禁止强制非空断言。

代码或图示

fun findById(id: OrderId): Order?  // 可空表达可能不存在
fun requireById(id: OrderId): Order = findById(id) ?: throw NotFoundException(id)

常见误区

  • 内部接口全标非空,实际可能返回 null。
  • 用 !! 压警告,运行期 NPE。

追问

  • 外部 JSON 字段缺失怎么处理?答:边界校验后映射,不把可空状态带入领域。
  • 空默认值与 null 区分?答:类型上明确,不用默认值掩盖缺失。

06.8.5.3-016 sealed class 怎么表达业务状态?

一句话结论

用 sealed 类/接口封闭业务状态与错误类型,编译器强制穷尽分支;比字符串枚举/状态码更类型安全。

概念解释

sealed 限制子类集合,when 表达式可穷尽检查。业务状态、错误类型、结果变体用 sealed 表达。新增变体编译器提示未处理分支。避免字符串状态散落比较。

原理流程

  1. 定义 sealed 状态/错误层级。
  2. 各变体携带必要数据。
  3. 用 when 穷尽匹配。
  4. 新增变体编译期检查覆盖。

代码或图示

sealed interface OrderStatus {
    data object Pending : OrderStatus
    data class Paid(val paidAt: Instant) : OrderStatus
    data object Cancelled : OrderStatus
}

常见误区

  • 状态用字符串,拼写错误运行期才发现。
  • when 不做穷尽检查,漏分支。

追问

  • sealed 与 enum 选择?答:状态无附加数据用 enum,变体带数据用 sealed。
  • 序列化怎么处理?答:边界层映射为对外契约格式。

06.8.5.3-017 架构守护测试怎么做(ArchUnit 思路)?

一句话结论

用测试断言包/模块依赖方向、层间调用规则与命名约定;架构违规在 CI 阶段失败,不靠评审记忆维护。

概念解释

架构规则随演进易被破坏。守护测试把分层规则变成可执行断言:Controller 不依赖 Repository、领域不依赖框架、包名约定。测试失败阻断合并。规则随架构调整更新。

原理流程

  1. 提取架构规则(依赖方向、包约定)。
  2. 编写架构测试扫描类/模块。
  3. CI 运行守护测试。
  4. 违规阻断并提示修复。

代码或图示

规则:controller 不得访问 repository;domain 不得依赖 web/db 框架

常见误区

  • 规则只写文档,无测试强制。
  • 架构测试运行太慢,被跳过。

追问

  • Kotlin 生态有哪些架构测试库?答:ArchUnit JVM 等可选,具体坐标与 API 待确认。
  • 模块级规则怎么测?答:Gradle 模块依赖声明与包扫描结合。

06.8.5.3-018 包结构怎么约定?

一句话结论

按分层/业务域组织包结构,每层职责对应包名;包内聚一个用例或领域概念,避免按技术类型平铺。

概念解释

包结构体现架构边界。常见按域分包(order/payment),包内分 controller/service/repository;大模块再拆 Gradle 模块。包名稳定公开,内部类不跨包滥用。结构与依赖规则一致。

原理流程

  1. 按业务域划包。
  2. 域内按层分子包。
  3. 公共契约出 API 包。
  4. 架构测试校验包依赖。

代码或图示

com.app.order
 ├─ api/        契约
 ├─ application/用例
 ├─ domain/     领域
 └─ infra/      适配器

常见误区

  • 按技术类型分包(所有 controller 一层),业务切分困难。
  • 包内混杂多域概念,边界模糊。

追问

  • 包结构和 Gradle 模块关系?答:包是源码组织,模块是编译隔离;大域拆模块。
  • 包名会变吗?答:公开包名谨慎调整,内部结构可重构。

06.8.5.3-019 领域事件怎么在层间传递?

一句话结论

领域对象产生事件记录,应用服务在事务提交后发布;事件表达已发生的业务事实,跨层通过事件通道传递,不反向调用领域。

概念解释

领域事件解耦主流程与后续动作。聚合在状态变更时记录事件,用例统一发布。事件携带不可变事实数据。事务内记录、提交后发出,避免未提交数据对外可见。监听方按事件做后续处理。

原理流程

  1. 领域变更记录事件到聚合。
  2. 用例提交事务。
  3. 提取事件发布到通道。
  4. 监听方异步/同步处理。

代码或图示

class Order {
    val events = mutableListOf<DomainEvent>()
    fun confirm() { events += OrderConfirmed(id) }
}

常见误区

  • 事务未提交就发事件,消费方读到未提交数据。
  • 事件回调反向依赖领域实现细节。

追问

  • 事件发布失败怎么办?答:可靠性按消息机制处理,见分布式与 MQ 分册。
  • 同步事件 vs 消息?答:进程内事件解耦内部,跨进程走消息。

06.8.5.3-020 事务跨层常见什么问题?

一句话结论

事务边界与编排层级错位会导致长事务、部分提交或副作用不一致;事务在用例层开启,Repository 不自行管理,外部调用不包在事务内。

概念解释

常见问题:Repository 各自开事务导致用例内多次提交;事务包裹远程调用拉长锁持有;事件/消息在事务内发出后回滚。梳理事务边界与副作用顺序。跨服务一致性不在本地事务解决。

原理流程

  1. 用例层声明事务。
  2. 存储操作在事务内。
  3. 外部调用与事件在提交后处理。
  4. 异常回滚存储。

代码或图示

事务内:数据库读写
事务提交后:发消息/事件/远程回调

常见误区

  • 事务内调用外部 HTTP,持锁等待。
  • 消息先发出后事务回滚,产生脏通知。

追问

  • 本地事务与消息一致性怎么做?答:事务发件表/Outbox 模式,见 09 分册。
  • 只读事务怎么声明?答:按框架注解标记只读,减少事务开销。

06.8.5.3-021 测试金字塔怎么在 Kotlin 后端落地?

一句话结论

大量快速单元测试覆盖业务规则,少量集成测试验证组件协作,少量端到端测试覆盖关键链路;越上层越慢越少。

概念解释

金字塔:底层单元测试快而多,中层集成测试验证真实组件,顶层 E2E 覆盖主流程。业务规则在单元测试隔离验证;跨组件契约靠集成测试。不要把大量逻辑推到慢 E2E 测试。

原理流程

  1. 单元测试覆盖领域/用例规则。
  2. 集成测试接真实 DB/消息组件。
  3. E2E 覆盖关键业务链路。
  4. 按层控制数量与速度。

代码或图示

   E2E(少,慢)
  集成(中)
 单元(多,快)

常见误区

  • 单元测试全 mock,未验证真实规则。
  • 核心逻辑只靠 E2E 覆盖,反馈慢。

追问

  • 接口测试算哪层?答:测试真实服务装配的接口属集成测试。
  • 怎么控制测试时长?答:单元快速本地跑,集成进 CI 门禁。

06.8.5.3-022 单元测试的纯函数与 mock 边界怎么划?

一句话结论

纯业务逻辑直接测,不 mock;外部依赖通过接口在测试替身替换。mock 只替代跨边界依赖,不在同一模块内 mock 真实业务对象。

概念解释

单元测试隔离被测单元,协作外部接口用替身。领域纯函数不依赖外部,直接构造输入断言。Repository/客户端接口 mock 返回。mock 过多说明边界设计可能有问题。

原理流程

  1. 提取被测用例/领域对象。
  2. 外部依赖接口注入。
  3. 测试提供替身/mock。
  4. 断言业务行为。

代码或图示

@Test
fun `pending order cannot pay twice`() {
    val order = OrderFixture.pending()
    // 纯规则断言,无 mock
}

常见误区

  • mock 内部领域对象,测试实现细节而非行为。
  • 一个测试 mock 十几个依赖,装配复杂。

追问

  • mock 接口还是实现?答:mock 接口契约,替换实现。
  • 替身类型有哪些?答:桩、假实现、mock,按用途选择。

06.8.5.3-023 mockk 与 Mockito 在 Kotlin 下怎么选?

一句话结论

Kotlin 项目常用 mockk(原生支持 Kotlin 类/协程/表达式),Mockito 需额外配置处理 final 类;按既有技术栈与协程需求选择。具体版本 API 待确认。

概念解释

mockk 是 Kotlin 友好的 mock 库,支持 final 类、协程挂起函数。Mockito 默认不能 mock final 类,需开启 inline 配置。两者都替代接口/类行为。团队统一选择一种,避免混用。

原理流程

  1. 测试框架引入 mock 库。
  2. 声明 mock 协作依赖。
  3. 打桩返回/验证调用。
  4. 断言行为。

代码或图示

val repo = mockk<OrderRepository>()
every { repo.findById(any()) } returns order
verify(exactly = 1) { repo.save(any()) }

常见误区

  • 混用两套 mock 库,配置冲突。
  • mock 过度验证调用细节,测试脆弱。

追问

  • 协程挂起函数怎么 mock?答:mockk 原生支持,Mockito 配置按版本确认(待确认)。
  • 不 mock 框架 bean 行吗?答:单测装配边界,只 mock 外部依赖。

06.8.5.3-024 Testcontainers 怎么起数据库做集成测试?

一句话结论

测试启动真实数据库容器,应用配置指向容器实例,跑完测试销毁容器;集成测试验证真实 SQL/迁移行为,不依赖本地安装数据库。

概念解释

Testcontainers 用 Docker 拉起数据库等依赖,测试获得隔离真实环境。连接信息动态注入配置。迁移脚本在容器库上执行验证。测试间容器隔离或复用。基线 Testcontainers 1.x,具体模块坐标待确认。

原理流程

  1. 测试启动数据库容器。
  2. 等待就绪,取连接配置。
  3. 应用用该配置启动/执行测试。
  4. 测试结束停止容器。

代码或图示

@Testcontainers
class OrderRepositoryIT {
    companion object {
        @Container val db = PostgreSQLContainer("postgres:16")
    }
}

常见误区

  • 用 H2 替代生产数据库验证 SQL,方言差异漏问题。
  • 容器未等待就绪就连接,测试偶发失败。

追问

  • 容器镜像版本怎么对齐生产?答:镜像版本与生产数据库版本一致。
  • 非 JVM 服务怎么用 Testcontainers?答:Testcontainers 提供 JVM 绑定;其他语言用对应库。

06.8.5.3-025 集成测试容器复用怎么平衡性能?

一句话结论

类级/全局复用容器减少启动开销,但测试间数据需隔离;权衡复用速度与数据污染,按测试套件规模选择复用级别。

概念解释

每次测试新建容器慢,复用容器快但共享状态。复用级别:方法级隔离、类级共享、全局共享。隔离靠事务回滚或数据清理。复用容器配置与迁移执行一次。CI 环境注意 Docker 资源。

原理流程

  1. 选择容器复用级别。
  2. 共享容器一次初始化。
  3. 测试间清理/回滚数据。
  4. 套件结束销毁。

代码或图示

全局容器:启动一次 → 多类复用 → 每用例清理数据

常见误区

  • 复用容器未清理数据,用例互相污染。
  • 为速度复用导致测试偶发失败难排查。

追问

  • 复用级别怎么定?答:套件小用方法级隔离,套件大用类/全局复用加清理。
  • 容器启动慢怎么优化?答:预热镜像、复用 JVM 内容器、检查拉取缓存。

06.8.5.3-026 契约测试解决什么问题?

一句话结论

契约测试验证服务间接口契约(请求/响应、状态码、错误格式)与提供方约定一致,防止消费方假设与提供方实现漂移。

概念解释

微服务协作中提供方变更易破坏消费方。契约测试把接口约定固化:提供方验证符合契约,消费方基于契约桩测试。契约可由消费方生成并共享。与端到端测试互补,定位契约层问题。

原理流程

  1. 定义接口契约(字段/类型/错误)。
  2. 提供方测试验证契约。
  3. 消费方用契约替身测试。
  4. 契约变更双向校验。

代码或图示

提供方契约测试 ← 契约 → 消费方契约桩

常见误区

  • 只有联调环境 E2E,契约漂移到后期才发现。
  • 契约只测成功路径,忽略错误响应。

追问

  • 契约测试工具选型?答:按技术栈评估,具体框架坐标待确认。
  • 契约版本怎么管理?答:随 API 版本演进,废弃有过渡期。

06.8.5.3-027 测试数据工厂怎么组织?

一句话结论

用工厂/构建器生成测试领域对象与 DTO,默认合法、关键字段可覆盖;避免每个用例手写大量样板数据。

概念解释

测试数据集中工厂管理,保证默认合法可通过校验。字段按用例覆盖变体。工厂生成领域对象,测试数据模型与生产模型一致。夹具避免硬编码业务假设。

原理流程

  1. 定义测试工厂/构建器。
  2. 默认值构造合法对象。
  3. 用例覆盖特定字段。
  4. 多变体由工厂方法提供。

代码或图示

object OrderFixture {
    fun pending(id: Long = 1) = Order(OrderId(id), OrderStatus.Pending)
}

常见误区

  • 测试数据散落各用例,字段调整多处改。
  • 工厂对象绕过领域校验,生成非法状态。

追问

  • 工厂与 builder 选择?答:简单对象工厂方法,多可选字段用 builder。
  • 测试种子数据放哪?答:测试资源/初始化脚本,工厂负责内存对象。

06.8.5.3-028 集成测试数据怎么隔离?

一句话结论

用事务回滚、每用例清理或独立数据集保证测试间互不影响;隔离策略按测试类型固定,不依赖执行顺序。

概念解释

共享数据库下测试残留数据导致顺序依赖。手段:用例事务回滚、前后清空表、独立 schema/数据集。测试不假设执行顺序。隔离策略写入测试约定。

原理流程

  1. 用例前准备数据集。
  2. 执行被测逻辑。
  3. 回滚或清理数据。
  4. 下一用例从干净状态开始。

代码或图示

隔离:事务回滚 / 表清空 / 独立 schema

常见误区

  • 测试依赖上一用例残留数据,顺序调换即失败。
  • 只清理部分表,关联数据残留。

追问

  • 回滚能覆盖已提交数据吗?答:不能,跨提交用例需清理策略。
  • 并发跑测试怎么隔离?答:独立数据库/schema 或行级隔离。

06.8.5.3-029 并发与竞态怎么测试?

一句话结论

并发测试用多线程/协程重复执行临界区,观察一致性与异常;竞态用重复压测与断言不变量验证,不能靠单次执行证明无并发问题。

概念解释

竞态缺陷偶发,单线程测试暴露不出。并发测试:多协程/线程同时操作共享状态,断言不变量(计数、状态合法)。重复运行提高暴露概率。锁与隔离正确性结合单元与集成测试。

原理流程

  1. 识别共享状态临界区。
  2. 并发触发多轮操作。
  3. 断言不变量与结果一致。
  4. 重复运行观察偶发失败。

代码或图示

runTest {
    (1..100).map { async { service.operation() } }.awaitAll()
    verifyInvariant()
}

常见误区

  • 单线程通过即认为并发安全。
  • 并发测试无断言,只看是否崩溃。

追问

  • 竞态复现不了怎么办?答:提高并发轮次、加压力、检查日志时序。
  • 共享状态测试用真实容器吗?答:乐观/悲观锁行为在集成测试验证。

06.8.5.3-030 参数化测试怎么用?

一句话结论

同一逻辑多组输入输出用参数化测试驱动,避免复制粘贴用例;分组覆盖正常、边界与非法输入。

概念解释

参数化把测试逻辑与数据分离。每组参数独立报告失败。边界值、非法枚举、典型场景成组列出。参数命名清晰表达场景。框架参数化 API 按测试库版本确认。

原理流程

  1. 提取测试公共逻辑。
  2. 列参数组(输入/期望)。
  3. 参数化执行每组。
  4. 失败定位到具体参数组。

代码或图示

listOf(
    Case("valid", input, expected),
    Case("invalid", badInput, error)
).forEach { /* 断言 */ }

常见误区

  • 参数组混在一起,失败场景不清晰。
  • 只覆盖正常输入,缺边界与非法。

追问

  • 参数化框架用什么?答:JUnit5 参数化或 Kotlin 测试库,坐标待确认。
  • 复杂对象怎么做参数?答:工厂构造参数值。

06.8.5.3-031 测试命名与 Given/When/Then 怎么规范?

一句话结论

测试名表达场景与预期(「当条件时期望结果」),体内分 Given/When/Then 三段;一个用例验证一个行为。

概念解释

测试名读起来即规格说明。Given 准备数据与依赖,When 执行被测动作,Then 断言结果。命名不暴露实现细节。失败时测试名直接说明哪个场景出问题。

原理流程

  1. Given:构造输入与替身。
  2. When:调用被测单元。
  3. Then:断言结果与状态。
  4. 命名对应场景。

代码或图示

@Test
fun `pending order confirmed then status is paid`() {
    // Given
    val order = OrderFixture.pending()
    // When
    val paid = order.pay()
    // Then
    assertEquals(OrderStatus.Paid, paid.status)
}

常见误区

  • 测试名用方法名堆砌,无语义。
  • 一个用例断言多个无关行为。

追问

  • 中文测试名可以吗?答:团队统一风格,保持可读。
  • 注释替代命名?答:场景由测试名表达,注释解释复杂意图。

06.8.5.3-032 协程代码怎么测试?

一句话结论

用 runTest 与测试调度器运行协程代码,控制虚拟时间,断言挂起结果;测试注入测试调度器,不依赖真实线程池时序。

概念解释

协程测试需要受控调度器。runTest 提供测试调度器与虚拟时间,快速推进延迟。挂起函数直接在测试协程调用。异步启动的子协程需等待收尾。调度器注入便于测试切换。

原理流程

  1. 测试用 runTest 启动。
  2. 被测协程在测试调度器执行。
  3. 虚拟时间推进延迟任务。
  4. 断言结果与状态。

代码或图示

@Test
fun `create order returns result`() = runTest {
    val result = service.create(cmd)
    assertEquals(OrderStatus.Pending, result.status)
}

常见误区

  • 测试用真实 Dispatchers.IO,时序不确定偶发失败。
  • 子协程未等待,断言先于执行。

追问

  • 调度器怎么注入?答:用例接收调度器参数,生产传 IO,测试传测试调度器。
  • 超时测试怎么做?答:测试调度器虚拟时间推进超时分支。

06.8.5.3-033 测试覆盖率怎么解读?

一句话结论

覆盖率衡量代码被执行比例,不衡量断言质量;作为辅助指标,重点覆盖分支与业务规则,不追求无意义高百分比。

概念解释

覆盖率统计行/分支是否被测试执行,未断言的执行不算验证。高覆盖率可能只是走过代码。关注核心业务分支与错误路径。覆盖率阈值按模块成熟度设定。工具统计口径按构建配置。

原理流程

  1. 测试运行收集覆盖数据。
  2. 报告未覆盖分支。
  3. 补核心规则测试。
  4. 阈值门禁拦截关键模块退化。

代码或图示

覆盖率:行覆盖 / 分支覆盖;关注错误分支与边界,不只看总行数

常见误区

  • 为覆盖率写无断言测试。
  • 只看总行覆盖,遗漏分支未测。

追问

  • 覆盖率阈值定多少?答:核心模块从严,遗留模块逐步提升,不一刀切。
  • 覆盖率工具选什么?答:按构建链配置,具体插件待确认。

06.8.5.3-034 外部依赖替身策略怎么选?

一句话结论

按测试目的选:单元测试用 mock/桩替代接口,集成测试用 Testcontainers 真实组件;替身保真度与测试速度权衡。

概念解释

替身谱系:mock 验证调用、桩返回固定值、假实现内存版、真实容器。单元快但不保真,集成保真但慢。按风险选择:外部契约用契约测试,内部规则用 mock。不要用假实现替代生产协议验证。

原理流程

  1. 明确测试目的(规则/契约/集成)。
  2. 选择对应替身保真度。
  3. 关键外部依赖真实组件验证。
  4. 记录替身与生产差异。

代码或图示

单测:mock/桩 → 集成:Testcontainers 真实依赖 → E2E:真实环境

常见误区

  • 关键外部调用只 mock,协议差异上线才暴露。
  • 集成测试连共享开发环境,不稳定。

追问

  • 第三方无测试环境怎么办?答:契约桩 + 沙箱,记录未覆盖风险。
  • 替身差异怎么标注?答:测试说明与待确认清单记录。

06.8.5.3-035 测试环境配置怎么管理?

一句话结论

测试用独立配置与测试数据,不连生产;配置通过测试资源/环境注入,敏感值用测试替身,与生产配置结构一致。

概念解释

测试配置独立 profile,指向测试容器/桩。测试不依赖开发者本地环境。配置校验在测试装配中同样生效。测试用密钥不使用真实凭证。配置差异最小化,避免「测试能跑生产不行」。

原理流程

  1. 加载测试 profile 配置。
  2. 注入容器/桩连接信息。
  3. 初始化测试数据。
  4. 测试结束清理。

代码或图示

测试配置:测试 DB 容器地址 / 桩客户端 / 测试密钥

常见误区

  • 测试默认连本地开发库,环境依赖不稳定。
  • 测试配置与生产结构不一致,校验未覆盖。

追问

  • 测试配置放源码吗?答:非敏感测试默认值可入库,敏感测试值走环境注入。
  • 多套测试环境配置?答:按套件区分,共享基础配置。

06.8.5.3-036 多阶段 Dockerfile 怎么组织?

一句话结论

构建阶段编译打包,运行阶段只拷贝产物与运行时;镜像分层构建,运行镜像不含编译器与源码。

概念解释

多阶段构建用一个 Dockerfile 分阶段:第一阶段用 JDK 镜像编译、测试、打包;第二阶段用 JRE/精简运行时镜像拷贝产物。运行镜像体积小、攻击面小。构建缓存按层复用。阶段间只复制必要文件。

原理流程

  1. 构建阶段:依赖缓存、编译、打包。
  2. 产物输出 fat jar/分层 jar。
  3. 运行阶段:基础运行时镜像。
  4. 拷贝产物与必要配置启动。

代码或图示

FROM gradle:8-jdk21 AS build
WORKDIR /app
COPY . .
RUN gradle bootJar --no-daemon

FROM eclipse-temurin:21-jre
COPY --from=build /app/build/libs/*.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

常见误区

  • 运行镜像用 JDK 全量镜像,体积过大。
  • 构建产物与源码混在同一镜像层。

追问

  • 多阶段能跑测试吗?答:构建阶段可执行测试,失败中断镜像构建。
  • 依赖缓存怎么放?答:先拷贝依赖清单利用层缓存,再拷源码。

一句话结论

运行镜像优先精简 JRE 或 jlink 裁剪运行时;JDK 只用于构建阶段。按应用实际模块裁剪,平衡体积与兼容性。

概念解释

JDK 含编译工具,运行不需要。JRE 镜像提供运行时;jlink 按模块裁剪生成定制运行时,体积更小。裁剪需确认应用反射/动态类需求。基础镜像版本与编译 JDK 对齐。安全更新跟随基础镜像。

原理流程

  1. 构建阶段用 JDK 镜像。
  2. 运行阶段选 JRE 或 jlink 运行时。
  3. 确认应用所需模块未被裁剪。
  4. 定期更新基础镜像补丁。

代码或图示

构建:JDK 21;运行:JRE 21 / jlink 裁剪运行时

常见误区

  • 运行镜像保留完整 JDK。
  • jlink 裁剪遗漏反射依赖,运行期类找不到。

追问

  • GraalVM 原生镜像算另一路线吗?答:是 AOT 路线,见 DI 与 AOT 题目;本篇以 JVM 镜像为主。
  • 基础镜像来源怎么选?答:官方维护、定期补丁的发行版镜像。

06.8.5.3-038 镜像分层怎么利用构建缓存?

一句话结论

Dockerfile 把变化少的依赖层放前面、变化多的源码层放后面;依赖清单先拷贝,源码变更不失效依赖缓存。

概念解释

镜像按层缓存,层内文件变更则后续层重建。依赖下载/编译重,应在源码变更时复用。顺序:依赖清单 → 下载依赖 → 源码 → 打包。频繁变更的配置放后层。缓存命中加快构建。

原理流程

  1. 拷贝构建依赖清单。
  2. 下载依赖层(缓存)。
  3. 拷贝源码。
  4. 打包启动。

代码或图示

COPY build.gradle settings.gradle ./
RUN gradle dependencies
COPY src ./src
RUN gradle bootJar

常见误区

  • 先拷全部源码再下依赖,源码改动失效依赖缓存。
  • 层内混放频繁变更文件,缓存命中率低。

追问

  • CI 缓存与镜像层缓存关系?答:Gradle 缓存加速依赖解析,镜像层缓存加速打包。
  • 缓存失效怎么排查?答:看哪一层开始重建,对应文件变更。

06.8.5.3-039 容器内 JVM 内存参数怎么配?

一句话结论

JVM 需感知容器内存限制,堆与直接内存/元空间总和不超过容器 limit;按容器内存设置 -Xmx 并保留堆外预算。具体默认行为按 JDK 版本确认(待确认)。

概念解释

老版本 JVM 读取宿主机内存而非容器 limit,导致超 limit 被杀。现代 JDK 支持容器内存感知,但堆大小仍需显式规划。预算 = 堆 + 元空间 + 直接内存 + 线程栈 + JVM overhead。limit 留出堆外空间。

原理流程

  1. 设定容器内存 limit。
  2. 计算堆占比与堆外预算。
  3. 设置 -Xmx 等参数。
  4. 压测验证实际内存占用。

代码或图示

容器 limit 1G:-Xmx 512m~640m,剩余留给堆外/元空间/线程栈

常见误区

  • -Xmx 按宿主机内存设置,容器内超 limit OOMKilled。
  • 忽略直接内存/元空间,堆外膨胀超限。

追问

  • 怎么查容器内 JVM 识别的内存?答:JVM 启动参数与容器 cgroup 限制对照。
  • 堆外内存包括哪些?答:直接缓冲区、线程栈、元空间、本机库。

06.8.5.3-040 容器为什么用 non-root 用户运行?

一句话结论

镜像内应用以非 root 用户运行,降低容器逃逸后主机权限风险;文件与目录归属该用户,权限最小化。

概念解释

容器内 root 与主机 root 有映射关系,特权风险高。non-root 用户运行进程,镜像内文件归属受限用户。必要目录挂载给用户可写。镜像扫描检查 root 运行与特权端口。

原理流程

  1. 镜像创建非 root 用户。
  2. 拷贝产物归属该用户。
  3. USER 指令切换。
  4. 启动进程以该用户运行。

代码或图示

RUN useradd -r appuser
USER appuser
ENTRYPOINT ["java", "-jar", "app.jar"]

常见误区

  • 容器内 root 运行,挂载目录权限失控。
  • 监听 1024 以下端口导致被迫用 root。

追问

  • 非 root 怎么写日志?答:标准流输出,不在容器内写受限目录。
  • 镜像扫描报 root 运行怎么修?答:Dockerfile 加非 root 用户。

06.8.5.3-041 镜像瘦身与 JIB 怎么选?

一句话结论

瘦身手段:精简基础镜像、分层 jar、jlink、排除无关文件;JIB 直接构建镜像无需 Docker 守护进程,按团队构建链选择。工具坐标与版本待确认。

概念解释

镜像体积影响拉取速度与攻击面。分层 jar 让依赖层与应用层分开缓存。JIB 在 Gradle/Maven 侧直接生成镜像层,不依赖本地 Docker。传统 Dockerfile 灵活但需 Docker 环境。两者按 CI 能力选型。

原理流程

  1. 评估镜像体积构成。
  2. 精简基础镜像与运行时。
  3. 分层打包或 JIB 构建。
  4. 扫描体积与漏洞。

代码或图示

路线 A:Dockerfile 多阶段 + 分层 jar
路线 B:JIB 插件直接推镜像

常见误区

  • fat jar 整包一层,应用改动全量重建依赖层。
  • 镜像含测试资源、源码、文档等无关文件。

追问

  • JIB 支持分层 jar 吗?答:按 JIB 版本能力确认(待确认)。
  • 镜像体积目标?答:以基础运行时 + 产物为基线,按业务评估。

06.8.5.3-042 fat jar 与分层 jar 有什么区别?

一句话结论

fat jar 把所有依赖打进单个包,简单但层缓存差;分层 jar 把依赖与应用类分层打包,镜像层可复用依赖层,加速重建。

概念解释

fat jar 一次打包全部类,镜像层随应用改动整体重建。分层 jar 按依赖/资源/应用类拆分,镜像分层拷贝,依赖层缓存复用。框架打包插件支持分层配置。运行启动脚本按分层结构加载。

原理流程

  1. 打包时拆分依赖与应用类。
  2. 镜像先拷依赖层。
  3. 再拷应用层。
  4. 应用改动只重建应用层。

代码或图示

分层:dependencies 层 → snapshot 层 → application 层

常见误区

  • 应用代码改动后依赖层也重建,缓存失效。
  • 分层配置与镜像拷贝步骤不匹配,类加载失败。

追问

  • 分层 jar 启动方式?答:按框架分层 jar 启动脚本,具体命令待确认。
  • 本地调试用哪种?答:本地 fat jar 即可,镜像构建用分层。

06.8.5.3-043 镜像内怎么做健康检查?

一句话结论

容器编排平台探针调用应用健康端点;镜像内 HEALTHCHECK 作为补充,不替代平台探针。健康检查区分存活与就绪。

概念解释

平台探针(K8s)从外部探测端点;镜像 HEALTHCHECK 在容器内执行命令。应用暴露健康端点检查依赖连通性。镜像内检查命令轻量,不重复平台编排。健康检查失败触发重启/摘流。

原理流程

  1. 应用暴露健康端点。
  2. 平台探针周期调用。
  3. 端点检查核心依赖。
  4. 失败按探针策略处理。

代码或图示

HEALTHCHECK --interval=30s CMD wget -qO- http://localhost:8080/actuator/health || exit 1

常见误区

  • 健康端点只返回 200,不检查依赖。
  • 镜像 HEALTHCHECK 与平台探针策略冲突。

追问

  • 探针与端点设计细节?答:见后续部署探针题目。
  • 健康检查依赖外部服务会导致误摘流吗?答:区分存活/就绪,依赖故障按策略摘流。

06.8.5.3-044 镜像内时区、字体与原生依赖怎么处理?

一句话结论

镜像显式设置时区,按需安装字体/原生库;应用依赖的系统库在基础镜像中确认,避免容器内运行期缺库报错。

概念解释

精简基础镜像常缺字体、时区数据、原生库。时区通过环境变量或 tzdata 包设置。PDF/图像等功能需要字体包。原生依赖(加密、压缩库)确认在镜像内可用。镜像与生产运行环境依赖一致。

原理流程

  1. 梳理应用系统依赖。
  2. 基础镜像安装必要包。
  3. 设置时区与编码。
  4. 启动验证缺库报错。

代码或图示

TZ=Asia/Shanghai;tzdata;fonts;lib 原生依赖

常见误区

  • 本地完整系统能跑,精简镜像缺库启动失败。
  • 时区默认 UTC,业务时间错乱。

追问

  • 时区在应用还是镜像设?答:镜像/容器环境统一,应用时间戳按规范处理。
  • 字体缺失表现?答:渲染中文乱码/方块,容器内补字体包。

06.8.5.3-045 镜像漏洞扫描怎么做?

一句话结论

镜像构建后扫描基础系统包与依赖漏洞,高危漏洞阻断发布;定期更新基础镜像与依赖,扫描结果纳入 CI 门禁。

概念解释

镜像漏洞来自基础系统包与应用依赖。扫描工具识别 CVE 并评级。门禁拦截高危未修复镜像。基础镜像定期更新补丁。扫描不替代依赖漏洞治理。扫描工具与规则库按项目选型(待确认)。

原理流程

  1. 镜像构建完成。
  2. 扫描系统层与依赖清单。
  3. 匹配漏洞库评级。
  4. 高危阻断,修复后重扫。

代码或图示

镜像构建 → 漏洞扫描 → 高危门禁 → 推送仓库

常见误区

  • 只扫应用依赖,忽略基础系统包。
  • 扫描报告积压不修复,门禁形同虚设。

追问

  • 漏洞修复要升级基础镜像吗?答:系统包漏洞升级基础镜像,依赖漏洞升级库版本。
  • 误报怎么处理?答:评估后在扫描规则中标记例外并记录。

06.8.5.3-046 liveness、readiness、startup 探针各有什么用?

一句话结论

liveness 探测进程是否存活,失败重启;readiness 探测是否可接流量,失败摘流;startup 探测启动完成,慢启动应用避免被 liveness 误杀。

概念解释

三类探针职责分离。存活探针发现死锁/僵死,重启恢复。就绪探针反映依赖与负载,失败从负载均衡摘除。启动探针覆盖慢启动窗口,期间不判存活失败。探针路径与阈值按应用启动时间配置。

原理流程

  1. startup 探针等待应用就绪。
  2. 就绪探针通过后加入流量。
  3. 存活探针持续检查进程健康。
  4. 失败按策略重启/摘流。

代码或图示

startup:启动窗口;readiness:可接流量;liveness:进程存活

常见误区

  • 用 liveness 检查外部依赖,依赖抖动导致反复重启。
  • 慢启动应用未配 startup,启动中被 liveness 杀掉。

追问

  • 探针端点怎么区分?答:存活/就绪可分端点,就绪含依赖检查。
  • 探针超时阈值怎么定?答:按启动耗时与正常响应时间设定。

06.8.5.3-047 优雅停机怎么实现?

一句话结论

收到停机信号后停止接新流量,等待在途请求处理完成,关闭连接池与外部资源,再退出;避免请求被硬切断。

概念解释

容器删除实例先发终止信号。应用先从负载均衡摘流,再处理在途请求。超时后强制退出。数据库连接、消息消费者、线程池有序关闭。停机超时配置与探针摘流配合。

原理流程

  1. 收到 SIGTERM。
  2. 就绪端点转未就绪,摘流。
  3. 等待在途请求完成。
  4. 关闭资源,进程退出。

代码或图示

SIGTERM → 摘流 → 等待在途 → 关闭连接池/消费者 → 退出

常见误区

  • 直接退出,在途请求被切断。
  • 先关连接池,在途请求拿不到连接。

追问

  • 等待多久合理?答:按最长请求超时设定,超时强制退出。
  • 消息消费者停机怎么处理?答:停止拉取,处理完当前消息再关闭。

06.8.5.3-048 健康检查端点怎么设计?

一句话结论

就绪端点检查核心依赖(DB、关键客户端)连通性,存活端点只反映进程自身;不暴露内部细节,分级聚合检查结果。

概念解释

健康端点区分存活与就绪。就绪检查依赖可达性,失败摘流。存活不依赖外部,避免外部故障引发重启循环。检查结果聚合各组件状态。敏感细节不返回给外部。端点路径与框架约定对齐。

原理流程

  1. 存活检查:进程可响应。
  2. 就绪检查:核心依赖连通。
  3. 聚合状态返回。
  4. 探针按端点判定。

代码或图示

/livez:进程存活
/readyz:DB/关键客户端就绪

常见误区

  • 健康端点返回数据库密码等内部信息。
  • 存活检查依赖外部服务,故障时反复重启。

追问

  • 依赖检查超时怎么设?答:短超时快速判定,避免探针堆积。
  • 健康检查要写日志吗?答:失败记录,成功不刷屏。

06.8.5.3-049 灰度与滚动更新怎么落地?

一句话结论

滚动更新逐批替换旧实例,新实例就绪后再接流量;灰度按流量比例/标签路由到新版本,观察指标无异常再全量。

概念解释

滚动更新保证更新期间服务可用:起新实例 → 就绪 → 摘旧实例。灰度(金丝雀)先小比例流量到新版本,对比指标与错误率,逐步放量。回滚在异常时切回旧版本。发布策略与探针、健康检查配合。

原理流程

  1. 部署新版本实例。
  2. 就绪探针通过。
  3. 小比例流量灰度。
  4. 指标观察后全量,异常回滚。

代码或图示

旧版本 → 灰度新版本 5% → 50% → 100%;异常回滚旧版本

常见误区

  • 未就绪就接流量,新实例报错。
  • 灰度无指标对比,放量后才发现问题。

追问

  • 灰度按什么路由?答:标签/版本/流量比例,按平台能力。
  • 数据库变更怎么配合?答:向后兼容变更先行,见部署顺序题目。

06.8.5.3-050 K8s 配置与密钥怎么注入?

一句话结论

普通配置用 ConfigMap 挂载/环境变量,密钥用 Secret 注入;不把配置与密钥打进镜像,环境差异运行期注入。

概念解释

配置与镜像解耦,同一镜像跑多环境。ConfigMap 存非敏感配置,Secret 存敏感值。注入方式:环境变量或挂载文件。应用启动读取。Secret 访问受限,不进镜像层。

原理流程

  1. 配置写入 ConfigMap/Secret。
  2. Pod 挂载为文件或环境变量。
  3. 应用启动读取。
  4. 更新后按挂载方式生效(部分需重启)。

代码或图示

ConfigMap → 非敏感配置文件/环境变量
Secret → 密钥环境变量/挂载文件

常见误区

  • 配置与密钥固化在镜像内,换环境要重打镜像。
  • Secret 明文写入镜像层或仓库。

追问

  • 配置热更新在 K8s 怎么做?答:挂载文件更新后由应用监听,环境变量注入通常需重启。
  • Secret 加密存储?答:按平台开启静态加密,访问权限受限。

06.8.5.3-051 requests 与 limits 怎么设定?

一句话结论

requests 保证调度资源基线,limits 约束上限;按压测实际内存/CPU 设定,避免 requests 过低被挤压或 limits 过高超用。

概念解释

CPU requests 影响调度与 CPU 配额,limits 限制突发;内存 limits 超限会 OOMKilled。按压测平均与峰值设定。JVM 堆与容器内存匹配。资源指标持续观察调整。limits 不是优化目标,是保护边界。

原理流程

  1. 压测测得内存/CPU 峰值。
  2. 设定 requests 基线与 limits 上限。
  3. 部署观察资源利用率。
  4. 按指标调整。

代码或图示

requests:调度基线;limits:资源上限;内存超限 OOMKill,CPU 超限限流

常见误区

  • 不压测直接照搬默认值,内存 limit 与 JVM 堆不匹配。
  • CPU limits 过低导致频繁限流,响应抖动。

追问

  • CPU limit 要不要设?答:按集群策略评估,CPU 超 limit 被限流,影响延迟。
  • 怎么看资源用满?答:资源利用率指标 + 重启/OOM 记录。

06.8.5.3-052 水平扩缩容为什么要求无状态?

一句话结论

水平扩缩实例复制副本,会话与状态外置(DB/缓存/对象存储),实例不持有本地状态,才能随负载增减副本。

概念解释

有本地会话/缓存/文件的实例不能随意销毁重建。无状态实例处理完请求即可替换。状态持久化到外部存储。扩缩容按指标(CPU/QPS/队列积压)触发。副本间共享外部状态一致性由存储层保证。

原理流程

  1. 实例不持有本地会话状态。
  2. 状态存外部存储。
  3. 负载指标触发扩缩。
  4. 新副本加入,旧副本优雅退出。

代码或图示

无状态实例 ↔ DB/缓存/对象存储(外置状态)

常见误区

  • 本地缓存/会话随副本销毁丢失。
  • 扩缩容依赖 sticky 会话,副本无法自由替换。

追问

  • 本地缓存怎么处理?答:可用但设计为可重建,失效后回源。
  • 扩缩容指标选什么?答:CPU、QPS、队列积压等饱和度指标。

06.8.5.3-053 缩容时在途请求怎么处理?

一句话结论

缩容实例先摘流,等待在途请求与消息处理完成再退出;配合优雅停机,超时后强制终止。

概念解释

缩容直接删实例会切断在途请求。编排平台先发终止信号,应用就绪转未就绪摘流,再等待处理完成。等待窗口覆盖最长请求。后台任务与消息消费者有序停止。超时兜底强制退出。

原理流程

  1. 缩容信号到达。
  2. 就绪端点摘流。
  3. 等待在途请求/消息完成。
  4. 超时强制退出。

代码或图示

摘流 → 等待在途(宽限时间)→ 关闭资源 → 退出

常见误区

  • 未摘流就退出,新请求打到终止实例。
  • 宽限时间短于最长请求,请求被切断。

追问

  • 宽限时间在哪配?答:编排平台终止宽限与应用停机超时对齐。
  • 长连接怎么处理?答:连接优雅关闭或迁移,按协议确认。

06.8.5.3-054 后台任务/定时任务在缩容时怎么办?

一句话结论

后台任务实例退出前停止领取新任务,处理完当前批次;任务调度支持实例撤离,避免重复执行与任务丢失。

概念解释

缩容杀掉后台任务实例可能中断批次。实例摘流后停止拉取新任务,完成当前工作。分布式任务调度负责重分配。幂等设计保证重复执行安全。任务心跳与撤离机制配套。

原理流程

  1. 收到停机信号。
  2. 停止领取新任务。
  3. 完成当前批次。
  4. 未完成任务由调度重分配。

代码或图示

停机 → 停止领任务 → 完成当前批次 → 任务重分配

常见误区

  • 任务被中途杀死,状态不一致。
  • 缩容后任务无人领取,积压告警。

追问

  • 任务幂等怎么保证?答:任务执行可重复不产生副作用,见 09 分册。
  • 多副本任务怎么分配?答:分布式锁/调度分片,避免重复跑。

06.8.5.3-055 CI 流水线分哪些阶段?

一句话结论

典型阶段:编译 → 静态检查/测试 → 构建镜像 → 扫描 → 部署;各阶段门禁递进,失败阻断后续。

概念解释

CI 流水线把质量关卡自动化。编译验证语法与依赖;测试跑单元/集成;静态检查规范;镜像构建与扫描;部署到环境。阶段缓存复用。门禁规则按风险递进。流水线配置即代码。

原理流程

  1. 提交触发编译。
  2. 静态检查 + 单元/集成测试。
  3. 构建制品与镜像。
  4. 扫描通过后部署。

代码或图示

编译 → 检查/测试 → 打包 → 镜像扫描 → 部署测试环境 → 人工/门禁 → 生产

常见误区

  • 测试全在生产前阶段,反馈太晚。
  • 门禁宽松,失败版本仍进入部署。

追问

  • 集成测试放哪个阶段?答:单元测试先行,集成测试在打包后 CI 阶段。
  • 流水线失败定位?答:按阶段日志与测试报告。

06.8.5.3-056 构建缓存怎么加速 CI?

一句话结论

依赖缓存、构建缓存与镜像层缓存分层复用;缓存按键隔离,失效策略明确,避免污染缓存导致诡异失败。

概念解释

CI 每次干净环境重建慢。Gradle 依赖与构建缓存复用历史结果。镜像层缓存复用未变更层。缓存键含依赖清单与分支。缓存定期清理防污染。本地构建与 CI 缓存配置一致。

原理流程

  1. 下载依赖缓存。
  2. 编译复用增量缓存。
  3. 镜像层复用未变更层。
  4. 缓存失效按清单变化。

代码或图示

Gradle 依赖缓存 → 构建缓存 → Docker 层缓存

常见误区

  • 缓存键不分分支,跨分支污染。
  • 缓存损坏不清理,构建结果不一致。

追问

  • 缓存与测试隔离冲突吗?答:构建缓存不影响测试数据隔离。
  • 缓存命中率怎么看?答:流水线各层耗时对比。

06.8.5.3-057 测试并行与门禁怎么设计?

一句话结论

测试按套件并行执行缩短反馈时间,门禁区分强制必过与可选检查;并行不破坏数据隔离,失败用例可重跑但不掩盖真实失败。

概念解释

单元测试快速全量并行,集成测试按容器/数据隔离并行。门禁:编译、核心单测、扫描阻断合并;耗时检查可异步。并行测试资源隔离。偶发失败先修稳定性,不靠重跑掩盖。

原理流程

  1. 测试分组(单元/集成/E2E)。
  2. 各组并行执行。
  3. 门禁判定必过项。
  4. 失败阻断,偶发失败标记排查。

代码或图示

门禁:编译 + 单元 + 扫描必过;集成/E2E 按阶段并行

常见误区

  • 并行测试共享数据库,互相污染。
  • 失败自动重跑通过即放过,隐藏不稳定用例。

追问

  • 测试套件太慢怎么拆?答:按模块/类型分组并行,慢集成独立阶段。
  • 门禁阈值怎么定?答:核心模块从严,遗留逐步加严。

06.8.5.3-058 制品版本号与镜像标签怎么管理?

一句话结论

制品版本号唯一可追溯(提交号/语义版本),镜像标签与版本号对应;不可变标签不覆盖,部署记录对应具体制品。

概念解释

版本号关联源码提交与构建记录。镜像标签唯一指向制品,避免 latest 漂移不可追溯。语义版本表达兼容程度。部署记录记录版本号与镜像 digest。回滚按版本号定位制品。

原理流程

  1. 构建生成版本号(提交号/语义版本)。
  2. 制品与镜像打对应标签。
  3. 部署记录版本。
  4. 回滚按标签取回制品。

代码或图示

app:1.2.3+abc1234;镜像 digest 锁定;latest 不用于生产部署

常见误区

  • 生产用 latest 标签,实际版本不可追溯。
  • 标签重复覆盖,回滚找不到当时制品。

追问

  • 语义版本与提交号怎么配合?答:发布版本用语义版本,构建追溯用提交号。
  • 镜像 digest 什么用?答:不可变摘要,锁定精确镜像。

06.8.5.3-059 多环境怎么隔离?

一句话结论

dev/test/staging/prod 环境配置、数据、权限与部署流程隔离;同套部署模板,环境差异由配置注入,禁止跨环境直连。

概念解释

环境隔离防止测试影响生产。各环境独立配置与数据,凭证分开。部署逐级晋级:测试环境验证后进 staging 再生产。权限按环境分级。配置结构一致,值不同。环境间网络访问受控。

原理流程

  1. 环境独立命名空间/资源。
  2. 配置与凭证隔离。
  3. 部署逐级晋级。
  4. 网络与权限受控。

代码或图示

dev → test → staging → prod;配置模板共享,环境值独立

常见误区

  • 测试服务直连生产数据库。
  • 各环境配置复制粘贴,结构不一致。

追问

  • staging 为什么必要?答:贴近生产拓扑做最后验证。
  • 环境配置差异怎么记录?答:配置清单 + 部署记录。

06.8.5.3-060 回滚策略怎么制定?

一句话结论

回滚基于不可变制品与向后兼容变更;代码回滚重部署旧版本,DB 变更兼容旧版本可回退;明确回滚触发条件与操作步骤。

概念解释

回滚分代码回滚与数据回滚。无兼容 DB 变更时代码回滚受 schema 阻塞。发布前评估回滚路径。回滚步骤演练,明确负责人与触发指标。制品仓库保留可回滚版本。回滚后复盘根因。

原理流程

  1. 发布前评估变更兼容性。
  2. 异常触发回滚条件。
  3. 重部署旧版本制品。
  4. 数据变更按兼容策略处理。

代码或图示

回滚:旧版本镜像重部署;DB 变更向后兼容,旧版本可读写

常见误区

  • 数据库不可逆变更先上,代码无法回滚。
  • 回滚步骤未演练,故障时操作慌乱。

追问

  • 回滚与重新发布区别?答:回滚取旧制品,重新发布是修后再发。
  • 数据回滚怎么做?答:优先兼容避免数据回滚;必须回退时按备份/迁移方案。

06.8.5.3-061 单体应用怎么划分模块?

一句话结论

单体按业务域切分模块与包,模块间通过契约接口协作;先模块内聚,边界清晰后再考虑拆服务。

概念解释

单体不是大泥球,模块按业务域划分。模块间依赖单向,契约接口隔离。共享内核抽取公共模块。模块边界对应未来服务边界。Gradle 模块强制编译隔离。先内聚再拆分,避免过早微服务化。

原理流程

  1. 识别业务域边界。
  2. 按域划模块与包。
  3. 定义模块契约接口。
  4. 架构测试守护依赖方向。

代码或图示

order 模块 / payment 模块 / user 模块 / common 模块

常见误区

  • 模块按技术层切(所有 controller 一层),业务无法拆。
  • 模块间直接共享内部实现,边界失效。

追问

  • 多模块编译慢怎么办?答:依赖最小化,见构建速度题目。
  • 模块耦合怎么判断?答:依赖方向变化频繁、共享模型过多。

06.8.5.3-062 从分层单体演进到微服务要注意什么?

一句话结论

先在单体内理清模块边界与契约,再按域拆服务;拆服务伴随数据拆分、远程通信与分布式一致性,不是简单复制包结构。

概念解释

微服务拆分把模块边界变为进程边界。每个服务独立数据存储,跨进程走远程调用。原共享表需按域拆分。分布式事务、链路、部署运维成本随之引入。拆分节奏按业务价值与团队规模。

原理流程

  1. 单体模块边界清晰。
  2. 选首个边界域拆出服务。
  3. 数据存储独立,接口契约化。
  4. 逐步迁移流量,治理分布式问题。

代码或图示

单体模块 → 服务边界 → 独立 DB → 远程契约 → 分布式治理

常见误区

  • 边界未清就拆服务,分布式下耦合依旧。
  • 多服务共享同一数据库,拆而不离。

追问

  • 什么时候不该拆?答:团队小、业务稳定、运维能力不足时保留单体。
  • 拆分后共享模型怎么办?答:通过契约 DTO 同步,不共享代码库模型。

06.8.5.3-063 DTO 怎么做版本兼容?

一句话结论

对外接口向后兼容:新增字段可选、废弃字段过渡保留、不改字段语义;版本变更在契约层管理,内部模型不受接口版本束缚。

概念解释

API 演进要照顾旧调用方。新增可选字段不破坏旧解析;字段废弃先标记再下线。字段类型与语义稳定,变更走新版本契约。请求/响应版本策略在接口层约定。兼容问题由契约测试守护。

原理流程

  1. 评估变更对调用方影响。
  2. 新增字段保持可选。
  3. 废弃字段过渡期保留。
  4. 契约测试验证兼容。

代码或图示

兼容:加可选字段;不兼容:改类型/删字段 → 新版本接口

常见误区

  • 直接改字段类型或删字段,旧调用方解析失败。
  • DTO 变更牵动内部领域模型。

追问

  • 版本号放哪?答:路径/头/参数,按团队 API 约定。
  • 废弃字段多久移除?答:按调用方迁移情况定过渡期。

06.8.5.3-064 跨服务领域事件怎么传递?

一句话结论

跨服务事实通过消息/事件流传递,事件结构作为对外契约;消费方幂等处理,生产与消费解耦,不直接同步调用对方内部。

概念解释

进程内事件跨不出服务。跨服务事件发往消息中间件,事件体是稳定契约。消费方按事件更新自身状态。事件投递可靠性与重复消费按 MQ 机制处理。事件不携带实现细节,只含事实数据。

原理流程

  1. 服务状态变更产生事件。
  2. 发布到消息通道。
  3. 消费方订阅并幂等处理。
  4. 事件契约随版本演进。

代码或图示

订单服务 → OrderConfirmed 事件 → 库存/营销服务消费

常见误区

  • 事件体暴露内部表结构,契约难演进。
  • 消费方非幂等,重复消息产生副作用。

追问

  • 事件顺序与重复怎么保证?答:见 MQ 与分布式分册。
  • 同步调用与事件怎么选?答:需要即时结果用同步,解耦后续动作用事件。

06.8.5.3-065 分布式边界处分层怎么调整?

一句话结论

跨进程边界对应适配层:对外提供契约接口,内部仍按用例/领域分层;远程通信、序列化、错误翻译在适配器层完成。

概念解释

拆服务后每个服务内部保持分层。对外接口是入站适配器,远程客户端是出站适配器。跨服务模型用契约 DTO,不共享领域模型。分布式问题(超时、重试、熔断)在出站适配器处理。内部规则不受远程机制污染。

原理流程

  1. 入站适配器接收远程请求。
  2. 调用内部用例。
  3. 出站适配器封装远程调用。
  4. 适配器做协议与错误翻译。

代码或图示

远程接口适配器 → 用例 → 领域 → 出站客户端适配器

常见误区

  • 远程重试/超时逻辑散落在业务用例。
  • 跨服务共享内部领域模型。

追问

  • 防腐层在哪?答:出站适配器把外部模型翻译为本服务领域模型。
  • 分布式事务影响分层吗?答:跨服务一致性在适配/编排层处理,见 09 分册。

06.8.5.3-066 集成测试选替身还是真实组件?

一句话结论

跨边界契约与真实协议必须用真实组件(Testcontainers);内部协作可替身;按缺陷风险选择保真度,关键路径不省真实集成验证。

概念解释

替身快但不保真,真实组件慢但抓协议/方言问题。决策:数据库 SQL、消息投递、外部 API 契约用真实容器;内部领域协作用 mock。风险高的集成点优先真实。测试策略矩阵记录各处选择。

原理流程

  1. 列出外部依赖与风险。
  2. 高风险契约用 Testcontainers。
  3. 内部协作用替身。
  4. 记录替身与真实差异。

代码或图示

真实:DB、MQ、对外 API 契约
替身:内部端口桩、假实现

常见误区

  • 关键集成全用 mock,上线暴露协议/方言问题。
  • 所有依赖都起容器,测试套件慢不可用。

追问

  • 第三方无测试环境?答:契约桩 + 沙箱,标注未覆盖风险。
  • 测试策略谁维护?答:架构/测试负责人随依赖变更更新矩阵。

06.8.5.3-067 集成测试数据清理有哪些方式?

一句话结论

按套件选择事务回滚、截断表、重建 schema 或独立容器;清理策略保证每用例干净状态,不依赖执行顺序。

概念解释

清理方式对比:事务回滚适合单用例内读写;截断表适合跨提交数据;重建 schema 最干净但慢;独立容器并行隔离。关联表清理顺序与外键约束配套。测试数据初始化脚本与清理策略对应。

原理流程

  1. 选定清理策略。
  2. 用例前准备数据集。
  3. 执行测试。
  4. 回滚/截断/重建清理。

代码或图示

回滚(未提交)/ 截断(跨提交)/ 重建 schema(重隔离)

常见误区

  • 只删主表,关联表残留。
  • 清理依赖用例执行顺序。

追问

  • 外键约束下怎么截断?答:按依赖顺序或禁用约束清理,按数据库能力确认。
  • 并行测试清理冲突?答:独立 schema/容器隔离。

06.8.5.3-068 性能测试放在哪个环节?

一句话结论

关键接口在 CI 定期做基准/压测,上线前在类生产环境验证容量;单元测试不测性能,性能基线纳入回归对比。

概念解释

性能测试分层:微基准测热点函数,压测测接口吞吐与延迟,容量测试定副本规模。CI 跑轻量基准防退化,完整压测在发布前。性能问题结合慢查询、资源指标定位。基准测试注意 JVM 预热与噪声。

原理流程

  1. 热点逻辑微基准纳入回归。
  2. 接口压测在预发环境。
  3. 记录吞吐/延迟基线。
  4. 容量评估副本数与资源。

代码或图示

微基准(热点函数)→ 压测(接口吞吐/延迟)→ 容量(副本/资源)

常见误区

  • 上线前从不压测,峰值才暴露容量不足。
  • 微基准未预热,结果噪声大不可比。

追问

  • 性能测试工具选什么?答:按技术栈选型,具体工具待确认。
  • 压测环境要等同生产吗?答:拓扑与配置尽量接近,记录差异。

06.8.5.3-069 detekt、spotless、lint 等质量门禁怎么配?

一句话结论

静态检查与格式检查在 CI 强制运行:detekt 查 Kotlin 规范/缺陷,spotless 统一格式,lint 查框架问题;违规阻断合并,规则随团队约定演进。

概念解释

静态门禁把规范问题前移到提交阶段。detekt 检查代码异味、复杂度、潜在缺陷;spotless 统一格式与换行;lint 检查框架使用问题。规则集在团队基线之上调整。本地提交前可运行同款检查。门禁不替代测试与评审。

原理流程

  1. 配置静态检查规则集。
  2. 本地/CI 运行检查。
  3. 违规阻断合并。
  4. 规则定期复盘调整。

代码或图示

detekt(静态缺陷/复杂度)+ spotless(格式)+ lint(框架检查)

常见误区

  • 规则全开后大量历史违规,门禁无法落地。
  • 检查只在 CI 跑,本地反馈慢。

追问

  • 历史代码怎么接入?答:先基线豁免新增,逐步清理存量。
  • 规则冲突怎么处理?答:团队约定优先,关闭有争议规则并记录。

06.8.5.3-070 架构守护测试在 CI 怎么落地?

一句话结论

把依赖方向、包约定规则写成测试,随单元测试在 CI 执行;违规即失败阻断合并,架构规则不靠人工评审记忆。

概念解释

架构守护测试纳入常规测试套件,编译期/测试期扫描类与模块依赖。规则库随架构演进更新。新增违规在 PR 暴露。守护测试与静态检查互补:检查结构方向,静态检查代码质量。测试运行速度需可接受。

原理流程

  1. 编写架构规则测试。
  2. 纳入 CI 测试阶段。
  3. 违规失败阻断合并。
  4. 规则随重构更新。

代码或图示

CI:编译 → 单测(含架构守护)→ 集成 → 镜像

常见误区

  • 架构测试被归入慢套件长期不跑。
  • 规则过严或过松,团队绕过门禁。

追问

  • 模块级依赖怎么测?答:Gradle 依赖声明检查 + 包扫描。
  • 守护测试失败怎么修?答:调整依赖方向或确认为规则演进。

06.8.5.3-071 耦合严重的单体怎么先拆模块?

一句话结论

先不动进程边界,在单体内按域抽模块、清共享模型与跨域调用;边界跑顺后再评估拆服务,避免把代码混乱复制到分布式。

概念解释

耦合表现:跨域直接调内部、共享可变模型、表关联混乱。步骤:识别域边界 → 抽模块与契约 → 切断跨域直调 → 抽公共内核。模块内聚后,拆服务才有清晰边界。先治理结构再分布式,降低迁移风险。

原理流程

  1. 梳理调用关系与共享数据。
  2. 按域划模块,定义接口。
  3. 跨域调用改走契约。
  4. 评审模块边界后评估拆服务。

代码或图示

现状耦合 → 模块抽取 → 契约隔离 → 边界稳定 → 服务拆分评估

常见误区

  • 边界未清就拆服务,远程调用替代了原内部耦合。
  • 抽模块时把共享模型原样复制到各模块。

追问

  • 共享表怎么办?答:先在模块间明确读写归属,拆分时再按域分表。
  • 重构怎么保证不破坏行为?答:先补特征测试,再重构。

06.8.5.3-072 错误码体系归哪一层定义?

一句话结论

领域/用例层定义业务错误类型,边界层翻译为对外错误码与 HTTP 状态;错误码是对外契约,内部不依赖错误码字符串判断逻辑。

概念解释

内部错误类型表达业务含义,对外错误码是接口契约。边界层做映射,错误码文档化。内部逻辑按错误类型分支,不解析对外错误码。新增错误类型在领域定义,边界补充码值。错误码与错误率指标分类对应。

原理流程

  1. 领域定义错误类型(sealed/枚举)。
  2. 用例返回错误结果。
  3. 边界映射错误码与状态码。
  4. 对外文档登记错误码。

代码或图示

领域:OrderNotFound / PaymentRejected
边界:404 ORDER_NOT_FOUND / 402 PAYMENT_REJECTED

常见误区

  • 内部代码用错误码字符串判断分支。
  • 错误码散落在 Controller 各自定义,重复冲突。

追问

  • 错误码要分大类吗?答:按域/类型分段,便于定位。
  • 错误信息对外暴露多少?答:对外给可读提示,内部细节走日志。

06.8.5.3-073 入参校验与领域校验怎么分工?

一句话结论

边界层做格式、类型、非空等语法校验;领域层做业务规则校验(状态、规则约束);两层都不省,校验失败分别翻译为对应错误。

概念解释

语法校验保证输入可解析,业务校验保证输入合法于规则。边界校验快速拒绝非法格式,领域校验在规则上下文内判定。校验失败信息分层返回。不要把业务规则压到注解校验,也不要在领域重复做格式解析。

原理流程

  1. 边界校验格式/必填/范围。
  2. 映射为领域命令。
  3. 领域执行业务规则校验。
  4. 失败返回对应错误。

代码或图示

边界:非空、长度、格式、枚举合法
领域:状态可操作、余额充足、规则约束

常见误区

  • 只做注解格式校验,业务规则漏到运行期。
  • 领域层重复解析原始字符串格式。

追问

  • 跨层校验规则共享吗?答:纯格式规则可共享工具,业务规则只在领域。
  • 校验失败算业务异常吗?答:格式失败边界拒绝,业务失败按结果类型处理。

06.8.5.3-074 权限检查放在哪一层?

一句话结论

认证在入口边界完成,授权(能不能做该操作)结合用例上下文校验;领域规则需要时可参与判定,但不把权限框架引入领域核心。

概念解释

认证识别身份在入口;授权判断角色/资源权限。粗粒度权限可在边界拦截,细粒度资源权限在用例加载资源后校验。领域核心不依赖权限框架。权限决策结果记录审计。跨层一致,不在多个入口重复散落。

原理流程

  1. 入口认证解析身份。
  2. 边界粗粒度权限拦截。
  3. 用例加载资源后做细粒度校验。
  4. 拒绝时返回授权错误。

代码或图示

入口认证 → 粗粒度授权(边界)→ 细粒度授权(用例/资源)

常见误区

  • 权限检查散落在各 Controller,规则不一致。
  • 领域模型直接依赖权限注解框架。

追问

  • 数据级权限(只能看自己数据)怎么做?答:用例查询带身份条件,Repository 按范围过滤。
  • 权限校验失败要审计吗?答:拒绝访问记录审计日志。

06.8.5.3-075 审计日志作为横切关注点怎么落地?

一句话结论

审计记录谁在什么时间对什么资源做了什么,通过拦截器/切面或用例显式记录;审计数据独立存储,不与调试日志混同。

概念解释

审计日志关注合规追溯:操作人、资源、动作、结果、时间。横切机制在边界/用例出口统一记录。审计内容不可被业务调试日志覆盖。敏感动作单独审计。审计记录与业务日志字段区分。

原理流程

  1. 识别需审计动作。
  2. 横切拦截或用例调用记录。
  3. 写入审计存储。
  4. 审计查询独立权限。

代码或图示

审计字段:actor, resource, action, result, time, traceId

常见误区

  • 审计记录散落在业务代码,易遗漏。
  • 审计日志与普通日志同库同级别,无法独立追溯。

追问

  • 审计用注解还是显式调用?答:通用动作横切,复杂业务语义显式记录。
  • 审计存多久?答:按合规要求定留存周期。

06.8.5.3-076 横切关注点在分层里归谁?

一句话结论

日志、指标、追踪、权限、审计、事务等横切能力由外层适配器/基础设施提供,通过拦截器或装饰器包裹用例;领域核心不实现横切逻辑。

概念解释

横切关注点贯穿多层,直接写进业务会重复污染。方案:外层装饰器/拦截器统一处理,用例只关心业务。DI 组装时包裹。横切能力可替换。领域方法保持纯业务,不直接打日志框架。

原理流程

  1. 识别横切能力。
  2. 外层实现拦截器/装饰器。
  3. 组装层包裹用例。
  4. 核心业务无横切代码。

代码或图示

拦截器(日志/指标/追踪/权限)→ 用例装饰器(事务/审计)→ 核心业务

常见误区

  • 每个用例手写日志/事务样板,重复且不一致。
  • 领域对象直接调用日志框架。

追问

  • 横切与用例编排冲突吗?答:横切处理通用动作,用例编排业务流程,职责分离。
  • 装饰器顺序怎么定?答:按调用链顺序,事务/权限/日志层级明确。

06.8.5.3-077 data class 暴露可变集合有什么问题?

一句话结论

领域对象返回内部可变集合引用,外部可绕过业务方法修改内部状态;应返回只读视图或副本,变更走明确业务方法。

概念解释

Kotlin List 默认只读,但集合内部可能是 MutableList。直接暴露内部可变集合引用,外部修改破坏封装。getter 返回只读视图或拷贝。集合字段构造后不被原地修改。封装规则保证状态变更经过业务方法。

原理流程

  1. 内部集合用可变类型持有。
  2. 对外返回只读视图/副本。
  3. 变更通过业务方法操作。
  4. 内部状态不被外部改写。

代码或图示

class Order(val items: List<OrderItem>) {
    private val _items = mutableListOf<OrderItem>()
    fun items(): List<OrderItem> = _items.toList()
}

常见误区

  • val items: MutableList 直接暴露。
  • 返回内部 list 引用,外部 add/remove 绕过校验。

追问

  • 拷贝有性能代价吗?答:大集合评估,热点路径用不可变集合封装。
  • 序列化场景怎么办?答:DTO 层单独构造,不暴露内部可变状态。

06.8.5.3-078 领域层怎么使用不可变集合?

一句话结论

领域模型优先使用只读集合类型,构造完成后不可变;需要变更时返回新集合/新实例,避免共享可变状态。

概念解释

不可变集合杜绝外部意外修改,并发推理简单。Kotlin 标准库只读接口是契约约束,配合不可变实现。状态流转产生新实例。大集合变更代价按场景权衡。领域不暴露可变集合类型签名。

原理流程

  1. 集合字段声明只读类型。
  2. 构造时填充。
  3. 变更方法返回新集合/实例。
  4. 外部无法原地修改。

代码或图示

data class Cart(val items: List<CartItem>) {
    fun add(item: CartItem): Cart = copy(items = items + item)
}

常见误区

  • 声明 List 但实际传入 MutableList 被持有引用修改。
  • 变更方法原地修改内部集合。

追问

  • 不可变集合库有必要吗?答:标准库只读满足多数场景,高性能不可变结构按需引入。
  • 聚合根内部需要可变累加怎么办?答:内部可变,对外不可见,提交后产出不可变结果。

06.8.5.3-079 协程在 Service 边界怎么组织?

一句话结论

用例/Service 暴露挂起函数或 Flow,协程边界清晰;线程模型由调度器注入,业务逻辑不直接操作线程。

概念解释

Service 作为协程边界接收调用方协程上下文。挂起函数表达异步用例。调度器通过参数注入,便于测试。阻塞操作在边界切换调度器。协程取消沿边界传播。不把线程池细节泄漏到领域。

原理流程

  1. 入口启动协程上下文。
  2. 用例挂起函数执行。
  3. 阻塞调用切换调度器。
  4. 结果/Flow 返回边界。

代码或图示

class OrderService(private val repo: OrderRepository, private val dispatcher: CoroutineDispatcher = Dispatchers.IO) {
    suspend fun getOrder(id: OrderId): Order? = withContext(dispatcher) { repo.findById(id) }
}

常见误区

  • 领域/用例内部直接 runBlocking 或自建线程池。
  • 阻塞调用留在默认调度器,阻塞事件循环。

追问

  • 调度器怎么注入?答:构造参数传入,测试替换 TestDispatcher。
  • Flow 在 Service 怎么暴露?答:流式查询返回 Flow,背压由调用方处理。

06.8.5.3-080 阻塞调用在协程里怎么切换调度器?

一句话结论

阻塞 IO/数据库调用在专用调度器上执行,用 withContext 切换;避免阻塞事件分发线程,阻塞与非阻塞代码边界明确。

概念解释

协程调度器区分 CPU 与 IO 负载。阻塞 API(同步 JDBC、旧客户端)不能跑在事件循环线程。withContext(IO) 包裹阻塞段。新异步客户端可直接挂起调用。阻塞段内不混挂起操作。

原理流程

  1. 识别阻塞调用。
  2. withContext(IO) 切换。
  3. 阻塞操作在 IO 线程执行。
  4. 返回后回到原上下文。

代码或图示

suspend fun load(id: OrderId): Order? = withContext(Dispatchers.IO) {
    blockingJdbcQuery(id)
}

常见误区

  • 阻塞调用留在主线程/事件循环,吞吐下降。
  • 整个 Service 包一层 IO,CPU 计算也跑 IO 调度器。

追问

  • 怎么判断调用是否阻塞?答:看客户端是否挂起 API,同步阻塞方法需切换。
  • 调度器线程池大小怎么定?答:按 IO 阻塞特性配置,具体参数按框架确认。

06.8.5.3-081 模块编译隔离怎么影响构建速度?

一句话结论

模块按依赖切分后可增量编译未变更模块;依赖最小化减少重编译面,公共契约稳定避免下游频繁重建。

概念解释

单模块改动全量编译慢。Gradle 模块隔离后,只重编变更模块及其下游。api 依赖最小化控制传递面。公共 API 稳定减少下游失效。构建缓存复用未变更模块。模块划分过细也有配置开销,需权衡。

原理流程

  1. 模块依赖单向最小化。
  2. 变更模块触发增量编译。
  3. 未变更模块走缓存。
  4. 下游按依赖重编。

代码或图示

改动 common → 依赖 common 的模块重编;无关模块缓存复用

常见误区

  • 模块间 api 滥用,改动一处全量重编。
  • 模块切分过碎,构建配置与依赖开销上升。

追问

  • 编译慢先查什么?答:依赖面、变更模块下游范围、缓存命中。
  • 循环依赖影响什么?答:编译失败且模块边界失效,先解环。

06.8.5.3-082 测试资源开销怎么控制?

一句话结论

按测试类型控制容器/线程/数据规模:单元测试零外部资源,集成测试复用容器,慢测试独立阶段并行;资源占用纳入 CI 容量规划。

概念解释

测试资源开销来自容器、数据库连接、线程与数据准备。控制手段:替身替代非关键依赖、容器复用、测试并行度受限、数据集精简。CI 节点资源与并行度匹配。慢测试不阻塞本地快速反馈。

原理流程

  1. 测试分层评估资源。
  2. 非关键依赖替身化。
  3. 容器复用与并行限流。
  4. CI 资源按开销规划。

代码或图示

单测:无外部资源;集成:复用容器;E2E:独立环境限量并行

常见误区

  • 每个用例新建数据库容器,CI 资源耗尽。
  • 测试并行度无限制,连接池打满偶发失败。

追问

  • 测试数据量大怎么减?答:精简最小数据集,覆盖规则而非全量业务数据。
  • 容器启动开销怎么降?答:复用 + 镜像预热,见容器复用题目。

06.8.5.3-083 镜像与 JVM/依赖版本怎么对齐?

一句话结论

镜像基础 JDK 版本、编译目标版本、依赖兼容版本三者一致;升级时整体验证,避免运行时类版本不匹配。

概念解释

编译 JDK、运行 JRE、字节码目标版本需兼容。依赖库版本同时支持编译与运行 JDK。基础镜像跟随补丁更新。版本矩阵在构建配置固化。升级 JDK 时回归测试与镜像同步。版本基线记录在项目文档。

原理流程

  1. 确定编译/运行 JDK 版本。
  2. 依赖版本兼容该 JDK。
  3. 基础镜像 JRE 对齐。
  4. 升级整体回归。

代码或图示

编译 JDK 21 / 运行 JRE 21 / 字节码 21 / 依赖兼容 21

常见误区

  • 高版本编译低版本运行,类版本错误。
  • 依赖只兼容旧 JDK,新运行时报错。

追问

  • 怎么查版本对齐?答:构建配置 + 镜像基础标签 + 依赖兼容声明。
  • 跨大版本升级注意什么?答:行为变更、移除 API、反射兼容逐项回归。

06.8.5.3-084 发布记录怎么追踪变更?

一句话结论

每次发布记录版本号、制品、变更内容、配置差异与责任人;发布记录可追溯,支撑回滚与问题定位。

概念解释

发布记录关联代码提交、制品版本、配置变更与审批。变更内容来自提交记录/变更单。环境配置差异一并记录。线上问题可按发布时间定位变更。发布记录与监控告警时间线对照。

原理流程

  1. 构建生成版本与制品。
  2. 记录变更提交与配置。
  3. 部署到环境登记版本。
  4. 问题追溯按版本与时间线。

代码或图示

发布记录:版本号 / 提交 / 制品 digest / 配置变更 / 审批 / 时间

常见误区

  • 发布无记录,故障时不知改了什么。
  • 配置变更未登记,与代码发布脱节。

追问

  • 变更记录谁生成?答:CI 自动关联提交,人工补充业务变更说明。
  • 回滚记录要留吗?答:回滚作为变更事件记录并复盘。

06.8.5.3-085 故障复盘怎么回流测试用例?

一句话结论

复盘把根因转化为回归测试用例与监控/配置改进;同类问题在下次变更前被测试或告警拦截,不重复踩坑。

概念解释

线上故障修复后,根因应沉淀为:单元/集成测试覆盖场景、监控指标与告警、文档约定。复盘行动项跟踪落地。测试用例复现故障场景。遗漏的边界补入测试矩阵。回流完成后关闭行动项。

原理流程

  1. 复盘定位根因与触发条件。
  2. 编写复现测试用例。
  3. 补监控/告警/文档。
  4. 跟踪行动项闭环。

代码或图示

故障 → 根因 → 回归测试 + 监控 + 规范 → 行动项闭环

常见误区

  • 只修代码不补测试,同类问题再发。
  • 复盘行动项无人跟踪,沉淀失效。

追问

  • 测试复现不了怎么办?答:记录触发条件与待验证场景,环境具备后补测。
  • 监控补什么?答:对应故障指标与告警阈值。

06.8.5.3-086 本篇版本基线对应哪些工具版本?

一句话结论

基线:Gradle 8.x、JDK 21、Testcontainers 1.x、Kotlin 2.x;K8s 与编排平台版本、镜像基础发行版版本号待确认,按项目实际环境核对。

概念解释

版本基线统一描述构建、运行时与测试工具。Gradle 8.x 构建脚本与缓存行为;JDK 21 编译运行;Testcontainers 1.x 集成测试容器。K8s 版本按集群实际确认。具体小版本以依赖清单与集群版本为准,不确定标待确认。

原理流程

  1. 核对构建文件与集群版本。
  2. 按基线描述工具行为。
  3. 版本敏感 API 标注待确认。
  4. 升级回归构建与部署。

代码或图示

基线:Gradle 8.x / JDK 21 / Kotlin 2.x / Testcontainers 1.x;K8s 版本待确认

常见误区

  • 引用旧版本 Gradle/JDK 行为当作当前约定。
  • 镜像版本与运行 JDK 不对齐。

追问

  • 怎么查集群版本?答:集群 API 版本信息,由部署环境确认。
  • 基线不一致时以什么为准?答:项目实际依赖与环境版本,文档标注差异。

06.8.5.3-087 待确认:Jib 与分层 jar 的插件坐标和配置是什么?

一句话结论

Jib Gradle 插件坐标、分层 jar 打包配置与启动脚本需对照当前框架版本官方文档确认(待确认),不在题库中编造插件名与参数。

概念解释

容器构建有 Dockerfile 与 Jib 两条路线。Jib 插件按构建工具不同坐标不同;分层 jar 由框架打包插件生成。分层配置与镜像拷贝步骤对应。引入前查官方示例工程验证。

原理流程

  1. 查构建工具对应的 Jib 插件文档。
  2. 确认分层 jar 打包配置。
  3. 最小镜像构建验证。
  4. 记录项目实际坐标。

代码或图示

待确认:Jib 插件 artifact、分层 jar 配置项、分层启动命令

常见误区

  • 照搬旧版插件写法,配置项已变更。
  • 分层结构与 Dockerfile 拷贝路径不匹配。

追问

  • 验证点有哪些?答:镜像生成、依赖层缓存命中、容器内启动成功。
  • 两条路线能混用吗?答:按团队统一一条,避免构建链割裂。

06.8.5.3-088 场景题:新服务后端骨架怎么设计?

一句话结论

按分层与模块搭骨架:配置与 DI 装配、Controller/用例/领域/Repository 分层、可观测性接入、测试与 CI 基线;先打通请求到存储主链路再补业务。

概念解释

新服务骨架落地顺序:工程模块与构建 → 配置校验 → 分层代码骨架 → 数据访问 → 可观测性 → 测试基线 → 容器化与 CI。主链路贯通后再填业务规则。架构边界在骨架期定型,后续少返工。

原理流程

  1. Gradle 模块与依赖基线。
  2. 配置对象与 DI 组装。
  3. 分层骨架与示例用例。
  4. 测试、镜像、CI 与探针接入。

代码或图示

模块/构建 → 配置/DI → 分层骨架 → 数据访问 → 可观测 → 测试/CI/镜像

常见误区

  • 先写业务再补分层,结构事后难调整。
  • 骨架缺测试与部署流水线,上线前仓促补齐。

追问

  • 骨架模板从哪来?答:团队内部标准工程模板,对齐分层与规范。
  • 第一版要包含哪些横切?答:日志 traceId、健康端点、配置校验、基础指标。

06.8.5.3-089 场景题:集成测试慢怎么优化?

一句话结论

先测量耗时分布,再按瓶颈优化:容器复用、并行隔离、替身非关键依赖、精简数据集;优化后保持测试保真度,不为速度砍掉真实集成验证。

概念解释

慢的来源:容器启动、数据准备、串行执行、全量用例。测量各阶段耗时。手段:容器复用、并行分组、非关键依赖替身、精简数据、慢测试独立阶段。优化前后对比时长与稳定性。

原理流程

  1. 统计测试各阶段耗时。
  2. 定位最大瓶颈(容器/数据/串行)。
  3. 对应优化(复用/并行/替身/精简)。
  4. 回归验证稳定性与覆盖。

代码或图示

耗时测量 → 瓶颈定位 → 复用/并行/替身/精简 → 稳定性回归

常见误区

  • 直接把集成测试改全 mock,保真度丢失。
  • 并行不加隔离,偶发失败增多。

追问

  • 容器启动慢优先优化什么?答:复用级别与镜像预热。
  • 测试数据准备慢?答:工厂/脚本批量初始化,避免逐条构造。

06.8.5.3-090 场景题:实例频繁重启怎么排查?

一句话结论

先区分重启原因:OOMKilled、存活探针失败、崩溃退出或手动删除;按退出码、事件日志与资源指标定位根因。

概念解释

重启来源:内存超限被杀、liveness 失败、未捕获异常退出、部署/缩容。查容器退出码、编排事件、应用日志与资源指标。OOM 看堆与堆外;探针失败看依赖与响应;崩溃看堆栈。定位后对应修复配置或代码。

原理流程

  1. 查重启类型与退出码。
  2. 看编排事件与探针记录。
  3. 分析资源指标与应用日志。
  4. 定位 OOM/探针/崩溃根因。

代码或图示

频繁重启 → 退出码/事件 → 资源指标/日志 → OOM / 探针 / 崩溃 → 修复

常见误区

  • 只看应用日志,忽略被 OOMKill 的容器事件。
  • 探针失败盲目放宽阈值,掩盖真实依赖故障。

追问

  • 内存超限怎么进一步查?答:堆转储/堆外指标,见 JVM 内存题目。
  • 存活探针误判怎么调?答:区分存活与就绪,检查阈值与依赖。

06.8.5.3-091 场景题:单体模块耦合怎么拆分落地?

一句话结论

从最独立的业务域入手:补特征测试、抽模块契约、切断跨域直调、数据归属明确;逐步迁移,每步可回归,不一次性大重构。

概念解释

拆分步骤:选低耦合域 → 补回归测试 → 抽模块与接口 → 跨域调用改契约 → 数据读写归属梳理。小步提交,每步可构建测试。共享模型先稳定边界再复制。拆分中发现新耦合点再治理。

原理流程

  1. 选边界清晰的域。
  2. 补特征测试保护行为。
  3. 抽模块契约接口。
  4. 切断直调,梳理数据归属,逐步迁移。

代码或图示

选域 → 测试保护 → 抽契约 → 断直调 → 数据归属 → 回归验证

常见误区

  • 一次性大规模重构,难以回归。
  • 模块抽出但仍共享可变模型与表,耦合未解除。

追问

  • 拆分中途怎么保证不影响线上?答:小步发布,特征测试守护行为。
  • 跨域事务怎么过渡?答:单体内先理清事务边界,分布式方案见 09 分册。

06.8.5.3-092 依赖版本怎么统一管理?

一句话结论

用版本目录/BOM 集中管理依赖版本,模块引用不带版本号;升级统一评审,避免各模块版本不一致冲突。

概念解释

散落版本号导致依赖冲突与升级困难。Gradle 版本目录集中声明依赖与版本,BOM 对齐兼容集合。模块只引用坐标。新增依赖登记到目录。升级按 BOM 版本统一评估。冲突依赖在构建报告中检查。

原理流程

  1. 集中声明依赖版本目录/BOM。
  2. 模块引用坐标不带版本。
  3. 升级统一调整目录。
  4. 构建报告检查冲突。

代码或图示

libs.versions.toml 集中版本 → 模块 implementation libs.xxx

常见误区

  • 各模块硬编码版本,同一库多版本冲突。
  • 升级只改一处,遗漏传递依赖。

追问

  • 依赖冲突怎么查?答:构建依赖树/报告定位冲突版本。
  • BOM 与版本目录区别?答:BOM 对齐兼容版本集合,目录统一项目内声明。

06.8.5.3-093 服务启动时间怎么优化?

一句话结论

启动慢先定位耗时阶段(类加载、Bean 初始化、外部连接、迁移),按阶段优化;冷启动场景与长驻服务优化目标不同。

概念解释

启动耗时构成:框架初始化、依赖装配、外部连接建立、数据迁移、预热。测量各阶段耗时。延迟初始化非核心 bean,并行连接初始化。冷启动场景关注快速就绪,长驻服务可接受一次性预热。启动探针覆盖慢启动窗口。

原理流程

  1. 测量各启动阶段耗时。
  2. 定位瓶颈阶段。
  3. 延迟初始化/并行化/减依赖。
  4. 启动探针配合就绪。

代码或图示

启动耗时:框架初始化 → Bean 装配 → 外部连接 → 迁移 → 就绪

常见误区

  • 不测量盲目优化,改动不命中瓶颈。
  • 非核心组件阻塞启动,就绪延迟。

追问

  • 数据库迁移算启动时间吗?答:迁移可独立步骤,避免阻塞服务就绪。
  • 冷启动敏感场景?答:评估 AOT/原生镜像路线,见 DI 与 AOT 题目。

06.8.5.3-094 长驻 JVM 服务要不要预热?

一句话结论

长驻服务靠运行期 JIT 编译与 JVM 自适应优化,就绪后初期性能可能波动;必要时做预热请求或预留热身窗口,观测稳定后再接全量流量。

概念解释

JVM 解释执行起步,JIT 逐步编译热点代码。长驻服务稳态性能优于启动瞬间。预热请求触发热点编译。新实例就绪后可观察一段时间再全量。预热不改变算法瓶颈,只抹平启动抖动。

原理流程

  1. 实例启动完成。
  2. 预热请求/热身窗口。
  3. JIT 编译热点。
  4. 指标稳定后全量接流。

代码或图示

启动 → 预热/热身 → JIT 稳定 → 全量流量

常见误区

  • 用启动后瞬时延迟判断性能瓶颈。
  • 依赖预热掩盖代码层面热点问题。

追问

  • 预热怎么做?答:演练请求或压测小流量,按业务场景构造。
  • 长驻服务还看启动时间吗?答:影响发布与弹性扩容速度,仍需关注。

06.8.5.3-095 容器内日志配置放在哪里?

一句话结论

日志配置随镜像或挂载配置提供,输出标准流;不在容器内写持久日志文件,配置按环境通过 profile/挂载区分。

概念解释

日志配置(级别、格式、编码器)打包进镜像或挂载配置文件。容器形态输出 stdout/stderr,留存由采集侧管理。级别按环境 profile 区分。配置变更随镜像发布或挂载更新。应用内不依赖本地日志目录。

原理流程

  1. 日志配置打入镜像默认值。
  2. 环境差异由 profile/挂载覆盖。
  3. 输出标准流。
  4. 采集侧留存。

代码或图示

logback 配置(镜像内/挂载)→ stdout → 节点采集

常见误区

  • 容器内写日志文件并依赖本地留存。
  • 日志路径写死在容器临时目录,重启丢失。

追问

  • 日志配置能热更新吗?答:按日志框架能力,容器内通常重启或重载配置。
  • 多实例配置一致吗?答:同一镜像配置一致,环境级别差异外部注入。

06.8.5.3-096 镜像产物怎么保持整洁?

一句话结论

镜像只包含运行所需产物与运行时依赖,排除源码、测试资源、文档与构建中间文件;构建产物清单明确,减少体积与攻击面。

概念解释

打包常带入测试类、配置样例、源码资源。分层打包分离产物与依赖。镜像内只留运行必需。构建脚本排除无关文件。镜像扫描检查文件清单。产物整洁也便于安全审计。

原理流程

  1. 明确运行所需文件清单。
  2. 打包排除测试/源码/文档。
  3. 分层拷贝产物。
  4. 检查镜像文件清单。

代码或图示

镜像内:运行时 + 应用 jar + 必要配置
排除:源码、测试资源、构建缓存、文档

常见误区

  • fat jar 内含测试类与开发配置。
  • 构建中间产物混入运行镜像。

追问

  • 配置文件要进镜像吗?答:默认配置可进,环境差异外部注入。
  • 怎么查镜像内容?答:列出镜像文件系统与产物清单。

06.8.5.3-097 部署清单在不同环境有什么差异?

一句话结论

部署模板共享,环境差异只体现在副本数、资源、配置与凭证;清单按环境参数化,禁止为环境复制整套独立配置。

概念解释

多环境部署易出现模板漂移。共享基础部署模板,环境覆盖参数:副本数、资源 limit、配置引用、镜像标签、域名。环境差异记录在配置清单。模板变更同步所有环境。参数校验防止漏配。

原理流程

  1. 定义通用部署模板。
  2. 环境参数覆盖差异项。
  3. 配置/凭证按环境注入。
  4. 清单记录环境差异。

代码或图示

模板:副本/资源/探针/挂载;环境参数:副本数、limit、配置引用、镜像标签

常见误区

  • 各环境手写部署清单,结构漂移。
  • 生产配置复制测试值,未区分凭证与规模。

追问

  • 模板参数怎么校验?答:部署前校验必填与范围,见配置校验题目。
  • 环境差异怎么审计?答:部署记录与配置版本对照。

06.8.5.3-098 蓝绿部署与金丝雀发布怎么选?

一句话结论

蓝绿用两套环境整体切换,回滚快但资源翻倍;金丝雀按流量比例逐步放量,风险暴露慢但资源省。按变更风险与回滚要求选择。

概念解释

蓝绿:新旧版本同时运行,流量整体切到绿版,异常切回蓝版。金丝雀:小比例流量到新版本,逐步观察放量。蓝绿适合需快速整体回滚;金丝雀适合渐进验证。两者都依赖探针与指标对比。发布策略与部署平台能力配套。

原理流程

  1. 评估变更风险与回滚要求。
  2. 选蓝绿或金丝雀。
  3. 部署新版本并接部分流量。
  4. 指标对比后全量或回滚。

代码或图示

蓝绿:旧环境 ↔ 新环境,整体切换
金丝雀:新版本 5% → 50% → 100%

常见误区

  • 金丝雀无指标对比,放量靠人工感觉。
  • 蓝绿两套环境数据/连接未隔离验证。

追问

  • 数据库变更兼容两种策略吗?答:变更需向后兼容,见部署顺序题目。
  • 资源成本怎么权衡?答:蓝绿双倍常驻,金丝雀增量副本。

06.8.5.3-099 数据库变更与应用部署顺序怎么安排?

一句话结论

遵循向后兼容:先上线兼容旧版本的数据库变更,再部署应用;表结构/数据迁移不破坏旧版本读写,保证回滚路径可用。

概念解释

应用与 DB 变更顺序不当导致启动失败或数据不一致。兼容扩展:先加列/表(可空/默认),应用双写/迁移,再清理旧结构。破坏性变更(删列、改类型)放在应用全部升级后。迁移脚本可回滚或兼容旧版本。顺序纳入发布清单。

原理流程

  1. 评估变更兼容性。
  2. 先上兼容 DB 变更。
  3. 部署应用读写新结构。
  4. 确认稳定后清理旧结构。

代码或图示

扩展(加列/表)→ 应用迁移 → 收缩(删旧列);全程旧版本可读写

常见误区

  • 先删列/改类型,旧应用启动报错无法回滚。
  • 大表迁移锁表阻塞线上,未评估迁移策略。

追问

  • 大表 DDL 怎么做?答:按数据库在线变更方案评估,见 05 分册。
  • 迁移脚本版本怎么管理?答:迁移工具版本化执行,见 Exposed 迁移题目。

06.8.5.3-100 场景题:服务从骨架到上线要过哪些 checklist?

一句话结论

上线前清单:分层与模块边界、配置校验与 Secret、测试分层与门禁、可观测性三件套、容器镜像与探针、优雅停机、部署回滚与兼容变更;逐项验证可观测、可回滚、可扩缩。

概念解释

综合清单覆盖工程质量与运行保障。架构:分层、契约、守护测试。配置:类型安全、校验、脱敏、环境隔离。测试:单元/集成/契约通过。运行:日志指标追踪、探针、优雅停机、资源配置。发布:镜像、版本、灰度、回滚、DB 兼容。逐项核对留记录。

原理流程

  1. 架构与代码门禁通过。
  2. 配置与凭证检查。
  3. 测试分层与报告。
  4. 可观测、探针、停机、部署与回滚验证。

代码或图示

架构/测试 → 配置/Secret → 可观测 → 探针/停机 → 镜像/部署/回滚/DB 兼容

常见误区

  • 功能完成即上线,缺探针、优雅停机与回滚方案。
  • 上线清单无记录,问题时无法核对。

追问

  • 最小上线基线是什么?答:主链路测试通过、错误日志带 traceId、健康探针、可回滚版本。
  • 上线后补什么?答:按复盘补充监控、测试与文档。

参考来源

待整理清单

  • [ ] 核对 Gradle 8.x、JDK 21、Kotlin 2.x、Testcontainers 1.x 在项目中的实际小版本
  • [ ] 确认 Jib 插件坐标、分层 jar 打包配置与分层启动命令
  • [ ] 核实架构守护测试库(ArchUnit JVM 等)在 Kotlin 项目中的坐标与 API
  • [ ] 确认 K8s 集群基线版本号与探针/资源配置模板
  • [ ] 整理 detekt/spotless/lint 规则集与 CI 门禁配置示例
  • [ ] 待确认:协程调度器注入、阻塞切换与测试调度器的具体集成方式