因为项目需要，需要对请求和响应进行二次处理，因此用到了okttp的拦截器，顺便记录一下
首先在retrofit中添加自定义拦截器
public static IRetrofitService getInstance() {
if (retrofit == null) {
synchronized (RetrofitManager.class) {
if (retrofit == null) {
retrofit = new Retrofit.Builder()
.baseUrl(baseUrl)
.addConverterFactory(ScalarsConverterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.client(TxokttpClient.create())
.build();
mRetrofitService = retrofit.create(IRetrofitService.class);
}
}
}
return mRetrofitService;
}
我们进入create中看一下
private static OkHttpClient.Builder txokttpClient = new TxokttpClient.Builder();
public static OkHttpClient create() {
txokttpClient.interceptors().add(new TxInterceptors());
return txokttpClient.build();
}
通过创建okhttpclient.Builder()，加入拦截器 TxInterceptors()，并创建出okHttpClient；
下面正式进入正题 intercept （），在okhttp中 intercept的设计是通过递归和chain相互调用的，如果有兴趣的可以去看看，这里不再多说。
static class TxInterceptors implements Interceptor {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
Response resp;
if (SignToken.isNeedSignPath(request)) {
Request newRequest = queryNewRequest(request);
showRequest(newRequest);
resp = chain.proceed(newRequest);
} else {
resp = chain.proceed(request);
return resp;
}
return checkToken(resp, chain);
}
}
首先我们拿到 请求对象 Request,我们的请求是需要对请求进行加密的，当然有的请求不是直接请求我们服务器的，所以就需要判断当前请求是否需要进行加密。
说句题外话，我们加密完之后的请求会变成四个请求参数，当时我有想过，将加密放在请求之前，后来想了想又感觉不好，首先做封装，那我们就要做的有点设计意义，别人在用的时候 当然也可以通过加密工具类将参数加密，然后将加密后的数据放入请求，也很简单，但是总感觉这一行代码有点多余，因为每次都要手写，能少一行代码就少一行，看着也不会很累赘，再一点就是偷懒并不适合去了解框架，如果你想去完完全全去了解一个框架，那就需要不断的去踩坑，原先跟朋友玩王者，说到了一句话，我的尸体遍布了整个峡谷，这句话很震撼，成功没有捷径，望诸君努力。
下面我们来看queryNewRequset()
queryNewRequest(Request request)
private Request queryNewRequest(Request request) {
String method = request.method();
if (method.equals("POST")) {
RequestBody requestBody = request.body();
RequestBody newRequestBody = null;
if (requestBody instanceof FormBody) {
newRequestBody = addParamsToFormBody((FormBody) requestBody);
Request newRequest = request.newBuilder()
.url(request.url())
.method(request.method(), newRequestBody)
.build();
return newRequest;
} else if (requestBody instanceof MultipartBody) {
return addParamsToMultipartBody((MultipartBody) requestBody, request);
} else {
return createRequestForGet(request);
}
} else {
return createRequestForGet(request);
}
}
这个方法的作用是 根据老的请求 创建一个新的加密之后的新的请求。
这里我们根据请求方式作了一个判断。
我们先来看post请求，拿到RequestBody，RequestBody有两个子类 FromBody和MultipartBody,普通的请求body和文件类的请求body，两者的处理是一样，取出其中的普通请求参数，然后进行加密，将加密后的数据重新放入其中，文件不需加密，代码也差不多
addParamsToFormBody(RequestBody requestBody):
Map<String, String> mParamsmap = new HashMap<>();
FormBody.Builder builder = new FormBody.Builder();
for (int i = 0; i < body.size(); i++) {
mParamsmap.put(body.encodedName(i), body.encodedValue(i));
}
SignToken signParams = new SignToken();
Map<String, String> newParamsMap = signParams.setSigen(mParamsmap);
String token = newParamsMap.get(SignToken.sToken);
builder.add(SignToken.sData, newParamsMap.get(SignToken.sData));
builder.add(SignToken.sSign, newParamsMap.get(SignToken.sSign));
builder.add(SignToken.sVersion, newParamsMap.get(SignToken.sVersion));
if (!TextUtils.isEmpty(token)) {
builder.add(SignToken.sToken, token);
}
return builder.build();
遍历取出其中的参数的key与value 然后进行加密，将加密的数据放入一个新的FormBody中并返回 ，然后就是将formBody重新封装成一个新的request，主要需要注意url 和 body
MultipartBody跟FormBody基本一样 ,如果说非要不一样，那就是内容不一样，MultipartBody里面含有文件，获取文件的方式也跟获取普通参数的方式也不一样，
MultipartBody
private Request addParamsToMultipartBody(MultipartBody body, Request request) {
MultipartBody.Builder builder = new MultipartBody.Builder();
builder.setType(MultipartBody.FORM);
Map<String, String> multipartParams = new HashMap<>();
HttpUrl httpUrl = HttpUrl.get(request.url().uri());
for (int index = 0; index < httpUrl.querySize(); index++) {
multipartParams.put(httpUrl.queryParameterName(index), httpUrl.queryParameterValue(index));
}
SignToken signParams = new SignToken();
Map<String, String> newParams = signParams.setSigen(multipartParams);
httpUrl = request.url().newBuilder()
.addQueryParameter(SignToken.sData, newParams.get(SignToken.sData))
.addQueryParameter(SignToken.sSign, newParams.get(SignToken.sSign))
.addQueryParameter(SignToken.sToken, newParams.get(SignToken.sToken))
.addQueryParameter(SignToken.sVersion, newParams.get(SignToken.sVersion))
.build();
//添加原请求体
for (int i = 0; i < body.size(); i++) {
builder.addPart(body.part(i));
}
return request.newBuilder().post(builder.build()).url(httpUrl).build();
// return builder.build();
}
}
唯一不一样的地方就就是在获取完普通请求以后，需要把原先的文件参数取出来放到新的MultipartBody中，然后重新组装成一个新的Request
post请求的最后一种特殊就是使用了@QueryMap，类似于get请求，将参数拼接到请求后面
createRequestForGet(Request request)
private static Request createRequestForGet(Request request) {
Request requestClone = request;
HttpUrl httpUrl = HttpUrl.get(requestClone.url().uri());
Map<String, String> requestParams = new HashMap<>();
for (int index = 0; index < httpUrl.querySize(); index++) {
if (!"file".equals(httpUrl.queryParameterValue(index))) {
requestParams.put(httpUrl.queryParameterName(index), httpUrl.queryParameterValue(index));
}
}
SignToken signParams = new SignToken();
HttpUrl mUrl = requestClone.url();
Map<String, String> newParams = signParams.setGetSign(requestParams);
Request newRequest = new Request.Builder()
.method(requestClone.method(), requestClone.body())
.url(mUrl.scheme() + "://" + mUrl.host() + mUrl.encodedPath()).build();
HttpUrl newHttpUrl = newRequest.url()
.newBuilder()
.addQueryParameter(SignToken.sData, newParams.get(SignToken.sData))
.addQueryParameter(SignToken.sSign, newParams.get(SignToken.sSign))
.addQueryParameter(SignToken.sToken, newParams.get(SignToken.sToken))
.addQueryParameter(SignToken.sVersion, newParams.get(SignToken.sVersion))
.build();
request = newRequest.newBuilder().url(newHttpUrl).build();
return request;
}
首先获取到HttpUrl 然后拿到里面的请求参数，加密，最后放入到新请求里面，
get请求同上，
最后
本篇纯看做一篇代码展示吧，好多地方都没说，也不想说了，
