wo883721
wo883721

Netty源码_AbstractByteBuf详解

上一章我们介绍了 ByteBuf 功能，这一章我们将讲解它重要的一个子类 AbstractByteBuf,它实现了 ByteBuf 中很多通用功能，这样子类就不需要各自实现了。

在 netty 中很多模块都是这样的，会有一个 Abstract 类实现模块的基础功能。

一. 重要属性

1.1 静态属性

1.1.1 checkAccessible

是否需要检查访问权限，默认是 true，是一个静态属性，所有 ByteBuf 实例一样。

    /**
     * Used internally by {@link AbstractByteBuf#ensureAccessible()} to try to guard
     * against using the buffer after it was released (best-effort).
     */
    boolean isAccessible() {
        return refCnt() != 0;
    }

    /**
     * Should be called by every method that tries to access the buffers content to check
     * if the buffer was released before.
     */
    protected final void ensureAccessible() {
        if (checkAccessible && !isAccessible()) {
            throw new IllegalReferenceCountException(0);
        }
    }

当 checkAccessible 为 true 的时候，才会调用 isAccessible() 方法，判断访问权限。

可以通过 io.netty.buffer.checkAccessible 和 io.netty.buffer.bytebuf.checkAccessible 两个配置项设置。

    private static final String LEGACY_PROP_CHECK_ACCESSIBLE = "io.netty.buffer.bytebuf.checkAccessible";
    private static final String PROP_CHECK_ACCESSIBLE = "io.netty.buffer.checkAccessible";

    static final boolean checkAccessible; // accessed from CompositeByteBuf

    static {
        if (SystemPropertyUtil.contains(PROP_CHECK_ACCESSIBLE)) {
            checkAccessible = SystemPropertyUtil.getBoolean(PROP_CHECK_ACCESSIBLE, true);
        } else {
            checkAccessible = SystemPropertyUtil.getBoolean(LEGACY_PROP_CHECK_ACCESSIBLE, true);
        }
        ......
}

1.1.2 checkBounds

是否需要检查操作是否超出缓存区 ByteBuf 界限，默认是 true，是一个静态属性，所有 ByteBuf 实例一样。

可以通过 io.netty.buffer.checkBounds 配置项设置

    private static final boolean checkBounds;

    static {
        ......
        checkBounds = SystemPropertyUtil.getBoolean(PROP_CHECK_BOUNDS, true);
        ......
    }

1.1.3 leakDetector

检查缓存区 ByteBuf 是否存在内存泄露情况。是一个静态属性，所有 ByteBuf 实例共享。

    static final ResourceLeakDetector leakDetector =
        ResourceLeakDetectorFactory.instance().newResourceLeakDetector(ByteBuf.class);

1.2 成员属性

  1. readerIndex: 读索引
  2. writerIndex: 写索引
  3. markedReaderIndex: 标记读索引
  4. markedWriterIndex: 标记写索引
  5. maxCapacity: 缓存区最大容量

你会发现，这里没有代表缓存区当前容量的属性，因为缓存区当前容量在不同类型缓存区实现中，表示形式是不一样的，所以这里就没有这个属性。

二. 构造方法

AbstractByteBuf 只有一个构造方法

    protected AbstractByteBuf(int maxCapacity) {
        checkPositiveOrZero(maxCapacity, "maxCapacity");
        this.maxCapacity = maxCapacity;
    }

也就是说缓存区必须设置它的最大容量 maxCapacity。

三. 重要方法

3.1 索引和标记索引相关

  1. checkIndexBounds: 检查是否超出缓存区界限

    private static void checkIndexBounds(final int readerIndex, final int writerIndex, final int capacity) {
    if (readerIndex < 0 || readerIndex > writerIndex || writerIndex > capacity) {
        throw new IndexOutOfBoundsException(String.format(
                "readerIndex: %d, writerIndex: %d (expected: 0 <= readerIndex <= writerIndex <= capacity(%d))",
                readerIndex, writerIndex, capacity));
    }
}

  2. readerIndex() 和 readerIndex(int readerIndex): 获取和设置读索引 readerIndex

    @Override
public int readerIndex() {
    return readerIndex;
}

@Override
public ByteBuf readerIndex(int readerIndex) {
    if (checkBounds) {
        checkIndexBounds(readerIndex, writerIndex, capacity());
    }
    this.readerIndex = readerIndex;
    return this;
}

  3. writerIndex() 和 writerIndex(int writerIndex): 获取和设置写索引 writerIndex

    @Override
public int writerIndex() {
    return writerIndex;
}

@Override
public ByteBuf writerIndex(int writerIndex) {
    if (checkBounds) {
        checkIndexBounds(readerIndex, writerIndex, capacity());
    }
    this.writerIndex = writerIndex;
    return this;
}

  4. setIndex(int readerIndex, int writerIndex): 同时设置读索引 readerIndex和写索引 writerIndex

    @Override
public ByteBuf setIndex(int readerIndex, int writerIndex) {
    if (checkBounds) {
        checkIndexBounds(readerIndex, writerIndex, capacity());
    }
    setIndex0(readerIndex, writerIndex);
    return this;
}

  5. clear(): 清除读索引 readerIndex和写索引 writerIndex，相当于 setIndex(0, 0)

    @Override
public ByteBuf clear() {
    readerIndex = writerIndex = 0;
    return this;
}

  6. markReaderIndex() 和 resetReaderIndex(): 标记和重置读索引 readerIndex。

    @Override
public ByteBuf markReaderIndex() {
    markedReaderIndex = readerIndex;
    return this;
}
@Override
public ByteBuf resetReaderIndex() {
    readerIndex(markedReaderIndex);
    return this;
}

  7. markWriterIndex() 和 resetWriterIndex(): 标记和重置写索引 writerIndex。

    @Override
public ByteBuf markWriterIndex() {
    markedWriterIndex = writerIndex;
    return this;
}
@Override
public ByteBuf resetWriterIndex() {
    writerIndex(markedWriterIndex);
    return this;
}

  8. discardReadBytes(): 这个方法会将可读区域 readable bytes 数据移动到开头，让可写区域writable bytes 变得更多，它也会改变读写索引。

    @Override
public ByteBuf discardReadBytes() {
  // 如果读索引是0，那么就不需要移动，直接返回
  if (readerIndex == 0) {
      ensureAccessible();
      return this;
  }

  if (readerIndex != writerIndex) {
      // readerIndex != writerIndex，说明还有可读数据，那么就需要将这些可读数据移动到开头。
      // 这里取巧了，直接调用 ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) 方法，源缓存区就是自己
      setBytes(0, this, readerIndex, writerIndex - readerIndex);
      // 移动后写索引的值
      writerIndex -= readerIndex;
      // 但是要调整一下标记索引的大小
      adjustMarkers(readerIndex);
      // 读索引的值设置为 0
      readerIndex = 0;
  } else {
      // 如果 readerIndex == writerIndex，说明没有可读内容了，就不涉及数据移动了。
      // 那么直接将 readerIndex 和 writerIndex 设置为 0
      ensureAccessible();
      // 但是要调整一下标记索引的大小
      adjustMarkers(readerIndex);
      writerIndex = readerIndex = 0;
  }
  return this;
}

    分为三种情况:

    • readerIndex == 0 说明可读数据就在开头，不需要移动，直接返回。
    • readerIndex == writerIndex 说明没有可读数据了，那么也不需要移动数据了，直接将读写索引都设置为 0，顺便修改一下标记索引的大小。
    • readerIndex != writerIndex 说明还有可读数据，那么就需要将这些可读数据移动到开头，通过调用 setBytes(int index, ByteBuf src, int srcIndex, int length) 方法来移动数据，然后将读索引设置为0,写索引设置为 writerIndex - readerIndex, 顺便修改一下标记索引的大小。

  9. discardSomeReadBytes() ：这个方法不像 discardReadBytes() 方法，必须将可读区域 readable bytes 移动到开头，它会判断读索引的位置，来决定是否将可读区域移动到开头。所以它也有可能改变读写索引。

    @Override
public ByteBuf discardSomeReadBytes() {
   // 只有读索引大于 0，才有可能需要移动
   if (readerIndex > 0) {
       // 当 readerIndex == writerIndex，说明没有可读内容了，不需要数据移动
       // 那么直接将 readerIndex 和 writerIndex 设置为 0
       if (readerIndex == writerIndex) {
           ensureAccessible();
           // 要调整一下标记索引的大小
           adjustMarkers(readerIndex);
           writerIndex = readerIndex = 0;
           return this;
       }

       // 当读索引的值大于或者等于 缓存区容量的一半时，才进行数据移动
       if (readerIndex >= capacity() >>> 1) {
           // 直接调用 ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) 方法，源缓存区就是自己
           setBytes(0, this, readerIndex, writerIndex - readerIndex);
           // 移动后写索引的值
           writerIndex -= readerIndex;
           // 调整一下标记索引的大小
           adjustMarkers(readerIndex);
           // 读索引的值设置为 0
           readerIndex = 0;
           return this;
       }
   }
   ensureAccessible();
   return this;
}

    这个方法与discardReadBytes() 方法相比较，你会发现，唯一的不同就是它只会当读索引的值大于或者等于缓存区容量的一半时，才进行数据移动。

3.2 容量相关

  1. maxCapacity() 和 maxCapacity(int maxCapacity): 获取和设置缓存区最大容量maxCapacity。

  2. isReadable() 和 isReadable(int numBytes): 缓存区是否有足够可读区域readable bytes。

    @Override
public boolean isReadable() {
    return writerIndex > readerIndex;
}

@Override
public boolean isReadable(int numBytes) {
    return writerIndex - readerIndex >= numBytes;
}

  3. isWritable() 和 isWritable(int numBytes): 缓存区是否有足够可写区域writable bytes。

    @Override
public boolean isWritable() {
    return capacity() > writerIndex;
}

@Override
public boolean isWritable(int numBytes) {
    return capacity() - writerIndex >= numBytes;
}

  4. readableBytes(): 缓存区可读区域readable bytes 的大小。

    @Override
public int readableBytes() {
    return writerIndex - readerIndex;
}

  5. writableBytes(): 缓存区可写区域writable bytes 的大小。

     @Override
 public int writableBytes() {
     return capacity() - writerIndex;
 }

  6. maxWritableBytes(): 缓存区最大可写区域writable bytes 的大小。

     @Override
 public int maxWritableBytes() {
     return maxCapacity() - writerIndex;
 }

  7. ensureWritable(int minWritableBytes): 扩展缓存区容量。

    @Override
public ByteBuf ensureWritable(int minWritableBytes) {
    ensureWritable0(checkPositiveOrZero(minWritableBytes, "minWritableBytes"));
    return this;
}

final void ensureWritable0(int minWritableBytes) {
    final int writerIndex = writerIndex();
    // 目标容量
    final int targetCapacity = writerIndex + minWritableBytes;
    // using non-short-circuit & to reduce branching - this is a hot path and targetCapacity should rarely overflow
    // 如果目标容量小于当前容量，那么不需要扩展，直接返回。
    // targetCapacity >= 0 是为了防止目标容量溢出了，超过 int 类型最大值
    if (targetCapacity >= 0 & targetCapacity <= capacity()) {
        ensureAccessible();
        return;
    }
    if (checkBounds && (targetCapacity < 0 || targetCapacity > maxCapacity)) {
        ensureAccessible();
        throw new IndexOutOfBoundsException(String.format(
                "writerIndex(%d) + minWritableBytes(%d) exceeds maxCapacity(%d): %s",
                writerIndex, minWritableBytes, maxCapacity, this));
    }

    // Normalize the target capacity to the power of 2.
    // 最快能够获取的最大可写区域大小，它的大小在 writableBytes() <= maxFastWritableBytes() <= markWriterIndex()
    final int fastWritable = maxFastWritableBytes();
    // 如果 fastWritable 大小足够，那么新容量就是 writerIndex + fastWritable；
    // 否则就是用 ByteBufAllocator 的 calculateNewCapacity 计算出新容量。
    // 特别注意，新的容量一定是 2的幂。
    int newCapacity = fastWritable >= minWritableBytes ? writerIndex + fastWritable
            : alloc().calculateNewCapacity(targetCapacity, maxCapacity);

    // 设置缓存区新容量
    capacity(newCapacity);
}

    注意一下几点:

    • 当目标容量targetCapacity 小于或者等于当前缓存区容量 capacity()，那就直接返回。
    • 当目标容量targetCapacity超出缓存区最大容量 maxCapacity，那么新容量newCapacity 的值就是maxCapacity，这是alloc().calculateNewCapacity(targetCapacity, maxCapacity) 方法的实现。
    • 新容量newCapacity 一定是 2 的幂数。

  8. int ensureWritable(int minWritableBytes, boolean force): 也是扩展缓存区容量。

    @Override
public int ensureWritable(int minWritableBytes, boolean force) {
    ensureAccessible();
    checkPositiveOrZero(minWritableBytes, "minWritableBytes");

    // minWritableBytes 在当前缓存区可写区域内，直接返回
    if (minWritableBytes <= writableBytes()) {
        return 0;
    }

    // 最大容量
    final int maxCapacity = maxCapacity();
    // 读索引
    final int writerIndex = writerIndex();
    // 待写字节大小 minWritableBytes，超出缓存区最大可写区域 `maxCapacity - writerIndex`
    if (minWritableBytes > maxCapacity - writerIndex) {
        // 非强制或者当前容量就是最大容量
        if (!force || capacity() == maxCapacity) {
            // 返回 1
            return 1;
        }

        // 将缓存区容量设置成最大容量maxCapacity
        capacity(maxCapacity);
        return 3;
    }

    // 扩展缓存区大小
    int fastWritable = maxFastWritableBytes();
    int newCapacity = fastWritable >= minWritableBytes ? writerIndex + fastWritable
            : alloc().calculateNewCapacity(writerIndex + minWritableBytes, maxCapacity);

    // Adjust to the new capacity.
    capacity(newCapacity);
    return 2;
}

    扩展缓存区只会分为四种情况:

    • 待写字节 minWritableBytes 小于或者等于缓存区可写区域大小 writableBytes()，不需要扩展容量，直接返回 0。
    • 待写字节 minWritableBytes 小于或者等于缓存区最大可写区域大小 maxCapacity - writerIndex，能够正常扩展容量，返回 2。
    • 待写字节 minWritableBytes 超出缓存区最大可写区域 maxCapacity - writerIndex, 不能正常扩展容量，那么分为两种情况：如果非强制(!force)或者当前容量就是最大容量时返回1,否则就将缓存区容量设置成最大容量并返回3。也就是 1 和 3 的区别，1 没有改变缓存区容量，而 3 重新设置的缓存区容量。

3.3 get 系列方法

我们知道 get 系列方法都从还钱指定索引位置读取数据。

3.3.1 获取基本数据类型的方法

首先我们讲解一下有符号和无符号类型的区别，因为 netty 提供了很多获取无符号基本数据类型的方法。

  • 对于有符号数据类型来说，它的最高位表示正负，即0 表示正数，1 表示负数。而对于无符号数据类型来说，它只表示正数，最高位也是数据内容。例如对于 byte 类型数据，有符号byte范围就是 -128 -->127，而无符号byte范围就是 0 --> 255。
  • 所以将有符号数据变成无符号数据也很简单，就是将自身字节数据全部保留。例如获取无符号byte类型数据，就是(short) (getByte(index) & 0xFF)。
  • 注意: 0xFF 是一个 int 类型数据，那么 getByte(index) 的值也要由byte 提升到 int 类型，然后才能计算，而类型提升时，如果是正数，那么高位全部补零，如果是负数，那么高位全部补1。而0xFF正好是高三个字节全是0,地位一个字节数据全是1，因此就正好保存了getByte(index) byte字节中全部数据。

  1. 获取 byte 类型数据

    @Override
public byte getByte(int index) {
    checkIndex(index);
    return _getByte(index);
}
protected abstract byte _getByte(int index);
@Override
public boolean getBoolean(int index) {
    return getByte(index) != 0;
}
@Override
public short getUnsignedByte(int index) {
    return (short) (getByte(index) & 0xFF);
}
    • 通过 getBoolean(int index) ，我们知道 boolean 类型在缓存区存储的是一个 byte 字节，0 表示false, 非零就是 true。
    • _getByte(int index) 方法是由子类实现的，不同类型的ByteBuf 实现不一样。
    • 必须通过 checkIndex(index) 方法，检查是否越界。
    • 通过 (getByte(index) & 0xFF) 获取无符号byte 值。

  2. 获取 short 类型数据

    @Override
public short getShort(int index) {
    checkIndex(index, 2);
    return _getShort(index);
}

protected abstract short _getShort(int index);

@Override
public short getShortLE(int index) {
    checkIndex(index, 2);
    return _getShortLE(index);
}

protected abstract short _getShortLE(int index);

@Override
public int getUnsignedShort(int index) {
    return getShort(index) & 0xFFFF;
}

@Override
public int getUnsignedShortLE(int index) {
    return getShortLE(index) & 0xFFFF;
}
    • 有两个需要子类复写的方法 _getShort(int index) 和 _getShortLE(int index)。
    • 必须通过 checkIndex(index, 2) 方法，检查是否越界。
    • 通过 & 0xFFFF 获取无符号的 short 类型。

  3. 获取 Medium类型数据
    这是一个三个字节的整形数据，java 中没有对应类型，只能用 int 类型表示。

    @Override
public int getUnsignedMedium(int index) {
    checkIndex(index, 3);
    return _getUnsignedMedium(index);
}

protected abstract int _getUnsignedMedium(int index);

@Override
public int getUnsignedMediumLE(int index) {
    checkIndex(index, 3);
    return _getUnsignedMediumLE(index);
}

protected abstract int _getUnsignedMediumLE(int index);

@Override
public int getMedium(int index) {
    int value = getUnsignedMedium(index);
     // 三字节最高位是不是 `1`
    if ((value & 0x800000) != 0) {
         // 通过 `0xff000000` 将 value 值转换成负数
        value |= 0xff000000;
    }
    return value;
}

@Override
public int getMediumLE(int index) {
    int value = getUnsignedMediumLE(index);
    // 三字节最高位是不是 `1`
    if ((value & 0x800000) != 0) {
        // 通过 `0xff000000` 将 value 值转换成负数
        value |= 0xff000000;
    }
    return value;
}
    • 有两个需要子类复写的方法 _getUnsignedMedium(int index) 和 _getUnsignedMediumLE(int index)。
    • 必须通过 checkIndex(index, 3) 方法，检查是否越界。
    • 你会发现不一样的点，Medium 类型数据，直接获取的是无符号Medium类型，有符号Medium类型反而要做特殊处理。即判断三字节最高位是不是 1 (即(value & 0x800000) != 0), 然后转成负数 value |= 0xff000000。主要是因为 java 是没有三个字节的整形数据的。

  4. 获取 int类型数据

    @Override
 public int getInt(int index) {
     checkIndex(index, 4);
     return _getInt(index);
 }
 protected abstract int _getInt(int index);
 @Override
 public int getIntLE(int index) {
     checkIndex(index, 4);
     return _getIntLE(index);
 }
 protected abstract int _getIntLE(int index);
 @Override
 public long getUnsignedInt(int index) {
     return getInt(index) & 0xFFFFFFFFL;
 }
 @Override
 public long getUnsignedIntLE(int index) {
     return getIntLE(index) & 0xFFFFFFFFL;
 }
    • 有两个需要子类复写的方法 _getInt(int index) 和 _getIntLE(int index)。
    • 必须通过 checkIndex(index, 4) 方法，检查是否越界。
    • 通过 & 0xFFFFFFFFL 获取无符号的 short 类型。注意 0xFFFFFFFFL 是一个 long 类型。

  5. 获取 long类型数据

     @Override
 public long getLong(int index) {
     checkIndex(index, 8);
     return _getLong(index);
 }
 protected abstract long _getLong(int index);
 @Override
 public long getLongLE(int index) {
     checkIndex(index, 8);
     return _getLongLE(index);
 }
 protected abstract long _getLongLE(int index);
    • 有两个需要子类复写的方法 _getLong(int index) 和 _getLongLE(int index)。
    • 必须通过 checkIndex(index, 8) 方法，检查是否越界。
    • long 类型不需要无符号long 类型了

  6. 其他基础类型方法

     @Override
 public char getChar(int index) {
     return (char) getShort(index);
 }
 @Override
 public float getFloat(int index) {
     return Float.intBitsToFloat(getInt(index));
 }
 public float getFloatLE(int index) {
     return Float.intBitsToFloat(getIntLE(index));
 }
 @Override
 public double getDouble(int index) {
     return Double.longBitsToDouble(getLong(index));
 }
 public double getDoubleLE(int index) {
     return Double.longBitsToDouble(getLongLE(index));
 }
    • 你会发现单浮点型float 数据是通过 int 类型存储的，双浮点型 double 数据是通过 long 类型存储的。

3.3.2 其他方法

  1. getBytes(int index, byte[] dst) 
    @Override
public ByteBuf getBytes(int index, byte[] dst) {
    getBytes(index, dst, 0, dst.length);
    return this;
}
  2. getBytes(int index, ByteBuf dst) 和 getBytes(int index, ByteBuf dst, int length) 
     @Override
 public ByteBuf getBytes(int index, ByteBuf dst) {
     getBytes(index, dst, dst.writableBytes());
     return this;
 }

 @Override
 public ByteBuf getBytes(int index, ByteBuf dst, int length) {
     getBytes(index, dst, dst.writerIndex(), length);
     dst.writerIndex(dst.writerIndex() + length);
     return this;
 }

    会改变目标缓存区 dst 的写索引 writerIndex 的值。

  3. getCharSequence(int index, int length, Charset charset) 
     @Override
 public CharSequence getCharSequence(int index, int length, Charset charset) {
     if (CharsetUtil.US_ASCII.equals(charset) || CharsetUtil.ISO_8859_1.equals(charset)) {
         // ByteBufUtil.getBytes(...) will return a new copy which the AsciiString uses directly
         return new AsciiString(ByteBufUtil.getBytes(this, index, length, true), false);
     }
     return toString(index, length, charset);
 }

3.4 set 系列方法

3.4.1 设置基本数据类型的方法

  1. 设置 byte 类型数据 
     @Override
 public ByteBuf setByte(int index, int value) {
     checkIndex(index);
     _setByte(index, value);
     return this;
 }
 protected abstract void _setByte(int index, int value);
 @Override
 public ByteBuf setBoolean(int index, boolean value) {
     setByte(index, value? 1 : 0);
     return this;
 }
    • 需要子类复写 _setByte(int index, int value) 方法
    • 注意，虽然设置byte 类型数据，但是传递的值 value 却是 int 类型。
  2. 设置 short 类型数据 
     @Override
 public ByteBuf setShort(int index, int value) {
     checkIndex(index, 2);
     _setShort(index, value);
     return this;
 }
 protected abstract void _setShort(int index, int value);
 @Override
 public ByteBuf setShortLE(int index, int value) {
     checkIndex(index, 2);
     _setShortLE(index, value);
     return this;
 }
 protected abstract void _setShortLE(int index, int value);
 @Override
 public ByteBuf setChar(int index, int value) {
     setShort(index, value);
     return this;
 }
    • 需要子类复写 _setShort(int index, int value) 和 _setShortLE(int index, int value)方法
    • 注意，虽然设置short 类型数据，但是传递的值 value 却是 int 类型。
    • char 类型也是用short 类型数据存储的。
  3. 设置 medium 类型数据 
     @Override
 public ByteBuf setMedium(int index, int value) {
     checkIndex(index, 3);
     _setMedium(index, value);
     return this;
 }
 protected abstract void _setMedium(int index, int value);
 @Override
 public ByteBuf setMediumLE(int index, int value) {
     checkIndex(index, 3);
     _setMediumLE(index, value);
     return this;
 }
 protected abstract void _setMediumLE(int index, int value);
    • 需要子类复写 _setMedium(int index, int value) 和 _setMediumLE(int index, int value)方法
    • 注意，虽然设置medium 类型数据，但是传递的值 value 却是 int 类型。
  4. 设置 int 类型数据 
     @Override
 public ByteBuf setInt(int index, int value) {
     checkIndex(index, 4);
     _setInt(index, value);
     return this;
 }
 protected abstract void _setInt(int index, int value);
 @Override
 public ByteBuf setIntLE(int index, int value) {
     checkIndex(index, 4);
     _setIntLE(index, value);
     return this;
 }
 protected abstract void _setIntLE(int index, int value);
 @Override
 public ByteBuf setFloat(int index, float value) {
     setInt(index, Float.floatToRawIntBits(value));
     return this;
 }
    • 需要子类复写 _setInt(int index, int value) 和 _setIntLE(int index, int value)方法
    • 单精度浮点型float数据使用 int类型存储的。
  5. 设置 long 类型数据 
    @Override
 public ByteBuf setLong(int index, long value) {
     checkIndex(index, 8);
     _setLong(index, value);
     return this;
 }
 protected abstract void _setLong(int index, long value);
 @Override
 public ByteBuf setLongLE(int index, long value) {
     checkIndex(index, 8);
     _setLongLE(index, value);
     return this;
 }
 protected abstract void _setLongLE(int index, long value);
 @Override
 public ByteBuf setDouble(int index, double value) {
     setLong(index, Double.doubleToRawLongBits(value));
     return this;
 }
    • 需要子类复写 _setLong(int index, long value) 和 _setLongLE(int index, long value)方法
    • 双精度浮点型double数据使用 long类型存储的。

3.4.2 其他方法

  1. setBytes(int index, byte[] src) 
     @Override
 public ByteBuf setBytes(int index, byte[] src) {
     setBytes(index, src, 0, src.length);
     return this;
 }
  2. setBytes(int index, ByteBuf src) 和 setBytes(int index, ByteBuf src, int length) 
     @Override
 public ByteBuf setBytes(int index, ByteBuf src) {
     setBytes(index, src, src.readableBytes());
     return this;
 }
 @Override
 public ByteBuf setBytes(int index, ByteBuf src, int length) {
     checkIndex(index, length);
     ObjectUtil.checkNotNull(src, "src");
     if (checkBounds) {
         checkReadableBounds(src, length);
     }

     setBytes(index, src, src.readerIndex(), length);
     src.readerIndex(src.readerIndex() + length);
     return this;
 }
    • 会改变源缓存区src 的读索引readerIndex的值。
  3. setZero(int index, int length) 
     @Override
 public ByteBuf setZero(int index, int length) {
     if (length == 0) {
         return this;
     }

     // 检查边界
     checkIndex(index, length);

     // 计算 length/8 的值，因为 long 类型是8个字节，优先使用 long 设置
     int nLong = length >>> 3;
     // 不足 8 的值
     int nBytes = length & 7;
     // 先使用 long 来设置
     for (int i = nLong; i > 0; i --) {
         _setLong(index, 0);
         index += 8;
     }
     // 如果正好等于4，那么直接用一个 int 类型就可以了
     if (nBytes == 4) {
         _setInt(index, 0);
         // Not need to update the index as we not will use it after this.
     } else if (nBytes < 4) {
         // 不足 4 个字节，那么就直接使用 byte 字节设置，这里就不用 short再来一层了
         for (int i = nBytes; i > 0; i --) {
             _setByte(index, (byte) 0);
             index ++;
         }
     } else {
         _setInt(index, 0);
         index += 4;
         // 不足 4 个字节，那么就直接使用 byte 字节设置，这里就不用 short再来一层了
         for (int i = nBytes - 4; i > 0; i --) {
             _setByte(index, (byte) 0);
             index ++;
         }
     }
     return this;
 }

    就是将缓存区从 index 起 length 长度的区域的值都设置成 0，这路使用了技巧，优先使用 long 类型设置，不足 8个字节的部分，使用int类型 和 byte 类型设置。

3.5 read 系列方法

3.5.1 读取基本数据类型的方法

  1. 读取 byte 类型数据 
     private void checkReadableBytes0(int minimumReadableBytes) {
     ensureAccessible();
     if (checkBounds && readerIndex > writerIndex - minimumReadableBytes) {
         throw new IndexOutOfBoundsException(String.format(
                 "readerIndex(%d) + length(%d) exceeds writerIndex(%d): %s",
                 readerIndex, minimumReadableBytes, writerIndex, this));
     }
 }

 @Override
 public byte readByte() {
     checkReadableBytes0(1);
     int i = readerIndex;
     byte b = _getByte(i);
     readerIndex = i + 1;
     return b;
 }
 @Override
 public boolean readBoolean() {
     return readByte() != 0;
 }
 @Override
 public short readUnsignedByte() {
     return (short) (readByte() & 0xFF);
 }
    • 通过 checkReadableBytes0(1) 方法检查是否越界。
    • 获取完数据之后，将读索引readerIndex值增加1。
  2. 读取 short 类型数据 
     @Override
 public short readShort() {
     checkReadableBytes0(2);
     short v = _getShort(readerIndex);
     readerIndex += 2;
     return v;
 }
 @Override
 public short readShortLE() {
     checkReadableBytes0(2);
     short v = _getShortLE(readerIndex);
     readerIndex += 2;
     return v;
 }
 @Override
 public int readUnsignedShort() {
     return readShort() & 0xFFFF;
 }
 @Override
 public int readUnsignedShortLE() {
     return readShortLE() & 0xFFFF;
 }
 @Override
 public char readChar() {
     return (char) readShort();
 }
    • 通过 checkReadableBytes0(2) 方法检查是否越界。
    • 获取完数据之后，将读索引readerIndex值增加2。
    • 字符char类型是通过 short 类型读取的。
  3. 读取 medium 类型数据 
     @Override
 public int readMedium() {
     int value = readUnsignedMedium();
     if ((value & 0x800000) != 0) {
         value |= 0xff000000;
     }
     return value;
 }
 @Override
 public int readMediumLE() {
     int value = readUnsignedMediumLE();
     if ((value & 0x800000) != 0) {
         value |= 0xff000000;
     }
     return value;
 }
 @Override
 public int readUnsignedMedium() {
     checkReadableBytes0(3);
     int v = _getUnsignedMedium(readerIndex);
     readerIndex += 3;
     return v;
 }
 @Override
 public int readUnsignedMediumLE() {
     checkReadableBytes0(3);
     int v = _getUnsignedMediumLE(readerIndex);
     readerIndex += 3;
     return v;
 }
    • 通过 checkReadableBytes0(3) 方法检查是否越界。
    • 获取完数据之后，将读索引readerIndex值增加3。
  4. 读取 int 类型数据 
     @Override
 public int readInt() {
     checkReadableBytes0(4);
     int v = _getInt(readerIndex);
     readerIndex += 4;
     return v;
 }
 @Override
 public int readIntLE() {
     checkReadableBytes0(4);
     int v = _getIntLE(readerIndex);
     readerIndex += 4;
     return v;
 }
 @Override
 public long readUnsignedInt() {
     return readInt() & 0xFFFFFFFFL;
 }
 @Override
 public long readUnsignedIntLE() {
     return readIntLE() & 0xFFFFFFFFL;
 }
 @Override
 public float readFloat() {
     return Float.intBitsToFloat(readInt());
 }
    • 通过 checkReadableBytes0(4) 方法检查是否越界。
    • 获取完数据之后，将读索引readerIndex值增加4。
    • 单精度浮点数 float 数据，是通过 int 类型转换的。
  5. 读取 long 类型数据 
     @Override
 public long readLong() {
     checkReadableBytes0(8);
     long v = _getLong(readerIndex);
     readerIndex += 8;
     return v;
 }

 @Override
 public long readLongLE() {
     checkReadableBytes0(8);
     long v = _getLongLE(readerIndex);
     readerIndex += 8;
     return v;
 }
 @Override
 public double readDouble() {
     return Double.longBitsToDouble(readLong());
 }
    • 通过 checkReadableBytes0(8) 方法检查是否越界。
    • 获取完数据之后，将读索引readerIndex值增加8。
    • 双精度浮点数 double 数据，是通过 long 类型转换的。

3.5.2 读取一小段缓存区

  1. readBytes(int length) 
     @Override
 public ByteBuf readBytes(int length) {
     checkReadableBytes(length);
     if (length == 0) {
         return Unpooled.EMPTY_BUFFER;
     }

     // 创建新的缓存区，初始容量initialCapacity就是 length，最大容量是maxCapacity
     ByteBuf buf = alloc().buffer(length, maxCapacity);
     // 通过 writeBytes 方法将本缓存区从readerIndex 起 length长度的数据写入到新创建的缓存区buf
     buf.writeBytes(this, readerIndex, length);
     // 增加读索引的值
     readerIndex += length;
     // 返回新创建的缓存区
     return buf;
 }

    这个将本缓存区的一段内容复制到新创建的缓存区中，它们不共享数据，不会互相影响。

  2. readSlice(int length) 和 readRetainedSlice(int length) 
     @Override
 public ByteBuf readSlice(int length) {
     checkReadableBytes(length);
     ByteBuf slice = slice(readerIndex, length);
     readerIndex += length;
     return slice;
 }

 @Override
 public ByteBuf readRetainedSlice(int length) {
     checkReadableBytes(length);
     ByteBuf slice = retainedSlice(readerIndex, length);
     readerIndex += length;
     return slice;
 }

    通过 slice 和 retainedSlice 方法，获取本缓存区一段内容的新缓存区，但是这个新缓存区与本缓存区共享内存，也就说更改本缓冲区对应区域的内容，那么新缓存区的内容也会改变。

3.5.3 读取数据到字节数组

    @Override
    public ByteBuf readBytes(byte[] dst) {
        readBytes(dst, 0, dst.length);
        return this;
    }
    @Override
    public ByteBuf readBytes(byte[] dst, int dstIndex, int length) {
        checkReadableBytes(length);
        getBytes(readerIndex, dst, dstIndex, length);
        readerIndex += length;
        return this;
    }

最终还是通过 getBytes(int index, byte[] dst, int dstIndex, int length) 方法实现。不过它增加了读索引 readerIndex 的值。

3.5.4 读取数据到其他缓存区ByteBuf 

    @Override
    public ByteBuf readBytes(ByteBuf dst) {
        readBytes(dst, dst.writableBytes());
        return this;
    }
    @Override
    public ByteBuf readBytes(ByteBuf dst, int length) {
        if (checkBounds) {
            if (length > dst.writableBytes()) {
                throw new IndexOutOfBoundsException(String.format(
                        "length(%d) exceeds dst.writableBytes(%d) where dst is: %s", length, dst.writableBytes(), dst));
            }
        }
        readBytes(dst, dst.writerIndex(), length);
        dst.writerIndex(dst.writerIndex() + length);
        return this;
    }
    @Override
    public ByteBuf readBytes(ByteBuf dst, int dstIndex, int length) {
        checkReadableBytes(length);
        getBytes(readerIndex, dst, dstIndex, length);
        readerIndex += length;
        return this;
    }
  • 最后通过调用 getBytes(int index, ByteBuf dst, int dstIndex, int length) 方法实现
  • 如果从目标缓存区dst 的写索引writerIndex处，那么就增加目标缓存区dst 的写索引值，因此前两个方法会增加目标缓存区dst 的写索引值。
  • 它们都增加本缓存区读索引值。

3.5.5 读取数据到 NIO缓存区ByteBuffer 

    @Override
    public ByteBuf readBytes(ByteBuffer dst) {
        int length = dst.remaining();
        checkReadableBytes(length);
        getBytes(readerIndex, dst);
        readerIndex += length;
        return this;
    }

3.5.6 读取数据到IO流

    @Override
    public int readBytes(GatheringByteChannel out, int length)
            throws IOException {
        checkReadableBytes(length);
        int readBytes = getBytes(readerIndex, out, length);
        readerIndex += readBytes;
        return readBytes;
    }

    @Override
    public int readBytes(FileChannel out, long position, int length)
            throws IOException {
        checkReadableBytes(length);
        int readBytes = getBytes(readerIndex, out, position, length);
        readerIndex += readBytes;
        return readBytes;
    }

    @Override
    public ByteBuf readBytes(OutputStream out, int length) throws IOException {
        checkReadableBytes(length);
        getBytes(readerIndex, out, length);
        readerIndex += length;
        return this;
    }

3.5.7 跳过一段区域

    @Override
    public ByteBuf skipBytes(int length) {
        checkReadableBytes(length);
        readerIndex += length;
        return this;
    }

3.6 write 系列方法

所有 write 方法都通过 ensureWritable0 方法来确保有足够的写入空间
，并且写入之后都会增加写索引 writerIndex 的值。

3.6.1 写入基本数据类型的方法

  1. 写入 byte 类型数据
 @Override
 public ByteBuf writeBoolean(boolean value) {
     writeByte(value ? 1 : 0);
     return this;
 }

 @Override
 public ByteBuf writeByte(int value) {
     ensureWritable0(1);
     _setByte(writerIndex++, value);
     return this;
 }
  1. 写入 short 类型数据 
     @Override
 public ByteBuf writeShort(int value) {
     ensureWritable0(2);
     _setShort(writerIndex, value);
     writerIndex += 2;
     return this;
 }
 @Override
 public ByteBuf writeShortLE(int value) {
     ensureWritable0(2);
     _setShortLE(writerIndex, value);
     writerIndex += 2;
     return this;
 }
 @Override
 public ByteBuf writeChar(int value) {
     writeShort(value);
     return this;
 }
  2. 写入 medium 类型数据 
     @Override
 public ByteBuf writeMedium(int value) {
     ensureWritable0(3);
     _setMedium(writerIndex, value);
     writerIndex += 3;
     return this;
 }

 @Override
 public ByteBuf writeMediumLE(int value) {
     ensureWritable0(3);
     _setMediumLE(writerIndex, value);
     writerIndex += 3;
     return this;
 }
  3. 写入 int 类型数据 
     @Override
 public ByteBuf writeInt(int value) {
     ensureWritable0(4);
     _setInt(writerIndex, value);
     writerIndex += 4;
     return this;
 }

 @Override
 public ByteBuf writeIntLE(int value) {
     ensureWritable0(4);
     _setIntLE(writerIndex, value);
     writerIndex += 4;
     return this;
 }
 @Override
 public ByteBuf writeFloat(float value) {
     writeInt(Float.floatToRawIntBits(value));
     return this;
 }
  4. 写入 long 类型数据 
     @Override
 public ByteBuf writeLong(long value) {
     ensureWritable0(8);
     _setLong(writerIndex, value);
     writerIndex += 8;
     return this;
 }

 @Override
 public ByteBuf writeLongLE(long value) {
     ensureWritable0(8);
     _setLongLE(writerIndex, value);
     writerIndex += 8;
     return this;
 }
 @Override
 public ByteBuf writeDouble(double value) {
     writeLong(Double.doubleToRawLongBits(value));
     return this;
 }

3.6.2 将字节数组的数据写入到缓存区

    @Override
    public ByteBuf writeBytes(byte[] src) {
        writeBytes(src, 0, src.length);
        return this;
    }
    @Override
    public ByteBuf writeBytes(byte[] src, int srcIndex, int length) {
        ensureWritable(length);
        setBytes(writerIndex, src, srcIndex, length);
        writerIndex += length;
        return this;
    }

3.6.3 将其他缓存区ByteBuf数据写入到缓存区

    @Override
    public ByteBuf writeBytes(ByteBuf src) {
        writeBytes(src, src.readableBytes());
        return this;
    }
    @Override
    public ByteBuf writeBytes(ByteBuf src, int length) {
        if (checkBounds) {
            checkReadableBounds(src, length);
        }
        writeBytes(src, src.readerIndex(), length);
        src.readerIndex(src.readerIndex() + length);
        return this;
    }
    @Override
    public ByteBuf writeBytes(ByteBuf src, int srcIndex, int length) {
        ensureWritable(length);
        setBytes(writerIndex, src, srcIndex, length);
        writerIndex += length;
        return this;
    }

前两个方法会增加源缓存区src 读索引readerIndex 的值。

3.6.4 将NIO 缓存区ByteBuffer的数据写入到缓存区

    @Override
    public ByteBuf writeBytes(ByteBuffer src) {
        int length = src.remaining();
        ensureWritable0(length);
        setBytes(writerIndex, src);
        writerIndex += length;
        return this;
    }

3.6.5 从输入流中读取数据写入到缓存区

    @Override
    public int writeBytes(InputStream in, int length)
            throws IOException {
        ensureWritable(length);
        int writtenBytes = setBytes(writerIndex, in, length);
        if (writtenBytes > 0) {
            writerIndex += writtenBytes;
        }
        return writtenBytes;
    }

    @Override
    public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
        ensureWritable(length);
        int writtenBytes = setBytes(writerIndex, in, length);
        if (writtenBytes > 0) {
            writerIndex += writtenBytes;
        }
        return writtenBytes;
    }
    @Override
    public int writeBytes(FileChannel in, long position, int length) throws IOException {
        ensureWritable(length);
        int writtenBytes = setBytes(writerIndex, in, position, length);
        if (writtenBytes > 0) {
            writerIndex += writtenBytes;
        }
        return writtenBytes;
    }

返回值表示写入缓存区的数据大小。

3.7 搜索

3.7.1 简单搜索

  1. indexOf(int fromIndex, int toIndex, byte value) 
     @Override
 public int indexOf(int fromIndex, int toIndex, byte value) {
     if (fromIndex <= toIndex) {
         return ByteBufUtil.firstIndexOf(this, fromIndex, toIndex, value);
     }
     return ByteBufUtil.lastIndexOf(this, fromIndex, toIndex, value);
 }

    当fromIndex <= toIndex 是升序搜索，反之就是降序搜索。
    搜索范围，如果是升序，那么就是 fromIndex(包括)到toIndex(排除)；如果是降序，那么就是fromIndex(排除)到toIndex(包括)，因为这个时候fromIndex的值比 toIndex 大。因此就是小的值会被包括，大的值会被排除。

  2. bytesBefore() 系列方法 
     @Override
 public int bytesBefore(byte value) {
     return bytesBefore(readerIndex(), readableBytes(), value);
 }

 @Override
 public int bytesBefore(int length, byte value) {
     checkReadableBytes(length);
     return bytesBefore(readerIndex(), length, value);
 }

 @Override
 public int bytesBefore(int index, int length, byte value) {
     int endIndex = indexOf(index, index + length, value);
     if (endIndex < 0) {
         return -1;
     }
     return endIndex - index;
 }
    • 最终通过 indexOf 方法来实现的。
    • 它只能升序查找。

3.7.2 复杂搜索

  1. 升序复杂搜索

     @Override
 public int forEachByte(ByteProcessor processor) {
     ensureAccessible();
     try {
         return forEachByteAsc0(readerIndex, writerIndex, processor);
     } catch (Exception e) {
         PlatformDependent.throwException(e);
         return -1;
     }
 }
 @Override
 public int forEachByte(int index, int length, ByteProcessor processor) {
     checkIndex(index, length);
     try {
         return forEachByteAsc0(index, index + length, processor);
     } catch (Exception e) {
         PlatformDependent.throwException(e);
         return -1;
     }
 }
 int forEachByteAsc0(int start, int end, ByteProcessor processor) throws Exception {
     // 升序遍历
     for (; start < end; ++start) {
         // 当 processor.process 返回false，表示查找到了，返回查找到的位置
         if (!processor.process(_getByte(start))) {
             return start;
         }
     }

     // -1 表示查找不到
     return -1;
 }

    注意当 processor.process 方法返回false，表示查找到了。

  2. 降序复杂搜索

     @Override
 public int forEachByteDesc(ByteProcessor processor) {
     ensureAccessible();
     try {
         return forEachByteDesc0(writerIndex - 1, readerIndex, processor);
     } catch (Exception e) {
         PlatformDependent.throwException(e);
         return -1;
     }
 }
 @Override
 public int forEachByteDesc(int index, int length, ByteProcessor processor) {
     checkIndex(index, length);
     try {
         return forEachByteDesc0(index + length - 1, index, processor);
     } catch (Exception e) {
         PlatformDependent.throwException(e);
         return -1;
     }
 }
 int forEachByteDesc0(int rStart, final int rEnd, ByteProcessor processor) throws Exception {
     // 降序遍历
     for (; rStart >= rEnd; --rStart) {
         // 当 processor.process 返回false，表示查找到了，返回查找到的位置
         if (!processor.process(_getByte(rStart))) {
             return rStart;
         }
     }
     // -1 表示查找不到
     return -1;
 }

3.8 复制缓存区

    @Override
    public ByteBuf copy() {
        return copy(readerIndex, readableBytes());
    }

最后调用 copy(readerIndex, readableBytes()) 方法，交给子类实现。

3.9 派生的缓冲区

 @Override
    public ByteBuf duplicate() {
        ensureAccessible();
        return new UnpooledDuplicatedByteBuf(this);
    }

    @Override
    public ByteBuf retainedDuplicate() {
        return duplicate().retain();
    }

    @Override
    public ByteBuf slice() {
        return slice(readerIndex, readableBytes());
    }

    @Override
    public ByteBuf retainedSlice() {
        return slice().retain();
    }

    @Override
    public ByteBuf slice(int index, int length) {
        ensureAccessible();
        return new UnpooledSlicedByteBuf(this, index, length);
    }

    @Override
    public ByteBuf retainedSlice(int index, int length) {
        return slice(index, length).retain();
    }

3.10 转换成 ByteBuffer 

    @Override
    public ByteBuffer nioBuffer() {
        return nioBuffer(readerIndex, readableBytes());
    }

    @Override
    public ByteBuffer[] nioBuffers() {
        return nioBuffers(readerIndex, readableBytes());
    }

这实现了这两个方法，剩余方法交给具体子类实现。

你可能感兴趣的:(Netty源码_AbstractByteBuf详解)

  • 下载Android源码 赛非斯
    repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
  • 【计算机网络】第 3 问：电路交换、报文交换、分组交换之间的区别？ 孤独打铁匠Julian #计算机408考研面试计算机网络计算机网络网络
    电路交换、报文交换、分组交换之间的区别？省流图详解电路交换电路交换的优点电路交换的缺点建立连接时间长的原因报文交换报文交换的优点报文交换的缺点分组交换分组交换的优点分组交换的缺点比较总结省流图详解电路交换在进行数据传输前，两个结点之间必须先建立一条专用（双方独占）的物理通信路径（由通信双方之间的交换设备和链路逐段连接而成），该路径可能经过许多中间结点。这一路径在整个数据传输期间一直被独占，直到通信
  • C#WPF控件TextBlock详解 未来无限 C#WPF程序设计c#wpf控件TextBlock回车换行多行显示强制回车换行
    本文讲解WPF控件TextBlock。目录定义常用属性实例如何实现自动换行？如何强制回车换行？
  • C#WPF窗口类 Window详解 未来无限 C#WPF程序设计c#wpfwindow类详解
    本文详解C#WPF窗口类Window。目录定义Window窗体属性Window窗体事件实例演示定义WPF中的Window继承于ContentControl，内部可以承载一个Content，当然，借助于ItemsControl或Panel，Content也可以向下添加多个
  • 自动化测试 —— Pytest fixture及conftest详解 咖啡加剁椒③ 软件测试pytest功能测试软件测试自动化测试程序人生职场和发展
    前言fixture是在测试函数运行前后，由pytest执行的外壳函数。fixture中的代码可以定制，满足多变的测试需求，包括定义传入测试中的数据集、配置测试前系统的初始状态、为批量测试提供数据源等等。fixture是pytest的精髓所在，类似unittest中setup/teardown，但是比它们要强大、灵活很多，它的优势是可以跨文件共享。一、Pytestfixture1.pytestfix
  • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
  • Unity3D 制作MMORPG 3D地图编辑器详解 Thomas_YXQ 3d编辑器Unity3D游戏开发unity开发语言
    前言在MMORPG游戏中，地图编辑器是一个非常重要的工具，可以帮助开发者快速创建复杂的游戏地图。本文将详细介绍如何使用Unity3D制作一个简单的MMORPG3D地图编辑器。对惹，这里有一个游戏开发交流小组，希望大家可以点击进来一起交流一下开发经验呀！创建地图编辑器界面首先，我们需要创建一个新的Unity项目，并在场景中创建一个空的GameObject作为地图编辑器的主要控制器。然后，我们可以使用
  • 【Git安装及使用学习笔记】 可可西里啊 零零散散的学习笔记git学习笔记c++qt5
    Git学习笔记Git安装Git创建本地版本库以及提交文件使用Git提交代码到码云使用Git从码云拉取代码参考博客Git安装这里参考Git详细安装教程（详解Git安装过程的每一个步骤）Git创建本地版本库以及提交文件1.查看git版本信息：git--version2.设置对应用户名与邮箱地址gitconfig--globaluser.name"your_usernamegitconfig--glob
  • DCGAN中的生成器和识别器代码详解 YYLin-AI DCGAN深度学习celebatensorflow
    #DCGAN中的生成器我自己写的有一个封装好的用于生成器和识别器的卷积操作但是在这个代码中我没有使用我自己的代码#原因想绍一下tensorflow自带的函数所以找了一个以前在书上的代码申明一下这个不是原创但是原来代码中有几处不符合DCGAN的要求所以就做了一些修改转载链接没有就直接写成原创建议看代码之前先看看DCGAN的特点，然后再看代码中如何实这些特点的这样会更有帮助DCGAN（深度卷积的对抗生
  • 优化选址问题 | 基于和声搜索算法求解基站选址问题含Matlab源码 天天酷科研 优化选址问题（LP）matlab和声搜索算法基站选址问题
    目录问题代码问题和声搜索算法（HarmonySearch,HS）是一种模拟音乐创作过程中乐师们凭借自己的记忆，通过反复调整各乐器的音调，直至达到最美和声状态为启发，通过反复调整解向量的各分量来寻求全局最优解的智能优化算法。下面是一个基于和声搜索算法求解基站选址问题的Matlab伪代码框架。请注意，这个框架是一个基本的实现，你可能需要根据你的具体问题和约束条件进行调整和优化。代码%和声搜索算法求解基
  • html版本号 webpack_html-webpack-plugin详解 weixin_39994949 html版本号webpack
    引言最近在react项目中初次用到了html-webapck-plugin插件，用到该插件的两个主要作用：为html文件中引入的外部资源如script、link动态添加每次compile后的hash，防止引用缓存的外部文件问题可以生成创建html入口文件，比如单页面可以生成一个html文件入口，配置N个html-webpack-plugin可以生成N个页面入口有了这种插件，那么在项目中遇到类似上面
  • webpack-loader详解 奶昔不会射手 webpack前端node.js
    一、loader的分类1.pre:前置loader2.normal:普通loader3.inline:内联loader4.post:后置loader二、执行顺序pre>normal>inline>post,相同类型的loader执行顺序为：从右到左，从下到上module:{rules:[{enforce:"pre",//通过这个参数来定义loader的类型，默认是normal类型test:/\.j
  • Java学习笔记04：Java_数组 JasonYangQ Javajava
    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
  • Netty服务器结合WebSocke协议监听和接收数据 beiback 服务器问题Java服务器运维netty
    目录1.pom依赖2.配置属性3.创建netty服务器4.建立监听和响应5.创建启动器6.前端static下页面7.前端js8.注意异常问题9.创建netty服务器--使用守护线程1.pom依赖io.nettynetty-all4.1.86.Final2.配置属性application.properties#启动端口server.port=8088server.servlet.context-pa
  • HTML背景带视频的个人炫酷引导页源码 erthre 源码php
    正文:一款简洁大气得个人团队引导HTML单页，非常不错，LOGO支持自行更改替换，可以拿来做为团队官网也可以个人，只是单页没有后台。程序:wwhtxs.lanzouq.com/if6oE0i26ohi图片:
  • npm 常用命令详解 马卫斌 前端工程师 npm
    npm（NodePackageManager）是Node.js的包管理器，它允许用户方便地安装、共享和管理Node.js项目中的依赖。以下是一些npm常用命令的详解：1.查看npm版本npm-v这个命令用于查看本地已安装的npm版本。2.初始化项目npminit运行这个命令会引导你创建一个package.json文件，该文件包含了项目的元数据，如名称、版本、描述、作者等信息以及项目的依赖配置。若要
  • 向开发板上移植ip工具：将ip工具移植到开发板系统中 凌肖战 linuxarm开发网络
    一.简介前面一篇文章对ip工具源码进行了交叉编译，生成了ip工具。文章如下：向开发板上移植ip工具：交叉编译ip工具-CSDN博客本文对生成的ip工具进行移植，即移植到开发板系统中，并确定是否可用。二.向开发板上移植ip工具：将ip工具移植到开发板系统中
  • 抖音返利平台哪个最高？叫什么？详解抖音返利平台哪个最高 全网优惠分享
    我想大家都在疑惑抖音返利平台哪个最高？叫什么？今天就为大家详解抖音返利平台哪个最高1.氧惠你平时在淘宝买东西，你通过氧惠依然是去淘宝买东西，你平时是在拼多多买东西，你通过氧惠还是去拼多多买东西，该在哪里买还是在哪里买，该买什么还是买什么。但是通过氧惠，不仅可以省钱，还可以赚钱，只要用户注册氧惠就可以享受超级折扣特权。比如你正常充话费是不是没有折扣？充100就是100，就算便宜也就便宜几毛钱，而在氧
  • 【WPF应用5】WPF中的TextBlock控件：属性与事件详解及示例 白话Learning WPFwpf
    在WPF（WindowsPresentationFoundation）开发中，TextBlock控件是一个常用的元素，用于显示静态或动态文本内容。它提供了丰富的属性和事件，使得开发者能够灵活地控制文本的显示样式和响应用户的交互行为。本文将详细介绍TextBlock控件的属性和事件，并提供一个完整的示例程序。1.TextBlock控件的基本属性TextBlock控件的属性可以分为布局属性、外观属性、
  • nginx upstream server主动健康监测模块添加https检测功能【上】 码农心语 nginx学习c++开发LINUXnginxhttps运维健康检测upstreamproxy
    1缘起  前面的《nginxupstreamserver主动健康检测模块ngx_http_upstream_check_module使用和源码分析》系列已经分析了ngx_http_upstream_check_module的实现原理，并且在借助这个模块的框架实现了一个udp健康检测的新功能。  但是ngx_http_upstream_check_module还缺乏基于https监测上游服务器健康状
  • GB28181 —— 4、C++编写GB28181设备端，完成将.h264文件读取转发至GB28181服务并可播放（附源码） 信必诺 GB28181GB28181eXosip2Qth264
    效果 源码说明     主要功能模拟设备端，完成注册、注销、心跳等，完成读取.h264文件实时转ps格式后封包rtp进行推送给服务端播放。 源码/****@remark:ps头的封装,里面的具体数据的填写已经占位，可以参考标准*@param:pData[in]填充ps头数据的地址*s64Src[in]时间戳*@return:0success,othersfailed*/intgb28181_mak
  • 【设计模式】单例模式详解 略知java的景初 JAVA设计模式java设计模式
    单例模式：定义：确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。为了防止出现重复的创建。单例模式是JAVA中最简单的设计模式之一。属于创建型设计模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有一个对象被创建。这个类提供了访问唯一对象的方法，可以直接访问，不需要new。饿汉式：程序起始就初始化对象。publicclassHungr
  • 软件评测师写作专栏之指令流水线知识01 昊洋_写作的匠心
    各位学员大家好，相信大家在学习计算机系统构成及硬件基础知识时，感觉指令流水线这部分比较难，其实只要大家掌握了解题方法，很快就可以定位出正确答案，接下来就带领大家一起来学习一下！1、例题：某指令流水线由4段组成，各段所需的时间如下图所示。连续输入8条指令时的吞吐率（单位时间内流水线所完成的任务数或输出的结果数）为（）？例题1A、8/56ΔtB、8/32ΔtC、8/28ΔtD、8/24Δt【昊洋详解】
  • 【CentOS7】【Nginx】CentOS7源码编译并安装nginx 小丛的知识窝 nginx运维服务器
    更新yumsudoyumupdate-y安装必要的编译工具和依赖项sudoyuminstall-ygccpcre-developenssl-develzlib-devel下载Nginx源代码wgethttp://nginx.org/download/nginx-1.20.1.tar.gz解压源代码包tar-zxvfnginx-1.20.1.tar.gz进入解压后的目录cdnginx-1.20.1配
  • npm 包管理工具：常用命令详解与使用指南 LXHYouth node.jsnpmnode.js
    npm常用命令的更详细解释和使用场景：npminit详细说明：此命令用于初始化一个新的Node.js项目。它会创建一个package.json文件，其中包含项目的基本信息，如名称、版本、描述、入口点（mainfile）、测试命令、git仓库地址等。这个文件是项目的心脏，记录了项目的元数据和依赖关系。使用示例：在命令行中输入npminit，然后根据提示填写项目信息。如果你想要快速生成一个默认的pac
  • .net framework日志和.net core的区别详解 白话Learning C#/.net.net.netcorec#
    在软件开发过程中，日志记录是一个非常重要的功能，它可以帮助开发人员了解应用程序的运行状况，跟踪错误和性能问题，以及进行应用程序的调试。.NETFramework和.NETCore都是微软推出的应用程序开发框架，它们都提供了日志记录的功能，但是两者之间存在一些区别。1.实现方式1.1日志记录在.NETFramework中的实现.NETFramework使用System.Diagnostics命名空间
  • LeetCode_32_困难_最长有效括号 Lins号丹 LeetCode进阶之路leetcode算法
    文章目录1.题目2.思路及代码实现详解（Java）2.1动态规划2.2不需要额外空间的算法1.题目给你一个只包含'('和')'的字符串，找出最长有效（格式正确且连续）括号子串的长度。示例1：输入：s=s=s="(()"输出：222解释：最长有效括号子串是"()"示例2：输入：s=s=s=")()())"输出：444解释：最长有效括号子串是"()()"示例3：输入：s=s=s=""输出：000提示：
  • TCP重传机制详解——03DSACK 没有理想的不伤心 LinuxTCPtcp/ip网络服务器
    TCP重传机制详解——03DSACK什么是DSACKDSACK是指"DuplicateSelectiveAcknowledgment"，即重复选择性确认。在TCP通信中，DSACK机制允许接收方向发送方发送有关重复数据包的信息，以帮助发送方更准确地处理重传和丢包情况。当接收方收到重复的数据包时，会发送DSACK选项给发送方，告知发送方已经接收到了重复的数据包。发送方收到DSACK选项后，可以根据这
  • Maxwell监听mysql的binlog日志变化写入kafka消费者 澄绪猿 mysqlkafka数据库
    一.环境：maxwell:v1.29.2(从1.30开始maxwell停止了对java8的使用，改为为11)maxwell1.29.2这个版本对mysql8.0以后的缺少utf8mb3字符的解码问题，需要对原码中加上一个部分内容：具体也给大家做了总结：关于v1.29.2版本的Maxwell存在于mysql8.0后版本部分源码字符集处理确实问题-CSDN博客二.程序这里还是那一个kafka模拟器来实
  • Linux笔记之ldd命令详解 努力脱单的害羞男孩 Linux笔记linux笔记服务器
    Linux笔记之ldd命令详解codereview!ldd是一个用于查看可执行文件或共享库所依赖的共享库的命令。它可以帮助你了解可执行文件或库与系统上安装的共享库之间的依赖关系。下面是ldd命令的详细解释：语法：ldd[选项][可执行文件或共享库]常用选项：-v：显示详细信息，包括符号版本信息。-u：显示未使用的直接依赖项。-d：执行数据重定位并报告缺失的对象。-r：执行数据和函数重定位，并报告缺
  • java杨辉三角 3213213333332132 java基础
    package com.algorithm; /** * @Description 杨辉三角 * @author FuJianyong * 2015-1-22上午10:10:59 */ public class YangHui { public static void main(String[] args) { //初始化二维数组长度 int[][] y
  • 《大话重构》之大布局的辛酸历史 白糖_ 重构
    《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。   背景         公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
  • 电驴链接在线视频播放源码 dubinwei 源码电驴播放器视频ed2k
    本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。 项目源码： http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。 项目源码依赖于两个库项目，库项目一链接： http://git.oschina.
  • Javascript中函数的toString()方法 周凡杨 JavaScriptjstoStringfunctionobject
    简述     The toString() method returns a string representing the source code of the function.     简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。 句法     function.
  • struts处理自定义异常 g21121 struts
    很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。 非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。 此处我们用的是非运行时异常，首先定义一个异常LoginException: /** * 类描述：登录相
  • Linux中find常见用法示例 510888780 linux
    Linux中find常见用法示例 ·find   path   -option   [   -print ]   [ -exec   -ok   command ]   {} \; find命令的参数；
  • SpringMVC的各种参数绑定方式 Harry642 springMVC绑定表单
    1. 基本数据类型(以int为例，其他类似)： Controller代码： @RequestMapping("saysth.do") public void test(int count) { } 表单代码： <form action="saysth.do" method="post&q
  • Java 获取Oracle ROWID aijuans javaoracle
    A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. The oracle.sql.ROWID class i
  • java获取方法的参数名 antlove javajdkparametermethodreflect
    reflect.ClassInformationUtil.java package reflect; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.Modifier; import javassist.bytecode.CodeAtt
  • JAVA正则表达式匹配 查找 替换 提取操作 百合不是茶 java正则表达式替换提取查找
    正则表达式的查找;主要是用到String类中的split();       String str;      str.split();方法中传入按照什么规则截取,返回一个String数组   常见的截取规则: str.split("\\.")按照.来截取 str.
  • Java中equals()与hashCode()方法详解 bijian1013 javasetequals()hashCode()
    一.equals()方法详解     equals()方法在object类中定义如下：  public boolean equals(Object obj) { return (this == obj); }    很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
  • 精通Oracle10编程SQL(4)使用SQL语句 bijian1013 oracle数据库plsql
    --工资级别表 create table SALGRADE ( GRADE NUMBER(10), LOSAL NUMBER(10,2), HISAL NUMBER(10,2) ) insert into SALGRADE values(1,0,100); insert into SALGRADE values(2,100,200); inser
  • 【Nginx二】Nginx作为静态文件HTTP服务器 bit1129 HTTP服务器
     Nginx作为静态文件HTTP服务器 在本地系统中创建/data/www目录，存放html文件(包括index.html) 创建/data/images目录，存放imags图片 在主配置文件中添加http指令   http { server { listen 80; server_name
  • kafka获得最新partition offset blackproof kafkapartitionoffset最新
    kafka获得partition下标，需要用到kafka的simpleconsumer   import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.
  • centos 7安装docker两种方式 ronin47
          第一种是采用yum 方式              yum install -y docker           
  • java-60-在O(1)时间删除链表结点 bylijinnan java
    public class DeleteNode_O1_Time { /** * Q 60 在O(1)时间删除链表结点 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点 * * Assume the list is: * head->...->nodeToDelete->mNode->nNode->..
  • nginx利用proxy_cache来缓存文件 cfyme cache
    user  zhangy users; worker_processes 10; error_log  /var/vlogs/nginx_error.log  crit; pid        /var/vlogs/nginx.pid; #Specifies the value for ma
  • [JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题 comsci 嵌入式
        假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做：     string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))"     定义一个0整数c,然后用这个整数c去
  • 如何集成支付宝官方文档 dai_lm android
    官方文档下载地址 https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 集成的必要条件 1. 需要有自己的Server接收支付宝的消息 2. 需要先制作app，然后提交支付宝审核，通过后才能集成 调试的时候估计会真的扣款，请注意
  • 应该在什么时候使用Hadoop datamachine hadoop
    原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 --------------------------------------------万能的分割线-------------------------------- 有人问我，“你在大数据和Hado
  • 在GridView中对于有外键的字段使用关联模型进行搜索和排序 dcj3sjt126com yii
    在GridView中使用关联模型进行搜索和排序 首先我们有两个模型它们直接有关联: class Author extends CActiveRecord { ... } class Post extends CActiveRecord { ... function relations() { return array( '
  • 使用NSString 的格式化大全 dcj3sjt126com Objective-C
    格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
  • 使用activeX插件对象object滚动有重影 蕃薯耀 activeX插件滚动有重影
      使用activeX插件对象object滚动有重影   <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
  • SpringMVC4零配置 hanqunfeng springmvc4
    基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。     项目说明如下： 1.db.sql是项目中用到的表，数据库使用的是oracle11g 2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 3.默认项目为零配置启动，如果需要更改启动方式，请
  • 《开源框架那点事儿16》：缓存相关代码的演变 j2eetop 开源框架
    问题引入 上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。 该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。 当然去看相关实现代代码的时候，大致是下面的样子。 [java] view plain copy print ? public vo
  • AngularJS浅析 kvhur JavaScript
    概念 AngularJS is a structural framework for dynamic web apps. 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm Directive 扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
  • 架构师之jdk的bug排查(一)---------------split的点号陷阱 nannan408 split
    1.前言.    jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 2.代码 String[] paths = "object.object2.prop11".split("'"); System.ou
  • 如何对10亿数据量级的mongoDB作高效的全表扫描 quentinXXZ mongodb
      本文链接:  http://quentinXXZ.iteye.com/blog/2149440 一、正常情况下，不应该有这种需求 首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。 说一下，
  • C语言算法之水仙花数 qiufeihu c算法
    /** * 水仙花数 */ #include <stdio.h> #define N 10 int main() { int x,y,z; for(x=1;x<=N;x++) for(y=0;y<=N;y++) for(z=0;z<=N;z++) if(x*100+y*10+z == x*x*x
  • JSP指令 wyzuomumu jsp
    jsp指令的一般语法格式： <%@ 指令名 属性 =”值 ” %> 常用的三种指令： page,include,taglib page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他