Okio好在哪里？【后篇】

/**
* 构造带缓冲的输入流
*/
Source source = null;
BufferedSource bufferedSource = null;
source = Okio.source(new File('yourFilePath'));
bufferedSource = Okio.buffer(source);

/**
* 构造带缓冲的输出流
*/
Sink sink = null;
BufferedSink bufferedSink = null;
sink = Okio.sink(new File('yourSaveFilePath'));
sink = Okio.buffer(sink);

int bufferSize = 8 * 1024; // 8kb

// 复制文件
while (!bufferedSource.exhausted()){
// 从输入流读取数据到输出流缓冲
bufferedSource.read(
bufferedSink.buffer(),
bufferSize
);
// 输出流缓冲写出
bufferedSink.emit();
}

source.close();
sink.close();

@Override
public long read(Buffer sink, long byteCount) throws IOException {
// 用来接收数据的Buffer 不能为空
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) {
// 从输入流中读取数据
long read = source.read(buffer, Segment.SIZE);
if (read == -1) return -1;
}

// 比较 byteCount 与 缓冲中的数据容量，得到到实际要读取的数据量
long toRead = Math.min(byteCount, buffer.size);
// 从Buffer 中读取数据
return buffer.read(sink, toRead);
}

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');
// 匿名内部类Source
return new Source() {
@Override public long read(Buffer sink, long byteCount) throws IOException {
// 获取的byteCount不能为负数
if (byteCount < 0) throw new IllegalArgumentException('byteCount < 0: ' + byteCount);
if (byteCount == 0) return 0;
try {
// 检查是否超时
timeout.throwIfReached();
// 获取尾节点的Segment，尾节点不满足填充新数据条件则拿到新的Segment
// 也是位于尾节点
Segment tail = sink.writableSegment(1);
// 实际从in读取的数据，能看出最大不能超过 Segment.SIZE
int maxToCopy = (int) Math.min(byteCount, Segment.SIZE - tail.limit);
// 从in中读取数据到Segment.data
int bytesRead = in.read(tail.data, tail.limit, maxToCopy);
// 这里说明没有读到有效数据
if (bytesRead == -1) return -1;
// 更新索引位置
tail.limit += bytesRead;
// 更新buffer容量
sink.size += bytesRead;
return bytesRead;
} catch (AssertionError e) {
if (isAndroidGetsocknameError(e)) throw new IOException(e);
throw e;
}
}
......
};
}

@Override
public long read(Buffer sink, long byteCount) {
// 用来接收数据的sink不能为空
if (sink == null) throw new IllegalArgumentException('sink == null');
// 接收的数据大小不能为负数
if (byteCount < 0) throw new IllegalArgumentException('byteCount < 0: ' + byteCount);
if (size == 0) return -1L;
// 读取的数据不超过当前缓冲区的容量
if (byteCount > size) byteCount = size;
// 从当前缓冲区，将数据写入到另一缓冲区，即从 this，写到sink
sink.write(this, byteCount);
return byteCount;
}

@Override
public void write(Buffer source, long byteCount) {
if (source == null) throw new IllegalArgumentException('source == null');
if (source == this) throw new IllegalArgumentException('source == this');
checkOffsetAndCount(source.size, 0, byteCount);

/**
缓冲区数据从 缓冲区source 移动到 缓冲区this，
在当前的案例中，缓冲区source代表输入流缓冲数据，缓冲区this代表输出流缓冲数据
此函数源码内部有一大段注释，可以细细品味，我就不贴了
*/

while (byteCount > 0) {

if (byteCount < (source.head.limit - source.head.pos)) {
// 进到这里说明，说明source的头节点有足够的数据

// 获取当前缓冲区尾节点
Segment tail = head != null ? head.prev : null;
if (tail != null && tail.owner
&& (byteCount + tail.limit - (tail.shared ? 0 : tail.pos) <= Segment.SIZE)) {
// 尾节点不为空，并且尾可解是owner状态
// 并且尾节点能够装下byteCount数量的数据

// 将数据从source的头节点 copy 到 当前缓冲区的尾节点
source.head.writeTo(tail, (int) byteCount);
source.size -= byteCount;
size += byteCount;
return;
} else {
// 说明数据当前缓冲区尾节点不能存下byteCount大小的数据
// 将source头节点的Segment分割，byteCount过阀值则共享，否则拷贝
// 共享过程则不用copy
source.head = source.head.split((int) byteCount);
}
}

/**
将source缓冲区的头节点pop，加入到当前缓冲区
*/
Segment segmentToMove = source.head;
long movedByteCount = segmentToMove.limit - segmentToMove.pos;
source.head = segmentToMove.pop();
if (head == null) {
// 进到这里说明当前缓冲区没有数据，将segmentToMove作为头节点
head = segmentToMove;
head.next = head.prev = head;
} else {
// 进到这里则是将segmentToMove放到链表尾部
Segment tail = head.prev;
tail = tail.push(segmentToMove);
tail.compact();
}
/**
更新缓冲区大小，已经还需的byteCount数量
*/
source.size -= movedByteCount;
size += movedByteCount;
byteCount -= movedByteCount;
}
}