请求加密，响应数据解密，过期自动刷新并且重新请求接口

此博客是参考http://blog.csdn.net/jdsjlzx/article/details/52442113
并且增加加密和解密的操作

1.先熟悉一下retrofit2.0+中的gson转换器

最开始的来看看主要的代码

转换器是在converter包里面
在GsonConverterFactory类里面

  @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 BaseResponse.class;
            }
        };
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(newType));
        if (String.class.equals(type)) {
            //响应如果是加密数据
            return new StringConverterFactory<>(adapter);
        }else{
            //响应是json对象
            return new GsonResponseBodyConverter<>(gson, adapter);
        }
    }

对应的加密数据，我统一在响应解析器里面做处理

public class StringConverterFactory<T> implements Converter<ResponseBody, Object> {
    private final TypeAdapter<T> adapter;

    StringConverterFactory(TypeAdapter<T> adapter) {
        this.adapter = adapter;
    }

    @Override
    public Object convert(ResponseBody value) throws IOException {
        try {
            String aseKey= UserCache.getAesSecretKey();
            LogUtils.d("解密秘钥aseKey = " + aseKey);
            String data = null;
            try {
                data = AES.dencrypt(value.string(), aseKey);
                LogUtils.e("返回数据："+data);
                BaseResponse baseResponse = new Gson().fromJson(data, BaseResponse.class);
                if(!StringUtils.isEmpty(baseResponse.getNewAesKey())){
                    //保证AESkey在缓存中
                    LogUtils.i("获得新的key====="+baseResponse.getNewAesKey());
                    //缓存中获取秘钥
                    UserCache.saveAesSecretKey(baseResponse.getNewAesKey());
                }
                if (baseResponse.isSuccess()) {
                    //保存Token
                    if(!StringUtils.isEmpty(baseResponse.getToken())){
                        LogUtils.i("保存token====="+baseResponse.getToken());
                        UserCache.saveToken(baseResponse.getToken());
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            BaseResponse apiModel = (BaseResponse) adapter.fromJson(data);
            if (apiModel.getErrCode() == ErrorCode.TOKEN_NOT_EXIST) {
                throw new TokenNotExistException();
            } else if (apiModel.getErrCode() == ErrorCode.TOKEN_INVALID) {
                //token失效保存原先的key
                UserCache.saveFirstAesSecretKey(aseKey);
                throw new TokenInvalidException();
            } else if (!apiModel.isSuccess()) {
                return null;
            } else if (apiModel.isSuccess()) {
                return apiModel.data;
            }else{
                BaseResponse baseResponse = new Gson().fromJson(value.string(), BaseResponse.class);
                return baseResponse;
            }
        } finally {
            value.close();
        }
    }
}

这里面做了解密操作，每次请求都会查看是否有新的key以及token，如果存在就进行缓存操作，还有就是对返回码做了一定的处理，后天返回10000代表token失效，直接向上面抛异常TokenInvalidException()

2.动态代理InvocationHandler方法，最关键的类

重试机制使用的是Rxjava中的retryWhen操作符

public class ProxyHandler implements InvocationHandler {
    private final static String JSON = "json";
    private Throwable mRefreshTokenError = null;
    //是否需要刷新token
    private boolean mIsTokenNeedRefresh;

    private Object mProxyObject;
    private String encrypt;

    public ProxyHandler(Object proxyObject) {
        mProxyObject = proxyObject;
    }

    @Override
    public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
        return Observable.just(null).flatMap(new Func1<Object, Observable<?>>() {
            @Override
            public Observable<?> call(Object o) {
                try {
                    try {
                        if (mIsTokenNeedRefresh) {
                            //刷新token请求
                            updateMethodToken(method, args);
                        }
                        //首次请求
                        return (Observable<?>) method.invoke(mProxyObject, args);
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }).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) {
                            //token过期
                            return refreshTokenWhenTokenInvalid();
                        } else if (throwable instanceof TokenNotExistException) {
                            //token不存在，目前没做处理
                            return Observable.error(throwable);
                        }
                        //其他异常
                        return Observable.error(throwable);
                    }
                });
            }
        });
    }

    /**
     * 请求token数据
     * @return Observable
     */
    private Observable<?> refreshTokenWhenTokenInvalid() {
        synchronized (ProxyHandler.class) {
                UserApi.updateToken(AppContext.getContext(), "1", new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                    }

                    @Override
                    public void onError(Throwable e) {
                        mRefreshTokenError = e;
                    }

                    @Override
                    public void onNext(String s) {
                        //设置标志位为true
                        mIsTokenNeedRefresh = true;
                    }
                });
                if (mRefreshTokenError != null) {
                    //直接抛异常
                    return Observable.error(mRefreshTokenError);
                } else {
                    //无异常，重新请求上一个请求
                    return Observable.just(true);
                }
        }
    }

    /**
     * 更新token，并且做了加密解密操作
     */
    private void updateMethodToken(Method method, Object[] args) {
        if (mIsTokenNeedRefresh && !TextUtils.isEmpty(UserCache.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) {
                            String json = ((Query) annotation).value();
                            if (JSON.equals(json)) {
                                //替换新的token
                                LogUtils.d("替换新的token+++json="+args[i].toString());
                                //1.先解密数据 缓存中获取秘钥
                                String firstAesKey = UserCache.getFirstAesSecretKey();
                                try {
                                    LogUtils.d("第二次请求中解密使用首次请求的秘钥aseKey = " + firstAesKey);
                                    String response= AES.dencrypt(args[i].toString(), firstAesKey);
                                    LogUtils.e("旧的json="+response);
                                    BaseRequest baseResponse = new Gson().fromJson(response, BaseRequest.class);
                                    baseResponse.setToken(UserCache.getToken());
                                    String newJson = new Gson().toJson(baseResponse);
                                    String aseKey= UserCache.getAesSecretKey();
                                    LogUtils.d("加密的秘钥aseKey = " + aseKey);
                                    UserCache.saveFirstAesSecretKey(aseKey);
                                    LogUtils.e("newJson="+newJson);
                                    encrypt = AES.encrypt(newJson, aseKey);
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                                args[i] = encrypt;
                            }
                        }
                    }
                }
            }
            mIsTokenNeedRefresh = false;
        }
    }
}

注释写的很详细了
整个请求逻辑是这样的(每次请求都会有加密和解密操作)
1. 首次请求中，正常的请求，返回数据解密后发现token过期，抛出TokenInvalidException；
2. 拦截token过期异常，同步请求获取新的token，在响应转换器里面做了token和key值的保存，最后返回一个just(true)，并把标志位设置为true,重试请求原先的Observable；
3. 判断标志位，更新token，在updateMethodToken()方法中，使用第一次的加密key,解密参数，然后做token数据的更新，使用的新的可以进行加密，再次发送请求；