🔥 OkHttp全面解析：从架构原理到性能优化与面试指南

## 1 OkHttp核心架构与设计理念

OkHttp是一个高效的HTTP客户端，它通过**连接池复用**、**拦截器链**和**透明压缩**等机制，为Android和Java应用提供了强大的网络通信能力。OkHttp的设计哲学强调**简单性**、**可靠性**和**高性能**。

### 1.1 核心组件架构

OkHttp采用分层设计，各个组件职责明确，通过协同工作提供统一的网络通信功能：

- **OkHttpClient**：作为整个库的**入口点和配置中心**，采用建造者模式进行配置。它是线程安全的，通常建议作为单例使用。负责管理连接池、缓存、拦截器等共享资源。
- **Request**：封装HTTP请求的所有信息，包括URL、方法、头部、请求体等。采用不可变设计，通过Builder模式构建，确保线程安全。
- **Response**：封装HTTP响应的所有信息，包括状态码、头部、响应体等。同样采用不可变设计，提供对响应数据的各种访问方法。
- **Call**：代表一个**已准备的请求**，是真正的执行单元。每个Call只能执行一次，但可以克隆。负责管理请求的生命周期，包括取消、重试等。
- **Interceptor**：OkHttp架构的**核心创新**，采用责任链模式处理请求和响应。允许开发者在请求发送前和响应返回后插入自定义处理逻辑。

### 1.2 整体工作流程
```java
// OkHttp基本使用示例
OkHttpClient client = new OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(30, TimeUnit.SECONDS)
    .build();

Request request = new Request.Builder()
    .url("https://api.example.com/data")
    .header("Authorization", "Bearer token")
    .build();

// 同步执行
try (Response response = client.newCall(request).execute()) {
    if (response.isSuccessful()) {
        String responseData = response.body().string();
        // 处理响应数据
    }
}

// 异步执行
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 处理成功响应
    }
    
    @Override
    public void onFailure(Call call, IOException e) {
        // 处理失败
    }
});
```

## 2 OkHttp拦截器机制深度解析

拦截器是OkHttp最强大的特性之一，它通过**责任链模式**将复杂的网络请求处理分解为多个独立的处理单元。

### 2.1 拦截器分类与执行顺序

OkHttp的拦截器按照执行顺序和功能分为两大类：

#### 2.1.1 应用拦截器（Application Interceptors）

- **执行位置**：最先执行，最后获得响应
- **特点**：
  - 不需要关心重定向和重试等中间响应
  - 总是只调用一次，即使响应来自缓存
  - 可以查看原始请求和最终响应
  - 适合用于日志记录、身份认证等全局处理

```java
// 应用拦截器示例：日志记录和认证
class AuthInterceptor implements Interceptor {
    private final String authToken;
    
    public AuthInterceptor(String token) {
        this.authToken = token;
    }
    
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request originalRequest = chain.request();
        
        // 添加认证头
        Request authenticatedRequest = originalRequest.newBuilder()
            .header("Authorization", "Bearer " + authToken)
            .build();
            
        long startTime = System.nanoTime();
        Response response = chain.proceed(authenticatedRequest);
        long elapsedTime = System.nanoTime() - startTime;
        
        Log.d("OkHttp", String.format("请求 %s 耗时 %.1fms", 
            response.request().url(), elapsedTime / 1e6d));
            
        return response;
    }
}
```

#### 2.1.2 网络拦截器（Network Interceptors）

- **执行位置**：在缓存拦截器和连接拦截器之间
- **特点**：
  - 能够观察所有中间响应，包括重定向和重试
  - 可以访问承载请求的连接
  - 适合用于网络层监控和修改

```java
// 网络拦截器示例：网络监控和重试
class RetryInterceptor implements Interceptor {
    private final int maxRetries;
    
    public RetryInterceptor(int maxRetries) {
        this.maxRetries = maxRetries;
    }
    
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = null;
        IOException exception = null;
        
        // 重试逻辑
        for (int attempt = 0; attempt <= maxRetries; attempt++) {
            try {
                response = chain.proceed(request);
                
                // 只在服务器错误时重试
                if (response.code() < 500) {
                    return response;
                }
            } catch (IOException e) {
                exception = e;
                if (attempt == maxRetries) {
                    break;
                }
            }
            
            // 指数退避延迟
            if (attempt < maxRetries) {
                try {
                    Thread.sleep((long) Math.pow(2, attempt) * 1000);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new IOException("重试被中断", ie);
                }
            }
        }
        
        if (exception != null) {
            throw exception;
        }
        
        return response;
    }
}
```

### 2.2 内置拦截器详解

OkHttp内置了多个核心拦截器，它们按照固定顺序执行：

#### 2.2.1 重试与重定向拦截器（RetryAndFollowUpInterceptor）
```java
// 伪代码：重试与重定向逻辑
public class RetryAndFollowUpInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        int followUpCount = 0;
        
        while (true) {
            Response response = null;
            boolean releaseConnection = true;
            
            try {
                // 执行请求
                response = chain.proceed(request);
                releaseConnection = false;
                
            } catch (IOException e) {
                // 检查是否应该重试
                if (!recover(e)) {
                    throw e;
                }
                releaseConnection = false;
                continue;
            }
            
            // 检查是否需要重定向或重试
            Request followUp = followUpRequest(response);
            if (followUp == null) {
                return response;
            }
            
            // 检查重定向次数限制
            if (++followUpCount > MAX_FOLLOW_UPS) {
                throw new ProtocolException("Too many follow-up requests: " + followUpCount);
            }
            
            request = followUp;
        }
    }
}
```

#### 2.2.2 桥接拦截器（BridgeInterceptor）

负责将用户友好的请求转换为网络友好的请求：

- 添加必要的HTTP头（Content-Type、Content-Length、Host等）
- 处理Cookie
- 启用GZIP压缩
- 从响应中解压GZIP内容

#### 2.2.3 缓存拦截器（CacheInterceptor）
```java
// 伪代码：缓存策略
public class CacheInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        // 尝试从缓存获取响应
        Response cacheCandidate = cache != null ? 
            cache.get(chain.request()) : null;
            
        long now = System.currentTimeMillis();
        
        // 根据缓存策略决定是否使用缓存
        CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
        Request networkRequest = strategy.networkRequest;
        Response cacheResponse = strategy.cacheResponse;
        
        if (cache != null) {
            cache.trackResponse(strategy);
        }
        
        // 如果禁止使用网络且缓存无效，返回504错误
        if (networkRequest == null && cacheResponse == null) {
            return new Response.Builder()
                .request(chain.request())
                .protocol(Protocol.HTTP_1_1)
                .code(504)
                .message("Unsatisfiable Request")
                .body(Util.EMPTY_RESPONSE)
                .sentRequestAtMillis(-1L)
                .receivedResponseAtMillis(System.currentTimeMillis())
                .build();
        }
        
        // 如果不需要网络，直接返回缓存
        if (networkRequest == null) {
            return cacheResponse.newBuilder()
                .cacheResponse(stripBody(cacheResponse))
                .build();
        }
        
        Response networkResponse = null;
        try {
            networkResponse = chain.proceed(networkRequest);
        } finally {
            // 如果我们在I/O操作中崩溃，不要泄漏缓存体
            if (networkResponse == null && cacheCandidate != null) {
                closeQuietly(cacheCandidate.body());
            }
        }
        
        // 如果服务器返回304，使用缓存
        if (cacheResponse != null) {
            if (networkResponse.code() == HTTP_NOT_MODIFIED) {
                Response response = cacheResponse.newBuilder()
                    .headers(combine(cacheResponse.headers(), networkResponse.headers()))
                    .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
                    .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
                    .cacheResponse(stripBody(cacheResponse))
                    .networkResponse(stripBody(networkResponse))
                    .build();
                networkResponse.body().close();
                return response;
            } else {
                closeQuietly(cacheResponse.body());
            }
        }
        
        Response response = networkResponse.newBuilder()
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build();
        
        // 缓存响应
        if (cache != null) {
            if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
                CacheRequest cacheRequest = cache.put(response);
                return cacheWritingResponse(cacheRequest, response);
            }
        }
        
        return response;
    }
}
```

#### 2.2.4 连接拦截器（ConnectInterceptor）

负责建立到目标服务器的连接，会尝试复用连接池中的连接：

- 从连接池获取可用连接
- 如果没有可用连接，创建新连接
- 处理HTTP/2多路复用
- 管理连接超时和重试

#### 2.2.5 调用服务器拦截器（CallServerInterceptor）

这是拦截器链的最后一个环节，负责实际的网络I/O操作：

- 写入请求头和请求体
- 读取响应头和响应体
- 处理100 Continue响应
- 管理请求和响应的流控制

### 2.3 拦截器链执行流程
```java
// RealInterceptorChain的核心执行逻辑
public class RealInterceptorChain implements Interceptor.Chain {
    private final List<Interceptor> interceptors;
    private final int index;
    private final Request request;
    
    @Override
    public Response proceed(Request request) throws IOException {
        if (index >= interceptors.size()) throw new AssertionError();
        
        // 创建下一个链
        RealInterceptorChain next = new RealInterceptorChain(
            interceptors, index + 1, request, ...);
            
        // 获取当前拦截器
        Interceptor interceptor = interceptors.get(index);
        
        // 调用当前拦截器
        Response response = interceptor.intercept(next);
        
        // 验证响应
        if (response == null) {
            throw new NullPointerException("interceptor " + interceptor + " returned null");
        }
        
        return response;
    }
}
```

## 3 OkHttp连接池与复用机制

OkHttp通过连接池机制大幅提升了网络性能，特别是在需要频繁创建短连接的应用场景中。

### 3.1 连接池设计与实现

#### 3.1.1 连接池核心结构
```java
// 连接池的核心实现
public class ConnectionPool {
    // 空闲连接的最大数量
    private final int maxIdleConnections;
    // 保持时间（秒）
    private final long keepAliveDurationNs;
    // 清理任务
    private final Runnable cleanupRunnable;
    // 连接双端队列
    private final Deque<RealConnection> connections = new ArrayDeque<>();
    
    public ConnectionPool() {
        this(5, 5, TimeUnit.MINUTES); // 默认：5个连接，5分钟保持时间
    }
    
    public ConnectionPool(int maxIdleConnections, long keepAliveDuration, TimeUnit timeUnit) {
        this.maxIdleConnections = maxIdleConnections;
        this.keepAliveDurationNs = timeUnit.toNanos(keepAliveDuration);
        this.cleanupRunnable = this::cleanup;
    }
    
    // 获取连接
    RealConnection get(Address address, StreamAllocation streamAllocation, Route route) {
        for (RealConnection connection : connections) {
            if (connection.isEligible(address, route)) {
                streamAllocation.acquire(connection);
                return connection;
            }
        }
        return null;
    }
    
    // 存放连接
    void put(RealConnection connection) {
        if (!cleanupRunning) {
            cleanupRunning = true;
            executor.execute(cleanupRunnable);
        }
        connections.add(connection);
    }
}
```

#### 3.1.2 连接清理算法
```java
// 连接清理逻辑
long cleanup() {
    int idleConnectionCount = 0;
    long longestIdleDurationNs = Long.MIN_VALUE;
    RealConnection longestIdleConnection = null;
    long now = System.nanoTime();
    
    // 查找最旧的空闲连接
    for (RealConnection connection : connections) {
        // 如果连接正在被使用，跳过
        if (pruneAndGetAllocationCount(connection, now) > 0) {
            continue;
        }
        
        idleConnectionCount++;
        
        // 如果这个连接空闲时间最长，记录下来
        long idleDurationNs = now - connection.idleAtNanos;
        if (idleDurationNs > longestIdleDurationNs) {
            longestIdleDurationNs = idleDurationNs;
            longestIdleConnection = connection;
        }
    }
    
    // 如果空闲连接超过最大数量或者最旧连接超时，移除它
    if (idleConnectionCount > maxIdleConnections 
        || (longestIdleDurationNs >= keepAliveDurationNs && longestIdleConnection != null)) {
        
        connections.remove(longestIdleConnection);
        closeQuietly(longestIdleConnection.socket());
        
        // 立即再次清理
        return 0;
    }
    
    // 计算下次清理时间
    if (idleConnectionCount > 0) {
        return keepAliveDurationNs - longestIdleDurationNs;
    }
    
    // 没有连接，不需要清理
    return -1;
}
```

### 3.2 HTTP/2多路复用

HTTP/2的多路复用能力让OkHttp可以在同一个连接上并行处理多个请求，大幅提升性能。

#### 3.2.1 HTTP/2连接管理
```java
// HTTP/2连接实现
public class Http2Connection {
    private final Connection connection;
    private final Map<Integer, Http2Stream> streams = new LinkedHashMap<>();
    private int lastGoodStreamId;
    private int nextStreamId;
    
    // 创建新流
    public Http2Stream newStream(List<Header> requestHeaders, boolean out) throws IOException {
        int streamId;
        boolean outFinished = !out;
        
        synchronized (this) {
            if (nextStreamId > 0) {
                streamId = nextStreamId;
                nextStreamId += 2;
            } else {
                throw new IOException("released");
            }
        }
        
        Http2Stream stream = new Http2Stream(streamId, this, outFinished, requestHeaders);
        synchronized (this) {
            streams.put(streamId, stream);
        }
        
        return stream;
    }
    
    // 写入请求头
    public void writeHeaders(int streamId, List<Header> requestHeaders, 
                           boolean outFinished, boolean inFinished) throws IOException {
        if (closed) throw new IOException("closed");
        writer.headers(outFinished, streamId, requestHeaders);
    }
}
```

## 4 OkHttp性能优化全面方案

OkHttp虽然本身性能优秀，但在复杂业务场景下仍需针对性优化才能达到最佳效果。

### 4.1 连接池优化配置

#### 4.1.1 优化连接池参数
```java
// 自定义连接池配置
public class OptimizedHttpClient {
    private static final int MAX_IDLE_CONNECTIONS = 20;
    private static final long KEEP_ALIVE_DURATION = 10L; // 10分钟
    
    public static OkHttpClient createOptimizedClient() {
        ConnectionPool connectionPool = new ConnectionPool(
            MAX_IDLE_CONNECTIONS, KEEP_ALIVE_DURATION, TimeUnit.MINUTES);
        
        return new OkHttpClient.Builder()
            .connectionPool(connectionPool)
            .connectTimeout(15, TimeUnit.SECONDS)    // 连接超时
            .readTimeout(30, TimeUnit.SECONDS)       // 读取超时  
            .writeTimeout(30, TimeUnit.SECONDS)      // 写入超时
            .retryOnConnectionFailure(true)          // 连接失败重试
            .build();
    }
}
```

#### 4.1.2 DNS优化
```java
// 自定义DNS解析，支持多个IP和故障转移
class MultiDns implements Dns {
    private static final Dns SYSTEM = Dns.SYSTEM;
    
    @Override
    public List<InetAddress> lookup(String hostname) throws UnknownHostException {
        try {
            // 首先尝试系统DNS
            return SYSTEM.lookup(hostname);
        } catch (UnknownHostException e) {
            // 备用DNS解析逻辑
            return fallbackLookup(hostname);
        }
    }
    
    private List<InetAddress> fallbackLookup(String hostname) {
        List<InetAddress> addresses = new ArrayList<>();
        
        // 添加备用DNS服务器解析逻辑
        // 可以集成HTTPDNS等自定义解析服务
        
        if (addresses.isEmpty()) {
            throw new UnknownHostException("所有DNS解析都失败了: " + hostname);
        }
        
        return addresses;
    }
}
```

### 4.2 缓存优化策略

#### 4.2.1 智能缓存配置
```java
// 创建优化的缓存配置
public class CacheOptimization {
    private static final long CACHE_SIZE = 100 * 1024 * 1024; // 100MB
    
    public static OkHttpClient createCachedClient(Context context) {
        File cacheDirectory = new File(context.getCacheDir(), "okhttp_cache");
        Cache cache = new Cache(cacheDirectory, CACHE_SIZE);
        
        return new OkHttpClient.Builder()
            .cache(cache)
            .addInterceptor(new CacheControlInterceptor())
            .addNetworkInterceptor(new RewriteCacheControlInterceptor())
            .build();
    }
    
    // 应用层缓存控制
    static class CacheControlInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            
            // 如果没有网络，强制使用缓存
            if (!isNetworkAvailable()) {
                request = request.newBuilder()
                    .cacheControl(CacheControl.FORCE_CACHE)
                    .build();
            }
            
            Response response = chain.proceed(request);
            
            // 如果网络不可用且缓存也不可用，定制错误信息
            if (!isNetworkAvailable() && response.cacheResponse() == null) {
                return new Response.Builder()
                    .request(request)
                    .protocol(Protocol.HTTP_1_1)
                    .code(504)
                    .message("网络不可用且无可用缓存")
                    .body(ResponseBody.create(null, new byte[0]))
                    .build();
            }
            
            return response;
        }
    }
    
    // 网络层缓存控制
    static class RewriteCacheControlInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Response originalResponse = chain.proceed(chain.request());
            
            // 重写缓存控制头，统一缓存策略
            return originalResponse.newBuilder()
                .header("Cache-Control", "public, max-age=300") // 5分钟
                .removeHeader("Pragma")
                .build();
        }
    }
}
```

### 4.3 请求优化技巧

#### 4.3.1 请求合并与批处理
```java
// 请求批处理管理器
public class RequestBatcher {
    private final OkHttpClient client;
    private final ScheduledExecutorService executor;
    private final Map<String, List<BatchRequest>> pendingRequests = new HashMap<>();
    private final long batchWindowMs;
    
    public RequestBatcher(OkHttpClient client, long batchWindowMs) {
        this.client = client;
        this.batchWindowMs = batchWindowMs;
        this.executor = Executors.newScheduledThreadPool(1);
    }
    
    public void enqueueRequest(String batchKey, Request request, Callback callback) {
        synchronized (pendingRequests) {
            List<BatchRequest> batch = pendingRequests.computeIfAbsent(
                batchKey, k -> new ArrayList<>());
                
            batch.add(new BatchRequest(request, callback));
            
            if (batch.size() == 1) {
                // 第一个请求，启动批处理窗口
                executor.schedule(() -> flushBatch(batchKey), 
                    batchWindowMs, TimeUnit.MILLISECONDS);
            }
        }
    }
    
    private void flushBatch(String batchKey) {
        List<BatchRequest> batch;
        synchronized (pendingRequests) {
            batch = pendingRequests.remove(batchKey);
        }
        
        if (batch != null && !batch.isEmpty()) {
            executeBatch(batch);
        }
    }
    
    private void executeBatch(List<BatchRequest> batch) {
        // 将多个请求合并为单个批处理请求
        // 发送到支持批处理的API端点
    }
    
    static class BatchRequest {
        final Request request;
        final Callback callback;
        
        BatchRequest(Request request, Callback callback) {
            this.request = request;
            this.callback = callback;
        }
    }
}
```

#### 4.3.2 文件上传优化
```java
// 带进度监听的文件上传
public class ProgressRequestBody extends RequestBody {
    private final File file;
    private final String contentType;
    private final ProgressListener listener;
    private static final int SEGMENT_SIZE = 2048; // 分段大小
    
    public ProgressRequestBody(File file, String contentType, ProgressListener listener) {
        this.file = file;
        this.contentType = contentType;
        this.listener = listener;
    }
    
    @Override
    public MediaType contentType() {
        return MediaType.parse(contentType);
    }
    
    @Override
    public long contentLength() {
        return file.length();
    }
    
    @Override
    public void writeTo(BufferedSink sink) throws IOException {
        Source source = null;
        try {
            source = Okio.source(file);
            long total = 0;
            long read;
            
            while ((read = source.read(sink.buffer(), SEGMENT_SIZE)) != -1) {
                total += read;
                sink.flush();
                
                // 回调进度，在主线程执行
                if (listener != null) {
                    final long finalTotal = total;
                    new Handler(Looper.getMainLooper()).post(() -> 
                        listener.onProgress(finalTotal, contentLength()));
                }
            }
        } finally {
            Util.closeQuietly(source);
        }
    }
    
    public interface ProgressListener {
        void onProgress(long bytesWritten, long totalBytes);
    }
}
```

### 4.4 内存与线程优化

#### 4.4.1 内存泄漏防护
```java
// 生命周期感知的OkHttp调用管理
public class LifecycleAwareCallManager {
    private final Map<Object, List<Call>> callMap = new WeakHashMap<>();
    
    public void executeWithLifecycle(Object lifecycleOwner, Call call, Callback callback) {
        // 包装回调，自动处理生命周期
        LifecycleCallback lifecycleCallback = new LifecycleCallback(callback, lifecycleOwner);
        
        // 记录调用
        synchronized (callMap) {
            List<Call> calls = callMap.computeIfAbsent(lifecycleOwner, k -> new ArrayList<>());
            calls.add(call);
        }
        
        call.enqueue(lifecycleCallback);
    }
    
    public void cancelAllCalls(Object lifecycleOwner) {
        synchronized (callMap) {
            List<Call> calls = callMap.remove(lifecycleOwner);
            if (calls != null) {
                for (Call call : calls) {
                    if (!call.isExecuted() && !call.isCanceled()) {
                        call.cancel();
                    }
                }
            }
        }
    }
    
    private class LifecycleCallback implements Callback {
        private final Callback delegate;
        private final Object lifecycleOwner;
        
        LifecycleCallback(Callback delegate, Object lifecycleOwner) {
            this.delegate = delegate;
            this.lifecycleOwner = lifecycleOwner;
        }
        
        @Override
        public void onResponse(Call call, Response response) throws IOException {
            synchronized (callMap) {
                List<Call> calls = callMap.get(lifecycleOwner);
                if (calls != null) {
                    calls.remove(call);
                }
            }
            delegate.onResponse(call, response);
        }
        
        @Override
        public void onFailure(Call call, IOException e) {
            synchronized (callMap) {
                List<Call> calls = callMap.get(lifecycleOwner);
                if (calls != null) {
                    calls.remove(call);
                }
            }
            delegate.onFailure(call, e);
        }
    }
}
```

## 5 高频面试题与参考答案

### 5.1 架构设计相关题目

**问题1：OkHttp的拦截器机制是如何工作的？请描述拦截器链的执行流程**

**参考答案：**
OkHttp的拦截器采用责任链模式，执行流程如下：

1. **构建拦截器链**：按照添加顺序构建包含所有拦截器的列表
2. **顺序执行**：从第一个拦截器开始，每个拦截器调用`chain.proceed()`将请求传递给下一个拦截器
3. **响应返回**：响应沿着拦截器链反向传递，每个拦截器有机会处理响应
4. **分类处理**：应用拦截器最先执行最后获得响应，网络拦截器在建立连接后执行

关键方法`RealInterceptorChain.proceed()`通过递归调用实现链式传递，每个拦截器都可以在`proceed()`前后添加处理逻辑。

**问题2：OkHttp的连接池是如何实现连接复用的？**

**参考答案：**
OkHttp连接池的实现机制：

- **数据结构**：使用`Deque<RealConnection>`存储空闲连接
- **连接查找**：通过`ConnectionPool.get()`方法根据地址和路由匹配可用连接
- **清理机制**：后台线程定期执行`cleanup()`，移除超时或超过最大空闲数量的连接
- **复用条件**：相同主机和端口、相同的代理和SSL配置、HTTP/2主机名验证等
- **性能优势**：避免TCP握手和SSL握手的开销，减少系统资源消耗

### 5.2 性能优化相关题目

**问题3：如何优化OkHttp的内存使用和避免内存泄漏？**

**参考答案：**
优化策略包括：

- **单例模式**：`OkHttpClient`应该使用单例，共享连接池和线程池
- **生命周期管理**：在Activity/Fragment销毁时取消所有相关请求
- **响应体及时关闭**：使用try-with-resources或手动关闭ResponseBody
- **缓存管理**：合理设置缓存大小，定期清理
- **拦截器优化**：避免在拦截器中持有外部引用
- **使用WeakReference**：在回调中使用弱引用避免持有Context
```java
// 正确关闭响应体的示例
try (Response response = client.newCall(request).execute()) {
    try (ResponseBody body = response.body()) {
        // 处理响应体
        String data = body.string();
    }
}
```

**问题4：OkHttp的缓存机制是如何工作的？**

**参考答案：**
OkHttp缓存通过`CacheInterceptor`实现：

- **缓存策略**：根据HTTP缓存规范（RFC 7234）实现
- **存储机制**：使用磁盘文件系统存储响应
- **缓存验证**：支持条件GET请求（If-Modified-Since、ETag）
- **新鲜度判断**：根据Cache-Control、Expires等头部判断响应新鲜度
- **网络fallback**：当缓存不可用时自动回退到网络请求

缓存流程：检查缓存 → 验证缓存有效性 → 返回缓存或网络响应 → 更新缓存。

### 5.3 工作原理相关题目

**问题5：OkHttp如何处理HTTP/2的多路复用？**

**参考答案：**
HTTP/2多路复用处理机制：

- **流管理**：在单个连接上创建多个并发的流（Stream），每个流承载一个请求-响应交换
- **帧传输**：将HTTP消息分解为帧（HEADERS、DATA等），交错传输
- **优先级控制**：支持流的优先级设置，优化资源分配
- **流量控制**：基于信用机制的流控制，防止接收方过载
- **头部压缩**：使用HPACK算法压缩请求头和响应头

OkHttp的`Http2Connection`类管理HTTP/2连接，`Http2Stream`类管理单个流。

**问题6：OkHttp的重试机制是如何实现的？**

**参考答案：**
重试机制由`RetryAndFollowUpInterceptor`处理：

- **异常重试**：对`IOException`进行重试，但不对`ProtocolException`重试
- **重定向处理**：自动处理3xx状态码的重定向响应
- **认证挑战**：处理401/407认证挑战
- **次数限制**：默认最多20次重定向或重试
- **请求体重试**：只有非一次性请求体（如文件）才能安全重试

实现原理：在拦截器中捕获异常，检查是否可恢复，然后创建新的请求继续执行。

### 5.4 实践应用相关题目

**问题7：如何在OkHttp中实现文件上传进度监控？**

**参考答案：**
通过自定义`RequestBody`实现进度监控：
```java
public class ProgressRequestBody extends RequestBody {
    private final RequestBody delegate;
    private final ProgressListener listener;
    
    @Override
    public void writeTo(BufferedSink sink) throws IOException {
        CountingSink countingSink = new CountingSink(sink);
        BufferedSink bufferedSink = Okio.buffer(countingSink);
        
        delegate.writeTo(bufferedSink);
        bufferedSink.flush();
    }
    
    private class CountingSink extends ForwardingSink {
        private long bytesWritten = 0;
        
        public CountingSink(Sink delegate) {
            super(delegate);
        }
        
        @Override
        public void write(Buffer source, long byteCount) throws IOException {
            super.write(source, byteCount);
            bytesWritten += byteCount;
            listener.onProgress(bytesWritten, contentLength());
        }
    }
}
```

**问题8：OkHttp如何配置HTTPS证书验证和自签名证书？**

**参考答案：**
HTTPS配置方案：
```java
// 信任所有证书（仅测试环境使用）
public static OkHttpClient createUnsafeClient() {
    try {
        TrustManager[] trustAllCerts = new TrustManager[] {
            new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] chain, String authType) {}
                
                @Override
                public void checkServerTrusted(X509Certificate[] chain, String authType) {}
                
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[]{};
                }
            }
        };
        
        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, trustAllCerts, new SecureRandom());
        
        return new OkHttpClient.Builder()
            .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager)trustAllCerts[0])
            .hostnameVerifier((hostname, session) -> true)
            .build();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

// 自定义证书验证
public static OkHttpClient createCustomSSLClient(InputStream certificateStream) {
    try {
        CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
        Certificate certificate = certificateFactory.generateCertificate(certificateStream);
        
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null, null);
        keyStore.setCertificateEntry("ca", certificate);
        
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(
            TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(keyStore);
        
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
        
        return new OkHttpClient.Builder()
            .sslSocketFactory(sslContext.getSocketFactory(), 
                (X509TrustManager) trustManagerFactory.getTrustManagers()[0])
            .build();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
```
通过深入理解OkHttp的设计架构、拦截器机制、连接池原理和优化策略，开发者可以构建出高效、稳定的网络通信模块，应对各种复杂的业务场景需求。