07.1.1.9.1 OkHttp 拦截器链与连接池
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.1 原生移动开发 / 07.1.1 Android / 07.1.1.9 网络栈与序列化
本节要解决的问题
本节沿一次真实请求的执行路径展开:从 Dispatcher 调度、拦截器链逐层处理,到连接池复用、缓存判定、超时划分、DNS 与代理,再到 HTTP/2 多路复用、TLS 校验、事件监听与重试去重。面试重点在「每层组件负责什么、链路如何串起来、复用条件与坑点在哪里」。版本基线:OkHttp 4.x(Kotlin 实现)、Android 14 / compileSdk 34;版本敏感行为标「待确认」并写明验证点。
07.1.1.9.1-001 OkHttp 一次请求的整体执行链路是怎样的?
一句话结论
请求从业务调用 Call 开始,经 Dispatcher 调度,穿过一串拦截器(应用拦截器、内置桥接/缓存/连接/协议拦截器、网络拦截器),再由连接池取出或新建 TCP/TLS 连接发出报文,最后把响应沿拦截器链逐层返回。
概念解释
OkHttp 把一次 HTTP 交互拆成「调度—链式处理—连接—协议」四段:业务层只看到 Call,中间的拦截器链与连接池对上层透明。链路是单向贯穿的,请求向下传、响应向上回,异常沿链反向传播。
原理流程
业务调用 client.newCall(request).enqueue(...)
→ Dispatcher 排队或分配线程
→ 应用拦截器 interceptors
→ BridgeInterceptor / CacheInterceptor / ConnectInterceptor / CallServerInterceptor
→ 连接池取连接 → DNS → TLS 握手 → 发送报文 → 读取响应
→ 网络拦截器 networkInterceptors
→ 响应体交回业务层
代码或图示
val client = OkHttpClient.Builder().build()
val call = client.newCall(
Request.Builder().url("https://example.com/api").get().build()
)
常见误区
- 认为拦截器是并行执行的;实际是一条递归调用链,顺序固定。
- 认为连接池在拦截器之前;实际取连接发生在 ConnectInterceptor 阶段。
追问
- 同步与异步请求走的是不是同一条链?答:是同一条拦截器与连接链路,区别只在 Dispatcher 用线程直接执行还是丢进调度队列。
- 响应体为什么必须关闭?答:底层套接字只有在流被消费完毕或关闭后才会归还连接池复用。
07.1.1.9.1-002 OkHttp 的应用层、连接层与协议层分别由哪些组件负责?
一句话结论
应用层负责请求语义与业务横切(拦截器、Call、Dispatcher),连接层负责套接字与复用(ConnectionPool、StreamAllocation),协议层负责报文编解码与协商(HTTP/1、HTTP/2、TLS、WebSocket)。
概念解释
分层对应源码包中的职责划分:Call 与 RealCall 是入口;Interceptor 链是横切处理;RouteSelector、StreamAllocation、ConnectionPool 处理路由与连接;Http1ExchangeCodec、Http2ExchangeCodec 处理协议编解码。上层不感知下层用的是哪个协议。
原理流程
语义层:Request/Response/Call/Interceptor
→ 资源层:RouteSelector(DNS/代理)、StreamAllocation、ConnectionPool
→ 协议层:Codec(HTTP/1 或 HTTP/2)、TLS、WebSocket
代码或图示
RealCall → RetryAndFollowUpInterceptor → BridgeInterceptor
→ CacheInterceptor → ConnectInterceptor → CallServerInterceptor
常见误区
- 把
Connection当成套接字本身;它是对一条底层连接与其状态的封装。 - 认为 HTTP/2 与 HTTP/1.1 的拦截器链不同;拦截器顺序一致,差异在 Codec。
追问
- StreamAllocation 是什么角色?答:它为一次交换(exchange)分配流,管理连接、路由与释放时机,是连接层与协议层之间的调度者。
- 协议层切换需要改拦截器吗?答:不需要,协议由连接协商结果决定,Codec 内部切换。
07.1.1.9.1-003 OkHttpClient 在应用内应如何持有与共享?
一句话结论
OkHttpClient 应作为进程内单例共享,因为内部持有连接池、线程池与缓存,重复 new 等于重复创建套接字与线程资源;需要差异化配置时用 newBuilder() 派生。
概念解释
客户端对象的成本主要不在构造本身,而在它聚合的 ConnectionPool、Dispatcher 线程池、Cache 与事件监听注册表。共享客户端才能让连接复用跨请求生效;派生客户端默认复用同一池与线程池。
原理流程
全局单例 client
├─ 派生 clientA: client.newBuilder().readTimeout(...)
├─ 派生 clientB: client.newBuilder().addInterceptor(...)
└─ 底层连接池 / 线程池仍共享
代码或图示
object Net {
val client: OkHttpClient by lazy {
OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.build()
}
}
常见误区
- 每个页面 new 一个 client,导致连接池无法复用、线程数膨胀。
- 认为
newBuilder()会复制一份连接池;实际派生客户端与原客户端共享池与线程池。
追问
- 不同业务要隔离连接池怎么办?答:为该业务单独构造
ConnectionPool并挂到独立 client 上,而非派生。 - 单例 client 持有的内存会在退出后释放吗?答:进程结束由系统回收;进程内长期驻留是设计预期。
07.1.1.9.1-004 Request、Response 与 Call 三个对象各自承载什么?
一句话结论
Request 是不可变的出站请求描述(方法、URL、头、体),Response 是不可变的入站响应(码、头、体、握手信息),Call 是一次请求的可执行句柄,负责发起、取消与跟踪生命周期。
概念解释
Request/Response 是数据载体,RealCall 是执行器。一个 Call 对应一次发起(重试与重定向在链内完成,对业务仍表现为同一个 Call)。响应体 ResponseBody 是流式资源,必须显式关闭或在使用后释放。
原理流程
Request 构建 → newCall(Request) 得到 Call
→ Call.execute()/enqueue() → 内部产出 Response(含 ResponseBody)
代码或图示
val request = Request.Builder().url(url).header("Accept", "application/json").build()
val call = Net.client.newCall(request)
val response = call.execute()
response.body?.close()
常见误区
- 把
Response当成可缓存的快照;其 body 是流,读完即失效。 - 复用同一个 Call 发起第二次请求;Call 一旦执行即不可重复使用。
追问
- Call 为什么不可重复执行?答:内部状态机记录了是否已执行、是否已取消,重复执行会抛异常。
- Request 的 body 可以在拦截器中替换吗?答:可以通过新构建的 Request 替换,原对象不可变。
07.1.1.9.1-005 Call 的同步 execute 与异步 enqueue 有什么区别?
一句话结论
execute() 在调用线程阻塞直到响应返回,enqueue() 把任务交给 Dispatcher 线程池异步执行,回调在工作线程触发;两者共享同一条拦截器与连接链路。
概念解释
同步调用适合自管理线程的场景(如协程内阻塞桥接),异步调用适合直接挂回调的旧写法。Android 主线程禁止网络访问,无论哪种方式都不能在主线程直接 execute()。异步回调的 onResponse/onFailure 跑在 Dispatcher 工作线程,更新 UI 要切回主线程。
原理流程
execute(): 调用线程 → 直接进入拦截器链 → 阻塞等待 Response
enqueue(): Dispatcher 队列 → 工作线程 → 拦截器链 → Callback.onResponse/onFailure
代码或图示
call.enqueue(object : Callback {
override fun onFailure(call: Call, e: IOException) { /* 工作线程 */ }
override fun onResponse(call: Call, response: Response) { /* 工作线程 */ }
})
常见误区
- 在
onResponse里直接操作 View;回调不在主线程。 - 用
execute()配合线程池却忘了关闭响应体,导致连接无法复用。
追问
- 异步任务排队时取消是否生效?答:生效,取消后未执行的任务不会进入链,在途任务中断后回调
onFailure。 - suspend 接口底层用哪种方式?答:Retrofit 的 suspend 适配在内部用异步调用桥接协程取消,不直接阻塞调用线程。
07.1.1.9.1-006 Dispatcher 在请求调度中处于什么位置?
一句话结论
Dispatcher 是客户端的请求调度器,负责维护同步/异步任务集合、控制并发上限、管理排队队列与执行线程池;它在进入拦截器链之前决定「何时跑、谁来跑」。
概念解释
对异步任务,Dispatcher 用 ready/running 两个集合跟踪排队与在途任务,达到最大并发后新任务入队,在途任务完成后再从队列提升。同步任务直接由调用线程执行,不占异步并发额度。
原理流程
enqueue → 若 runningAsyncCalls < maxRequests 则入 running 并提交线程池
否则入 ready 队列等待
在途完成 → promoteCalls() 从 ready 提升任务执行
代码或图示
val dispatcher = Dispatcher().apply {
maxRequests = 64
maxRequestsPerHost = 5
}
val client = OkHttpClient.Builder().dispatcher(dispatcher).build()
常见误区
- 把 Dispatcher 当成拦截器之一;它在链外调度。
- 认为并发上限对同步请求同样生效;同步请求不走该额度。
追问
- maxRequestsPerHost 的作用是什么?答:限制同一主机的在途并发,避免把单个服务打满,连接池侧也按主机分组。
- 排队任务可以按优先级调整吗?答:Dispatcher 不提供优先级 API,需要优先级要在业务队列层排序后再提交。
07.1.1.9.1-007 OkHttp 4.x 相对 3.x 在 API 上有什么变化?
一句话结论
4.x 用 Kotlin 重写了核心实现,对外 Java/Kotlin 调用面大体兼容,主要变化是部分接口改成 Kotlin 风格(如内联扩展、TimeUnit 配合的 Kotlin DSL 友好方法),行为上修复了若干连接与协议问题。
概念解释
OkHttp 4.x 保留 3.x 的公开 API 兼容层以降低迁移成本,内部类与协程化调整较多;具体废弃方法与新增方法以官方迁移说明为准。版本敏感的枚举、默认超时与线程数行为标「待确认」,需对照实际所用小版本的 changelog 验证。
原理流程
3.x(Java 实现)→ 4.x(Kotlin 重写,兼容公开调用面)
→ 业务迁移:依赖坐标不变,方法签名按编译器告警核对
代码或图示
// 4.x 下常见的 Kotlin 友好写法
val client = OkHttpClient.Builder()
.callTimeout(Duration.ofSeconds(10)) // 重载是否存在于当前小版本:待确认,需查 API 文档
.build()
常见误区
- 认为 4.x 与 3.x 包名不同;坐标与包名保持延续。
- 直接按博客里的 3.x 代码替换到 4.x 而不看编译告警,容易用到已废弃签名。
追问
- 4.x 是否强制要求 Kotlin 运行时?答:Kotlin 标准库随产物带入,Java 项目仍可调用其兼容 API。
- 哪个版本开始要求 Android 最低版本?答:具体 minSdk 要求随小版本演进,以官方发布说明为准(待确认)。
07.1.1.9.1-008 为什么 OkHttp 默认基于连接复用而不是每次新建 Socket?
一句话结论
新建 TCP 连接要经历 DNS、三次握手、TLS 握手与协议协商,成本远高于一次请求本身;连接池保留空闲连接供后续请求复用,把多次往返压缩为一次流交换。
概念解释
移动端弱网下握手开销可能占首字节时间的一半以上。复用连接可省去 DNS 与 TLS 往返;HTTP/2 进一步在一条连接上多路并发流。连接复用的前提是同一「路由」(主机、端口、协议、代理、TLS 配置)可匹配。
原理流程
请求到来 → 连接池查找可复用空闲连接
→ 命中:直接分配流 → 复用已完成握手的套接字
→ 未命中:DNS/握手/建连 → 用完放回池内等待复用
代码或图示
未复用:DNS + TCP + TLS + 发送请求(多次 RTT)
复用: 直接发送请求(零握手 RTT)
常见误区
- 认为只要同域名就能复用;路由键还包含端口、代理与安全配置。
- 复用连接后 TLS 会话会重新协商;实际复用已建立的会话与密钥。
追问
- 复用连接对首字节时间的收益如何量化?答:对比含握手与不含握手两次请求的
connectStart/connectEnd与首字节时间差,结合 EventListener 统计。 - 移动网络下长连接为什么不一定划算?答:运营商 NAT 与基站切换会让空闲连接失效,keepAlive 需配合超时与失效重试。
07.1.1.9.1-009 一个 HTTP 请求从业务调用到收到字节经过哪些阶段?
一句话结论
依次经过:调度排队、应用拦截器、桥接补全、缓存判定、连接获取(DNS/代理/TLS)、协议发送、响应读取、网络拦截器回传;每个阶段都有可观测的时间点。
概念解释
阶段划分与 EventListener 的回调一一对应:callStart、proxySelectStart/End、dnsStart/End、connectStart/End、secureConnectStart/End、connectEnd、requestHeadersStart/End、responseHeadersStart/End、responseBodyEnd、callEnd。把这些时间点连起来即可定位慢在哪一段。
原理流程
callStart → proxySelect → dns → connect(TCP) → secureConnect(TLS)
→ requestHeaders → responseHeaders → responseBody → callEnd
代码或图示
override fun callStart(call: Call) { startedAt = System.nanoTime() }
override fun callEnd(call: Call) { /* 汇总各阶段耗时 */ }
常见误区
- 把「首字节」等同于「连接建立」;首字节在响应头到达时,连接早在此前已完成。
- 忽略 DNS 与代理选择阶段,慢网问题只盯握手。
追问
- 哪个阶段最容易在弱网下被放大?答:DNS 解析与 TLS 握手,往返次数多、丢包敏感。
- 响应体读取慢属于哪个阶段?答:
responseBodyEnd区间内,受带宽与服务端推送速度影响。
07.1.1.9.1-010 OkHttp 相比原生 HttpURLConnection 解决了什么问题?
一句话结论
OkHttp 在原生连接能力之上提供了连接池、拦截器链、HTTP/2、缓存、超时统一控制、事件监听与压缩等工程能力,而 HttpURLConnection 只暴露低层套接字交互,复用与横切逻辑都要自己写。
概念解释
HttpURLConnection 是系统提供的基础客户端,连接管理、重定向跟随、缓存策略与并发控制都需手动实现;OkHttp 把这些沉淀为默认行为并可配置。现代 Android 应用基本以 OkHttp 作为底层 HTTP 引擎,Retrofit 也构建在其上。
原理流程
HttpURLConnection: 手动 openConnection → 手动读流 → 手动关闭,无内建连接池
OkHttp: 单例客户端内建池/缓存/拦截器/协议协商,业务只描述请求
代码或图示
原生:URL.openConnection() → setRequestProperty → getInputStream → 逐行读
OkHttp:Request.Builder → newCall → execute/enqueue → Response.body
常见误区
- 认为 OkHttp 只是「封装得更好看」;核心差异在连接管理与协议层能力。
- 认为系统客户端默认支持 HTTP/2;协议协商能力依赖实现版本,OkHttp 提供可控支持。
追问
- 为什么 Android 上多数网络库底层仍是 OkHttp?答:成熟的连接复用、拦截器生态与兼容性,且可被 Retrofit、图片库等复用。
- 还有哪些底层客户端可选?答:原生
HttpURLConnection、java.net.http.HttpClient(Android 上可用性受限,待确认版本支持)、各类自研原生栈;选型需结合 minSdk。
07.1.1.9.1-011 拦截器链(Interceptor Chain)是如何串联执行的?
一句话结论
链上每个 Interceptor 持有 Interceptor.Chain,实现里先做前置处理,再调用 chain.proceed(request) 拿到下游 Response,最后做后置处理;所有拦截器按注册顺序组成一条递归调用链。
概念解释
链是职责的线性叠加:请求从第一个拦截器逐层向下,响应沿相反方向逐层返回。内置拦截器按固定顺序插入在应用拦截器与网络拦截器之间,业务拦截器只能插在两端。
原理流程
interceptor1.intercept(chain)
→ 前置处理 req1
→ chain.proceed(req1)
→ interceptor2.intercept(chain)
→ ... 下游 ...
← resp2
→ 后置处理 resp1
← 回到调用方
代码或图示
class LoggingInterceptor : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response {
val req = chain.request()
val resp = chain.proceed(req)
return resp
}
}
常见误区
- 以为拦截器并行处理请求;实际是顺序递归,前一个不 proceed 后面就不会执行。
- 把多个拦截器的职责写成重复横切,导致头被重复追加。
追问
- 链上能否拿到上一个拦截器改过的请求?答:能,
chain.request()反映的是当前链节点收到的请求,即上游修改后的结果。 - 内置拦截器顺序可以调整吗?答:不可以,内置顺序是固定契约,业务只能在外围追加。
07.1.1.9.1-012 chain.proceed 的语义是什么,为什么必须调用一次?
一句话结论
proceed 把请求交给链的下一环并阻塞等待其 Response;每个拦截器在一次 intercept 中语义上应恰好 proceed 一次,不 proceed 等于短路,多次 proceed 会发起多次下游交换。
概念解释
proceed 是链的「继续执行」入口:它返回的 Response 是下游全部处理后的结果。短路拦截器直接构造 Response 返回而不 proceed;放行拦截器必须 proceed。拦截器中可在 proceed 前后分别改请求与改响应。
原理流程
intercept(chain):
可选:改 request
resp = chain.proceed(新请求) // 向下游传递,阻塞取响应
可选:改 response
return resp
代码或图示
override fun intercept(chain: Interceptor.Chain): Response {
val original = chain.request()
val newReq = original.newBuilder().header("X-Trace", "abc").build()
return chain.proceed(newReq)
}
常见误区
- 忘记调用 proceed 又没有自己返回响应,导致链断开且无响应。
- 一个拦截器内反复 proceed 做「重试」,使下游发出重复请求且共享同一个 Call 状态。
追问
- proceed 抛出的异常属于哪一层?答:沿链反向传播到 Call 调用方,由
onFailure或 execute 抛出。 - 可以在 proceed 后再替换请求吗?答:不能,请求向下游传递在 proceed 时已完成,后置只能改响应。
07.1.1.9.1-013 应用拦截器与网络拦截器有什么区别?
一句话结论
应用拦截器注册在 interceptors,只被调用一次、看不到重定向与重试的中间响应;网络拦截器注册在 networkInterceptors,贴近连接,能看到链路产生的每个交换(含跟随重定向的逐跳响应),但在缓存命中时可能不执行。
概念解释
两者插入点不同:应用拦截器在链的最外层,收到的是业务原始请求;网络拦截器在 CallServer 之前,收到的是桥接/缓存处理后的请求,看到的是真正发往网络的报文。缓存直接命中时,网络拦截器不被调用。
原理流程
业务 → 应用拦截器 → 内置链(含缓存判定)→ 网络拦截器 → 连接 → 服务端
缓存命中:业务 → 应用拦截器 →(缓存返回,网络拦截器不执行)
代码或图示
OkHttpClient.Builder()
.addInterceptor(appInterceptor) // 应用层
.addNetworkInterceptor(netInterceptor) // 网络层
常见误区
- 把鉴权头加在网络拦截器导致缓存回源请求缺头;横切业务头应放应用拦截器。
- 认为网络拦截器一定执行;纯缓存命中时它不参与。
追问
- 日志要记录真实发出的头放哪?答:网络拦截器,它看到桥接补全后的最终请求。
- 缓存校验的 304 响应哪层能看到?答:网络拦截器能看到网络交换结果;应用拦截器通常只看到最终 200 或缓存响应。
07.1.1.9.1-014 如何为单个请求添加拦截器,与全局拦截器有何不同?
一句话结论
全局拦截器挂在 OkHttpClient.Builder 上对所有请求生效;单请求拦截器通过 Request.Builder 无法直接挂,常见做法是为该请求派生一个配置了专属拦截器的子 client,或在应用拦截器内按请求标识分流。
概念解释
OkHttp 的拦截器属于客户端级别,Request 本身不持有拦截器列表。按请求差异化横切有两种思路:派生 client(共享连接池与线程池,仅附加拦截器),或在统一拦截器中读取请求标记(如自定义 header、tag)决定逻辑。
原理流程
全局:client.Builder().addInterceptor(...) → 全部 Call 经过
按请求:client.newBuilder().addInterceptor(perCall).build() → 仅派生 client 的 Call
分流:统一拦截器内 if (request.tag(Scope::class) == X) { ... }
代码或图示
val specialClient = Net.client.newBuilder()
.addInterceptor(SpecialInterceptor())
.build()
常见误区
- 期望在
Request.Builder上直接addInterceptor;该 API 不存在。 - 为每个请求 new 一个完整 client,导致连接池与线程池不共享。
追问
- 派生 client 是否复制连接池?答:
newBuilder()派生时默认复用原客户端的连接池、Dispatcher 与缓存。 - 按 tag 分流有什么风险?答:tag 类型与取值要约定清楚,避免业务语义散落在拦截器里。
07.1.1.9.1-015 拦截器中能否多次调用 chain.proceed?会发生什么?
一句话结论
技术上可以多次 proceed,但每一次都会让下游重新走一遍连接分配与请求发送;同一 Call 上反复 proceed 属于错误用法,重试应交给 retryOnConnectionFailure 或在上层用新的 Call 完成。
概念解释
链的单次语义是「一次请求一次响应」。手动多次 proceed 会产生多次交换,共享同一个请求上下文,可能出现响应体关闭顺序混乱、连接占用重复、统计翻倍等问题。需要重试时应新建 Call 或在专门的重试拦截器中清晰隔离每次交换。
原理流程
错误示范:proceed 两次 → 下游两次交换 → 两个 Response,流管理极易混乱
正确做法:单次 proceed;失败后上层重新 newCall 执行
代码或图示
// 不推荐:同一条链多次 proceed
override fun intercept(chain: Interceptor.Chain): Response {
val first = chain.proceed(chain.request())
// ... 再次 proceed 属于越界用法
return chain.proceed(chain.request())
}
常见误区
- 在拦截器里写「失败再试一次」直接循环 proceed;应理解为每次重试都是一次独立交换。
- 忽略多次 proceed 产生的多个响应体未关闭。
追问
- 官方重试拦截器是怎么处理的?答:
RetryAndFollowUpInterceptor在链内按规则产生后续交换,并对响应与连接做统一管理,业务不应模仿其内部细节自行循环。 - 业务幂等重试放在哪一层更稳妥?答:放在应用层用新 Call 发起,配合幂等键与退避策略。
07.1.1.9.1-016 拦截器如何在请求发出前重写请求头?
一句话结论
在 intercept 内基于 chain.request() 用 newBuilder().header(...)/addHeader(...) 构造新请求,再 proceed(新请求);header 覆盖同名键,addHeader 追加多值。
概念解释
Request 不可变,重写必须新建请求对象。注意区分 header(替换)与 addHeader(追加),以及 removeHeader 清理已有值。通用横切头(鉴权、追踪、设备信息)适合在应用拦截器统一追加。
原理流程
读 chain.request()
→ newBuilder() 改头/改方法/改体
→ proceed(改造后的 Request)
代码或图示
override fun intercept(chain: Interceptor.Chain): Response {
val req = chain.request().newBuilder()
.header("Authorization", "Bearer $token")
.addHeader("X-App-Version", versionName)
.build()
return chain.proceed(req)
}
常见误区
- 直接在原 Request 上调
header以为会生效;原对象不可变,必须用 builder 产物。 - 用
addHeader追加本应唯一的头,导致重复值被服务端拒绝。
追问
- 敏感头会被日志记录吗?答:取决于日志拦截器实现;鉴权类头应在日志层脱敏。
- 网络拦截器还能改请求头吗?答:能,但此时已贴近协议层,补全类头应由桥接拦截器负责,业务头尽量在应用层处理。
07.1.1.9.1-017 拦截器如何在响应返回后重写响应?
一句话结论
proceed 拿到 Response 后,用 Response.newBuilder() 修改状态码、头或体,返回改造后的新响应;响应体替换需用 ResponseBody.create(...) 构造新流。
概念解释
Response 同样不可变。后置处理常用于统一注入降级提示、补齐缺省头、对空体做包装。注意:原响应体是流,若要读取内容再改写,必须先消费原 body,再构造新 body 返回。
原理流程
resp = chain.proceed(req)
→ 读 resp 头/体(必要时)
→ resp.newBuilder()...build()
→ 返回新 Response
代码或图示
override fun intercept(chain: Interceptor.Chain): Response {
val resp = chain.proceed(chain.request())
return resp.newBuilder()
.header("X-From-OkHttp", "1")
.build()
}
常见误区
- 读完原 body 后忘记返回新 body,导致上层拿到空流。
- 在后置阶段改请求;请求在 proceed 时已向下游传递。
追问
- 能否把错误码响应改写成 200?答:技术上可以构造,但会污染上层错误语义,建议保留原始码并在业务层统一解析。
- 改写响应体会影响响应长度头吗?答:必须同步更新
Content-Length,否则协议层可能按旧长度读取。
07.1.1.9.1-018 拦截器如何短路返回而不发起网络请求?
一句话结论
拦截器不调用 proceed,直接用 Response.Builder 构造一个离线响应返回;常用于缓存兜底、本地 mock、鉴权拦截等场景。
概念解释
短路发生在链的某一环,下游连接与协议交换完全不发生。构造离线响应需要给出请求、状态码、协议版本与响应体;不 proceed 时务必保证响应体可被关闭,避免资源泄漏。
原理流程
拦截器判定:本地可应答
→ Response.Builder().request(req).code(200).body(...)
→ 直接返回,不经过连接池与网络
代码或图示
override fun intercept(chain: Interceptor.Chain): Response {
val req = chain.request()
if (offlineCache.has(req.url)) {
return Response.Builder()
.request(req).protocol(Protocol.HTTP_1_1)
.code(200).message("from cache")
.body(ResponseBody.create("application/json", offlineCache.get(req.url)))
.build()
}
return chain.proceed(req)
}
常见误区
- 短路响应不设置
protocol或message,导致响应构建不完整。 - 离线响应体不关闭,长期堆积泄漏。
追问
- 短路响应会不会经过缓存拦截器?答:应用拦截器在缓存拦截器之前短路;网络拦截器短路则跳过连接但仍在内置链内。
- 鉴权失败短路应该返回什么?答:返回明确的 401/403 语义响应或抛业务异常,让上层走登录流程,避免伪装成功。
07.1.1.9.1-019 拦截器如何给请求统一追加鉴权头?
一句话结论
在应用拦截器中读取当前令牌,为每个出站请求追加 Authorization 头;令牌过期刷新建议配合 401 重试拦截器或由上层认证层统一处理。
概念解释
统一鉴权头是典型横切关注点,放在应用拦截器可保证所有经过该客户端的请求都带上。刷新令牌、并发请求同时过期、401 重试与请求排队的配合,是实现时的主要复杂度。
原理流程
请求进入 → 拦截器取本地令牌
→ 有令牌:追加 Authorization
→ 无令牌:放行或短路跳转登录
→ proceed → 响应 401 时触发刷新与重试(需谨慎控制次数)
代码或图示
override fun intercept(chain: Interceptor.Chain): Response {
val token = authStore.currentToken()
val req = chain.request().newBuilder()
.apply { if (token != null) header("Authorization", "Bearer $token") }
.build()
return chain.proceed(req)
}
常见误区
- 在拦截器里做阻塞的令牌刷新,拖慢主线程以外的工作线程并放大排队。
- 401 无限重试,形成刷新死循环。
追问
- 并发多请求同时 401 怎么避免重复刷新?答:用单飞(single-flight)锁让后续请求等待同一个刷新结果,刷新成功后重放。
- 令牌放 Header 还是 Cookie?答:无状态 API 常用 Bearer Header;会话态可用 Cookie,凭证管理见存储与安全相关章节。
07.1.1.9.1-020 拦截器中读取并改写响应体时,为什么要注意流只能消费一次?
一句话结论
ResponseBody 是一次性流,读取后底层缓冲区已推进,再次读取会得到空内容;要既记录日志又把正文交给上层,必须用缓冲流复制一份,而不是直接反复读 body.string()。
概念解释
响应体连接着套接字,流被消费后不可重置。日志拦截器常见做法是读取一份字节复制体:把原始 body 替换成内容相同的新 body 返回给上游,同时把复制体写日志。注意大文件下载不能全量缓冲。
原理流程
原 resp.body 流
→ bytes = body.bytes()(消费原始流)
→ 用 bytes 构造两个副本:一个日志,一个新 ResponseBody 回传上游
代码或图示
val source = resp.body!!.source()
source.request(Long.MAX_VALUE)
val peek = source.buffer.peekByteArray(source.buffer.size)
val newBody = ResponseBody.create(resp.body!!.contentType(), peek)
return resp.newBuilder().body(newBody).build()
常见误区
- 先
body.string()打日志,再把原 Response 上交,上层读到空体。 - 大文件也全量
bytes()缓冲,造成内存峰值。
追问
- 二进制流(图片/文件)能这样复制吗?答:可以用字节缓冲副本,但大体积应走流式拷贝,避免整包进内存。
- 响应体不关闭会怎样?答:连接无法归还复用,长期累积导致连接耗尽与泄漏。
07.1.1.9.1-021 日志拦截器应放在应用拦截器还是网络拦截器?
一句话结论
要看日志目标:记录业务请求与最终响应用应用拦截器;记录真实发往网络的报文、重定向与逐跳响应用网络拦截器。生产环境默认只打精简元数据,报文全量日志仅在调试包开启。
概念解释
应用拦截器看不到缓存命中之外的网络细节,网络拦截器看不到业务层改造前的原始请求。完整链路诊断通常两者配合:应用层记录业务入参,网络层记录协议头与状态。敏感字段必须脱敏,且响应体大时不能全量打印。
原理流程
应用拦截器:记录 URL/方法/业务标记、最终结果码
网络拦截器:记录桥接后请求头、真实状态、耗时、重定向链路
代码或图示
if (BuildConfig.DEBUG) {
client.addNetworkInterceptor(HttpLoggingInterceptor().apply {
level = HttpLoggingInterceptor.Level.BASIC
})
}
常见误区
- 生产包开启 BODY 级日志,泄漏令牌与用户数据。
- 在应用拦截器里期望看到重定向后的第二跳响应。
追问
- 日志里怎么脱敏?答:对 Authorization、Cookie、手机号等键名按规则掩码后再输出。
- 抓包日志与服务端日志如何对齐?答:透传相同的
X-Trace-Id,两端按 trace id 串联。
07.1.1.9.1-022 OkHttp 内置拦截器按什么顺序排列?
一句话结论
典型内置顺序为:重试与跟随重定向 → 桥接补全 → 缓存处理 → 连接获取 → 服务端交换;应用拦截器在最前,网络拦截器在服务端交换之前。
概念解释
内置拦截器各自承担固定职责:RetryAndFollowUpInterceptor 处理失败重试与重定向跟随,BridgeInterceptor 补全 Host/Content-Type 等协议头,CacheInterceptor 判定缓存命中或回源,ConnectInterceptor 从池取/建连接,CallServerInterceptor 写请求读响应。
原理流程
应用拦截器
→ RetryAndFollowUpInterceptor
→ BridgeInterceptor
→ CacheInterceptor
→ ConnectInterceptor
→ 网络拦截器
→ CallServerInterceptor
代码或图示
顺序不可调换:先桥接补全,再缓存判定,再取连接,最后协议交换。
常见误区
- 认为缓存拦截器在桥接之前;实际头补全后缓存语义才完整。
- 把自己的横切拦截器插到内置之间;API 不允许,只能在外围。
追问
- 重定向跟随发生在哪一层?答:重试与重定向拦截器在链前部统一处理,产生后续交换。
- 哪一层决定是否真正发网络?答:缓存拦截器,命中离线缓存时可在连接之前返回。
07.1.1.9.1-023 BridgeInterceptor 做了哪些协议层补全工作?
一句话结论
桥接拦截器把业务 Request 补全为合规的 HTTP 报文:补 Host、Content-Type、Content-Length、Connection、Accept-Encoding、User-Agent、Cookie 等头,并在响应侧处理 gzip 解压与 Cookie 回填。
概念解释
业务代码通常只写方法、URL、业务头与体;桥接层按协议规范补齐传输必需的元信息。启用 gzip 时,它会在请求加 Accept-Encoding: gzip,响应侧若被压缩则解压并调整体与长度。
原理流程
出站:补 Host / UA / Connection / Content-Length / Accept-Encoding / Cookie
入站:按 Content-Encoding 解压,还原响应体与长度
代码或图示
原始请求:GET /api
桥接后: GET /api HTTP/1.1
Host: example.com
User-Agent: okhttp/4.x
Accept-Encoding: gzip
常见误区
- 手动设置
Accept-Encoding: gzip却不处理解压,导致拿到压缩字节乱码;交给桥接层更稳妥。 - 自定义替换
User-Agent时覆盖掉必要的协议信息。
追问
- Cookie 是在哪层带上的?答:配置了 CookieJar 时由桥接层在出站前读取并写入请求。
- Content-Length 如何计算?答:有固定体时由体的字节长度决定;分块传输场景由协议层处理。
07.1.1.9.1-024 CacheInterceptor 如何决定命中网络还是缓存?
一句话结论
缓存拦截器先用请求条件查磁盘缓存:缓存满足新鲜度直接返回缓存响应;过期则带上校验条件(If-None-Match/If-Modified-Since)回源,命中 304 则升级缓存,否则用新响应覆盖缓存;不可缓存或缓存缺失才走网络。
概念解释
判定依据响应的 Cache-Control、Expires、ETag、Last-Modified 与请求 Cache-Control 指令。缓存响应也会经过下游链;网络结果再由拦截器写回缓存目录。是否可缓存还受方法、状态码与响应头约束。
原理流程
查缓存 → 新鲜度足够:返回缓存
→ 过期:构造条件请求 → 网络 → 304 升级缓存 / 200 写入新缓存
无缓存或不可缓存 → 直接网络 → 按规则写缓存
代码或图示
val cache = Cache(cacheDir, maxSizeBytes)
val client = OkHttpClient.Builder().cache(cache).build()
常见误区
- 以为配置了 Cache 所有响应都进缓存;POST 与不可缓存头的响应不会落盘。
- 忽略服务端
no-store,仍在本地存敏感响应。
追问
- 304 响应体为什么通常为空?答:校验通过后复用本地缓存体,只更新响应头与新鲜度元数据。
- 缓存与业务状态一致性怎么保证?答:依赖服务端新鲜度与校验头;强时效数据应显式
no-cache或绕过缓存。
07.1.1.9.1-025 ConnectInterceptor 与连接池如何协作?
一句话结论
连接拦截器通过 StreamAllocation 向连接池申请一条可用于本次路由的连接:池内有空闲复用连接则取出,没有则选路由、建 TCP/TLS,用完再归还池中管理。
概念解释
StreamAllocation 是连接分配的协调者:结合 DNS 选出的路由、代理与协议偏好,从 ConnectionPool 取候选连接;复用失败(路由不匹配、连接已死)则新建。连接的关闭、清理与 keepAlive 由池负责。
原理流程
ConnectInterceptor.intercept
→ StreamAllocation.newStream()
→ 池查找匹配空闲连接
→ 未命中:RouteSelector 选路由 → 建连 → 握手
→ 把可交换连接交给 CallServer 层
代码或图示
Pool 空闲队列 → 匹配 route 的连接 → 占用流
未匹配 → 新建 RealConnection → 加入池 → 本次交换使用
常见误区
- 认为连接在请求一开始就建好;建连发生在该拦截器阶段。
- 复用失败的连接被继续使用;连接死亡会在下次复用前探测并丢弃。
追问
- 连接与路由是什么关系?答:一条连接绑定一组路由(主机/端口/代理/协议),路由变化就无法复用。
- 池里的空闲连接谁来清理?答:连接池自身的清理任务按 keepAlive 与空闲上限回收。
07.1.1.9.1-026 CallServerInterceptor 在 HTTP/1 与 HTTP/2 下分别做什么?
一句话结论
服务端交换拦截器负责把请求写入连接并读取响应:HTTP/1 走文本编解码与单行流,HTTP/2 走帧与多路复用流;对业务层而言都是提交请求、拿到响应头与体。
概念解释
该层调用对应的 ExchangeCodec:HTTP/1 由 Http1ExchangeCodec 处理文本报文,HTTP/2 由 Http2ExchangeCodec 在共享连接上分配流。二者在拦截器层的调用形态一致,差异在帧编解码、流优先级与流控。
原理流程
写请求头/体 → 等待响应头 → 读取响应体
HTTP/1: 一条连接一次交换,串行占用
HTTP/2: 共享连接上并发多个流,帧交错
代码或图示
Codec 接口:writeRequestHeaders / writeRequestBody /
readResponseHeaders / openResponseBody
常见误区
- 认为 HTTP/2 也要在应用层限制单连接并发;流控由协议层处理。
- 把 HTTP/1 连接占用与 HTTP/2 流占用混为一谈。
追问
- 一条 HTTP/2 连接能同时跑多少请求?答:受流控与对端设置影响,具体并发上限取决于协议参数与实现(待确认当前版本默认值)。
- 切换协议后拦截器需要改吗?答:不需要,Codec 按协商结果选择。
07.1.1.9.1-027 网络拦截器为什么能看到重试与重定向的真实链路?
一句话结论
网络拦截器位于服务端交换之前,链内每产生一次后续交换(重定向、跟随重试)都会再次经过该位置,因此能逐跳看到真实请求与响应;应用拦截器只看到最初请求与最终结果。
概念解释
重定向跟随与部分重试由链内重试拦截器展开为多次交换,网络拦截器处于每次交换的连接之前,会被重复调用;应用拦截器在最外层,只包裹整次 Call。需要审计逐跳链路、记录每跳耗时与状态时使用网络拦截器。
原理流程
Call 初始请求 → 应用拦截器(一次)
→ 重试/重定向展开:交换1 → 网络拦截器 → 302
交换2 → 网络拦截器 → 200
→ 最终响应回到应用拦截器
代码或图示
override fun intercept(chain: Interceptor.Chain): Response {
val req = chain.request()
val resp = chain.proceed(req)
// 每次网络交换都会进入这里,可记录逐跳状态
return resp
}
常见误区
- 在网络拦截器里按「一次 Call 只回调一次」做去重统计。
- 用应用拦截器采集重定向链路,导致漏记中间跳。
追问
- 重定向次数在哪控制?答:客户端可配置跟随重定向开关与最大重定向次数,具体 API 名以版本文档为准(待确认)。
- 哪些跳转不会被自动跟随?答:跨协议跳转与策略禁止的场景需上层处理,行为以实现为准。
07.1.1.9.1-028 拦截器如何统计一次请求的耗时与大小?
一句话结论
在拦截器内记录进入时间,proceed 后用响应头与 Content-Length、responseBodyEnd 等信息汇总;更细粒度的 DNS/握手/首字节耗时应交给 EventListener,而非在拦截器里猜阶段。
概念解释
拦截器只能拿到整段耗时与可读的头信息;连接内部阶段(DNS、TCP、TLS、首字节)不可见。统计上报要区分请求头大小、响应体大小与总耗时,并在失败分支同样记录。
原理流程
t0 = nanoTime()
resp = proceed(req)
耗时 = nanoTime() - t0
响应大小:读 Content-Length 或在 body 消费后由事件回调汇总
失败分支:在 onFailure/异常路径补报
代码或图示
val start = System.nanoTime()
val resp = chain.proceed(req)
val costMs = (System.nanoTime() - start) / 1_000_000
metrics.report(req.url.encodedPath, resp.code, costMs)
return resp
常见误区
- 只统计成功请求,失败样本缺失导致平均耗时失真。
- 在拦截器里测量连接握手耗时;该阶段不在拦截器可见范围内。
追问
- 响应体大小怎么精确拿到?答:
Content-Length可用时直接取;分块或压缩场景需结合事件回调在流关闭时统计实际字节。 - 耗时统计要不要包含排队等待?答:看口径,整段 Call 耗时含排队,交换耗时不含排队,需在指标命名上区分。
07.1.1.9.1-029 拦截器中抛异常会沿链怎样传播?
一句话结论
拦截器抛出的 IOException 或运行时异常沿链反向冒泡到 Call 调用方:同步 execute() 直接抛出,异步 enqueue() 回调 onFailure;下游已建立的连接按规则释放或归还。
概念解释
异常不会被链自动吞掉;未捕获异常会中止本次交换。需要业务化错误(如鉴权失败、业务码非成功)时,可在拦截器把响应包装成领域异常抛出,或返回错误响应交由上层解析。连接与响应体在异常路径上仍需关闭,避免泄漏。
原理流程
某拦截器 throw X
→ 反向穿过各拦截器后置逻辑
→ execute(): 抛出给调用线程
→ enqueue(): Callback.onFailure(call, e)
代码或图示
override fun intercept(chain: Interceptor.Chain): Response {
val resp = chain.proceed(chain.request())
if (resp.code == 401) throw AuthExpiredException()
return resp
}
常见误区
- 拦截器里 catch 异常后不关闭原响应体,直接返回伪造响应。
- 把
Response.code非 2xx 也当成异常抛出,导致业务码处理路径混乱。
追问
- 运行时异常与 IOException 有区别吗?答:都会冒泡;异步回调
onFailure传入的异常类型按实际抛出为准,业务层要区分可重试错误与编程错误。 - 异常时连接会泄漏吗?答:实现层在 Call 结束/取消时释放流与连接;业务自管理的响应体仍需在 finally 关闭。
07.1.1.9.1-030 拦截器能否修改请求的 HTTP 方法或 URL?
一句话结论
可以:基于 chain.request() 新建 Request 时通过 method(...) 改方法,通过 url(...)/newBuilder().url(...) 改地址,再 proceed;改方法通常要配套调整请求体。
概念解释
请求对象不可变,任何修改都走 builder。URL 改写常用于域名替换、灰度路由、加查询参数;方法改写较少见,需注意 GET/HEAD 无体、POST/PUT 有体的协议约束。改写后的路由可能改变连接复用归属。
原理流程
原 Request → newBuilder()
→ method("POST", body) 或 url(newUrl)
→ proceed(改造后请求)
代码或图示
val newReq = chain.request().newBuilder()
.url(chain.request().url.newBuilder().addQueryParameter("channel", "x").build())
.build()
常见误区
- 只改 URL 不改 Host 头;桥接层会按新 URL 重算 Host。
- 把 GET 改成 POST 却不带 body,服务端返回 411 或解析失败。
追问
- 改 URL 后 Cookie 与缓存还能命中吗?答:缓存键与 Cookie 域名按新 URL 匹配,旧缓存与旧域 Cookie 不自动套用。
- 灰度路由在拦截器做还是域名层做?答:轻量参数追加可在拦截器;多域名/证书隔离建议在 DNS 或客户端配置层处理。
07.1.1.9.1-031 应用拦截器中能否读到 304 这类缓存校验响应?
一句话结论
通常读不到:304 是回源校验的中间结果,由缓存拦截器内部处理并升级本地缓存,最终交回应用拦截器的是合并后的 200/缓存响应;逐跳校验响应需在网络拦截器观察。
概念解释
应用拦截器看到的是整次 Call 的最终响应;304 不带完整体,属于缓存层内部交换。要观察回源校验是否发生、ETag 是否生效,应在网络拦截器记录状态码与条件请求头。
原理流程
缓存过期 → 条件请求(If-None-Match)
→ 网络返回 304 → 缓存层升级本地响应
→ 应用层看到的是更新后的缓存响应(200 语义)
代码或图示
网络拦截器可见:请求 If-None-Match,响应 304
应用拦截器可见:合并后的最终 Response
常见误区
- 在应用拦截器统计 304 占比,得到恒为零的结果。
- 把 304 当失败上报;它是缓存命中的一种形式。
追问
- 如何监控缓存命中率?答:在网络拦截器统计条件请求与 304,结合本地缓存命中计数,按路径汇总。
- 304 后本地响应的修改时间会更新吗?答:缓存元数据随校验结果更新,具体字段以缓存实现为准。
07.1.1.9.1-032 拦截器顺序颠倒会带来什么后果?
一句话结论
顺序决定头追加、日志记录与异常包装的先后:鉴权在日志前则日志能脱敏,压缩在缓存前则缓存存的是压缩后内容;顺序错误会导致头重复、日志漏记、缓存键错乱甚至功能失效。
概念解释
拦截器链是嵌套调用,先注册的先做请求前置、后做响应后置。横切关注点有依赖顺序:日志包在最外层便于覆盖全部异常;鉴权在业务参数补全之后;缓存相关处理不能随意插在协议补全之前。
原理流程
顺序 A:日志 → 鉴权 → 业务头 → proceed
顺序 B:业务头 → 鉴权 → 日志 → proceed
后果:日志能否看到鉴权头、异常是否被记录,都随外层位置变化
代码或图示
client.addInterceptor(metricsInterceptor) // 最外:包全部
.addInterceptor(authInterceptor)
.addInterceptor(headerInterceptor)
常见误区
- 多个拦截器都
addHeader同一字段,顺序叠加导致重复值。 - 把压缩拦截器放在缓存拦截器之前,缓存内容与新鲜度判断失真。
追问
- 如何评审拦截器顺序?答:画出请求下行与响应上行两条线,确认每个横切关注点应在包内还是包外。
- 内置拦截器能被业务顺序影响吗?答:不能,业务拦截器只能挂在两端。
07.1.1.9.1-033 如何实现一个请求/响应压缩拦截器?
一句话结论
请求压缩需手动写压缩体并设置 Content-Encoding;响应解压要按服务端返回的编码处理。OkHttp 桥接层已内建 gzip 处理,自定义压缩应明确边界,避免与桥接层重复编码。
概念解释
Accept-Encoding: gzip 与响应解压由 BridgeInterceptor 自动完成;若要对请求体压缩(如大报文 POST),需在应用层构造压缩后的 RequestBody,并告知服务端编码。不要在桥接层之上再压一次响应。
原理流程
请求:原始体 → 压缩 → RequestBody(gzip 字节) + Content-Encoding: gzip
响应:桥接层按 Content-Encoding 解压 → 上层拿到明文
代码或图示
val gzipBody = object : RequestBody() {
override fun contentType() = MediaType.get("application/json")
override fun writeTo(sink: BufferedSink) {
GzipSink(sink).buffer().use { it.write(jsonString) }
}
}
常见误区
- 重复加 gzip 头又让桥接层自动处理,导致双重压缩。
- 压缩体不计算正确长度,分片传输异常。
追问
- 哪些响应不需要桥接解压?答:二进制下载或已明确透传编码的场景,需在拦截器层绕过自动处理,行为以版本实现为准(待确认)。
- 压缩对移动端收益如何评估?答:对比报文大小、CPU 解压耗时与弱网传输时间,按接口体量决定。
07.1.1.9.1-034 拦截器内做长耗时操作应注意什么线程问题?
一句话结论
拦截器运行在执行该 Call 的工作线程(异步为 Dispatcher 线程池,同步为调用线程),其中的阻塞操作会占用调度线程;长耗时计算、磁盘 IO、锁等待应控制时长,避免耗尽 Dispatcher 线程池。
概念解释
拦截器本身不切线程,proceed 期间线程被占用。若在拦截器里做磁盘读写、数据库查询或加锁等待,会直接拉长在途时间并占用并发额度。重活应前置到业务层或异步准备好,拦截器只做轻量读取与改写。
原理流程
Dispatcher 工作线程 → 拦截器(含阻塞操作)→ proceed → 等待响应
阻塞越久:占用线程越久,可并发任务越少,排队越长
代码或图示
// 反例:拦截器内同步查库
override fun intercept(chain: Interceptor.Chain): Response {
val cached = localDao.queryLatest() // 阻塞磁盘 IO,拖慢调度线程
return chain.proceed(chain.request())
}
常见误区
- 在拦截器里做主线程回调假设;拦截器不在 UI 线程。
- 把重量级初始化(读配置、解密)放进首个拦截器,拖慢全部请求。
追问
- 拦截器需要切换协程上下文吗?答:拦截器是同步回调形态,不宜直接挂协程;准备工作应在进入网络层之前完成。
- 阻塞排队如何观测?答:结合 Dispatcher 在途/排队数量与
callStart到真正连接开始的时间差定位。
07.1.1.9.1-035 自定义拦截器如何获取原始 Request 与最终 Response 的对照信息?
一句话结论
在拦截器内保存 chain.request() 的引用作为出站快照,proceed 后对比下游返回的 Response;需要对照桥接后的真实报文时,把对照逻辑放到网络拦截器读取最终请求。
概念解释
应用拦截器拿到的原始请求尚未经过桥接补全;网络拦截器拿到的是补全后的请求。需要「业务入参 vs 实际报文」双侧对照时,要在两层各取一份并通过 Call 或 tag 关联。Response 侧注意流只消费一次,对照只能读元数据或缓冲副本。
原理流程
应用层:记录业务 Request 快照
网络层:记录补全后 Request 与 Response 元数据
按 Call/request tag 串联两侧日志
代码或图示
val original = chain.request()
val response = chain.proceed(original)
metrics.attach(original.url.encodedPath, response.code, response.headers)
常见误区
- 在两层各自解析响应体并重复消费,导致上层空体。
- 用 Response 对象身份做跨层关联;响应在链中可能被包装替换。
追问
- 跨层关联用什么标识?答:在 Request 上打自定义 tag(如 trace id),两层按同一 tag 对齐。
- 对照信息上报要包含哪些字段?答:路径、方法、状态码、耗时、关键头(脱敏)、错误信息;体内容按需采样。
07.1.1.9.1-036 Dispatcher 的最大并发请求数与队列如何配置?
一句话结论
通过 Dispatcher.maxRequests 限制全局在途异步请求数,maxRequestsPerHost 限制单主机在途数;超出额度的任务进入就绪队列等待,默认全局上限 64、单主机 5(默认值随版本可能调整,待确认,以官方文档核对)。
概念解释
并发上限保护客户端线程与对端服务:全局上限防止本机线程与连接数膨胀,单主机上限避免把单一后端打满。队列本身不设长度上限,任务积压会占用 Call 对象与请求体内存。
原理流程
新异步 Call 入队
→ running < maxRequests 且该 host < maxRequestsPerHost:提交执行
→ 否则进入 readyAsyncCalls 排队
→ 在途完成后 promoteCalls() 提升排队任务
代码或图示
val dispatcher = Dispatcher().apply {
maxRequests = 64
maxRequestsPerHost = 5
}
常见误区
- 把
maxRequestsPerHost当成全局并发;它只按主机维度限流。 - 队列无限积压时不做业务层降级,内存随请求体增长。
追问
- 同步请求受这两个上限约束吗?答:不受,同步由调用线程直接执行。
- 单主机上限设多少合理?答:结合服务端容量与 HTTP/2 多路复用情况压测确定,HTTP/2 下可适当放宽流并发。
07.1.1.9.1-037 异步任务队列在并发上限达到后如何排队?
一句话结论
达到全局或单主机上限后,新任务进入就绪队列按入队顺序等待;在途任务完成后,Dispatcher 从队列头部按主机配额提升可执行的任务。
概念解释
队列分就绪(等待调度)与在途(正在执行)两组。提升任务时同时检查全局额度与主机额度;同一主机排队较多时,其他主机任务不受该主机配额阻塞。队列顺序在默认实现中近似 FIFO,不提供优先级接口。
原理流程
running 满 → ready 入队
→ 在途 Call 结束 → promoteCalls()
→ 遍历 ready:满足全局+主机额度则转 running 并提交线程池
代码或图示
readyAsyncCalls: 等待执行
runningAsyncCalls: 已提交线程池
promoteCalls():在两组之间搬运
常见误区
- 认为排队任务也占用网络连接;未调度任务尚未取连接。
- 期望队列支持插队;需要优先级要在业务层先排序再提交。
追问
- 排队期间取消任务会怎样?答:从就绪组移除,不进入在途;已在途的取消后中断执行。
- 队列积压如何告警?答:监控 ready 队列长度与排队等待时长,超阈值上报并触发降级。
07.1.1.9.1-038 readyAsyncCalls 与 runningAsyncCalls 分别存什么?
一句话结论
readyAsyncCalls 存已入队但因额度不足尚未执行的异步 Call,runningAsyncCalls 存正在执行(含可被取消)的异步 Call;两组都由 Dispatcher 维护,同步 Call 不进这两组。
概念解释
这两组集合是 Dispatcher 调度状态的直接来源:提升任务从 ready 搬入 running,结束后从 running 移除。内部还会记录每个 Call 的主机信息以支持单主机配额统计。通过 Dispatcher 的只读快照方法可观察两组数量。
原理流程
enqueue → 额度满足:加入 running,提交线程池
→ 额度不足:加入 ready
完成/取消 → 从 running 移除 → promoteCalls()
代码或图示
val d = client.dispatcher
println("running=${d.runningCallsCount}, ready=${d.queuedCallsCount}")
常见误区
- 把同步 Call 也算进 running 计数;计数方法只反映异步任务。
- 直接修改内部集合;应通过 Cancel 系列方法操作。
追问
- 如何遍历当前在途与排队请求?答:Dispatcher 提供运行中/排队中 Call 的只读列表快照方法,具体方法名以版本 API 为准(待确认)。
- 两组集合是否线程安全?答:Dispatcher 内部按并发访问设计,外部读取快照用于监控即可。
07.1.1.9.1-039 如何取消某个请求或某一批请求?
一句话结论
单个 Call 调 call.cancel();批量取消可遍历 Dispatcher 的在途/排队 Call 按 tag 或主机过滤后逐个取消,也可以为一批请求派生独立 client 后整体停掉其 Dispatcher。
概念解释
取消协作式进行:已排队的任务不再执行,在途任务在可中断点(读写、等待响应)抛 IOException 回调 onFailure。取消不保证立即中断,套接字与流的释放按实现完成。按 tag 批量取消适合页面离开、退出登录等场景。
原理流程
页面退出 → 按 tag 收集 Call
→ 逐个 cancel()
→ 排队:直接移除;在途:中断并回调 onFailure(取消异常)
代码或图示
client.dispatcher.queuedCalls() + client.dispatcher.runningCalls()
.filter { it.request().tag(PageTag::class.java) == tag }
.forEach { it.cancel() }
常见误区
- 取消后仍等待回调更新 UI;应在回调里判断取消状态避免误操作。
- 批量取消遍历集合时直接修改原集合,引发并发问题。
追问
- 取消异常如何识别?答:通常表现为
IOException且消息与 canceled 相关;业务层应区分主动取消与真实网络失败。 - 取消后连接会立刻关闭吗?答:未读完的连接按实现回收;已复用的空闲连接保留在池中待后续使用。
07.1.1.9.1-040 Dispatcher 的执行线程池是怎样创建与复用的?
一句话结论
Dispatcher 内部持有一个核心线程数为 0、按空闲超时回收的缓存线程池,异步 Call 提交到该池执行;线程随任务量伸缩,空闲超时后回收,避免长期占着线程。
概念解释
线程池用于跑异步网络任务,线程数受 maxRequests 间接约束:同时在途任务数决定占用线程数。池内线程是守护线程还是非守护线程、空闲存活时长随实现版本而定(待确认),不要假设固定线程数。
原理流程
Call 进入 running → 提交内部线程池
→ 空闲线程复用;无空闲则新建
→ 任务结束线程归还池内,空闲超时后回收
代码或图示
内部池:corePoolSize=0,SynchronousQueue,空闲超时回收
(具体参数以当前 OkHttp 版本源码为准,待确认)
常见误区
- 认为线程数等于 maxRequests;线程是池化复用,在途任务与线程并非一一长期绑定。
- 替换 Dispatcher 线程池配置后误传一个固定大池,失去伸缩能力。
追问
- 线程池满了任务去哪?答:受 Dispatcher 额度控制,超额任务在 ready 队列等待,不直接打到线程池队列。
- 如何监控线程数?答:观察 Dispatcher 运行任务数与线程池活跃线程,结合线程名前缀在 Profiler 中查看。
07.1.1.9.1-041 同步请求受不受 Dispatcher 并发上限约束?
一句话结论
不受:execute() 由调用线程直接进入拦截器链,不经过 ready/running 异步集合,maxRequests 与 maxRequestsPerHost 只约束异步任务。
概念解释
同步调用的并发度完全由调用方线程模型决定;如果自己开一个固定线程池跑同步 Call,实际并发由该业务线程池控制。因此同步批量请求仍需在业务层限流,不能依赖 Dispatcher 默认上限。
原理流程
execute() → 当前线程直接进链
enqueue() → Dispatcher 额度检查 → 队列/线程池
代码或图示
// 同步批量:业务线程池决定并发,Dispatcher 不兜底
ExecutorService(...).submit { client.newCall(req).execute() }
常见误区
- 以为设了
maxRequests就能管住同步批量任务。 - 在主线程调
execute(),触发主线程网络异常。
追问
- 协程 suspend 方法算同步还是异步?答:Retrofit 内部以异步 Call 桥接,调度走 Dispatcher,并发受其约束。
- 同步请求如何限流?答:在业务线程池或信号量上控制并发数。
07.1.1.9.1-042 如何监控当前正在执行与排队的请求?
一句话结论
通过 Dispatcher.runningCallsCount() 与 queuedCallsCount() 读取在途与排队数量,配合 runningCalls()/queuedCalls() 快照按主机、tag 聚合,作为客户端侧负载与排队告警指标。
概念解释
这些计数反映客户端自身调度压力,不等同于服务端负载。监控口径要区分:在途数表示占用连接/线程,排队数表示等待额度。长时间高排队说明并发上限过小、下游过慢或请求量过大,需要结合耗时一起看。
原理流程
定时采样:runningCount / queuedCount
→ 按 host/tag 聚合路径与状态
→ 超阈值上报:排队长度、等待时长、在途耗时分布
代码或图示
val d = client.dispatcher
metrics.gauge("net.running", d.runningCallsCount())
metrics.gauge("net.queued", d.queuedCallsCount())
常见误区
- 只看在途数不看排队数,漏掉排队积压。
- 高频轮询快照遍历全部 Call,自身成为性能负担。
追问
- 排队等待时长怎么算?答:从 Call 入队到真正进入连接阶段的时间差,结合 EventListener 的
callStart与连接开始回调。 - 指标按什么维度拆分?答:按业务模块、主机、页面场景拆分,便于定位是哪类接口积压。
07.1.1.9.1-043 后台应用退到桌面后在途请求如何处理?
一句话结论
OkHttp 本身不感知前后台,在途请求继续执行直到完成、失败或被取消;前后台策略由业务层决定,例如退后台后按页面生命周期批量取消,或配合后台任务允许关键请求收尾。
概念解释
客户端只是执行引擎,不做后台限制决策。Android 侧的后台执行约束由系统与调度框架(如 WorkManager)控制;OkHttp Call 在进程存活期间会继续跑。进程被系统回收时,套接字随进程终止而断开。
原理流程
退后台 → 业务层决定:取消本页 Call / 保留关键请求
→ 进程存活:在途请求继续
→ 进程被回收:连接随进程结束
代码或图示
override fun onStop() {
super.onStop()
pageCalls.forEach { it.cancel() } // 按页面作用域清理
}
常见误区
- 以为退后台网络请求会被 OkHttp 自动暂停。
- 后台长期挂着大量未取消请求,进程驻留期间持续耗电与占连接。
追问
- 后台续传长任务用什么?答:系统约束下优先 WorkManager 等调度方案,普通 Call 不保证后台持续执行。
- 进程死亡后未完成的请求如何恢复?答:下次启动由业务层重新发起,Call 本身不可跨进程恢复。
07.1.1.9.1-044 Dispatcher 与协程 suspend 调用在调度上是什么关系?
一句话结论
Retrofit 的 suspend 适配在内部把异步 Call 提交给 OkHttp Dispatcher,协程挂起等待结果;协程取消会映射为 Call 取消,底层线程调度仍由 Dispatcher 线程池承担。
概念解释
suspend 函数不占着调用线程阻塞等待:内部 enqueue 后挂起协程,回调恢复协程;取消时调用 call.cancel()。因此 suspend 接口的并发上限同样受 Dispatcher 的 maxRequests 约束,而不是由协程调度器直接决定。
原理流程
suspend 接口 → Retrofit 适配 → client.newCall().enqueue()
→ Dispatcher 线程池执行 → 回调恢复挂起协程
cancel 协程 → call.cancel() → onFailure(取消) 传播
代码或图示
interface ApiService {
@GET("user")
suspend fun getUser(): User
}
常见误区
- 认为 suspend 接口绕过 Dispatcher 并发限制。
- 协程取消后底层 Call 仍继续读完响应;实际取消会随映射链路中断。
追问
- 回调线程恢复到哪个调度器?答:由 CallAdapter 实现决定,通常回到异步回调线程再由协程机制切换;更新 UI 需在主线程调度器。
- 并发发大量 suspend 请求会排队吗?答:会,受 Dispatcher 额度约束,超额在就绪队列等待。
07.1.1.9.1-045 高并发接口场景下 Dispatcher 排队过长如何治理?
一句话结论
先区分瓶颈在客户端额度、连接复用还是下游服务:合理调大并发上限与单主机额度,确保连接复用;对请求做合并、分页与懒加载;下游慢则做超时、降级与限流,而不是一味堆并发。
概念解释
排队过长的表现是 ready 队列持续增长、等待时长升高。治理顺序:测量各阶段耗时定位瓶颈;检查连接是否被复用、单主机是否成为瓶颈;业务侧减少无效请求;客户端额度与线程池按机型与网络调整;对非关键接口降低优先级。
原理流程
监控 ready 长度/等待时长
→ 连接未复用:修连接池与路由匹配
→ 单主机瓶颈:评估服务端容量,必要时分域名
→ 请求过多:合并/懒加载/预取策略调整
→ 下游慢:超时降级,控制在途量
代码或图示
dispatcher.maxRequests = 64
dispatcher.maxRequestsPerHost = 8 // 按压测结果调整
常见误区
- 盲目把 maxRequests 调到很大,线程与连接激增反而压垮本机与服务端。
- 只调客户端参数,不治理重复请求与冗余轮询。
追问
- 如何判断排队是客户端问题还是下游问题?答:对比在途请求耗时与连接阶段耗时;下游慢会拉长在途,客户端额度不足表现为高 ready 与低连接占用。
- 关键与非关键请求能否分池?答:可派生两个 client,各自 Dispatcher 与连接池,关键接口独享额度。
07.1.1.9.1-046 ConnectionPool 复用一条连接的条件是什么?
一句话结论
只有当空闲连接与本次请求的路由匹配(主机、端口、代理、协议、TLS 配置一致)且连接仍健康、未被标记淘汰时,才会被复用;路由不一致或连接已死则必须新建。
概念解释
连接池按路由分组管理候选连接。复用匹配先看路由键,再看连接状态:是否空闲、是否已被驱逐、对端是否已关闭。HTTP/2 连接还需确认流未耗尽、协议协商一致。匹配过程由 StreamAllocation 在取连接时完成。
原理流程
新请求 → 计算 Route
→ 遍历池内空闲连接:Route 匹配 + 状态健康
→ 命中:复用
→ 未命中:新建连接并入池
代码或图示
匹配键:address(域名/端口) + proxy + protocol + tls 配置 + 路由
常见误区
- 同域名不同端口共用一条连接;端口不同属于不同路由。
- 池里有同域连接就一定复用;连接已死或协议不匹配时不复用。
追问
- 什么叫连接健康?答:未被明确关闭、空闲期间未收到对端关闭信号;复用前会做可用性判断,死亡连接会被剔除。
- 路由匹配失败的连接留在池里吗?答:保留给匹配该路由的后续请求,超 keepAlive 后被清理。
07.1.1.9.1-047 keepAlive 时长与空闲连接数如何配置?
一句话结论
ConnectionPool(maxIdleConnections, keepAliveDuration, timeUnit) 配置最多保留的空闲连接数与每条空闲连接的存活时长;默认值(如 5 条、5 分钟)随版本可能调整,具体数值以官方文档为准(待确认)。
概念解释
keepAlive 控制空闲连接在池内等待多久后被清理;最大空闲连接数限制池规模,避免长期持有大量半开连接。移动端弱网与 NAT 环境下,过长 keepAlive 会保留易失效连接,过短则频繁重建握手。
原理流程
交换结束 → 连接空闲入池
→ 超过 keepAliveDuration 或空闲数超上限:清理任务淘汰
→ 后续同路由请求优先复用存活连接
代码或图示
val pool = ConnectionPool(
maxIdleConnections = 5,
keepAliveDuration = 5, TimeUnit.MINUTES
)
val client = OkHttpClient.Builder().connectionPool(pool).build()
常见误区
- 把 keepAlive 设得很长,保留大量已被 NAT 回收的死连接。
- 限制空闲连接数过小,高并发场景下反复建连。
追问
- keepAlive 由谁计时?答:连接池内部按空闲开始时间计时,配合清理任务检查。
- 服务端
Keep-Alive: timeout头要不要对齐?答:客户端空闲时长应不大于服务端建议的存活时间,避免复用到已被服务端关闭的连接。
07.1.1.9.1-048 连接池什么时候清理空闲连接?
一句话结论
连接池在放入新连接或有空闲连接等待时触发清理任务:按 keepAlive 淘汰超时空闲连接,并把空闲数压到上限以内;清理在后台线程执行,不阻塞本次请求。
概念解释
清理策略不是逐条定时扫描全部连接,而是在入池/检查时处理到期项。被淘汰的连接关闭套接字并移出池。没有空闲连接时无需额外清理动作。
原理流程
连接归还入池 → 触发清理
→ 找到超时空闲连接 / 超上限连接 → 关闭移除
→ 存活连接保留等待复用
代码或图示
Pool.cleanup():计算最老空闲连接剩余时间,到期则关闭;返回下次延迟
常见误区
- 认为池有固定周期轮询所有连接;清理是按需触发的延迟任务。
- 手动持有连接引用导致池清理不掉,连接长期不释放。
追问
- 如何观察清理行为?答:结合连接数指标与 EventListener 连接开闭事件,统计建连/拆连频率。
- 池能手动清空吗?答:
ConnectionPool提供清空闲置连接的方法(方法名以版本 API 为准,待确认),用于切换环境等场景。
07.1.1.9.1-049 什么情况下连接无法复用而必须新建?
一句话结论
路由不匹配(域名/端口/代理/协议/TLS 配置不同)、连接已死亡或被关闭、HTTP/1 连接正被占用且无空闲同路由连接、连接上已有不可恢复错误时,必须新建连接。
概念解释
复用是有前提的:路由键一致且连接健康可用。HTTP/1.1 一条连接同时只服务一个交换,并发第二个请求时若无空闲同路由连接就要新建;HTTP/2 可在一条连接上开多个流,复用概率更高。对端关闭、写入失败、TLS 状态损坏都会让连接作废。
原理流程
取池内候选 → 路由匹配?否:新建
→ 健康可用?否:关闭作废,新建
→ HTTP/1 忙:另找空闲,无则新建
→ 全部不满足:选路由建 TCP/TLS
代码或图示
不可复用典型:跨端口、跨代理、明文/HTTPS 混排、连接 reset、TLS 错误、HTTP/1 占用中
常见误区
- 同域名下切换代理后仍期望复用旧连接。
- 复用失败的连接反复重试同一死连接,而非新建路由。
追问
- 连接判断死亡的时机?答:复用前检查状态;使用中发现读写错误会标记并释放,下次不再取。
- 新建连接对首屏影响多大?答:含 DNS 与握手往返,弱网下明显,应通过复用率指标监控。
07.1.1.9.1-050 连接合并(Connection Merging)在什么场景触发?
一句话结论
当池内已有一条连接可覆盖多个目标域名(证书包含相关域名、协议与路由兼容)时,新域名请求会复用该连接,而不是为新域名另建;HTTP/2 下这种合并最常见。
概念解释
合并依赖证书的 SAN 覆盖与协议能力:一条连接协商出的 TLS 证书同时覆盖多个域名,HTTP/2 允许在其上为不同主机开流。若证书只覆盖单域或协议不兼容,则无法合并,必须新建连接。
原理流程
新请求域名 → 池内现有连接证书 SAN 是否覆盖该域名
→ 覆盖且协议兼容:合并到现有连接开流
→ 不覆盖:新建连接
代码或图示
证书 SAN: a.example.com, b.example.com
现有连接已服务 a → b 请求可复用该连接(HTTP/2)
常见误区
- 认为只要同主域就一定合并;证书覆盖是硬前提。
- 合并后误以为两套 Cookie 共享;Cookie 仍按域名隔离。
追问
- 合并失败会回退新建吗?答:会,候选连接不兼容即按新路由建连。
- 如何监控合并收益?答:统计建连次数与请求数比值,结合连接上的流数量分析。
07.1.1.9.1-051 同一主机多端口、多域名能否共用连接?
一句话结论
同主机不同端口不能共用一条连接(端口是路由键的一部分);不同域名只有在证书 SAN 覆盖且协议允许(HTTP/2)时才可能合并共用,HTTP/1.1 一般按独立连接处理。
概念解释
路由键包含端口与地址,端口不同套接字目标不同,无法复用。多域名合并是证书与协议层的特例,不是默认行为。设计多服务部署时,同域不同路径比跨域共享连接更可控。
原理流程
:8080 与 :8081 → 不同路由 → 各自连接
example.com / api.example.com → 看证书覆盖 + HTTP/2 → 可能合并
代码或图示
路由键 = host:port + proxy + protocol + tls
端口不同:键不同,不复用
常见误区
- 把多端口服务部署在同域后期望连接复用,导致握手次数翻倍。
- 用通配证书但忽略协议限制,HTTP/1 下仍无法合并。
追问
- 多域名共用连接对证书有什么要求?答:证书必须在 SAN 中覆盖所有被合并域名,泛域名证书按匹配规则覆盖。
- 如何让连接复用更稳定?答:统一网关域名、收敛端口、使用 HTTP/2,减少跨路由请求。
07.1.1.9.1-052 HTTP/1.1 与 HTTP/2 连接复用行为有何差异?
一句话结论
HTTP/1.1 一条连接同一时刻只跑一个交换,并发要靠多条连接;HTTP/2 在一条连接上并发多个流,复用粒度是「流」而非整条连接,单主机连接数显著下降。
概念解释
HTTP/1.1 的复用体现在串行排队使用同一条空闲连接,并发请求需池内多条连接;HTTP/2 把请求拆成帧在共享连接上交错传输,流之间互不阻塞(除流控外)。连接合并、多路复用都以 HTTP/2 为基础。
原理流程
HTTP/1.1:连接 A 交换完 → 空闲归还 → 下一个串行使用;并发 N 需要 N 条连接
HTTP/2:连接上并发流 1/2/3,帧交错,流结束不拆连接
代码或图示
协议协商结果 → Http1ExchangeCodec 或 Http2ExchangeCodec
常见误区
- HTTP/2 下仍按 HTTP/1 经验限制单主机连接数,浪费并发能力。
- 认为 HTTP/2 消除了队头阻塞;传输层 TCP 队头阻塞仍存在。
追问
- HTTP/2 流并发受什么限制?答:受对端流控窗口与实现设置约束,具体默认值待确认。
- 哪些场景退回 HTTP/1.1?答:协议协商失败、代理不支持、服务端仅支持 HTTP/1 时。
07.1.1.9.1-053 连接池中的连接在 TLS 握手上会被复用吗?
一句话结论
会:复用健康连接意味着 TCP 连接与已完成的 TLS 会话一起复用,后续请求不再重复完整握手;只有连接重建时才重新协商 TLS。
概念解释
TLS 握手包含密钥交换与证书校验,成本很高。池化连接保留会话状态,复用后直接在加密通道上发请求。若连接被判定不可用或路由变化,新建连接才走完整握手;会话恢复(会话复用)行为随 TLS 版本与服务端配置而定(待确认细节)。
原理流程
首次:DNS → TCP → TLS 握手 → 加密通道
复用:直接在现有加密通道写请求,无握手往返
重建:连接失效 → 重新 TCP + TLS
代码或图示
EventListener: secureConnectStart/End 只在新建连接握手时出现
常见误区
- 认为复用连接仍会每次校验证书;校验发生在握手阶段,复用阶段不再重复。
- 复用 TLS 会话能替代证书固定;固定校验仍在握手时执行。
追问
- TLS 会话恢复能省多少?答:取决于版本,会话复用可减少往返;以 EventListener 握手阶段耗时对比为准。
- 握手失败的连接会进池吗?答:不会,握手异常的连接不可用,直接走失败路径。
07.1.1.9.1-054 连接耗尽(No New Connections)在弱网下如何表现?
一句话结论
连接耗尽表现为新请求排队等待空闲连接或建连失败:在途连接被占用、新建连接受网络/协议限制,请求长时间停在连接阶段,最终超时或报连接类异常。
概念解释
移动弱网下读写变慢拉长每条连接占用时间,HTTP/1 连接串行占用更易堆积;HTTP/2 受流控限制也会出现流等待。表象是请求集中卡在 connect/wait 阶段,超时率与重试率上升。需要结合在途连接数、建连失败率与各阶段耗时定位。
原理流程
弱网 → 单交换耗时变长 → 连接占用时间变长
→ 池内无空闲 → 等待/新建 → 新建再失败 → 超时重试放大压力
代码或图示
指标:连接等待时长、新建连接失败数、在途连接数、超时分类占比
常见误区
- 把连接耗尽当成服务端报错;先看客户端连接阶段与网络状态。
- 盲目重试加剧建连压力,形成弱网雪崩。
追问
- 如何缓解?答:控制在途并发、缩短占用时间(减小报文)、合理超时与退避重试、优先复用连接。
- 连接耗尽与线程池耗尽如何区分?答:前者卡在连接/等待流,后者卡在 Dispatcher 排队;用排队数与连接阶段时间区分。
07.1.1.9.1-055 如何观测连接池状态与空闲连接数?
一句话结论
可通过 ConnectionPool 的快照方法读取空闲连接数,并结合 EventListener 的连接建立/释放事件与在途连接数,统计复用率、新建率与连接存活时长。
概念解释
公开 API 对池内部细节暴露有限:空闲连接计数、池大小等可通过对应方法读取(方法名以版本为准,待确认);更细的连接生命周期靠事件回调记录。复用率 = 复用交换次数 / 总交换次数,是衡量连接池效果的核心指标。
原理流程
定时采样:空闲连接数 / 在途连接数
事件流:connectionAcquired / connectionReleased / connectStart / connectEnd
汇总:复用率、新建握手次数、平均连接存活时长
代码或图示
override fun connectionAcquired(call: Call, connection: Connection) {
metrics.count("net.connection.acquired")
}
常见误区
- 只看空闲连接数判断复用好坏;空闲多也可能是 keepAlive 过长保留死连接。
- 不区分新建握手与复用交换,握手耗时被平均值掩盖。
追问
- 复用率低先查什么?答:路由是否一致(端口/代理/域名)、连接是否快速失效、keepAlive 是否过短。
- 连接数指标按什么维度拆?答:按主机与网络类型(Wi-Fi/移动网络)拆分对比。
07.1.1.9.1-056 连接被服务端主动关闭后复用时会发生什么?
一句话结论
服务端在空闲期关闭连接后,客户端池内仍持有该连接;下次复用时写入可能收到对端关闭信号或读到 EOF,实现会识别为死连接并失败本次交换,随后新建连接重试(受重试策略约束)。
概念解释
空闲期间对端关闭对客户端不可即时感知,这是长连接复用的固有风险。复用前的可用性探测程度取决于实现;典型表现是首次复用出现连接被重置/EOF 异常。合理设置 keepAlive 不超过服务端 Keep-Alive 时长,可降低踩中死连接的概率。
原理流程
空闲期对端关闭 → 客户端池仍保留
→ 下次复用:写请求/读响应 → 收到 RST 或 EOF
→ 标记连接死亡 → 失败/重试 → 新建连接
代码或图示
异常表象:SocketException/EOFException,发生在复用连接的首次交换
常见误区
- 认为池内连接一定活着;空闲长连接存在被对端关闭的窗口。
- 把复用死连接导致的首请求失败误判为服务端宕机。
追问
- 如何减少死连接复用?答:对齐服务端 keepAlive 时长、缩短客户端空闲时长、监控复用后首请求失败率。
- 检测到死连接后池会怎么处理?答:丢弃该连接,后续同路由请求新建。
07.1.1.9.1-057 池化连接的生命周期由谁管理?
一句话结论
由 ConnectionPool 统一管理:入池、空闲计时、淘汰关闭、复用取出;StreamAllocation 负责为本次交换分配与释放连接,业务代码不直接持有连接。
概念解释
连接对象的创建由交换触发,归还与清理归池管理。一次交换结束后连接回到空闲池等待复用;达到淘汰条件或客户端关闭时连接被关闭。业务层不应该长期保存 Connection 引用跨请求使用。
原理流程
新建连接 → 本次交换占用 → 空闲归还池
→ 复用:取出占用 → 归还
→ 淘汰:关闭套接字 → 移出池
代码或图示
ConnectionPool: put / get / cleanup / evictAll
StreamAllocation: acquire / release / connection 生命周期协调
常见误区
- 在拦截器里缓存 Connection 给下一个请求用;连接由池分配,外部持有不安全。
- 客户端关闭后仍期待池内连接可用。
追问
- 客户端何时关闭池?答:不再使用客户端时可调用关闭方法释放连接与线程(API 名以版本为准,待确认);进程退出由系统回收。
- 多客户端共享池是什么效果?答:派生客户端默认共享原池,连接在这些客户端间复用。
07.1.1.9.1-058 自定义 ConnectionPool 与默认池在内存占用上有何差异?
一句话结论
默认池按内置上限管理少量空闲连接;自定义增大空闲数或延长 keepAlive 会保留更多空闲套接字与缓冲,占用更多内存与文件描述符,减小则降低常驻但提高建连频率。
概念解释
每条空闲连接占用套接字、读写缓冲与 TLS 状态。池规模是「复用率」与「常驻资源」的权衡:移动端内存受限,空闲连接数不宜盲目放大。池大小还要结合并发峰值与机型内存评估。
原理流程
空闲连接数 ↑ → 复用率 ↑,常驻内存/FD ↑
空闲连接数 ↓ → 常驻资源 ↓,新建握手 ↑,弱网耗时 ↑
代码或图示
ConnectionPool(maxIdleConnections = 3, keepAliveDuration = 2, TimeUnit.MINUTES)
常见误区
- 为追求复用把空闲连接数设成与并发请求数一样大,常驻套接字过多。
- 忽略文件描述符上限;长连接过多在低资源设备上可能触达 FD 限制。
追问
- 默认池配置如何选择?答:先按默认值观察复用率与空闲数,再按弱网占比和内存基线微调。
- 池内存怎么观测?答:Profiler 查看连接对象与缓冲占用,结合空闲连接数指标。
07.1.1.9.1-059 DNS 解析结果变化后连接池如何感知?
一句话结论
已建立连接绑定的是建连时的路由与 IP,DNS 后续变更不会主动迁移存量连接;新请求按当前 DNS 结果选路由,若指向新 IP 且与池内连接路由不匹配,则新建连接。
概念解释
DNS 是建连阶段的解析结果,连接一旦建立不随 DNS 刷新而切换。流量调度(灰度、切机房)对存量连接的影响有限,新连接才走新解析。需要按最新解析快速生效时,要配合连接释放/短连接策略,具体行为以 DNS 实现与自定义 DNS 为准。
原理流程
T1:解析 IP-A → 建连 A 入池
T2:DNS 变更为 IP-B
→ 存量连接 A 继续使用至失效
→ 新请求解析 B → 路由不匹配 A → 新建连接 B
代码或图示
class PinDns(private val hosts: Map<String, List<InetAddress>>) : Dns {
override fun lookup(hostname: String) = hosts[hostname] ?: Dns.SYSTEM.lookup(hostname)
}
常见误区
- 以为改 DNS 配置后所有连接立刻切到新 IP。
- 自定义 DNS 返回多 IP 时不做失败切换,首个 IP 不通就整体失败。
追问
- 如何让新解析尽快生效?答:缩短长连接占用、必要时清理池内旧连接,结合故障切换策略。
- DNS 轮询结果与连接池如何配合?答:每条连接绑定所选 IP,池内可能并存多 IP 连接,按本次解析选择匹配项。
07.1.1.9.1-060 代理连接是否进入同一连接池?
一句话结论
进入同一 ConnectionPool,但代理是路由键的一部分:直连与代理连接、不同代理之间互不复用,池内按路由分组管理。
概念解释
连接复用匹配包含代理信息:走 HTTP 代理、SOCKS 代理或直连属于不同路由。同一代理下的同目标地址才可复用。配置了代理选择器时,每次请求按选择结果确定路由,再去池中匹配。
原理流程
请求 → ProxySelector 选代理 → 构造 Route(host, port, proxy)
→ 池内匹配同 Route 连接 → 复用;否则经代理建连
代码或图示
val client = OkHttpClient.Builder()
.proxy(Proxy(Proxy.Type.HTTP, InetSocketAddress("proxy", 8080)))
.build()
常见误区
- 代理切换后期望复用直连旧连接;路由不同无法复用。
- 抓包代理与正式环境混用同一 client,凭证与连接串在一起。
追问
- 代理连接的 TLS 校验有何不同?答:经代理转发时最终仍对目标站点做 TLS 校验;代理层是否解密取决于代理类型与配置,安全风险需单独评估。
- 如何为调试与正式隔离连接?答:派生独立 client 与连接池,调试结束后丢弃。
07.1.1.9.1-061 HTTP 与 HTTPS 连接能否混在池中复用?
一句话结论
不能:明文 HTTP 与 TLS 加密连接属于不同路由与安全配置,池内分别管理,互不复用。
概念解释
协议与安全配置是路由匹配条件之一:HTTPS 连接经过 TLS 握手并持有证书状态,HTTP 连接是明文通道。两者套接字状态、握手信息不同,无法互换。域名相同但 scheme 不同也视为不同路由。
原理流程
http://example.com → 明文 Route
https://example.com → TLS Route
池内两组独立候选,互不匹配
代码或图示
匹配键包含 isTls / tls 配置;scheme 不同即不复用
常见误区
- 同域 HTTP/HTTPS 共用一条连接;安全模型不同,不可能复用。
- 把自动升级 HTTPS 的旧连接拿来复用;升级后需新建 TLS 连接。
追问
- 明文流量在 Android 上有什么限制?答:高版本默认禁止明文,需网络安全配置显式放行;相关规则见安全配置章节。
- 混合内容页面资源加载要注意什么?答:HTTPS 页面不应加载明文资源,否则被系统或浏览器拦截。
07.1.1.9.1-062 连接复用失败的常见原因有哪些?
一句话结论
常见原因:路由不一致(域名/端口/代理/协议/安全配置)、连接已被对端关闭或标记错误、HTTP/1 连接忙且无空闲同路由连接、证书或协议协商不兼容、池内已无候选连接。
概念解释
复用失败先从路由键排查,再看连接状态与协议占用。排查时结合 EventListener:若每次请求都走 connectStart 说明几乎未复用;若复用后首请求报 EOF/RST 则是踩中死连接。多 IP 与多代理场景还要核对实际选中的路由。
原理流程
复用失败 → 1. 路由键是否一致
→ 2. 连接是否健康
→ 3. HTTP/1 是否忙、HTTP/2 流是否可用
→ 4. 协议/证书是否兼容
代码或图示
排查顺序:连接复用率 → 路由分布 → 空闲连接年龄 → 复用后错误率
常见误区
- 只看域名相同就判断应当复用,忽略端口与代理差异。
- 复用失败后反复重试死连接,而不是新建健康连接。
追问
- 复用率低如何快速定位?答:按 host 统计 connectStart 次数与请求次数,找出未复用的路由维度。
- 连接忙导致的失败与连接死亡如何区分?答:忙是暂时不可用、等空闲或新建;死亡伴随读写错误与关闭信号。
07.1.1.9.1-063 长连接在移动网络 NAT 超时后会有什么问题?
一句话结论
运营商 NAT 表项有空闲超时,长连接静默过久后中间映射被回收,客户端仍以为连接存活;下次复用发送数据时才发现通路已断,表现为首包超时、RST 或 EOF。
概念解释
移动网络(蜂窝)NAT 与基站状态变化比 Wi-Fi 更频繁,空闲长连接容易失效。问题不在对端服务而在中间映射;客户端探测滞后导致复用死连接。缓解方式是控制空闲时长、必要时心跳保活(权衡功耗)、复用失败快速重建。
原理流程
空闲静默 → NAT 映射超时回收
→ 客户端连接看似存活
→ 复用发数据 → 无响应/RST/EOF → 失败 → 重建
代码或图示
对策:缩短 keepAlive、按网络类型调整、失败快速重试、关键链路按需心跳
常见误区
- 在蜂窝网络下沿用 Wi-Fi 的长空闲时长,死连接比例升高。
- 用高频心跳保活,抵消长连接省下的功耗。
追问
- 心跳间隔怎么定?答:需小于典型 NAT 超时并结合功耗预算实测;具体 NAT 时长随运营商变化(待确认)。
- 切换 Wi-Fi/蜂窝后旧连接还能用吗?答:网络切换后路由与通路变化,旧连接多已失效,新连接走新网络。
07.1.1.9.1-064 如何按域名拆分连接池以隔离不同业务?
一句话结论
为不同业务域构造独立 OkHttpClient,各自持有独立 ConnectionPool(可共享 Dispatcher 或各自配置),使各业务连接互不占用、配额与超时单独调优。
概念解释
单例共享池便于通用复用,但多业务混用时,一个慢业务占用连接会影响其他业务。隔离方案是按业务拆分 client:连接池独立,必要时限速与超时独立;公共组件仍可共享底层配置。注意派生客户端默认共享池,需要隔离时必须传入新建 ConnectionPool。
原理流程
业务 A clientA(poolA, dispatcherA)
业务 B clientB(poolB, dispatcherB)
→ 连接、超时、并发配额互不影响
代码或图示
val poolA = ConnectionPool(...)
val clientA = base.newBuilder().connectionPool(poolA).build()
val poolB = ConnectionPool(...)
val clientB = base.newBuilder().connectionPool(poolB).build()
常见误区
- 用
newBuilder()后以为池已隔离;默认仍共享原池,必须显式传新池。 - 过度拆分导致连接总数上升,整体资源占用反增。
追问
- 隔离到什么粒度合适?答:按 SLA 差异大的业务(核心交易 vs 图片/日志)拆分,普通接口共享即可。
- 隔离后公共拦截器如何复用?答:抽取公共配置方法,在各 builder 上统一挂载。
07.1.1.9.1-065 连接池与 Keep-Alive 头之间是什么关系?
一句话结论
连接池是客户端侧的连接复用管理,Keep-Alive 响应头是服务端侧的存活提示;池的空闲时长应参考服务端建议,避免在对端已关闭后仍长时间保留死连接。
概念解释
服务端可通过 Keep-Alive: timeout=N 告知空闲连接保留多久;客户端池的 keepAlive 决定本地保留策略。两者不一致时,以先到的淘汰为准:本地保留超过服务端时长就可能复用死连接。HTTP/2 下连接存活语义与 HTTP/1 的 Keep-Alive 头不完全相同(待确认具体协商字段)。
原理流程
服务端响应 Keep-Alive: timeout=60
客户端池 keepAlive=300s
→ 60s 后对端可能关闭;客户端 300s 内复用即踩死连接
对齐:客户端空闲时长 ≤ 服务端 timeout
代码或图示
客户端 ConnectionPool keepAliveDuration 与服务端 Keep-Alive timeout 对齐
常见误区
- 只看本地 keepAlive,忽略服务端已主动缩短存活时间。
- 把
Connection: keep-alive与 Keep-Alive 时长混为一个字段。
追问
- 服务端不返回 Keep-Alive 时怎么办?答:按客户端默认时长与弱网实测调整,监控复用后失败率。
- HTTP/2 的连接存活由什么控制?答:协议层设置与服务端关闭行为,客户端池按空闲状态管理,具体字段以协议实现为准(待确认)。
07.1.1.9.1-066 OkHttp 的 Cache 是基于什么结构做磁盘缓存的?
一句话结论
磁盘缓存基于文件系统目录实现,每条缓存条目由响应体文件与索引元数据组成,按 HTTP 语义管理新鲜度、校验条件与淘汰配额;不使用数据库索引。
概念解释
缓存目录下条目以哈希命名,包含响应体与头信息;Cache 负责写入、读取、校验过期与按容量淘汰。缓存线程化写入与清理,读取命中时直接从磁盘文件取体。配置 Cache(directory, maxSize) 即启用磁盘缓存。
原理流程
启用 Cache(dir, maxSize)
→ 响应可缓存:写元数据 + 体文件
→ 请求到来:按索引查条目 → 新鲜度判断 → 命中/回源
→ 超配额:按淘汰策略清理旧条目
代码或图示
val cacheDir = File(context.cacheDir, "http")
val cache = Cache(cacheDir, 10L * 1024 * 1024)
常见误区
- 把缓存目录放私有外部存储且不做清理策略;配额由 Cache 自身管理。
- 多进程共用同一缓存目录,索引与文件竞争导致损坏。
追问
- 缓存能在内存层再加速吗?答:磁盘 Cache 是落盘层;内存级缓存需业务层自行管理,注意一致性与容量。
- 缓存损坏如何恢复?答:Cache 会跳过损坏条目;必要时清理目录重建,具体容错行为以实现为准(待确认)。
07.1.1.9.1-067 Cache-Control 各指令在客户端缓存中如何解释?
一句话结论
no-cache 表示可用前必须回源校验,no-store 表示禁止落盘存储,max-age 控制新鲜期,must-revalidate 过期后不得用陈旧响应,private/public 影响缓存归属;客户端按请求与响应两侧指令综合判定。
概念解释
缓存判定同时看请求头与响应头:请求 Cache-Control: no-cache 强制绕过本地新鲜判断;响应 max-age=0 立即进入校验;no-store 连元数据都不落盘。no-cache 不等于不缓存,而是每次需校验后才能用。
原理流程
响应指令:max-age / no-store / no-cache / must-revalidate / private
请求指令:no-cache / max-age=... / only-if-cached
→ 综合计算:可新鲜使用 / 需校验 / 禁止缓存
代码或图示
Cache-Control: max-age=60, must-revalidate
→ 60 秒内直接用;过期后必须带条件请求回源校验
常见误区
- 把
no-cache理解为完全不存;它允许存但必须校验。 - 忽略请求侧
no-cache,服务端响应再新鲜也应回源。
追问
max-stale客户端能容忍陈旧吗?答:请求可带max-stale接受过期响应,客户端是否采用按实现与指令语义处理(待确认版本行为)。private响应能否进共享缓存?答:按语义只归属私有缓存;移动端单用户场景下仍可由本地 Cache 管理。
07.1.1.9.1-068 什么条件下走强缓存、什么条件下回源校验?
一句话结论
响应在 max-age 新鲜期内且无强制回源指令时走强缓存直接返回;超过新鲜期但可校验(有 ETag 或 Last-Modified)则带条件请求回源校验;不可校验或校验失败则重新拉取完整响应。
概念解释
强缓存不发网络请求,直接读本地;校验回源只发条件请求,304 复用本地体。新鲜度计算结合 max-age、Expires 与 Age。需要校验标识:ETag 对应 If-None-Match,Last-Modified 对应 If-Modified-Since。
原理流程
本地有条目
→ 新鲜:强缓存返回
→ 过期 + 有校验标识:条件请求 → 304 升级 / 200 新内容
→ 无可校验标识:完整回源
代码或图示
响应头:ETag: "v123",Last-Modified: ...
回源请求:If-None-Match: "v123"
常见误区
- 有 ETag 就认为一定走校验;过期判断先于校验。
- 强缓存命中后不更新任何元数据;新鲜度时间随响应刷新。
追问
- 强缓存命中率怎么统计?答:区分本地新鲜命中、304 校验命中、完整回源三类计数上报。
- 动态数据如何避免被强缓存?答:服务端设置
no-cache/短max-age,或客户端绕过缓存。
07.1.1.9.1-069 响应不可缓存的典型情形有哪些?
一句话结论
典型情形:no-store 指令、非缓存方法(如 POST/PUT 默认)、响应状态码不可缓存、缺少可缓存性且需授权头、响应头明确禁止存储,以及流式/不可重复读取的体。
概念解释
HTTP 语义对可缓存范围有约定:GET/HEAD 的成功响应通常可缓存;POST 响应是否可缓存取决于服务端明确指令。带 Authorization 的响应默认视为私有且不可被共享缓存复用,移动端本地行为按实现处理(待确认细节)。不可缓存响应不会写入磁盘 Cache。
原理流程
响应到达缓存拦截器
→ 检查指令/方法/状态码/头
→ 不可缓存:不写盘,直接交上层
→ 可缓存:写元数据 + 体文件
代码或图示
不可缓存示例:Cache-Control: no-store;401/500 默认不缓存;POST 无显式缓存指令
常见误区
- 给 POST 响应也期待本地缓存兜底;默认不落盘。
- 把含敏感凭证的响应允许缓存,违反
no-store语义。
追问
- 如何强制某接口不使用缓存?答:请求加
Cache-Control: no-cache,或配置无缓存客户端。 - 错误响应要缓存吗?答:5xx 临时错误不应长期缓存;按业务决定是否短暂兜底。
07.1.1.9.1-070 缓存命中与未命中的响应头在拦截器层如何体现?
一句话结论
命中本地缓存的响应可能携带缓存相关头(如来自缓存标记),未命中则真正走网络并回写缓存;在网络拦截器能否被调用、响应是否带条件请求头上可区分命中类型。
概念解释
应用拦截器看到最终 Response,难以直接区分强缓存与网络结果;网络拦截器在缓存未命中时才执行,其请求是否带 If-None-Match 可判断是否为校验回源。缓存条目自身记录新鲜度与校验元数据,不全部暴露为业务响应头。
原理流程
强缓存:网络拦截器不执行,无网络请求
校验回源:网络拦截器执行,请求带条件头,可能 304
未命中:网络拦截器执行,完整请求响应,响应写缓存
代码或图示
override fun intercept(chain: Interceptor.Chain): Response {
val req = chain.request()
val resp = chain.proceed(req)
val fromCache = resp.networkResponse == null // 标记语义以版本 API 为准(待确认)
return resp
}
常见误区
- 靠响应头里固定字段判断缓存命中;字段名随实现而定,应结合网络/缓存响应引用判断。
- 在网络拦截器统计强缓存命中,得到的只是回源与校验样本。
追问
- Response 上如何区分本地与网络来源?答:可通过
cacheResponse/networkResponse引用判断,具体 API 名以当前版本为准(待确认)。 - 304 响应在缓存命中统计里算哪类?答:算校验命中,不计完整回源。
07.1.1.9.1-071 如何手动强制刷新或绕过缓存?
一句话结论
在请求上设置 Cache-Control: no-cache 强制回源校验,或 Cache-Control: no-store 不读取本地;也可构造不带缓存配置的客户端直接请求。需要强制最新数据时不要依赖本地新鲜度判断。
概念解释
绕过缓存分两种:no-cache 仍可走条件校验(304 复用体),no-store 完全不碰本地。客户端侧还可以通过请求头覆盖响应的新鲜度指令。注意手动绕过只影响本次请求,不清理已有缓存条目。
原理流程
请求加 Cache-Control: no-cache → 缓存拦截器不直接用本地,走条件回源
请求加 no-store → 不读不写本地缓存
代码或图示
val req = Request.Builder().url(url)
.header("Cache-Control", "no-cache")
.build()
常见误区
- 以为清掉内存对象就能清磁盘缓存;磁盘条目仍在目录中。
- 给动态接口加
no-store后又期待离线兜底。
追问
- 如何清空已有磁盘缓存?答:调用
Cache的清空方法或删除缓存目录重建(方法名以版本 API 为准,待确认)。 - 强制刷新会影响连接复用吗?答:不影响连接层,只是缓存判定不同。
07.1.1.9.1-072 POST/PUT 响应为什么默认不被缓存?
一句话结论
HTTP 语义默认认为非安全方法(POST/PUT/DELETE)产生副作用,响应不具备可复用性;除非服务端通过明确缓存指令声明可缓存,否则客户端不落盘缓存。
概念解释
缓存的前提是同一请求重复执行结果一致。POST 通常改变服务端状态,重复复用旧响应可能导致数据不一致。GET/HEAD 是安全方法,其成功响应更适合缓存。POST 响应即使被缓存,复用风险也需业务自行评估。
原理流程
方法非 GET/HEAD → 默认不可缓存
→ 响应带显式可缓存指令 → 按指令评估
→ 仍不可缓存 → 不写盘
代码或图示
GET /list → 可缓存候选
POST /order → 默认不缓存
PUT /profile → 默认不缓存
常见误区
- 把 POST 列表接口的响应也指望本地缓存兜底。
- 缓存了写操作响应,重试时展示过期结果。
追问
- 服务端能否让 POST 响应可缓存?答:可通过显式缓存指令声明,但需确保该请求幂等且结果可复用,语义风险由服务端承担。
- 查询类 POST(复杂条件查询)怎么办?答:按不可缓存处理,或改 GET 带查询参数以便走缓存。
07.1.1.9.1-073 缓存目录损坏或配额超限如何处理?
一句话结论
配额由 Cache 按上限自动淘汰旧条目;目录损坏时实现会跳过不可读条目,严重时清理目录重建。业务侧应把缓存目录放在应用私有缓存区,并在异常路径上兜底走网络。
概念解释
Cache 内部维护索引与体文件,写入失败、文件被外部清理或多进程竞争都可能造成条目不一致。读取损坏条目时不应让崩溃冒泡到业务;监控缓存读写异常并定期清理目录是工程兜底。配额超限触发的淘汰属于正常行为,不视为错误。
原理流程
写入 → 超配额 → 淘汰旧条目
读取 → 条目损坏 → 跳过/回源
异常无法恢复 → 清理缓存目录重建
代码或图示
// 兜底:缓存不可用时直接网络请求
val req = Request.Builder().url(url).build()
常见误区
- 多进程共享同一缓存目录且无同步,索引损坏概率升高。
- 把缓存目录放外部公共存储,被其他应用随意清理。
追问
- 缓存大小如何选?答:按可缓存资源体量与磁盘余量设定上限,监控缓存占用与淘汰频率。
- 缓存损坏会导致崩溃吗?答:正常实现应容错跳过;若线上出现缓存相关异常,需结合具体版本与堆栈确认(待确认)。
07.1.1.9.1-074 连接、读取、写入、整体超时分别指什么阶段?
一句话结论
connectTimeout 控制建立 TCP 连接的等待,readTimeout 控制两次数据读取之间的间隔,writeTimeout 控制写入数据的间隔,callTimeout 控制整次 Call(含所有阶段)的总时长。
概念解释
四个超时对应不同阶段:连接超时在建连握手阶段生效;读写超时是套接字级别的间隔超时,不是整段传输上限;整体超时是 Call 级别的兜底,防止任一阶段无限挂起。下载大文件时 readTimeout 按数据到达间隔设置,而非总时长。
原理流程
callTimeout(整段上限)
├─ connectTimeout:TCP 建连等待
├─ writeTimeout:写报文间隔
└─ readTimeout:读响应间隔
代码或图示
OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.writeTimeout(10, TimeUnit.SECONDS)
.callTimeout(30, TimeUnit.SECONDS)
常见误区
- 把 readTimeout 当成下载总时长;它是两次读取的间隔,慢速持续传输不会触发。
- 只设 connectTimeout,忽略读写与整体兜底,弱网下请求长期挂起。
追问
- 哪个超时覆盖整次请求?答:
callTimeout,从 Call 开始到响应体读完结束,具体边界以实现为准(待确认)。 - 超时异常类型是什么?答:连接/读写超时抛
SocketTimeoutException相关 IOException,整体超时另有对应异常类型(待确认版本)。
07.1.1.9.1-075 全局超时与单请求超时如何覆盖?
一句话结论
客户端 builder 上设置的是全局默认超时;单个请求可通过 Request.Builder 派生覆盖对应超时,未覆盖的字段沿用全局值。
概念解释
全局配置对所有 Call 生效,适合统一基线;大文件下载、长轮询等特殊接口单独放宽或收紧。覆盖是字段级的:只改 readTimeout 不影响其他三项。派生客户端也可以为某类接口整体配置独立超时。
原理流程
全局 client:connect/read/write/call 默认值
单请求:request.tag 或超时覆盖 → 仅本次 Call 生效
代码或图示
val req = Request.Builder().url(url)
.readTimeout(30, TimeUnit.SECONDS) // 单请求覆盖(API 形态以版本为准,待确认)
.build()
常见误区
- 以为单请求覆盖会重置全部超时;实际只覆盖指定字段。
- 为长轮询放宽全局 readTimeout,拖累普通接口在弱网下的挂起时间。
追问
- 超时配置放在派生 client 还是单请求?答:同类接口放派生 client 统一管理,个别特例放单请求。
- 超时能在拦截器里动态改吗?答:超时属于客户端/请求配置,拦截器改的是请求对象,不直接改套接字超时;动态调整需在构造请求时确定。
07.1.1.9.1-076 超时抛的是什么异常,如何区分网络超时与业务失败?
一句话结论
超时类失败抛 IOException 子类(连接/读取/写入超时对应 SocketTimeoutException 等),业务失败是 HTTP 状态码非 2xx 或业务码错误;前者是传输层问题可重试,后者是服务端应答,不应按超时重试。
概念解释
异常类型与响应状态要分开判断:onFailure 里的异常代表请求未拿到有效响应;拿到 Response 后再按 code 判断业务成败。区分超时、连接拒绝、DNS 失败、SSL 错误有助于选择重试策略与上报分类。
原理流程
onFailure(e):传输层失败 → 按异常类型分类(超时/拒绝/DNS/SSL)
onResponse(resp):拿到响应 → 按 code 与业务码判断成败
代码或图示
override fun onFailure(call: Call, e: IOException) {
when (e) {
is SocketTimeoutException -> report("timeout")
else -> report("network")
}
}
常见误区
- 把 5xx 响应当成网络异常去重试;它是服务端明确应答。
- 不区分超时类型,所有失败都走同一重试次数。
追问
- 408 与 readTimeout 是一回事吗?答:408 是服务端返回的状态码;readTimeout 是客户端等待读数据超时,两者来源不同。
- 异常分类上报包含哪些字段?答:异常类型、消息、阶段(connect/read/write/call)、路径、网络类型。
07.1.1.9.1-077 分片下载时 readTimeout 如何设置才合理?
一句话结论
下载大文件应按「数据到达间隔」设置 readTimeout,保证慢速持续传输不被误杀;整体时长由 callTimeout 或业务侧分段控制,避免单次 readTimeout 等于文件总下载时限。
概念解释
readTimeout 是两次读取之间的最大间隔,持续有数据到达就不会触发;若按总下载时长设 readTimeout,大文件必然超时。分片下载可每片单独请求,每片超时独立计算,失败只重传该片。
原理流程
分片 1 → 请求 → 间隔内持续到达 → 完成
分片 2 → 同上
单片超时 → 只重试该片,不重传整文件
代码或图示
// 分片请求:每片独立超时
val range = "bytes=$start-$end"
Request.Builder().url(fileUrl).header("Range", range).build()
常见误区
- 大文件用全局短 readTimeout,下载到一半被掐断。
- 整文件一次性缓冲到内存再写盘,峰值内存过高。
追问
- 下载中途断网如何续传?答:记录已下载偏移,用 Range 请求从断点续传,服务端需支持分片。
- 写盘慢会触发 readTimeout 吗?答:读取间隔受消费速度影响,写盘阻塞可能拉长读取间隔,需边下边写并控制缓冲。
07.1.1.9.1-078 超时计时在连接复用与重试下如何重置?
一句话结论
复用连接时本次交换重新计时读写超时;连接阶段超时只在建连时生效。链内重试会产生新的交换,各阶段超时按本次交换重新计算,整体 callTimeout 则贯穿整次 Call 不随重试重置。
概念解释
要区分套接字级超时与 Call 级超时:connect/read/write 超时绑定单次交换,重试或复用连接后重新计时;callTimeout 是整次 Call 的总预算,重试不延长总时长。理解这一点才能避免「重试把总耗时无限拉长」。
原理流程
复用连接:跳过 connect 阶段,read/write 重新计时
重试交换:新交换重新走各阶段超时
callTimeout:从首次 callStart 到结束,累计不重置
代码或图示
交换1:connect/read/write 计时 → 失败
交换2(重试):各阶段重新计时
callTimeout:两次交换总时长受上限约束
常见误区
- 以为重试后 readTimeout 也从头累计进总时长;套接字超时按交换重置,整体超时不重置。
- 关闭 callTimeout 又允许多次重试,弱网下请求长期挂起。
追问
- 重试次数在哪一层控制?答:连接失败重试由客户端开关控制,业务重试在应用层用新 Call 发起。
- 如何统计重试带来的额外耗时?答:按交换事件分别记录阶段耗时,再汇总整 Call 时长。
07.1.1.9.1-079 callTimeout 与其他三个超时的关系是什么?
一句话结论
callTimeout 是整次 Call 的总预算上限,覆盖连接、写入、读取与等待的全部时间;connect/read/write 是各阶段的局部超时,局部超时先触发则先报对应异常,整体超时兜底防止任何阶段无限挂起。
概念解释
四者是嵌套关系:整体超时包住三个阶段超时。设置 callTimeout 后,即使某阶段超时未配置或过长,整次 Call 也不会超过总预算。适合给批量请求、弱网场景加一道全局兜底,避免线程与连接长期占用。
原理流程
callTimeout 总预算
→ connectTimeout(建连局部)
→ writeTimeout(写局部)
→ readTimeout(读局部)
任一局部超时先触发 → 对应异常;否则总预算到点触发整体超时
代码或图示
OkHttpClient.Builder()
.callTimeout(30, TimeUnit.SECONDS)
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
常见误区
- 只配 callTimeout 不配阶段超时,单阶段长时间挂起的定位信息缺失。
- 把 callTimeout 设得比 readTimeout 还短,正常慢速传输被整体超时掐断。
追问
- callTimeout 包含响应体读取完吗?答:包含到本次 Call 结束(含体消费),具体边界以版本实现为准(待确认)。
- 长轮询接口怎么配?答:放宽 read/call 超时或改用支持挂起的协议,不要用普通短超时 Call 硬扛长等待。
07.1.1.9.1-080 OkHttp 的 DNS 解析在哪一步发生,可否自定义?
一句话结论
DNS 解析发生在选路由阶段(建连之前),客户端通过 Dns 接口解析主机名;可注入自定义 Dns 实现替换系统解析,做就近接入、Host 映射或多 IP 策略。
概念解释
Dns.lookup(hostname) 返回候选 IP 列表,路由选择器结合代理与协议从中挑选。系统默认实现走 InetAddress 解析。自定义 DNS 可缓存解析结果、按网络类型返回不同 IP、拦截特定域名。解析失败属于可分类的网络错误。
原理流程
请求 → 路由选择 → Dns.lookup(host) → IP 列表
→ 结合代理/协议选 Route → 建连
代码或图示
val client = OkHttpClient.Builder()
.dns(Dns.SYSTEM) // 可替换为自定义实现
.build()
常见误区
- 把 DNS 解析放在拦截器里做;解析在连接选路阶段,拦截器拿不到 IP 候选。
- 自定义 DNS 不处理异常,解析失败直接抛崩溃。
追问
- DNS 结果要缓存吗?答:可短期缓存减少解析次数,但要注意 TTL 与故障切换;缓存策略自行实现。
- 系统解析失败如何兜底?答:在自定义 Dns 中返回备用 IP 或回退系统解析,并上报解析失败。
07.1.1.9.1-081 如何实现自定义 DNS 做就近接入或 Host 映射?
一句话结论
实现 Dns 接口的 lookup,按域名返回内置映射或调度后的 IP 列表;配合路由选择与连接池,使指定域名直连目标 IP,同时保留 Host 头用于虚拟主机与证书校验。
概念解释
自定义 DNS 常见用途:绕过本地 DNS 做调度、域名映射到固定 IP、内网环境 Hosts 替代。注意直连 IP 后请求 Host 头仍应保留原域名,否则服务端虚拟主机路由与证书主机名校验可能失败。多 IP 时按顺序尝试,失败切换下一个。
原理流程
lookup("api.example.com")
→ 调度表/本地映射 → 选定 IP 列表
→ 连接到 IP,Host 头保留域名
代码或图示
class MappingDns(private val map: Map<String, List<InetAddress>>) : Dns {
override fun lookup(hostname: String): List<InetAddress> =
map[hostname] ?: Dns.SYSTEM.lookup(hostname)
}
常见误区
- 直连 IP 后把 Host 改成 IP,导致虚拟主机与 SNI/证书不匹配。
- 映射表不随网络环境更新,Wi-Fi/蜂窝下指向错误内网地址。
追问
- 自定义 DNS 会影响证书校验吗?答:证书主机名仍按域名校验;IP 直连只改变连接目标,不改校验对象。
- 多 IP 故障切换在哪一层?答:路由选择器按候选 IP 尝试,具体切换策略与重试行为以实现为准(待确认)。
07.1.1.9.1-082 代理(Proxy)与代理选择器如何配置?
一句话结论
可在客户端固定设置 Proxy,或通过 ProxySelector 按 URL/网络环境动态选择直连或代理;代理类型支持 HTTP 与 SOCKS,代理地址与凭证随路由一起参与连接复用匹配。
概念解释
固定代理适合调试与强制走代理场景;选择器适合按域名分流(内网直连、外网走代理)。代理凭证通过 Authenticator 在代理握手需要时提供。代理属于路由键,不同代理之间连接不复用。
原理流程
请求 URL → ProxySelector.select(uri) → 候选代理列表
→ 构造 Route(host, port, proxy) → 经代理建连
→ 需要代理认证 → Authenticator 提供凭证
代码或图示
val proxy = Proxy(Proxy.Type.SOCKS, InetSocketAddress("127.0.0.1", 1080))
val client = OkHttpClient.Builder().proxy(proxy).build()
常见误区
- 配置代理后忘记处理代理认证,握手 407 失败。
- 调试代理残留到正式包,影响线上连接与隐私。
追问
- 代理认证信息放哪?答:通过
Authenticator在收到代理质询时注入,避免硬编码到连接参数。 - 代理选择器抛异常会怎样?答:解析代理失败按网络错误处理,需在选择器内兜底返回直连。
07.1.1.9.1-083 系统代理被自动识别会带来什么安全风险?
一句话结论
客户端默认可能读取系统代理设置,若设备配置了恶意或不可信代理,流量会经过第三方;敏感接口应明确直连或使用受控代理,并在生产配置中审查代理链路与 TLS 校验。
概念解释
系统代理常用于企业网络与抓包调试;默认跟随系统意味着代理环境变化会影响请求路径。风险包括:代理记录明文头(HTTPS 仍加密,但 TLS 终止代理可解密)、代理故障导致连接异常。安全敏感场景应固定直连或限定可信代理。
原理流程
请求 → 读取系统代理配置 → 经代理转发
风险:不可信代理观测/篡改流量;TLS 终止代理需信任其证书
代码或图示
// 显式直连,不跟随系统代理
val client = OkHttpClient.Builder().proxy(Proxy.NO_PROXY).build()
常见误区
- 认为走 HTTPS 就不怕代理;TLS 终止代理持有解密能力。
- 调试期开启系统代理抓包,正式包未关闭。
追问
- 如何检测当前是否走代理?答:通过路由信息或连接事件观察代理类型,上报网络环境时一并记录。
- 企业内网代理如何配置才安全?答:使用受控代理地址与认证,配合证书固定与网络安全配置评估风险。
07.1.1.9.1-084 DNS 轮询多 IP 时连接与重试如何配合?
一句话结论
自定义 DNS 返回多个候选 IP,路由选择器按顺序尝试建连;首个 IP 不通时切换下一个,成功的连接按其路由入池。业务层无需为每个 IP 重复发起请求。
概念解释
多 IP 解析用于故障转移与就近接入:解析结果列表是候选,不是并行全部连接。切换在选路与建连阶段完成;连接池可能同时保留不同 IP 的连接,后续请求按当次解析选择。多 IP 与重试配合要控制尝试次数,避免弱网下放大建连风暴。
原理流程
lookup 返回 [IP1, IP2, IP3]
→ 尝试 IP1 建连失败 → 切换 IP2
→ 成功 → 该连接入池复用
代码或图示
override fun lookup(hostname: String) = when (hostname) {
"api.example.com" -> listOf(ip1, ip2)
else -> Dns.SYSTEM.lookup(hostname)
}
常见误区
- 以为多 IP 会并发建连提速;默认按候选顺序尝试。
- 候选 IP 全部失败后不区分是 DNS 问题还是单点不可达。
追问
- 如何选择最优 IP?答:可结合就近解析、延迟探测排序,探测成本与收益需权衡;具体排序策略在自定义 Dns 内实现。
- 切换 IP 后旧连接还在池里吗?答:在,直到空闲淘汰;不同 IP 属于不同连接,互不影响。
07.1.1.9.1-085 直连与代理混用时连接池如何区分?
一句话结论
直连、HTTP 代理、SOCKS 代理属于不同路由,池内分别管理候选连接;同一目标地址经不同代理不复用,切换代理后新建对应连接。
概念解释
路由键包含代理类型与地址,混用场景下池内可能并存多条到同域名的连接:一条直连、一条经代理。按本次请求选择的路由匹配对应连接。调试与正式环境若共享客户端,需注意代理连接残留。
原理流程
直连 Route(example, NO_PROXY)
代理 Route(example, http-proxy)
→ 两组候选独立匹配
代码或图示
匹配键:目标地址 + 代理 + 协议 + TLS 配置
代理不同:键不同,不复用
常见误区
- 切换代理后期望复用直连旧连接,导致建连失败或走错通道。
- 混用时不隔离客户端,调试代理连接残留到正式流量。
追问
- 如何在切换环境后清掉旧代理连接?答:派生独立客户端与连接池,或在环境切换时清理池内连接。
- 代理连接的复用率怎么看?答:按代理维度拆分连接指标,避免与直连混合统计。
07.1.1.9.1-086 HTTP/2 多路复用在一条连接上如何承载并发流?
一句话结论
HTTP/2 把请求/响应拆成帧,在一条 TCP 连接上为每个请求分配独立流(stream),帧按流标识交错传输,多个流并发复用同一连接,避免 HTTP/1 一队头阻塞式的串行等待。
概念解释
多路复用的核心是流与帧:每个流有独立标识与状态,请求头、数据、响应头、响应数据分帧在连接上交错。流之间在应用层并发,但共享一条 TCP 连接的带宽。连接合并与单主机连接数下降都建立在多路复用之上。
原理流程
一条 TCP/TLS 连接
├─ stream 1:帧序列
├─ stream 2:帧序列
└─ stream 3:帧序列
帧按流标识重组为各请求/响应
代码或图示
帧类型:HEADERS / DATA / RST_STREAM / SETTINGS / WINDOW_UPDATE
常见误区
- 认为多路复用消除了所有队头阻塞;TCP 层丢包仍会阻塞整条连接。
- 把 HTTP/2 流当成独立连接做连接数统计。
追问
- 流之间如何分配优先级?答:协议支持流权重与依赖,客户端实现是否暴露优先级 API 以版本为准(待确认)。
- 一条连接流过多会怎样?答:受流控窗口与对端设置约束,过慢流可能拖慢共享连接上的其他流。
07.1.1.9.1-087 HTTP/2 流控与单连接高并发有什么关系?
一句话结论
HTTP/2 流控通过窗口限制发送方在未确认接收前可推送的数据量;窗口不足时流等待,高并发下表现为流被挂起,而不是新建更多连接。理解流控有助于解释单连接下的吞吐瓶颈。
概念解释
流控分连接级与流级窗口,接收方通过 WINDOW_UPDATE 释放额度。慢消费方会压低窗口,影响其流的推送速度;共享连接上其他流仍可传输。移动端上行受限或服务端处理慢时,流等待是常见现象,需与连接阻塞区分。
原理流程
发送方数据量 ≤ 流窗口 → 连续发送
窗口耗尽 → 等待 WINDOW_UPDATE
连接窗口与流窗口分别约束
代码或图示
WINDOW_UPDATE:更新接收窗口
RST_STREAM:中止流
常见误区
- 流控等待被误判为连接超时;实际连接存活,只是流额度不足。
- 以为提高并发流数就能提吞吐;窗口与带宽才是上限。
追问
- 流控窗口初始值在哪协商?答:连接建立时通过 SETTINGS 帧交换,具体默认值以协议实现为准(待确认)。
- 如何观测流控等待?答:结合响应体读取速率与事件时间点分析,公开客户端未必暴露流级窗口细节。
07.1.1.9.1-088 协议协商(ALPN)在握手阶段如何完成?
一句话结论
HTTPS 握手时通过 ALPN 扩展在 TLS 握手中协商应用层协议(如 h2 与 http/1.1),服务端从客户端提供的列表中选择,双方据此决定后续走 HTTP/2 还是 HTTP/1.1。
概念解释
ALPN 避免了先建 TLS 再单独协商协议的额外往返。客户端在 ClientHello 带上支持的协议列表,服务端在扩展中回选一个;协商结果决定 Codec 选择。代理环境下 ALPN 能否透传取决于代理实现。
原理流程
ClientHello(alpn: h2, http/1.1)
→ ServerHello(alpn: h2)
→ 双方使用 HTTP/2
未协商出 h2 → 回退 HTTP/1.1
代码或图示
OkHttp 按客户端配置的 protocols 参与 ALPN 协商
常见误区
- 认为服务端支持 HTTP/2 就一定走 HTTP/2;ALPN 列表与中间代理都可能导致回退。
- 忽略代理对 ALPN 的透传,经代理后协议降级。
追问
- 在哪查看实际协商到的协议?答:Response 的
protocol()字段,或 EventListener 连接事件。 - 如何强制只使用 HTTP/2?答:在客户端 protocols 配置中限定 h2;协商失败按实现回退或报错(待确认行为)。
07.1.1.9.1-089 OkHttp 如何决定使用 HTTP/1.1 还是 HTTP/2?
一句话结论
优先按客户端配置的协议列表与 ALPN 协商结果决定:双方支持且协商出 h2 走 HTTP/2,否则回退 HTTP/1.1;代理、服务端能力与配置都会影响最终协议。
概念解释
客户端可通过 protocols(...) 声明支持顺序;建连时 ALPN 协商匹配。若服务端只支持 HTTP/1、代理不支持 h2,或协商失败,使用 HTTP/1.1。实际协议记录在响应的 protocol 字段,可用于核对线上协议分布。
原理流程
配置 protocols → TLS ALPN 协商
→ 命中 h2:HTTP/2 Codec
→ 否则:HTTP/1.1 Codec
代码或图示
val client = OkHttpClient.Builder()
.protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
.build()
常见误区
- 代码里配置了 h2 就认为线上全部走 h2;需按响应 protocol 统计实际比例。
- 把 HTTP/1.1 连接占用问题归因为连接池;协议回退时本就需要多连接并发。
追问
- 如何统计线上 HTTP/2 占比?答:按响应
protocol()分维度上报。 - 强制 HTTP/1.1 有什么场景?答:兼容性问题、代理仅支持文本协议时临时回退,需记录原因。
07.1.1.9.1-090 TLS 握手与证书链校验发生在哪个拦截器附近?
一句话结论
TLS 握手与证书校验发生在连接建立阶段,贴近 ConnectInterceptor 取出/新建连接之后;应用拦截器在握手之前,网络拦截器在连接可用之后,都不直接做证书链校验。
概念解释
连接新建时完成 TCP 连接与 TLS 握手:协议栈校验证书链有效期、主机名与信任锚;配置证书固定后在握手阶段追加固定校验。复用连接跳过握手。握手失败属于连接阶段错误,归为可分类的网络失败。
原理流程
ConnectInterceptor → 新建连接
→ TCP → TLS 握手 → 证书链/主机名校验 → 固定校验(若配置)
→ 加密连接交付协议层
代码或图示
EventListener: secureConnectStart → secureConnectEnd → connectEnd
常见误区
- 在业务拦截器里做证书校验;校验在握手层完成,拦截器拿到的已是可用连接。
- 复用连接时重复校验证书;复用阶段不再走握手。
追问
- 主机名校验在哪一步?答:TLS 握手后由主机名校验逻辑核对证书 SAN/CN 与请求域名。
- 握手慢怎么定位?答:看 secureConnectStart/End 间隔,区分证书链校验与网络往返。
07.1.1.9.1-091 CertificatePinner 如何校验证书或公钥?
一句话结论
CertificatePinner 在 TLS 握手后按配置的域名匹配规则,校验链路中证书或公钥的 SPKI 指纹是否在固定列表内;不匹配则握手失败。配置按域名添加固定项,指纹以 Base64 编码的哈希形式给出。
概念解释
证书固定可锁定服务端证书或公钥,降低信任被中间 CA 劫持的风险。固定粒度是域名:hostname(pins) 配置该域名接受的指纹。校验基于握手实际链路中的证书,不替代系统信任链校验。固定规则的接入点与 API 形态在 OkHttp 层完成,兜底策略(多指纹、过期轮换)属安全设计范畴。
原理流程
TLS 握手完成 → 取链路证书
→ 按请求域名匹配 pinner 规则
→ 计算 SPKI 指纹 → 命中列表:通过
→ 未命中:抛固定校验异常,连接失败
代码或图示
val pinner = CertificatePinner.Builder()
.add("api.example.com", "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAA=")
.build()
val client = OkHttpClient.Builder().certificatePinner(pinner).build()
常见误区
- 固定了唯一指纹,证书轮换后全部请求失败;应预留备用指纹。
- 把固定规则配到错误域名,子域与通配匹配范围不清。
追问
- 固定证书与固定公钥有何区别?答:固定公钥(SPKI)在证书轮换但密钥不变时仍有效;固定整证书随证书更换需更新规则。
- 指纹如何生成?答:从服务端证书链提取公钥或证书哈希,工具与命令以官方文档为准(待确认具体命令)。
07.1.1.9.1-092 证书固定在代理抓包环境下会有什么表现?
一句话结论
抓包代理用自签或代理证书替换服务端证书后,固定校验比对指纹不匹配,握手直接失败;调试需要临时关闭固定或把代理证书指纹加入固定列表,正式包不得保留调试绕过。
概念解释
固定与抓包代理在安全模型上互斥:中间人代理必然改变证书链路,固定会阻断该链路。开发调试可使用专用调试客户端关闭固定;生产环境绕过固定等于削弱防护,不应通过关固定来排查线上问题。
原理流程
代理解密 → 代理证书替换服务端证书
→ 固定校验指纹不匹配 → 握手异常
调试:调试 client 关闭固定;或加入代理证书指纹
代码或图示
// 仅调试包:不挂 CertificatePinner
val debugClient = base.newBuilder().certificatePinner(CertificatePinner.DEFAULT).build()
常见误区
- 为抓包在正式实现里注释掉固定,打包后忘记恢复。
- 把代理 CA 装成系统信任锚就以为固定会放行;固定仍按指纹校验。
追问
- 线上用户遇到固定失败如何兜底?答:按安全策略决定是否允许解除固定;放宽固定需走灰度与配置开关,不能在客户端无条件绕过。
- 固定失败归为哪类错误?答:握手/证书校验异常,上报时与普通 TLS 错误区分,便于统计固定命中问题。
07.1.1.9.1-093 HTTP/2 连接合并(coalescing)对证书与域名有什么要求?
一句话结论
合并到一条已有连接要求新域名被当前连接的证书覆盖(SAN 匹配)、协议兼容且路由条件一致;证书不含该域名则不能合并,必须新建连接。
概念解释
连接合并是 HTTP/2 下的优化:一条连接已协商的 TLS 证书若覆盖多个域名,后续域名复用该连接开流。判断依据是证书 SAN 与目标域名匹配,而不是 DNS 解析结果相同。跨证书域、HTTP/1 连接、不同代理都不能合并。
原理流程
已有连接证书 SAN: [a.example.com, b.example.com]
请求 b.example.com
→ SAN 覆盖 + HTTP/2 → 合并开流
→ 未覆盖 → 新建连接
代码或图示
合并条件:证书域名匹配 + 同连接安全配置 + 协议支持多路复用
常见误区
- 同主域不同后缀证书未覆盖也期待合并。
- 合并后误以为 Cookie 与缓存跨域名共享;各域独立。
追问
- 合并失败是否影响正确性?答:不影响,只是退回新建连接,复用率下降。
- 如何提升合并成功率?答:统一证书覆盖、收敛域名到同一网关、保持 HTTP/2。
07.1.1.9.1-094 EventListener 可以采集哪些网络指标?
一句话结论
EventListener 覆盖 Call 全生命周期回调:开始/结束、代理选择、DNS、连接建立与释放、TLS 握手、请求头/体、响应头/体、失败等,可据此拆分各阶段耗时与字节量。
概念解释
相比拦截器只能看到整段请求,事件回调深入连接内部阶段。每个回调带 Call 引用,可按 Call 聚合一次请求的完整时间线。实现时按需覆写关心的方法,未覆写的方法默认空实现。
原理流程
callStart → proxySelect → dns → connect → secureConnect
→ requestHeaders/Body → responseHeaders/Body → callEnd / callFailed
代码或图示
val listener = object : EventListener() {
override fun callStart(call: Call) { /* 记录起点 */ }
override fun callEnd(call: Call) { /* 汇总 */ }
}
常见误区
- 在回调里做重 IO 或加锁,拖慢网络线程;回调应轻量记录与异步上报。
- 只采集成功路径,失败回调未覆写导致指标缺失。
追问
- 监听器如何挂到客户端?答:通过
eventListener或eventListenerFactory注册;工厂模式为每个 Call 创建独立实例便于存状态。 - 事件顺序是否固定?答:按阶段触发,复用连接时 connect/secure 相关回调可能缺失。
07.1.1.9.1-095 如何用 EventListener 统计 DNS、握手、首字节耗时?
一句话结论
在对应开始/结束回调里记录时间戳,按 Call 聚合:dnsEnd - dnsStart 为 DNS 耗时,secureConnectEnd - secureConnectStart 为握手耗时,responseHeadersStart 减连接完成时间为首字节耗时。
概念解释
每个阶段成对出现开始/结束回调,时间差即阶段耗时。首字节通常以响应头到达为准;响应体读取时长由 responseBodyEnd 与头到达时间差衡量。按路径、网络类型、成功/失败聚合上报,定位慢在哪一段。
原理流程
dnsStart/dnsEnd → DNS 耗时
connectStart/End → TCP 耗时
secureConnectStart/End → TLS 握手耗时
responseHeadersStart → 首字节时间
responseBodyEnd → 体读取结束
代码或图示
override fun dnsStart(call: Call, domain: String) { t[domain] = System.nanoTime() }
override fun dnsEnd(call: Call, domain: String, ips: List<InetAddress>) {
metrics.report("dns", System.nanoTime() - t[domain]!!)
}
常见误区
- 用整 Call 耗时代替阶段耗时,无法定位是 DNS、握手还是传输慢。
- 复用连接时仍期待 connect 回调;复用阶段没有建连事件。
追问
- 首字节时间包含排队吗?答:从 CallStart 算包含排队,从连接完成算不含;指标口径要写明。
- 如何统计响应体大小?答:在
responseBodyEnd回调结合字节计数,分块传输需累计实际读取量。
07.1.1.9.1-096 retryOnConnectionFailure 打开后会重试什么、不重试什么?
一句话结论
该开关控制在连接层面遇到可恢复的连接失败时是否自动重建连接重试;它不处理业务状态码失败,也不替代业务层的幂等重试。开关默认开启(默认值以版本为准,待确认)。
概念解释
重试针对建连与交换中发现的连接类问题,例如连接不可用、写入/读取时连接异常;重试会在链内产生后续交换。HTTP 响应已明确返回(含 5xx)不属于该重试范围。自动重试是否安全取决于请求幂等性,非幂等接口需谨慎。
原理流程
交换中连接失败(可恢复类型)
→ retryOnConnectionFailure 开启:重新选路建连,再发请求
→ 关闭:直接把异常交回上层
业务码/HTTP 错误:不经过该重试
代码或图示
val client = OkHttpClient.Builder()
.retryOnConnectionFailure(true)
.build()
常见误区
- 以为打开开关会自动重试 5xx 或业务失败;不会。
- 非幂等 POST 依赖自动重试,造成重复写入风险。
追问
- 自动重试次数有限制吗?答:连接失败重试由实现控制次数与条件,不暴露无限重试;具体策略以版本源码为准(待确认)。
- 重试会复用同一连接吗?答:原连接失败后通常新建连接再试。
07.1.1.9.1-097 哪些异常属于可重试的连接失败?
一句话结论
典型可重试类型:连接被重置/断开、读写时套接字异常、代理/路由临时不可用等连接层瞬时故障;DNS 解析失败、证书校验失败、明确的 4xx 响应通常不属于连接重试范围。
概念解释
判断标准是「连接通道瞬时不可用,换一条路由可能成功」。不可重试的是确定性错误:证书不匹配、主机名错误、请求格式被拒、业务鉴权失败。分类清楚后再决定自动重试还是上层退避重试。
原理流程
连接层瞬时故障:reset / EOF / 连不上代理 → 候选重试
确定性错误:SSL 校验失败 / DNS 无解析 / 4xx → 不重试
代码或图示
分类:SocketException(连接中断) 可重试
SSLPeerUnverifiedException 不可重试
UnknownHostException 视 DNS 策略处理
常见误区
- 把证书错误也重试多次,浪费请求且无意义。
- DNS 失败盲目重试同一路由,应切换解析或上报。
追问
- 读取一半连接断开算可重试吗?答:取决于请求是否幂等与服务端是否已处理;已收到部分响应时重试需业务判断。
- 重试间隔由谁控制?答:客户端连接重试不做退避;业务层重试应加指数退避与抖动。
07.1.1.9.1-098 业务层如何基于幂等键做请求去重?
一句话结论
为写操作生成唯一幂等键,请求头携带并由服务端在窗口期内去重;客户端在重试/超时重复提交时复用同一幂等键,保证重复请求不会产生多条业务数据。
概念解释
网络超时后客户端不确定服务端是否已处理,重试可能造成重复下单。幂等键让服务端识别同一笔业务:首次处理并记录结果,重复键返回既有结果。客户端生成策略需保证同一业务操作多次提交使用同一键。
原理流程
提交业务 → 生成幂等键 key
→ 请求头 Idempotency-Key: key
→ 超时/失败重试:复用同一 key
→ 服务端:首请求处理;重复键返回原结果
代码或图示
val req = Request.Builder().url(submitUrl)
.header("Idempotency-Key", idempotencyKey)
.post(body)
.build()
常见误区
- 每次重试都重新生成幂等键,去重失效。
- 幂等键只在客户端保存,进程重建后丢失导致重复提交。
追问
- 幂等键放 Header 还是参数?答:常见放专用 Header;服务端约定为准。
- 查询接口需要幂等键吗?答:GET 天然安全;写接口(POST/PUT)才需要重点保障。
07.1.1.9.1-099 并发相同请求如何避免重复打向后端(请求合并)?
一句话结论
同一资源的并发请求在客户端层做单飞合并:首个请求发出后,后续相同请求共享同一个 Call 结果,待首个完成后一起分发;缓存命中场景则直接读本地。
概念解释
页面多个组件同时拉取同一接口时,不合并会产生重复网络交换。单飞模式按请求键(方法+URL+关键参数)登记在途 Call,重复请求挂起等待同一结果。注意合并只对只读安全请求安全;写操作不能合并。
原理流程
请求键 K
→ 无在途:发起 Call,登记 K → Call
→ 有在途:订阅该 Call 结果,不新建请求
→ 完成:分发给所有订阅者,移除登记
代码或图示
inFlight: Map<RequestKey, SharedCall>
重复请求 → 加入回调列表 → 复用同一响应
常见误区
- 把写请求也做单飞合并,导致后到请求拿不到独立结果。
- 合并后不处理取消引用,订阅者泄漏。
追问
- 单飞与响应缓存如何配合?答:先查缓存新鲜结果,未命中再走单飞在途合并。
- 合并键如何构造?答:方法、URL、查询参数、必要业务头;用户身份维度纳入键,避免跨会话串数据。
07.1.1.9.1-100 弱网下 OkHttp 重试、超时与连接池联动时如何取舍参数?
一句话结论
弱网治理是联动取舍:连接复用降低握手开销,超时按阶段分级避免长挂起,重试只对幂等与瞬时故障开启并加退避;参数组合要按实测耗时分布与失败类型调整,而不是套用单一默认值。
概念解释
三者互相影响:keepAlive 过短导致频繁建连放大弱网压力;超时过长拉长在途占用与排队;重试过激在弱网下形成请求风暴。治理顺序:先测 DNS/握手/首字节/体传输分布,再定超时基线,评估复用率与失败类型,最后控制重试次数与退避,关键与非关键请求分池治理。
原理流程
实测阶段耗时分布 → 定 connect/read/write/call 超时基线
连接复用率评估 → 调 keepAlive 与空闲数
失败分类 → 仅瞬时连接故障 + 幂等请求重试,指数退避
非关键请求降并发/延迟,关键请求独享额度
代码或图示
val client = OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.retryOnConnectionFailure(true)
.connectionPool(ConnectionPool(4, 3, TimeUnit.MINUTES))
.build()
常见误区
- 弱网下一味加大超时与重试次数,排队与连接占用进一步恶化。
- 只看平均耗时,忽略慢分位与超时失败率。
追问
- 如何验证一组参数的效果?答:对比调整前后的复用率、各阶段耗时分位、超时率、重试率与成功率,在弱网模拟环境回归。
- 弱网下优先保什么?答:保关键请求成功率与在途可控,非关键接口延迟或降级。
参考来源
- OkHttp 官方文档:客户端配置、超时、连接池、拦截器与事件监听的整体说明。
- OkHttp 拦截器指南:应用拦截器与网络拦截器的差异、执行顺序与示例。
- OkHttp Events 监听:EventListener 回调时机与阶段指标采集方式。
- OkHttp GitHub 仓库:版本基线、默认参数与变更记录(具体默认值以对应版本为准)。
- MDN:HTTP 缓存(Cache-Control):缓存指令语义与新鲜度、校验规则。
待整理清单
- [ ] 核对项目实际 OkHttp 版本下
maxRequests、maxRequestsPerHost、默认连接池空闲数与 keepAlive 时长的具体默认值。 - [ ] 验证
callTimeout的边界是否包含响应体完整消费,以及整体超时对应的异常类型。 - [ ] 确认当前版本下 Dispatcher 在途/排队 Call 列表快照方法的准确名称与可见性。
- [ ] 核对 ALPN 协商、HTTP/2 流控窗口默认值与连接合并在所用版本中的实际行为。
- [ ] 补充生产环境证书固定的指纹生成方式、备用指纹轮换流程与线上解除固定的灰度策略。
- [ ] 整理弱网参数基线在真机与弱网模拟环境下的实测数据(各阶段耗时分位、复用率、超时率)。