1、它是什么？

它是一套在Java IO基础上再次进行封装的IO框架，在形式上比原来的Java IO更简洁易用。引入OkHttp依赖即可引用之，源码地址：https://github.com/square/okio。

2、如何使用？

2.1 利用kotlin扩展函数，代码简洁，两行代码搞定

当然，前提是记得加入文件读写权限。

@Testfun useExtension() {   val appContext = InstrumentationRegistry.getInstrumentation().targetContext   var file:File = File(appContext.filesDir.path.toString()+"/test.txt")   //写文件   file.sink().buffer().writeString("write sth", Charset.forName("utf-8")).close()   //读文件   val fileContent = file.source().buffer().readString(Charset.forName("utf-8”))    println()}

运行结果如下

2.2 老版本的java调用方式

代码如下：

@Testpublic void testIO() {   Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();   File file = new File(appContext.getFilesDir().getPath().toString());   try {       //  写文件       BufferedSink bufferedSink = Okio.buffer(Okio.sink(file));       bufferedSink.writeString("write sth", Charset.forName("utf-8"));       bufferedSink.close();       //   读文件       BufferedSource bufferedSource = Okio.buffer(Okio.source(file));       bufferedSource.readString(Charset.forName("utf-8"));   } catch (FileNotFoundException e) {       e.printStackTrace();   } catch (IOException e) {       e.printStackTrace();   }   System.out.println("===end");}

运行结果也一样，不再列出。

3、看看原理

*注：版本为最新版的kotlin代码

3.1 它使用了谁？

3.1.1 InputStream、OutputStream

跟踪sink()、source()方法很明显，扩展了InputStream、OutputStream的相关函数，并将其子类封装成Source、Sink的实例。

3.1.2 SegmentPool和Segment

跟踪Okio的buffer方法，可以看到RealBufferedSink、RealBufferedSource类，他们分别实现了Sink、Source。而RealBufferedSink、RealBufferedSource都持有Buffer类型的属性buffer。这个Buffer类很关键，内部使用到了SegmentPool，SegmentPool是管理Segment的工具，Segment是缓冲区中的某一片段，正是有它的存在，可以实现分段存储。

3.1.3 ByteString

还值得一提的是ByteString，这是一个方便Byte和String类互转的工具

3.2 谁使用了它？

3.2.1 OkHttp

okhttp中使用okio支撑相关流操作。

3.2.2 支付宝等众多大型应用中

3.3 原理解析

3.3.1 类图

Sink负责输出相关的操作，而Source负责输入相关的操作。

可以看到，无论读写，都是通过Buffer统一操作的。底层还是使用了OutputSream、InputStream，本质上还是对Java IO相关的API的封装。

3.3.2 分段存储的Segment

Segment本质上是缓存片段，通过SegmentPool维护，数据结构表现为双向链表。如下图

通过SegmentPool取出某一个Segment片段，用于缓存待写入的数据。

采用双向链表可以在数据的复制、转移等操作场景显得十分高效。

以文件写入为例，看看Segment是何时发挥作用的。

var file:File = File(appContext.getFilesDir().getPath().toString());file.sink().buffer().writeString("write sth", Charset.forName("utf-8")).close()

File类没有sink方法，这里的sink方法为扩展函数，返回Sink的实例。

/** Returns a sink that writes to `file`. */@JvmOverloads@Throws(FileNotFoundException::class)fun File.sink(append: Boolean = false): Sink = FileOutputStream(this, append).sink()

FileOutputStream类的sink方法同样是扩展函数，继续跟进可以看到，此为OutputStream的扩展函数，FileOutputStream继承自OutputStream。

/** Returns a sink that writes to `out`. */fun OutputStream.sink(): Sink = OutputStreamSink(this, Timeout())

OutputStreamSink中的this为FileOutputStream，是File.sink方法调用时初始化的实例，再看看OutputStreamSink类的具体实现，内部复写了write方法，本质上最终还是调用Java IO中的OutputStream进行数据写入。

private class OutputStreamSink(  private val out: OutputStream,  private val timeout: Timeout) : Sink {  override fun write(source: Buffer, byteCount: Long) {    /*省略*/    out.write(head.data, head.pos, toCopy)    /*省略*/  }}

虽然看到了最终的通过OutputStream实现，但此时还未进行真正的写入方法的调用，继续跟进buffer()方法，此方法返回RealBufferedSink实例。注意，构造方法中的this就是OutputStreamSink

fun Sink.buffer(): BufferedSink = RealBufferedSink(this)

继续跟进至RealBufferedSink的writeString方法，此方法逻辑步骤比较简单，第一步通过Buffer写入数据，第二步提交已完成的Segment片段。

override fun writeString(string: String, charset: Charset): BufferedSink {  check(!closed) { "closed" }  buffer.writeString(string, charset)  return emitCompleteSegments()}

跟进至Buffer类，最终会调用commonWrite方法，而commonWrite内部调用commonWritableSegment方法，此时Segment登场了，通过SegmentPool取出Segment片段，最终将数据拷贝至Segment片段中。

internal inline fun Buffer.commonWritableSegment(minimumCapacity: Int): Segment {  require(minimumCapacity >= 1 && minimumCapacity <= Segment.SIZE) { "unexpected capacity" }  if (head == null) {    val result = SegmentPool.take() // Acquire a first segment.    head = result    result.prev = result    result.next = result    return result  }  var tail = head!!.prev  if (tail!!.limit + minimumCapacity > Segment.SIZE || !tail.owner) {    tail = tail.push(SegmentPool.take()) // Append a new empty segment to fill up.  }  return tail}

至此依然没发生真正的读写调用，跟进emitCompleteSegments方法，最终调用commonEmitCompleteSegment方法。

internal inline fun RealBufferedSink.commonEmitCompleteSegments(): BufferedSink {  check(!closed) { "closed" }  val byteCount = buffer.completeSegmentByteCount()  if (byteCount > 0L) sink.write(buffer, byteCount)  return this}