Android Okio

转自： Android 善用Okio简化处理I/O操作

Okio库是一个由square公司开发的，它补充了Java.io和java.nio的不足，以便能够更加方便，快速的访问、存储和处理你的数据。而OkHttp的底层也使用该库作为支持。而在开发中，使用该库可以大大给你带来方便。

目前，Okio的最新版本是1.6.0，gradle的引用如下

compile 'com.squareup.okio:okio:1.6.0'
1
2
3
1
2
3

Okio中有两个关键的接口，Sink和Source，这两个接口都继承了Closeable接口；而Sink可以简单的看做OutputStream，Source可以简单的看做InputStream。而这两个接口都是支持读写超时设置的。结构图如下

它们各自有一个支持缓冲区的子类接口，BufferedSink和BufferedSource，而BufferedSink有一个实现类RealBufferedSink,BufferedSource有一个实现类RealBufferedSource；此外，Sink和Source它门还各自有一个支持gzip压缩的实现类GzipSink和GzipSource；一个具有委托功能的抽象类ForwardingSink和ForwardingSource；还有一个实现类便是InflaterSource和DeflaterSink，这两个类主要用于压缩，为GzipSink和GzipSource服务；整体的结构图如下

BufferedSink中定义了一系列写入缓存区的方法，比如write方法写byte数组，writeUtf8写字符串，还有一些列的writeByte，writeString，writeShort，writeInt，writeLong，writeDecimalLong等等方法；

BufferedSource定义的方法和BufferedSink极为相似，只不过一个是写一个是读，基本上都是一一对应的，如readUtf8，readByte，readString，readShort，readInt等等等等。这两个接口中的方法有兴趣的点源码进去看就可以了。

而这两个支持缓冲区的接口的实现类RealBufferedSink和RealBufferedSource都是通过包装一个Sink+Buffer或者Source+Buffer来进行实现的。如下图所示

拿RealBufferedSink来举例，实际调用的write的一系列方法，都是直接的对成员变量buffer进行的操作，当写入buffer成功后，最后会调用一个方法将buffer中的内容写入到sink中去，我们随便拿一个方法看一下

    public BufferedSink writeLong(long v) throws IOException {        if(this.closed) {            throw new IllegalStateException("closed");        } else {            this.buffer.writeLong(v);            return this.emitCompleteSegments();        }    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

可以看到，首先会判断closed成员变量是否是标记着关闭，如果已经关闭了则扔出一个异常，否则将内容写入到buffer，写入完成后调用了一个emitCompleteSegments的方法，该方法中做了什么呢,没错，就是将buffer中的内容写入到sink成员变量中去，然后将自身返回。

    public BufferedSink emitCompleteSegments() throws IOException {        if(this.closed) {            throw new IllegalStateException("closed");        } else {            long byteCount = this.buffer.completeSegmentByteCount();            if(byteCount > 0L) {                this.sink.write(this.buffer, byteCount);            }            return this;        }    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这两个实现类的内部的所有方法都是类似的，这里不一一展开。

而这一切的背后都是一个叫做Buffer的类在支持着缓冲区,Buffer是BufferedSink和BufferedSource的实现类，因此它既可以用来读数据，也可以用来写数据，其内部使用了一个Segment和SegmentPool，维持着一个链表，其循环利用的机制和Android中Message的利用机制是一模一样的。

final class SegmentPool {    static final long MAX_SIZE = 65536L;    static Segment next;    static long byteCount;    private SegmentPool() {    }    static Segment take() {        Class var0 = SegmentPool.class;        synchronized(SegmentPool.class) {            if(next != null) {                Segment result = next;                next = result.next;                result.next = null;                byteCount -= 2048L;                return result;            }        }        return new Segment();    }    static void recycle(Segment segment) {        if(segment.next == null && segment.prev == null) {            if(!segment.shared) {                Class var1 = SegmentPool.class;                synchronized(SegmentPool.class) {                    if(byteCount + 2048L <= 65536L) {                        byteCount += 2048L;                        segment.next = next;                        segment.pos = segment.limit = 0;                        next = segment;                    }                }            }        } else {            throw new IllegalArgumentException();        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

内部一个成员变量next指向链表下一个元素，take方法首先判断池中是否存在可用的，存在则返回，不存在则new一个，而recycle则是将不再使用的Segment重新扔到池中去。从而达到一个Segment池的作用。

而Okio暴露给外部使用的类便是Okio这个类，其内部有大量的静态方法,包括通过一个Source获得BufferedSource，通过一个Sink获得一个BufferedSink。这个过程很简单，我们调用Okio的buffer方法即可返回我们需要的，如下

Okio.buffer(sink)Okio.buffer(source)
1
2
3
4
5
1
2
3
4
5

但是上面两个方法需要传递一个Sink或者Source，那么这个Sink和Source又是如何获得的呢。其实方法也在Okio这个类中。我们可以调用sink方法获得一个Sink，调用source方法获得一个Source，而数据的来源或者目的可以是一个File，一个输入或者输出流，一个Socket链接等等。如下

Okio.sink(new File("***"));Okio.sink(new FileOutputStream(new File("***")));Okio.sink(new Socket("***",8888));Okio.source(new File("***"));Okio.source(new FileInputStream(new File("***")));Okio.source(new Socket("****",8888));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这样你可能还不过瘾，那么让我们连起来应用一下，现在我们从本地读一个文件，读完后再往另一个文件中写入内容。

public static void main(String[] args) {    Source source = null;    BufferedSource bufferedSource = null;    try {        File file = new File("resources/test.txt");        source = Okio.source(file);        bufferedSource = Okio.buffer(source);        String content = bufferedSource.readUtf8();        System.out.println(content);    } catch (FileNotFoundException e) {        e.printStackTrace();    } catch (IOException e) {        e.printStackTrace();    } finally {        closeQuietly(bufferedSource);    }    Sink sink = null;    BufferedSink bufferedSink = null;    try {        File dest = new File("resources/dest.txt");        sink = Okio.sink(dest);        bufferedSink = Okio.buffer(sink);        bufferedSink.writeUtf8("11111111111");    } catch (FileNotFoundException e) {        e.printStackTrace();    } catch (IOException e) {        e.printStackTrace();    } finally {        closeQuietly(bufferedSink);    }}public static void closeQuietly(Closeable closeable) {    if (closeable != null) {        try {            closeable.close();        } catch (RuntimeException rethrown) {            throw rethrown;        } catch (Exception ignored) {        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

或许有时候网络请求中，我们需要使用到Gzip的功能，那么，我们可以简单的使用一下gzip的功能

public static void main(String[] args) {    Sink sink = null;    BufferedSink bufferedSink = null;    GzipSink gzipSink=null;    try {        File dest = new File("resources/gzip.txt");        sink = Okio.sink(dest);        gzipSink=new GzipSink(sink);        bufferedSink = Okio.buffer(gzipSink);        bufferedSink.writeUtf8("android vs ios");    } catch (FileNotFoundException e) {        e.printStackTrace();    } catch (IOException e) {        e.printStackTrace();    } finally {        closeQuietly(bufferedSink);    }    Source source = null;    BufferedSource bufferedSource = null;    GzipSource gzipSource=null;    try {        File file = new File("resources/gzip.txt");        source = Okio.source(file);        gzipSource=new GzipSource(source);        bufferedSource = Okio.buffer(gzipSource);        String content = bufferedSource.readUtf8();        System.out.println(content);    } catch (FileNotFoundException e) {        e.printStackTrace();    } catch (IOException e) {        e.printStackTrace();    } finally {        closeQuietly(bufferedSource);    }}public static void closeQuietly(Closeable closeable) {    if (closeable != null) {        try {            closeable.close();        } catch (RuntimeException rethrown) {            throw rethrown;        } catch (Exception ignored) {        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

验证是否正确的方法便是查看该写入的文件是否是乱码，以及读出来是否是原来的字符串。

对比一下原来的gzip压缩与解压缩的方式，你就会发现还是简单了不少的

public class GzipUtil {    /**     * GZIP压缩     *     * @param data     * @return     */    public static byte[] gzip(byte[] data) throws Exception {        if (data == null || data.length == 0) {            return null;        }        ByteArrayOutputStream out = new ByteArrayOutputStream();        GZIPOutputStream zos;        BufferedInputStream bis = new BufferedInputStream(new ByteArrayInputStream(data));        byte[] buf = new byte[512];        int len;        try {            zos = new GZIPOutputStream(out);            while ((len = bis.read(buf)) != -1) {                zos.write(buf, 0, len);                zos.flush();            }            bis.close();            zos.close();            return out.toByteArray();        } finally {            if (out != null) {                try {                    out.close();                } catch (Exception e2) {                }            }        }    }    /**     * Gzip解压缩     * @param b     * @return     */    public static byte[] unGzip(byte[] b) {        if (b == null || b.length == 0) {            return null;        }        ByteArrayOutputStream out = new ByteArrayOutputStream();        ByteArrayInputStream in = new ByteArrayInputStream(b);        try {            GZIPInputStream gunzip = new GZIPInputStream(in);            byte[] buffer = new byte[256];            int n;            while ((n = gunzip.read(buffer)) >= 0) {                out.write(buffer, 0, n);            }            return out.toByteArray();        } catch (IOException e) {            Log.e(WDCore.getInstance().getConfiguration().getLogTag(), "uncompress error", e);        } finally {            try {                if (out != null) {                    out.close();                }                if (in != null) {                    in.close();                }            } catch (Exception e2) {            }        }        return null;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

此外还有一个ByteString类，这个类可以用来做各种变化，它将byte转会为String，而这个String可以是utf8的值，也可以是base64后的值，也可以是md5的值，也可以是sha256的值，总之就是各种变化，最后取得你想要的值。

总之，在合适的地方适当使用一下Okio这个库，一定能给你开发带来诸多便利，何乐而不为呢！