OkHttp解析（三）关于Okio

可以看到Buffer这里实现了两个接口，它集 BufferedSource 和 BufferedSink 的功能于一身，为我们提供了访问数据缓冲区所需要的一切 API。
而这里ReadBufferSource和ReadBufferSink虽然各自实现了单独的接口，但他们内部都保存了个成员变量Buffer，而Buffer却涵盖了两者。在ReadBufferSource和ReadBufferSink中调用读写实际上是调用到了Buffer的读写。这种设计有点类似装饰模式

官方例子

我们来看一下官方文档中 PNG 解码的例子：

private static final ByteString PNG_HEADER = ByteString.decodeHex("89504e470d0a1a0a");

public void decodePng(InputStream in) throws IOException {
  try (BufferedSource pngSource = Okio.buffer(Okio.source(in))) {
    ByteString header = pngSource.readByteString(PNG_HEADER.size());
    if (!header.equals(PNG_HEADER)) {
      throw new IOException("Not a PNG.");
    }
    ...
}

我们先一点一点看，这里有个静态成员变量PNG_HEADER，它则是把相应的十六进制字符串转换为相应的字节串。

 public static ByteString decodeHex(String hex) {
    if (hex == null) throw new IllegalArgumentException("hex == null");
    if (hex.length() % 2 != 0) throw new IllegalArgumentException("Unexpected hex string: " + hex);

    byte[] result = new byte[hex.length() / 2];
    for (int i = 0; i < result.length; i++) {
      int d1 = decodeHexDigit(hex.charAt(i * 2)) << 4;
      int d2 = decodeHexDigit(hex.charAt(i * 2 + 1));
      result[i] = (byte) (d1 + d2);
    }
    return of(result);
  }
  
  public static ByteString of(byte... data) {
    if (data == null) throw new IllegalArgumentException("data == null");
    return new ByteString(data.clone());
 }

可以看到，这里把十六进制中每个字符通过decodeHexDigit方法转换为对应的字节，再存放到字节数组中，最后调用of方法来创建出ByteString

继续看官方例子

public void decodePng(InputStream in) throws IOException {
  try (BufferedSource pngSource = Okio.buffer(Okio.source(in))) {
    ByteString header = pngSource.readByteString(PNG_HEADER.size());
    if (!header.equals(PNG_HEADER)) {
      throw new IOException("Not a PNG.");
    }

    while (true) {
      Buffer chunk = new Buffer();

      // Each chunk is a length, type, data, and CRC offset.
      int length = pngSource.readInt();
      String type = pngSource.readUtf8(4);
      pngSource.readFully(chunk, length);
      int crc = pngSource.readInt();

      decodeChunk(type, chunk);
      if (type.equals("IEND")) break;
    }
  }
}

我们先来看下Okio.buffer(Okio.source(in))这里

private static Source source(final InputStream in, final Timeout timeout) {
    return new Source() {
      @Override public long read(Buffer sink, long byteCount) throws IOException {
       ...
      }
       ...
    };
  }

public static BufferedSource buffer(Source source) {
    return new RealBufferedSource(source);
  }

可以看到，首先调用Okio.source(in)把InputStream输入流转换为Source，接着调用buffer方法创建了RealBufferedSource它实现了BufferSource方法。
此时这个pngSource则代表了图片的输入流信息

接着调用ByteString header = pngSource.readByteString(PNG_HEADER.size());
来读取图片首部的字节串

@Override public ByteString readByteString(long byteCount) throws IOException {
    require(byteCount);
    return buffer.readByteString(byteCount);
  }

可以看到，最终的读取转换则是通过Buffer来进行调用。而Buffer同样也实现了和ReadBufferdSource的接口BufferedSource。

为什么要这么折腾呢？明明可以简单的调用ReadBufferedSource为什么还要通过Buffer来调用？

让我们从功能需求和设计方案来考虑。

BufferedSource 要提供各种形式的读取操作，还有查找与判等操作。大家可能会想，那我就在实现类中自己实现不就好了吗？干嘛要经过 Buffer 中转呢？这里我们实现的时候，需要考虑效率的问题，而且不仅 BufferedSource 需要高效实现，BufferedSink 也需要高效实现，这两者的高效实现技巧，很大部分都是共通的，所以为了避免同样的逻辑重复两遍，Okio 就直接把读写操作都实现在了 Buffer 这一个类中，这样逻辑更加紧凑，更加内聚。而且还能直接满足我们对于“两用数据缓冲区”的需求：既可以从头部读取数据，也能向尾部写入数据。至于我们单独的读写操作需求，Okio 就为 Buffer 分别提供了委托类：RealBufferedSource 和 RealBufferedSink，实现好 Buffer 之后，它们两者的实现将非常简洁（前者 450 行，后者 250 行）。

OkHttp里面Okio的使用

前面说到

在OkHttp底层网络连接是使用Socket，连接成功后则通过Okio库与远程socket建立了I/O连接，接着调用createTunnel创建代理隧道，在这里HttpStream与Okio建立了I/O连接。

我们直接定位到RealConnection.connectSocket方法这里

 private void connectSocket(int connectTimeout, int readTimeout) throws IOException {
    Proxy proxy = route.proxy();
    Address address = route.address();

    rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP
        ? address.socketFactory().createSocket()
        : new Socket(proxy);

    rawSocket.setSoTimeout(readTimeout);
    try {
      Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
    } catch (ConnectException e) {
      throw new ConnectException("Failed to connect to " + route.socketAddress());
    }
    source = Okio.buffer(Okio.source(rawSocket));
    sink = Okio.buffer(Okio.sink(rawSocket));
  }

可以看到，这里根据挑选出来的线路代理，创建完Socket后，调用了连接，连接成功后，则使用Okio.source和Okio.sink打开对应的输入输出流保存到BufferedSource source和BufferedSink中。

之后再把创建出来的source和sink绑定到HttpStream，使得HttpStream拥有两者的调用。
前一篇文章说到，当Socket连接完成后，就会根据source和sink来选择创建对应HttpStream

  public HttpStream newStream(OkHttpClient client, boolean doExtensiveHealthChecks) {
      ...
      HttpStream resultStream;
      if (resultConnection.framedConnection != null) {
        resultStream = new Http2xStream(client, this, resultConnection.framedConnection);
      } else {
        resultConnection.socket().setSoTimeout(readTimeout);
        resultConnection.source.timeout().timeout(readTimeout, MILLISECONDS);
        resultConnection.sink.timeout().timeout(writeTimeout, MILLISECONDS);
        resultStream = new Http1xStream(
            client, this, resultConnection.source, resultConnection.sink);
    ...
}

之后就可以进行读取和写入数据。
写入数据的话，由第一篇文章可知道是在CallServerInterceptor中，在里面写入我们的请求体

// CallServerInterceptor#intercept
// 发送请求 body
Sink requestBodyOut = httpCodec.createRequestBody(request, 
        request.body().contentLength());
BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);
request.body().writeTo(bufferedRequestBody);
bufferedRequestBody.close();

// 读取响应 body
response = response.newBuilder()
    .body(httpCodec.openResponseBody(response))
    .build();

可以看到在这里，先调用了createRequestBody来根据request创建一个Sink不过此时还未写入数据，里面只是空的，只是根据request来选择创建Sink而已

 @Override public Sink createRequestBody(Request request, long contentLength) {
    if ("chunked".equalsIgnoreCase(request.header("Transfer-Encoding"))) {
      // Stream a request body of unknown length.
      return newChunkedSink();
    }
    if (contentLength != -1) {
      // Stream a request body of a known length.
      return newFixedLengthSink(contentLength);
    }
    ...
  }

接着把创建好的Sink包装到BufferedSink中，最终调用request.body().writeTo(bufferedRequestBody);来把自己的请求体写入BufferedSink，这里也就是写入到Socket里面了。

同理，读取数据到Response则是使用BufferedSource，这里就不扩展开了。

参考资料

拆轮子系列：拆 Okio
官方Okio

转载:https://www.jianshu.com/p/ade7bccfff7c