Retrofit Token过期自动刷新并重新请求接口

最新推荐文章于 2024-10-08 09:48:40 发布
最新推荐文章于 2024-10-08 09:48:40 发布
阅读量3.4w 收藏 35
点赞数 7
分类专栏： Android开发 文章标签： retrofit token 刷新
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jdsjlzx/article/details/52442113
版权

在有心课堂的群里，有网友提出如下场景：

当前开发的 App 遇到一个问题：

当请求某个接口时，由于 token 已经失效，所以接口会报错。
但是产品经理希望 app 能够马上刷新 token ，然后重复请求刚才那个接口，这个过程对用户来说是无感的。

请求 A 接口－》服务器返回 token 过期－》请求 token 刷新接口－》请求 A 接口

我们应该是怎么解决这个问题呢？

经过百度搜索到了相关信息，这里总结下。

本文是采用RxJava + Retrofit来实现网络请求封装。

实现原理

利用 Observale 的 retryWhen 的方法，识别 token 过期失效的错误信息，此时发出刷新 token 请求的代码块，完成之后更新 token，这时之前的请求会重新执行，但将它的 token 更新为最新的。另外通过代理类对所有的请求都进行处理，完成之后，我们只需关注单个 API 的实现，而不用每个都考虑 token 过期，大大地实现解耦操作。

App多个请求token失效的处理逻辑

当集成了Retrofit之后，我们app中的网络请求接口则变成了一个个单独的方法，这时我们需要添加一个全局的token错误抛出机制，来避免每个接口都所需要的token验证处理。

token失效错误抛出

在Retrofit中的Builder中，是通过GsonConvertFactory来做json转成model数据处理的，这里我们就需要重新实现一个自己的GsonConvertFactory，这里主要由三个文件GsonConvertFactory,GsonRequestBodyConverter,GsonResponseBodyConverter，它们三个从源码中拿过来新建即可。主要我们重写GsonResponseBodyConverter这个类中的convert的方法，这个方法主要将ResponseBody转换我们需要的Object，这里我们通过拿到我们的token失效的错误信息，然后将其以一个指定的Exception的信息抛出。

GsonConverterFactory代码如下：

这里写图片描述

修改的地方：
1.修改 GsonConverterFactory 中，生成 GsonResponseBodyConverter 的方法：

@Override
public Converter<ResponseBody, ?> responseBodyConverter(final Type type, Annotation[] annotations, Retrofit retrofit) {
  Type newType = new ParameterizedType() {
      @Override
      public Type[] getActualTypeArguments() {
          return new Type[] { type };
      }

      @Override
      public Type getOwnerType() {
          return null;
      }

      @Override
      public Type getRawType() {
          return ApiModel.class;
      }
  };
  TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(newType));
  return new GsonResponseBodyConverter<>(adapter);
}

可以看出我们这里对 type 类型，做以包装，让其重新生成一个类型为 ApiModel 的新类型。因为我们在写接口代码的时候，都以真正的类型 type 来作为返回值的，而不是 ApiModel。

2.GsonResponseBodyConverter的处理 它的修改，则是要针对返回结果，做以异常的判断并抛出，主要看其的 convert方法：

@Override
public Object convert(ResponseBody value) throws IOException {
  try {
      ApiModel apiModel = (ApiModel) adapter.fromJson(value.charStream());
      if (apiModel.errorCode == ErrorCode.TOKEN_NOT_EXIST) {
          throw new TokenNotExistException();
      } else if (apiModel.errorCode == ErrorCode.TOKEN_INVALID) {
          throw new TokenInvalidException();
      } else if (!apiModel.success) {
          // TODO: 16/8/21 handle the other error.
          return null;
      } else if (apiModel.success) {
          return apiModel.data;
      }
  } finally {
      value.close();
  }
  return null;
}
错误抛出

当服务器错误信息的时候，同样也是一个 model，不同的是 success 为 false，并且含有 error_code的信息。所以我们需要针对 model 处理的时候，做以判断。主要修改的地方就是 retrofit 的 GsonConvertFactory，这里不再通过 gradle 引入，直接把其源码中的三个文件添加到咱们的项目中。

首先提及的一下是对统一 model 的封装，如下：

public class ApiModel<T> {
    public boolean success;
    @SerializedName("error_code") public int errorCode;

    public T data;
}

当正确返回的时候，我们获取到 data，直接给上层；当出错的时候，可以针对 errorCode的信息，做一些处理，让其走最上层调用的 onError 方法。

多请求的API代理

为所有的请求都添加Token的错误验证，还要做统一的处理。借鉴Retrofit创建接口的api，我们也采用代理类，来对Retrofit的API做统一的代理处理。

建立API代理类
public class ApiServiceProxy {

    Retrofit mRetrofit;

    ProxyHandler mProxyHandler;

    public ApiServiceProxy(Retrofit retrofit, ProxyHandler proxyHandler) {
        mRetrofit = retrofit;
        mProxyHandler = proxyHandler;
    }

    public <T> T getProxy(Class<T> tClass) {
        T t = mRetrofit.create(tClass);
        mProxyHandler.setObject(t);
        return (T) Proxy.newProxyInstance(tClass.getClassLoader(), new Class<?>[] { tClass }, mProxyHandler);
    }
}

这样，我们就需要通过ApiServiceProxy中的getProxy方法来创建API请求。另外，其中的ProxyHandler则是实现InvocationHandler来实现。

public class ProxyHandler implements InvocationHandler {

    private Object mObject;

    public void setObject(Object obj) {
        this.mObject = obj;
    }

    @Override
    public Object invoke(Object proxy, final Method method, final Object[] args) throws Throwable {
        Object result = null;
        result = Observable.just(null)
            .flatMap(new Func1<Object, Observable<?>>() {
                @Override
                public Observable<?> call(Object o) {
                    try {
                        checkTokenValid(method, args);
                        return (Observable<?>) method.invoke(mObject, args);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }
                    return Observable.just(new APIException(-100, "method call error"));
                }
            }).retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
                             @Override
                             public Observable<?> call(Observable<? extends Throwable> observable) {
                                 return observable.
                                     flatMap(new Func1<Throwable, Observable<?>>() {
                                                 @Override
                                                 public Observable<?> call(Throwable throwable) {
                                                     Observable<?> x = checkApiError(throwable);
                                                     if (x != null) return x;
                                                     return Observable.error(throwable);
                                                 }
                                             }

                                     );
                             }
                         }

                , Schedulers.trampoline());
        return result;
        }
  }

这里的invoke方法则是我们的重头戏，在其中通过将method.invoke方法包装在Observable中，并添加retryWhen的方法，在retryWhen方法中，则对我们在GsonResponseBodyConverter中暴露出来的错误，做一判断，然后执行重新获取token的操作，这段代码就很简单了。就不再这里细述了。

还有一个重要的地方就是，当token刷新成功之后，我们将旧的token替换掉呢？笔者查了一下，java8中的method类，已经支持了动态获取方法名称，而之前的Java版本则是不支持的。那这里怎么办呢？通过看retrofit的调用，可以知道retrofit是可以将接口中的方法转换成API请求，并需要封装参数的。那就需要看一下Retrofit是如何实现的呢？最后发现重头戏是在Retrofit对每个方法添加的@interface的注解，通过Method类中的getParameterAnnotations来进行获取，主要的代码实现如下：

/**
     * Update the token of the args in the method.
     */
private void updateMethodToken(Method method, Object[] args) {
        if (mIsTokenNeedRefresh && !TextUtils.isEmpty(GlobalToken.getToken())) {
            Annotation[][] annotationsArray = method.getParameterAnnotations();
            Annotation[] annotations;
            if (annotationsArray != null && annotationsArray.length > 0) {
                for (int i = 0; i < annotationsArray.length; i++) {
                    annotations = annotationsArray[i];
                    for (Annotation annotation : annotations) {
                        if (annotation instanceof Query) {
                            if (TOKEN.equals(((Query) annotation).value())) {
                                args[i] = GlobalToken.getToken();
                            }
                        }
                    }
                }
            }
            mIsTokenNeedRefresh = false;
        }
    }

这里，则遍历我们所使用的token字段，然后将其替换成新的token.

代码验证

最上层的代码调用中，添加了两个按钮:

按钮1：获取token

这里写图片描述

token 获取成功之后，仅仅更新一下全局的token即可。

按钮2：正常的请求

这里为了模拟多请求，这里我直接调正常的请求5次：
这里写图片描述

为了查看输出，另外对 Okhttp 添加了 HttpLoggingInterceptor 并设置 Body 的 level 输出，用来监测 http 请求的输出。

一切完成之后，先点击获取 token 的按钮，等待30秒之后，再点击正常请求按钮。可以看到如下的输出：

--> GET http://192.168.56.1:8888/request?token=1471774119164 http/1.1
 --> END GET
 --> GET http://192.168.56.1:8888/request?token=1471774119164 http/1.1
 --> END GET
 --> GET http://192.168.56.1:8888/request?token=1471774119164 http/1.1
 --> END GET
 --> GET http://192.168.56.1:8888/request?token=1471774119164 http/1.1
 --> END GET
 --> GET http://192.168.56.1:8888/request?token=1471774119164 http/1.1
 --> END GET
 <-- 200 OK http://192.168.56.1:8888/request?token=1471774119164 (8ms)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Transfer-Encoding: chunked
 {"success":false,"error_code":1001}
 <-- END HTTP (35-byte body)
 <-- 200 OK http://192.168.56.1:8888/request?token=1471774119164 (5ms)
 <-- 200 OK http://192.168.56.1:8888/request?token=1471774119164 (4ms)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Transfer-Encoding: chunked
 --> GET http://192.168.56.1:8888/refresh_token http/1.1
 --> END GET
 {"success":false,"error_code":1001}
 <-- END HTTP (35-byte body)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Transfer-Encoding: chunked
 <-- 200 OK http://192.168.56.1:8888/request?token=1471774119164 (7ms)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 {"success":false,"error_code":1001}
 Transfer-Encoding: chunked
 <-- END HTTP (35-byte body)
 {"success":false,"error_code":1001}
 <-- END HTTP (35-byte body)
 <-- 200 OK http://192.168.56.1:8888/refresh_token (2ms)
 Content-Type: text/plain
 <-- 200 OK http://192.168.56.1:8888/request?token=1471774119164 (6ms)
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Connection: keep-alive
 Transfer-Encoding: chunked
 Transfer-Encoding: chunked
 {"success":true,"data":{"token":"1471826289336"}}
 <-- END HTTP (49-byte body)
 {"success":false,"error_code":1001}
 <-- END HTTP (35-byte body)
roxy: Refresh token success, time = 1471790019657
 --> GET http://192.168.56.1:8888/request?token=1471826289336 http/1.1
 --> GET http://192.168.56.1:8888/request?token=1471826289336 http/1.1
 --> END GET
 --> END GET
 --> GET http://192.168.56.1:8888/request?token=1471826289336 http/1.1
 --> GET http://192.168.56.1:8888/request?token=1471826289336 http/1.1
 --> END GET
 --> END GET
 --> GET http://192.168.56.1:8888/request?token=1471826289336 http/1.1
 --> END GET
 <-- 200 OK http://192.168.56.1:8888/request?token=1471826289336 (2ms)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Transfer-Encoding: chunked
 {"success":true,"data":{"result":true}}
 <-- END HTTP (39-byte body)
 <-- 200 OK http://192.168.56.1:8888/request?token=1471826289336 (4ms)
 <-- 200 OK http://192.168.56.1:8888/request?token=1471826289336 (6ms)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Transfer-Encoding: chunked
 {"success":true,"data":{"result":true}}
 <-- END HTTP (39-byte body)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Transfer-Encoding: chunked
 <-- 200 OK http://192.168.56.1:8888/request?token=1471826289336 (4ms)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Transfer-Encoding: chunked
 {"success":true,"data":{"result":true}}
 <-- END HTTP (39-byte body)
 <-- 200 OK http://192.168.56.1:8888/request?token=1471826289336 (7ms)
 Content-Type: text/plain
 Date: Mon, 22 Aug 2016 00:38:09 GMT
 Connection: keep-alive
 Transfer-Encoding: chunked
 {"success":true,"data":{"result":true}}
 <-- END HTTP (39-byte body)
 {"success":true,"data":{"result":true}}
 <-- END HTTP (39-byte body)

刚发出的5个请求都返回了 token 过期的 error，之后看到一个重新刷新 token 的请求，它成功之后，原先的5个请求又进行了重试，并都返回了成功的信息。

完整代码：
https://github.com/alighters/AndroidDemos/tree/master/app/src/main/java/com/lighters/demos/token

server代码则是根目录下的 server 文件夹中，测试的时候不要忘启动 server 哦。

参考文章：

http://alighters.com/blog/2016/08/22/rxjava-plus-retrofitshi-xian-zhi-demo/

以上实现是将token放在在url里面，如果是放在Header里面，怎么实现呢？还是要通过okhttp的拦截器来实现。

思路：
1.通过拦截器，获取返回的数据
2.判断token是否过期
3.如果token过期则刷新token
4.使用最新的token，重新请求网络数据

实现如下：

public class TokenInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = chain.proceed(request);

        if (isTokenExpired(response)) {//根据和服务端的约定判断token过期
            //同步请求方式，获取最新的Token
            String newSession = getNewToken();
            //使用新的Token，创建新的请求
            Request newRequest = chain.request()
                    .newBuilder()
                    .header("Cookie", "JSESSIONID=" + newSession)
                    .build();
            //重新请求
            return chain.proceed(newRequest);
        }
        return response;
    }

    /**
     * 根据Response，判断Token是否失效
     *
     * @param response
     * @return
     */
    private boolean isTokenExpired(Response response) {
        if (response.code() == 404) {
            return true;
        }
        return false;
    }

    /**
     * 同步请求方式，获取最新的Token
     *
     * @return
     */
    private String getNewToken() throws IOException {
        // 通过一个特定的接口获取新的token，此处要用到同步的retrofit请求
        Response_Login loginInfo = CacheManager.restoreLoginInfo(BaseApplication.getContext());
        String username = loginInfo.getUserName();
        String password = loginInfo.getPassword();

        Call<Response_Login> call = WebHelper.getSyncInterface().synclogin(new Request_Login(username, password));
        loginInfo = call.execute().body();

        loginInfo.setPassword(password);
        CacheManager.saveLoginInfo(loginInfo);
        return loginInfo.getSession();
    }
}

添加拦截器：

OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(new TokenInterceptor())
                .build();

参考：http://www.jianshu.com/p/8d1ee61bc2d2

一叶飘舟
关注
专栏目录
Android 关于Retrofit OkHttp Token过期刷新 请求并发的问题
Dacaiji_的博客
03-07 4050
class TokenInterceptor( @Volatile var token: String, @Volatile var refreshToken: String ) : Interceptor { companion object { const val ACCESS_TOKEN_NAME = "accessToken" const val REFRESH_TOKEN_NAME = "refreshToken" .
Android中使用Retrofit刷新Token
进击的Coder
06-29 3334
Android中使用Retrofit刷新Token 实际开发中，例如登录，我们向后台传参用户名和密码，后台会返回给我们一个Token，用于后面接口的调用， 这样后端就能通过我们传入的token知道我们是哪个用户，一般token的有效期是2小时。2小时候token会自动过期。我们需要拿到新的Token，保持登陆状态。 如何刷新Token呢 如上图所示，我们loging过后后台返回token、...
Rxjava2+Retrofit之Token自动刷新
热门推荐
smily的博客
07-27 1万+
* 本文同步发表在简书，转载请注明出处。 上篇文章主要对Retrofit做了封装，使之使用起来更加方便。在之前的封装中token过期再次刷新token后需要手动调用之前的请求，这种处理方式不够优雅，因此，在原有的基础上，本篇文章将基于上篇文章的封装并优化Token验证机制。使之能够实现过期自动刷新并重新调用请求。 接下来将通过以下几个小节来学习如何实现token验证。 - 为什么要引入......
Retrofit-Android上的token验证
CC
03-14 3579
这篇文章是一个除了前面的帖子使用retrofit进行基本的身份验证和使用基于OAuth的基本APIS。我们将讨论的话题token认证从一个Android应用到任何网络服务或API支持这种认证。 Integrate Token Authentication 如果你读前面的帖子关于使用retrofit的身份验证,你会猜到我们要怎么做:扩展ServiceGenerator类和集成方法处理
前端无感刷新token机制（一文说明白）
最新发布
weixin_47339511的博客
10-08 1164
用户登录成功之后，两个 token（一个 access_token、一个 refresh_token），访问接口时携带 access_token 访问，当 access_token 过期时，通过 refresh_token 来刷新，拿到新的 access_token 和 refresh_token。 而 access_token 一般过期时间设置的比较短，比如 30 分钟，refresh_token 设置的过期时间比较长，比如 7 天。这样，只要你 7 天内访问一次，就能刷新 token，再续 7 天，一
RXjava+Retrofit封装:刷新token
皮卡丘的博客
01-10 560
http://gank.io/post/56e80c2c677659311bed9841
Retrofit Token过期 重新请求Token再去请求接口
weixin_30687051的博客
05-25 511
需求是这样的：请求接口A -- 服务器返回数据Token过期或失效 -- 重新请求Token并设置 -- 再去请求接口A刚解决了这个问题，趁热打铁，写个博客记录一下；这个Token是添加到请求头里面的；使用OKHTTP设置Retrofit中的请求头：*记录请求到的Token/** * 请求头token * @return */ public String ...
Retrofit 刷新token
cmmboy1990的博客
07-06 419
Retrofit 刷新token package com.cmmboy.lib_basic.network; import com.cmmboy.lib_basic.BuildConfig; import com.cmmboy.lib_basic.sp.UserSharedPre; import com.cmmboy.lib_basic.utils.LogUtils; import com.google.gson.JsonObject; import org.json.JSONException; i
Retrofit 通过刷新头部Token解决token过期
crazyZhangxl的博客
11-01 4169
需求分析： 使用token来维持用户登陆状态是很常见的，但应当明确后台设置的token也都是有一定期限的，假如说是7天，那么我们的用户信息的获取必然是和token相绑定的，所以不可避免的我们的Android应用会存在token过期的问题，以下将一个开发案例来记录下如何自动刷新token的问题。 运行结果： 运行流程是获取相应的信息，首先是验证了token是否有效[包括一开始token不存...
Android开发 Retrofit实现token失效刷新的处理方案
weixin_33797791的博客
09-05 1326
2019独角兽企业重金招聘Python工程师标准>>> ...
请求时token过期自动刷新token操作
11-19
1.在开发过程中，我们都会接触到token，token的作用是什么呢？主要的作用就是为了安全，用户登陆时，服务器会随机生成一个有时效性的token,用户的每一次请求都需要携带上token，证明其请求的合法性，服务器会验证token，只有通过验证才会返回请求结果。 2.当token失效时，现在的网站一般会做两种处理，一种是跳转到登陆页面让用户重新登陆获取新的token，另外一种就是当检测到请求失效时，网站自动去请求新的token，第二种方式在app保持登陆状态上面用得比较多。 3.下面进入主题，我们请求用的是axios，不管用何种请求方式，刷新token的原理都是一样的。 //封装了一个统一的请
Android OkHttp实现全局过期token自动刷新示例
01-20
总结，Android应用使用OkHttp实现全局过期token自动刷新的关键在于创建一个拦截器，检测HTTP响应以确定token是否过期，如果过期则刷新token并重新发送请求。这种方式有效地解决了用户在token过期时无感知地保持会话...
Android token过期刷新处理的方法示例
08-26
Android Token 过期刷新处理可以通过两种解决方案来实现：第一种解决方案是通过 OkHttp 提供的 Authenticator 接口来实现 Token 的刷新，第二种解决方案是根据与后端协商好的返回码处理刷新 Token 步骤。两种解决...
RxJava - 为Retrofit添加请求重试
qq_21184657的专栏
06-13 2271
在App程序中不可避免的会用到网络请求，但是我们在平常的使用中每个网络请求都是一次性的操作，有可能此时的网络请求正好是不稳定的就造成了你的这次请求无效，因此我们必须为APP添加请求重试功能。 在这里网络请求重试功能应该有两个必须点 1. 可配置的重试次数，重新请求时间 2. 对网络请求错误的判断（是超时，404） 操作符retryWhen 在这里需要用到rxjava的操作符ret...
retrofit+okhttp实现单点登录自动刷新token并处理并发问题
狂发小生的博客
12-24 1309
retrofit+okhttp实现单点登录自动刷新token说明技术实现直接撸代码 说明 在app使用过程中，登录中因为token过期的原因，可以需要重新登录，这样使用体验上会不好，所以会有产品要求token过期后自动刷新token，获取到新的token在继续请求接口，用户在使用上无感知，大大提升了用户体验。 技术实现 token一般我们会放到网络请求的header中 这样我们可以使用okhttp中拦截器，对网络请求进行拦截，获取到token过期的code码后，去请求刷新token，替换header请求中对
java retrofit_java – 使用Retrofit 2重试请求
weixin_28744613的博客
02-16 516
我终于做了这样的事情，对任何有兴趣的人：1首先我做了一个抽象类CallbackWithRetrypublic abstract class CallbackWithRetry implements Callback {private static final int TOTAL_RETRIES = 3;private static final String TAG = CallbackWithRe...
android token机制_Android网络实战篇——Token添加、过期判定以及处理（全局自动刷新）...
weixin_34997006的博客
02-22 1835
Android日常开发中网络请求必不可少，一般来说每一个接口API都会设置Token，用来验证和做唯一识别，Token都会设置一个有效时间，那么Token失效了怎么办？怎样来更新Token？首先怎样来判断Token失效呢？与后端约定，保存到本地，约定时间到了就判定Token已过期后端返回HTTP Code 401，客户端接到401后判定Token已过期后端返回与客户端约定的自定义Code，客户端接...
android token过期后刷新并重新请求A接口。代码实现
06-06
好的，以下是一个可能的代码实现，供您参考： 首先，我们需要定义一个TokenInterceptor拦截器类，用于在每次请求接口时检查Token是否过期： ```java public class TokenInterceptor implements Interceptor { private static final String TOKEN_KEY = "token"; private static final String AUTHORIZATION_HEADER = "Authorization"; private SharedPreferences mSharedPreferences; private ApiService mApiService; public TokenInterceptor(Context context, ApiService apiService) { mSharedPreferences = context.getSharedPreferences("my_prefs", Context.MODE_PRIVATE); mApiService = apiService; } @Override public Response intercept(Chain chain) throws IOException { Request request = chain.request(); String token = mSharedPreferences.getString(TOKEN_KEY, ""); if (!TextUtils.isEmpty(token)) { request = request.newBuilder() .addHeader(AUTHORIZATION_HEADER, "Bearer " + token) .build(); } Response response = chain.proceed(request); if (response.code() == 401) { // Token过期，重新请求Token并重试请求 String newToken = getNewToken(); if (!TextUtils.isEmpty(newToken)) { // 更新Token并重试请求 mSharedPreferences.edit().putString(TOKEN_KEY, newToken).apply(); Request newRequest = request.newBuilder() .addHeader(AUTHORIZATION_HEADER, "Bearer " + newToken) .build(); response = chain.proceed(newRequest); } } return response; } private String getNewToken() { // 发送获取新Token的请求，返回新Token Call<TokenResponse> call = mApiService.refreshToken(); try { Response<TokenResponse> response = call.execute(); if (response.isSuccessful()) { TokenResponse tokenResponse = response.body(); return tokenResponse.getToken(); } } catch (IOException e) { e.printStackTrace(); } return null; } } ``` 然后，在创建Retrofit实例时，添加上述拦截器： ```java OkHttpClient client = new OkHttpClient.Builder() .addInterceptor(new TokenInterceptor(context, apiService)) .build(); Retrofit retrofit = new Retrofit.Builder() .baseUrl(BASE_URL) .client(client) .addConverterFactory(GsonConverterFactory.create()) .build(); ``` 其中，apiService是一个定义了刷新Token接口的Retrofit接口。 最后，在请求A接口时，如果遇到Token过期的情况，TokenInterceptor会自动发送请求获取新Token，并重新发送A接口请求： ```java Call<ResponseA> call = apiService.getAData(); call.enqueue(new Callback<ResponseA>() { @Override public void onResponse(Call<ResponseA> call, Response<ResponseA> response) { if (response.isSuccessful()) { // 请求成功 ResponseA responseA = response.body(); // 处理返回的数据 } else { // 请求失败 // 这里不需要处理401 Unauthorized错误，TokenInterceptor已经处理过了 } } @Override public void onFailure(Call<ResponseA> call, Throwable t) { // 请求失败 } }); ``` 以上就是一个简单的android token过期后刷新并重新请求A接口的代码实现，仅供参考。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值