retrofit封装网络请求 retrofit2封装

本文深入探讨了retrofit2在处理动态授权令牌时遇到的常见问题，特别是由于静态retrofit或okhttpclient实例导致的旧令牌持续使用，进而引发401未授权错误。文章提供了多种解决方案，从简单的每次重新初始化到更高级的基于拦截器和认证器的动态令牌刷新机制，旨在帮助开发者构建健壮的api客户端。

在使用Retrofit2进行API请求时，特别是在需要动态授权令牌（例如OAuth2令牌）的场景下，开发者常常会遇到一个棘手的问题：即使应用程序中已更新了新的令牌，Retrofit发出的请求却仍然携带旧的、已过期的令牌，导致服务器返回401未授权错误。这种现象通常发生在令牌过期后，应用程序从数据库获取了新令牌，但API请求依然失败，直到应用重启后才恢复正常。

以下是导致此问题的典型Retrofit客户端初始化代码：

public class RetrofitClient {    private static Retrofit retrofit = null;    public static Retrofit getClient(String baseUrl, String token) {        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;    }}

上述代码的核心问题在于retrofit变量被声明为static，并且其初始化被包裹在if (retrofit == null)条件块中。

因此，即使后续调用getClient方法时传入了一个全新的、有效的令牌，由于retrofit变量已经不为null，if条件不再满足，方法会直接返回之前创建的Retrofit实例。这个实例内部的OkHttpClient仍然携带着首次构建时捕获的旧令牌，从而导致所有后续请求都使用旧令牌，最终引发401错误。

最直接的解决方案是确保每次调用getClient时都重新构建Retrofit实例和OkHttpClient，从而强制更新拦截器中使用的令牌。

原理： 移除if (retrofit == null)条件，让Retrofit和OkHttpClient的构建逻辑在每次调用getClient时都执行。

优点： 简单直接，能确保每次请求都使用最新的令牌。

缺点： 频繁创建Retrofit和OkHttpClient对象会带来一定的性能开销，尤其是在高频请求的场景下。对于不变的baseUrl，这种重复构建是不必要的。

示例代码：

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实例        return new Retrofit.Builder()                .baseUrl(baseUrl)                .addConverterFactory(GsonConverterFactory.create())                .client(okHttpClient.build())                .build();    }}

另一种方法是放弃static关键字，让RetrofitClient成为一个普通的类，并在令牌更新时创建其新的实例。

原理： 移除retrofit变量的static修饰符，并在应用程序中，当令牌过期并更新后，创建RetrofitClient的新实例来获取带有新令牌的Retrofit服务。

优点： 提供了更灵活的生命周期管理，可以根据需要创建和销毁RetrofitClient实例。

缺点： 需要外部代码负责管理RetrofitClient的实例，确保在令牌更新时替换旧实例。如果应用程序中有多处使用RetrofitClient，可能需要一个依赖注入框架或单例管理机制来协调。

示例说明：

Perplexity是一个ChatGPT和谷歌结合的超级工具，可以让你在浏览互联网时提出问题或获得即时摘要

public class RetrofitClient {    private Retrofit retrofit = null; // 移除 static    public Retrofit getClient(String baseUrl, String token) { // 移除 static        if (retrofit == null) {            // ... (与原始代码相同，构建OkHttpClient和Retrofit)            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服务// RetrofitClient client = new RetrofitClient();// MyApiService service = client.getClient("https://api.example.com/", "initial_token").create(MyApiService.class);// 当令牌过期并更新后// String newToken = getNewTokenFromDatabase();// client = new RetrofitClient(); // 创建新的RetrofitClient实例// service = client.getClient("https://api.example.com/", newToken).create(MyApiService.class);

为了兼顾性能和令牌的正确性，可以在每次调用getClient时检查baseUrl或token是否发生了变化。只有当它们发生变化时，才重新构建Retrofit实例。

原理： 引入静态变量来缓存上一次使用的baseUrl和token。在if条件中，除了检查retrofit == null，还要检查当前传入的baseUrl或token是否与缓存值不同。

优点： 避免了不必要的Retrofit和OkHttpClient重建，提升了性能，同时确保在令牌更新时能正确刷新。

缺点： 增加了代码的复杂性，需要手动管理缓存状态。

示例代码：

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的动态令牌拦截器 (Interceptor) 和 认证器 (Authenticator)。

原理： 创建一个自定义的Interceptor，它在每次网络请求发出之前被调用。在这个拦截器中，我们可以实时地从一个可靠的数据源（如内存中的SharedPreferences、数据库或ViewModel）获取最新的授权令牌，并将其添加到请求头中。

优点：

示例代码：

public class AuthInterceptor implements Interceptor {    private TokenProvider tokenProvider; // 假设有一个接口提供最新令牌    public AuthInterceptor(TokenProvider tokenProvider) {        this.tokenProvider = tokenProvider;    }    @Override    public Response intercept(Chain chain) throws IOException {        Request originalRequest = chain.request();        String currentToken = tokenProvider.getToken(); // 实时获取最新令牌        if (currentToken != null && !currentToken.isEmpty()) {            Request newRequest = originalRequest.newBuilder()                    .header("Authorization", "Bearer " + currentToken)                    .header("Content-Type", "application/json")                    .build();            return chain.proceed(newRequest);        }        return chain.proceed(originalRequest); // 没有令牌则继续原请求    }}// TokenProvider 接口示例interface TokenProvider {    String getToken();    void saveToken(String token);    String getRefreshToken();    void saveRefreshToken(String refreshToken);}// RetrofitClient 的初始化public class RetrofitClient {    private static Retrofit retrofit = null;    private static OkHttpClient okHttpClient = null; // 缓存OkHttpClient    public static Retrofit getClient(String baseUrl, TokenProvider tokenProvider) {        if (okHttpClient == null) {            okHttpClient = new OkHttpClient.Builder()                    .addInterceptor(new AuthInterceptor(tokenProvider)) // 添加动态令牌拦截器                    // 可以添加其他拦截器，如日志拦截器等                    .build();        }        if (retrofit == null || !retrofit.baseUrl().toString().equals(baseUrl)) {            retrofit = new Retrofit.Builder()                    .baseUrl(baseUrl)                    .addConverterFactory(GsonConverterFactory.create())                    .client(okHttpClient) // 使用缓存的OkHttpClient                    .build();        }        return retrofit;    }}

原理： 当服务器返回401（未授权）响应时，OkHttp的Authenticator会被触发。在这个认证器中，我们可以执行令牌刷新逻辑（使用刷新令牌获取新的访问令牌），然后用新的访问令牌重新尝试之前的请求。

优点：

示例代码：

public class TokenAuthenticator implements Authenticator {    private TokenProvider tokenProvider; // 假设有一个接口提供最新令牌和刷新令牌的服务    private final Object lock = new Object(); // 用于同步刷新令牌    public TokenAuthenticator(TokenProvider tokenProvider) {        this.tokenProvider = tokenProvider;    }    @Override    public Request authenticate(Route route, Response response) throws IOException {        // 检查是否是由于我们自己的认证头导致401        if (response.request().header("Authorization") == null) {            return null; // 不是认证问题，跳过        }        // 同步块，确保只有一个线程在刷新令牌        synchronized (lock) {            String newAccessToken = tokenProvider.getToken(); // 获取当前可能已刷新的令牌            // 如果旧令牌和新令牌不同，说明令牌已在其他线程中刷新，直接重试            if (!response.request().header("Authorization").equals("Bearer " + newAccessToken)) {                return response.request().newBuilder()                        .header("Authorization", "Bearer " + newAccessToken)                        .build();            }            // 否则，执行令牌刷新逻辑            String refreshToken = tokenProvider.getRefreshToken();            if (refreshToken != null) {                // 假设这里有一个同步的API调用来刷新令牌                // 注意：这里不能直接使用Retrofit实例进行刷新，因为可能导致死循环                // 应该使用一个独立的OkHttpClient实例进行刷新请求                String refreshedToken = refreshAccessToken(refreshToken); // 实际的刷新令牌网络请求                if (refreshedToken != null) {                    tokenProvider.saveToken(refreshedToken); // 保存新令牌                    return response.request().newBuilder()                            .header("Authorization", "Bearer " + refreshedToken)                            .build();                }            }        }        return null; // 无法刷新令牌，返回null表示不再重试    }    // 假设这是一个独立的同步方法来刷新令牌    private String refreshAccessToken(String refreshToken) throws IOException {        // TODO: 在这里实现一个独立的HTTP客户端来发送刷新令牌请求        // 不要使用与主Retrofit客户端相同的OkHttpClient，以避免死循环        // 例如：        // OkHttpClient client = new OkHttpClient();        // Request request = new Request.Builder()        //         .url("YOUR_REFRESH_TOKEN_URL")        //         .post(RequestBody.create(MediaType.parse("application/json"), "{\"refresh_token\":\"" + refreshToken + "\"}"))        //         .build();        // Response response = client.newCall(request).execute();        // if (response.isSuccessful()) {        //     // 解析响应，返回新的access token        // }        return null; // 刷新失败    }}// 在 RetrofitClient 中配置 Authenticatorpublic class RetrofitClient {    // ... (其他部分同上)    public static Retrofit getClient(String baseUrl, TokenProvider tokenProvider) {        if (okHttpClient == null) {            okHttpClient = new OkHttpClient.Builder()                    .addInterceptor(new AuthInterceptor(tokenProvider))                    .authenticator(new TokenAuthenticator(tokenProvider)) // 添加认证器                    .build();        }        // ... (其他部分同上)        return retrofit;    }}

管理Retrofit2中的动态授权令牌是构建健壮API客户端的关键。避免静态实例和硬编码令牌是首要原则。通过采用动态令牌拦截器，我们可以确保每次请求都携带最新的令牌；而结合使用认证器，则能优雅地处理令牌过期后的自动刷新和请求重试。这些策略共同构成了处理动态授权令牌的最佳实践，显著提升了应用程序的稳定性和用户体验。

以上就是Retrofit2授权令牌管理：深入理解与解决方案的详细内容，更多请关注乐哥常识网其它相关文章！