在使用retrofit进行api请求时，如果授权令牌（token）是动态变化的，例如有过期时间，可能会遇到okhttpclient缓存旧令牌导致认证失败的问题。这通常是由于retrofit实例或其底层的okhttpclient在首次创建后没有被正确更新，尤其是在使用了`static`变量和惰性初始化逻辑时。本文将深入探讨这一问题的原因，并提供多种解决方案，确保您的应用程序能够始终使用最新的令牌进行请求。
理解Retrofit旧令牌缓存问题
在使用Retrofit进行网络请求时，如果遇到令牌过期后请求持续失败（例如返回401 Unauthorized），即使数据库中已更新为新令牌，这通常意味着Retrofit或其底层的OkHttpClient实例仍然在使用旧的令牌。这种现象的根本原因在于RetrofitClient的配置方式，特别是当Retrofit实例被定义为static且仅在首次调用时初始化时。
考虑以下示例代码：
public class RetrofitClient {
private static Retrofit retrofit = null;
public static Retrofit getClient(String baseUrl, String token) {
if (retrofit == null) { // 仅在retrofit为null时执行初始化
String auth = "Bearer " + token;
String cont = "application/json";
OkHttpClient.Builder okHttpClient = new OkHttpClient.Builder();
okHttpClient.addInterceptor(chain -> {
Request request = chain.request().newBuilder()
.addHeader("Authorization", auth)
.addHeader("Content-Type", cont)
.build();
return chain.proceed(request);
});
retrofit = new Retrofit.Builder()
.baseUrl(baseUrl)
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient.build())
.build();
}
return retrofit;
}
}这段代码的问题在于：
- retrofit被声明为static，这意味着它在整个应用程序生命周期中只有一个实例。
- if (retrofit == null)条件确保了Retrofit实例及其内部的OkHttpClient只会在getClient方法首次调用时被创建。
- 在OkHttpClient的拦截器中，Authorization头部的token值是在retrofit实例首次创建时捕获的。
因此，一旦retrofit实例被创建，后续对getClient的调用，即使传入了新的token，由于retrofit不再是null，if块内的逻辑将不会再次执行。这意味着OkHttpClient的拦截器将继续使用首次创建时捕旧的token，从而导致令牌过期后的请求失败。
解决方案
针对上述问题，有几种策略可以确保Retrofit始终使用最新的令牌：
方案一：每次都重新构建Retrofit和OkHttpClient实例
最直接的方法是移除if (retrofit == null)条件，让Retrofit和OkHttpClient实例在每次调用getClient方法时都重新构建。
public class RetrofitClient {
// 移除 static Retrofit retrofit = null;
// 每次都创建新的实例
public static Retrofit getClient(String
baseUrl, String token) {
String auth = "Bearer " + token;
String cont = "application/json";
OkHttpClient.Builder okHttpClient = new OkHttpClient.Builder();
okHttpClient.addInterceptor(chain -> {
Request request = chain.request().newBuilder()
.addHeader("Authorization", auth)
.addHeader("Content-Type", cont)
.build();
return chain.proceed(request);
});
Retrofit retrofit = new Retrofit.Builder() // 每次都创建新的Retrofit实例
.baseUrl(baseUrl)
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient.build())
.build();
return retrofit;
}
}
优点： 简单直接，确保每次请求都使用最新的token。 缺点： 每次请求都会创建新的OkHttpClient和Retrofit实例，可能带来一定的性能开销。对于频繁请求的场景，这可能不是最优解。
方案二：移除static关键字，为每个新的令牌创建RetrofitClient实例
如果不想每次都重新构建，可以移除retrofit的static修饰符，并在令牌更新时创建新的RetrofitClient实例。
public class RetrofitClient {
private Retrofit retrofit = null; // 移除static
public Retrofit getClient(String baseUrl, String token) {
// 这里的逻辑可以保持 if (retrofit == null) 以在单个 RetrofitClient 实例生命周期内复用
// 但关键在于，当token更新时，你需要创建一个新的 RetrofitClient 实例
if (retrofit == null) {
String auth = "Bearer " + token;
String cont = "application/json";
OkHttpClient.Builder okHttpClient = new OkHttpClient.Builder();
okHttpClient.addInterceptor(chain -> {
Request request = chain.request().newBuilder()
.addHeader("Authorization", auth)
.addHeader("Content-Type", cont)
.build();
return chain.proceed(request);
});
retrofit = new Retrofit.Builder()
.baseUrl(baseUrl)
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient.build())
.build();
}
return retrofit;
}
}使用方式： 当令牌过期并获取到新令牌时：
// 旧的RetrofitClient实例 // RetrofitClient oldClient = ...; // oldClient.getClient(baseUrl, oldToken); // 当token更新时，创建新的RetrofitClient实例 RetrofitClient newClient = new RetrofitClient(); Retrofit newRetrofit = newClient.getClient(baseUrl, newToken); // 使用 newRetrofit 进行后续请求
优点： 避免了每次请求都重新构建，同时允许在令牌更新时刷新配置。 缺点： 需要在应用层面管理RetrofitClient实例的生命周期，确保在令牌更新后替换旧的实例。
方案三：缓存参数，仅在必要时重新构建
为了兼顾性能和正确性，可以缓存baseUrl和token，仅当这些参数发生变化时才重新构建Retrofit实例。
public class RetrofitClient {
private static Retrofit retrofit = null;
private static String baseUrlCached = null;
private static String tokenCached = null;
public static Retrofit getClient(String baseUrl, String token) {
// 当retrofit为null，或baseUrl/token与缓存值不同时，重新构建
if (retrofit == null || !baseUrl.equals(baseUrlCached) || !token.equals(tokenCached)) {
String auth = "Bearer " + token;
String cont = "application/json";
OkHttpClient.Builder okHttpClient = new OkHttpClient.Builder();
okHttpClient.addInterceptor(chain -> {
Request request = chain.request().newBuilder()
.addHeader("Authorization", auth)
.addHeader("Content-Type", cont)
.build();
return chain.proceed(request);
});
retrofit = new Retrofit.Builder()
.baseUrl(baseUrl)
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient.build())
.build();
baseUrlCached = baseUrl; // 更新缓存
tokenCached = token; // 更新缓存
}
return retrofit;
}
}优点： 实现了惰性初始化和按需更新，兼顾了性能和正确性。 缺点： 增加了代码的复杂性，需要仔细管理缓存状态。
方案四：使用OkHttp的Authenticator进行令牌刷新（推荐）
对于动态令牌刷新，OkHttp提供了一个更优雅、更健壮的机制：Authenticator。当服务器返回401（Unauthorized）响应时，Authenticator会被调用，允许你刷新令牌并重新发送请求。
-
实现 Authenticator 接口：
public class TokenAuthenticator implements Authenticator { private final TokenManager tokenManager; // 假设有一个TokenManager负责获取和存储令牌 public TokenAuthenticator(TokenManager tokenManager) { this.tokenManager = tokenManager; } @Nullable @Override public Request authenticate(@Nullable Route route, Response response) throws IOException { if (response.request().header("Authorization") == null) { return null; // 没有Authorization头，不是我们的问题 } // 检查是否已经尝试过刷新令牌，避免无限循环 String latestToken = tokenManager.getLatestToken(); if (response.request().header("Authorization").equals("Bearer " + latestToken)) { // 已经用最新令牌尝试过，但仍然失败，说明令牌无效或请求本身有问题 return null; } // 同步刷新令牌（这里需要一个同步操作，避免多个线程同时刷新） synchronized (this) { // 再次检查令牌，防止在等待锁的过程中其他线程已经刷新了令牌 latestToken = tokenManager.getLatestToken(); if (!response.request().header("Authorization").equals("Bearer " + latestToken)) { // 如果当前请求的令牌不是最新的，说明在等待锁期间令牌已更新 // 直接用新令牌重新构建请求 return response.request().newBuilder() .header("Authorization", "Bearer " + latestToken) .build(); } // 令牌确实过期了，需要刷新 String newToken = tokenManager.refreshToken(); // 这是一个阻塞调用，获取新令牌 if (newToken != null) { tokenManager.saveToken(newToken); // 保存新令牌 return response.request().newBuilder() .header("Authorization", "Bearer " + newToken) .build(); } } return null; // 无法刷新令牌，返回null表示原始请求失败 } } -
配置 OkHttpClient 使用 Authenticator：
public class RetrofitClient { private static Retrofit retrofit = null; private static OkHttpClient okHttpClient = null; // 缓存OkHttpClient实例 public static Retrofit getClient(String baseUrl, TokenManager tokenManager) { if (retrofit == null) { // 创建一个拦截器来添加初始令牌 Interceptor authInterceptor = chain -> { Request originalRequest = chain.request(); String currentToken = tokenManager.getLatestToken(); // 获取当前令牌 if (currentToken != null) { Request authorizedRequest = originalRequest.newBuilder() .header("Authorization", "Bearer " + currentToken) .header("Content-Type", "application/json") .build(); return chain.proceed(authorizedRequest); } return chain.proceed(originalRequest); }; // 构建OkHttpClient，并设置Authenticator okHttpClient = new OkHttpClient.Builder() .addInterceptor(authInterceptor) // 添加初始令牌的拦截器 .authenticator(new TokenAuthenticator(tokenManager)) // 设置Authenticator .build(); retrofit = new Retrofit.Builder() .baseUrl(baseUrl) .addConverterFactory(GsonConverterFactory.create()) .client(okHttpClient) .build(); } return retrofit; } }
优点：
- 自动化： 令牌刷新逻辑完全封装在Authenticator中，应用层无需手动处理401错误和重新发送请求。
- 线程安全： Authenticator内部的同步块确保了在多线程环境下令牌刷新的一致性。
- 集中管理： 将令牌获取、存储和刷新逻辑集中到TokenManager和Authenticator中，提高了代码的可维护性。
- 性能： OkHttpClient和Retrofit实例只需创建一次，性能开销小。
缺点：
- 实现相对复杂，需要理解Authenticator的工作原理。
- refreshToken()方法必须是同步阻塞的，因为它需要在原始请求失败后立即获取新令牌。
总结与最佳实践
Retrofit动态令牌管理的关键在于确保底层的OkHttpClient能够及时更新其请求头中的Authorization令牌。直接使用static变量和惰性初始化时，如果未考虑令牌的动态性，很容易导致旧令牌缓存问题。
推荐策略： 对于需要动态刷新令牌的场景，方案四：使用OkHttp的Authenticator 是最推荐和专业的做法。它提供了一个优雅且健壮的机制来处理令牌过期和刷新，将这一复杂逻辑与业务代码分离。
如果你的应用场景非常简单，令牌刷新不频繁，或者对性能要求不高，方案一：每次都重新构建 也是一个可行的选择。
无论选择哪种方案，理解Retrofit和OkHttpClient的生命周期以及它们如何处理请求头是解决这类问题的基础。通过本文提供的解决方案，你应该能够有效地管理Retrofit中的动态令牌，确保应用程序的网络通信顺畅无阻。
