Android第六次面试总结（okhttp篇）

OkHttp 是一个高效的 HTTP 客户端，它的工作流程包含多个步骤，从请求的创建、发送，到服务器响应的接收和处理，每个环节都有特定的逻辑和组件参与。以下是对 OkHttp 工作流程的详细说明：

1. 请求构建

在使用 OkHttp 发起 HTTP 请求之前，需要先构建一个 Request 对象，这个对象包含了请求的所有必要信息，如请求的 URL、请求方法（GET、POST 等）、请求头和请求体等。可以使用 Request.Builder 来构建 Request 对象，示例代码如下：

import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.MediaType;// 定义请求体的媒体类型
MediaType JSON = MediaType.get("application/json; charset=utf-8");
// 创建请求体
RequestBody body = RequestBody.create(JSON, "{\"name\":\"John\",\"age\":30}");// 构建请求
Request request = new Request.Builder().url("https://example.com/api").post(body).build();

2. 客户端配置

创建一个 OkHttpClient 对象，它是 OkHttp 的核心客户端，用于管理请求的发送和接收。可以使用 OkHttpClient.Builder 来配置客户端的各种参数，例如连接超时时间、读取超时时间、缓存设置、拦截器等，示例代码如下：

import okhttp3.OkHttpClient;
import java.util.concurrent.TimeUnit;// 构建 OkHttpClient
OkHttpClient client = new OkHttpClient.Builder().connectTimeout(10, TimeUnit.SECONDS).readTimeout(30, TimeUnit.SECONDS).writeTimeout(30, TimeUnit.SECONDS).build();

3. 生成 Call 对象

将构建好的 Request 对象传入 OkHttpClient 的 newCall 方法中，会得到一个 Call 对象。Call 对象代表一个已经准备好执行的请求，它有两种执行方式：同步执行和异步执行。示例代码如下：

import okhttp3.Call;// 创建 Call 对象
Call call = client.newCall(request);

4. 执行请求

同步请求

调用 Call 对象的 execute 方法可以发起同步请求，该方法会阻塞当前线程，直到请求完成并返回响应。示例代码如下：

import okhttp3.Response;
import java.io.IOException;try {Response response = call.execute();if (response.isSuccessful()) {String responseData = response.body().string();System.out.println(responseData);}
} catch (IOException e) {e.printStackTrace();
}

异步请求

调用 Call 对象的 enqueue 方法可以发起异步请求，该方法会将请求任务放入线程池中执行，不会阻塞当前线程。当请求完成后，会通过回调方法返回响应结果。示例代码如下：

import okhttp3.Callback;
import okhttp3.Response;
import java.io.IOException;call.enqueue(new Callback() {@Overridepublic void onFailure(Call call, IOException e) {e.printStackTrace();}@Overridepublic void onResponse(Call call, Response response) throws IOException {if (response.isSuccessful()) {String responseData = response.body().string();System.out.println(responseData);}}
});

 

OkHttp 的缓存机制是其重要特性之一，它基于 HTTP 缓存协议实现，能够有效减少网络请求，提升应用性能、降低数据消耗。以下将从缓存原理、缓存配置、缓存策略、缓存验证以及缓存清理等方面详细介绍。

缓存原理

OkHttp 的缓存机制遵循 HTTP 缓存协议（如 Cache-Control、ETag、Last-Modified 等）。当发起一个请求时，CacheInterceptor 拦截器会先检查本地缓存中是否存在符合条件的响应。若存在且未过期，就直接使用缓存响应，避免发起网络请求；若缓存不存在或已过期，则发起网络请求，并根据响应的缓存策略将响应结果缓存起来。

缓存配置

要使用 OkHttp 的缓存功能，需要在创建 OkHttpClient 时配置缓存目录和缓存大小。以下是示例代码：

 

import okhttp3.Cache;
import okhttp3.OkHttpClient;
import java.io.File;// 指定缓存目录
File cacheDirectory = new File(getApplicationContext().getCacheDir(), "http_cache");
// 设置缓存大小为 10MB
int cacheSize = 10 * 1024 * 1024; 
Cache cache = new Cache(cacheDirectory, cacheSize);// 构建带有缓存的 OkHttpClient
OkHttpClient client = new OkHttpClient.Builder().cache(cache).build();

缓存策略

缓存策略主要通过 Cache-Control 请求头和响应头来控制，以下是常见的缓存策略：

1. 强制使用缓存

在请求头中设置 Cache-Control: only-if-cached，表示只使用缓存，不发起网络请求。若缓存不存在或已过期，请求会失败。示例代码如下：

import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;Request request = new Request.Builder().url("https://example.com/api").header("Cache-Control", "only-if-cached").build();try {Response response = client.newCall(request).execute();if (response.isSuccessful()) {// 处理响应}
} catch (IOException e) {e.printStackTrace();
}

2. 忽略缓存

在请求头中设置 Cache-Control: no-cache 或 Cache-Control: max-age=0，表示忽略缓存，直接发起网络请求。示例代码如下：

Request request = new Request.Builder().url("https://example.com/api").header("Cache-Control", "no-cache").build();

3. 根据缓存有效期使用缓存

响应头中的 Cache-Control 字段可以设置缓存的有效期，如 Cache-Control: max-age=3600 表示缓存有效期为 1 小时。在有效期内，再次请求相同资源时会使用缓存响应。

缓存验证

当缓存存在但不确定是否过期时，OkHttp 会使用 ETag 或 Last-Modified 进行缓存验证。

1. ETag

ETag 是服务器为资源生成的一个唯一标识符，当资源发生变化时，ETag 也会发生变化。在请求时，OkHttp 会将缓存中的 ETag 添加到请求头的 If-None-Match 字段中发送给服务器。服务器会比较请求中的 ETag 和当前资源的 ETag，如果相同，则返回 304 状态码，表示资源未修改，OkHttp 可以使用缓存响应；如果不同，则返回新的资源和新的 ETag。

2. Last-Modified

Last-Modified 是服务器记录资源最后修改的时间。在请求时，OkHttp 会将缓存中的 Last-Modified 添加到请求头的 If-Modified-Since 字段中发送给服务器。服务器会比较请求中的 Last-Modified 和当前资源的最后修改时间，如果请求中的时间早于或等于当前资源的最后修改时间，则返回 304 状态码；否则返回新的资源和新的 Last-Modified。

缓存清理和过期处理

OkHttp 使用 DiskLruCache 来管理本地缓存文件，它会自动处理缓存的清理和过期。

1. 缓存空间清理

当缓存空间达到上限时，DiskLruCache 会根据 LRU（Least Recently Used）算法删除最近最少使用的缓存项，以释放空间。

2. 缓存过期处理

当缓存项的有效期过期时，OkHttp 会将其标记为无效，下次请求时会重新发起网络请求。

总结

OkHttp 的缓存机制通过遵循 HTTP 缓存协议，结合 CacheInterceptor 拦截器和 DiskLruCache 来实现高效的缓存管理。合理配置缓存策略和验证机制，可以有效减少网络请求，提升应用性能和用户体验。

深入理解 OkHttp 拦截器

1. 拦截器接口详解

Interceptor 接口是自定义拦截器的基础，它仅包含一个抽象方法 intercept。以下是对该方法参数和返回值的详细解释：

 

import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;public class CustomInterceptor implements Interceptor {@Overridepublic Response intercept(Chain chain) throws IOException {// chain 包含了当前请求的所有信息以及后续拦截器的处理逻辑Request originalRequest = chain.request(); // 可以对原始请求进行修改，例如添加请求头、修改请求方法等Request modifiedRequest = originalRequest.newBuilder().header("Custom-Header", "Custom-Value").build();// proceed 方法会将修改后的请求传递给下一个拦截器，并返回响应Response response = chain.proceed(modifiedRequest);// 可以对响应进行处理，例如添加自定义响应头、解析响应体等return response.newBuilder().header("Custom-Response-Header", "Custom-Response-Value").build();}
}

• Chain 参数：Chain 是一个接口，它代表了整个拦截器链。chain.request() 方法可以获取当前的请求对象；chain.proceed(request) 方法会将请求传递给下一个拦截器，并返回响应。
• Response 返回值：intercept 方法必须返回一个 Response 对象，这个对象可以是原始响应，也可以是经过修改后的响应。

2. 应用拦截器和网络拦截器的区别

应用拦截器

• 添加方式：通过 OkHttpClient.Builder().addInterceptor(Interceptor interceptor) 方法添加。
• 执行时机：在所有网络相关操作之前执行，仅处理应用层发起的原始请求。
• 特点：
  • 不会受到重定向、重试等网络操作的影响，每个请求只会经过应用拦截器一次。
  • 可以获取到最原始的请求和最终的响应，适合进行日志记录、请求头添加等操作。

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;public class ApplicationInterceptorExample {public static void main(String[] args) throws IOException {CustomInterceptor customInterceptor = new CustomInterceptor();OkHttpClient client = new OkHttpClient.Builder().addInterceptor(customInterceptor).build();Request request = new Request.Builder().url("https://example.com").build();Response response = client.newCall(request).execute();System.out.println(response.body().string());}
}

网络拦截器

• 添加方式：通过 OkHttpClient.Builder().addNetworkInterceptor(Interceptor interceptor) 方法添加。
• 执行时机：在建立网络连接之后、发送请求到服务器之前执行，会处理所有的网络请求，包括重定向和重试的请求。
• 特点：
  • 可以处理网络层的细节，例如请求的重试、重定向等。
  • 可能会执行多次，因为重定向和重试会导致请求多次经过网络拦截器。

 

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;public class NetworkInterceptorExample {public static void main(String[] args) throws IOException {CustomInterceptor customInterceptor = new CustomInterceptor();OkHttpClient client = new OkHttpClient.Builder().addNetworkInterceptor(customInterceptor).build();Request request = new Request.Builder().url("https://example.com").build();Response response = client.newCall(request).execute();System.out.println(response.body().string());}
}

 

3. 拦截器链的详细执行流程

整体流程

OkHttp 的拦截器链是一个有序的拦截器集合，请求和响应会依次经过每个拦截器。拦截器链的执行顺序是固定的，如下所示：

1. 应用拦截器：按照添加的顺序依次执行。
2. RetryAndFollowUpInterceptor：负责处理请求的重试和重定向逻辑。如果请求失败，会根据一定的规则进行重试；如果服务器返回重定向响应，会自动发起新的请求到重定向的 URL。
3. BridgeInterceptor：将用户构建的请求转换为适合网络传输的请求，添加必要的请求头，如 Content-Type、Content-Length、User-Agent 等。
4. CacheInterceptor：处理缓存逻辑，根据请求的 Cache-Control 头和缓存中的响应信息判断是否可以使用缓存。如果缓存有效，则直接返回缓存响应；否则发起网络请求，并将响应结果缓存起来。
5. ConnectInterceptor：负责建立与服务器的连接，根据请求的 URL 确定服务器的地址和端口，然后建立 TCP 连接（如果是 HTTP/2 协议，还会建立 HTTP/2 连接）。
6. 网络拦截器：按照添加的顺序依次执行。
7. CallServerInterceptor：负责向服务器发送请求并接收响应，将请求的内容（如请求头、请求体）发送到服务器，然后读取服务器返回的响应头和响应体。

示例代码说明

import okhttp3.*;
import java.io.IOException;public class InterceptorChainExample {public static void main(String[] args) throws IOException {// 应用拦截器Interceptor appInterceptor = chain -> {Request request = chain.request();System.out.println("App Interceptor: Request URL - " + request.url());Response response = chain.proceed(request);System.out.println("App Interceptor: Response Code - " + response.code());return response;};// 网络拦截器Interceptor networkInterceptor = chain -> {Request request = chain.request();System.out.println("Network Interceptor: Request URL - " + request.url());Response response = chain.proceed(request);System.out.println("Network Interceptor: Response Code - " + response.code());return response;};OkHttpClient client = new OkHttpClient.Builder().addInterceptor(appInterceptor).addNetworkInterceptor(networkInterceptor).build();Request request = new Request.Builder().url("https://example.com").build();Response response = client.newCall(request).execute();System.out.println(response.body().string());}
}

在上述代码中，请求会先经过应用拦截器，然后依次经过 RetryAndFollowUpInterceptor、BridgeInterceptor、CacheInterceptor、ConnectInterceptor，接着经过网络拦截器，最后由 CallServerInterceptor 发送请求并接收响应。响应会按照相反的顺序再次经过拦截器链。

4. 拦截器的高级应用场景

缓存控制拦截器

可以创建一个拦截器来动态控制缓存策略，例如根据网络状态或用户设置来决定是否使用缓存。

 

import okhttp3.*;
import java.io.IOException;public class CacheControlInterceptor implements Interceptor {@Overridepublic Response intercept(Chain chain) throws IOException {Request request = chain.request();if (isNetworkAvailable()) {// 网络可用时，设置缓存策略为最多缓存 60 秒request = request.newBuilder().header("Cache-Control", "max-age=60").build();} else {// 网络不可用时，强制使用缓存request = request.newBuilder().header("Cache-Control", "only-if-cached").build();}return chain.proceed(request);}private boolean isNetworkAvailable() {// 实现网络状态检查逻辑return true;}
}

超时重试拦截器

可以创建一个拦截器来处理请求超时的情况，当请求超时时，自动重试一定次数。

import okhttp3.*;
import java.io.IOException;public class RetryInterceptor implements Interceptor {private static final int MAX_RETRIES = 3;@Overridepublic Response intercept(Chain chain) throws IOException {Request request = chain.request();Response response = null;IOException exception = null;for (int i = 0; i < MAX_RETRIES; i++) {try {response = chain.proceed(request);if (response.isSuccessful()) {break;}} catch (IOException e) {exception = e;}}if (response == null) {throw exception;}return response;}
}

总结

   OkHttp 的拦截器机制提供了强大的扩展性和灵活性，通过合理使用应用拦截器和网络拦截器，可以实现日志记录、请求头添加、缓存控制、错误处理等多种功能。深入理解拦截器链的执行流程和不同拦截器的特点，有助于更好地利用拦截器来优化网络请求。

感谢观看！！！