okio篇2-RealBufferedSource

上一篇讲过，okio只有两个概念，source和sink。source对应InputStream，即负责将数据读出，是一个输出方（所以只有source.read方法）。sink对应outputStream，负责获取数据写入，是一个写入方（所以只有sink.write方法）。而对于，source.read(sink)这个方法，实际就是，将source中的数据读出，写入到sink当中。

所以其实source和sink只有数据的流向不一致。所以，这里只介绍了RealBufferedSource，实际是跟RealBufferedSink是一致的。

介绍RealBufferedSource，首先先看下okio的基础用法。

public void readFileUseOkIo() {
    try {
        BufferedSource source = Okio.buffer(Okio.source(new File(fileName)));
        String content;
        while ((content = source.readUtf8Line()) != null) {
            System.out.println("readFileUseOkIo content:"+content);
        }
        source.close();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

注意，一般对应okio，只有两个常用的api，okio.source和okio.buffer方法。

这一行的实际含义是：

创建new File，内部创建new FileInputStream，作为source对应的inputStream。

再调用buffer，将source传入RealBufferedSource。RealBufferedSource同时维护一个Buffer，和一个Source。

Okio.source

source方法接收一个InputStream。并返回一个新创建的Source，重写了read(Buffer,long)方法。

这个方法在哪里会被调用到呢？后面会讲到。先记住source方法实际是重写了read(Buffer,long)方法。

// Okio.Source
private static Source source(final InputStream in, final Timeout timeout) {
    if (in == null) {
        throw new IllegalArgumentException("in == null");
    } else if (timeout == null) {
        throw new IllegalArgumentException("timeout == null");
    } else {
        return new Source() {
            // 这里实际上，是从source中的buffer转移数据到sink当中，如果source中没有数据了，
            // 就从in中读取数据到source中的buffer
            public long read(Buffer sink, long byteCount) throws IOException {
                if (byteCount < 0L) {
                    throw new IllegalArgumentException("byteCount < 0: " + byteCount);
                } else if (byteCount == 0L) {
                    return 0L;
                } else {
                    try {
                        timeout.throwIfReached();
                        // 从sink中获取一个可写的segment
                        Segment tail = sink.writableSegment(1);
                        int maxToCopy = (int)Math.min(byteCount, (long)(8192 - tail.limit));
                        // 从in中获取tail中可容纳的空间个字节到tail中
                        int bytesRead = in.read(tail.data, tail.limit, maxToCopy);
                        if (bytesRead == -1) {
                            return -1L;
                        } else {
                            tail.limit += bytesRead;
                            sink.size += (long)bytesRead;
                            return (long)bytesRead;
                        }
                    } catch (AssertionError var7) {
                        if (Okio.isAndroidGetsocknameError(var7)) {
                            throw new IOException(var7);
                        } else {
                            throw var7;
                        }
                    }
                }
            }

            public void close() throws IOException {
                in.close();
            }

            public Timeout timeout() {
                return timeout;
            }

            public String toString() {
                return "source(" + in + ")";
            }
        };
    }
}

Okio.buffer

// Okio.buffer方法
public static BufferedSource buffer(Source source) {
    return new RealBufferedSource(source);
}

Okio.buffer方法，只简单返回了RealBufferSource方法。

RealBufferedSource实际上是一个Source类型，内部维护了一个Buffer和一个Source。这个Source参数，实际就是刚才okio.source方法新创建的new Source，这个source重写了read(Buffer,long)方法。

// RealBufferedSource.read
// 两个Buffer之间转移，比如Source.read(Sink,byteCount)的时候，会调用这个方法
public long read(Buffer sink, long byteCount) throws IOException {
    if (sink == null) {
        throw new IllegalArgumentException("sink == null");
    } else if (byteCount < 0L) {
        throw new IllegalArgumentException("byteCount < 0: " + byteCount);
    } else if (this.closed) {
        throw new IllegalStateException("closed");
    } else {
        long read;
        if (this.buffer.size == 0L) {// 从这里看出，实际就是先从source读Segment.Size个字节的数据到buffer
        // 注意这里，这里实际是okio.source方法那里重写的read方法
        // 即这里，如果buffer内数据为空，就会调用stream.read方法，将数据读到buffer，即RealBufferedSource也是一个缓冲区。
            read = this.source.read(this.buffer, 8192L);
            if (read == -1L) {
                return -1L;
            }
        }

        read = Math.min(byteCount, this.buffer.size);
        // 然后再从buffer读取read个字节的数据到sink。一次最多只读取一个Segment的数据
        return this.buffer.read(sink, read);
    }
}

RealBufferedSource方法也重写了read(Buffer,long)。这个方法一般用于buffer间的数据交互，比如source的buffer数据，转移到sink的buffer中。

从上面的注释可以看出：

RealBufferSource中持有Source(Stream)和Buffer，Buffer相当于Source的缓冲区，Sink直接跟Buffer进行数据交互。当Buffer中数据被读取完了，Buffer会从Source中读数据。

也即：

总结

okio对外暴露的接口：okio.source和okio.buffer。

其中okio.source，构建了stream到buffer的数据流向。

而okio.buffer，创建了RealBufferedSource。RealBufferedSource维护一个buffer。当需要将数据传给sink的时候，优先从buffer中读取数据到sink。如果buffer为空，就会调用okio.source的方法，从stream中读取数据到buffer。