okhttp学习1

1.Http网络请求流程

建立连接（tcp 3次握手）
发送请求给服务器（头信息 body等等）
服务器返回数据给客户端（状态数据等等）
客户端取消连接（tcp 4次挥手）
ps:服务器返回值状态码 1xx 信息，2xx成功，3xx重定向，4xx错误，5xx服务器错误
版本基于com.squareup.okhttp3:okhttp:3.14.7

2 .OkHttp执行流程源码解读

getResponseWithInterceptorChain（）方法完成请求，并返回数据，我们看具体步骤

第一步按顺序添加所有拦截器，我们可以看到，最先添加应用拦截器，而网络拦截器是在ConnectInterceptor和CallServerInterceptor中间添加的

  Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    //按照顺序添加所有的拦截器
    List interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(new RetryAndFollowUpInterceptor(client));
    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, transmitter, null, 0,
        originalRequest, this, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    boolean calledNoMoreExchanges = false;
    try {
    //这里看到开始执行拦截器顺序
      Response response = chain.proceed(originalRequest);

我们继续看proceed方法,下面这段代码是一个递归调用，从第一个拦截器开始执行，直到最后一个拦截器结束。其实我们会从第一个拦截器的intercept方法开始调用，每次遇到realChain.proceed，又开始调用RealInterceptorChain中proceed方法，开始会对下一个拦截器调用。也就是责任链模式。

  // Call the next interceptor in the chain.
    RealInterceptorChain next = new RealInterceptorChain(interceptors, transmitter, exchange,
        index + 1, request, call, connectTimeout, readTimeout, writeTimeout);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);

连接与发送请求

ConnectInterceptor里面初始化Exchage对象，建立socket连接

    // We need the network to satisfy this request. Possibly for validating a conditional GET.
    boolean doExtensiveHealthChecks = !request.method().equals("GET");
    Exchange exchange = transmitter.newExchange(chain, doExtensiveHealthChecks);

我们继续看ConnectInterceptor中的方法，transmitter.newExchange中ExchangeCodec，该类子类有Http1ExchangeCodec和Http2ExchangeCodec，表示http请求的协议。方法执行到这里，我们确定了这次请求的协议。

好了，接下来就是调用最后一个拦截器了CallServerInterceptor，也就是在这里将请求头数据发送给服务器。我们看intercept里面的方法

1.准备请求头信息

exchange.writeRequestHeaders(request);

我们点进去会发现，最终是Http1ExchangeCodec类处理发送requeset请求，并且处理返回的response数据。找到请求头，我们可以看到okhttp的请求使用socket实现的，也就是说okhttp和httpurlconnection一样，同样是对socket的封装。下面是代码

  //这里对请求就行了封装，socket请求包括head等信息。包括\r\n的换行等等
  /** Returns bytes of a request header for sending on an HTTP transport. */
  public void writeRequest(Headers headers, String requestLine) throws IOException {
    if (state != STATE_IDLE) throw new IllegalStateException("state: " + state);
    sink.writeUtf8(requestLine).writeUtf8("\r\n");
    for (int i = 0, size = headers.size(); i < size; i++) {
      sink.writeUtf8(headers.name(i))
          .writeUtf8(": ")
          .writeUtf8(headers.value(i))
          .writeUtf8("\r\n");
    }
    sink.writeUtf8("\r\n");
    state = STATE_OPEN_REQUEST_BODY;
  }

2.请求头准备好了，socket的连接也在上一个connectintercept连接了，那就发送请求给服务器

 @Override public void flushRequest() throws IOException {
    sink.flush();
  }

3.Socket连接与请求详细说明

1.ConnectInterceptor 拦截器，用来建立Socket连接，核心连接代码位于ExchangeFinder.findConnection()

    //tcp 三次握手，建立连接
    // Do TCP + TLS handshakes. This is a blocking operation.
    result.connect(connectTimeout, readTimeout, writeTimeout, pingIntervalMillis,
        connectionRetryEnabled, call, eventListener);
    connectionPool.routeDatabase.connected(result.route());

我们在点进去，看看connetc方法

 if (route.requiresTunnel()) {
  //开始进行连接，如果服务器需要安全认证，则抛出异常
          connectTunnel(connectTimeout, readTimeout, writeTimeout, call, eventListener);
          if (rawSocket == null) {
            // We were unable to connect the tunnel but properly closed down our resources.
            break;
          }
        } else {
          connectSocket(connectTimeout, readTimeout, call, eventListener);
        }

无论是connectTunnel或者connectSocket，还是最后执行connectSocket方法
我们继续看看connectTunnel方法，

 Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
//继续点进去，到这里开始正式建立连接
 socket.connect(address, connectTimeout);

2.CallServerInterceptor 再上一个拦截器执行完毕后，socket已经正式建立连接，接下来就是发送数据在这拦截器里面。在这个拦截器里面，我们准备header等信息

@Override public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Exchange exchange = realChain.exchange();
    Request request = realChain.request();
    //准备heade信息
    exchange.writeRequestHeaders(request);

3.接下来重点，发送真正的请求


    if (request.body() == null || !request.body().isDuplex()) {
      exchange.finishRequest();
    }

//continue
  public void finishRequest() throws IOException {
    try {
      codec.finishRequest();
    } catch (IOException e) {
      eventListener.requestFailed(call, e);
      trackFailure(e);
      throw e;
    }
  }
//continue 

//最终调用Http1ExchangeCodec中的，这里的sink.flush就是发送请求啦
  @Override public void finishRequest() throws IOException {
    sink.flush();
  }

这里的sink是什么呢？我们去找相关的初始化方法

//在RealConntection 我们找到了初始化
  ExchangeCodec newCodec(OkHttpClient client, Interceptor.Chain chain) throws SocketException {
    if (http2Connection != null) {
      return new Http2ExchangeCodec(client, this, chain, http2Connection);
    } else {
      socket.setSoTimeout(chain.readTimeoutMillis());
      source.timeout().timeout(chain.readTimeoutMillis(), MILLISECONDS);
      sink.timeout().timeout(chain.writeTimeoutMillis(), MILLISECONDS);
      return new Http1ExchangeCodec(client, this, source, sink);
    }
  }
  
//看到这里，我们应该知道soucc sink由realconnection传入
//最终我们在这里看到，source输入流，sink输出流
source = Okio.buffer(Okio.source(socket));
sink = Okio.buffer(Okio.sink(socket));

到这里，我们就该明白sink.flush方法，也就是将我们的header信息发送给服务器，下面就是通过source读取数据了。

   if (responseBuilder == null) {
      responseBuilder = exchange.readResponseHeaders(false);
    }

//最终我们执行到这里，读取socket流数据
  private String readHeaderLine() throws IOException {
    String line = source.readUtf8LineStrict(headerLimit);
    headerLimit -= line.length();
    return line;
  }

4.总结

okhttp的请求流程整体是比较简单的，底层采用socket连接，又准备了连接池缓存，减少重复的服务器连接，有利于高并发效率。Okhttp对输入流输出流用了okio这个框架，高效也更加方便处理输入输出流，sink处理输出流，source处理输入流，内部也用了字符缓存池。

拦截器的执行顺序也是按照第一个添加的顺序依次往下执行，至于添加应用拦截器还是网络拦截器也很简单，取决于你想处理网络连接以后的数据还是连接之前的处理，前者用网络拦截器。

okhttp系统自带5个拦截器。RetryAndFollowUpInterceptor 处理网络连接失败，再次发送请求和重定向。BridgeInterceptor处理一些head信息。添加一些Connection", "Keep-Alive ，编码之类的信息。CacheInterceptor就是将返回的数据进行缓存。ConnectInterceptor拦截器连接服务器，socket连接。CallServerInterceptor发送请求信息给服务器，处理响应数据。

关于拦截器的具体实现，比如缓存拦截器处理机制没有仔细去看，应该也不难

应用开发中。我们自定义拦截器也是比较简单的，大致可以按照下面这个模板处理。处理下request response就行了、然后注意的就是你要添加应用拦截器还是网络拦截器

 @Override public Response intercept(Interceptor.Chain chain) throws IOException {
    //1.获取request
    Request request = chain.request();
    ......处理
    //2.获取response
    Response response = chain.proceed(request);
    .......处理
    /3./返回response
    return response;
  }

okhttp学习1

1.Http网络请求流程

2 .OkHttp执行流程源码解读

3.Socket连接与请求详细说明

4.总结

你可能感兴趣的:(okhttp学习1)