12 | Android 高级进阶(源码剖析篇) Square 高效易用的 IO 框架 okio

Posted ACE1985

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了12 | Android 高级进阶(源码剖析篇) Square 高效易用的 IO 框架 okio相关的知识,希望对你有一定的参考价值。

作者简介:ASCE1885, 《android 高级进阶》作者。

本文由于潜在的商业目的,未经授权不开放全文转载许可,谢谢!

本文分析的源码版本已经 fork 到我的 Github。

在本系列第二篇文章中,我们专门介绍了 okio 中的 Source,但其中 InflaterSource 和 GzipSource 由于涉及 segment 的相关知识,因此没有作介绍,本文就来补充一下。由于压缩和解压算法是配套的,因此,本文同时也会介绍 DeflaterSink 和 GzipSink。顾名思义,

  • DeflaterSink 是一个具备压缩功能的输出流,将数据写入这个 sink 时,它会使用 DEFLATE算法对数据进行压缩操作

  • InflaterSource 是一个具备解压功能的输入流,从这个 source 中读取数据时,它会使用 DEFLATE 算法对自身的数据进行解压操作

  • GzipSink 是一个具备压缩功能的输出流,将数据写入这个 sink 时,它会使用 GZIP 算法对数据进行压缩操作

  • GzipSource 是一个具备解压功能的输入流,从这个 source 中读取数据时,它会使用 GZIP 算法对数据进行解压操作

下面我们分别进行介绍。

PS:okio 中输入流 Source 和输出流 Sink 的字节数据都是存放在自身 segment 链表的元素中,因此,在下面代码中我们可以看到大量的对 segment 的操作,大家请自觉复习本系列第三篇文章。

DEFLATE 算法

DEFLATE 是一个同时运用了 LZ77 算法和哈夫曼编码的无损数据压缩算法,在 Java 中,提供了 Deflater 工具类来实现数据压缩,该 API 使用的示例如下所示:

String inputString = "blahblahblah";	
byte[] input = inputString.getBytes("UTF-8"); // 未压缩的数据	
	
byte[] output = new byte[100]; // 存放压缩后的数据	
Deflater compresser = new Deflater();	
compresser.setInput(input); // 设置需要压缩的数据	
compresser.finish(); // 表示需要压缩的数据设置完成	
int compressedDataLength = compresser.deflate(output); // 执行压缩操作	
compresser.end(); // 关闭压缩器,并丢弃任何还未压缩的数据

提供 Inflater 工具类来实现数据的解压,该 API 使用的示例如下所示,为了演示方便,承接上面的压缩代码,使用其中的某些变量:

Inflater decompresser = new Inflater();	
decompresser.setInput(output, 0, compressedDataLength); // 设置需要解压的数据	
byte[] result = new byte[100];	
int resultLength = decompresser.inflate(result); // 执行实际的解压操作	
decompresser.end(); // 关闭解压器,并丢弃任何还未解压的数据

可见,API 的使用还是挺简单的,接下来看看怎么将 DEFLATE 算法和 okio 相结合实现数据流的压缩和解压,首先来看压缩操作,也就是 DeflaterSink 这个类。

DeflaterSink

DeflaterSink 类从某个输入流的 segment 链表中读取数据,然后使用 DEFLATE 对数据进行压缩后存放到自身的 segment 链表中,核心算法在 write 方法中,该方法首先进行参数校验,然后每次以一个 segment 为单位,循环从输入流中读取数据进行压缩,直到达到 write 方法指定的压缩字节数,具体的逻辑我们直接看代码和注释:

@Override public void write(Buffer source, long byteCount) throws IOException 	
    // 参数校验	
    checkOffsetAndCount(source.size, 0, byteCount);	
	
    // byteCount表示剩余的需要压缩的字节数	
    while (byteCount > 0) 	
      // 每次从输入流source中取出segment链表的第一个元素	
      Segment head = source.head;	
	
      // 根据segment中的未读的数据大小和byteCount来决定要压缩的数据字节数	
      int toDeflate = (int) Math.min(byteCount, head.limit - head.pos);	
	
      // 设置需要压缩的数据	
      deflater.setInput(head.data, head.pos, toDeflate);	
	
      // 将原始数据压缩后存入当前sink中	
      deflate(false);	
	
      // 移动数据指针	
      source.size -= toDeflate;	
      head.pos += toDeflate;	
      if (head.pos == head.limit) 	
        // 输入流已经没有未压缩数据,释放资源	
        source.head = head.pop();	
        SegmentPool.recycle(head);	
      	
	
      // 重新计算未压缩数据字节数	
      byteCount -= toDeflate;	
    	

可以看到,上面代码操作的主要是输入流的 segment,而实际的压缩操作和对输出流的 segment 的申请等操作则在 deflate 私有方法中,如下所示:

private void deflate(boolean syncFlush) throws IOException 	
    Buffer buffer = sink.buffer();	
    while (true) 	
      // 在当前sink中申请一个位于segment链表尾部的segment,用来存放压缩后的数据	
      Segment s = buffer.writableSegment(1);	
	
      // 调用Deflater类的压缩方法执行实际的压缩操作,压缩后的数据存放在s.data中	
      int deflated = syncFlush	
          ? deflater.deflate(s.data, s.limit, Segment.SIZE - s.limit, Deflater.SYNC_FLUSH)	
          : deflater.deflate(s.data, s.limit, Segment.SIZE - s.limit);	
	
      if (deflated > 0) 	
        // 有数据被压缩了	
        s.limit += deflated;	
        buffer.size += deflated;	
        sink.emitCompleteSegments();	
       else if (deflater.needsInput()) 	
        // 没有数据被压缩,同时也不存在需要压缩的数据,则释放申请的segment	
        if (s.pos == s.limit) 	
          buffer.head = s.pop();	
          SegmentPool.recycle(s);	
        	
        return;	
      	
    	

总结起来,DeflaterSink 的核心算法就是将输入流中需要压缩的数据,以 segment 为单位循环进行压缩后存放到输出流的 segment 中,仅此而已,当然细节是魔鬼,一切的细节都在上面的代码中,大家可以细细品味。

InflaterSource

和 DeflaterSink 相对应,InflaterSource 的核心算法就是将自身需要解压的数据,以 segment 为单位进行解压后存放到输出流中。我们来看下核心的 read 方法,该方法首先进行参数校验,然后从当前输入流 source 中读取需要解压的数据填充给解压器 inflater,然后从输出流 sink 中申请 segment,用来存放解压后的数据,代码和注释如下所示:

@Override public long read(	
      Buffer sink, long byteCount) throws IOException 	
    // 参数校验	
    if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);	
    if (closed) throw new IllegalStateException("closed");	
    if (byteCount == 0) return 0;	
	
    while (true) 	
      // 从当前source中获取需要解压的数据并设置给解压器inflater	
      boolean sourceExhausted = refill();	
	
      try 	
        // 从输出流中申请segment	
        Segment tail = sink.writableSegment(1);	
	
        // 调用Inflater类的解压方法执行实际的解压操作,并将解压后的数据存放到输出流sink的tail.data中	
        int bytesInflated = inflater.inflate(tail.data, tail.limit, Segment.SIZE - tail.limit);	
        if (bytesInflated > 0) 	
          // 有数据被解压,返回被解压的字节数	
          tail.limit += bytesInflated;	
          sink.size += bytesInflated;	
          return bytesInflated;	
        	
	
        // 没有需要解压的数据	
        if (inflater.finished() || inflater.needsDictionary()) 	
          // 清理未解压的数据	
          releaseInflatedBytes();	
          if (tail.pos == tail.limit) 	
            // 回收前面申请的segment	
            sink.head = tail.pop();	
            SegmentPool.recycle(tail);	
          	
          return -1;	
        	
        if (sourceExhausted) throw new EOFException("source exhausted prematurely");	
       catch (DataFormatException e) 	
        throw new IOException(e);	
      	
    	

需要注意的一点是,上面代码中每次解压都是把当前 segment 中剩余未读的所有数据(大小是 Segment.SIZE - tail.limit)进行解压,而入参 byteCount 没有使用到,这是有问题的,这部分代码如下:

Segment tail = sink.writableSegment(1);	
int bytesInflated = inflater.inflate(tail.data, tail.limit, Segment.SIZE - tail.limit);

正确的做法是把入参 byteCount 考虑进来,取亮着的最小值作为实际解压的数据大小,如下所示:

Segment tail = sink.writableSegment(1);	
int toRead = (int) Math.min(byteCount, Segment.SIZE - tail.limit);	
int bytesInflated = inflater.inflate(tail.data, tail.limit, toRead);

通过查看 Github 上最新的 okio 的代码,我们可以发现这个问题已经被解决了,具体可以参见这次提交。

好,我们继续分析,在上面 read 方法中调用了另外两个私有方法,其中 refill 是重新给解压器设置需要解压的数据,也就是调用 Inflater 的 setInput 方法,代码如下所示:

public boolean refill() throws IOException 	
    // 判断inflater中是否已经有需要解压的数据	
    if (!inflater.needsInput()) return false;	
	
    // 清理inflater中未解压的数据	
    releaseInflatedBytes();	
    if (inflater.getRemaining() != 0) throw new IllegalStateException("?"); // TODO: possible?	
	
    // source 中没有数据了	
    if (source.exhausted()) return true;	
	
    // 每次从输入流source中取出segment链表的第一个元素	
    Segment head = source.buffer().head;	
    // 记录inflater当前持有(setInput)的未解压数据字节数,默认是segment中所有的未读数据	
    bufferBytesHeldByInflater = head.limit - head.pos;	
    // 设置需要解压的数据	
    inflater.setInput(head.data, head.pos, bufferBytesHeldByInflater);	
    return false;	

releaseInflatedBytes 是根据解压过的数据大小来移动 source 中第一个 segment 的数据读取指针,代码如下所示:

... 更多内容请点击阅读原文继续阅读。

以上是关于12 | Android 高级进阶(源码剖析篇) Square 高效易用的 IO 框架 okio的主要内容,如果未能解决你的问题,请参考以下文章

Android高级进阶(源码剖析篇) 前言

04 | Android 高级进阶(源码剖析篇) 优美的日志框架 logger

Android 高级进阶(源码剖析篇) 小而美的日志框架 timber(上)

Android 高级进阶(源码剖析篇) 小而美的日志框架 timber(下)

13 | Android 高级进阶(源码剖析篇) Square 高效易用的 IO 框架 okio

Android 高级进阶(源码剖析篇) 便于性能分析的日志框架 hugo