Android处理token失效的处理方法

有些公司服务端是按照oauth设计的，请求的时候用token来进行身份验证。token分为refresh_token和access_token。

进行网络请求的时候用access_token，access_token有效期比较短，access_token过期后用refresh_token刷新出新的access_token。

refresh_token有效期比较长，只有用户在别的地方登陆了或者过了有效期了才会失效，refresh_token失效之后通过用户名密码请求出新的refresh_token。

Android在处理网络请求的时候使用access_token，如果access_token过期，自动拿refresh_token刷新出access_token，再重新发起刚刚的请求。也就是说刷新access_token这个动作是我们程序帮用户实现的，对于用户来说不需要这个过程。

那么怎么实现  在进行某个网络请求的时候，返回了access_token过期的错误码，程序自动刷出新access_token，重新发起之前的请求呢？

之前我有想过，网络请求的时候，把请求的url和参数暂时的保存下来，在解析返回结果 access_token过期的时候，重新创建一个请求刷access_token，然后把之前暂时保存的url和参数重新请求一次。

理论上是可行的，但是不太优雅。网上也没找到什么好的写法。

但是网上有个不错的第三方网络请求框架okhttp，这个东西对于上面说说的需求有很好的封装。

有个博主的帖子写的不错，Android上使用retrofit+okhttp时token失效的处理方案，帖子地址如下：

http://www.jianshu.com/p/62ab11ddacc8

但是网上内容我也转载一下，原作者镜花水月一梦不觉 博主若有问题请在下面留言哈

第一种方案

通过okhttp提供的Authenticator接口，相关资料点击这里 ，但是查看okhttp的源码会发现，只有返回HTTP的状态码为401时，才会使用Authenticator接口，如果服务端设计规范，可以尝试如下方法。

实现Authenticator接口

public class TokenAuthenticator implements Authenticator {

    @Override
    public Request authenticate(Proxy proxy, Response response) throws IOException {

        //取出本地的refreshToken
        String refreshToken = "sssgr122222222";

        // 通过一个特定的接口获取新的token，此处要用到同步的retrofit请求
        ApiService service = ServiceManager.getService(ApiService.class);
        Call call = service.refreshToken(refreshToken);

        //要用retrofit的同步方式
        String newToken = call.execute().body();

        return response.request().newBuilder()
                .header("token", newToken)
                .build();
    }

    @Override
    public Request authenticateProxy(Proxy proxy, Response response) throws IOException {
        return null;
    }
}

然后给添加给OkHttpClient

OkHttpClient client = new OkHttpClient();
client.setAuthenticator(new TokenAuthenticator());
Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(BASEURL)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .client(client)
                .build();

第一种方案就这样了。

但是，万事不会尽如人意，如果服务端在token过期的时候，不给返回401的HTTP状态码，而是返回如下类型的数据，叫你根据code判断。

{
    "data":"[{"userId":"6b2bb89b68ef4b10988a7c3d089c70cf","userName":"leo","age":"20"},
             {"userId":"a46c3b3b847743649f201e232b5a544d","userName":"李四","age":"30"}]",
    "success":true,
    "msg":"message success"
    "code":401
}

这里要清楚HTTP状态码是指200，404，401这些，而上面的数据中的code是自定义的。如果在token过期时，服务端返回的是如上类型的数据，那么第一种方案就行不通。

第二种方案

通过okhttp的拦截器，okhttp 2.2.0 以后提供了拦截器的功能，相关介绍点击这里

public class TokenInterceptor implements Interceptor {

    private static final Charset UTF8 = Charset.forName("UTF-8");

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

        // try the request
        Response originalResponse = chain.proceed(request);

        /**通过如下的办法曲线取到请求完成的数据
         *
         * 原本想通过  originalResponse.body().string()
         * 去取到请求完成的数据,但是一直报错,不知道是okhttp的bug还是操作不当
         *
         * 然后去看了okhttp的源码,找到了这个曲线方法,取到请求完成的数据后,根据特定的判断条件去判断token过期
         */
        ResponseBody responseBody = originalResponse.body();
        BufferedSource source = responseBody.source();
        source.request(Long.MAX_VALUE); // Buffer the entire body.
        Buffer buffer = source.buffer();
        Charset charset = UTF8;
        MediaType contentType = responseBody.contentType();
        if (contentType != null) {
            charset = contentType.charset(UTF8);
        }

        String bodyString = buffer.clone().readString(charset);

        LogUtil.debug("body---------->" + bodyString);

        /***************************************/

        if (response shows expired token){//根据和服务端的约定判断token过期

            //取出本地的refreshToken
            String refreshToken = "sssgr122222222";

            // 通过一个特定的接口获取新的token，此处要用到同步的retrofit请求
            ApiService service = ServiceManager.getService(ApiService.class);
            Call call = service.refreshToken(refreshToken);

            //要用retrofit的同步方式
            String newToken = call.execute().body();


            // create a new request and modify it accordingly using the new token
            Request newRequest = request.newBuilder().header("token", newToken)
                    .build();

            // retry the request

            originalResponse.body().close();
            return chain.proceed(newRequest);
        }

        // otherwise just pass the original response on
        return originalResponse;
    }
}

然后给okhttp设置拦截器

OkHttpClient client = new OkHttpClient();
client.interceptors().add(new TokenInterceptor());
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl(BASEURL)
        .addConverterFactory(GsonConverterFactory.create(gson))
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .client(getOkHttpClient())
        .build();

第二种方案的思路是通过拦截返回的数据，判断token是否过期，如果过期则进行一次刷新token的操作。

上面2种方案都没有进行实际验证过，希望以后有机会能验证。