12 | Android 高级进阶(源码剖析篇) Square

作者简介：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 方法，代码如下所示：