前言
其實接觸Square的這款IO框架還是因為okHttp這個網路框架，因為他的網路IO是通過OKio來完成的。不過，對於Java原生IO體系我卻是早已心懷不滿。基本上我很排斥寫Java的IO部分，因為寫起來很麻煩和笨重，有多排斥呢？
我記得大學那會兒，準備寫一個編譯器，在讀取程式碼的那個IO部分用的python來完成的，然後在Java層來接收字元。
我就是這麼不喜歡Java原生IO體系。
我一直都想自己對Java IO的API做一個徹底的封裝，和原生IO介面來個了斷，結果一直因為各種原因沒去做。在瞭解了OKio之後，就更加沒有動力去封裝原生介面了。
今天藉著這個機會，向大家介紹這個短小精悍的IO框架，順便也和大家探討一下封裝的相關問題，希望通過這篇文章，大家能夠樂於放棄原生的IO介面，轉而使用這款IO框架來作為自己日常開發的工具。
原生IO：沒那麼簡單
在聊OKio之前，我們還是先複習一下Java原生IO體系。
下面是Java IO輸入部分的架構
需要說明的是，以上並不是Java IO框架的全部，只是例舉一些大家可能有印象的類，並且省去了很多繼承自這些類的的子類。看一看上面的結構圖，你就知道什麼叫複雜了。觀察上圖，我們至少可以吐槽以下幾點：
- IO介面的實現類太多
- 每個類基本對應一種IO需求，導致它的體系十分龐大
當然,Java中出現這種龐大的IO體系是有它的歷史原因的，這是使用裝飾者模式來構建和擴充的Java IO體系的必然結果。因此我們也不必過分苛責。
OKio：就是這麼簡單
說完了Java原生IO介面的種種問題之後，我們可以開始來聊一聊OKio這個框架了。那麼，它到底是一種什麼樣的框架呢？
俗話說得好， 文字定義終覺淺，絕知此事要上圖
從上面可以看到，其實OKio是對於Java原生IO介面的一次封裝。一次成功的封裝。
那麼，在OKio 的幫助下，完成一次讀寫操作又是怎樣的呢？
// 寫入資料
String fileName="test.txt";
String path= Environment.getExternalStorageDirectory().getPath();
File file=null;
BufferedSink bufferSink=null;
try{
file=new File(path,fileName);
if (!file.exists()){
file.createNewFile();
}
bufferSink=Okio.buffer(Okio.sink(file));
bufferSink.writeString("this is some thing import
", Charset.forName("utf-8"));
bufferSink.writeString("this is also some thing import
", Charset.forName("utf-8"));
bufferSink.close();
}catch(Exception e){
}
//讀取資料
try {
BufferedSource bufferedSource=Okio.buffer(Okio.source(file));
String str=bufferedSource.readByteString().string(Charset.forName("utf-8"));
Log.e("TAG","--->"+str);
} catch (Exception e) {
e.printStackTrace();
}複製程式碼以上是我隨手寫的一個檔案的寫入和讀取操作，可以看到，整個過程其實是非常簡單的，不過這並不是重點，重點是寫入和讀取的方式和資料型別都十分的靈活，
是的，十分靈活。
比如，讀取資料可以很輕鬆的一行一行的讀取：
//一行一行的讀出資料
try {
BufferedSource bufferedSource=Okio.buffer(Okio.source(file));
Log.e("TAG-string","--->"+bufferedSource.readUtf8Line());
Log.e("TAG-string","--->"+bufferedSource.readUtf8Line());
Log.e("TAG-string","--->"+bufferedSource.readUtf8Line());
bufferedSource.close();
} catch (Exception e) {
e.printStackTrace();
}複製程式碼再比如，你可以直接讀寫Java資料型別等等，可以說，OKio非常優雅的滿足了Java IO的絕大部分需求。卻有沒有Java原生IO的繁瑣。
OKio詳解
上文寫的一些例項程式碼解釋不多，當你仔細的瞭解了OKio這個框架之後，你就會理解上面每一行示例程式碼所代表的意思。
好了，我們還是從這張圖來切入
上面可以看到，實際上Sink和Source是OKio中的最基本的介面，大概相當於OutputStream和InputStream在原生介面中的地位。
我們以輸出相關的Sink介面為例
public interface Sink extends Closeable, Flushable {
//通過緩衝區寫入資料
void write(Buffer source, long byteCount) throws IOException;
//重新整理 （緩衝區）
@Override void flush() throws IOException;
//超時機制
Timeout timeout();
//關閉寫操作
@Override void close() throws IOException;
}複製程式碼上面的寫入操作最基礎的介面，當然，你看到了Buffer和flush()這個方法，這也就意味著寫入操作很可能是圍繞緩衝區來進行的，事實上確實是這樣，我們往後看。
Sink下面一層介面是BufferedSink：
public interface BufferedSink extends Sink {
Buffer buffer();
BufferedSink write(ByteString byteString) throws IOException;
BufferedSink write(byte[] source) throws IOException;
BufferedSink write(byte[] source, int offset, int byteCount) throws IOException;
long writeAll(Source source) throws IOException;
BufferedSink write(Source source, long byteCount) throws IOException;
BufferedSink writeUtf8(String string) throws IOException;
BufferedSink writeUtf8(String string, int beginIndex, int endIndex) throws IOException;
BufferedSink writeUtf8CodePoint(int codePoint) throws IOException;
BufferedSink writeString(String string, Charset charset) throws IOException;
BufferedSink writeString(String string, int beginIndex, int endIndex, Charset charset)
throws IOException;
BufferedSink writeByte(int b) throws IOException;
BufferedSink writeShort(int s) throws IOException;
BufferedSink writeShortLe(int s) throws IOException;
BufferedSink writeInt(int i) throws IOException;
BufferedSink writeIntLe(int i) throws IOException;
BufferedSink writeLong(long v) throws IOException;
BufferedSink writeLongLe(long v) throws IOException;
BufferedSink writeDecimalLong(long v) throws IOException;
BufferedSink writeHexadecimalUnsignedLong(long v) throws IOException;
BufferedSink emitCompleteSegments() throws IOException;
BufferedSink emit() throws IOException;
OutputStream outputStream();
}複製程式碼其實上面的介面也很明瞭，就是在基本介面的基礎上，定義各式各樣的寫入方式。
真正實現上面這些介面的類則是RealBufferedSink,我摘取部分程式碼作為說明
final class RealBufferedSink implements BufferedSink {
//例項化一個緩衝區，用於儲存需要寫入的資料。
public final Buffer buffer = new Buffer();
public final Sink sink;
boolean closed;
RealBufferedSink(Sink sink) {
if (sink == null) throw new NullPointerException("sink == null");
this.sink = sink;
}
@Override public Buffer buffer() {
return buffer;
}
//通過緩衝區把ByteString型別的資料寫入
@Override public BufferedSink write(ByteString byteString) throws IOException {
if (closed) throw new IllegalStateException("closed");
buffer.write(byteString);
//完成寫入
return emitCompleteSegments();
}
//通過緩衝區把String型別的資料寫入
@Override public BufferedSink writeString(String string, Charset charset) throws IOException {
if (closed) throw new IllegalStateException("closed");
buffer.writeString(string, charset);
return emitCompleteSegments();
}
...
...
//通過緩衝區把byte陣列中的資料寫入
@Override public BufferedSink write(byte[] source, int offset, int byteCount) throws IOException {
if (closed) throw new IllegalStateException("closed");
buffer.write(source, offset, byteCount);
//完成寫入
return emitCompleteSegments();
}
//完成寫入
@Override public BufferedSink emitCompleteSegments() throws IOException {
if (closed) throw new IllegalStateException("closed");
long byteCount = buffer.completeSegmentByteCount();
if (byteCount > 0) sink.write(buffer, byteCount);
return this;
}
...
...
...
}複製程式碼ByteString內部可以儲存byte型別的資料，作為一個工具類，它可以把byte轉為String，這個String可以是utf8的值，也可以是base64後的值，也可以是md5的值等等
上面只是一部分嗎的程式碼，但是大家也能看到buffer這個變數反覆出現，而且深度參與了寫入資料的過程，我們可以一起去看看,著重看上面涉及到的幾個方法
public final class Buffer implements BufferedSource, BufferedSink, Cloneable {
private static final byte[] DIGITS =
{ `0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `a`, `b`, `c`, `d`, `e`, `f` };
static final int REPLACEMENT_CHARACTER = `ufffd`;
Segment head;
long size;
public Buffer() {
}
/** Returns the number of bytes currently in this buffer. */
public long size() {
return size;
}
//寫入String型別的資料
@Override
public Buffer writeString(String string, Charset charset) {
//呼叫下面的方法
return writeString(string, 0, string.length(), charset);
}
//準備寫入String資料
@Override
public Buffer writeString(String string, int beginIndex, int endIndex, Charset charset) {
if (string == null) throw new IllegalArgumentException("string == null");
if (beginIndex < 0) throw new IllegalAccessError("beginIndex < 0: " + beginIndex);
if (endIndex < beginIndex) {
throw new IllegalArgumentException("endIndex < beginIndex: " + endIndex + " < " + beginIndex);
}
if (endIndex > string.length()) {
throw new IllegalArgumentException(
"endIndex > string.length: " + endIndex + " > " + string.length());
}
if (charset == null) throw new IllegalArgumentException("charset == null");
//假如是utf-8編碼的資料，則呼叫writeUtf8（）
if (charset.equals(Util.UTF_8)) return writeUtf8(string, beginIndex, endIndex);
//否則，將String轉化為byte型別的資料
byte[] data = string.substring(beginIndex, endIndex).getBytes(charset);
//然後執行write()，寫入byte陣列
return write(data, 0, data.length);
}
//offset：寫入資料的陣列下標起點，
//byteCount ：寫入資料的長度
@Override
public Buffer write(byte[] source, int offset, int byteCount) {
if (source == null) throw new IllegalArgumentException("source == null");
//做一些檢查工作
checkOffsetAndCount(source.length, offset, byteCount);
int limit = offset + byteCount;
//開始迴圈寫入資料
while (offset < limit) {
//Segment？？黑人問號臉？？
//我們不妨把Segment先看成一種類似陣列結構的容器
//這個方法就是獲取一個資料容器
Segment tail = writableSegment(1);
// limit - offset是代寫入的資料的長度
// Segment.SIZE - tail.limit是這個容器剩餘空間的長度
int toCopy = Math.min(limit - offset, Segment.SIZE - tail.limit);
//呼叫Java方法把資料複製到容器中。
System.arraycopy(source, offset, tail.data, tail.limit, toCopy);
//記錄相關偏移量
offset += toCopy;
tail.limit += toCopy;
}
//增加buffer的size
size += byteCount;
return this;
}
//獲取一個Segment
Segment writableSegment(int minimumCapacity) {
if (minimumCapacity < 1 || minimumCapacity > Segment.SIZE) throw new IllegalArgumentException();
if (head == null) {
假如當前Segment為空，則從Segment池中拿到一個
head = SegmentPool.take(); // Acquire a first segment.
return head.next = head.prev = head;
}
//獲取當前Segment的前一個Segment
//看來這是一個連結串列結構沒跑了
Segment tail = head.prev;
//檢查這個Segment容器是否有剩餘空間可供寫入
if (tail.limit + minimumCapacity > Segment.SIZE || !tail.owner) {
//假如沒有，則拿一個新的的Segment來代替這個（即連結串列的下一個）
tail = tail.push(SegmentPool.take()); // Append a new empty segment to fill up.
}
return tail;
}
}複製程式碼好了，現在我們基本上揭開了OKio框架中隱藏的最重要的一個東西，資料快取機制，主要包括Buffer，Segment,SegmentPool，
後兩者主要集中在Buffer類中運用，資料是通過Buffer寫入一個叫Segment容器中的。
關於SegmentPool,其實它的存在很簡單，儲存暫時不用的資料容器，防止頻繁GC，基本上所有的XX池的作用的是這樣，防止已申請的資源被回收，增加資源的重複利用，提高效率，減少GC,避免記憶體抖動….
關於Segment，我們已經知道它是一個資料容器，而且是一個連結串列結構，根據它有prev和next兩個引用變數可以推測，其實它是一個雙向連結串列，為了照顧某些資料結構比較弱的同學，特意畫了一下
大概就是這個樣子。下面我們在深入去了解這個Segment的程式碼細節
final class Segment {
/** The size of all segments in bytes. */
static final int SIZE = 8192;
/** Segments will be shared when doing so avoids {@code arraycopy()} of this many bytes. */
static final int SHARE_MINIMUM = 1024;
//segment中儲存資料的陣列
final byte[] data;
/** The next byte of application data byte to read in this segment. */
int pos;
/** The first byte of available data ready to be written to. */
int limit;
/** True if other segments or byte strings use the same byte array. */
boolean shared;
/** True if this segment owns the byte array and can append to it, extending {@code limit}. */
boolean owner;
/** Next segment in a linked or circularly-linked list. */
Segment next;
/** Previous segment in a circularly-linked list. */
Segment prev;
Segment() {
this.data = new byte[SIZE];
this.owner = true;
this.shared = false;
}
Segment(Segment shareFrom) {
this(shareFrom.data, shareFrom.pos, shareFrom.limit);
shareFrom.shared = true;
}
//建立一個Segment
Segment(byte[] data, int pos, int limit) {
this.data = data;
this.pos = pos;
this.limit = limit;
this.owner = false;
this.shared = true;
}
//從連結串列中移除一個segment
/**
* Removes this segment of a circularly-linked list and returns its successor.
* Returns null if the list is now empty.
*/
public Segment pop() {
Segment result = next != this ? next : null;
prev.next = next;
next.prev = prev;
next = null;
prev = null;
return result;
}
//從連結串列中新增一個segment
/**
* Appends {@code segment} after this segment in the circularly-linked list.
* Returns the pushed segment.
*/
public Segment push(Segment segment) {
segment.prev = this;
segment.next = next;
next.prev = segment;
next = segment;
return segment;
}
//下面這些方法主要是在Segment內部做一些儲存的優化用的
/**
* Splits this head of a circularly-linked list into two segments. The first
* segment contains the data in {@code [pos..pos+byteCount)}. The second
* segment contains the data in {@code [pos+byteCount..limit)}. This can be
* useful when moving partial segments from one buffer to another.
*
* <p>Returns the new head of the circularly-linked list.
*/
public Segment split(int byteCount) {
...
...
...
}
/**
* Call this when the tail and its predecessor may both be less than half
* full. This will copy data so that segments can be recycled.
*/
public void compact() {
...
...
...
}
/** Moves {@code byteCount} bytes from this segment to {@code sink}. */
public void writeTo(Segment sink, int byteCount) {
...
...
...
}
}複製程式碼其實整體來看，Segment的結構還是非常簡單的。SegmentPool我們也可以順手看了,因為也很簡單
final class SegmentPool {
/** The maximum number of bytes to pool. */
// TODO: Is 64 KiB a good maximum size? Do we ever have that many idle segments?
static final long MAX_SIZE = 64 * 1024; // 64 KiB.
/** Singly-linked list of segments. */
static Segment next;
/** Total bytes in this pool. */
static long byteCount;
private SegmentPool() {
}
//獲取一個閒置的Segment
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.
}
//回收一個閒置的Segment
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;
}
}
}複製程式碼SegmentPool是通過一個單向的連結串列結構構成的池，你問我為啥他不用雙向連結串列？因為沒必要，Segment池中所有閒置的物件都是一樣的，只要保證每次能從其中獲取到一個物件即可，因此不必用雙向連結串列結構來實現。
那麼Segment中使用雙向連結串列的結構來構造節點是為什麼呢？那是因為使用雙向連結串列結構的話，資料的複製和轉移，以及Segment內部做相關的優化都十分方便和高效。
好了，我們現在可以理一理了，在RealBufferedSink這個實現類中，資料從以各種形式寫入到其Buffer裡，而Buffer通過Segment和SegmentPool來管理這些快取的資料，目前為止，資料還沒有真正寫入到檔案中，只是儲存在快取裡，
那麼資料真正寫入檔案是在什麼時候呢？
答案是在Close()方法中,我們可以看看RealBufferedSink這個類的close()方法
//每次寫入完，我們會呼叫close（）方法，最終都會呼叫到這裡
@Override public void close() throws IOException {
//如果已經關閉，則直接返回
if (closed) return;
// Emit buffered data to the underlying sink. If this fails, we still need
// to close the sink; otherwise we risk leaking resources.
Throwable thrown = null;
try {
//只要buffer中有資料，就一次性寫入
if (buffer.size > 0) {
sink.write(buffer, buffer.size);
}
} catch (Throwable e) {
thrown = e;
}
try {
sink.close();
} catch (Throwable e) {
if (thrown == null) thrown = e;
}
closed = true;
if (thrown != null) Util.sneakyRethrow(thrown);
}複製程式碼sink.write(buffer, buffer.size);這個方法才是真正的寫入資料到檔案，這個sink只是一個介面，那麼它的實現類在哪裡呢？
我們在回看最開頭關於寫入資料的示例程式碼：
String fileName="test.txt";
String path= Environment.getExternalStorageDirectory().getPath();
File file=null;
BufferedSink bufferSink=null;
try{
file=new File(path,fileName);
if (!file.exists()){
file.createNewFile();
}
//這是非常關鍵的一步，Okio.sink(file)就是建立Sink的實現類
bufferSink=Okio.buffer(Okio.sink(file));
bufferSink.writeString("this is some thing import
", Charset.forName("utf-8"));
bufferSink.writeString("this is also some thing import
", Charset.forName("utf-8"));
bufferSink.close();
}catch(Exception e){
}複製程式碼我們在進入OKio類中看看這個sink(file)方法：
//會往下呼叫
/** Returns a sink that writes to {@code file}. */
public static Sink sink(File file) throws FileNotFoundException {
if (file == null) throw new IllegalArgumentException("file == null");
//構建一個輸出流
return sink(new FileOutputStream(file));
}
//會往下呼叫
/** Returns a sink that writes to {@code out}. */
public static Sink sink(OutputStream out) {
return sink(out, new Timeout());
}
//在這裡建立一個sink的實現類
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;
int toCopy = (int) Math.min(byteCount, head.limit - head.pos);
//最後使用的依然是Java 原生的api來實現資料的真正寫入
out.write(head.data, head.pos, toCopy);
head.pos += toCopy;
byteCount -= toCopy;
source.size -= toCopy;
if (head.pos == head.limit) {
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 + ")";
}
};
}複製程式碼好了，關於資料寫入，整個來龍去脈我們基本上都講完了。
讀取的過程以此類推，先讀入快取區，在從快取區中讀，沒有太大的區別。
總結
我們可以再回顧一下：
- 通過外部傳入File,Socket，或者OutputStream型別來構建一個輸入流
- OKio內部建立一個快取區，並返回一個BufferSink
- 通過這個BufferSink來實現寫入各種資料，實際上都存入了快取區
- 最終呼叫close()方法，一次定把快取區的資料寫入到檔案中
雖然它內部對於資料型別的轉換，資料快取的優化我並沒有提到，但是也無傷大雅，因為只要你；理解了它的緩衝區的設計，那麼這個IO框架的優點和高效的地方就一目瞭然了；當然，OKio也號稱能高效的使用NIO來進行讀寫，不過客戶端基本上用不上這樣的功能，所以也不做考究。
我們再回過頭來看OKio的框架，就可以明白一些事情，為什麼他可以這麼簡單的實現多種資料型別的讀寫？原因就在於它實現了一個快取區，整個IO是基於快取的。我們的操作都是針對快取區的，所以可以非常靈活的實現多種資料型別的讀寫。而我們也看到，最終資料還是通過位元組流寫入到了檔案。
我不知道你從中是否看到了什麼關於封裝的一些東西，不過我倒是有幾分感觸想分享給大家。
封裝並不應該僅僅侷限於把幾步重複的程式碼放在一個方法裡然後統一呼叫，更多的時候，我們應該思考原來框架的缺陷，以解決這些缺陷為目的進行封裝，如果在原來的架構上難以解決，則應該在適當的時候往前跨一步，跳出原來框架的侷限。
有的時候，一次成功的封裝，相當於一次完美的重構。
後記
去年年末沒有湊熱鬧發《年度總結》，所以沒機會祝大家新年快樂，在這裡祝大家新的一年裡工作順利
！！
勘誤
暫無