Okhttp深入浅出

Okhttp分析

//同步
OkhttpClient.Builder().newCall(request).execute()
//异步
OkhttpClient.Builder().newCall(request).enqueue{
	onSuccess(...){}
	onFailed(...){}
}

newCall的时候创建了RealCall,同时传入了request的请求参数。

• 看异步方法：

     client.dispatcher().enqueue(new AsyncCall(responseCallback));
    1.到Dispatch中，判断当前正在请求数，同一host的最大请求数有没有超5。
    2.调用asyncCall的executeOn(executorService) ，把线程池带了过来
    3.executorService.execute(this);
    4.回调AsyncCall的execute()方法
    Response response = getResponseWithInterceptorChain();
    拦截器开始工作，返回的是response
  

getResponseWithInterceptorChain()

Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List<Interceptor> interceptors = new ArrayList<>();
1. 加入自定义的拦截器,主要用于为请求添加header之类的
interceptors.addAll(client.interceptors());
2. 重定向拦截器
interceptors.add(retryAndFollowUpInterceptor);
3. 添加请求信息拦截器，比如cookies
interceptors.add(new BridgeInterceptor(client.cookieJar()));
4. 缓存拦截器 
interceptors.add(new CacheInterceptor(client.internalCache()));
5. 连接拦截器
interceptors.add(new ConnectInterceptor(client));
if (!forWebSocket) {
6. 非webSocket，添加网络拦截器，自定义的，主要是响应返回之后的，自定义拦截
  interceptors.addAll(client.networkInterceptors());
}
7. 请求服务器拦截器
interceptors.add(new CallServerInterceptor(forWebSocket));
//拦截器的封装
Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
    originalRequest, this, eventListener, client.connectTimeoutMillis(),
    client.readTimeoutMillis(), client.writeTimeoutMillis());
//开始执行
Response response = chain.proceed(originalRequest);
if (retryAndFollowUpInterceptor.isCanceled()) {
  closeQuietly(response);
  throw new IOException("Canceled");
}
return response;}

RetryAndFollowUpInterceptor，重定向拦截器

@Override public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Call call = realChain.call();
//连接池的操作
StreamAllocation streamAllocation = new StreamAllocation(client.connectionPool(),
    createAddress(request.url()), call, eventListener, callStackTrace);
this.streamAllocation = streamAllocation;

int followUpCount = 0;
Response priorResponse = null;
//while的循环，循环搞事情，看来不简单
while (true) {
  if (canceled) {
    streamAllocation.release();
    throw new IOException("Canceled");
  }

  Response response;
  boolean releaseConnection = true;
  try {
	//调用下一个拦截器
    response = realChain.proceed(request, streamAllocation, null, null);
    releaseConnection = false;
  } 
 ...
  // Attach the prior response if it exists. Such responses never have a body.
  if (priorResponse != null) {
    response = response.newBuilder()
        .priorResponse(priorResponse.newBuilder()
                .body(null)
                .build())
        .build();
  }

  Request followUp;
  try {
	// 300-303 重定向操作，这个followUp已经在其中封装好了下次请求的请求头
	// 408 请求超时，也需要重新进行请求
    followUp = followUpRequest(response, streamAllocation.route());
  } catch (IOException e) {
    streamAllocation.release();
    throw e;
  }
 // 为空就不要请求了，不为空：重试或者重定向 即 再次请求 
  if (followUp == null) {
    streamAllocation.release();
    return response;
  }

  closeQuietly(response.body());
//请求次数是否达到了20次
  if (++followUpCount > MAX_FOLLOW_UPS) {
    streamAllocation.release();
    throw new ProtocolException("Too many follow-up requests: " + followUpCount);}
// 重新请求的request赋值
  request = followUp;
//当前返回的response赋值
  priorResponse = response;}}

BridgeInterceptor

@Override public Response intercept(Chain chain) throws IOException {
Request userRequest = chain.request();
Request.Builder requestBuilder = userRequest.newBuilder();
RequestBody body = userRequest.body();
//处理了以下首部：
// Content-Type
// Content-Length
// Transfer-Encoding
// Host
// Connection
//Accept-Encoding
if (body != null) {
  MediaType contentType = body.contentType();
  if (contentType != null) {
    requestBuilder.header("Content-Type", contentType.toString());
  }
  long contentLength = body.contentLength();
  if (contentLength != -1) {
    requestBuilder.header("Content-Length", Long.toString(contentLength));
    requestBuilder.removeHeader("Transfer-Encoding");
  } else {
    requestBuilder.header("Transfer-Encoding", "chunked");
    requestBuilder.removeHeader("Content-Length");
  }
}

if (userRequest.header("Host") == null) {
  requestBuilder.header("Host", hostHeader(userRequest.url(), false));
}

if (userRequest.header("Connection") == null) {
  requestBuilder.header("Connection", "Keep-Alive");
}

// If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
// the transfer stream.
boolean transparentGzip = false;
if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
  transparentGzip = true;
  requestBuilder.header("Accept-Encoding", "gzip");
}
//接口回调，根据当前url,返回需要的cookies
List<Cookie> cookies = cookieJar.loadForRequest(userRequest.url());
if (!cookies.isEmpty()) {
  requestBuilder.header("Cookie", cookieHeader(cookies));
}

if (userRequest.header("User-Agent") == null) {
  requestBuilder.header("User-Agent", Version.userAgent());
}
//调用下一个拦截器
Response networkResponse = chain.proceed(requestBuilder.build());
//检查响应是否包含了cookies,有的话接口回调，存储起来
HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());

Response.Builder responseBuilder = networkResponse.newBuilder()
    .request(userRequest);

if (transparentGzip
    && "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))
    && HttpHeaders.hasBody(networkResponse)) {
  GzipSource responseBody = new GzipSource(networkResponse.body().source());
  Headers strippedHeaders = networkResponse.headers().newBuilder()
      .removeAll("Content-Encoding")
      .removeAll("Content-Length")
      .build();
  responseBuilder.headers(strippedHeaders);
  String contentType = networkResponse.header("Content-Type");
  responseBuilder.body(new RealResponseBody(contentType, -1L, Okio.buffer(responseBody)));
}
return responseBuilder.build();}

CacheInterceptor

@Override public Response intercept(Chain chain) throws IOException {
//根据request获取缓存，默认是为空的
Response cacheCandidate = cache != null
    ? cache.get(chain.request())
    : null;

long now = System.currentTimeMillis();

CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
//默认netWorkRequest不为空，如果有缓存，并且缓存可以使用，那么netWorkRequest为空
Request networkRequest = strategy.networkRequest;
//默认为空				  如果有缓存，并且缓存可以使用，那么cacheResponse不为空
Response cacheResponse = strategy.cacheResponse;

if (cache != null) {
  cache.trackResponse(strategy);
}

if (cacheCandidate != null && cacheResponse == null) {
  closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
}

// If we're forbidden from using the network and the cache is insufficient, fail.
if (networkRequest == null && cacheResponse == null) {
  return new Response.Builder()
      .request(chain.request())
      .protocol(Protocol.HTTP_1_1)
      .code(504)
      .message("Unsatisfiable Request (only-if-cached)")
      .body(Util.EMPTY_RESPONSE)
      .sentRequestAtMillis(-1L)
      .receivedResponseAtMillis(System.currentTimeMillis())
      .build();
}

// If we don't need the network, we're done.
if (networkRequest == null) { //缓存可用，直接返回。
  return cacheResponse.newBuilder()
      .cacheResponse(stripBody(cacheResponse))
      .build();
}

Response networkResponse = null;
try {
//下一个拦截器
  networkResponse = chain.proceed(networkRequest);
} finally {
  // If we're crashing on I/O or otherwise, don't leak the cache body.
  if (networkResponse == null && cacheCandidate != null) {
    closeQuietly(cacheCandidate.body());
  }
}

// If we have a cache response too, then we're doing a conditional get.
if (cacheResponse != null) {
  if (networkResponse.code() == HTTP_NOT_MODIFIED) {
    Response response = cacheResponse.newBuilder()
        .headers(combine(cacheResponse.headers(), networkResponse.headers()))
        .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
        .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();
    networkResponse.body().close();

    // Update the cache after combining headers but before stripping the
    // Content-Encoding header (as performed by initContentStream()).
    cache.trackConditionalCacheHit();
    cache.update(cacheResponse, response);
    return response;
  } else {
    closeQuietly(cacheResponse.body());
  }
}

Response response = networkResponse.newBuilder()
    .cacheResponse(stripBody(cacheResponse))
    .networkResponse(stripBody(networkResponse))
    .build();

if (cache != null) {
  if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
    // Offer this request to the cache.
	//加入到cache中
    CacheRequest cacheRequest = cache.put(response);
    return cacheWritingResponse(cacheRequest, response);
  }

  if (HttpMethod.invalidatesCache(networkRequest.method())) {
    try {
      cache.remove(networkRequest);
    } catch (IOException ignored) {
      // The cache cannot be written.
    }
  }
}
return response;}

ConnectInterceptor

@Override public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Request request = realChain.request();
StreamAllocation streamAllocation = realChain.streamAllocation();

// We need the network to satisfy this request. Possibly for validating a conditional GET.
boolean doExtensiveHealthChecks = !request.method().equals("GET");
HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
RealConnection connection = streamAllocation.connection();
return realChain.proceed(request, streamAllocation, httpCodec, connection);}

从上面这个拦截器，见名知意，就要开始搞大事了。

在此之前，我们需要注意的是OkhttpClient在初始化的时候的两个点

1. 在Builder()构造函数中:

    //啥？连接池，是的，你没看错。
    connectionPool = new ConnectionPool();
    //果断杀入这个ConnectionPool，不过属性和方法，我就能知道你在干啥
    //线程池，虽然开的无限大，但是其实只创建了一个线程来搞事情
      private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,
          Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,
          new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp ConnectionPool", true));
    
      /** The maximum number of idle connections for each address. */
      private final int maxIdleConnections; // 5
      private final long keepAliveDurationNs; // 5分钟
    //这个线程池就只会执行这唯一一个runable,仔细看它的内容你会知道，在做一些超时清理问题
      private final Runnable cleanupRunnable = new Runnable() {
        @Override public void run() {
          while (true) {
            long waitNanos = cleanup(System.nanoTime());
            if (waitNanos == -1) return;
            if (waitNanos > 0) {
              long waitMillis = waitNanos / 1000000L;
              waitNanos -= (waitMillis * 1000000L);
              synchronized (ConnectionPool.this) {
                try {
                  ConnectionPool.this.wait(waitMillis, (int) waitNanos);
                } catch (InterruptedException ignored) {}}}}}};
    
    //双端队列用来存储RealConnection
      private final Deque<RealConnection> connections = new ArrayDeque<>();
    ##################################
    //根据host、路由来寻找已经存在的RealConnection. 注意这个方法的调用
      @Nullable RealConnection get(Address address, StreamAllocation streamAllocation, Route route) {
        assert (Thread.holdsLock(this));
        for (RealConnection connection : connections) {
          if (connection.isEligible(address, route)) {
    		//设置streamAllocation中的RealConnection 为这找到的这个
            streamAllocation.acquire(connection, true);
            return connection;
          }
        }
        return null;
      }		
   

2. OkhttpClient中还有另外一个需要注意的点：

    //所以一会儿，Internal.instance.get(...)你就需要到ConnectionPool中去查看
    //静态的初始化
    static {
    	//抽象类
        Internal.instance = new Internal() {
    	...
      @Override public RealConnection get(ConnectionPool pool, Address address,
          StreamAllocation streamAllocation, Route route) {
    //调用ConnectPool的get方法
        return pool.get(address, streamAllocation, route);
      }
      @Override public void put(ConnectionPool pool, RealConnection connection) {
    //调用ConnectPool的put方法
        pool.put(connection);
      }
    	...
   

继续回到ConnectInterceptor中

//不是get方法
boolean doExtensiveHealthChecks = !request.method().equals("GET");
//调用streamAllocation的newStream()
//返回的是一个HttpCodec,这个HttpCodec分为Http1Codec和Http2Codec，分别对应的是http1.XX和http2.xx
HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
RealConnection connection = streamAllocation.connection();

StreamAllocation.newStream()

//~~寻找健康的Connection
  RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
      writeTimeout, pingIntervalMillis, connectionRetryEnabled, doExtensiveHealthChecks);
  HttpCodec resultCodec = resultConnection.newCodec(client, chain, this);

//寻找健康的RealConnection
 private RealConnection findHealthyConnection(int connectTimeout, int readTimeout,
  int writeTimeout, int pingIntervalMillis, boolean connectionRetryEnabled,
  boolean doExtensiveHealthChecks) throws IOException {
  //while循环，你应该知道事情没那么简单
  while (true) {
  //candidate 候选人的意思
  RealConnection candidate = findConnection(connectTimeout, readTimeout, writeTimeout,
      pingIntervalMillis, connectionRetryEnabled);
  // If this is a brand new connection, we can skip the extensive health checks.
  synchronized (connectionPool) {
    if (candidate.successCount == 0 && !candidate.isMultiplexed()) {
      return candidate;
    }
  }
 //判断这个socket的输入流，输出流，socket是否close
  // isn't, take it out of the pool and start again.
  if (!candidate.isHealthy(doExtensiveHealthChecks)) {
	//已经挂了，做一些清理工作
    noNewStreams();
	//继续，这次就找不到缓存的了，只能新new一个RealConnection出来。
    continue;}
  return candidate;}}

findConnection()

private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout,
  int pingIntervalMillis, boolean connectionRetryEnabled) throws IOException {
boolean foundPooledConnection = false;
RealConnection result = null;
Route selectedRoute = null;
Connection releasedConnection;
Socket toClose;
synchronized (connectionPool) {
  ################
我们知道StreamAllocation是在RetryAndFllowUpInterceptor中创建的对象，
如果第一次请求超时，返回了408，那么将会重试，再次请求，下面这个connection就不会为空。
  releasedConnection = this.connection;
  toClose = releaseIfNoNewStreams();
  if (this.connection != null) {
    // We had an already-allocated connection and it's good.
    result = this.connection;
    releasedConnection = null;
  }
  if (!reportedAcquired) {
    // If the connection was never reported acquired, don't report it as released!
    releasedConnection = null;
  }
  if (result == null) {
	//去ConnectPool里面寻找一个匹配的RealConnection
	//通过上面的分析，我们知道下面这个get,实则是去ConnectionPool里面找，找到之后
	//通过传入的这个this(streamAllocation),把这个RealConnection传到当前类中
    Internal.instance.get(connectionPool, address, this, null);
	//上一步如果找到，那么connection在这已经不为空了
    if (connection != null) {
      foundPooledConnection = true;
      result = connection;
    } else {
      selectedRoute = route;
    }
  }
}
closeQuietly(toClose);

if (releasedConnection != null) {
  eventListener.connectionReleased(call, releasedConnection);
}
if (foundPooledConnection) {
  eventListener.connectionAcquired(call, result);
}
//如果已经找到了，那么就可以返回了
if (result != null) {
  // If we found an already-allocated or pooled connection, we're done.
  route = connection.route();
  return result;
}

// If we need a route selection, make one. This is a blocking operation.
boolean newRouteSelection = false;
if (selectedRoute == null && (routeSelection == null || !routeSelection.hasNext())) {
  newRouteSelection = true;
  routeSelection = routeSelector.next();
}

synchronized (connectionPool) {
  if (canceled) throw new IOException("Canceled");

  if (newRouteSelection) {
    // Now that we have a set of IP addresses, make another attempt at getting a connection from
    // the pool. This could match due to connection coalescing.
    List<Route> routes = routeSelection.getAll();
    for (int i = 0, size = routes.size(); i < size; i++) {
      Route route = routes.get(i);
      Internal.instance.get(connectionPool, address, this, route);
      if (connection != null) {
        foundPooledConnection = true;
        result = connection;
        this.route = route;
        break;
      }
    }
  }

  if (!foundPooledConnection) {
    if (selectedRoute == null) {
      selectedRoute = routeSelection.next();
    }

    // Create a connection and assign it to this allocation immediately. This makes it possible
    // for an asynchronous cancel() to interrupt the handshake we're about to do.
    route = selectedRoute;
    refusedStreamCount = 0;
	//找不到，直接new一个RealConnection
    result = new RealConnection(connectionPool, selectedRoute);
	//设置当前的connection为这new出来的这个RealConnection.
    acquire(result, false);
  }
}

// If we found a pooled connection on the 2nd time around, we're done.
if (foundPooledConnection) {
  eventListener.connectionAcquired(call, result);
  return result;
}
//下面的注释就知道进行了TCP，TLS握手
// Do TCP + TLS handshakes. This is a blocking operation.
//这行代码进行了Socket的链接，也就是三次握手，另外，也有两行很重要的代码
// ##################################################
//可以看到是通过Okio来进行的操作。 这些操作都是在RealConnection中进行的
// source = Okio.buffer(Okio.source(rawSocket)); 数入流
// sink = Okio.buffer(Okio.sink(rawSocket));     输出流
// ###################################################
result.connect(connectTimeout, readTimeout, writeTimeout, pingIntervalMillis,
    connectionRetryEnabled, call, eventListener);
routeDatabase().connected(result.route());

Socket socket = null;
synchronized (connectionPool) {
  reportedAcquired = true;
//将这个创建 出来的RealConnection加入到线程池中
  // Pool the connection.

  Internal.instance.put(connectionPool, result);
// 上面这行代码的具体实现是ConnectionPool的put方法 #######
//  void put(RealConnection connection) {
//    assert (Thread.holdsLock(this));
//    if (!cleanupRunning) { //ConnectionPool是的cleanupRunning默认是false
//      cleanupRunning = true; //只会执行一次
//      executor.execute(cleanupRunnable); // 用于超时的链接清理
//    }
//    connections.add(connection);
//  }										   #######
  // If another multiplexed connection to the same address was created concurrently, then
  // release this connection and acquire that one.
  if (result.isMultiplexed()) {
    socket = Internal.instance.deduplicate(connectionPool, address, this);
    result = connection;
  }
}
closeQuietly(socket);
eventListener.connectionAcquired(call, result);
//返回，结束
return result;}

最后一个拦截器：CallServerInterceptor

@Override public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
//HttpCodec包裹了在RealConnection中创建好socket之后拿到的source和sink，即输入输出流
HttpCodec httpCodec = realChain.httpStream();
StreamAllocation streamAllocation = realChain.streamAllocation();
RealConnection connection = (RealConnection) realChain.connection();
Request request = realChain.request();

long sentRequestMillis = System.currentTimeMillis();

realChain.eventListener().requestHeadersStart(realChain.call());
httpCodec.writeRequestHeaders(request);
realChain.eventListener().requestHeadersEnd(realChain.call(), request);

Response.Builder responseBuilder = null;
if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
  // If there's a "Expect: 100-continue" header on the request, wait for a "HTTP/1.1 100
  // Continue" response before transmitting the request body. If we don't get that, return
  // what we did get (such as a 4xx response) without ever transmitting the request body.
  if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {
    httpCodec.flushRequest();
    realChain.eventListener().responseHeadersStart(realChain.call());
    responseBuilder = httpCodec.readResponseHeaders(true);
  }

  if (responseBuilder == null) {
    // Write the request body if the "Expect: 100-continue" expectation was met.
    realChain.eventListener().requestBodyStart(realChain.call());
    long contentLength = request.body().contentLength();
	//创建请求body
    CountingSink requestBodyOut =
        new CountingSink(httpCodec.createRequestBody(request, contentLength));
    BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);

    request.body().writeTo(bufferedRequestBody);
    bufferedRequestBody.close();
    realChain.eventListener()
        .requestBodyEnd(realChain.call(), requestBodyOut.successfulCount);
  } else if (!connection.isMultiplexed()) {
    // If the "Expect: 100-continue" expectation wasn't met, prevent the HTTP/1 connection
    // from being reused. Otherwise we're still obligated to transmit the request body to
    // leave the connection in a consistent state.
    streamAllocation.noNewStreams();
  }
}
//调用 sink.flush();
httpCodec.finishRequest();

if (responseBuilder == null) {
  realChain.eventListener().responseHeadersStart(realChain.call());
//只是拿了响应头，后续判断响应是否正确
  responseBuilder = httpCodec.readResponseHeaders(false);
}

Response response = responseBuilder
    .request(request)
    .handshake(streamAllocation.connection().handshake())
    .sentRequestAtMillis(sentRequestMillis)
    .receivedResponseAtMillis(System.currentTimeMillis())
    .build();
//判断响应头是否正确
int code = response.code();
if (code == 100) {
  // server sent a 100-continue even though we did not request one.
  // try again to read the actual response
  responseBuilder = httpCodec.readResponseHeaders(false);

  response = responseBuilder
          .request(request)
          .handshake(streamAllocation.connection().handshake())
          .sentRequestAtMillis(sentRequestMillis)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build();

  code = response.code();
}

realChain.eventListener()
        .responseHeadersEnd(realChain.call(), response);

if (forWebSocket && code == 101) {
  // Connection is upgrading, but we need to ensure interceptors see a non-null response body.
  response = response.newBuilder()
      .body(Util.EMPTY_RESPONSE)
      .build();
} else {
//响应头无异常，调用httpCodec.openResponseBody(response)真正的读取响应体
  response = response.newBuilder()
      .body(httpCodec.openResponseBody(response))
      .build();
}

if ("close".equalsIgnoreCase(response.request().header("Connection"))
    || "close".equalsIgnoreCase(response.header("Connection"))) {
  streamAllocation.noNewStreams();
}

if ((code == 204 || code == 205) && response.body().contentLength() > 0) {
  throw new ProtocolException(
      "HTTP " + code + " had non-zero Content-Length: " + response.body().contentLength());
}
//请求结束，返回响应.
return response; }

---

至此Okhttp的分析就到此了。遇到的关键点：

1. RealCall --> call
2. AsyncCall --> Runable
3. Dispatcher --> 线程池调度器，维护着集合: readyAsyncCalls、 runningAsyncCalls、runningSyncCalls，正在运行的是否超过64？ 同一个url请求是否超过5个连接？
4. 拦截器： RetryAndFllowUpInterceptor、BridgeInterceptor、CacheInterceptor、ConnectInterceptor、CallServerInterceptor.
5. StreamAllocation --> 流管理，连接服务器,调度TCP连接的关键
6. ConnectionPool --> socket连接池，负责管理空闲的socket连接，超时？socket断开？进行清理工作，其内部包含了一个Deque ，队列用来存储已经连接的Socket,方便进行复用。
7. RealConnection --> 一个真正的socket的连接，获取sorce和sink,即输入输出流
8. HttpCodec 接口，实现为Http1Codec和Http2Codec分别为http1.XX和http2.xx的协议。HttpCodeC主要引用这Sorce和Sink，进行输入和输出流的操作，对服务器进行请求和响应的接收。

其实，分析这些主流的框架，会有一种直观的感受就是“层次分明”。各个部分是什么功能，细粒度的分解，组合，封装。好像很散，但是有很紧密。计算机里面设计的很重要的思想就是分层，代码层面，通过这些开源框架的学习，也能深有体会。记得小学学画画的时候，老师就一直强调：层次感很重要。明、暗、灰，各个部分的结合才能体现层次感。不能太黑，没有层次，不能太亮没有细节。

还有很多细节需要后续深入的去学习。但是了解一个框架的逻辑，也能从整体上把握住。也值得我们去学习。不要因为细节而丢失整体，不要因为整体而把握不住细节。