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

此博客是参考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数据的更新，使用的新的可以进行加密，再次发送请求；