ByteBuffer:写入，然后返回到缓冲区的开头，并在之前写入的所有数据之前写入(前置?)

Question

我对使用ByteBuffer仍然有点不稳定。 我想做的是将数据写入 ByteBuffer，然后转到 ByteBuffer 的开头并在所有这些数据之前写入一个字节（数据包的有效负载被写入，然后在标头前面加上。 我该怎么做？

图：

缓冲区开头为：

|  PAYLOAD  |

添加操作代码标头后的缓冲区（在我想做的事情之后）：

|  HEADER  |  PAYLOAD  |

| 只是那种数据的分隔符，而不是字面上的任何东西。

Answer 1

您正在寻找的内容称为"分散-聚集I/O"，它由ScatteringByteChannel.read(ByteBuffer[])和GatheringByteChannel.write(ByteBuffer[])支持。请注意数组。这些接口受FileChannel、SocketChannel、DatagramSocketChannel和管道通道的支持。

Answer 2

ByteBuffer bbuf = ByteBuffer.allocate(HEADER_SZ + PAYLOAD_SZ);
bbuf.position(HEADER_SZ);
for(int i=0; i < PAYLOAD_SZ; i++)
    bbuf.put(payload[i]);
bbuf.rewind();
for(int i=0; i < HEADER_SZ; i++)
    bbuf.put(header[i]);

我已经对源数据的字节索引做出了假设。最好批量放置，但这是一个开始。

Answer 3

我将为这个问题添加另一个答案，因为我今天遇到了这个问题，并且接受的解决方案对我的情况没有那么有帮助。

为了解决我的问题，我定义了一个int，该将表示ByteBuffer将包含的数据量（以字节为单位），以及如下所示的Queue<Consumer<ByteBuffer>>：

/**
 * An {@code int} representing the amount
 * of bytes that this {@link OutgoingPacket}
 * will send.
 */
private int size;
/**
 * A {@link Queue} that lazily writes data to the
 * backing {@link ByteBuffer}.
 */
private final Queue<Consumer<ByteBuffer>> queue = new ArrayDeque<>();

接下来，我创建了诸如putByte、putInt等方法。

/**
 * Writes a single {@code byte} to this
 * {@link Packet}'s payload.
 *
 * @param b
 *      An {@code int} for ease-of-use,
 *      but internally down-casted to a
 *      {@code byte}.
 * @return
 *      The {@link Packet} to allow for
 *      chained writes.
 */
public OutgoingPacket putByte(int b) {
    size++;
    queue.offer(payload -> payload.put((byte) b));
    return this;
}

最后，我创建了一个send方法，其中分配ByteBuffer并传递相应的数据。

/**
 * Transmits this {@link OutgoingPacket} to
 * a specific client.
 *
 * @param channels
 *      A variable amount of {@link AsynchronousSocketChannel}s.
 *
 * TODO: Send to {@link Client} instead.
 */
public void send(AsynchronousSocketChannel... channels) {
    /*
     * Allocate a new buffer with the size of
     * the data being added, as well as an extra
     * two bytes to account for the opcode and the
     */
    ByteBuffer payload = ByteBuffer.allocate(size + 2);
    /*
     * Write the opcode to the buffer.
     */
    payload.put((byte) opcode);
    /*
     * Write the length to the buffer.
     */
    payload.put((byte) size);
    /*
     * Add the rest of the data to the buffer.
     */
    queue.forEach(consumer -> consumer.accept(payload));
    /*
     * Flip the buffer so the client can immediately
     * read it on arrival.
     */
    payload.flip();
    /*
     * Write the buffer to the channels.
     */
    for (AsynchronousSocketChannel channel : channels) {
        channel.write(payload);
    }
}

希望这将为将来遇到此问题的人提供见解！