Okhttp的源码解读

Posted 2023-02-14 风雨田

重要的类

类名	描述
OkHttpClient	OkHttp请求客户端，Builder模式实现
Dispatcher	本质是异步请求的调度器，负责调度异步请求的执行，控制最大请求并发数和单个主机的最大并发数，并持有有一个线程池负责执行异步请求，对同步请求只是作统计操作。
Request	封装网络请求，就是构建请求参数（如url，header,请求方式，请求参数），Builder模式实现
Response	网络请求对应的响应，Builder模式实现，真正的Response是通过RealCall.getResponseWithInterceptorChain()方法获取的。
Call	是根据Request生成的一个具体的请求实例，且一个Call只能被执行一次。
ConnectionPool	连接池
Interceptor	Interceptor可以说是OkHttp的核心功能，它就是通过Interceptor来完成监控管理，重写和重试请求的。
Cache	可以自定义是否采用缓存，缓存形式是磁盘缓存，DiskLruCache。

源码思想

OkHttp3，网络请求库，同步请求RealCall.execute()和异步请求RealCall.enqueue(),请求任务都是交给Dispatcher调度请求任务的处理，请求通过一条拦截链，每一个拦截器处理一部分工作，最后一个拦截器，完成获取请求任务的响应，会将响应沿着拦截链向上传递。

源码流程

初始化一个OkHttpClient对象

OkHttpClient mOkHttpClient = new OkHttpClient();  

public OkHttpClient()   
    this(new Builder());  
  

Builder是OkHttpClient的一个内部类，目的是构造和封装数据

public Builder()   
     dispatcher = new Dispatcher();  
     protocols = DEFAULT_PROTOCOLS;  
     connectionSpecs = DEFAULT_CONNECTION_SPECS;  
     proxySelector = ProxySelector.getDefault();  
     cookieJar = CookieJar.NO_COOKIES;  
     socketFactory = SocketFactory.getDefault();  
     hostnameVerifier = OkHostnameVerifier.INSTANCE;  
     certificatePinner = CertificatePinner.DEFAULT;  
     proxyAuthenticator = Authenticator.NONE;  
     authenticator = Authenticator.NONE;  
     connectionPool = new ConnectionPool();  
     dns = Dns.SYSTEM;  
     followSslRedirects = true;  
     followRedirects = true;  
     retryOnConnectionFailure = true;  
     connectTimeout = 10_000;  
     readTimeout = 10_000;  
     writeTimeout = 10_000;  

创建一个请求

Request类是HTTP请求，它携带了请求地址、请求方法、请求头部、请求体以及其他信息。它也是通过Builder模式创建的。

  Request request = new Request.Builder()  
      .url(url)  
      .build(); 

public Request build()   
  if (url == null) throw new IllegalStateException("url == null");  
  return new Request(this);  
  

private Request(Builder builder)   
    this.url = builder.url;  
    this.method = builder.method;  
    this.headers = builder.headers.build();  
    this.body = builder.body;  
    this.tag = builder.tag != null ? builder.tag : this;  
  

接下来对应的就是请求，请求分为异步与同步，先看同步

Response  response = mOkHttpClient.newCall(request).execute();

Response是HTTP响应，它继承自Closeable（Closeable继承自AutoCloseable，AutoCloseable资源自动关闭的接口），它携带了请求、网络请求协议、返回状态码、请求头、响应体等等，其中，网络请求协议是Protocol，Protocol是一个枚举类型，包含4中类型

public enum Protocol   
    HTTP_1_0("http/1.0"),  
    HTTP_1_1("http/1.1"),  
    SPDY_3("spdy/3.1"),  
    HTTP_2("h2");  
  

Call类是一个抽象类

OkHttpClient.newCall(request);  

@Override   
public Call newCall(Request request)   
    return new RealCall(this, request);  //RealCall extends Call


protected RealCall(OkHttpClient client, Request originalRequest)   
  this.client = client;  
  this.originalRequest = originalRequest;  
  this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client);  
 

public interface Call   
    Request request();  
    Response execute() throws IOException;  
    void enqueue(Callback responseCallback);  
    void cancel();  
    boolean isExecuted();  
    boolean isCanceled();  
    interface Factory   
        Call newCall(Request request);  
      
  

OKHttp提供了execute()方法（同步方法）和enqueue()方法（异步方法），下面我们先看看execute()方法（同步方法）

execute()方法，首先判断是否已执行过，如果已经执行过，则抛出异常信息，也就是说一次Call实例只能调用一次execute()方法。没有执行则通过分发器进行执行

@Override 
public Response execute() throws IOException   
synchronized (this)   
    if (executed) throw new IllegalStateException("Already Executed");  
    executed = true;  
  
try   
    client.dispatcher().executed(this);  
    Response result = getResponseWithInterceptorChain();  
    if (result == null) throw new IOException("Canceled");  
    return result;  
 finally   
    client.dispatcher().finished(this);  
 

分发器将请求加入到队列

 ...  
 private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();//双端队列  
 ...  
     /** Used by @code Call#execute to signal it is in-flight. */  
synchronized void executed(RealCall call)   
  runningSyncCalls.add(call);  
  

最后通过分发器的finished()方法结束请求

void finished(RealCall call)   
    finished(runningSyncCalls, call, false);  
  

private <T> void finished(Deque<T> calls, T call, boolean promoteCalls)   
    int runningCallsCount;  
    Runnable idleCallback;  
    synchronized (this)   
        if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");  
        if (promoteCalls) promoteCalls();  
        runningCallsCount = runningCallsCount();  
        idleCallback = this.idleCallback;  
      
    if (runningCallsCount == 0 && idleCallback != null)   
        idleCallback.run();  
      
 

所以通过上面信息可知真正发送请求的地方是getResponseWithInterceptorChain()方法

真正发送请求源码分析

组装各种拦截器，然后发送请求

private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOException 
    Interceptor.Chain chain = new ApplicationInterceptorChain(0, originalRequest, forWebSocket);
    return chain.proceed(originalRequest);

拦截器接口

public interface Interceptor 
    Response intercept(Chain chain) throws IOException;
    interface Chain 
        Request request();
        Response proceed(Request request) throws IOException;
        Connection connection();
    

在这个责任链模式中执行每一个连接器的proceed方法，然后我们逐个分析这些连接器

这里是责任链模式，由用户主动调用此方法，因此需要实现拦截的功能

这里如果有Intercepter实现已经添加，则为每一个拦截器创建一个ApplicationInterceptorChain然后递归直到将所有的链调用完成最后进入getResponse方法中。

@Override public Response proceed(Request request) throws IOException 
  //If there's another interceptor in the chain, call that.
  if (index < client.interceptors().size()) 
  //新建一个环节，并且将索引＋1，这里的request可能不再是originalRequest了，因为在拦截器中可能被修改了
    Interceptor.Chain chain = new ApplicationInterceptorChain(index + 1, request, forWebSocket);
    //获取到对应的拦截器
    Interceptor interceptor = client.interceptors().get(index);
    //执行拦截器的intercept方法，参数是上面新建的环节，这个方法里面会调用chain.proceed()，递归了。
    //在最深的一层调用getResponse之后，响应会一层层的往外传
    Response interceptedResponse = interceptor.intercept(chain);

    if (interceptedResponse == null) 
      throw new NullPointerException("application interceptor " + interceptor
          + " returned null");
    
 // 返回这一层拦截器处理用的响应
    return interceptedResponse;
  

  //递归到了最深的一层，拦截器都进入过了，发送httpRequest，获取到response.
  return getResponse(request, forWebSocket);

当执行完getResponse完成之后就一步步返回。

真正请求数据的方法

1. request.newBuilder();由于是之前的请求，所以内部调用newBuilder的时候使用老请求的url，method，body，tag，headers。然后给这个requestBuilder中添加各种请求的键值对信息最后构造一个原信息+新信息的新请求。
2. 创建一个请求引擎，每一个请求引擎代表依次请求/响应
3. 在死循环中做的事情
   
   1. 如果请求被取消抛出异常
   2. 然后发送请求，读取响应，重新连接设置成false
   3. 如果请求失败则算了不请求了，但是如果是路由异常则需要恢复请求。
   4. 最后释放链接，得到响应。
   5. 如果存在下一步请求，则重定向。

  Response getResponse(Request request, boolean forWebSocket) throws IOException 
    // 复制请求头，并设置适合的属性。如果长度不为－1，则设置Content-Length，否则使用chunked方式传输。
    // 如果对chunked不熟悉，请参考其他资料
    RequestBody body = request.body();
    if (body != null) 
      // 根据传进来的request创建新的Builder.
      Request.Builder requestBuilder = request.newBuilder();

      // 设置Content-Type
      MediaType contentType = body.contentType();
      if (contentType != null) 
        requestBuilder.header("Content-Type", contentType.toString());
      

      // 判断使用何种方式传输
      long contentLength = body.contentLength();
      // body长度不为－1,设置Content-Length
      if (contentLength != -1) 
        requestBuilder.header("Content-Length", Long.toString(contentLength));
        requestBuilder.removeHeader("Transfer-Encoding");
       else 
        //  body 长度为 -1 ,使用chunked传输
        requestBuilder.header("Transfer-Encoding", "chunked");
        requestBuilder.removeHeader("Content-Length");
      

      //创建新请求
      request = requestBuilder.build();
    

    // 创建一个新的引擎，每个引擎代表一次请求／响应对
    engine = new HttpEngine(client, request, false, false, forWebSocket, null, null, null);

    int followUpCount = 0; //重试次数
    //死循环 出口：
    // 1. 请求被取消
    // 2. 请求有问题
    // 3. 捕获到异常，且尝试恢复失败
    // 4. 获取到响应，且无需重定向
    // 5. 重定向次数超过最大限制
    while (true) 
      // 被取消的情况
      if (canceled) 
        engine.releaseStreamAllocation();
        throw new IOException("Canceled");
      

      boolean releaseConnection = true;
      try 
        // 发送请求
        engine.sendRequest();
        // 读取响应
        engine.readResponse();
        releaseConnection = false;
       catch (RequestException e) 
        // 请求失败，请求本身有问题，或者是网络不通
        throw e.getCause();
       catch (RouteException e) 
        // 连接到服务器的路由发生异常，请求还没被发送
        // 通过上一次连接异常恢复引擎
        HttpEngine retryEngine = engine.recover(e.getLastConnectException(), null);
        // 如果恢复成功，将当前的引擎设置为这个恢复好的引擎
        if (retryEngine != null) 
          releaseConnection = false;
          engine = retryEngine;
          continue;
        
        // 没法恢复，抛出异常
        throw e.getLastConnectException();
       catch (IOException e) 
        // 与服务器交互失败，这时，请求可能已经被发送
        // 恢复引擎
        HttpEngine retryEngine = engine.recover(e, null);
        //如果恢复成功，将当前的引擎设置为这个恢复好的引擎
        if (retryEngine != null) 
          releaseConnection = false;
          engine = retryEngine;
          continue;
        

        // 没法恢复，抛出异常
        throw e;
       finally 
        // 如果需要释放连接，则将连接释放
        if (releaseConnection) 
          StreamAllocation streamAllocation = engine.close();
          streamAllocation.release();
        
      

      // 获取响应
      Response response = engine.getResponse();
      // 下一步的请求，如果存在，则需要重定向
      Request followUp = engine.followUpRequest();

      //如果不需要重定向
      if (followUp == null) 
        if (!forWebSocket) 
          // 释放连接
          engine.releaseStreamAllocation();
        
        //返回响应
        return response;
      

      // 如果需要重定向，关闭当前引擎
      StreamAllocation streamAllocation = engine.close();

      // 如果超过最大数，释放连接，并抛出异常
      if (++followUpCount > MAX_FOLLOW_UPS) 
        // 释放连接
        streamAllocation.release();
        // 抛出异常
        throw new ProtocolException("Too many follow-up requests: " + followUpCount);
      

      // 如果重定向的地址和当前的地址一样，则不需要释放连接
      if (!engine.sameConnection(followUp.url())) 
        streamAllocation.release();
        streamAllocation = null;
      

      // 使用重定向后的请求，重新实例一个引擎，开始下一次循环
      request = followUp;
      engine = new HttpEngine(client, request, false, false, forWebSocket, streamAllocation, null,
          response);
    
  

最后HttpEngine进行的操作与http协议很大相关，作者对此不感兴趣，本文只是对流程做大概分析

哥哥若是喜欢可移驾公众号：码老板