OKHttp 核心知识点详解

OKHttp 核心知识点详解

一、基本概念与架构

1. OKHttp 简介

• 类型：高效的HTTP客户端
• 特点：
  • 支持HTTP/2和SPDY（多路复用）
  • 连接池减少请求延迟
  • 透明的GZIP压缩
  • 响应缓存
  • 自动恢复网络故障

2. 核心组件

二、基础使用

1. 添加依赖

implementation("com.squareup.okhttp3:okhttp:4.10.0") // 最新稳定版

2. 同步请求

val client = OkHttpClient()
val request = Request.Builder()
    .url("https://api.example.com/data")
    .build()

try {
    val response = client.newCall(request).execute()
    if (response.isSuccessful) {
        val responseData = response.body?.string()
    }
} catch (e: IOException) {
    e.printStackTrace()
}

3. 异步请求

val request = Request.Builder()
    .url("https://api.example.com/data")
    .build()

client.newCall(request).enqueue(object : Callback {
    override fun onResponse(call: Call, response: Response) {
        val responseData = response.body?.string()
    }
    
    override fun onFailure(call: Call, e: IOException) {
        e.printStackTrace()
    }
})

三、高级功能

1. 拦截器（Interceptors）

应用拦截器（Application Interceptors）

val client = OkHttpClient.Builder()
    .addInterceptor(LoggingInterceptor())
    .build()

class LoggingInterceptor : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        
        // 请求前日志
        Log.d("OKHttp", "Sending request: ${request.url}")
        
        val response = chain.proceed(request)
        
        // 响应后日志
        Log.d("OKHttp", "Received response: ${response.code}")
        
        return response
    }
}

网络拦截器（Network Interceptors）

.addNetworkInterceptor(StethoInterceptor())  // Facebook调试工具

2. 缓存配置

val cacheSize = 10 * 1024 * 1024 // 10MB
val cache = Cache(File(context.cacheDir, "http_cache"), cacheSize)

val client = OkHttpClient.Builder()
    .cache(cache)
    .addInterceptor(CacheInterceptor())
    .build()

class CacheInterceptor : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        val response = chain.proceed(request)
        
        val cacheControl = CacheControl.Builder()
            .maxAge(30, TimeUnit.MINUTES)
            .build()
            
        return response.newBuilder()
            .header("Cache-Control", cacheControl.toString())
            .build()
    }
}

3. 超时设置

val client = OkHttpClient.Builder()
    .connectTimeout(15, TimeUnit.SECONDS)  // 连接超时
    .readTimeout(15, TimeUnit.SECONDS)    // 读取超时
    .writeTimeout(15, TimeUnit.SECONDS)   // 写入超时
    .callTimeout(30, TimeUnit.SECONDS)    // 整个调用超时
    .build()

四、请求定制

1. 请求头设置

val request = Request.Builder()
    .url("https://api.example.com/data")
    .header("Authorization", "Bearer token123")
    .addHeader("Accept", "application/json")
    .build()

2. 表单提交

val formBody = FormBody.Builder()
    .add("username", "admin")
    .add("password", "123456")
    .build()

val request = Request.Builder()
    .url("https://api.example.com/login")
    .post(formBody)
    .build()

3. 文件上传

val file = File("/sdcard/image.jpg")
val requestBody = MultipartBody.Builder()
    .setType(MultipartBody.FORM)
    .addFormDataPart("file", file.name,
        file.asRequestBody("image/jpeg".toMediaType()))
    .addFormDataPart("description", "A cool image")
    .build()

val request = Request.Builder()
    .url("https://api.example.com/upload")
    .post(requestBody)
    .build()

4. JSON 数据提交

val json = """
    {
        "name": "John",
        "age": 30
    }
""".trimIndent()

val requestBody = json.toRequestBody("application/json".toMediaType())

val request = Request.Builder()
    .url("https://api.example.com/users")
    .post(requestBody)
    .build()

五、响应处理

1. 响应头读取

val response = client.newCall(request).execute()
val contentType = response.header("Content-Type")
val allHeaders = response.headers

2. 响应体处理

// 字符串形式
val stringBody = response.body?.string()

// 字节流形式
val bytes = response.body?.bytes()

// 流式处理
response.body?.source()?.use { source ->
    while (!source.exhausted()) {
        val buffer = source.buffer()
        // 处理buffer
    }
}

六、高级配置

1. 连接池配置

val client = OkHttpClient.Builder()
    .connectionPool(ConnectionPool(5, 5, TimeUnit.MINUTES))
    .build()

2. 代理设置

val proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress("proxy.example.com", 8080))
val client = OkHttpClient.Builder()
    .proxy(proxy)
    .build()

3. 证书锁定（Certificate Pinning）

val certificatePinner = CertificatePinner.Builder()
    .add("api.example.com", "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
    .build()

val client = OkHttpClient.Builder()
    .certificatePinner(certificatePinner)
    .build()

4. 自定义DNS

val dns = Dns { hostname ->
    if (hostname == "api.example.com") {
        listOf(InetAddress.getByName("1.2.3.4"))
    } else {
        Dns.SYSTEM.lookup(hostname)
    }
}

val client = OkHttpClient.Builder()
    .dns(dns)
    .build()

七、WebSocket 支持

val request = Request.Builder()
    .url("wss://echo.websocket.org")
    .build()

val listener = object : WebSocketListener() {
    override fun onOpen(webSocket: WebSocket, response: Response) {
        webSocket.send("Hello!")
    }
    
    override fun onMessage(webSocket: WebSocket, text: String) {
        println("Received: $text")
    }
    
    override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
        println("Closed: $reason")
    }
    
    override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
        t.printStackTrace()
    }
}

val webSocket = client.newWebSocket(request, listener)

// 关闭连接
webSocket.close(1000, "Goodbye!")

八、常见问题解决方案

1. 内存泄漏问题

// 在Activity/Fragment销毁时取消请求
private val calls = mutableListOf<Call>()

override fun onDestroy() {
    super.onDestroy()
    calls.forEach { it.cancel() }
}

// 发起请求时保存Call对象
val call = client.newCall(request)
calls.add(call)
call.enqueue(object : Callback {
    override fun onResponse(call: Call, response: Response) {
        calls.remove(call)
        // 处理响应
    }
    
    override fun onFailure(call: Call, e: IOException) {
        calls.remove(call)
        // 处理错误
    }
})

2. 大文件下载进度监听

val request = Request.Builder()
    .url("https://example.com/largefile.zip")
    .build()

client.newCall(request).enqueue(object : Callback {
    override fun onResponse(call: Call, response: Response) {
        response.body?.let { body ->
            val inputStream = body.byteStream()
            val contentLength = body.contentLength()
            var bytesRead: Long = 0
            val buffer = ByteArray(8192)
            
            FileOutputStream(localFile).use { output ->
                var read = inputStream.read(buffer)
                while (read != -1) {
                    output.write(buffer, 0, read)
                    bytesRead += read
                    val progress = (bytesRead * 100 / contentLength).toInt()
                    updateProgress(progress) // 更新UI
                    read = inputStream.read(buffer)
                }
            }
        }
    }
    
    override fun onFailure(call: Call, e: IOException) {
        // 处理错误
    }
})

3. 请求重试机制

val client = OkHttpClient.Builder()
    .addInterceptor(RetryInterceptor(maxRetries = 3))
    .build()

class RetryInterceptor(private val maxRetries: Int) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        var response: Response? = null
        var exception: IOException? = null
        
        for (i in 0..maxRetries) {
            try {
                response = chain.proceed(request)
                if (response.isSuccessful) {
                    return response
                }
            } catch (e: IOException) {
                exception = e
            }
            
            if (i < maxRetries) {
                Thread.sleep(1000L * (i + 1)) // 指数退避
            }
        }
        
        throw exception ?: IOException("Unknown error")
    }
}

九、最佳实践

1. 单例模式：推荐将OkHttpClient实例作为单例使用
2. 资源释放：确保关闭Response和ResponseBody
3. 线程安全：OkHttpClient是线程安全的，可共享使用
4. 性能优化：
   • 合理设置连接池大小
   • 使用缓存减少网络请求
   • 压缩请求数据
5. 错误处理：
   • 处理各种IO异常
   • 检查响应码（response.isSuccessful）
   • 考虑网络不可用情况

OKHttp 是 Android 开发中最强大、灵活的 HTTP 客户端之一，掌握其核心功能可以显著提升应用的网络性能和稳定性。