OkHttp深入学习（四）——0kio

最新推荐文章于 2024-04-08 23:43:51 发布
最新推荐文章于 2024-04-08 23:43:51 发布
阅读量492 收藏
点赞数
分类专栏： android-okhttp学习 文章标签： okhttp使用 okhttp使用详解

转载请注明出处：http://blog.csdn.net/evan_man/article/details/51204469


    上一节《OkHttp深入学习（三）——Cache》我们对okhttp中的Cache缓存机制进行了学习，学习了上一节的内容，如果叫我们自己去设计一个缓存机制，那么我们一定会有了自己的思路，想想还有点小激动。这一节我们继续来看看okhttp这个教科书中还有什么值得我们继续挖掘的东西。果不其然，我们发现了okio这个好东西，该类主要负责对Java中io的封装，使得java中的io流读写更加方便，甚至还能提高读写效率。okio项目开源地址请戳这里。在正式学习之前，我们先来了解一下它是如何使用的，随后我们再根据涉及到的内容进行深入学习。


okio的数据存储实体

    okio提供了ByteString和Buffer两钟数据类型，用于存储数据。
    ByteString存储的是不可变比特序列，可能你不太理解这句话，如果给出final byte[] data你是不是就懂了呢。官方文档说可以把它看成String的远方亲戚，且这个亲戚符合人体工学设计，有没有感觉很高大上。不过简单的讲它就是能够对一个byte序列(数组)，以指定的编码格式进行编解码。目前支持的编解码规则有hex, base64和 UTF-8等。机智的朋友会说jav.lang.String也可以实现这些功能，是的你说的没错，ByteString只是把这些方法进行了封装，免去了我们直接输入类似”UTF-8”这样的字符串，通过直接调用byteString.utf8()获取对应的解码结果,你说哪个方便？使用前面的方法容易引入输出时的错误，在敲UTF-8这几个字符的时候可能会出现输入的错误。所以总的来讲ByteString干了一件封装的事情，它把经常用到的几种编解码方式进行了封装，不过封装的好处避免了犯错。最后ByteString对于UTF-8格式的解码还做了优化，在第一次调用utf8()方法的时候得到一个该编码的String，同时在ByteString内部保留了这个引用 ，当再次调用utf8()的时候则直接返回这个引用。
    Buffer存储的是可变比特序列，需要注意的是Buffer内部对比特数据的存储不是直接使用一个byte数组那么简单，它使用了一种新的数据类型Segment进行存储。不过我们先不去管Segment是什么东西，可以先直接将Buffer想象成一个ArrayList集合就可以了，之所以做这样的想象是因为Buffer的容量可以动态拓展，从序列的尾部存入数据，从序列的头部读取数据。其实Buffer的底层实现远比ArrayList复杂的多，它使用的是一个双向链表的形式存储数据，链表结点的数据类型就是前面说的Segment，Segment中存储有一个不可变比特序列，即final byte[] data。使用Buffer的好处在于在从一个Buffer移动到另一个Buffer的时候，实际上并没有对比特序列进行拷贝，只是改变了对应Segment的所有者，其实这也采用链表存储数据的好处，这样的特点在多线程网络通信中会带来很大的好处。最后使用Buffer还有另一个好处那就是它实现了BufferedSource和BufferedSink接口，这两个接口我们后面再讲，主要是实现了形如nextInt等方法，方便从buffer中读取数据，否则Buffer中存储的byte数据我们并不能直接拿来使用。
    上面的文字有点多，我们对ByteString和Buffer做个小节。ByteString存储了一个final byte[] data比特数组，通过调用ByteString的相关方法对存储的比特数据进行相应的编解码，常用编解码有UTF-8、Base64和hex。Buffer用双向链表形式存储了一系列的Segment结点，Segment结点中存储final byte[] data比特数组；Buffer实现了BufferedSource和BufferedSink接口，通过调用形如buffer.readXX()方法将比特数组进行解码，返回XX类型的数据，就像scanner.nextInt一样使用。

okio的输入输出流

    接下来看看okio中与java sdk中的InputStream和OutPutStream两个对应的接口，Sink和Source。 官方认为sink和source接口相对于java sdk的inputStream和OutputStream更加容易实现，定义sink和source两个接口的作者认为，sdk中的available()和读写单字节的方法纯属鸡肋。
  • Sink定义了四个方法write(Buffer source, long byteCount), flush(), close(), and timeout()；
  • Source定义了三个方法long read(Buffer sink, long byteCount), close(), and timeout()；
虽然Sink和Source只定义了很少的方法，这也是为何说它容易实现的原因，但是我们在使用过程中，并不直接拿它进行使用，而是使用BufferedSink和BufferedSource对前面的接口进行再度的封装，BufferedSink和BufferedSource接口定义了一系列好用的方法。
  • BufferedSink定义了writeUtf8、writeString、writeByte、writeShort、 writeInt、writeLong等常用方法；
  • BufferedSource定义了readByte()、readShort()、readInt()、readLong()、readUtf8()等常用方法；
    最后okio的作者认为，java的sdk对字节流和字符流进行分开定义这一事情，并不是那么优雅，特此okio并不进行这样的划分。具体做法就是把比特数据都交给Buffer管理，然后Buffer实现BufferedSource和BufferedSink这两个接口，最后通过调用buffer相应的方法对数据进行编解码。

okio的实例

[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. private static final ByteString PNG_HEADER = ByteString.decodeHex(“89504e470d0a1a0a”);  
  2. public void decodePng(InputStream in) throws IOException {  
  3.   BufferedSource pngSource = Okio.buffer(Okio.source(in)); //note1  
  4.   ByteString header = pngSource.readByteString(PNG_HEADER.size()); //note2  
  5.   if (!header.equals(PNG_HEADER)) {  
  6.     throw new IOException(“Not a PNG.”);  
  7.   }  
  8.   while (true) {  
  9.     Buffer chunk = new Buffer(); //note3  
  10.     // Each chunk is a length, type, data, and CRC offset.  
  11.     int length = pngSource.readInt(); //note4  
  12.     String type = pngSource.readUtf8(4);  
  13.     pngSource.readFully(chunk, length); //note5  
  14.     int crc = pngSource.readInt();  
  15.     decodeChunk(type, chunk);  
  16.     if (type.equals(“IEND”)) break;  
  17.   }  
  18.   pngSource.close(); //note7  
  19. }  
  20. private void decodeChunk(String type, Buffer chunk) {  
  21.   if (type.equals(“IHDR”)) {  
  22.     int width = chunk.readInt(); //note6  
  23.     int height = chunk.readInt();  
  24.     System.out.printf(”%08x: %s %d x %d%n”, chunk.size(), type, width, height);  
  25.   } else {  
  26.     System.out.printf(”%08x: %s%n”, chunk.size(), type);  
  27.   }  
  28. }  
private static final ByteString PNG_HEADER = ByteString.decodeHex("89504e470d0a1a0a");
public void decodePng(InputStream in) throws IOException {
  BufferedSource pngSource = Okio.buffer(Okio.source(in)); //note1
  ByteString header = pngSource.readByteString(PNG_HEADER.size()); //note2
  if (!header.equals(PNG_HEADER)) {
    throw new IOException("Not a PNG.");
  }
  while (true) {
    Buffer chunk = new Buffer(); //note3
    // Each chunk is a length, type, data, and CRC offset.
    int length = pngSource.readInt(); //note4
    String type = pngSource.readUtf8(4);
    pngSource.readFully(chunk, length); //note5
    int crc = pngSource.readInt();
    decodeChunk(type, chunk);
    if (type.equals("IEND")) break;
  }
  pngSource.close(); //note7
}
private void decodeChunk(String type, Buffer chunk) {
  if (type.equals("IHDR")) {
    int width = chunk.readInt(); //note6
    int height = chunk.readInt();
    System.out.printf("%08x: %s %d x %d%n", chunk.size(), type, width, height);
  } else {
    System.out.printf("%08x: %s%n", chunk.size(), type);
  }
}
1、将InputStream转换为BufferedSource对象
2、将指定长度的比特数据转换成ByteString数据
3、创建Buffer对象
4、从第一步获取到的BufferedSource中读取到int和UTF8数据
5、读取固定长度的数据到Buffer中
6、Buffer的读写跟BufferedSource和BufferedSink一样，因为它们实现了同样的接口
7、关闭第一步得到的输出流。
    总的来讲okio的使用就是首先创建一个对应的BufferedSource和BufferedSink对象，随后利用相关方法，获取或写入ByteString、Buffer、int、long等类型数据，对于Buffer数据可以通过调用与BufferedSource和BufferedSink一样的方法对已经读取到的数据进行进一步的解析。

okio的原理介绍

    上面我们对于okio的基本情况进行了介绍，同时给出了一个简答的使用案例。本小节将对底层的实现进行介绍。介绍的内容以前面的几个小节涉及到的内容为主，首先对ByteString、Buffer两个数据类型介绍，随后对Okio.buffer和Okio.source两个方法进行介绍。

ByteString

按照以往的惯例，首先看看该对象都有哪些域：
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. static final char[] HEX_DIGITS = { ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’ }; //很明显这个肯定是在进行hex解析的时候被使用到  
  2. final byte[] data;  
  3. transient int hashCode; //说是String远方亲戚也不假，String也有类似上面的两个域  
  4. transient String utf8; //这个域的存在就是实现了对utf-8解码的优化，是一个对utf8解码String的优化  
static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; //很明显这个肯定是在进行hex解析的时候被使用到
final byte[] data;
transient int hashCode; //说是String远方亲戚也不假，String也有类似上面的两个域
transient String utf8; //这个域的存在就是实现了对utf-8解码的优化，是一个对utf8解码String的优化
ByteString()@ByteString.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. ByteString(byte[] data) {  
  2.     this.data = data;   
  3. }  
ByteString(byte[] data) {
    this.data = data; 
}
构造器 的参数为 一个byte[]类型，不过该构造器只能被同包的类使用，因此我们创建ByteString对象并不是通过该方法。 我们是如何构造一个ByteString对象？看下面的方法
of@ByteString.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public static ByteString of(byte… data) {  
  2.     if (data == null) throw new IllegalArgumentException(“data == null”);  
  3.     return new ByteString(data.clone());//note1  
  4. }  
  5. public static ByteString of(byte[] data, int offset, int byteCount) {  
  6.     if (data == null) throw new IllegalArgumentException(“data == null”);  
  7.     checkOffsetAndCount(data.length, offset, byteCount);//note2  
  8.     byte[] copy = new byte[byteCount];  
  9.     System.arraycopy(data, offset, copy, 0, byteCount);//note3  
  10.     return new ByteString(copy);  
  11. }  
public static ByteString of(byte... data) {
    if (data == null) throw new IllegalArgumentException("data == null");
    return new ByteString(data.clone());//note1
}
public static ByteString of(byte[] data, int offset, int byteCount) {
    if (data == null) throw new IllegalArgumentException("data == null");
    checkOffsetAndCount(data.length, offset, byteCount);//note2
    byte[] copy = new byte[byteCount];
    System.arraycopy(data, offset, copy, 0, byteCount);//note3
    return new ByteString(copy);
}
1、调用clone方法，重新创建一个byte数组，clone一个数组的原因很简单，我们确保ByteString的data域指向的byte[]没有被其它对象所引用，否则就容易破坏ByteString中存储的是一个不可变比特流数据这一约束。
2、边界检查
3、老朋友了，将data中指定的数据拷贝到copy数组中去。
接下来对ByteString的相关方法进行介绍，在此并不准备对byteString中的所有方法进行介绍，只是介绍几个常用的方法。
toString()@ByteString.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public String toString() {  
  2.     if (data.length == 0) {  
  3.       return “ByteString[size=0]”;  
  4.     }  
  5.     if (data.length <= 16) {  
  6.       return String.format(“ByteString[size=%s data=%s]”, data.length, hex());  
  7.     }  
  8.     return String.format(“ByteString[size=%s md5=%s]”, data.length, md5().hex());  
  9. }  
public String toString() {
    if (data.length == 0) {
      return "ByteString[size=0]";
    }
    if (data.length <= 16) {
      return String.format("ByteString[size=%s data=%s]", data.length, hex());
    }
    return String.format("ByteString[size=%s md5=%s]", data.length, md5().hex());
}
很简单，这就不讲了，将data数据分别以hex和md5格式打印
utf8()@ByteString.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public String utf8() {  
  2.     String result = utf8;  
  3.     return result != null ? result : (utf8 = new String(data, Util.UTF_8));  
  4. }  
public String utf8() {
    String result = utf8;
    return result != null ? result : (utf8 = new String(data, Util.UTF_8));
}
这里的一个判断语句，实现ByteString性能的优化，看来优化这个东西还是很容易实现的嘛。第一次创建UTF-8对象的方法是调用new String(data, Util.UTF_8)，后面就不再调用该方法而是直接返回result；发现utf8就是对String的方法进一步封装，ByteString中很多其它的方法也类似，在此就不讲了。
在正式介绍Buffer之前我们先来了解一下Segment。

Segment.class

需要注意的是这是一个双向链表结构！！
按照以往的惯例，首先看看该对象都有哪些域：
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. static final int SIZE = 2048; //一个Segment存储的最大比特数据的数量  
  2. final byte[] data; //比特数组的引用  
  3. int pos; //pos第一个可以读的位置  
  4. int limit; //limit是第一个可以写的位置，所以一个Segment的可读数据数量为pos~limit-1=limit-pos；limit和pos的有效值为0~SIZE-1  
  5. boolean shared; //当前存储的data数据是其它对象共享的则为真  
  6. boolean owner; //是当前data的所有者  
  7. Segment next; //下一个Segment  
  8. Segment prev; //前一个Segment  
static final int SIZE = 2048; //一个Segment存储的最大比特数据的数量
final byte[] data; //比特数组的引用
int pos; //pos第一个可以读的位置
int limit; //limit是第一个可以写的位置，所以一个Segment的可读数据数量为pos~limit-1=limit-pos；limit和pos的有效值为0~SIZE-1
boolean shared; //当前存储的data数据是其它对象共享的则为真
boolean owner; //是当前data的所有者
Segment next; //下一个Segment
Segment prev; //前一个Segment
Segment()@Segment.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. Segment() {  
  2.   this.data = new byte[SIZE];  
  3.   this.owner = true; //note1  
  4.   this.shared = false; //note2  
  5. }  
  6. Segment(Segment shareFrom) {  
  7.   this(shareFrom.data, shareFrom.pos, shareFrom.limit);  
  8.   shareFrom.shared = true; //note3  
  9. }  
  10. Segment(byte[] data, int pos, int limit) {  
  11.   this.data = data;  
  12.   this.pos = pos;  
  13.   this.limit = limit;  
  14.   this.owner = false; //note4  
  15.   this.shared = true; //note5  
  16. }  
  Segment() {
    this.data = new byte[SIZE];
    this.owner = true; //note1
    this.shared = false; //note2
  }
  Segment(Segment shareFrom) {
    this(shareFrom.data, shareFrom.pos, shareFrom.limit);
    shareFrom.shared = true; //note3
  }
  Segment(byte[] data, int pos, int limit) {
    this.data = data;
    this.pos = pos;
    this.limit = limit;
    this.owner = false; //note4
    this.shared = true; //note5
  }
1、采用该构造器表明该数据data的所有者是该Segment，故owner为真
2、数据不是来自其它对象，所以shared为假
3、数据来自其它的Segment，设置参数Segment的Shared为真，表明该Segment数据被别人共享了
4、数据是来自其它对象，所以shared为真
pop()@Seg ment.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public Segment pop() {  
  2.     Segment result = next != this ? next : null;  
  3.     prev.next = next;  
  4.     next.prev = prev;  
  5.     next = null;  
  6.     prev = null;  
  7.     return result;  
  8. }  
public Segment pop() {
    Segment result = next != this ? next : null;
    prev.next = next;
    next.prev = prev;
    next = null;
    prev = null;
    return result;
}
将当前Segment从Segment链中移除出去。 返回参数Segment的后一个Segment
push()@Segment.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public Segment push(Segment segment) {  
  2.     segment.prev = this;  
  3.     segment.next = next;  
  4.     next.prev = segment;  
  5.     next = segment;  
  6.     return segment;  
  7.   }  
public Segment push(Segment segment) {
    segment.prev = this;
    segment.next = next;
    next.prev = segment;
    next = segment;
    return segment;
  }
将参数中的Segment压人调用该方法的Segment结点后面。返回刚刚压入的Segment
split()@Segment.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public Segment split(int byteCount) {  
  2.     if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();  
  3.     Segment prefix = new Segment(this);  
  4.     prefix.limit = prefix.pos + byteCount;  
  5.     pos += byteCount;  
  6.     prev.push(prefix);  
  7.     return prefix;  
  8.   }  
public Segment split(int byteCount) {
    if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
    Segment prefix = new Segment(this);
    prefix.limit = prefix.pos + byteCount;
    pos += byteCount;
    prev.push(prefix);
    return prefix;
  }
该方法用于将Segment一分为二，将pos+1~pos+byteCount-1的内容给新的Segment，将pos+byteCount~limit-1的内容留给自己，然后将前面的新Segment插入到自己前面。这里需要注意的是，虽然这里变成了两个Segment但是实际上byte[]数据并没有被拷贝，两个Segment都引用该Segment。

下面介绍的这个方法尝试将当前Segment和它之前的Segment进行合并，目的是减少Segment数量，如果没有任何异常出现的话，结果就是将调用该方法的Segment从Segment链中被移除出去。
compact()@Segment.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public void compact() {  
  2.     if (prev == this) throw new IllegalStateException();  
  3.     if (!prev.owner) return; //note1  
  4.     int byteCount = limit - pos; //note2  
  5.     int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos); //note3  
  6.     if (byteCount > availableByteCount) return; //note4  
  7.     writeTo(prev, byteCount); //note5  
  8.     pop(); //note6  
  9.     SegmentPool.recycle(this); //note7  
  10.   }  
public void compact() {
    if (prev == this) throw new IllegalStateException();
    if (!prev.owner) return; //note1
    int byteCount = limit - pos; //note2
    int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos); //note3
    if (byteCount > availableByteCount) return; //note4
    writeTo(prev, byteCount); //note5
    pop(); //note6
    SegmentPool.recycle(this); //note7
  }
1、如果当前Segment前结点不是自己，且前结点具备可写性。则进行下列操作，或者说下列操作的前提是当前结点的前结点可以写入数据
2、记录当前Segment具有的数据，数据大小为limit-pos-1;
3、统计前结点是否被共享，如果共享则只记录Size-limit大小，如果没有被共享，则加上pre.pos之前的空位置；
4、判断pre拥有的空余位置是否够将当前Segment的全部数据存入进来；
5、将当前Segment中数据写入pre中
6、将当前Segment从Segment链表中移除
7、回收该Segment

下面这个方法的作用就是将调用该方法的Segment中的byteCount个数据写入到方法参数的Segment中。
writeTo()@Segment.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public void writeTo(Segment sink, int byteCount) {  
  2.     if (!sink.owner) throw new IllegalArgumentException(); //note1  
  3.     if (sink.limit + byteCount > SIZE) { //note2  
  4.       if (sink.shared) throw new IllegalArgumentException(); //note3  
  5.       if (sink.limit + byteCount - sink.pos > SIZE) throw new IllegalArgumentException(); //note4  
  6.       System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos); //note5  
  7.       sink.limit -= sink.pos;  
  8.       sink.pos = 0;  
  9.     }  
  10.     System.arraycopy(data, pos, sink.data, sink.limit, byteCount);//note6  
  11.     sink.limit += byteCount;  
  12.     pos += byteCount;  
  13. }  
public void writeTo(Segment sink, int byteCount) {
    if (!sink.owner) throw new IllegalArgumentException(); //note1
    if (sink.limit + byteCount > SIZE) { //note2
      if (sink.shared) throw new IllegalArgumentException(); //note3
      if (sink.limit + byteCount - sink.pos > SIZE) throw new IllegalArgumentException(); //note4
      System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos); //note5
      sink.limit -= sink.pos;
      sink.pos = 0;
    }
    System.arraycopy(data, pos, sink.data, sink.limit, byteCount);//note6
    sink.limit += byteCount;
    pos += byteCount;
}
1、首先判断参数sink是否具有更改数据的权限，没有则抛出异常，运行时异常不需要捕获
2、如果当前写入的数据在limit~SIZE-1之间得不到满足，意味着需要先将sink中的数据移动到字节数组的最前端，因此需要进行下面的判断，判断是否可移动不能则抛出异常
3、当前Fragment处于可共享的状态，抛出异常
4、条件转换为 byteCount  > SIZE-（sink.limit- sink.pos），意味着当前Segment没有足够的空间写入byteCount数据
5、
这里我们来复习一下arraycopy方法public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);  将src中的srcPos~srcPos+length-1的数据复制到dest中的destPos~destPos+length-1位置处； 该方法很重要只要涉及到数组的移动，最底层都是调用该方法。
那么note5中的含义就是将pos~limit-1之间的数据移动到0~limit-pos-1位置处，并设置Segment.limit值为limit-pos，sink.pos设置为0；
6、将当前Segment的pos~pos+byteCount-1之间的数据复制到sink的limit~limit+byteCount-1之间，同时设置sink.limit和当前Segment的pos值。

    到此为止我们对于Segment的分析就结束了，但是在我们正式介绍Buffer之前，还需要介绍一下SegmentPool这个类，在compact()方法的最后我们调用egmentPool.recycle(this);方法对该Segment资源进行回收。

SegmentPool.class

按照以往的惯例，首先看看该对象都有哪些域：
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. static final long MAX_SIZE = 64 * 1024; // 大家是否还记得一个Segment记录的数据最大长度为2048？因此该Segment相当于能存储32个Segment对象。不过为何不是32*2048？  
  2. static Segment next; //该SegmentPool存储了一个回收Segment的链表  
  3. static long byteCount; //该值记录当前存储的所有Segment总大小，最大值为MAX_SIZE  
static final long MAX_SIZE = 64 * 1024; // 大家是否还记得一个Segment记录的数据最大长度为2048？因此该Segment相当于能存储32个Segment对象。不过为何不是32*2048？
static Segment next; //该SegmentPool存储了一个回收Segment的链表
static long byteCount; //该值记录当前存储的所有Segment总大小，最大值为MAX_SIZE
take()@SegmentPool.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. static Segment take() {  
  2.     synchronized (SegmentPool.class) {  
  3.       if (next != null) {  
  4.         Segment result = next;  
  5.         next = result.next;  
  6.         result.next = null;  
  7.         byteCount -= Segment.SIZE;  
  8.         return result;  
  9.       }  
  10.     }  
  11.     return new Segment(); // Pool is empty. Don’t zero-fill while holding a lock.  
  12. }  
static Segment take() {
    synchronized (SegmentPool.class) {
      if (next != null) {
        Segment result = next;
        next = result.next;
        result.next = null;
        byteCount -= Segment.SIZE;
        return result;
      }
    }
    return new Segment(); // Pool is empty. Don't zero-fill while holding a lock.
}
方法很简单，就是尝试从SegmentPool的Segment链表中取出一个Segment对象，如果链表为空则创建一个Segment对象返回。
recycle()@SegmentPool.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. static void recycle(Segment segment) {  
  2.     if (segment.next != null || segment.prev != null) throw new IllegalArgumentException();  
  3.     if (segment.shared) return; // This segment cannot be recycled.  
  4.     synchronized (SegmentPool.class) {  
  5.       if (byteCount + Segment.SIZE > MAX_SIZE) return; // Pool is full.  
  6.       byteCount += Segment.SIZE;  
  7.       segment.next = next;  
  8.       segment.pos = segment.limit = 0;  
  9.       next = segment;  
  10.     }  
  11.   }  
static void recycle(Segment segment) {
    if (segment.next != null || segment.prev != null) throw new IllegalArgumentException();
    if (segment.shared) return; // This segment cannot be recycled.
    synchronized (SegmentPool.class) {
      if (byteCount + Segment.SIZE > MAX_SIZE) return; // Pool is full.
      byteCount += Segment.SIZE;
      segment.next = next;
      segment.pos = segment.limit = 0;
      next = segment;
    }
  }
方法同样很简单，就是尝试将参数的Segment对象加入到自身的Segment链表中，如果SegmentPool已经满了，则直接抛弃该Segment，否则加入到链表中。
    细心的同学肯定发现，SegmentPool中的域和方法都是static修饰的，原因很简单，SegmentPool的作用就是管理多余的Segment，不直接丢弃废弃的Segment，等客户需要Segment的时候直接从该池中获取一个对象，避免了重复创建新对象，提高资源利用率。

在正式进入Buffer内容前我们先梳理一下，我们期望从中了解的内容，我们参照ByteString部分的讲解，这里我们需要学习和了解如何构建一个Buffer对象，Buffer中的数据如何管理、存储，Buffer中的buffer.readXX()方法底层是如何实现的。有了这些目标我们就来分析一下Buffer这个类。

Buffer.class

首先看看该对象都有哪些域：
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. static final char[] HEX_DIGITS = { ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’ }; //很明显这个肯定是在进行hex解析的时候被使用到  
  2. Segment head; //Buffer存储了一个这样的head结点，这就是Buffer对数据的存储结构。字节数组都是交给Segment进行管理。  
  3. long size; //当前存储的数据的大小  
static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; //很明显这个肯定是在进行hex解析的时候被使用到
Segment head; //Buffer存储了一个这样的head结点，这就是Buffer对数据的存储结构。字节数组都是交给Segment进行管理。
long size; //当前存储的数据的大小
Buffer()@Buffer.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public Buffer() {  
  2. }  
public Buffer() {
}
构造器是空的！不过想想构造器是空的也不足为奇，因为即使构造器是空的，其实域中的值也早就被赋了值，即segment=null，size=0；
前面一直讲Buffer到Buffer之间的移动数据效率是如何如何的牛逼，这里我们就一探究竟
copyTo()@@Buffer.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public Buffer copyTo(Buffer out, long offset, long byteCount) {  
  2.     if (out == null) throw new IllegalArgumentException(“out == null”);  
  3.     checkOffsetAndCount(size, offset, byteCount);  
  4.     if (byteCount == 0) return this;  
  5.     out.size += byteCount; //note1  
  6.     Segment s = head;    
  7.     for (; offset >= (s.limit - s.pos); s = s.next) { //note2  
  8.       offset -= (s.limit - s.pos);  
  9.     }  
  10.     // note3  
  11.     for (; byteCount > 0; s = s.next) {  
  12.       Segment copy = new Segment(s);  
  13.       copy.pos += offset;  
  14.       copy.limit = Math.min(copy.pos + (int) byteCount, copy.limit);  
  15.       if (out.head == null) {  
  16.         out.head = copy.next = copy.prev = copy;  
  17.       } else {  
  18.         out.head.prev.push(copy);  
  19.       }  
  20.       byteCount -= copy.limit - copy.pos;  
  21.       offset = 0;  
  22.     }  
  23.     return this;  
  24.   }  
public Buffer copyTo(Buffer out, long offset, long byteCount) {
    if (out == null) throw new IllegalArgumentException("out == null");
    checkOffsetAndCount(size, offset, byteCount);
    if (byteCount == 0) return this;
    out.size += byteCount; //note1
    Segment s = head;  
    for (; offset >= (s.limit - s.pos); s = s.next) { //note2
      offset -= (s.limit - s.pos);
    }
    // note3
    for (; byteCount > 0; s = s.next) {
      Segment copy = new Segment(s);
      copy.pos += offset;
      copy.limit = Math.min(copy.pos + (int) byteCount, copy.limit);
      if (out.head == null) {
        out.head = copy.next = copy.prev = copy;
      } else {
        out.head.prev.push(copy);
      }
      byteCount -= copy.limit - copy.pos;
      offset = 0;
    }
    return this;
  }
1、更改目标Buffer的size值
2、求出从当前Buffer的head需要扩过多少个segment才能能够满足offset，之后将对该s往后的byteCount个数据进行拷贝
3、每次插入一个Segment节点，实际创建的new Fragment并不是真的创建一个Segment对象，而是将Segment中的数据进行共享。
4、注意！！Buffer中建立的链表是一个双向链表结构，所以out.head.prev等价于获取到了buffer双向链表的尾部Segment节点，随后在该尾部节点后插入新得到Segment。

下面我们最后看一个readInt方法
readInt()@Buffer.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public int readInt() {  
  2.     if (size < 4) throw new IllegalStateException(“size < 4: ” + size); //note1  
  3.     Segment segment = head;  
  4.     int pos = segment.pos;  
  5.     int limit = segment.limit;  
  6.     //note2  
  7.     if (limit - pos < 4) {  
  8.       return (readByte() & 0xff) << 24  
  9.           |  (readByte() & 0xff) << 16  
  10.           |  (readByte() & 0xff) <<  8  
  11.           |  (readByte() & 0xff);  
  12.     }  
  13.    //note3  
  14.     byte[] data = segment.data;  
  15.     int i = (data[pos++] & 0xff) << 24  
  16.         |   (data[pos++] & 0xff) << 16  
  17.         |   (data[pos++] & 0xff) <<  8  
  18.         |   (data[pos++] & 0xff);  
  19.     size -= 4;  
  20.     if (pos == limit) { //note4  
  21.       head = segment.pop();  
  22.       SegmentPool.recycle(segment);  
  23.     } else {  
  24.       segment.pos = pos;  
  25.     }  
  26.     return i; //note5  
  27.   }  
public int readInt() {
    if (size < 4) throw new IllegalStateException("size < 4: " + size); //note1
    Segment segment = head;
    int pos = segment.pos;
    int limit = segment.limit;
    //note2
    if (limit - pos < 4) {
      return (readByte() & 0xff) << 24
          |  (readByte() & 0xff) << 16
          |  (readByte() & 0xff) <<  8
          |  (readByte() & 0xff);
    }
   //note3
    byte[] data = segment.data;
    int i = (data[pos++] & 0xff) << 24
        |   (data[pos++] & 0xff) << 16
        |   (data[pos++] & 0xff) <<  8
        |   (data[pos++] & 0xff);
    size -= 4;
    if (pos == limit) { //note4
      head = segment.pop();
      SegmentPool.recycle(segment);
    } else {
      segment.pos = pos;
    }
    return i; //note5
  }
1、很明显一个int数据的字节数是4，所以必须保证当前buffer的size大于4
2、当前的Segment所包含的字节数小于4，因此还需要去下一个Segment中获取一部分数据，因此通过调用readByte()方法一字节一个字节的读取，该方法我们后面进行介绍。
3、当前的Segment数据够用，因此直接从pos位置起读取4个字节数据，然后将其转换为int数据，转换方式很简单就是进行移位和或运算
4、如果pos==limit证明当前head对应的Segment没有可读数据，因此将该Segment从双向链表中移除出去，并回收该Segment。如果还有数据则刷新Segment的pos值。
5、返回解析得到的int值

readByte()@Buffer.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public byte readByte() {  
  2.     if (size == 0) throw new IllegalStateException(“size == 0”);  
  3.     Segment segment = head;  
  4.     int pos = segment.pos;  
  5.     int limit = segment.limit;  
  6.     byte[] data = segment.data;  
  7.     byte b = data[pos++]; //note1  
  8.     size -= 1;  
  9.     if (pos == limit) { //note2  
  10.       head = segment.pop();  
  11.       SegmentPool.recycle(segment);  
  12.     } else {  
  13.       segment.pos = pos;  
  14.     }  
  15.     return b; //note3  
  16.   }  
public byte readByte() {
    if (size == 0) throw new IllegalStateException("size == 0");
    Segment segment = head;
    int pos = segment.pos;
    int limit = segment.limit;
    byte[] data = segment.data;
    byte b = data[pos++]; //note1
    size -= 1;
    if (pos == limit) { //note2
      head = segment.pop();
      SegmentPool.recycle(segment);
    } else {
      segment.pos = pos;
    }
    return b; //note3
  }
1、从当前Segment中获取一个字节数据
2、如果pos==limit证明当前head对应的Segment没有可读数据，因此将该Segment从双向链表中移除出去，并回收该Segment，如果还有数据则刷新Segment的pos值。
3、返回读到的字节数据

到此为止我们对okio的数据存储内容就介绍到这里，下面我们对Okio.buffer、Okio.source、Okio.sink这几个方法进行介绍。

Okio.class



Okio为我们提供了如下的方法获取一个Source对象：共计5个方法
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. Source source(final InputStream in) { return source(in, new Timeout());}  
  2. Source source(File file) throws FileNotFoundException{ return source(new FileInputStream(file)); }  
  3. Source source(Path path, OpenOption… options) throws IOException { return source(Files.newInputStream(path, options)); }  
  4. Source source(final Socket socket) throws IOException{   
  5.     AsyncTimeout timeout = timeout(socket);  
  6.     Source source = source(socket.getInputStream(), timeout);  
  7.     return timeout.source(source);  
  8. }  
Source source(final InputStream in) { return source(in, new Timeout());}
Source source(File file) throws FileNotFoundException{ return source(new FileInputStream(file)); }
Source source(Path path, OpenOption... options) throws IOException { return source(Files.newInputStream(path, options)); }
Source source(final Socket socket) throws IOException{ 
    AsyncTimeout timeout = timeout(socket);
    Source source = source(socket.getInputStream(), timeout);
    return timeout.source(source);
}
上面的无论参数是path、file、socket、InputStream最终都是会调用下面的方法创建一个Source对象
Source source(final InputStream in, final Timeout timeout){  }
source()@Okio.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. private static Source source(final InputStream in, final Timeout timeout) {  
  2.   if (in == null) throw new IllegalArgumentException(“in == null”);  
  3.   if (timeout == null) throw new IllegalArgumentException(“timeout == null”);  
  4.   return new Source() {  
  5.     @Override public long read(Buffer sink, long byteCount) throws IOException {  
  6.       if (byteCount < 0) throw new IllegalArgumentException(“byteCount < 0: ” + byteCount);  
  7.       if (byteCount == 0) return 0;  
  8.       timeout.throwIfReached();//note1  
  9.       Segment tail = sink.writableSegment(1); //note2  
  10.       int maxToCopy = (int) Math.min(byteCount, Segment.SIZE - tail.limit); //note3  
  11.       int bytesRead = in.read(tail.data, tail.limit, maxToCopy); //note4  
  12.       if (bytesRead == -1) return -1;  
  13.       tail.limit += bytesRead;//note5  
  14.       sink.size += bytesRead;  
  15.       return bytesRead;  
  16.     }  
  17.     @Override public void close() throws IOException {  
  18.       in.close();  
  19.     }  
  20.     @Override public Timeout timeout() {  
  21.       return timeout;  
  22.     }  
  23.     @Override public String toString() {  
  24.       return “source(“ + in + “)”;  
  25.     }  
  26.   };  
  27. }  
  private static Source source(final InputStream in, final Timeout timeout) {
    if (in == null) throw new IllegalArgumentException("in == null");
    if (timeout == null) throw new IllegalArgumentException("timeout == null");
    return new Source() {
      @Override public long read(Buffer sink, long byteCount) throws IOException {
        if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);
        if (byteCount == 0) return 0;
        timeout.throwIfReached();//note1
        Segment tail = sink.writableSegment(1); //note2
        int maxToCopy = (int) Math.min(byteCount, Segment.SIZE - tail.limit); //note3
        int bytesRead = in.read(tail.data, tail.limit, maxToCopy); //note4
        if (bytesRead == -1) return -1;
        tail.limit += bytesRead;//note5
        sink.size += bytesRead;
        return bytesRead;
      }
      @Override public void close() throws IOException {
        in.close();
      }
      @Override public Timeout timeout() {
        return timeout;
      }
      @Override public String toString() {
        return "source(" + in + ")";
      }
    };
  }
1、检查当前线程是否被中断，是否触及到了deadLine；满足任意一个条件都会抛出异常
2、从sink（Buffer对象）中获取得到可以写入一个字符的第一个Segment
3、在Segment剩余写入空间和目标写入数byteCount之间选择最小的数，结果为从InputStream读入的最大数据量。
4、从InputStream中读入最多maxToCopy数量的字节到tail.data中，写入位置为tail.limit；
5、对buffer的Segment的值进行刷新；返回读取字节数


Okio为我们提供了如下的方法获取一个Sink对象：共计6个方法
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. Sink sink(final OutputStream out) {  return sink(out, new Timeout()); }  
  2. Sink sink(File file) throws FileNotFoundException{ return sink(new FileOutputStream(file)); }  
  3. Sink appendingSink(File file) throws FileNotFoundException{ return sink(new FileOutputStream(file, true)); }  
  4. Sink sink(Path path, OpenOption… options) throws IOException{ return sink(Files.newOutputStream(path, options)); }  
  5. Sink sink(final Socket socket) throws IOException{   
  6.     AsyncTimeout timeout = timeout(socket);  
  7.     Sink sink = sink(socket.getOutputStream(), timeout);  
  8.     return timeout.sink(sink);  
  9. }  
Sink sink(final OutputStream out) {  return sink(out, new Timeout()); }
Sink sink(File file) throws FileNotFoundException{ return sink(new FileOutputStream(file)); }
Sink appendingSink(File file) throws FileNotFoundException{ return sink(new FileOutputStream(file, true)); }
Sink sink(Path path, OpenOption... options) throws IOException{ return sink(Files.newOutputStream(path, options)); }
Sink sink(final Socket socket) throws IOException{ 
    AsyncTimeout timeout = timeout(socket);
    Sink sink = sink(socket.getOutputStream(), timeout);
    return timeout.sink(sink);
}
上面的无论参数是path、file、socket、OutputStream最终都是会调用下面的方法创建一个Sink对象
Sink sink(final OutputStream out, final Timeout timeout){ }
 sink()@Okio.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public static Sink sink(final OutputStream out) {  
  2.   return sink(out, new Timeout());  
  3. }  
  4. private static Sink sink(final OutputStream out, final Timeout timeout) {  
  5.   if (out == null) throw new IllegalArgumentException(“out == null”);  
  6.   if (timeout == null) throw new IllegalArgumentException(“timeout == null”);  
  7.   return new Sink() {  
  8.     @Override public void write(Buffer source, long byteCount) throws IOException {  
  9.       checkOffsetAndCount(source.size, 0, byteCount);  
  10.       while (byteCount > 0) {  
  11.         timeout.throwIfReached();  
  12.         Segment head = source.head; //note1  
  13.         int toCopy = (int) Math.min(byteCount, head.limit - head.pos);//note2  
  14.         out.write(head.data, head.pos, toCopy); //note3  
  15.         head.pos += toCopy;//note4  
  16.         byteCount -= toCopy;  
  17.         source.size -= toCopy;  
  18.         if (head.pos == head.limit) {//note4  
  19.           source.head = head.pop();  
  20.           SegmentPool.recycle(head);  
  21.         }  
  22.       }  
  23.     }  
  24.     @Override public void flush() throws IOException {  
  25.       out.flush();  
  26.     }  
  27.     @Override public void close() throws IOException {  
  28.       out.close();  
  29.     }  
  30.     @Override public Timeout timeout() {  
  31.       return timeout;  
  32.     }  
  33.     @Override public String toString() {  
  34.       return “sink(“ + out + “)”;  
  35.     }  
  36.   };  
  37. }  
  public static Sink sink(final OutputStream out) {
    return sink(out, new Timeout());
  }
  private static Sink sink(final OutputStream out, final Timeout timeout) {
    if (out == null) throw new IllegalArgumentException("out == null");
    if (timeout == null) throw new IllegalArgumentException("timeout == null");
    return new Sink() {
      @Override public void write(Buffer source, long byteCount) throws IOException {
        checkOffsetAndCount(source.size, 0, byteCount);
        while (byteCount > 0) {
          timeout.throwIfReached();
          Segment head = source.head; //note1
          int toCopy = (int) Math.min(byteCount, head.limit - head.pos);//note2
          out.write(head.data, head.pos, toCopy); //note3
          head.pos += toCopy;//note4
          byteCount -= toCopy;
          source.size -= toCopy;
          if (head.pos == head.limit) {//note4
            source.head = head.pop();
            SegmentPool.recycle(head);
          }
        }
      }
      @Override public void flush() throws IOException {
        out.flush();
      }
      @Override public void close() throws IOException {
        out.close();
      }
      @Override public Timeout timeout() {
        return timeout;
      }
      @Override public String toString() {
        return "sink(" + out + ")";
      }
    };
  }
1、获取数据源buffer的第一个Segment
2、在Segment的可读数据和预期写入字节数之间选择一个最小值
3、将Segment的pos位置处到toCopy之间的数据写入到输出流中
4、判断Segment值是否全部读取完毕，完毕则将该Segment从buffer中移出，并将移出的Segment进行回收



RealBufferedSource.class




本节的最后我们在看看buffer(Source source)和buffer(Sink sink)这两个方法
BufferedSource buffer()@Okio.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public static BufferedSource buffer(Source source) {  
  2.     if (source == null) throw new IllegalArgumentException(“source == null”);  
  3.     return new RealBufferedSource(source);  
  4. }  
public static BufferedSource buffer(Source source) {
    if (source == null) throw new IllegalArgumentException("source == null");
    return new RealBufferedSource(source);
}
所以Okio的buffer方法实际上创建的是一个RealBufferedSource对象，下面我们看其构造器的内容


RealBufferedSource()@RealBufferedSource.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public RealBufferedSource(Source source) {  
  2.     this(source, new Buffer()); //note1  
  3. }  
  4. public RealBufferedSource(Source source, Buffer buffer) {  
  5.     if (source == null) throw new IllegalArgumentException(“source == null”);  
  6.     this.buffer = buffer;  
  7.     this.source = source;  
  8. }  
public RealBufferedSource(Source source) {
    this(source, new Buffer()); //note1
}
public RealBufferedSource(Source source, Buffer buffer) {
    if (source == null) throw new IllegalArgumentException("source == null");
    this.buffer = buffer;
    this.source = source;
}
1、通过new RealBufferedSource(source); 创建的RealBufferedSource对象，系统还会自动的给其创建一个Buffer对象。RealBufferedSource对象的创建到此为止就结束了，但是为了内容的健全，这里再对RealBufferedSource的个别方法进行简单介绍。使用RealBufferedSource对Source进行包装的目的在于，RealBufferedSource提供了很多好用的方法，如readXX，同时既然使用了BufferedSource这个名字，意味着它一次可能读取多个数据，提高I/O读写效率，因此下面我们分别看下它read方法和readInt方法。
read()@RealBufferedSource.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public long read(Buffer sink, long byteCount) throws IOException {  
  2.     if (sink == null) throw new IllegalArgumentException(“sink == null”);  
  3.     if (byteCount < 0) throw new IllegalArgumentException(“byteCount < 0: ” + byteCount);  
  4.     if (closed) throw new IllegalStateException(“closed”);  
  5.     if (buffer.size == 0) { //note1  
  6.       long read = source.read(buffer, Segment.SIZE);  
  7.       if (read == -1) return -1;  
  8.     }  
  9.     long toRead = Math.min(byteCount, buffer.size); //note2  
  10.     return buffer.read(sink, toRead); //note3  
  11. }  
public long read(Buffer sink, long byteCount) throws IOException {
    if (sink == null) throw new IllegalArgumentException("sink == null");
    if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);
    if (closed) throw new IllegalStateException("closed");
    if (buffer.size == 0) { //note1
      long read = source.read(buffer, Segment.SIZE);
      if (read == -1) return -1;
    }
    long toRead = Math.min(byteCount, buffer.size); //note2
    return buffer.read(sink, toRead); //note3
}
1、如果当前buffer为空，则通过source的read方法读取最多Segment.Size个数据。
2、从Segment.SIZE和目标读取数中取出的最小值
3、从buffer中取出上面得到的toRead个字节数据
所以RealBufferedSource的缓存机制（提高I/O读写效率的方式）为当buffer为空时从Source中读取最多2048个字节数，对于多次调用read方法读取少量的字节的情况，很可能只进行一次真实的I/O流操作，大多数情况是从buffer读取数据。

接着我们查看一下readInt方法
readInt()@RealBufferedSource.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public int readInt() throws IOException {  
  2.     require(4);  
  3.     return buffer.readInt();  
  4. }  
public int readInt() throws IOException {
    require(4);
    return buffer.readInt();
}
喂喂喂，那位同学里下巴掉了诶。对方法就是这么偷懒，RealBufferedSource结果就是调用buffer的readInt方法。不过require(4)方法第一次见，我们进入看看。
require()@RealBufferedSource.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public void require(long byteCount) throws IOException {  
  2.     if (!request(byteCount)) throw new EOFException(); //没有读到要求的数据宝宝表示不开心，后果很严重  
  3. }  
  4. public boolean request(long byteCount) throws IOException {  
  5.     if (byteCount < 0) throw new IllegalArgumentException(“byteCount < 0: ” + byteCount);  
  6.     if (closed) throw new IllegalStateException(“closed”);  
  7.     while (buffer.size < byteCount) {  
  8.       if (source.read(buffer, Segment.SIZE) == -1) return false; //note1  
  9.     }  
  10.     return true;  
  11. }  
public void require(long byteCount) throws IOException {
    if (!request(byteCount)) throw new EOFException(); //没有读到要求的数据宝宝表示不开心，后果很严重
}
public boolean request(long byteCount) throws IOException {
    if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);
    if (closed) throw new IllegalStateException("closed");
    while (buffer.size < byteCount) {
      if (source.read(buffer, Segment.SIZE) == -1) return false; //note1
    }
    return true;
}
1、底层调用source的read方法读取目标字节数到buffer中。
到此为止我们对RealBufferedSource介绍完毕。RealBufferedSource扮演的一个中间的角色，利用source读取目标字节的字节数据，存入buffer。随后又利用buffer将结果字节流数据按照要求格式进行转换输出。

RealBufferedSink.class

接着看buffer(Sink sink)这个方法。
BufferedSink buffer()@Okio.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public static BufferedSink buffer(Sink sink) {  
  2.     if (sink == null) throw new IllegalArgumentException(“sink == null”);  
  3.     return new RealBufferedSink(sink);  
  4. }  
public static BufferedSink buffer(Sink sink) {
    if (sink == null) throw new IllegalArgumentException("sink == null");
    return new RealBufferedSink(sink);
}
跟前面一样这里创建一个RealBufferedSink对象
RealBufferedSink()@RealBufferedSink.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public RealBufferedSink(Sink sink) {  
  2.     this(sink, new Buffer());  
  3. }  
  4. public RealBufferedSink(Sink sink, Buffer buffer) {  
  5.     if (sink == null) throw new IllegalArgumentException(“sink == null”);  
  6.     this.buffer = buffer;  
  7.     this.sink = sink;  
  8. }  
public RealBufferedSink(Sink sink) {
    this(sink, new Buffer());
}
public RealBufferedSink(Sink sink, Buffer buffer) {
    if (sink == null) throw new IllegalArgumentException("sink == null");
    this.buffer = buffer;
    this.sink = sink;
}
RealBufferedSink对象的创建也同样很简单，我们直接看看write方法如何实现
write()@RealBufferedSink.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public BufferedSink write(byte[] source) throws IOException {  
  2.     if (closed) throw new IllegalStateException(“closed”);  
  3.     buffer.write(source);//note1  
  4.     return emitCompleteSegments();//note2  
  5. }  
public BufferedSink write(byte[] source) throws IOException {
    if (closed) throw new IllegalStateException("closed");
    buffer.write(source);//note1
    return emitCompleteSegments();//note2
}
1、将数据写入buffer中
2、下面我们介绍其emitCompleteSegments()方法
emitCompleteSegments()@@RealBufferedSink.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public BufferedSink emitCompleteSegments() throws IOException {  
  2.     if (closed) throw new IllegalStateException(“closed”);  
  3.     long byteCount = buffer.completeSegmentByteCount(); //note1  
  4.     if (byteCount > 0) sink.write(buffer, byteCount);  
  5.     return this;  
  6. }  
public BufferedSink emitCompleteSegments() throws IOException {
    if (closed) throw new IllegalStateException("closed");
    long byteCount = buffer.completeSegmentByteCount(); //note1
    if (byteCount > 0) sink.write(buffer, byteCount);
    return this;
}
1、该方法我们前面没有介绍，不过它的结果就是buffer的size减去双向链表存储数据尾结点的可读数据大小，即除去尾结点的所有数据都写入到OutputStream流中。这样做的好处就是没必要写入几个字节就直接通过OutputStream写入，这样频繁的io会消耗的资源比较多。因为一个Segment大小为2048因此正常情况等到写数据大于2048时才会想OutputStream流中写入数据。这也就是BufferedSink的缓存机制，提高I/O读写效率的方法。
接着我们看下writeInt方法
writeInt()@RealBufferedSink.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public BufferedSink writeInt(int i) throws IOException {  
  2.     if (closed) throw new IllegalStateException(“closed”);  
  3.     buffer.writeInt(i); //note1  
  4.     return emitCompleteSegments(); //note2  
  5. }  
public BufferedSink writeInt(int i) throws IOException {
    if (closed) throw new IllegalStateException("closed");
    buffer.writeInt(i); //note1
    return emitCompleteSegments(); //note2
}
1、与RealBufferedSource很类似，这里也是通过buffer来对目标数据进行格式的转换
2、emitCompleteSegments()方法前面已经介绍过

最后我们介绍一个RealBufferedSink的flush方法
flush()@@RealBufferedSink.class
[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. public void flush() throws IOException {  
  2.     if (closed) throw new IllegalStateException(“closed”);  
  3.     if (buffer.size > 0) {  
  4.       sink.write(buffer, buffer.size);  
  5.     }  
  6.     sink.flush();  
  7.   }  
public void flush() throws IOException {
    if (closed) throw new IllegalStateException("closed");
    if (buffer.size > 0) {
      sink.write(buffer, buffer.size);
    }
    sink.flush();
  }
方法很简单就是将buffer中所有数据写入到OutputStream流中，然后调用sink的flush方法。

到此为止我们对okio的介绍就结束了，回顾一下我们学习的内容。
    首先okio的存储数据的类型ByteString，Buffer各自都维护一个byte[]数组，提供了一系列方法实现了字节序列和目标格式之间的转换。Buffer并不直接对byte[]进行操作，而是操作管理Segment对象，Buffer中有一个由多个Segment组成的双向链表，同时okio还提供了一个SegmentPool用于对废弃Segment的管理，不用的Segment并不直接丢弃而是丢入这个池中，提高了Segment的使用率。Okio中Segment的创建都是通过SegmentPool来获取的。
    okio提供的输入输出流分别为Sink Source，分别定义了write和read方法，实现对字节流的输入输出。不过客户使用一般都是对BufferedSource和BufferedSink进行操作，这两个接口定义了大量的方法用于对字节数据的编解码，同时通过该对象能有效提高I/O使用效率。
    okio中的BufferedSink和BufferedSource这两个接口很重要，okio的输入输出流分别实现了这两个接口，而且buffer也同样实现这两个接口，因此buffer的方法和okio的输入输出流有很多方法都是相同的，这一点在实际使用过程中带来了极大的便利。

 本篇是整个okhttp系列博客的完结篇。回顾一下该博客系列的内容，《OkHttp深入学习（一）——初探》对okhttp开源项目的使用方式以及经常用到的几个类进行简单学习，随后《OkHttp深入学习（二）——网络》对okhttp的网络访问底层如何实现进行分析，接着《OkHttp深入学习（三）——Cache》对okhttp的网络缓存底层如何实现进行解析，最后本篇《OkHttp深入学习（四）——0kio》对okhttp的okio子项目如何提高I/O读写效率与使用方式进行深入的分析和介绍。感谢各位的阅读！










SoMustYY
关注
专栏目录
OkHttp3 (四)——Cookie与拦截器
陈小默的博客
12-22 1万+
OkHttp3 (四)——Cookie与拦截器标签（空格分隔）： OkHttp3版本：1 作者：陈小默 声明：禁止商业，禁止转载 发布于：作业部落、[简书]、[CSDN]OkHttp3 四Cookie与拦截器 Cookie Android设备中的Cookie持久化 拦截器 取消重定向 Cookie在介绍如何使用Cookie之前，我们应该对后台的数据处理有一定的认识。由于HTTP协议无状态的特性，后台
基本使用——OkHttp3详细使用教程
热门推荐
薛瑄的博客
08-30 5万+
概述 OkHttp现在应该算是最火的Http第三方库，Retrofit底层也是使用OkHttp，网上很多教程都写的不错，但是有些我认为重要的知识，大多一笔带过，所以我决定写一篇入门文章 OkHttp官网地址：http://square.github.io/okhttp/ OkHttp GitHub地址：https://github.com/square/okhttp 出现背景 网络...
OkHttp解析（三）关于Okio
QG
08-31 1347
OkHttp解析（三）关于Okio
OkHttp源码解析（三）
lihuanxing的博客
10-11 216
上一篇我们讲到拦截器链，还讲解了前两个拦截器RetryAndFollowUpInterceptor和BridgeInterceptor，今天我们要讲解的是CacheInterceptor-----缓存拦截器。 首先我们看看它是如何使用缓存的： OkHttpClient okHttpClient = new OkHttpClient.Builder() .cache(new Cach...
Okhttp 之 okio
不惜留恋_
04-04 5704
本文是的前一篇文章 Okhttp IO 之 Segment &amp; SegmentPool 的基础上写的，如果你没看懂前面的文章，那么看本文会相当的吃力，因为很多关键的代码都是在前面这篇文章中剖析的。 ByteString okio 中添加一个类 ByteString，顾名思义就是字节串，这里做一个概要的讲解，具体的实现大家可以去看源码。 既然是字节串，它内部就是用一个字节数组支持的。 ...
都看OkHttp的源码，Okio的源码你看过吗？，php的软件
最新发布
kOS0ym的博客
04-08 899
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**
Android——okhttp的封装
11-06
Android——okhttp的封装,Android——okhttp的封装,Android——okhttp的封装,Android——okhttp的封装,Android——okhttp的封装
Android实战——okhttp3的使用和封装
05-22
本文将深入探讨OkHttp3的使用和封装，旨在帮助开发者更好地理解和掌握这一强大的网络请求工具。 首先，让我们了解OkHttp的基本概念。OkHttp是由Square公司开发的，它提供了一个高效的HTTP客户端接口，具有缓存、...
自己整理的OkHttp工具——留存用
04-27
OkHttp 是一个高效的 HTTP 客户端库，由 Square 公司开发，广泛应用于 Android 和 Java 开发中。它提供了一种简单的方式来发起网络请求，处理...通过深入理解和合理使用 OkHttp，可以显著提升应用程序的网络通信体验。
【No buffer space available】异常解决
一亩三分地
10-27 4万+
最近在工作中遇到这样一个场景：使用一个Java编写的模拟硬件设备的工具，这个工具会模拟很多设备（每个设备需要占用一个端口）去连接服务器。一般情况下，一台Windows虚拟机上会模拟5000至10000个设备，这样一般不会有问题。后来改成模拟40000个设备的时候，出现了“No buffer space available”的异常，具体如下： 1. 问题原因 乍一看以为是虚拟机内存不够或者是模拟工...
No buffer space available (maximum connections reached?)问题的最终解决
shenxiaomo1688的博客
01-15 2万+
前段时间在项目维护当中遇见一个问题，方便以后再次遇见类似的问题，可以参考解决问题的思路，记录如下： 问题概述： 维护项目当中，客户这边发来消息，称自己的网站登录不上去了，提示用户名密码错误，我就登录到服务器上查看系统日志和报错情况，如图： 这个异常来源部署的一个jar包，用于读取数据存入mongodb，再看了Tomcat也报错了，错误是：java.net.SocketException。...
okhttp工具类之获取请求和响应内容
sinat_28332517的博客
12-18 2628
okhttp3 获取requestBody和ResponseBody中的数据工具类
okio读写流源码详解（第一篇（缓存BufferedSink 写入流程详解））
xiatiandefeiyu的博客
09-13 8398
首先贴一下牛逼的Square公司开源的框架地址Square开源框架，okio帮助文档地址：okio的api地址。 看文档的截图发现类不是很多，瞬间感觉很轻松有木有，看源码的规则就是首先你得会用，会用了，那么就会知道入口函数在哪，然后一步一步的剖析代码 Sink：此接口负责写数据。 public interface Sink extends Closeable, Flush
Android Okhttp之Okio解析
android信徒
12-31 1万+
背景网络在Android中的重要性那是自然的，Android的HttpUrlconnection和Apach的HttpClientokio已经不能够满足Android的需求，Okio作为okhttp的io组件整个项目的规模不是很大，大神代码的质量也很高，是学习源码的良好素材，也为学习okhhtp奠定一些基础。okio简单使用1.1 okio的几种使用 代码开源项目，作者的测试源代码，使用了jun
Okhttp解析（3.10.0）
chen_white的博客
03-28 2929
Okhttp（3.10.0） 目录 简介 主要类 流程分析 请求 构建 拦截器 请求体数据结构 表单形式 文件形式 简介 SSL与TLS SSL — Secure Sockets Layer(安全套接层) TLS — Transport Layer Security(传输层安全协议) SSL 协议，为了解决HTTP协议是明文，...
OkHttp的作用_为什么要使用OkHttp？(笔记)
qq_43842093的博客
05-16 1574
OkHttp is an HTTP client。 如果是HTTP的方式想得到数据，就需要我们在页面上输入网址，如果网址没有问题，就有可能返回对应的String字符串，如果这个地址是返回字符串的话。 OkHttp是在idea代码中，通过调用它里边的方法，就可以实现调用该url，并将结果返回。 用大白话解释，就是你提供一个url地址，以及地址的参数，通过客户端Httpclient可以实现对该url地址进行调用，返回相对应的结果。 当然，这个地址是一个可以有实际返回的地址，就相当于一个接口，通过访问接口的路径，
Android OkHttp完全解析 是时候来了解OkHttp了
dawuafang
08-24 2423
转载请标明出处： http://blog.csdn.net/lmj623565791/article/details/47911083； 本文出自:【张鸿洋的博客】 一、概述 最近在群里听到各种讨论okhttp的话题，可见okhttp的口碑相当好了。再加上Google貌似在6.0版本里面删除了HttpClient相关API，对于这个行为不做评价。为了更好的在应对网络访问，学...
OkHttp拦截器深入解析与应用
资源摘要信息:"五大拦截器资料.zip" OkHttp是一款流行的HTTP客户端，广泛用于Android应用中进行网络请求。...在OkHttp的版本更新中，拦截器机制可能会有所调整，因此开发者需要关注OkHttp的官方文档来获取最新的信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值