RxJava+Retrofit实现全局过期token自动刷新Demo篇

在上篇文章Rxjava+Retrofit 实现全局过期 Token 自动刷新中,主讲了实现的思想,发布之后,有些小伙伴抱怨没有完整的 Demo,所以在这里重新补上了一个姗姗来迟的简单的实例。Android代码点我

适用情况

一个应用的大部分请求都需要一个带有 token 的参数,来表示当前的用户信息;另外 token 是带有有效时间的,当 token 过期时,需要执行刷新 token 的操作。这个解决方案就是针对这种情况而产生的,当一个请求收到 token 过期的错误信息,我们会在底层执行刷新 token 的操作(这个操作是透明操作,对用户不可见),当 token 刷新成功之后,则重新执行之前发出的请求。

另外,不适用的就是 token 是放在 http 请求的 header 中的请求,这种情况的需要通过使用 okhttp 的拦截器来实现,可自行查阅其他的文章。

Demo 实现

1.实现思想

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

2.API实现

为了保证 Demo 的完整性,API 这个环节是必不可少的,这里允许我偷个小懒,没有采用远程的 API 服务来实现。而是使用 NodeJs 在本地写了个简单的服务,所以小小地辛苦读者多动一下手指头,先启动咱们的 API 服务。NodeJs代码点我

  • 启动服务
    完成的服务器代码在项目的根目录下的 server 文件中,里面包含一个名 refresh_token 的 js 文件。我们切到 server 目录下,在命令行下执行 node refresh_token.js,就可以启动一个监听端口号为 8888 的服务。
    另外,如果在电脑上访问的话,执行 http://127.0.0.1:8888 即可访问;如果通过模拟器访问的话,需要拿到电脑的本地 IP,这里我获取到的是 192.168.56.1。

  • API 介绍
    这里为了模仿真实的 token 原理,我采用时间戳来作为 token 的一种实现。客户端向服务器请求 token, 服务器返回当前的时间戳来作为 token;之后用户每次的请求则需要携带这个 token 作为参数,服务器拿到客户端发送过来的 token,来与当前的时间进行比较,这里我使用的时间间隔为30秒,若小于30秒,服务器认为 token 合法,返回正确结果;若大于30秒,则认为 token 失效。

  • 实现
    这里我设计了三个 API,获取 token 的 get_token 及刷新 token 的 refresh_token,简单起见,它俩不需要参数,并且返回的结果相同;另外一个正常请求的 API 是 request,它需要传递一个名称为 token 的参数。代码很简单,如下:

var http = require('http');
var url = require('url');
var querystring = require('querystring');

http.createServer(function (request, response) {

   // 发送 HTTP 头部 
   // HTTP 状态值: 200 : OK
   // 内容类型: text/plain
   response.writeHead(200, {'Content-Type': 'text/plain'});

   var pathname = url.parse(request.url).pathname;
   if (pathname == "/get_token" || pathname == "/refresh_token"){
      // get a new token or refresh the token
      var result = {
         "success" : true,
         "data" : {
            "token" : new Date().getTime().toString()
         }
      }
      response.end(JSON.stringify(result));
   }else if (pathname == "/request"){
      // Normal request
      var token_str = querystring.parse(url.parse(request.url).query)['token'];
      if (token_str){
         var token_time = parseFloat(token_str);
         var cur_time = new Date().getTime();
         if(cur_time - token_time < 30 * 1000){
            var result = {
               "success" : true,
               "data" : {
                  "result" : true
               }
            }
            response.end(JSON.stringify(result)); 
         }else{
            response.end(JSON.stringify({"success": false, "error_code" : 1001})); 
         }
      } else {
         response.end(JSON.stringify({"success": false, "error_code" : 1000})); 
      }
   }

}).listen(8888);

代码很简单,需要提及的是当 token 超过限定的30秒,返回的 error_code 是 1001;而 token 不存在则返回的 error_code 是 1000,这时我们可能需要做的操作就是重新登录的操作等等。

3.错误抛出

当服务器错误信息的时候,同样也是一个 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 方法。

好了,说说我们这里要修改的地方:

  • 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;
}

4.添加代理

在使用 Retrofit 的时候,我们都需要针对每个 API 编写相应的接口代码,最后通过 Retrofit 的 create 方法来实现调用,而这个方法就是通过使用代理,根据这个接口方法的各种注解参数,最后一个个单独的完整的 API 调用。

因为我们也需要对每个 API 做处理,所以我们也对它的 create 方法做一个代理的实现,主要使用的代码是 Proxy类的 newProxyInstance方法。

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

核心的代理实现则是这个 ProxyHandler,它是对接口 InvocationHandler 的一个实现类。思想就是针对 method 的调用,做以 retryWhen 的包装,在retryWhen 中获取相应的异常信息来做处理,看 retryWhen 的代码:

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) {
                        if (throwable instanceof TokenInvalidException) {
                            return refreshTokenWhenTokenInvalid();
                        } else if (throwable instanceof TokenNotExistException) {
                            Toast.makeText(BaseApplication.getContext(), "Token is not existed!!", Toast.LENGTH_SHORT).show();
                            return Observable.error(throwable);
                        }
                        return Observable.error(throwable);
                    }
                });
            }
        })

这里针对 token 过期的 TokenInvalidException 的异常,执行刷新 token 的操作,刷新 token 的操作则是直接调用 Retrofit 的方法,而不需要走代理了。另外它必须是个同步的代码块,主要的代码就不在这里贴了,具体的代码见 这里

5.代码验证

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

  • 按钮1:获取token
@OnClick(R.id.btn_token_get)
public void onGetTokenClick(View v) {
  RetrofitUtil.getInstance()
      .get(IApiService.class)
      .getToken()
      .subscribeOn(Schedulers.io())
      .observeOn(AndroidSchedulers.mainThread())
      .subscribe(new Subscriber<TokenModel>() {
          @Override
          public void onCompleted() {

          }

          @Override
          public void onError(Throwable e) {

          }

          @Override
          public void onNext(TokenModel model) {
              if (model != null && !TextUtils.isEmpty(model.token)) {
                  GlobalToken.updateToken(model.token);
              }
          }
      });
}

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

  • 正常的请求
    这里为了模拟多请求,这里我直接调正常的请求5次:
@OnClick(R.id.btn_request)
public void onRequestClick(View v) {
  for (int i = 0; i < 5; i++) {
      RetrofitUtil.getInstance()
          .getProxy(IApiService.class)
          .getResult(GlobalToken.getToken())
          .subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<ResultModel>() {
              @Override
              public void onCompleted() {

              }

              @Override
              public void onError(Throwable e) {

              }

              @Override
              public void onNext(ResultModel model) {

              }
          });
  }
}

为了查看输出,另外对 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个请求又进行了重试,并都返回了成功的信息。一切圆满。

最后,一个完整而又简单的Demo就完成了,若是还有什么不清楚的小伙伴可以加 QQ 群:289926871 来交流。完整的代码这里的包为 token 的结构下,server 代码则是根目录下的 server 文件夹中,测试的时候不要忘启动 server 哦。

推荐阅读更多精彩内容