转载

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即可。

按钮2：正常的请求

这里为了模拟多请求，这里我直接调正常的请求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)