Android网络全链路拆解：一次HTTP请求背后的性能陷阱

class NetworkTimingListener : EventListener() {private var callStartMs = 0L
private var dnsStartMs = 0L
private var connectStartMs = 0L
private var tlsStartMs = 0L
private var requestStartMs = 0L
private var responseStartMs = 0Loverride fun callStart(call: Call) {
callStartMs = System.currentTimeMillis()
}override fun dnsStart(call: Call, domainName: String) {
dnsStartMs = System.currentTimeMillis()
}override fun dnsEnd(call: Call, domainName: String, inetAddressList: List<InetAddress>) {
val dnsMs = System.currentTimeMillis() - dnsStartMs
reportMetric("dns_time", dnsMs)
}override fun connectStart(call: Call, inetSocketAddress: InetSocketAddress, proxy: Proxy) {
connectStartMs = System.currentTimeMillis()
}override fun secureConnectStart(call: Call) {
tlsStartMs = System.currentTimeMillis()
}override fun secureConnectEnd(call: Call, handshake: Handshake?) {
val tlsMs = System.currentTimeMillis() - tlsStartMs
reportMetric("tls_time", tlsMs)
}override fun connectEnd(call: Call, inetSocketAddress: InetSocketAddress, proxy: Proxy, protocol: Protocol?) {
val connectMs = System.currentTimeMillis() - connectStartMs
reportMetric("connect_time", connectMs)
}override fun responseHeadersStart(call: Call) {
responseStartMs = System.currentTimeMillis()
}override fun responseHeadersEnd(call: Call, response: Response) {
// TTFB = 从请求发出到收到第一个响应字节
val ttfb = responseStartMs - requestStartMs
reportMetric("ttfb", ttfb)
}override fun callEnd(call: Call) {
val totalMs = System.currentTimeMillis() - callStartMs
reportMetric("total_time", totalMs)
}
}

val client = OkHttpClient.Builder()
.eventListenerFactory { NetworkTimingListener() }
.build()

// 弱网检测：通过ConnectivityManager监听网络质量变化
class NetworkQualityMonitor(private val context: Context) {fun isWeakNetwork(): Boolean {
val cm = context.getSystemService(ConnectivityManager::class.java)
val nc = cm.getNetworkCapabilities(cm.activeNetwork) ?: return true// 下行带宽低于150Kbps认为是弱网
val downBandwidth = nc.linkDownstreamBandwidthKbps
if (downBandwidth < 150) return true// 也可以结合实际请求的RTT来判断
return recentAvgRtt > 800 // ms
}fun adaptTimeouts(builder: OkHttpClient.Builder): OkHttpClient.Builder {
return if (isWeakNetwork()) {
builder
.connectTimeout(15, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
} else {
builder
.connectTimeout(5, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.writeTimeout(10, TimeUnit.SECONDS)
}
}
}

// 监听网络切换，主动清理无效连接
class NetworkSwitchHandler(
private val client: OkHttpClient
) {
private val networkCallback = object : ConnectivityManager.NetworkCallback() {
override fun onLost(network: Network) {
// 网络丢失，清空连接池中对应的连接
// 避免后续请求拿到已死的连接还尝试使用
client.connectionPool.evictAll()
}override fun onAvailable(network: Network) {
// 新网络可用，可以预热关键域名的连接
prewarmConnections()
}
}private fun prewarmConnections() {
// 对核心域名提前建立连接（后台线程）
CRITICAL_HOSTS.forEach { host ->
Executors.IO.execute {
try {
client.newCall(
Request.Builder().url("https://$host")
.head().build()
).execute().close()
} catch (_: Exception) { }
}
}
}
}

enum class NetworkGrade {
EXCELLENT,  // WiFi/5G，RTT<50ms
GOOD,       // 4G良好，RTT<200ms
FAIR,       // 4G一般/3G，RTT<500ms
POOR,       // 弱网，RTT<1000ms
TERRIBLE    // 极端弱网，RTT>1000ms
}object NetworkStrategy {
fun getConfig(grade: NetworkGrade): NetworkConfig = when (grade) {
EXCELLENT -> NetworkConfig(
connectTimeout = 3.seconds,
enablePrefetch = true,
imageQuality = Quality.HIGH
)
GOOD -> NetworkConfig(
connectTimeout = 5.seconds,
enablePrefetch = true,
imageQuality = Quality.MEDIUM
)
FAIR -> NetworkConfig(
connectTimeout = 10.seconds,
enablePrefetch = false,
imageQuality = Quality.LOW
)
POOR -> NetworkConfig(
connectTimeout = 15.seconds,
enablePrefetch = false,
imageQuality = Quality.THUMBNAIL,
enableCompression = true
)
TERRIBLE -> NetworkConfig(
connectTimeout = 20.seconds,
enablePrefetch = false,
imageQuality = Quality.NONE,
enableCompression = true,
useCacheOnly = true  // 极端情况先展示缓存
)
}
}

// 通过EventListener统计连接复用率
class ConnectionReuseTracker : EventListener() {
private var isConnectionReused = falseoverride fun connectionAcquired(call: Call, connection: Connection) {
// 如果没有触发connectStart，说明是复用的连接
isConnectionReused = !hadConnectStart
}override fun connectStart(call: Call, inetSocketAddress: InetSocketAddress, proxy: Proxy) {
hadConnectStart = true
}override fun callEnd(call: Call) {
MetricsCollector.report(
"connection_reused",
if (isConnectionReused) 1 else 0
)
}
}

// ❌ 错误做法：每个Retrofit实例用独立Client
val apiRetrofit = Retrofit.Builder()
.client(OkHttpClient())  // 独立连接池
.baseUrl("https://api.example.com")
.build()val cdnRetrofit = Retrofit.Builder()
.client(OkHttpClient())  // 又一个独立连接池
.baseUrl("https://cdn.example.com")
.build()// ✅ 正确做法：共享Client
val sharedClient = OkHttpClient.Builder()
.connectionPool(ConnectionPool(15, 5, TimeUnit.MINUTES))
.build()val apiRetrofit = Retrofit.Builder()
.client(sharedClient)
.baseUrl("https://api.example.com")
.build()val cdnRetrofit = Retrofit.Builder()
.client(sharedClient)  // 共享连接池！
.baseUrl("https://cdn.example.com")
.build()

// 在EventListener里确认协商结果
override fun connectEnd(
call: Call,
inetSocketAddress: InetSocketAddress,
proxy: Proxy,
protocol: Protocol?
) {
// protocol = h2 表示HTTP/2协商成功
Log.d("Network", "Protocol: $protocol")
if (protocol != Protocol.HTTP_2) {
// 上报，看看哪些域名还不支持H2
reportH2Failure(call.request().url.host)
}
}

// Application.onCreate 中提前预解析
object DnsPreResolver {
private val criticalHosts = listOf(
"api.yourapp.com",
"cdn.yourapp.com",
"auth.yourapp.com"
)fun prewarm() {
Executors.IO.execute {
criticalHosts.forEach { host ->
try {
// 触发系统DNS查询，结果会被系统缓存
InetAddress.getAllByName(host)
} catch (_: Exception) { }
}
}
}
}