OkHttp3源码解读一：接口请求层

##1、基本介绍：

• 接口层：接收用户的网络访问请求（同步请求/异步请求），发起实际的网络访问，接受服务器返回的结果。

##2、重要类：
####2.1、OkHttpClient：

• OkHttp框架的客户端，更确切的说是一个用户面板，用户使用OkHttp进行各种设置，发起各种网络请求都是通过OkHttpClient完成的。
• 每个OkHttpClient内部都维护了属于自己的任务队列Dispatcher，连接池ConnectionPool，缓存Cache，拦截器Interceptor等。
• 在使用OkHttp作为网络框架时应该全局共享一个OkHttpClient实例。

####2.2、Call：【每一个请求实例接口】

Call call  = okHttpClient.newCall(request);

• Call本身只是一个接口，描述一个实际的HTTP访问请求，用户的每一个HTTP请求都是一个Call实例。
• 每一个Call就是一个线程。
• Call包含了怎么生成Request对象request()、execute（）、enqueue（）方法。

####2.3、RealCall：

• 具体的Call接口实现类，代表每一个HTTP请求。
• 每一个RealCall内部有一个AsyncCall final类。

####2.4、AsyncCall ：

• RealCall类的内部final类，实现了NamedRunnable类的execute()。
• 继承于NamedRunnable类，NamedRunnable类实现了Runnable接口，并且有一个execute()抽象方法，这个抽象方法在Runnable的run()里执行。

####2.5、Dispatcher：【管理Call的任务队列】

• OkHttp的任务队列，其内部维护了一个线程池，进行线程分发，实现非阻塞，高可用，高并发。
• 当有接收到一个Call时，Dispatcher负责在线程池中找到空闲的线程并执行其execute方法。
• Okhttp采用Deque作为缓存队列，按照入队的顺序先进先出。
• OkHttp最出彩的地方就是在try/finally中调用了finished函数，可以主动控制等待队列的移动，而不是采用锁或者wait/notify，极大减少了编码复杂性。

##3、重要流程：
####3.1、okHttpClient.newCall(request)：

# OkHttpClient.java 

Call call  = okHttpClient.newCall(request)；

//okHttpClient.newCall(request)会为每一个请求创建一个RealCall类实例。

####3.2、RealCall.execute（）：

# RealCall.java
	  @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);
	    }
	  }

//1、调用Dispatcher类的executed()：将对应任务加入分发器Dispatcher，执行任务。
//2、构建拦截器链，调用拦截器链的proceed()：返回请求结果。
//3、调用Dispatcher类的finished()：执行完成后通知dispatcher对应任务已完成，对应任务出队。

####3.2、RealCall.enqueue（）：

# RealCall.java   
	@Override 
	public void enqueue(Callback responseCallback) {
	    synchronized (this) {
	      if (executed) throw new IllegalStateException("Already Executed");
	      executed = true;
	    }
	    captureCallStackTrace();
	    client.dispatcher().enqueue(new AsyncCall(responseCallback));
	  }
	
//构建AsyncCall类实例并执行Dispatcher的enqueue()：最终RealCall被转化成一个AsyncCall并被放入到任务队列Dispatcher中，启动Dispatcher中的线程池，等待合适的时机会执行AsyncCall的execute()。
	        

 #  RealCall#AsyncCall.java
	@Override 
	protected void execute() {
	      boolean signalledCallback = false;
	      try {
	            //执行耗时IO任务
	        Response response = getResponseWithInterceptorChain();
	        if (retryAndFollowUpInterceptor.isCanceled()) {
	          signalledCallback = true;
	              //回调，注意这里回调是在线程池中，而不是想当然的主线程回调.
	          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
	        } else {
	          signalledCallback = true;
	              //回调，同上
	          responseCallback.onResponse(RealCall.this, response);
	        }
	      } catch (IOException e) {
	        if (signalledCallback) {
	          // Do not signal the callback twice!
	          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
	        } else {
	          responseCallback.onFailure(RealCall.this, e);
	        }
	      } finally {
	        client.dispatcher().finished(this);
	      }
	    }
	  }
//1、调用getResponseWithInterceptorChain()：构建了一个拦截器链，通过依次执行该拦截器链中的每一个拦截器最终得到服务器返回。
//2、通知任务分发器(client.dispatcher)该任务已结束。
	        

####3.3、getResponseWithInterceptorChain()：【构建拦截器链】

# RealCall.java 
	Response getResponseWithInterceptorChain() throws IOException {
	    // Build a full stack of interceptors.
	    List<Interceptor> interceptors = new ArrayList<>();
	    interceptors.addAll(client.interceptors());
	    interceptors.add(retryAndFollowUpInterceptor);
	    interceptors.add(new BridgeInterceptor(client.cookieJar()));
	    interceptors.add(new CacheInterceptor(client.internalCache()));
	    interceptors.add(new ConnectInterceptor(client));
	    if (!forWebSocket) {
	      interceptors.addAll(client.networkInterceptors());
	    }
	    interceptors.add(new CallServerInterceptor(forWebSocket));
	
	    Interceptor.Chain chain = new RealInterceptorChain(
	        interceptors, null, null, null, 0, originalRequest);
	    return chain.proceed(originalRequest);
	  }
	
//1、创建一系列拦截器，并将其放入一个拦截器数组中。这部分拦截器即包括用户自定义的拦截器也包括框架内部拦截器。
//2、创建一个拦截器链RealInterceptorChain,并执行拦截器链的proceed方法。

####3.4、RealInterceptorChain#proceed（）：【调用下一个拦截器】

# RealInterceptorChain.java
	 public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
	      RealConnection connection) throws IOException {
	    ......
	    // Call the next interceptor in the chain.
	    RealInterceptorChain next = new RealInterceptorChain(
	        interceptors, streamAllocation, httpCodec, connection, index + 1, request);
	    Interceptor interceptor = interceptors.get(index);
	    Response response = interceptor.intercept(next);
	    
	    ...... 
	
	    return response;
	  }
//1、创建下一个拦截链。传入index + 1使得下一个拦截器链只能从下一个拦截器开始访问。
//2、执行索引为index的拦截器的intercept方法，并将下一个拦截器链传入该intercept方法。