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

06.8.1.1 Ktor 架构、路由与管道

所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.8 Kotlin 后端 / 06.8.1 Ktor 框架

本节要解决的问题

  • Ktor 3.x 的 Engine、Application、Pipeline、Plugin 各层职责如何划分,一次请求在管道里经过哪些阶段?
  • 路由树如何组织,路径参数、通配符、匹配优先级与 404/405 行为如何确定?
  • 插件安装顺序、请求状态共享、异常处理、请求体读取与限流在管道层如何落地;Ktor 3 与 2.x 在上下文和调度上有哪些差异。

版本前提:Ktor 3.x、Kotlin 2.x、协程;涉及具体 API 名称与行为差异处标注「待确认」并给出验证点。

06.8.1.1-001 Ktor 3.x 的整体架构分哪几层?

一句话结论

自底向上分为引擎层(ApplicationEngine)、应用层(Application)、管道层(Pipeline)、路由与插件层,业务 Handler 运行在 ApplicationCall 上下文内,各层通过协程与管道串联。

概念解释

引擎负责网络连接与协议解析,把原始请求交给 Application;Application 持有环境、配置、插件注册表与路由;Pipeline 是请求与响应的拦截执行链;Plugin 在管道各阶段挂载横切能力;Handler 只关心当前请求与响应。

原理流程

  1. 引擎接收 HTTP 请求,构造 ApplicationCall 进入应用管道。
  2. 管道依次经过前置阶段、插件阶段、路由匹配阶段、处理器执行、响应写出阶段。
  3. 插件在安装时把拦截逻辑注册到对应管道阶段。
  4. 路由匹配成功后调用 Handler,结果经管道回写响应。

代码或图示

引擎 Netty/CIO/Jetty
  -> ApplicationEngine 管道
    -> Application(环境/配置/插件/路由)
      -> Routing 路由树
        -> Handler(ApplicationCall)

常见误区

  • 把插件当成独立服务容器:插件只是管道拦截能力,不单独运行。
  • 认为 Handler 直接绑定 socket:Handler 不接触网络层,只处理 Call。

追问

  • 哪一层可以替换?答:引擎可替换,应用与管道结构不变。
  • 应用层状态在进程内可见吗?答:Application 单例在整个进程生命周期内可见。

06.8.1.1-002 Application 对象的生命周期与职责是什么?

一句话结论

Application 是单个服务实例的根对象,启动时创建、关闭时销毁,持有环境配置、已安装插件、路由表与属性表,是请求级 Call 之外的进程级上下文。

概念解释

Application 对应一个由引擎加载的模块实例;call.application 可在 Handler 中访问它。它保存 attributes(进程级共享状态)、日志、配置与插件实例,不保存单个请求的数据。

原理流程

  1. 引擎根据配置加载模块函数,创建 Application 实例。
  2. 模块函数内 install 插件、注册路由,配置写入 Application。
  3. 启动完成后 Application 对外提供请求处理能力。
  4. 服务关闭时触发停机回调,释放 Application 持有的资源。

代码或图示

embeddedServer(Netty, port = 8080) {
    // this: Application
    install(Routing) { /* ... */ }
}

常见误区

  • 在 Application 上放请求级可变状态:多请求并发互相覆盖。
  • 把 Application 当作每次请求新建对象:它是进程级单例。

追问

  • 进程级共享对象放哪里?答:application.attributes 或构造时注入的依赖容器。
  • 多个模块函数会产生几个 Application?答:一次引擎启动通常一个 Application,多模块在同一实例内装配。

06.8.1.1-003 ApplicationEngine 与 Application 的关系是什么?

一句话结论

ApplicationEngine 是网络运行时适配器,负责绑定端口、接收连接、调度请求;Application 是应用逻辑容器,引擎把解析后的 Call 交给应用管道执行,二者通过引擎工厂解耦。

概念解释

同一套 Application 代码可以跑在 Netty、CIO、Jetty 等不同引擎上;引擎实现 ApplicationEngine 接口,向应用提供 pipeline 与启动/停机控制。引擎决定线程模型与连接管理,应用不感知底层 socket。

原理流程

  1. embeddedServer(Netty, ...) 传入引擎工厂,工厂创建引擎实例。
  2. 引擎加载模块构建 Application,并把请求管道接到引擎事件循环。
  3. 请求到达时引擎构造 Call,调用应用管道执行。
  4. 引擎负责优雅停机与连接释放。

代码或图示

val engine: ApplicationEngine = embeddedServer(Netty, port = 8080) {
    routing { get("/") { call.respondText("ok") } }
}
engine.start(wait = true)

常见误区

  • 直接拿引擎对象写业务路由:业务应在模块函数内配置。
  • 换引擎要改业务代码:接口契约一致,通常只换工厂参数。

追问

  • 引擎在哪里启动端口?答:引擎实例的 start 方法绑定监听。
  • 能否在测试里替换引擎?答:可以,测试用专用引擎或测试 Application 构造器。

06.8.1.1-004 Pipeline 在 Ktor 架构中处于什么位置?

一句话结论

Pipeline 是 Ktor 的执行骨架:请求从进入到响应写出的每一步都是管道中的阶段,拦截器与插件挂在阶段上,路由处理器是管道末端的目标节点。

概念解释

Pipeline 由有序阶段(Phase)和挂在阶段上的拦截器组成;上一个拦截器可决定是否继续执行下一个。应用管道、路由管道、插件管道各自独立但串联执行。理解管道是排查认证失效、响应被改写、异常漏处理等问题的关键。

原理流程

  1. 请求进入管道,按阶段顺序执行已注册拦截器。
  2. 拦截器调用 proceed 进入下一个节点;不调用即短路。
  3. 到达路由管道后匹配处理器执行业务逻辑。
  4. 响应沿管道反向回写,监控阶段记录结果状态。

代码或图示

intercept(ApplicationCallPipeline.Plugins) {
    // 前置处理
    proceed()
    // 后置处理(proceed 返回后执行)
}

常见误区

  • 认为拦截器只是洋葱模型的固定两层:Ktor 是多阶段有序管道。
  • 忘记调用 proceed 导致后续处理器不执行:请求被挂起或短路。

追问

  • 管道能否动态加节点?答:插件安装阶段注册,运行期通常不改结构。
  • 失败在哪个阶段被捕获?答:异常沿管道向上传播,由 StatusPages 或监控阶段处理。

06.8.1.1-005 Plugin 在分层模型里扮演什么角色?

一句话结论

Plugin 是可复用的管道装配单元:通过 install 把一组拦截器、配置与属性挂到 Application 上,横切能力(认证、序列化、压缩、CORS)都以插件形式提供。

概念解释

Ktor 官方插件与自定义插件遵循同一套安装机制:插件定义构造逻辑,install 时读取配置闭包并把行为接入管道。插件本身不直接处理业务请求,而是为管道补充阶段行为。

原理流程

  1. 插件定义暴露一个 Plugin 描述符与配置对象。
  2. install(XxxPlugin) { /* 配置 */ } 时调用插件安装器。
  3. 安装器在管道对应阶段注册拦截器,必要时写入 attributes。
  4. 请求经过相应阶段时触发插件逻辑。

代码或图示

install(ContentNegotiation) {
    // 配置序列化转换器
}

常见误区

  • 把插件当框架启动必需组件:多数插件按需安装。
  • 在 Handler 里手动复制插件已做的横切逻辑:重复且易遗漏分支。

追问

  • 插件状态存哪里?答:插件安装时构造,进程级;请求级数据放 Call 属性。
  • 插件能访问路由表吗?答:安装阶段可访问 Application,能力边界以插件 API 为准。

06.8.1.1-006 ApplicationEnvironment 包含哪些配置?

一句话结论

ApplicationEnvironment 封装服务运行环境:配置源(命令行、配置文件、环境变量)、类加载器、日志与开发模式标识,模块函数可通过 application.environment 读取。

概念解释

环境把外部配置与应用对象解耦;配置项按 key 读取,区分开发与生产。引擎启动参数、配置文件路径在环境创建时传入,应用代码只通过配置 API 取值,不直接读系统属性。

原理流程

  1. 启动入口构造环境配置,加载配置源。
  2. Application 持有环境实例并暴露给插件与模块。
  3. 业务代码按 key 读取配置,缺失时给默认值。
  4. 开发模式、日志级别等环境标识影响插件行为。

代码或图示

val port: String? = application.environment.config.propertyOrNull("app.port")?.getString()

常见误区

  • 在业务代码里直接读 System.getenv 绕过配置抽象:难以测试与替换。
  • 把敏感配置写进默认配置文件:应走环境变量或部署密钥管理。

追问

  • 配置文件格式?答:Ktor 常用 HOCON 风格配置,具体格式以启动器支持为准。
  • 多环境配置怎么切?答:按环境选择配置源或 profile,代码读同一套 key。

06.8.1.1-007 Ktor 服务的启动入口通常怎么写?

一句话结论

最常见入口是 embeddedServer(引擎, 端口) { 模块配置 }.start(wait = true):闭包内完成插件安装与路由注册,start 阻塞等待服务停机。

概念解释

启动入口把引擎工厂、端口主机与模块函数组合在一起;模块函数也可独立定义为 fun Application.module(),便于测试与多入口复用。wait = true 让主线程挂起直到引擎停止。

原理流程

  1. 调用 embeddedServer,选定引擎工厂与监听参数。
  2. 闭包或模块函数装配 Application。
  3. start 绑定端口、注册停机钩子。
  4. wait 为真时阻塞主线程,进程随引擎结束退出。

代码或图示

fun Application.module() {
    routing { get("/") { call.respondText("ok") } }
}

fun main() {
    embeddedServer(Netty, port = 8080, module = Application::module).start(wait = true)
}

常见误区

  • 忘记 start:配置完成但端口未监听。
  • wait = false 后主线程直接退出:引擎随进程结束被销毁。

追问

  • 模块函数有什么签名要求?答:Application 扩展函数,无参或带配置参数,具体以启动器 API 为准。
  • 多入口如何复用?答:公共装配抽到公共模块函数,入口只选引擎与端口。

06.8.1.1-008 embeddedServer 与引擎工厂是什么关系?

一句话结论

embeddedServer 是启动辅助函数:接收引擎工厂(EngineFactory)、连接参数与模块,由工厂创建引擎实例;工厂负责具体引擎的实例化与默认配置。

概念解释

工厂模式让业务代码只引用工厂对象(如 Netty、CIO),不直接 new 引擎;不同工厂实现同一创建契约。除 embeddedServer 外,也可通过 ApplicationEngineFactory 自定义引擎参数。

原理流程

  1. 调用方把工厂与连接配置传入 embeddedServer。
  2. 工厂根据配置创建引擎,注入模块装配出的 Application。
  3. embeddedServer 返回已配置但未启动的引擎实例。
  4. 调用 start 进入监听状态。

代码或图示

embeddedServer(CIO, port = 8080) { /* module */ }
//           ^^^^ 引擎工厂

常见误区

  • 以为工厂决定路由能力:路由能力由应用层提供,工厂只决定运行时。
  • 直接构造引擎类绕过工厂:丢失默认装配与可移植性。

追问

  • 引擎参数在哪里调?答:工厂扩展参数或启动配置,如线程数、连接限制,以各引擎 API 为准。
  • 能否同时起多个引擎?答:可在同一进程内启动多个引擎实例,端口各不相同。

06.8.1.1-009 Netty、CIO、Jetty 引擎有什么差异,如何选型?

一句话结论

Netty 基于成熟异步网络框架,性能与生态成熟;CIO 是 Ktor 自研纯协程引擎,依赖轻量;Jetty 面向嵌入式 servlet 兼容场景;选型看性能基准、依赖体积与团队熟悉度,三者 API 契约一致。

概念解释

引擎只影响连接管理、线程模型与依赖,业务代码不感知。CIO 以协程事件循环为核心;Netty 用自己的事件循环与池化能力;Jetty 集成传统 Java Web 运行时。生产选型应以压测结果为准,不凭印象下结论。

原理流程

  1. 按部署形态与依赖约束列出候选引擎。
  2. 在目标并发与报文大小下做基准压测。
  3. 对比吞吐、延迟、内存与依赖体积。
  4. 选定工厂后业务代码保持不变。

代码或图示

embeddedServer(Netty, port = 8080) { /* ... */ }
embeddedServer(CIO, port = 8080) { /* ... */ }
embeddedServer(Jetty, port = 8080) { /* ... */ }

常见误区

  • 认为某引擎天然快一个数量级:实际差异受业务阻塞度与报文形态影响。
  • 引擎切换后不回归测试:线程模型差异可能暴露阻塞调用问题。

追问

  • 哪个引擎默认依赖最轻?答:CIO 不绑定 Netty 依赖,但成熟度需按版本评估。
  • 待确认:各引擎在 Ktor 3 中的维护状态与默认线程参数,需查官方引擎文档核对。

06.8.1.1-010 ApplicationCall 是什么,承载哪些状态?

一句话结论

ApplicationCall 是单次请求的上下文对象:持有请求、响应、属性表、应用引用与管道状态,Handler 通过它读取入参、写出响应,请求结束即丢弃。

概念解释

Call 是请求级可变上下文,生命周期严格绑定一次请求;不同请求的 Call 互不共享。它聚合接收(请求体、参数、头)与响应(状态码、头、内容)能力,并携带 attributes 供管道节点间传值。

原理流程

  1. 引擎构造 Call,放入管道起始阶段。
  2. 各插件与拦截器在 Call 上读取或写入属性。
  3. Handler 通过 Call 取参数、读取请求体、调用 respond 写出。
  4. 响应提交后 Call 进入收尾,请求结束后不可再用。

代码或图示

get("/users/{id}") {
    val id = call.parameters["id"]
    call.respondText("user $id")
}

常见误区

  • 把 Call 引用存到全局集合:请求结束后引用悬垂,且并发串数据。
  • 请求结束后再写响应:响应已提交,写出被忽略或报错。

追问

  • Call 之间怎么传值?答:call.attributes 请求级,application.attributes 进程级。
  • Call 是否线程安全?答:同一请求内由协程串行推进,不要跨请求共享。

06.8.1.1-011 Ktor 3 请求处理的协程调度模型大致如何?

一句话结论

每个请求在独立协程中处理,挂起点等待 IO 时不占用阻塞线程;引擎把连接事件提交到协程调度,业务 Handler 是 suspend 函数;阻塞调用仍会占住所在线程,必须避免。

概念解释

协程模型让单线程事件循环也能支撑大量并发连接:等待数据库、远程调用时挂起释放线程。Handler 内可直接调用挂起函数;同步阻塞代码(老式 JDBC、阻塞 IO)会抵消协程收益,应包裹在合适的调度器上或改用异步客户端。

原理流程

  1. 引擎接收连接,为请求启动处理协程。
  2. 协程进入管道与 Handler,遇到挂起点让出线程。
  3. IO 完成后调度回原协程继续推进。
  4. 请求结束协程收尾释放资源。

代码或图示

get("/users") {
    // 异步等待数据访问,挂起期间不占线程
    val users = userRepository.findAll().await()
    call.respond(users)
}

常见误区

  • 在 Handler 里跑阻塞同步调用:线程被占满,并发能力骤降。
  • 以为协程自动把阻塞代码变非阻塞:阻塞线程不会被挂起机制释放。

追问

  • 阻塞调用怎么收口?答:切换到专用调度器执行,或替换为异步客户端;不要在事件循环线程上跑。
  • 待确认:各引擎默认协程 Dispatcher 绑定与线程数,查引擎文档核对。

06.8.1.1-012 Ktor 3 相比 2.x 在上下文与调度上有哪些变化?

一句话结论

Ktor 3 围绕 Kotlin 2.x 与协程持续收敛上下文模型:请求处理协程化程度更高,部分旧的阻塞式回调与弃用 API 被清理;具体类名与调度器差异需以 3.x 迁移文档核对,不确定处标「待确认」。

概念解释

大版本升级常伴随上下文传播、Dispatcher 绑定与弃用 API 移除。面试时能说出「请求协程化、旧同步回调收敛、迁移需对照官方 changelog」即可,不应编造被删除类的精确清单。

原理流程

  1. 对照 2.x 与 3.x 迁移指南梳理编译告警与弃用 API。
  2. 验证请求协程上下文、调度器绑定与阻塞调用行为。
  3. 修复移除的 API 引用,补充压测观察线程模型变化。

代码或图示

迁移核对项:
- 弃用/移除的启动器与插件 API
- Call 上下文访问方式
- 引擎线程模型与阻塞调用约束

常见误区

  • 凭记忆声称某 API 在 3.x 必删:未核对文档前应标待确认。
  • 只看编译通过就认为调度行为一致:阻塞与上下文传播需运行验证。

追问

  • 待确认验证点:Ktor 3 各引擎默认 Dispatcher 绑定策略,查官方文档与迁移说明确认。
  • 升级后优先观察什么?答:线程占用、阻塞点告警、请求取消行为。

06.8.1.1-013 启动参数 wait 的作用是什么?

一句话结论

start(wait: Boolean) 中 wait 为 true 时主线程阻塞等待引擎停机,服务进程常驻;false 时立即返回,主线程退出会导致引擎随进程结束,需自行持有运行期。

概念解释

wait 只影响启动线程是否挂起,不改变请求处理协程。可嵌入到其他应用进程时通常 false 并自行管理生命周期;独立服务入口一般 true。

原理流程

  1. start 完成端口绑定与管道装配。
  2. wait 为 true:把当前线程挂到引擎停机等待上。
  3. wait 为 false:返回引擎实例,调用方负责不让进程退出。
  4. 停机信号到达后解除等待。

代码或图示

val engine = embeddedServer(Netty, port = 8080) { /* ... */ }
engine.start(wait = true) // 主线程阻塞

常见误区

  • main 函数里 wait=false 后直接返回:容器内进程秒退。
  • 在测试里 wait=true:测试线程被阻塞无法断言。

追问

  • 如何优雅停止?答:引擎实例的停机方法或部署信号钩子,按引擎 API 调用。
  • wait 阻塞的是主线程还是请求线程?答:启动线程,请求仍在各自协程中处理。

06.8.1.1-014 development mode 开启后行为有哪些差异?

一句话结论

开发模式面向本地调试:开启细节错误页、热重载或友好错误展示等便利行为,生产环境必须关闭,避免泄露内部信息与使用不稳定的开发装配。

概念解释

开发模式通过环境标识传给引擎与插件;影响错误响应呈现、监视与重载行为。生产环境关闭开发模式后,异常对外只返回中性响应,细节进日志。

原理流程

  1. 启动配置标记开发模式。
  2. 环境把标识传递给 Application。
  3. 错误处理插件据此选择详情页或中性响应。
  4. 本地开发时可配合文件监视重载模块。

代码或图示

// 生产启动必须不开启开发模式;本地调试环境按需开启
embeddedServer(Netty, port = 8080, watchPaths = listOf("main")) { /* ... */ }

常见误区

  • 生产误开开发模式:堆栈与内部路径暴露给客户端。
  • 依赖热重载做生产发布:重载只适用于开发场景。

追问

  • 待确认:Ktor 3 中开发模式对应的配置项与监视能力名称,以官方文档为准。
  • 错误页谁来渲染?答:StatusPages 与开发模式标识共同决定。

06.8.1.1-015 服务器端口与主机如何配置?

一句话结论

通过引擎启动参数绑定主机与端口,也可由配置文件读取;端口冲突时引擎启动失败,需在启动日志中确认实际监听地址。

概念解释

主机地址决定绑定网卡(本机回环、全部网卡、指定内网地址);端口决定监听端口。容器部署常绑定 0.0.0.0 并由外部映射端口,本机调试默认回环即可。

原理流程

  1. 从启动参数或配置读取 host、port。
  2. 引擎工厂据此构造监听通道。
  3. 端口被占用时启动抛异常,日志给出绑定失败原因。
  4. 服务对外地址由部署网关/映射决定,不等同于绑定地址。

代码或图示

embeddedServer(Netty, host = "0.0.0.0", port = 8080) { /* ... */ }

常见误区

  • 绑回环地址后容器外访问不通:容器内应绑 0.0.0.0。
  • 把外部映射端口当成进程内端口:两者可能不同。

追问

  • 端口能否启动后动态改?答:监听在启动时确定,改端口需重启。
  • 多实例同端口?答:同机多实例需不同端口,或前置负载均衡。

06.8.1.1-016 多模块结构中 module 函数如何组织?

一句话结论

按职责把装配拆成多个 Application 扩展函数(公共插件、路由模块、基础设施模块),根模块按顺序调用;模块间共享依赖通过构造或 attributes 注入。

概念解释

模块拆分提升可测试性与可读性:每个模块函数内只装自己的插件与路由。模块注册顺序影响插件管道顺序,基础横切插件先装,业务路由模块后装。

原理流程

  1. 定义公共基础设施模块(日志、监控、配置)。
  2. 定义业务路由模块,依赖基础设施已就位。
  3. 根 module 依次调用各子模块函数。
  4. 测试可单独装配子模块构造测试 Application。

代码或图示

fun Application.module() {
    configureMonitoring()
    configureSecurity()
    configureRouting()
}

fun Application.configureRouting() {
    routing { get("/") { call.respondText("ok") } }
}

常见误区

  • 子模块里再装基础插件导致重复安装:插件幂等性与顺序需核对。
  • 模块间用全局可变对象传依赖:破坏可测试性与隔离性。

追问

  • 模块函数能返回对象吗?答:标准装配函数是 Application 扩展;需要返回值时在外部构造器组合。
  • 子模块能否独立启动?答:可作为单独引擎入口装配,复用公共函数。

06.8.1.1-017 routing 插件是怎么被安装和激活的?

一句话结论

routing { ... } 是路由插件的装配入口:调用时安装 Routing 插件并在其管道内注册路由节点;不调用 routing 则没有路由表,所有请求落到 404。

概念解释

Routing 是一个 Application 插件,负责维护路由树并在应用管道末端执行路由匹配。路由节点(route、get、post 等)都挂在 Routing 管道下。

原理流程

  1. 模块内调用 routing { },触发 Routing 插件安装。
  2. 闭包内逐层注册路由节点与处理器。
  3. 请求进入路由管道,按路径与方法匹配节点。
  4. 匹配成功执行节点 Handler,失败返回 404 或 405。

代码或图示

routing {
    get("/health") { call.respondText("up") }
}

常见误区

  • 在 routing 闭包外写 get/post:节点没有挂载到路由树。
  • 以为任何请求默认有根路由:未注册路径一律 404。

追问

  • Routing 插件能手动 install 吗?答:可显式 install(Routing) 后装配,routing {} 是便捷入口,二者等价程度以 API 为准。
  • 路由表在哪里查看?答:开发模式或插件日志可输出已注册路由清单。

06.8.1.1-018 路由树是如何组织的?

一句话结论

路由树由嵌套节点构成:根节点下按路径段拆分子节点,每个节点携带匹配规则(路径段、参数、方法)与处理器;嵌套 route 形成共享前缀子树。

概念解释

树节点对应 URL 路径的一段;静态段优先于参数段,参数段再到通配段。节点可以挂多个 HTTP 方法处理器,子节点继承父节点的拦截与插件装配。

原理流程

  1. route("/users") 创建前缀节点。
  2. 子作用域内 get("/{id}") 注册带参数的叶子节点。
  3. 请求路径按段逐级匹配节点。
  4. 方法与节点都匹配才执行对应处理器。

代码或图示

routing {
    route("/users") {
        get("/{id}") { /* ... */ }
        post { /* ... */ }
    }
}

常见误区

  • 把路由表理解为平铺列表:嵌套前缀是树结构,父子共享管道拦截。
  • 子节点重复写父前缀:嵌套 route 已继承前缀,重复拼接会形成错误路径。

追问

  • 同一节点挂多方法会冲突吗?答:按方法区分处理器,不冲突。
  • 父节点的拦截对子节点生效吗?答:生效,子节点在父管道之后继续匹配。

06.8.1.1-019 嵌套 route 与前缀复用怎么写?

一句话结论

用 route("/prefix") { ... } 把共享前缀、公共拦截与子路由收拢到一个作用域,子节点路径相对于父前缀拼接,避免每个 Handler 重复写长前缀。

概念解释

嵌套 route 同时复用路径前缀与管道装配:父节点上挂的拦截、认证、插件对子树生效。适合按业务域(/users、/orders)划分路由分组。

原理流程

  1. 定义父 route 前缀与子树公共装配。
  2. 子作用域内注册相对路径的方法节点。
  3. 匹配时先命中父前缀,再在子树内继续匹配。
  4. 离开作用域不影响其他路由分支。

代码或图示

route("/api/v1") {
    route("/users") {
        get { /* 路径 /api/v1/users */ }
        get("/{id}") { /* 路径 /api/v1/users/{id} */ }
    }
}

常见误区

  • 子路径又写全前缀:拼出双重前缀路径。
  • 在父 route 上挂只属于个别子节点的拦截:影响面过大。

追问

  • 能否多级嵌套?答:可以,层级按业务域划分即可。
  • 分组能做命名隔离吗?答:路由树不强制命名,靠目录结构与模块函数组织。

06.8.1.1-020 路径参数 {id} 如何声明与读取?

一句话结论

路径段写 {id} 声明命名参数,Handler 内通过 call.parameters["id"] 读取;参数值是字符串,需自行转成目标类型并校验。

概念解释

路径参数匹配路径中的一段,不能跨斜杠;同名参数在父子节点间逐级取值。查询参数与路径参数都进 call.parameters,来源不同,取值时注意区分。

原理流程

  1. 节点路径声明 {id}。
  2. 请求路径对应段被捕获为参数值。
  3. 匹配阶段把参数放入 Call 的 parameters。
  4. Handler 读取字符串并转换、校验后使用。

代码或图示

get("/users/{id}") {
    val raw = call.parameters["id"] ?: return@get call.respond(HttpStatusCode.BadRequest)
    val id = raw.toIntOrNull() ?: return@get call.respond(HttpStatusCode.BadRequest)
    call.respondText("user $id")
}

常见误区

  • 直接 toInt() 不判空:非法段抛异常变成 500。
  • 把路径参数当查询参数:跨段匹配行为不同。

追问

  • 参数能声明类型约束吗?答:基础按字符串捕获,类型转换与正则约束在处理器或拦截层完成。
  • 同名父子参数取到哪个?答:按当前匹配链取值,具体覆盖规则以参数解析实现为准。

06.8.1.1-021 路径参数类型与转换(Int、UUID)怎么做?

一句话结论

Ktor 不强制路径参数类型,转换在 Handler 或公共提取逻辑中完成:用 toIntOrNull、UUID.fromString 等安全解析,失败返回 400;复杂类型可抽到公共扩展函数复用。

概念解释

路径段本质是字符串,路由匹配不负责语义校验。类型转换失败属于客户端错误(400),不应抛未捕获异常导致 500。重复的转换逻辑可封装为 Call 扩展或参数类。

原理流程

  1. 读取原始参数字符串。
  2. 安全解析为目标类型,失败短路响应 400。
  3. 解析后的类型化值传给业务逻辑。
  4. 公共解析器在多路由间复用。

代码或图示

val userId: Int = call.parameters["id"]?.toIntOrNull()
    ?: return@get call.respond(HttpStatusCode.BadRequest)

常见误区

  • 用非空断言强转:非法输入直接 500。
  • 每个 Handler 重复写解析代码:漏边界校验。

追问

  • 能否让路由层拒绝非法类型段?答:可借助正则匹配或拦截层统一处理,基础路由只做段捕获。
  • UUID 解析失败怎么响应?答:按 400 处理,不要回显内部格式细节。

06.8.1.1-022 通配符与多段匹配如何写?

一句话结论

单段通配与多段捕获用于匹配不确定路径:单段匹配一个路径段,多段通配捕获剩余整段路径;具体语法名称以 Ktor 路由文档为准,未核对前标「待确认」。

概念解释

通配段优先级低于静态段与命名参数,常用于前端资源回退、静态文件代理。多段捕获要注意编码、斜杠保留与安全边界,避免任意路径穿越。

原理流程

  1. 静态与命名参数节点优先匹配。
  2. 未命中时回退到通配节点。
  3. 多段通配把剩余路径收集为参数。
  4. 处理器对捕获路径做规范化与边界校验。

代码或图示

// 语法以官方路由文档为准;此处示意剩余段回退
get("/{...path}") {
    val path = call.parameters["path"] ?: ""
    call.respondText(path)
}

常见误区

  • 通配节点放得比静态节点优先:匹配预期反转。
  • 直接把捕获段拼到文件系统路径:存在目录穿越风险。

追问

  • 待确认:Ktor 3 通配段与多段参数的确切写法和保留斜杠行为,查官方 routing 文档核对。
  • 通配路由能挂认证吗?答:可以,按节点挂公共拦截或认证插件。

06.8.1.1-023 可选斜杠与尾斜杠行为如何处理?

一句话结论

是否把 /users 与 /users/ 视为同一节点取决于路由匹配实现;生产上应在网关或路由层统一 trailing slash 策略,避免同一资源两个入口造成缓存与鉴权不一致。

概念解释

尾斜杠差异常见于静态资源与前端回退;匹配规则可能自动归一,也可能分别匹配。面试重点是意识到这是一个需要显式确认的行为,而非想当然。

原理流程

  1. 确认目标引擎版本下尾斜杠匹配规则。
  2. 在入口层统一重定向或归一化路径。
  3. 路由注册与测试用例覆盖两种写法。
  4. 缓存与鉴权按归一化后的路径生效。

代码或图示

验证用例:
- GET /users
- GET /users/
分别断言状态码与处理器归属

常见误区

  • 假设框架自动归一:未验证前两种写法可能落到不同处理器。
  • 两种入口分别加不同策略:状态不一致。

追问

  • 待确认:Ktor 3 路由对尾斜杠的默认归一行为,以官方文档或实测为准。
  • 静态资源受尾斜杠影响吗?答:受影响,目录与文件映射规则需单独验证。

06.8.1.1-024 HTTP 方法动词函数如何注册处理器?

一句话结论

get、post、put、delete、patch、head、options 等动词函数在路由节点下注册对应方法的处理器;路径与方法同时匹配才执行。

概念解释

动词函数是路由节点的子构造器,每个绑定一个 HTTP 方法。同一节点可注册多个方法处理器,方法之间互不干扰。处理器内是挂起函数,可直接调用协程逻辑。

原理流程

  1. 在 route 作用域内调用动词函数并给路径。
  2. 构造方法节点,注册 Handler 协程。
  3. 请求方法与路径都命中节点时执行。
  4. 方法不匹配而路径匹配时进入 405 判定。

代码或图示

routing {
    post("/users") { /* 创建 */ }
    get("/users/{id}") { /* 查询 */ }
    put("/users/{id}") { /* 更新 */ }
    delete("/users/{id}") { /* 删除 */ }
}

常见误区

  • 用 get 处理写操作:违背语义且被缓存/预取误伤。
  • 同一方法重复注册到同一路径:覆盖或冲突行为需按实现核对。

追问

  • 自定义 HTTP 方法能注册吗?答:基础动词覆盖常见方法,自定义方法支持程度以 API 为准。
  • Handler 为什么是 suspend?答:请求处理在协程中进行,可异步等待 IO。

06.8.1.1-025 路由匹配优先级如何决定?

一句话结论

匹配顺序通常是静态段优先于参数段、参数段优先于通配段;树深与注册顺序在同级别参与取舍,具体优先级表以官方文档为准,出现歧义时用测试用例固化预期。

概念解释

优先级避免 /users/me 被 /{id} 抢先捕获;静态字面量段最具体,动态段次之,通配最宽泛。同级别多节点的次序可能受注册顺序影响,不应依赖未文档化的细节。

原理流程

  1. 请求路径按段进入路由树。
  2. 每段优先匹配静态子节点,再试参数段,最后通配段。
  3. 方法匹配在路径命中后判定。
  4. 匹配结果固定后执行处理器。

代码或图示

get("/users/me") { /* 静态优先于参数 */ }
get("/users/{id}") { /* 参数段 */ }

常见误区

  • 把 /{id} 写在静态特例前面并指望它先匹配:优先级可能反转。
  • 依赖注册顺序保证特例命中:应靠静态段优先级与测试固化。

追问

  • 待确认:Ktor 3 同级节点在并列情况下的精确比较规则,查 routing 文档核对。
  • 匹配歧义怎么排查?答:为冲突路径各写测试,观察实际命中节点与处理器。

06.8.1.1-026 同一路由的多个处理器如何叠加?

一句话结论

节点上的处理器叠加主要通过管道拦截实现:父节点或插件拦截器先执行,最后才是方法 Handler;同一方法节点注册多个处理器时的叠加/覆盖行为以实现为准,不建议依赖未文档化的重复注册。

概念解释

Ktor 的「多层处理」不是同节点堆多个业务 Handler,而是拦截链 + 末端 Handler 结构。横切逻辑放拦截器,业务响应放动词 Handler,职责分层清晰。

原理流程

  1. 父节点与插件注册前置/后置拦截。
  2. 方法节点注册末端 Handler。
  3. 管道逐级 proceed,拦截器包裹 Handler。
  4. 响应写出后拦截器做收尾处理。

代码或图示

route("/users") {
    intercept(ApplicationCallPipeline.Call) {
        // 节点级前置拦截
        proceed()
    }
    get("/{id}") { /* 末端 Handler */ }
}

常见误区

  • 同一 get 路径注册两个 Handler 期望链式执行:行为不确定,应合并到拦截器。
  • 把业务前置校验写进第二个 Handler:链路不可控。

追问

  • 节点拦截与全局拦截区别?答:节点拦截只作用于该子树,全局作用于全部请求。
  • 拦截器能否改请求体?答:请求体读取后缓存能力有限,改写需结合接收插件实现。

06.8.1.1-027 404 是如何产生的?

一句话结论

路由树中没有任何节点与请求路径匹配时返回 404;路径命中但方法不命中时先进入 405 判定,二者不要混淆。

概念解释

404 表示资源位置不存在,由路由匹配阶段未命中产生;可通过 StatusPages 的 status(NotFound) 自定义响应体。静态资源未找到也走同一未命中语义。

原理流程

  1. 请求进入路由管道逐级匹配路径。
  2. 所有节点都不命中路径:管道末端置 404。
  3. StatusPages 捕获 404 状态可改写响应体。
  4. 响应按 404 写出。

代码或图示

install(StatusPages) {
    status(HttpStatusCode.NotFound) { call ->
        call.respondText("资源不存在", status = HttpStatusCode.NotFound)
    }
}

常见误区

  • 把方法不匹配也当 404:语义上是 405。
  • 未自定义 404 时返回框架默认页:生产建议统一响应结构。

追问

  • 404 能记日志吗?答:可在监控拦截或 StatusPages 中记录,注意区分探测流量。
  • 根路径未注册会怎样?答:同样 404。

06.8.1.1-028 405 Method Not Allowed 何时返回?

一句话结论

路径匹配到节点但该节点没有注册对应 HTTP 方法时,按 405 处理;允许的方法列表(Allow 头)由已注册方法节点汇总,具体行为以引擎与路由实现为准。

概念解释

405 区分「路径存在但方法不对」与「路径不存在」,帮助客户端纠正调用。框架是否自动生成 Allow 头、是否默认返回 405,需结合版本验证,不确定处标待确认。

原理流程

  1. 路径命中某节点。
  2. 检查该节点已注册方法集合。
  3. 当前方法不在集合内:判定 405。
  4. 响应携带允许方法信息(若实现支持)。

代码或图示

示例:节点只注册了 get
- GET  /users/1  -> 命中
- POST /users/1  -> 路径命中、方法缺失 -> 405(待确认默认行为)

常见误区

  • 路径与方法都不匹配时回 405:优先按 404 语义处理。
  • 前端把 405 当 404 重试:状态语义被抹平。

追问

  • 待确认:Ktor 3 是否默认生成 405 与 Allow 响应头,查官方文档或实测核对。
  • 405 能自定义响应体吗?答:可经 StatusPages 按状态码覆盖。

06.8.1.1-029 静态资源如何挂载?

一句话结论

通过静态资源插件/路由把目录或类路径资源映射到 URL 前缀:指定 URL 路径与资源根位置,框架按请求路径解析文件并返回,目录穿越必须被拦截。

概念解释

静态资源与动态路由同属路由树的一种节点;可映射文件系统目录或 jar 内类路径资源。生产常把静态资源交给网关/CDN,Ktor 内挂载主要用于开发或小文件场景。

原理流程

  1. 注册静态资源节点,给 URL 前缀与资源根。
  2. 请求路径映射到相对资源路径。
  3. 规范化后检查是否落在资源根内。
  4. 存在则返回文件,否则 404。

代码或图示

routing {
    // 具体工厂方法名以官方静态资源文档为准
    staticResources("/static", "static")
}

常见误区

  • 直接拼接请求段到文件路径:未规范化导致目录穿越。
  • 把源码目录当生产资源根:暴露打包外文件。

追问

  • 待确认:Ktor 3 静态资源挂载的 API 名称(文件系统/类路径两种形式),查官方文档核对。
  • 静态资源缓存头怎么加?答:配合 CachingHeaders 插件或节点拦截设置。

06.8.1.1-030 路径参数与查询参数有什么区别?

一句话结论

路径参数属于 URL 路径段,标识资源定位;查询参数位于 ? 之后,表达筛选、分页、排序等辅助条件;二者都可从 call.parameters 读取,语义与缓存行为不同。

概念解释

路径参数参与路由匹配,变更路径会改变资源地址;查询参数不影响路由节点命中,常用于可选条件。查询参数可重复出现,取值可能是列表,需按多值读取。

原理流程

  1. 路径段在路由匹配时捕获为路径参数。
  2. 问号后键值对解析为查询参数。
  3. 二者并入 parameters 视图。
  4. Handler 按语义取用并校验。

代码或图示

get("/users") {
    val page = call.parameters["page"]?.toIntOrNull() ?: 1
    val size = call.parameters["size"]?.toIntOrNull() ?: 20
}

常见误区

  • 用查询参数做资源标识:URL 语义不清,缓存与鉴权边界混乱。
  • 忽略重复参数:多值场景只取到第一个。

追问

  • 多值参数怎么取?答:按参数名取列表的 API,以参数解析实现为准。
  • 查询参数会进路由匹配吗?答:不参与节点匹配,只在处理器内读取。

06.8.1.1-031 路径参数命名冲突与校验如何处理?

一句话结论

父子节点同名参数按匹配链取值,语义不清时应改为不同名;所有路径参数在进入业务前完成类型、范围与存在性校验,非法输入返回 400 而不是 500。

概念解释

参数冲突常出现在嵌套路由复用 {id}:父级资源 id 与子级资源 id 同名时取值易混淆。校验集中在公共解析器或拦截层,避免每个 Handler 各写一套。

原理流程

  1. 检查父子参数命名是否语义独立,必要时改名。
  2. 公共解析器把原始段转为类型化值。
  3. 范围、格式校验失败短路 400。
  4. 业务层只接收已校验类型。

代码或图示

// 避免父子 {id} 冲突:显式区分订单与用户
get("/orders/{orderId}/items/{itemId}") {
    val orderId = call.parameters["orderId"]
}

常见误区

  • 同名参数靠位置记忆取值:嵌套调整后取错。
  • 校验散落在各 Handler:边界条件遗漏。

追问

  • 参数能加正则约束吗?答:基础捕获为字符串,约束在解析层或匹配层实现,具体能力以文档为准。
  • 非法参数统一响应格式?答:在 StatusPages 或公共解析器中归一。

06.8.1.1-032 HEAD 与 OPTIONS 方法由谁处理?

一句话结论

HEAD 通常期望只返回响应头不带 body,OPTIONS 用于描述允许方法;是否由框架自动派生对应 GET 处理、自动返回 Allow,取决于版本实现,未核对前标待确认。

概念解释

HEAD 与 GET 共享资源定位但不返回实体;OPTIONS 是 CORS 与接口发现的前置方法。业务一般不手写 HEAD 处理器,重点确认框架派生行为与自定义覆盖方式。

原理流程

  1. 请求方法为 HEAD/OPTIONS 进入路由匹配。
  2. 框架按派生规则映射到 GET 或生成方法描述。
  3. HEAD 响应剥离 body,保留头与状态码。
  4. 自定义处理器可覆盖默认派生行为。

代码或图示

待确认核对项:
- HEAD 是否自动对应同路径 GET
- OPTIONS 响应头与状态码默认值

常见误区

  • 手写 HEAD 复制 GET 逻辑:重复且易漏响应头差异。
  • 把 OPTIONS 预检当业务登录:应由 CORS 插件处理。

追问

  • 待确认:Ktor 3 对 HEAD、OPTIONS 的默认派生策略,查官方文档或实测核对。
  • 预检失败看哪里?答:CORS 插件日志与响应头,而非业务 Handler。

06.8.1.1-033 路由分组中按认证隔离怎么写?

一句话结论

在父 route 作用域上挂载认证插件引用或节点拦截,受保护子树整体走认证;公开路由放在无认证父节点下,分组边界即鉴权边界。

概念解释

认证是管道行为,可以按子树粒度挂载:父节点拦截器对所有子节点生效。这样公开接口与受保护接口在路由结构上物理分开,避免逐个 Handler 判断登录态。

原理流程

  1. 公开路由注册在普通父节点下。
  2. 受保护业务域挂到引用认证配置的父 route。
  3. 子请求先过认证拦截,通过后才进入处理器。
  4. 认证失败由 challenge 返回 401/403。

代码或图示

route("/api") {
    route("/public") { get("/health") { /* 公开 */ } }
    authenticate("jwt") {
        route("/private") { get("/me") { /* 受保护 */ } }
    }
}

常见误区

  • 在每个 Handler 内重复查 principal:漏掉某个接口即成越权入口。
  • 认证挂在最外层后又给公开接口放行:规则缠绕难懂。

追问

  • 同一子树能挂多套认证吗?答:可组合多个认证引用,选择规则见认证插件章节。
  • 节点级认证能继承到孙节点吗?答:继承,子树整体受保护。

06.8.1.1-034 动态路径与正则约束如何配合?

一句话结论

路由层捕获动态段,格式与范围约束放在参数解析或前置拦截中;若版本支持正则段约束可在声明时使用,不支持时不要假设,用测试固化非法输入的 400 行为。

概念解释

动态路径解决「资源 id 这类可变段」,正则约束解决「段必须符合某种格式」。把校验下沉到公共解析器后,路由表保持可读,非法输入不进业务逻辑。

原理流程

  1. 节点声明参数段。
  2. 前置拦截或解析器用正则/格式规则校验。
  3. 不匹配则短路 400。
  4. 合法值进入业务 Handler。

代码或图示

val id = call.parameters["id"]
    ?.takeIf { it.matches(Regex("\\d+")) }
    ?.toIntOrNull()
    ?: return@get call.respond(HttpStatusCode.BadRequest)

常见误区

  • 假设路由声明支持内联正则:未核对文档前按字符串捕获处理。
  • 把格式校验写进业务 service:路由层就该挡住非法输入。

追问

  • 待确认:Ktor 3 路径段是否支持内置正则语法,以官方 routing 文档为准。
  • 非法输入记日志吗?答:可记参数形态,不要记录未脱敏敏感值。

06.8.1.1-035 路由树节点在源码层大致如何表示?

一句话结论

路由节点持有路径段描述、匹配规则、已注册方法处理器与子节点列表;父子节点构成树,匹配从根逐级向下;具体类名与字段以 Ktor 源码为准,不确定处不编造。

概念解释

理解节点结构有助于解释「嵌套 route 共享前缀」「父节点拦截作用于子树」「方法不匹配进入 405」等行为。面试讲清树形组织与处理器挂载位置即可,不需要背内部类名。

原理流程

  1. 注册动词函数时创建或复用路径节点。
  2. 节点记录方法到 Handler 的映射与子节点集合。
  3. 匹配遍历子节点,按段规则命中。
  4. 命中后执行对应方法 Handler。

代码或图示

RouteNode
├─ 段描述(静态 / 参数 / 通配)
├─ methods: Map<HttpMethod, Handler>
└─ children: List<RouteNode>

常见误区

  • 把节点当成全局路由表一项:节点是树中的位置,带父子关系。
  • 编造内部类名与字段:读源码前不要在答案里写死。

追问

  • 待确认:Ktor 3 路由节点实现类名与方法注册字段,需对照源码核对。
  • 节点拦截挂在哪一层?答:挂在节点管道上,作用于该子树匹配到的请求。

06.8.1.1-036 请求进入引擎后依次经过哪些 Pipeline 阶段?

一句话结论

请求先过引擎前置阶段,再进应用管道的插件/路由/监控阶段:前置拦截装配通用行为,路由阶段匹配处理器,监控阶段记录结果与异常;阶段顺序固定,拦截器按阶段挂载。

概念解释

Ktor 管道把「请求进来」到「响应出去」拆成有序阶段,每个阶段可挂多个拦截器。应用管道与路由管道嵌套执行:先全局应用管道,再进入匹配子树的节点管道,最后到 Handler。

原理流程

  1. 引擎构造 Call 进入应用管道起始阶段。
  2. 插件拦截器在各自阶段执行前置逻辑。
  3. 路由管道匹配节点并执行 Handler。
  4. 响应返回后经过监控阶段记录状态,回写客户端。

代码或图示

Engine 接收
  -> Before/Plugins 阶段(认证、压缩、CORS 等)
    -> Routing 阶段(匹配 + Handler)
      -> Monitoring 阶段(日志、异常、结果记录)
        -> 响应写出

常见误区

  • 把所有拦截都挂在同一阶段:顺序耦合,调整时互相影响。
  • 以为监控阶段能改响应体:它主要观察与记录,改写应在响应前阶段。

追问

  • 待确认:Ktor 3 应用管道各阶段的精确名称与顺序,以官方 pipeline 文档或源码核对。
  • 阶段能新增吗?答:自定义阶段可在管道中插入,能力边界以 Pipeline API 为准。

06.8.1.1-037 intercept 如何插入拦截逻辑?

一句话结论

intercept(阶段) { ... } 在指定阶段注册拦截器闭包,闭包内调用 proceed() 放行到下一节点;proceed 返回后可做收尾处理,形成包裹 Handler 的前后置逻辑。

概念解释

拦截器是管道节点,闭包持有当前 Call;前置代码在 proceed 前执行,收尾代码在 proceed 后执行。不调用 proceed 即短路,后续节点与 Handler 不执行。

原理流程

  1. 选定挂载阶段。
  2. 闭包内读取 Call、做前置校验或改造。
  3. 调用 proceed 进入下一管道节点。
  4. proceed 返回后记录状态、补充响应头或清理资源。

代码或图示

intercept(ApplicationCallPipeline.Plugins) {
    val start = System.currentTimeMillis()
    proceed()
    val elapsed = System.currentTimeMillis() - start
    application.log.info("${call.request.uri} ${elapsed}ms")
}

常见误区

  • 忘记 proceed:后续 Handler 不执行,请求无响应。
  • 在 proceed 之后读已提交的响应体:body 通常不可再读。

追问

  • 拦截器里能抛异常吗?答:可以,异常沿管道传播到异常处理阶段。
  • 拦截器顺序由什么决定?答:阶段先后 + 同阶段注册顺序,安装顺序敏感。

06.8.1.1-038 ApplicationCallPipeline 各阶段分别承担什么职责?

一句话结论

基础管道阶段覆盖请求前置准备、插件装配、路由调用与结果监控四类职责;认证、序列化等插件挂在装配阶段,业务处理器在路由调用阶段,日志与异常统计在监控阶段。

概念解释

阶段划分让横切能力各归其位:准备阶段解析基础请求信息,插件阶段执行通用过滤器,调用阶段执行业务,监控阶段观察结果。具体阶段常量名以版本为准。

原理流程

  1. 请求进入基础阶段,Call 就绪。
  2. 插件阶段运行已安装插件的拦截逻辑。
  3. 调用阶段进入路由匹配与 Handler。
  4. 监控阶段记录状态码、耗时与异常。

代码或图示

intercept(ApplicationCallPipeline.Monitoring) {
    try { proceed() } catch (e: Throwable) { application.log.error("处理失败", e) }
}

常见误区

  • 把日志统计挂在插件阶段:拿不到最终响应状态码。
  • 在监控阶段改写响应:响应可能已提交。

追问

  • 待确认:各阶段常量在 Ktor 3 中的命名与可拦截行为,查官方文档核对。
  • 哪个阶段最适合统一异常捕获?答:监控或专门的异常处理插件(StatusPages)。

06.8.1.1-039 拦截器中如何跳过后续处理并直接响应?

一句话结论

校验不通过时直接调用 call.respond(...) 写出响应且不调用 proceed,管道即短路;响应已提交后不要再 proceed,避免重复写出。

概念解释

短路用于鉴权失败、参数非法、限流拒绝等场景:响应由拦截器直接生成,Handler 不执行。短路后 proceed 不再调用,后续拦截器的收尾逻辑是否执行取决于管道实现。

原理流程

  1. 拦截器读取请求做判定。
  2. 不满足条件:构造错误响应并 respond。
  3. 不调用 proceed,管道到此为止。
  4. 响应提交后结束本次请求。

代码或图示

intercept(ApplicationCallPipeline.Plugins) {
    if (call.request.headers["X-Token"].isNullOrBlank()) {
        call.respond(HttpStatusCode.Unauthorized)
        return@intercept
    }
    proceed()
}

常见误区

  • respond 之后仍 proceed:触发重复响应或异常。
  • 短路响应不带状态码:默认 200,语义错误。

追问

  • 短路后子树拦截还会跑吗?答:不会进入路由子树,节点拦截不执行。
  • 如何记录短路原因?答:拦截器内写日志,响应体保持中性。

06.8.1.1-040 响应写出前还能修改响应吗?

一句话结论

响应头、状态码可在提交前的拦截阶段修改;响应体一经写出通常不可回读或替换,需要统一包装时应在 Handler 产出响应前或序列化插件层处理。

概念解释

Ktor 响应写出经过拦截链:头与状态码在准备阶段可改,body 由序列化插件或 Handler 生成。想统一包一层 envelope,应在响应生成层拦截,而不是在 body 写出后改写。

原理流程

  1. Handler 调用 respond 携带响应对象。
  2. 序列化插件把对象转为 body,写入响应头。
  3. 提交前的拦截可补充/覆盖头与状态码。
  4. body 提交后进入网络写出,不可再改。

代码或图示

// 提交前补充响应头
intercept(ApplicationCallPipeline.Plugins) {
    proceed()
    call.response.headers.append("X-App", "ktor")
}

常见误区

  • 响应 body 写出后再读取重写:缓存行为不确定。
  • 在多个拦截器里各自包 envelope:格式互相覆盖。

追问

  • 统一响应体在哪做?答:序列化插件层或自定义响应包装,按响应类型拦截。
  • 状态码能被后置拦截改吗?答:未提交前可以,已提交则忽略。

06.8.1.1-041 管道执行与协程取消如何关联?

一句话结论

请求协程被取消(客户端断连、超时)时,管道推进随之终止,Handler 内挂起点感知取消并清理资源;必须在 finally 或协程取消回调中释放连接、临时文件等资源。

概念解释

协程取消是协作式的:阻塞不可中断的代码会延迟取消效果。管道节点依次在同一请求协程内执行,取消信号沿协程传播,未完成的 proceed 不再继续。

原理流程

  1. 客户端断开或超时触发取消。
  2. 请求协程收到取消异常。
  3. 正在挂起的 IO 收到取消,释放资源。
  4. 未提交的响应不再写出。

代码或图示

get("/stream") {
    val resource = acquire()
    try {
        // 流式处理
        proceed()
    } finally {
        resource.close() // 取消路径下也会执行
    }
}

常见误区

  • 依赖 Handler 正常返回才释放资源:取消路径泄漏连接。
  • 跑不可中断的阻塞循环:取消信号无法及时生效。

追问

  • 如何观察客户端断连?答:协程取消与请求通道关闭事件,具体 API 以版本为准。
  • 取消后还要写日志吗?答:记录取消事件即可,避免对已断连响应写出。

06.8.1.1-042 插件如何挂到管道不同阶段?

一句话结论

插件安装器内部用 intercept(阶段) 把行为注册到管道对应位置;官方插件已选定合适阶段,自定义插件应按行为性质选前置、调用或监控阶段,顺序在 install 时确定。

概念解释

插件 = 配置闭包 + 一组管道拦截 + 可选属性。认证类插件应在业务 Handler 之前拦截,压缩类插件包裹响应写出,统计类插件挂监控阶段。阶段选错会导致行为过早或过晚。

原理流程

  1. install 读取插件配置。
  2. 安装器在 Application 管道选取阶段注册拦截。
  3. 请求经过阶段时触发插件逻辑。
  4. 插件需要的进程级对象存入 attributes。

代码或图示

val MyPlugin = createApplicationPlugin("MyPlugin") {
    onCall { call ->
        // onCall 对应调用阶段,具体钩子以插件 API 为准
    }
}

常见误区

  • 自定义插件把拦截挂到监控阶段做鉴权:Handler 已执行,鉴权失效。
  • 在插件里直接持有请求集合:破坏请求隔离。

追问

  • 待确认:Ktor 3 自定义插件各钩子(onCall、intercept 等)对应的阶段语义,以官方插件文档核对。
  • 插件能影响路由匹配吗?答:一般不影响路由表,只在管道行为层介入。

06.8.1.1-043 monitor 事件机制与管道拦截有什么区别?

一句话结论

管道拦截是请求处理链上的同步包裹,可前置校验、短路与改写;monitor 是事件订阅机制,在生命周期节点发布事件供观察者记录,不参与拦截与短路。

概念解释

两者用途不同:横切控制逻辑走拦截器;指标、日志、链路追踪这类观察走事件订阅。事件发生在固定生命周期节点,订阅者不能终止请求。

原理流程

  1. 管道节点按顺序执行可拦截逻辑。
  2. 生命周期关键节点向 monitor 发布事件。
  3. 观察者订阅事件做统计与记录。
  4. 事件订阅不改变管道走向。

代码或图示

// 观察侧:订阅应用停止等生命周期事件;请求级事件以 monitor API 为准
application.monitor.subscribe(ApplicationStopping) {
    // 停机前清理
}

常见误区

  • 用事件订阅做鉴权:事件在 Handler 之后才观察,挡不住请求。
  • 拦截器里做重统计:影响请求路径,观察应放事件层。

追问

  • 待确认:Ktor 3 可用的 monitor 事件类型名称,查官方文档核对。
  • 观察者抛异常会影响请求吗?答:观察逻辑应自行吞异常,避免波及主流程。

06.8.1.1-044 日志如何挂到请求生命周期?

一句话结论

请求日志通过管道拦截或监控事件记录:进入时取请求信息,结束时记录状态码与耗时;结构化字段(路径、方法、状态、trace id)统一格式,敏感头与参数脱敏。

概念解释

日志分访问日志(每个请求一行)与应用日志(业务细节)。访问日志挂监控阶段拿最终状态;应用日志在 Handler 内按级别输出。引擎也可能输出连接层日志,需区分来源。

原理流程

  1. 请求开始记录方法、路径、trace 标识。
  2. proceed 等待 Handler 完成。
  3. 读取响应状态码计算耗时。
  4. 输出结构化访问日志,敏感字段脱敏。

代码或图示

intercept(ApplicationCallPipeline.Monitoring) {
    val start = System.currentTimeMillis()
    try { proceed() } finally {
        val status = call.response.status()?.value
        application.log.info("${call.request.httpMethod} ${call.request.uri} -> $status ${System.currentTimeMillis() - start}ms")
    }
}

常见误区

  • 在 Handler 内拼访问日志:漏异常与短路路径。
  • 记录 Authorization、Cookie 等敏感头:合规风险。

追问

  • trace id 怎么贯穿?答:请求入口生成或透传请求头,放入 Call 属性与日志 MDC。
  • 待确认:Ktor 3 日志插件默认字段与 MDC 集成方式,以官方文档为准。

06.8.1.1-045 请求阶段抛出的异常如何沿管道传播?

一句话结论

Handler 或拦截器抛出的异常在协程内向上传播,经过管道各阶段,最终由 StatusPages 或引擎兜底处理;未被处理的异常转为 500,异常对象随取消与日志记录。

概念解释

管道不吞异常:拦截器内未捕获的错误继续向上抛。统一异常映射应在异常处理插件完成,而不是每个 Handler try-catch 一遍。异常类型与状态码的映射要区分业务异常与系统错误。

原理流程

  1. 处理器抛出异常。
  2. 协程沿调用栈与管道节点向上传播。
  3. StatusPages 匹配异常类型生成响应。
  4. 无匹配则引擎兜底 500,记录堆栈。

代码或图示

install(StatusPages) {
    exception<IllegalArgumentException> { call, cause ->
        call.respond(HttpStatusCode.BadRequest, cause.message ?: "bad request")
    }
}

常见误区

  • 异常在 Handler 内吞掉只记日志:返回体与状态码不一致。
  • 把所有异常都映射成 400:掩盖系统故障,排查困难。

追问

  • 异步子协程异常会冒泡到 Call 吗?答:取决于父子协程关系与异常传播配置,需按结构化并发规则核对。
  • 500 响应体能暴露堆栈吗?答:生产禁止,堆栈只进日志。

06.8.1.1-046 install 插件的顺序为什么重要?

一句话结论

插件按安装顺序在管道阶段注册拦截器,横切逻辑的包裹层次因此确定:基础插件先装,依赖前置状态的插件后装;顺序颠倒可能导致认证拿不到序列化后的主体、压缩包不到响应等问题。

概念解释

管道拦截形成包裹顺序:先安装的更靠近外层,后安装的更靠近内层。认证、CORS、压缩、序列化之间存在隐含依赖,调整安装顺序时要对照各插件阶段职责。

原理流程

  1. 列出插件及其拦截阶段。
  2. 按「基础环境 → 安全 → 内容协商 → 业务」顺序安装。
  3. 请求按外层到内层包裹执行。
  4. 响应沿内层到外层回写。

代码或图示

fun Application.module() {
    install(Monitoring)
    install(CORS)
    install(Authentication)
    install(ContentNegotiation)
    routing { /* ... */ }
}

常见误区

  • 任意排列插件:拦截包裹层次与预期不符。
  • 把路由插件装到安全插件之后又期望安全作用于全部:节点挂载方式需核对。

追问

  • 插件重复安装会怎样?答:多数插件有幂等或重复安装保护,具体行为按插件实现核对,不依赖重复装配。
  • 顺序问题怎么排查?答:在拦截器打桩观察进入/退出次序,定位包裹层次。

06.8.1.1-047 Application attributes 如何在进程内共享状态?

一句话结论

application.attributes 是进程级属性表,按 Key 存取插件装配时构造的单例对象(依赖客户端、配置值);请求级状态放 call.attributes,二者生命周期不能混用。

概念解释

属性表用 AttributeKey 做类型安全的键,避免弱类型 map 强转。进程级单例必须线程安全;每请求对象(如上下文、事务)不能放 Application 属性,否则并发串数据。

原理流程

  1. 插件安装时构造进程级对象。
  2. 以类型化 Key 写入 application.attributes。
  3. Handler 或其他插件按 Key 取出复用。
  4. 请求结束只清理 Call 属性,Application 属性随进程释放。

代码或图示

val ClientKey = AttributeKey<ApiClient>("ApiClient")

// 装配阶段
application.attributes.put(ClientKey, ApiClient(config))

// 使用处
val client = application.attributes[ClientKey]

常见误区

  • 把请求级 DTO 存进程属性:并发请求互相覆盖。
  • 用字符串键存对象:取值要强转,易出错。

追问

  • 属性表能存连接池吗?答:可以,属于进程级资源,注意关闭钩子释放。
  • Call 属性与 Application 属性怎么选?答:看生命周期:跨请求复用选 Application,单次请求传递选 Call。

06.8.1.1-048 插件配置闭包中能拿到什么上下文?

一句话结论

install 闭包内可配置插件参数、读取 Application 环境与属性;闭包在装配阶段执行,不持有单个请求,不能在其中读取请求体或当前 Call。

概念解释

装配阶段应用尚未处理任何请求,配置闭包负责构造插件行为与默认值;请求级逻辑必须通过拦截器在 Call 上实现。混淆装配期与请求期是常见设计错误。

原理流程

  1. install 时进入配置闭包。
  2. 读取环境配置、构造默认策略。
  3. 注册请求期拦截器。
  4. 请求到来时拦截器才访问 Call。

代码或图示

install(ContentNegotiation) {
    // 装配期:配置序列化器
    json(Json { ignoreUnknownKeys = true })
}

常见误区

  • 在 install 闭包里取 call.parameters:装配期无请求上下文。
  • 把每请求计算的默认值写死进配置:策略不能随请求变化。

追问

  • 配置需要分环境怎么办?答:装配期从 environment.config 读取,按环境给不同默认值。
  • 插件能在装配期启动后台协程吗?答:可以,但要绑定应用生命周期并在停机时取消。

06.8.1.1-049 全局单例依赖与每请求对象如何区分?

一句话结论

无状态客户端、连接池、配置属进程级单例,装配时构造一次;请求上下文、当前用户、事务属每请求对象,随 Call 创建与销毁;单例必须线程安全,请求对象不能被单例持有。

概念解释

依赖生命周期与并发边界是后端基础设计:单例共享可变状态会串请求,请求对象泄漏到单例会造成内存占用与数据串扰。Ktor 中分别用 Application 属性与 Call 属性承载。

原理流程

  1. 识别依赖是否有状态、是否随请求变化。
  2. 进程级对象在装配期构造并注册。
  3. 请求级对象在拦截器/Handler 内创建,挂到 Call 属性。
  4. 请求结束释放请求级对象。

代码或图示

// 进程级:无状态远程客户端
val httpClient = HttpClient(CIO)

// 请求级:当前主体,挂在 Call 上
call.attributes.put(PrincipalKey, currentUser)

常见误区

  • 在单例字段里缓存当前登录用户:并发串号。
  • 把请求 DAO/事务池化到单例:连接生命周期错乱。

追问

  • 每请求对象怎么注入 Handler?答:Call 属性取出,或经公共参数解析器传入。
  • 单例如何保证线程安全?答:优先无状态;有状态共享用并发集合与同步策略。

06.8.1.1-050 自定义插件如何读取应用配置?

一句话结论

插件安装器通过 application.environment.config 读取配置键,给默认值并校验必填项;配置在装配期读取一次,请求期拦截器只使用已解析的配置对象。

概念解释

自定义插件应暴露配置 DSL,缺省值兜底,缺失必填配置在启动期快速失败,而不是请求期才报错。敏感配置从环境变量或部署密钥注入,不写死在代码里。

原理流程

  1. 定义插件配置类与默认值。
  2. 装配期读 config 属性合并覆盖。
  3. 校验必填与取值范围。
  4. 拦截器闭包引用不可变配置对象。

代码或图示

class MyPluginConfig {
    var timeoutMs: Long = 1000
}

val MyPlugin = createApplicationPlugin("MyPlugin", ::MyPluginConfig) {
    val configured = pluginConfig.timeoutMs
    // 注册拦截器,引用 configured
}

常见误区

  • 请求期才读配置文件:每次 IO 且失败时机滞后。
  • 配置对象可变并在请求期修改:多请求竞争。

追问

  • 待确认:createApplicationPlugin 在 Ktor 3 中的配置构造参数签名,以官方插件文档核对。
  • 配置非法何时报错?答:启动装配期抛异常,拒绝上线。

06.8.1.1-051 StatusPages 如何统一处理异常?

一句话结论

StatusPages 插件按异常类型或状态码注册处理器:异常匹配后生成统一错误响应;未匹配的异常继续向上传播,最终由引擎兜底 500。

概念解释

异常处理集中在插件层,避免 Handler 重复 try-catch。处理器能拿到 Call 与异常对象,可记录日志、映射状态码、输出统一错误结构。注意不要在处理器内再次抛出未处理异常。

原理流程

  1. install(StatusPages) 注册异常与状态码规则。
  2. 管道异常向上传播进入插件处理链。
  3. 匹配异常类型,执行对应处理器。
  4. 处理器 respond 写出错误响应,否则继续传播。

代码或图示

install(StatusPages) {
    exception<NotFoundException> { call, _ ->
        call.respond(HttpStatusCode.NotFound, ErrorBody("not found"))
    }
    exception<Throwable> { call, cause ->
        call.application.log.error("未处理异常", cause)
        call.respond(HttpStatusCode.InternalServerError)
    }
}

常见误区

  • 兜底处理器把堆栈写进响应体:内部信息泄露。
  • 只处理业务异常不记日志:线上问题无法追溯。

追问

  • 业务异常与参数异常怎么分状态?答:参数类 400,资源不存在 404,冲突 409,未预期 500。
  • StatusPages 能处理响应状态码吗?答:可以按 status(码) 注册覆盖响应体。

06.8.1.1-052 status() 处理器如何覆盖默认 404/403 响应?

一句话结论

StatusPages 的 status(HttpStatusCode.Xxx) { ... } 在响应为指定状态码时替换响应体;适合统一 404、401、403、400 的返回结构,处理器内读取 Call 后 respond 自定义内容。

概念解释

状态码处理器在响应产生后介入:路由未命中 404、认证拒绝 403、参数校验失败 400 都可归一到同一错误结构。处理器不应再改变请求处理结果,只塑造响应表达。

原理流程

  1. 插件注册状态码到处理器映射。
  2. 管道产生目标状态码响应。
  3. 匹配状态码时执行处理器改写 body。
  4. 按新响应写出。

代码或图示

install(StatusPages) {
    status(HttpStatusCode.NotFound) { call ->
        call.respond(HttpStatusCode.NotFound, ErrorBody("资源不存在"))
    }
    status(HttpStatusCode.Forbidden) { call ->
        call.respond(HttpStatusCode.Forbidden, ErrorBody("无权限"))
    }
}

常见误区

  • 处理器里再抛异常:处理链二次失败变成兜底 500。
  • 403 响应体提示资源是否存在:辅助越权枚举。

追问

  • 状态码处理器与异常处理器优先级?答:先按异常传播匹配,再按最终状态码匹配,具体顺序以插件实现为准。
  • 能改状态码本身吗?答:可以在处理器内重新 respond 指定状态。

06.8.1.1-053 业务异常如何映射到 HTTP 状态码?

一句话结论

定义领域异常层次,在 StatusPages 按类型映射:输入类 400、未认证 401、无权限 403、不存在 404、冲突 409、限流 429,未预期异常 500;响应体只给中性错误码与消息。

概念解释

HTTP 状态表达请求处理结果类别,业务错误码放在 body 内供前端区分。异常映射表集中维护,避免各 Handler 凭感觉选状态码。映射时记录原始异常到日志。

原理流程

  1. 领域层定义带错误码的业务异常。
  2. StatusPages 按异常类型映射状态码与 body 错误码。
  3. 日志记录异常堆栈与请求标识。
  4. 响应保持统一结构。

代码或图示

exception<OrderNotFoundException> { call, _ ->
    call.respond(HttpStatusCode.NotFound, ApiError("ORDER_NOT_FOUND"))
}
exception<OutOfStockException> { call, _ ->
    call.respond(HttpStatusCode.Conflict, ApiError("OUT_OF_STOCK"))
}

常见误区

  • 业务失败一律 200 加 body 错误字段:网关与监控按状态码统计失效。
  • 异常消息原文回显:可能泄露内部实现细节。

追问

  • 校验错误多条怎么返回?答:400 body 内带字段错误列表。
  • 第三方上游错误映射什么码?答:按语义映射,上游不可用归 502/503 一类,以网关约定为准。

06.8.1.1-054 请求体 receive 只能读一次吗?

一句话结论

请求体流本质只能消费一次:读取后内容不自动保留;需要多次解析(先校验签名再反序列化)时应在读取层缓存字节或引入缓存插件,具体缓存能力以插件实现为准。

概念解释

请求体是网络流,重复 receive 可能得到空流或抛异常。常见场景:原始报文验签后再解析 JSON、上传文件同时算哈希。正确做法是一次读取为字节/字符串,再按需派生多个视图。

原理流程

  1. 首次 receive 消费网络流。
  2. 需要二次使用时保留读到的字节数组。
  3. 从缓存字节反序列化或计算校验。
  4. 流未读完时注意释放连接。

代码或图示

val raw = call.receive<ByteArray>()
// 基于 raw 验签,再解析成对象
val body = Json.decodeFromString<Request>(raw.decodeToString())

常见误区

  • 先 receive 成对象再拿原始报文:流已被消费。
  • 大请求体一次性全读进内存:内存放大风险。

追问

  • 待确认:Ktor 3 是否提供请求体缓存/重读的官方插件或开关,以文档核对。
  • 文件上传怎么避免全量入内存?答:用流式接收并落盘,控制大小与临时目录。

06.8.1.1-055 如何限制请求体大小防止大 payload 打爆内存?

一句话结论

在读取层设置大小上限:超过阈值中断接收并返回 413;结合引擎连接限制与反向代理的 body 上限双重防护;大文件上传走分片或流式落盘,不在内存全量缓冲。

概念解释

无上限接收会被超大报文打爆堆内存与线程占用。限制点可放在引擎配置、请求拦截或接收插件层;超限应尽快断开/拒绝,避免继续读完整报文。

原理流程

  1. 声明允许的最大 body 字节数。
  2. 接收过程中累计已读字节。
  3. 超阈值停止读取,响应 413。
  4. 释放连接与临时资源。

代码或图示

防护层级:
- 网关/代理 body 上限
- 引擎连接与请求大小配置
- 应用层接收阈值校验

常见误区

  • 只在反序列化后判断大小:大报文已经进内存。
  • 超时仍不中断读取:连接被慢速大报文占住。

追问

  • 待确认:Ktor 3 各引擎可配置的请求体大小上限参数名称,以官方文档核对。
  • 上传接口怎么办?答:分片上传、流式写盘、逐片限额,单独目录与配额控制。

06.8.1.1-056 表单参数与文件上传如何读取?

一句话结论

application/x-www-form-urlencoded 表单从参数读取;multipart/form-data 按部件遍历读取字段与文件,文件部件流式写入临时位置;读完释放临时文件,限制部件数量与单部件大小。

概念解释

multipart 由多个 part 组成,普通字段与文件部件混排;文件不应整体缓存在内存,需边读边写盘。表单解析依赖 Content-Type 与编码,缺类型时按普通请求体处理。

原理流程

  1. 判断 Content-Type 是否为 multipart。
  2. 遍历 part:字段读字符串,文件部件流式落盘。
  3. 累计部件大小与数量做限制。
  4. 请求结束清理临时文件。

代码或图示

val multipart = call.receiveMultipart()
while (true) {
    val part = multipart.readPart() ?: break
    when (part) {
        is PartData.FormItem -> { /* 字段 */ }
        is PartData.FileItem -> { part.streamProvider().use { it.copyTo(target) } }
    }
    part.dispose()
}

常见误区

  • 把文件部件全读到内存再存盘:大文件 OOM。
  • 不 dispose 部件:临时资源泄漏。

追问

  • 待确认:Ktor 3 multipart 部件遍历 API 名称与释放方法,以官方文档核对。
  • 上传校验什么?答:类型、大小、扩展名与内容头校验,存储路径防穿越。

06.8.1.1-057 限流在管道层如何落地?

一句话结论

限流在前置拦截器按主体(IP、用户、租户)计数,超阈值短路 429;计数存储选进程内内存(单机)或 Redis(分布式),策略含窗口、配额与排队;Ktor 核心不自带生产级限流器,需自行实现或引入第三方。

概念解释

限流属于保护型横切行为,挂在业务 Handler 之前。单机计数器简单但多实例不准;分布式限流共享计数存储并处理时钟与滑窗问题。限流响应带重试提示,不暴露内部计数细节。

原理流程

  1. 拦截器解析限流主体标识。
  2. 读取/递增计数器(窗口或令牌桶)。
  3. 超限:响应 429 并写 Retry-After。
  4. 未超限 proceed 进入业务。

代码或图示

intercept(ApplicationCallPipeline.Plugins) {
    val key = call.request.origin.remoteHost
    if (!rateLimiter.tryAcquire(key)) {
        call.respond(HttpStatusCode.TooManyRequests)
        return@intercept
    }
    proceed()
}

常见误区

  • 用进程内计数做全局限流:多实例配额成倍放大。
  • 限流判定放在 Handler 内:已经消耗业务资源才拒绝。

追问

  • 待确认:Ktor 3 是否提供官方限流插件;若无,第三方库坐标需查生态文档。
  • 限流按什么维度?答:公开接口按 IP/设备,登录后按用户,内部接口按租户。

06.8.1.1-058 响应缓冲与流式写出如何选择?

一句话结论

小对象用序列化后整体缓冲写出;大结果集、文件下载或长文本用流式分块写出,避免全量进内存;流式响应要处理背压、取消与连接断开。

概念解释

缓冲响应便于统一设置 Content-Length 与拦截包装;流式响应边生成边发送,内存占用低但头信息受限(常走分块传输)。选择取决于结果体量与生成速度。

原理流程

  1. 评估结果大小与生成方式。
  2. 小结果:对象序列化后整体响应。
  3. 大结果:流通道逐块写出。
  4. 写出期间响应取消则终止生成并清理。

代码或图示

// 流式下载示意:具体流式响应 API 以官方文档为准
get("/download") {
    call.respondOutputStream {
        source.copyTo(this)
    }
}

常见误区

  • 把大列表全量聚合成内存对象再响应:堆内存峰值过高。
  • 流式写出期间不响应取消:生成协程长期挂住。

追问

  • 待确认:Ktor 3 流式响应(OutputStream/Channel 写出)的 API 名称,以文档核对。
  • 分块传输影响缓存吗?答:影响 Content-Length 与中间缓存策略,需评估网关行为。

06.8.1.1-059 超时与挂起请求如何取消?

一句话结论

请求超时通过协程超时控制:超过时限取消请求协程并释放已获取资源;客户端断连同样触发取消;超时响应映射为 503 或网关约定的错误码,避免线程与连接长期占用。

概念解释

挂起等待远程调用、数据库查询时需要独立超时预算,不能无限等待。超时取消是协作式的,阻塞不可中断代码仍会占住线程。超时时间按接口 SLA 分级设置。

原理流程

  1. 为请求或下游调用设定超时区间。
  2. 超时时限到期触发取消。
  3. 协程 catch 超时异常,释放资源。
  4. 写出超时响应或由网关兜底。

代码或图示

withTimeoutOrNull(2_000) {
    remoteApi.fetch()
} ?: call.respond(HttpStatusCode.ServiceUnavailable)

常见误区

  • 下游调用不传超时:依赖默认值,长尾请求拖垮线程池。
  • 超时后不清理临时资源:取消路径泄漏。

追问

  • 请求级超时在哪里挂?答:拦截器包裹 Handler 协程,或各下游调用独立设限。
  • 待确认:Ktor 3 是否提供请求超时插件配置,以官方文档为准。

06.8.1.1-060 Content-Length 与分块传输如何取舍?

一句话结论

响应体长度已知时设置 Content-Length;长度未知或流式生成时使用分块传输;两者由引擎与响应写出层协商,Handler 一般不手动拼长度头,避免长度与实际 body 不符。

概念解释

Content-Length 让客户端知道响应边界,支持进度与连接复用;分块传输边发边定界,适合流式。手动写长度头但 body 不一致会破坏连接解析,属于典型低级错误。

原理流程

  1. 响应对象体量确定:序列化后计算长度写头。
  2. 流式响应:不设长度,走分块编码。
  3. 引擎按响应通道写出。
  4. 代理/客户端按头或分块定界读取。

代码或图示

已知长度 -> Content-Length: N
未知长度/流式 -> Transfer-Encoding: chunked(由引擎处理)

常见误区

  • 手动算长度与实际流不一致:响应截断或连接挂起。
  • 给流式响应强行写 Content-Length:写出超预期长度。

追问

  • 待确认:Ktor 3 引擎对响应长度与分块的默认处理,以引擎文档核对。
  • 中间代理对分块缓存有何影响?答:代理可能无法预缓存,按场景评估。

06.8.1.1-061 一个请求对应一个协程吗?

一句话结论

请求处理在独立协程作用域内推进,协程数量与并发请求相关,但底层线程复用;Handler 与拦截器都在该请求协程内挂起执行,请求结束作用域随之取消。

概念解释

协程轻量于线程:大量并发请求对应少量复用线程。请求协程的父子结构决定异常传播与取消边界;子任务应挂在请求作用域下,便于随请求取消。

原理流程

  1. 引擎为请求建立处理协程。
  2. 管道与 Handler 在该协程内执行。
  3. 发起的下游调用作为子协程/挂起任务。
  4. 请求结束作用域取消,子任务一并清理。

代码或图示

// Handler 内并发拉取多个依赖,绑定请求生命周期
val (a, b) = coroutineScope {
    val x = async { repoA.load() }
    val y = async { repoB.load() }
    x.await() to y.await()
}

常见误区

  • 把请求子任务提交到全局作用域:请求结束后任务仍跑,泄漏且串数据。
  • 认为一请求一线程:线程被协程多路复用。

追问

  • 待确认:Ktor 3 请求协程作用域的实现与可访问的 Job,以源码/文档核对。
  • 后台定时任务放哪里?答:应用级作用域,绑定 Application 生命周期,不要挂请求协程。

06.8.1.1-062 阻塞操作在 Ktor 服务里为什么危险?

一句话结论

协程挂起只释放协程不释放线程;同步阻塞调用占住底层线程,阻塞线程池耗尽后所有请求排队,并发能力塌缩;阻塞代码必须切换到专用调度器或改用异步客户端。

概念解释

事件循环/少量线程模型下,一个阻塞调用就能拖住整个线程池。常见阻塞点:同步 JDBC、同步 HTTP 客户端、Thread.sleep、CPU 密集计算。识别后用异步 API 或隔离调度器处理。

原理流程

  1. Handler 调用阻塞函数。
  2. 所在线程被占用,无法处理其他就绪协程。
  3. 阻塞堆积导致线程池饱和。
  4. 新请求排队,延迟与拒绝率上升。

代码或图示

// 不推荐:阻塞调用占住引擎线程
val result = blockingClient.call()

// 推荐:异步客户端或隔离调度器
val result = withContext(Dispatchers.IO) { blockingClient.call() }

常见误区

  • 以为 suspend 函数包一层就非阻塞:内部仍是同步阻塞调用。
  • 用 Dispatchers.IO 无限扩大阻塞池:下游慢调用仍可能压垮系统。

追问

  • CPU 密集任务怎么办?答:隔离线程池/调度器,避免占请求线程;必要时异步化。
  • 如何发现阻塞点?答:线程栈采样、慢请求日志、线程池监控。

06.8.1.1-063 Dispatchers 与引擎线程模型如何配合?

一句话结论

引擎决定事件循环与工作线程的划分,协程调度器决定挂起任务恢复到哪个线程;业务代码一般不在 Handler 里随意切换全局调度器,阻塞隔离与并发控制按调度器边界组织。

概念解释

不同引擎线程模型不同:事件循环线程、工作线程池各有职责。调度器切换代价不高,但跨线程共享 Call 状态需注意可见性。默认不要在 Handler 内长时间占用事件循环线程。

原理流程

  1. 引擎在自有线程上接收事件。
  2. 请求协程在绑定调度器上开始执行。
  3. 挂起恢复时由调度器分派线程。
  4. 阻塞任务切换到隔离调度器。

代码或图示

withContext(Dispatchers.IO) {
    // 阻塞式资源访问
}

常见误区

  • 跨引擎假设同一线程模型:Netty 与 CIO 的线程划分不同。
  • 在事件循环线程上做文件 IO:拖慢连接接受。

追问

  • 待确认:Ktor 3 各引擎默认线程数与调度器绑定,以官方引擎文档核对。
  • 线程数怎么调?答:按压测与阻塞比例调整,不照搬通用公式。

06.8.1.1-064 call.application 与 call 的上下文边界是什么?

一句话结论

call.application 指向进程级 Application 单例,call 是请求级上下文;通过 Application 访问全局配置与单例依赖,通过 Call 读取请求与写响应,两者不可互换。

概念解释

越界使用是常见 bug:把请求数据放 Application 字段造成串号,把全局客户端从 Call 临时字段取造成空指针。访问路径应按生命周期选择,依赖注入按此边界装配。

原理流程

  1. Handler 内通过 call 获取请求参数与响应通道。
  2. 需要全局客户端/配置时经 call.application 取。
  3. 全局对象不持有 Call 引用。
  4. 请求结束 Call 释放,Application 存活。

代码或图示

get("/me") {
    val principal = call.principal<User>()        // 请求级
    val client = call.application.attributes[ApiClientKey] // 进程级
}

常见误区

  • 在插件里缓存 call 到全局 map:请求结束后悬垂引用。
  • 从 application 上读当前用户:进程级对象无当前请求概念。

追问

  • 子协程能访问 call 吗?答:同一请求作用域内可访问,跨作用域不要传递 Call。
  • 测试里怎么模拟两个上下文?答:测试应用提供 Call 构造入口,Application 单独装配。

06.8.1.1-065 协程泄漏与 supervisorJob 如何处理?

一句话结论

请求作用域内启动的子任务随请求取消;脱离作用域的全局协程若不持有 Job 引用,异常与取消都失控,造成泄漏。后台任务必须绑定应用 Job,停机时统一取消。

概念解释

结构化并发要求父子 Job 关联:子任务失败按规则向上传播,父作用域取消时子任务一并取消。泄漏典型表现:请求结束后任务仍在跑、内存持续增长、日志出现孤儿任务。

原理流程

  1. 启动子任务时挂在当前作用域 Job 下。
  2. 需要独立生命周期时显式创建 SupervisorJob 并持有引用。
  3. 应用停机时取消根 Job。
  4. 定期检查未完成任务数与线程占用。

代码或图示

val background = SupervisorJob()
// 应用停止时取消
application.monitor.subscribe(ApplicationStopping) { background.cancel() }

常见误区

  • 用 GlobalScope 起后台任务:无法随应用关闭取消。
  • 子任务异常无人处理:协程崩溃且无日志。

追问

  • supervisor 与普通 Job 区别?答:supervisor 子任务失败不影响兄弟与父级,具体传播规则按协程规范。
  • 如何排查泄漏?答:监控活跃协程数、线程栈与滞留请求日志。

06.8.1.1-066 Ktor 3 的 Call 上下文 API 有哪些变化点?

一句话结论

升级 Ktor 3 时重点核对:上下文访问方式、弃用的回调/扩展 API、协程上下文传播与引擎调度绑定;具体移除与改名清单以官方迁移指南为准,未核对前标「待确认」,不凭记忆断言。

概念解释

大版本常清理旧的阻塞式 API 与遗留扩展。面试能区分「稳定的 Call 读取/响应契约」与「可能变动的内部上下文工具」即可;代码迁移以编译告警、弃用标记和 changelog 为依据。

原理流程

  1. 编译工程,收集弃用与移除告警。
  2. 对照官方迁移指南替换 API。
  3. 运行测试验证上下文传递与取消行为。
  4. 压测观察线程模型变化。

代码或图示

核对清单:
- Call 属性与主体读取 API
- 插件安装器 API(createApplicationPlugin 等)
- 引擎工厂与启动器签名
- 上下文/Dispatcher 传播行为

常见误区

  • 把 2.x 笔记直接当成 3.x 事实写进答案:版本行为可能已变。
  • 只编译不运行:上下文类问题多在并发路径暴露。

追问

  • 待确认:Ktor 3 相对 2.x 的具体 API 移除列表,查官方 migration 文档逐条核对。
  • 升级风险最大的模块?答:自定义插件、底层引擎集成、依赖同步阻塞调用的旧代码。

06.8.1.1-067 多模块拆分如何兼顾测试与复用?

一句话结论

公共装配抽成 Application 扩展函数,按基础设施、安全、业务路由分层;测试可单独装配子集模块构造测试 Application,复用同一套模块函数,避免测试复制生产配置。

概念解释

可测试性来自依赖可替换:模块函数接收可注入的客户端与配置,测试替换为内存或 Mock 实现。模块间通过显式依赖传递,而不是全局可变状态查找。

原理流程

  1. 抽取公共配置与依赖装配函数。
  2. 业务模块只接收所需依赖。
  3. 测试构造 Application 时装配测试替身模块。
  4. 生产入口组合完整模块链。

代码或图示

fun Application.configureUsers(repository: UserRepository) {
    routing { /* 依赖注入的 repository */ }
}

常见误区

  • 模块内硬编码真实远程客户端:测试无法隔离外部依赖。
  • 测试复制一份路由配置:生产与测试漂移。

追问

  • 配置差异怎么注入?答:模块函数参数或环境配置覆盖,测试传测试值。
  • 模块间共享单例在哪构造?答:根模块装配一次,向下传递。

06.8.1.1-068 端口冲突导致启动失败如何排查?

一句话结论

启动报端口绑定时,先确认目标端口是否被占用、占用进程是谁,再检查是否存在重复启动实例或配置写错端口;容器环境还要区分端口映射与容器内监听。

概念解释

绑定失败通常是占用、权限或配置问题。排查顺序:看启动异常堆栈 -> 查端口监听进程 -> 核对配置端口 -> 检查残留进程。不要盲目换端口而不释放旧实例。

原理流程

  1. 阅读启动日志中的绑定异常与端口号。
  2. 在本机/容器内检查端口监听状态与占用进程。
  3. 核对配置源(命令行、配置文件、环境变量)端口值。
  4. 释放占用或修改配置后重启。

代码或图示

排查顺序:
1. 启动异常堆栈:BindException / 端口占用
2. 端口监听列表与进程归属
3. 配置端口是否被环境变量覆盖
4. 是否有旧实例未退出

常见误区

  • 反复重启不查占用:端口一直被占。
  • 容器端口与宿主机映射混淆:进程内端口正确但外部访问不通。

追问

  • 待确认:目标系统端口查询命令按 OS 选择;Ktor 引擎绑定失败的异常类型以引擎实现为准。
  • 如何避免多实例抢端口?答:部署编排分配端口,启动前健康检查与就绪探针配合。

06.8.1.1-069 Ktor 3 如何处理优雅停机?

一句话结论

停机流程:停止接收新连接 -> 等待在处理请求完成或达到宽限时限 -> 释放连接池、客户端与后台任务 -> 退出进程;停机钩子订阅应用停止事件,避免硬断开进行中的请求。

概念解释

优雅停机保证滚动发布与缩容时不丢在途请求。需要控制等待上限:超过宽限强制取消。资源释放按依赖逆序:先停接收流量,再关客户端与池,最后退出。

原理流程

  1. 收到停机信号,引擎停止接受新连接。
  2. 就绪探针转为不可流量摘除。
  3. 在途请求处理至完成或超时取消。
  4. 订阅停止事件释放池与后台协程,进程退出。

代码或图示

application.monitor.subscribe(ApplicationStopping) {
    // 关闭共享客户端、连接池、后台调度
    httpClient.close()
}

常见误区

  • 直接杀死进程:在途请求被截断。
  • 停机钩子里再发远程调用:退出延迟且可能卡住。

追问

  • 待确认:Ktor 3 引擎优雅停机的等待配置与事件名,以官方文档核对。
  • 宽限时间设多少?答:按接口最长响应与发布策略设定,配合探针摘除。

06.8.1.1-070 开发模式下的文件监视与热重载机制是什么?

一句话结论

开发模式可监视类路径/源码变化,变化时重载模块或提示重启;该能力只用于本地开发,生产不启用。热重载行为受引擎、类加载与监视路径影响,状态不保证完全保留。

概念解释

热重载提升本地迭代速度,但不等于生产滚动发布。重载会重建应用装配,内存态单例可能重置;涉及底层引擎、静态资源与配置文件的变更可能需要完整重启。

原理流程

  1. 启动时配置监视路径。
  2. 文件变化触发重载事件。
  3. 重新装配模块或重启引擎。
  4. 生产构建不开启监视。

代码或图示

// 监视路径参数仅用于开发;具体参数名以启动器文档为准
embeddedServer(Netty, port = 8080, watchPaths = listOf("classes")) { module() }

常见误区

  • 在生产依赖热重载发布:状态不一致且无发布审计。
  • 期望重载后内存数据保留:重载可能重置 Application 状态。

追问

  • 待确认:Ktor 3 开发监视/重载的启用方式与支持的变更类型,以官方文档核对。
  • 哪些变更必须完整重启?答:引擎参数、依赖类结构、底层配置等按重载能力验证。

06.8.1.1-071 多实例部署下如何保持服务无状态?

一句话结论

会话、计数、文件等可变状态外置到共享存储,应用实例只保留无状态处理能力;进程内缓存仅作可选优化并可失效,保证任意实例都能响应同一请求。

概念解释

无状态是水平扩缩容与负载均衡的前提。实例内存里的登录态、限流计数、上传文件在多实例下会不一致;需要状态的场景用 Redis、数据库或对象存储承载,实例启动时重建必要的只读缓存。

原理流程

  1. 识别请求链路中的可变状态。
  2. 会话与令牌校验外置存储或改为无状态令牌。
  3. 计数器、配额共享到分布式存储。
  4. 实例可随时重启,不依赖本地残留数据。

代码或图示

实例 A/B/C -> 共享 Redis/DB/对象存储
本地仅保留只读配置与可重建缓存

常见误区

  • 把登录状态存在本地内存:会话粘滞之外的实例认不出用户。
  • 限流用本地计数:多实例总配额被放大。

追问

  • 本地缓存什么时候可以用?答:可重建、允许短暂不一致的只读数据,带失效策略。
  • 会话粘滞能替代外置状态吗?答:只是缓解,实例重启与扩容仍会丢状态。

06.8.1.1-072 路由匹配不上时的排查思路是什么?

一句话结论

按「路径是否注册 -> 前缀拼接是否正确 -> 方法是否命中 -> 参数段是否匹配 -> 拦截器是否短路」逐层核对;用开发期路由清单与测试用例固化预期,不要先怀疑引擎。

概念解释

404/405 大多来自注册位置错误、嵌套前缀重复拼接、方法动词用错或参数段不匹配。排查时先打印实际请求方法与路径,再对照路由树逐层缩小范围。

原理流程

  1. 记录请求方法、原始路径与查询串。
  2. 列出已注册路由,核对完整路径拼接。
  3. 判断是路径未命中(404)还是方法未命中(405)。
  4. 检查拦截器是否在路由前短路。

代码或图示

排查清单:
- 路由是否在 routing 闭包内注册
- 父/子前缀是否重复拼接
- 动词方法与请求方法是否一致
- 参数段数量与命名是否匹配
- 前置拦截是否直接 respond

常见误区

  • 看到 404 就查引擎:多数是路由注册问题。
  • 忽略尾斜杠与编码差异:两种写法可能落到不同节点。

追问

  • 如何输出已注册路由?答:开发模式/插件日志或测试中遍历路由树,具体能力以版本为准。
  • 静态资源 404 单独查什么?答:资源根目录、类路径打包与文件名大小写。

06.8.1.1-073 拦截器顺序导致认证失效的典型案例是什么?

一句话结论

认证拦截装在业务路由之后、或被更外层短路响应绕过,受保护接口实际未校验主体;典型表现是公开接口正常、带密钥访问却进入 Handler 后才报错,或任意请求都能到达业务逻辑。

概念解释

管道包裹层次由安装与挂载顺序决定。认证必须在业务 Handler 之前拦截;若认证插件安装晚于产生响应的外层插件,或认证只挂在个别子节点,其余子树就失去保护。

原理流程

  1. 梳理各拦截器安装顺序与挂载层级。
  2. 画出外层到内层的包裹链。
  3. 确认认证拦截位于 Handler 之前。
  4. 用未携带凭据的请求回归全部受保护路径。

代码或图示

错误层次:外层先 respond,认证在内层 -> 永远执行不到
正确层次:认证外层拦截 -> 通过后才进入业务子树

常见误区

  • 只测带凭据的正常路径:漏测未认证请求。
  • 认证挂在某个父节点,新增子节点放到了别的分支:保护遗漏。

追问

  • 如何回归受保护面?答:枚举受保护路由,逐一用匿名请求断言 401/403。
  • 认证插件与节点拦截谁优先?答:按管道阶段与挂载层级,实测包裹顺序。

06.8.1.1-074 同一插件被重复安装会怎样?

一句话结论

重复安装行为取决于插件实现:部分插件检测重复注册并忽略或抛异常,部分会叠加拦截器导致同一逻辑执行多次;不应依赖兜底,应在装配结构上保证每个插件只装一次。

概念解释

基础插件(监控、序列化)重复安装可能造成重复日志、重复包装响应;自定义插件若重复注册拦截器,行为翻倍且难以排查。模块拆分层级时要理清公共模块与入口模块的安装边界。

原理流程

  1. 检查公共模块是否被多个入口重复调用安装。
  2. 观察重复拦截的日志/执行次数。
  3. 保留单一安装点。
  4. 自定义插件可在安装器内做重复保护(能力以 API 为准)。

代码或图示

排查现象:日志两条、响应被包两层、计数翻倍 -> 怀疑重复 install

常见误区

  • 以为 install 天然幂等:各插件实现不一。
  • 在子模块里重复装基础插件:组合入口时叠加。

追问

  • 待确认:Ktor 3 官方插件对重复 install 的处理策略,以各插件文档核对。
  • 如何保证只装一次?答:基础插件集中在根模块,子模块只装自身职责相关插件。

06.8.1.1-075 如何读取原始请求头、查询串与原始报文?

一句话结论

请求头经 call.request.headers 按名读取,查询参数经 parameters 读取,原始报文需在接收层保留字节;读不到原始 body 时说明流已被消费,应在首次读取时缓存。

概念解释

请求对象提供方法、版本、主机、路径、头、远程地址等元数据;body 是一次性流。多用途读取(验签、反序列化、日志脱敏)先取字节再派生视图。头名大小写不敏感,取值注意多值头。

原理流程

  1. 从 request 元数据获取头与路径信息。
  2. 首次接收读取字节并缓存。
  3. 从缓存派生反序列化对象与校验摘要。
  4. 日志输出前脱敏敏感头。

代码或图示

val token = call.request.headers["Authorization"]
val rawQuery = call.request.queryParameters

常见误区

  • 直接遍历头打印 Authorization/Cookie:敏感信息入日志。
  • 反复 receive body:第二次拿到空内容。

追问

  • 多值头怎么取?答:按多值读取 API 获取列表,具体以 request API 为准。
  • 原始报文用于什么场景?答:签名校验、报文审计,注意留存合规期限。

06.8.1.1-076 响应状态码与响应头如何在拦截器中改写?

一句话结论

响应提交前可通过 call.response 设置状态码与头;拦截器在 proceed 前或后补充头,状态码由 Handler 或异常处理器确定;已提交后的改写不会生效。

概念解释

响应头适用于统一补充(应用标识、追踪头、缓存策略);状态码改写应谨慎,避免覆盖业务语义。后置拦截读到的是当前响应状态,最终以提交值为准。

原理流程

  1. 拦截器在响应提交前访问 response。
  2. 设置/追加状态码或头。
  3. proceed 后可读取最终状态做补充头。
  4. body 写出后不可再改响应元数据。

代码或图示

intercept(ApplicationCallPipeline.Plugins) {
    proceed()
    call.response.headers.append("X-Request-Id", requestId)
}

常见误区

  • 响应提交后改头:被忽略且造成困惑。
  • 统一在拦截器里把错误状态改成 200:破坏网关统计与客户端判断。

追问

  • 头能覆盖已存在的值吗?答:append 与 set 语义不同,按响应头 API 选择。
  • CORS 头由谁加?答:CORS 插件统一处理,不要在业务拦截器重复拼。

06.8.1.1-077 路由级插件与全局插件如何选择?

一句话结论

影响所有请求的横切能力(监控、序列化、安全基础)装全局;只作用于某业务子树的能力(分组认证、分组压缩、分组限流)挂到对应 route 节点;范围越小越贴近节点挂载。

概念解释

全局插件在应用管道装配,所有 Call 都会经过;节点级拦截只在该子树匹配后生效。选择挂载范围时先问「这条规则是否适用于全部请求」,避免把子树规则泄漏到公开接口。

原理流程

  1. 列出能力适用范围。
  2. 全局共性能力 install 到 Application。
  3. 子树专属能力挂父 route 作用域。
  4. 回归公开与受保护两组路径。

代码或图示

install(ContentNegotiation) { /* 全局 */ }

routing {
    route("/admin") {
        authenticate("admin") { /* 节点级 */ }
    }
}

常见误区

  • 把只给后台用的认证装全局:公开接口被拦。
  • 每个子节点重复写同样的拦截:应上提到父 route 复用。

追问

  • 节点级能力能下沉到孙节点吗?答:继承生效,孙节点不必重复挂。
  • 全局插件能读取路由信息吗?答:装配期无路由信息,请求期在匹配后可访问匹配结果,能力以实现为准。

06.8.1.1-078 如何给子路由单独安装认证或压缩?

一句话结论

在父 route 作用域内引用对应认证配置,或在子树拦截链上挂专属压缩/限流;子树内节点自动继承,公开兄弟路由不受影响;按业务域划分作用域边界。

概念解释

认证配置可命名后在多个子树引用;压缩等内容协商能力通常是全局插件,若需按路径区分压缩策略,应在节点拦截层判断路径后选择编码,能力边界以插件支持为准。

原理流程

  1. 在全局安装器里定义命名认证提供者。
  2. 受保护父 route 上引用认证名称。
  3. 子树处理器只面对已认证主体。
  4. 公开兄弟路由不引用认证。

代码或图示

route("/internal") {
    authenticate("service-jwt") {
        get("/metrics") { /* 仅内部 */ }
    }
}

常见误区

  • 认证名称拼错:子树未受保护且不报错,需测试暴露。
  • 压缩策略按子树切换时假设插件支持路径条件:未核对前自行在拦截层判断。

追问

  • 同一子树能否引用多套认证?答:可以组合,选择与回退规则见认证插件章节。
  • 子树专属限流怎么挂?答:节点拦截器按路径前缀计数,与全局限流分层。

06.8.1.1-079 WebSocket 长连接与普通请求在管道处理上有何差异?

一句话结论

普通 HTTP 请求一次请求一次响应后结束;WebSocket 在升级握手成功后保持双向长连接,会话对象在连接存活期间持续收发帧,管道拦截主要作用于握手阶段,帧消息处理在会话协程内进行。

概念解释

握手仍是一次 HTTP 请求,可被认证、CORS 等管道插件拦截;升级成功后进入 WebSocket 会话生命周期,连接取消对应会话关闭。长连接的并发模型、心跳与超时和短请求不同。

原理流程

  1. HTTP 握手请求经过常规管道拦截。
  2. 握手通过后协议升级,建立会话。
  3. 会话协程内循环接收/发送帧。
  4. 连接关闭或异常导致会话协程结束。

代码或图示

HTTP 握手(走管道) -> 升级 WebSocket -> 会话帧循环 -> 关闭清理

常见误区

  • 把请求级拦截逻辑直接套到帧消息上:握手后管道不再逐帧拦截。
  • 会话结束不清理订阅资源:连接断开后任务泄漏。

追问

  • 握手阶段怎么做认证?答:在握手请求的认证拦截中校验,通过后再升级。
  • 心跳与断线检测在哪配?答:会话配置层,具体参数见 WebSocket 插件章节。

06.8.1.1-080 静态资源的缓存头如何挂载?

一句话结论

静态资源响应通过缓存头插件或节点拦截设置 ETag/Last-Modified/Cache-Control;不可变资源长缓存,入口 HTML 与带版本的资源区别对待,目录穿越与类型校验仍然必须做。

概念解释

缓存策略分强缓存(Cache-Control max-age)与协商缓存(ETag/Last-Modified)。版本化静态资源可长缓存,未版本化资源用协商缓存避免发版陈旧。缓存头与静态资源映射配合在同一路由节点配置。

原理流程

  1. 识别资源是否内容版本化。
  2. 版本化资源设长 max-age 不可变。
  3. 其余资源设协商缓存头。
  4. 校验资源路径与类型后再响应。

代码或图示

// 缓存头插件按响应资源类型配置;具体 API 以 CachingHeaders 文档为准
install(CachingHeaders) { /* ... */ }

常见误区

  • 所有静态资源都长缓存:发版后客户端拿旧文件。
  • 只设缓存不校验路径:缓存不了安全问题,穿越风险仍在。

追问

  • 待确认:Ktor 3 缓存头插件的配置方式与可用取值,以官方文档核对。
  • 代理层缓存要注意什么?答:区分私有/共享缓存,按资源可公开性设置指令。

06.8.1.1-081 多环境配置如何注入引擎与模块?

一句话结论

配置按环境从配置文件、环境变量或启动参数解析,引擎端口与模块策略从同一配置源读取;代码只认 key 不取来源,测试与生产通过替换配置源切换,不写环境分支硬编码。

概念解释

环境差异包括端口、外部地址、开关、日志级别与凭据。配置优先级(命令行 > 环境变量 > 配置文件)在启动层合并;敏感值走环境变量或密钥管理,不进仓库配置。

原理流程

  1. 定义配置 key 与默认值。
  2. 启动环境按优先级加载配置源。
  3. 模块装配读取配置构造依赖。
  4. 测试注入测试配置覆盖。

代码或图示

val port = environment.config.propertyOrNull("app.port")?.getString()?.toInt() ?: 8080

常见误区

  • 在代码里 if (env == "prod") 分支:环境判断散落各处。
  • 凭据写进默认配置文件并提交仓库:泄露风险。

追问

  • 待确认:Ktor 3 配置文件格式与覆盖优先级,以官方配置文档为准。
  • 配置变更需要重启吗?答:静态装配配置需重启;可热更新的配置应显式设计刷新机制。

06.8.1.1-082 测试时如何构造可断言的应用上下文?

一句话结论

测试专用启动器装配模块函数,构造测试 Application 与客户端请求入口;断言响应状态、body 与主体,外部依赖替换为内存或 Mock 实现;不依赖真实端口与网络栈。

概念解释

可测试性来自模块函数可独立装配。测试上下文绕过真实引擎监听,直接在内存管道中推进请求。测试替身替换数据库、远程客户端,断言业务行为而非网络细节。

原理流程

  1. 测试构造应用装配,注入测试依赖。
  2. 通过测试客户端发起 GET/POST 等请求。
  3. 断言状态码、响应体与调用交互。
  4. 清理测试资源。

代码或图示

testApplication {
    val response = client.get("/users/1")
    assertEquals(HttpStatusCode.OK, response.status)
}

常见误区

  • 测试连真实外部服务:用例不稳定且污染数据。
  • 依赖真实端口冲突:并行测试互相干扰。

追问

  • 待确认:Ktor 3 测试启动器与客户端 API 名称,以官方测试文档为准。
  • 如何测试未认证路径?答:测试客户端不带凭据断言 401/403。

06.8.1.1-083 Ktor 与 Spring Boot 架构模型有何异同(仅对比提及)?

一句话结论

两者都提供装配、路由、插件生态与运行时;Ktor 以协程、管道与显式插件装配为核心,Spring Boot 以容器、依赖注入与注解生态为核心;本项目只做概念对比,不展开 Spring 通用题。

概念解释

Ktor 配置偏代码式 DSL,管道拦截显式;Spring 依赖容器管理 Bean 生命周期与自动装配。并发模型上 Ktor 原生协程,Spring 生态同时支持同步与响应式。选型看团队、生态集成与现有技术栈。

原理流程

  1. 对比装配方式:代码 DSL vs 容器自动装配。
  2. 对比横切能力:管道插件 vs AOP/过滤器。
  3. 对比并发模型:协程 vs 阻塞/响应式并存。
  4. 按集成需求与团队经验决策。

代码或图示

Ktor:Application + Pipeline + Plugin + 协程
Spring Boot:ApplicationContext + Bean 容器 + 注解生态

常见误区

  • 认为 Ktor 性能一定优于 Spring:实际取决于实现、阻塞比例与调优。
  • 把 Spring 注解习惯硬套到 Ktor:装配模型不同。

追问

  • 存量 Spring 体系内引入 Ktor 适合什么场景?答:独立轻量服务、协程密集网关等,按集成成本评估。
  • 对比题不在本节展开:Spring 细节见 06.2 分册。

06.8.1.1-084 嵌入式 Server 能否作为库内嵌到其他 JVM 程序?

一句话结论

可以:embeddedServer 返回引擎实例,可在宿主程序内启动、持有引用并受控关闭;适用于同进程附带 HTTP 管理端口、测试与工具程序,但要自行管理生命周期与停机钩子。

概念解释

嵌入式模式下服务不是独立 main 进程,而是宿主应用的一部分。引擎线程、端口与资源随宿主生命周期管理;宿主退出时必须释放引擎与共享客户端,避免端口与线程残留。

原理流程

  1. 宿主构造引擎实例并装配模块。
  2. 启动监听,持有引擎引用。
  3. 宿主业务运行期间服务对外提供接口。
  4. 关闭时停止引擎、释放资源后退出。

代码或图示

val engine = embeddedServer(Netty, port = 8081) { /* 内嵌接口 */ }
engine.start(wait = false)
// 宿主退出前:engine.stop(...)

常见误区

  • wait = true 放在宿主线程:阻塞宿主启动流程。
  • 宿主退出不调 stop:端口与后台线程残留。

追问

  • 待确认:引擎 stop 方法的超时参数与行为,以引擎 API 文档核对。
  • 内嵌多引擎实例可行吗?答:可行,端口与资源分别管理。

06.8.1.1-085 引擎线程数与并发吞吐是什么关系?

一句话结论

线程数决定可并行处理的阻塞单元数,协程在其上多路复用;纯异步场景线程数不必等于并发数,阻塞比例越高越需要工作线程;线程数过大增加上下文切换与内存,过小则排队,应以压测定值。

概念解释

事件循环 + 工作线程是常见划分:事件循环负责连接接受与 IO 就绪,工作线程跑请求处理。线程数不是越多越好,目标是 CPU 利用率饱和而不过度切换。下游慢响应主要靠异步与隔离,而非堆线程。

原理流程

  1. 压测基线:记录吞吐、延迟、线程池队列与阻塞比例。
  2. 调整线程数观察拐点。
  3. 区分 IO 等待与 CPU 密集分别调参。
  4. 结合下游容量设上限。

代码或图示

吞吐 ≈ 并行单元数 × 单单元处理速率(受下游与内存限制)

常见误区

  • 线程数按并发连接数照搬:协程模型下连接不占线程。
  • 只加线程不解决阻塞:上下文切换吃掉收益。

追问

  • 待确认:各引擎默认线程数配置项,以官方引擎文档核对。
  • 线程池监控看什么?答:活跃线程、队列长度、拒绝数、平均等待。

06.8.1.1-086 CIO 引擎适合什么场景?

一句话结论

CIO 是 Ktor 自研协程导向引擎,适合希望轻依赖、与协程模型对齐的服务;生产采用前需在目标负载下压测,并核对版本维护状态;不凭印象断言其性能优于其他引擎。

概念解释

引擎差异主要在网络实现与依赖:CIO 不绑定 Netty 生态依赖,模型贴合协程;Netty 生态成熟、资料多。选型应结合压测结果、依赖体积与团队排障经验,而非单点基准。

原理流程

  1. 列出候选引擎与依赖约束。
  2. 用典型报文与并发模型压测。
  3. 对比吞吐、延迟、内存与排障成本。
  4. 选定后业务代码保持引擎无关。

代码或图示

embeddedServer(CIO, port = 8080) { /* 业务代码与引擎解耦 */ }

常见误区

  • 认为自研引擎一定更快或更慢:基准受场景影响。
  • 忽略依赖体积:嵌入式分发场景需评估打包大小。

追问

  • 待确认:Ktor 3 中 CIO/Netty/Jetty 的维护状态与推荐场景,以官方文档为准。
  • 切换引擎要回归什么?答:线程行为、阻塞点、长连接与超时配置。

06.8.1.1-087 请求协程的结构化并发边界如何界定?

一句话结论

请求作用域内启动的子任务挂在请求 Job 下,随请求取消一起清理;脱离请求作用域的任务属于应用级生命周期,必须显式持有 Job 并在停机时取消,边界不能模糊。

概念解释

结构化并发保证「父取消则子取消、子失败按规则上报」。Handler 内 async 拉取多个依赖属于请求边界;后台轮询、订阅推送属于应用边界。跨边界传递引用会导致取消失控。

原理流程

  1. 任务按生命周期归类:请求级或应用级。
  2. 请求级任务在请求作用域内启动。
  3. 应用级任务挂应用根 Job,登记停机取消。
  4. 定期核对活跃任务归属。

代码或图示

// 请求级:随请求结束
coroutineScope { async { /* 依赖调用 */ } }

// 应用级:在装配期启动,停机取消

常见误区

  • 后台任务用请求作用域启动:请求结束被误取消。
  • 请求任务用全局作用域启动:取消不到,泄漏。

追问

  • 子任务失败如何影响主请求?答:按 Job 传播规则,supervisor 场景子失败不波及兄弟,需按设计选择。
  • 待确认:Ktor 3 请求作用域 Job 的可访问方式,以源码/文档核对。

06.8.1.1-088 慢下游调用如何隔离避免拖垮请求管道?

一句话结论

为下游调用设独立超时与隔离线程池/并发上限,熔断降级;慢调用不占住请求工作线程,失败快速返回兜底结果,避免级联排队把整个管道压垮。

概念解释

慢下游是后端雪崩常见起点:线程被等待占满,新请求排队。隔离手段包括超时、并发舱壁、熔断与降级;异步客户端配合协程等待,阻塞客户端切到隔离调度器。各下游独立配额,互不挤占。

原理流程

  1. 识别所有远程/慢依赖。
  2. 配置超时、重试与并发上限。
  3. 隔离线程池或调度器,限制阻塞扩散。
  4. 超时/熔断后返回降级响应,记录指标。

代码或图示

val result = withTimeoutOrNull(1_500) { remote.fetch() }
    ?: fallback()

常见误区

  • 所有下游共用一个无界线程池:一个慢依赖拖垮全部。
  • 重试叠加超时:放大下游压力,雪上加霜。

追问

  • 重试策略怎么配?答:有限次数、退避、只对可重试错误重试,配合熔断。
  • 隔离池满了怎么办?答:快速失败降级,而不是无限排队。

06.8.1.1-089 插件之间如何通过 attributes 协作共享对象?

一句话结论

先安装的插件把进程级对象写入 Application attributes,后安装的插件或 Handler 按类型化 Key 取出;Key 统一命名定义,取值判空,共享对象保证线程安全,请求级数据不走该通道。

概念解释

插件协作常见场景:认证插件放主体、监控插件放 trace 标识、基础设施插件放客户端。共享表是装配期约定,Key 类型安全;插件卸载/重复安装时注意对象生命周期。

原理流程

  1. 定义共享 AttributeKey 与对象类型。
  2. 生产插件装配时写入。
  3. 消费插件在拦截器或 Handler 读取。
  4. 对象生命周期随 Application,停机时释放。

代码或图示

val TraceKey = AttributeKey<String>("TraceId")

// 生产侧
call.attributes.put(TraceKey, traceId)
// 消费侧
val traceId = call.attributes[TraceKey]

常见误区

  • 用字符串键跨插件传对象:强转失败且易重名。
  • 把可变请求对象存进程 attributes:并发污染。

追问

  • 待确认:Ktor 3 attributes 读写 API 的可空行为,以官方文档核对。
  • 插件顺序影响协作吗?答:影响,消费插件必须在生产插件之后的阶段读取。

06.8.1.1-090 全局异常处理与处理器内局部异常的优先级如何?

一句话结论

Handler 内 try-catch 先捕获局部异常;未捕获的异常向上传播到全局异常处理插件;全局处理器只兜未处理情形,局部 catch 不应吞掉异常不记录,避免与全局映射冲突。

概念解释

局部处理适合需要结合上下文做分支的场景;统一状态映射、日志与响应结构放全局。两层职责分明:局部决策业务分支,全局塑造错误响应与兜底记录。

原理流程

  1. Handler 内捕获可预期局部异常并处理。
  2. 未处理异常继续向上抛。
  3. 全局 StatusPages 匹配类型映射响应。
  4. 兜底未识别异常为 500 并记录堆栈。

代码或图示

try {
    orderService.place()
} catch (e: OutOfStockException) {
    // 局部业务分支
}
// 其余异常由全局 StatusPages 映射

常见误区

  • 局部 catch 后返回 200 空响应:全局映射被绕过。
  • 全局处理器重复局部已处理的状态:行为不一致。

追问

  • 异步子协程异常走全局吗?答:取决于传播到请求作用域的方式,未冒泡的需自行记录。
  • 待确认:StatusPages 与引擎兜底异常的先后顺序,以插件实现核对。

06.8.1.1-091 Ktor 2 升到 3 时项目级迁移应分哪几步?

一句话结论

先升级依赖与编译,清理弃用 API,再逐模块核对插件、引擎与上下文行为,补充并发路径测试,最后压测观察线程与取消行为;每步可回滚,不一次性推翻全部装配。

概念解释

大版本迁移风险集中在弃用 API、插件坐标、线程模型与协程上下文。项目级步骤:依赖升级 -> 编译告警清零 -> 插件替换 -> 测试回归 -> 性能基线对比。版本行为不确定处查官方迁移文档。

原理流程

  1. 对齐 Kotlin 与 Ktor 版本基线。
  2. 编译收集弃用/移除告警并替换。
  3. 核对自定义插件与引擎集成 API。
  4. 回归测试与压测,对比延迟、线程与泄漏。

代码或图示

迁移步骤:依赖升级 -> 编译修复 -> 插件核对 -> 测试回归 -> 压测对比 -> 灰度发布

常见误区

  • 直接升版本不跑回归:并发与取消问题只在运行时暴露。
  • 跳过官方 changelog 凭经验改 API:改名/移除点遗漏。

追问

  • 待确认:Ktor 3 对 Kotlin 版本、JDK 版本的基线要求,以官方发布说明核对。
  • 哪些模块优先迁移?答:独立、依赖少的服务先行,沉淀插件适配经验。

06.8.1.1-092 哪些旧特性在 Ktor 3 中可能被移除或改名(待确认)?

一句话结论

不能凭记忆列举移除清单:应以官方 2.x 到 3.x 迁移指南与编译告警为准;常见核对方向包括旧插件描述符、弃用的启动器扩展、上下文工具与引擎配置项,未核实前均标「待确认」。

概念解释

面试中编造被删除类名、插件坐标属于硬伤。正确做法是说明核对路径:编译告警 -> 迁移文档 -> 源码引用;不确定的 API 在答案中标注待确认并写出验证点。

原理流程

  1. 编译工程,收集所有弃用与 unresolved 告警。
  2. 查官方迁移指南对应条目。
  3. 在源码/依赖 jar 中核对符号是否存在。
  4. 记录替代 API 与行为差异。

代码或图示

验证点:
- 旧 ApplicationPlugin 描述符是否仍可用
- 启动器/引擎工厂签名是否变化
- 弃用扩展函数的替代写法

常见误区

  • 把 2.x 笔记里的类名当 3.x 现状写进答案。
  • 看到编译通过就认为 API 行为一致:弃用 API 可能行为已变。

追问

  • 待确认:具体移除/改名清单,查 Ktor 官方 migration 文档与发布说明逐条核对。
  • 如何记录差异?答:在本项目知识库中标注版本与验证日期,后续升级复核。

06.8.1.1-093 Application 关闭时各类资源按什么顺序释放?

一句话结论

逆序释放:先停止接收新流量与后台定时任务,再关闭对外客户端与连接池,最后释放本地文件与缓存;释放绑定应用停止事件,每个资源关闭要容错并记录失败,避免一个释放失败阻断其余。

概念解释

资源释放顺序与装配顺序相反:后创建的先关。后台协程先取消并等待结束,再关连接池,避免池关闭后任务仍借池调用。关闭过程设超时,不无限等待僵死资源。

原理流程

  1. 应用停止事件触发。
  2. 取消后台 Job 并等待结束。
  3. 关闭远程客户端、消息消费者与连接池。
  4. 清理本地临时文件与缓存,记录释放结果。

代码或图示

application.monitor.subscribe(ApplicationStopping) {
    background.cancel()
    httpClient.close()
}

常见误区

  • 先关池再等后台任务:任务借已关闭池报错。
  • 一个资源关闭抛异常中断后续释放:其余资源泄漏。

追问

  • 待确认:Ktor 3 停止事件类型与回调时机,以官方文档核对。
  • 释放超时怎么办?答:设上限强制退出并告警,记录未释放资源。

06.8.1.1-094 如何生成 trace id 并贯穿拦截链与日志?

一句话结论

请求入口从传入头取或生成 trace id,放入 Call 属性与响应头;后续拦截器、Handler 与日志都从属性读取,日志输出统一带该标识;跨服务调用随请求头透传。

概念解释

trace id 是排障串联一次请求全链路的键。入口决定生成还是复用上游传入值;日志 MDC 或结构化字段写入标识。响应回写 trace id 便于客户端报障对应。注意不要把敏感信息写进标识。

原理流程

  1. 入口拦截读取上游 trace 头,缺失则生成。
  2. 存入 Call 属性并追加到响应头。
  3. 日志输出携带标识字段。
  4. 出站调用把标识写入请求头透传。

代码或图示

val traceId = call.request.headers["X-Trace-Id"] ?: UUID.randomUUID().toString()
call.attributes.put(TraceKey, traceId)
call.response.headers.append("X-Trace-Id", traceId)

常见误区

  • 每个拦截器各自生成 id:链路断裂。
  • 日志不带标识:无法跨拦截器与服务串起来。

追问

  • 待确认:Ktor 3 日志 MDC 集成方式,以日志插件文档核对。
  • 跨服务透传什么头?答:按网关/链路追踪约定的请求头,统一命名。

06.8.1.1-095 路径编码与非 ASCII 字符如何处理?

一句话结论

URL 路径段按百分号编码传输,框架解码后再做参数匹配;中文、空格等字符在路径中应先编码,解码后的参数再做业务校验;不要把原始未编码片段直接拼到文件系统或 SQL。

概念解释

编码不一致会导致匹配失败、参数乱码或注入风险。路径参数取出时已是解码后字符串;文件名、查询条件等下游使用前再做白名单校验。前后端统一编码规则,特殊字符走规范转义。

原理流程

  1. 客户端按 URL 规则编码路径与查询。
  2. 引擎解码得到段文本。
  3. 路由参数捕获解码后的值。
  4. 业务使用前校验字符集与边界。

代码或图示

/用户/中文  -> 编码后路径 -> 引擎解码 -> 参数值按 UTF-8 校验

常见误区

  • 假设路径参数天然安全:解码后仍需防穿越与注入。
  • 双重编码未识别:参数出现残留百分号转义。

追问

  • 待确认:Ktor 3 路径解码字符集与异常处理行为,以官方文档核对。
  • 文件名含中文怎么存?答:解码后规范化,存储名与展示名分离。

06.8.1.1-096 为什么 GET 请求不应携带业务请求体?

一句话结论

GET 语义是安全幂等的资源读取,代理、缓存与预取可能只按 URL 缓存或重放 GET;把业务参数放 body 会被中间件忽略、缓存错乱或被预取触发副作用,写操作必须用 POST/PUT/DELETE 等方法。

概念解释

HTTP 方法语义约束请求用途。GET body 虽然技术上可被某些服务读取,但并非所有客户端与代理都转发或保留 body,兼容性不可靠。查询条件放查询参数,复杂入参才用带 body 的方法。

原理流程

  1. 按操作语义选择方法:读取用 GET,写操作用对应动词。
  2. GET 参数放查询串。
  3. 复杂入参通过 POST 等携带 body。
  4. 网关与缓存按方法语义处理。

代码或图示

GET  /users?page=1&size=20   读取
POST /users                   创建(body 入参)

常见误区

  • 用 GET 提交敏感查询:URL 与代理日志记录参数。
  • 依赖 GET body 传复杂对象:中间链路行为不可控。

追问

  • 复杂查询入参怎么办?答:用 POST 查询类接口或接受查询参数限制,按团队 API 约定。
  • GET 能缓存什么?答:可缓存响应按 URL 与头,body 不参与缓存键。

06.8.1.1-097 启动期并发注册路由是否存在线程安全问题?

一句话结论

路由注册在装配阶段、引擎接收请求之前完成,正常装配路径不存在并发注册;请求开始后不应动态改路由表。若在运行期动态注册,需自行保证结构一致性,框架不承诺运行期可变路由安全。

概念解释

装配期单线程式遍历模块函数构建路由树,请求处理与注册在时间上分离。运行期动态加路由属于非常规需求,节点结构变更可能影响正在匹配的请求,应在启动期完成或用独立重载流程。

原理流程

  1. 模块装配阶段注册全部节点。
  2. 引擎启动后路由表视为只读。
  3. 运行期不修改节点集合。
  4. 需要动态能力时前置装配或重启重载。

代码或图示

装配期:构建路由树(单进程装配流程)
启动后:只读匹配,不动态改表

常见误区

  • 在请求 Handler 里动态加路由:结构与可见性不可控。
  • 多线程并行 install 模块:装配顺序与可见性未定义。

追问

  • 待确认:Ktor 3 路由表是否支持运行期修改及同步策略,以源码/文档核对。
  • 动态租户路由怎么做?答:启动期按已知租户装配,或用通配参数在 Handler 内分发。

06.8.1.1-098 场景:为一组内部接口统一加鉴权与日志,管道如何组织?

一句话结论

内部接口收拢到同一父 route:外层认证拦截校验服务凭据,节点拦截补充访问日志与内部标识,子节点只写业务;公开接口放兄弟分支不受保护,测试枚举两组路径回归。

概念解释

该场景是节点级管道的典型应用:认证与日志作为父节点包裹层,业务子树复用。内部调用凭据、主体类型与日志字段在父层统一,避免子节点重复实现。

原理流程

  1. 划分公开与内部父路由。
  2. 内部父节点挂认证引用。
  3. 父节点拦截记录主体、路径与耗时。
  4. 子节点 Handler 读取已认证主体。

代码或图示

route("/internal") {
    authenticate("service") {
        intercept(ApplicationCallPipeline.Call) { /* 内部访问日志 */ }
        get("/health") { /* 业务 */ }
    }
}

常见误区

  • 鉴权写在每个内部 Handler:新增接口易漏。
  • 日志在认证前记录匿名内部调用:主体字段缺失。

追问

  • 内部接口被外部网关暴露怎么办?答:网络层隔离 + 认证双重校验,网关不转发无凭据请求。
  • 日志记什么字段?答:主体标识、调用方、路径、状态、耗时;不记凭据明文。

06.8.1.1-099 场景:接口返回 500 但日志无堆栈,如何沿管道排查?

一句话结论

先确认异常是否被某层吞掉:沿管道从 Handler 向上找局部 catch、全局异常处理器与引擎兜底;补全未捕获异常日志,核对异步子协程异常是否冒泡;复现请求并保留 trace id 对照日志。

概念解释

无堆栈 500 常见原因:局部 catch 后空响应、异常处理器只记状态不记 cause、异步任务异常未回传、日志级别过滤。排查从响应生成点反向追溯到异常抛出点,逐层补日志。

原理流程

  1. 用 trace id 定位本次请求全部日志。
  2. 检查 Handler 与拦截器是否有吞异常的 catch。
  3. 核对全局处理器是否记录 cause 堆栈。
  4. 检查异步子协程异常是否独立处理未上报。

代码或图示

排查链:500 响应 -> StatusPages 处理器 -> 局部 catch -> 异步子协程 -> 引擎兜底

常见误区

  • 只在处理器里记状态码不记 cause:无法定位根因。
  • 子协程异常无人消费:崩溃静默。

追问

  • 如何补全兜底日志?答:全局处理器记录 cause 与请求标识,异步任务异常显式回传或记录。
  • 日志级别过滤导致看不到?答:核对生产日志级别与采样策略。

06.8.1.1-100 选型:什么场景下 Ktor 比传统 MVC 框架更合适?

一句话结论

协程密集、轻依赖、需要灵活管道与多端复用(服务端/客户端)的场景适合 Ktor;重注解生态、成熟企业集成与团队既有的 MVC 体系则传统框架更稳;选型以团队能力、生态集成与压测结果为准。

概念解释

Ktor 优势在 DSL 装配、原生协程、客户端/服务端同构与较轻依赖;传统 MVC 框架胜在自动装配、插件生态、招聘与资料积累。框架不决定系统成败,架构边界、异步模型与运维成熟度更关键。

原理流程

  1. 梳理业务并发模型与集成需求。
  2. 评估团队 Kotlin/协程经验与生态可得性。
  3. 做概念验证与压测对比。
  4. 按长期维护成本决策,不追逐单点热点。

代码或图示

倾向 Ktor:协程高并发、轻量网关、客户端服务端复用
倾向传统框架:企业生态集成、既有团队与存量体系

常见误区

  • 只凭性能传闻选型:未结合自身阻塞比例与下游容量。
  • 忽视团队学习成本:协程与管道模型需要适应期。

追问

  • 存量系统能混用吗?答:可按服务边界拆分,新服务试点,接口契约保持一致。
  • 待确认:Ktor 3 生态中各集成组件的成熟度,按实际依赖清单核对官方与社区状态。

参考来源

待整理清单

  • [ ] 核对 Ktor 3 管道阶段常量名称与执行顺序(对照官方 pipeline 文档与源码)
  • [ ] 核对自定义插件 createApplicationPlugin 钩子与阶段对应关系
  • [ ] 核对各引擎默认线程数、请求体上限与优雅停机配置参数
  • [ ] 核对静态资源挂载、缓存头与 multipart 部件遍历的 3.x API 名称
  • [ ] 核对 2.x 到 3.x 迁移清单:移除/改名插件、启动器与上下文 API
  • [ ] 补充本项目实际工程中的模块划分、拦截器顺序与配置示例