吃透Netty源码系列三十六之CompositeByteBuf详解二

removeComponent删除组件

前一篇讲了新增操作，接下来讲讲其他的，首先当然是删除啦，删除索引对应的缓冲区。原理就是获取对应的组件，然后释放，然后从组件数组中删除

  public CompositeByteBuf removeComponent(int cIndex) {
        checkComponentIndex(cIndex);
        Component comp = components[cIndex];
        if (lastAccessed == comp) {//查找的时候缓存用的
            lastAccessed = null;
        }
        comp.free();//释放缓冲区
        removeComp(cIndex);//删除组件
        if (comp.length() > 0) {//如果有可读数据被删除了，那就需要更新之后的组件索引
            updateComponentOffsets(cIndex);
        }
        return this;
    }
//删除索引对应的组件
    private void removeComp(int i) {
        removeCompRange(i, i + 1);
    }

getByte获取数据

增删讲完了，该说说读和写吧，获取指定索引的字节数据。

  @Override
    public byte getByte(int index) {
        Component c = findComponent(index);
        return c.buf.getByte(c.idx(index));//根据索引获取字节数据
    }

findComponent查找组件

如果缓存的那个索引区域就是我们要找的，就直接返回去，否则就要去找。

    private Component findComponent(int offset) {
        Component la = lastAccessed;//缓存的
        if (la != null && offset >= la.offset && offset < la.endOffset) {//索引在缓存组件内
           ensureAccessible();
           return la;
        }
        checkIndex(offset);
        return findIt(offset);
    }

findIt二分查找

二分查找法查找，找到的组件会缓存到lastAccessed 。

private Component findIt(int offset) {
        for (int low = 0, high = componentCount; low <= high;) {
            int mid = low + high >>> 1;
            Component c = components[mid];
            if (offset >= c.endOffset) {
                low = mid + 1;
            } else if (offset < c.offset) {
                high = mid - 1;
            } else {
                lastAccessed = c;
                return c;
            }
        }

        throw new Error("should not reach here");
    }

其实写也是类似的：

toComponentIndex获取偏移对应的组件索引

获取索引后当然就可以获取组件啦，当组件数量少的时候用了一些快速的方法，多了就用二分查找。

 public int toComponentIndex(int offset) {
        checkIndex(offset);
        return toComponentIndex0(offset);
    }
    //二分查找
    private int toComponentIndex0(int offset) {
        int size = componentCount;
        if (offset == 0) { // fast-path zero offset
            for (int i = 0; i < size; i++) {
                if (components[i].endOffset > 0) {
                    return i;//返回存在可读的第一个组件的索引
                }
            }
        }
        if (size <= 2) { // fast-path for 1 and 2 component count
            return size == 1 || offset < components[0].endOffset ? 0 : 1;//个数为1，直接就是0。如果是2的话，看偏移是否小于第一个组件的endOffset，是就是0，否就是1
        }
        for (int low = 0, high = size; low <= high;) {//二分查找
            int mid = low + high >>> 1;
            Component c = components[mid];
            if (offset >= c.endOffset) {
                low = mid + 1;
            } else if (offset < c.offset) {
                high = mid - 1;
            } else {
                return mid;
            }
        }

        throw new Error("should not reach here");
    }

addFlattenedComponents可以添加复合缓冲区

这个方法可以判断添加的是什么类型的，如果不是复合的就按一般方法处理，如果是符合的，就把里面可读的组件都添加进来，注意如果待添加的复合缓冲区不可读的话，就不会添加，什么也不做。

 public CompositeByteBuf addFlattenedComponents(boolean increaseWriterIndex, ByteBuf buffer) {
        checkNotNull(buffer, "buffer");
        final int ridx = buffer.readerIndex();
        final int widx = buffer.writerIndex();
        if (ridx == widx) {//不可读了就释放
            buffer.release();
            return this;
        }
        if (!(buffer instanceof CompositeByteBuf)) {//不是复合类型的就直接调用加入
            addComponent0(increaseWriterIndex, componentCount, buffer);
            consolidateIfNeeded();
            return this;
        }
        final CompositeByteBuf from = (CompositeByteBuf) buffer;
        from.checkIndex(ridx, widx - ridx);
        final Component[] fromComponents = from.components;//取出所有组件
        final int compCountBefore = componentCount;//增加前个数
        final int writerIndexBefore = writerIndex;//增加前的写索引
        try {//从读索引开始获取对应的fromComponents组件获取信息，并重新创建组件添加到最后
            for (int cidx = from.toComponentIndex0(ridx), newOffset = capacity();; cidx++) {
                final Component component = fromComponents[cidx];//获取索引对应的组件
                final int compOffset = component.offset;//获取偏移
                final int fromIdx = Math.max(ridx, compOffset);//起点索引
                final int toIdx = Math.min(widx, component.endOffset);//终点索引
                final int len = toIdx - fromIdx;//还有多少个可读字节
                if (len > 0) { // skip empty components //不是空的，就创建组件添加到后面
                    addComp(componentCount, new Component(
                            component.srcBuf.retain(), component.srcIdx(fromIdx),
                            component.buf, component.idx(fromIdx), newOffset, len, null));
                }
                if (widx == toIdx) {//已经处理完了
                    break;
                }
                newOffset += len;//更新偏移
            }
            if (increaseWriterIndex) {
                writerIndex = writerIndexBefore + (widx - ridx);
            }
            consolidateIfNeeded();//必要就合并
            buffer.release();//释放
            buffer = null;
            return this;
        } finally {
            if (buffer != null) {//有异常的话需要回滚
                // if we did not succeed, attempt to rollback any components that were added
                if (increaseWriterIndex) {
                    writerIndex = writerIndexBefore;
                }
                for (int cidx = componentCount - 1; cidx >= compCountBefore; cidx--) {
                    components[cidx].free();//释放缓冲区
                    removeComp(cidx);//删除组件
                }
            }
        }
    }

iterator获取缓冲区迭代器

就是把里面的缓冲区都封装到迭代器里了，而且是只读的，获取的是组件里源缓冲区的切片slice。

    public Iterator<ByteBuf> iterator() {
        ensureAccessible();
        return componentCount == 0 ? EMPTY_ITERATOR : new CompositeByteBufIterator();
    }

切片这个时候有用了，而且是源缓冲区：

isDirect是否是直接缓冲区

只有组件里的缓冲区全部是直接缓冲区的时候，才是直接缓冲区。

capacity有多少可读字节

deallocate释放缓冲区

根据组件数量来判断的方法

组件数量两个的时候可能就没结果了。





主要的方法都介绍了，只要理解这些，其他的大部分方法也都是这些简单的组合而已，就不多说了。

好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。