Okhttp拦截器Interceptor学习和使用

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  Response response = client.newCall(request).execute();
  return response.body().string();
}

public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory {
    /***部分代码省略***/
	/**
     * Prepares the {@code request} to be executed at some point in the future.
     */
    @Override 
    public Call newCall(Request request) {
    	return new RealCall(this, request, false /* for web socket */);
  	}
}

final class RealCall implements Call {
	final RetryAndFollowUpInterceptor retryAndFollowUpInterceptor;
	RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
	    final EventListener.Factory eventListenerFactory = client.eventListenerFactory();
	    this.client = client;
	    this.originalRequest = originalRequest;
	    this.forWebSocket = forWebSocket;
	    this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
	    // TODO(jwilson): this is unsafe publication and not threadsafe.
	    this.eventListener = eventListenerFactory.create(this);
	}
	@Override 
	public Response execute() throws IOException {
	    synchronized (this) {
	    	if (executed) throw new IllegalStateException("Already Executed");
	      	executed = true;
	    }
	    captureCallStackTrace();
	    try {
	        //进行网络请求
	      	client.dispatcher().executed(this);
	      	//经过一层层网络拦截器之后，获取网络请求的返回值
	      	Response result = getResponseWithInterceptorChain();
	      	if (result == null) throw new IOException("Canceled");
	      	return result;
	    } finally {
	      	client.dispatcher().finished(this);
	    }
	  }
	  Response getResponseWithInterceptorChain() throws IOException {
	    // Build a full stack of interceptors.
	    List<Interceptor> interceptors = new ArrayList<>();
	    //Application拦截器
	    interceptors.addAll(client.interceptors());
	    //重定向和失败后重新请求拦截器
	    interceptors.add(retryAndFollowUpInterceptor);
	    //网桥拦截器，顾名思义client和Server之前的桥梁
	    interceptors.add(new BridgeInterceptor(client.cookieJar()));
	    //缓存处理拦截器
	    interceptors.add(new CacheInterceptor(client.internalCache()));
	    //Socket层的握手链接
	    interceptors.add(new ConnectInterceptor(client));
	    if (!forWebSocket) {
	    	//网络烂拦截器
	    	interceptors.addAll(client.networkInterceptors());
	    }
	    //client和Server之前的读写操作
	    interceptors.add(new CallServerInterceptor(forWebSocket));
		//责任链开始执行
	    Interceptor.Chain chain = new RealInterceptorChain(
	        interceptors, null, null, null, 0, originalRequest);
	    return chain.proceed(originalRequest);
	  }
}

public interface Interceptor {
	//拦截处理
	Response intercept(Chain chain) throws IOException;
	interface Chain {
		//获取请求的request
	  	Request request();
		//处理request获取response
	    Response proceed(Request request) throws IOException;
	
	    /**
	     * Returns the connection the request will be executed on. This is only available in the chains
	     * of network interceptors; for application interceptors this is always null.
	     */
	    @Nullable Connection connection();
	}
}

HttpUrl httpurl = request.url();
//获取request中的原始url地址
String requestUrl = httpurl.url().toString();
/**
 * 获取url中的参数
 * @param httpUrl
 * @return
 */
private Map<String, String> getHttpUrlParams(HttpUrl httpUrl) {
    Set<String> paramsSet = httpUrl.queryParameterNames();
    Map<String, String> paramMap = new HashMap<>();
    if (paramsSet != null && paramsSet.size() > 0) {
        for (String s: paramsSet) {
            paramMap.put(s, httpUrl.queryParameter(s));
        }
    }
    return paramMap;
}
//一般POST请求参数都是放在RequestBody中,使用时需要判断RequestBody是否为子类FormBody的实例
RequestBody requestBody = request.body();
/**
 * 获取请求form中的参数
 * @param formBody
 * @return
 */
private Map<String, String> getHttpUrlParams(FormBody formBody) {
    Map<String, String> paramMap = new HashMap<>();
    if (formBody != null) {
        for (int i = 0; i < formBody.size(); i++) {
            paramMap.put(formBody.name(i), formBody.value(i));
        }
    }
    return paramMap;
}
//构造新的POST表单
FormBody.Builder formBuilder = new FormBody.Builder();
for (String key: map.keySet()) {
    formBuilder.add(key, map.get(key));
}
//构造新的HttpUrl，动态修改请求url地址
HttpUrl httpUrl = HttpUrl.parse(requestUrlTrue);
//构造新的request请求
request = request.newBuilder()
        .method(POST, formBuilder.build())
        .url(httpUrl)
        .build();
//获取相应体对应的请求体，请求和返回一一对应
Request request = response.request()
//获取请求的相应体
ResponseBody responseBody = response.body();
//获取返回值类型
MediaType mediaType = responseBody.contentType();
//获取相应体重的数据流，只能获取一次，在获取之后数据流会关闭，再次获取会有异常抛出
byte[] responseBytes = responseBytes = responseBody.bytes();
//利用修改后的返回值，构造新的相应体
response = response.newBuilder()
        .body(ResponseBody.create(mediaType, responseBytes))
        .build();