美文网首页
okio解析

okio解析

作者: HardMan | 来源:发表于2021-12-09 16:16 被阅读0次

    使用okhttp的时候,看过源码会知道,里面是使用了okio对流进行处理,那么okio到底是什么?
    okio 同样也是square公司推出的io处理利器,它相对传统的io操作有一些优势。

    优势

    1、更低的CPU消耗和内存开销。okio内部使用了segment(片)来存放数据,segment里面放的也是byte[],但在外面有一个segmentPool来对segment进行回收复用。避免了频繁创建segment而导致的内存开销。
    2、使用更简单。传统的io流,采用了装饰模式的思想。装饰模式可以增强类的功能,而不通过继承的方式。如果需要读取一个整形数据,我们会使用DataInputStream进行包装,或者如果我们需要用到缓存,会用到BufferInputStream。但okio不需要这么麻烦,okio的Buffer已经提供了一系列的方法,比如readInt(),readUtf8()等等。
    3、okio中的Timeout提供了超时的处理。

    实例分析

    okio中最重要的两个接口分别是Sink和Source
    Source:这个接口相当于InputStream,是用来读数据。数据来源可以是磁盘、网络、内存等
    Sink:这个接口相当于OutputStream,是用于往外写数据。
    InputStream和OutputStream可以以内存为参照物,加载到内存的输入流、而从内存中输出到别的地方,称为输出流
    从一个最简单的例子入手去了解okio的内部逻辑

            File file=new File("/mnt/sdcard/需求.txt");
            InputStream in=new FileInputStream(file);
            BufferedSource source = Okio.buffer(Okio.source(in));  //创建BufferedSource
            String s = source.readUtf8();  //以UTF-8读
            System.out.println(s);     //打印
    
            BufferedSink sink=Okio.buffer(Okio.sink(new File("/mnt/sdcard/需求copy.txt")));
            sink.writeUtf8(s);
            source.close();
            sink.close();
    

    这个例子是从设备磁盘中读取txt文件的内容 并打印出来。再将内容写到另一个txt文件中。
    按顺序先看一下Okio.source(in)方法

      public static Source source(InputStream in) {
        return source(in, new Timeout());
      }
      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");
    
        return new Source() {
          @Override public long read(Buffer sink, long byteCount) throws IOException {
            if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);
            if (byteCount == 0) return 0;
            try {
              /检查读取是否超时 如果超时了直接抛出异常
              timeout.throwIfReached(); 
              //获取一个可写的segment
              Segment tail = sink.writableSegment(1);
              int maxToCopy = (int) Math.min(byteCount, Segment.SIZE - tail.limit);
              int bytesRead = in.read(tail.data, tail.limit, maxToCopy);
              if (bytesRead == -1) return -1;
              tail.limit += bytesRead;
              sink.size += bytesRead;
              return bytesRead;
            } catch (AssertionError e) {
              if (isAndroidGetsocknameError(e)) throw new IOException(e);
              throw e;
            }
          }
    
          @Override public void close() throws IOException {
            in.close();
          }
    
          @Override public Timeout timeout() {
            return timeout;
          }
    
          @Override public String toString() {
            return "source(" + in + ")";
          }
        };
      }
    

    这个方法其实是构建了一个Source的实例对象,并实现了read函数,内部通过Buffer对象sink的writableSegment函数返回一个可写的segment,并调用inputStream的read函数,将数据写入到segment中。那么这个sink是从哪里来的,我们接着往下分析。

    Okio.buffer(Okio.source(in));
    

    进到Okio的 buffer(Source source)函数

      public static BufferedSource buffer(Source source) {
        return new RealBufferedSource(source);
      }
    

    这个方法返回一个RealBufferedSource对象,RealBufferedSource类实现了BufferedSource接口,而BufferedSource又实现了Source接口。RealBufferedSource内部又有一个Source对象和一个Buffer对象。这里其实有点装饰模式的味道了,通过RealBufferedSource增强了read方法。


    image.png

    现在我们已经做好准备工作了,已经有了一个RealBufferSource对象了,接下来就是调用该对象的readxxx()方法了,我们这里用的是readUtf8(),具体看一下。

      @Override public String readUtf8() throws IOException {
        buffer.writeAll(source);
        return buffer.readUtf8();
      }
    

    首先先看Buffer的writeAll方法

      @Override public long writeAll(Source source) throws IOException {
        if (source == null) throw new IllegalArgumentException("source == null");
        long totalBytesRead = 0;
        for (long readCount; (readCount = source.read(this, Segment.SIZE)) != -1; ) {
          totalBytesRead += readCount;
        }
        return totalBytesRead;
      }
    

    重点看一下for循环里面的代码,其中的source对象就是前面构造出来的那个对象,不断调用它的read方法,将数据写入当前Buffer中。从前面的代码分析中可以知道,实际上,buffer对象通过调用writableSegment函数返回一个segment,将数据写到这个segment中。

    Segment和Buffer

    那么segment到底是什么,Buffer对象又是什么,之间有什么联系?


    okiopng.png

    okio使用segment来存储流数据,segment之间是双向链表的数据结构,buffer对象持有该链表的表头 head,通过head 可以快速定位到其它segment。Segment内部使用了byte[]数组,整体采用了链表和数组结合的模式,可以说在数据查找和修改移除做了相对平衡的选择。

    注意:Segment中的split方法,从字面上了解是将一个segment对象 一分为二,用链表再串起来。但每个segment引用的是同一个byte[],只不过是在数组上的不同区域,即不同的pos和limit。所以这个时候需要区分该segment是属于owner还是share,这两者互斥。如果是share,那对该segment处理便有很多限制,因为会影响其它引用同一个byte[]的segment。

    回到例子中,在将数据读到buffer中后,调用了readUtf8方法,将字节流转换utf8字符串。

      @Override public String readString(long byteCount, Charset charset) throws EOFException {
        checkOffsetAndCount(size, 0, byteCount);
        if (charset == null) throw new IllegalArgumentException("charset == null");
        if (byteCount > Integer.MAX_VALUE) {
          throw new IllegalArgumentException("byteCount > Integer.MAX_VALUE: " + byteCount);
        }
        if (byteCount == 0) return "";
    
        Segment s = head;
        if (s.pos + byteCount > s.limit) {
          // If the string spans multiple segments, delegate to readBytes().
          return new String(readByteArray(byteCount), charset);
        }
    
        String result = new String(s.data, s.pos, (int) byteCount, charset);
        s.pos += byteCount;
        size -= byteCount;
    
        if (s.pos == s.limit) {
          head = s.pop();
          SegmentPool.recycle(s);
        }
    
        return result;
      }
    

    将数据读出来 通过newString处理。

    相关文章

      网友评论

          本文标题:okio解析

          本文链接:https://www.haomeiwen.com/subject/asztfrtx.html