java代码实现一个 SocketUtil，实现1个接口：readFromStream 输入参数为socket的OutputStream，进行一次数据读取，第一个是占6个字节的HEAD，内容为常量"BTVRV1",当匹配时，读取第二个参数，占2个字节，为数据包类型，第三个为数据长度占4个字节，需要从小端转为大端，转化为int，第四个为data负载，为数据长度大小的byte，第5个参数为CRC值，占4个字节，也需要小端转大端为int 当HEAD不匹配时，就将数据拼接到缓冲区中，等待下一次读取。当缓冲区的数据拼接后包含“BTRV1”时，服务器即可开始解析报文，使用bytebuffer

以下是一个可能的实现：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;

public class SocketUtil {
    private static final String HEAD = "BTVRV1";
    private static final int HEAD_LENGTH = 6;
    private static final int TYPE_LENGTH = 2;
    private static final int LENGTH_LENGTH = 4;
    private static final int CRC_LENGTH = 4;

    public static void readFromStream(OutputStream out, InputStream in) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = in.read(buffer.array(), buffer.position(), buffer.remaining());
        if (bytesRead > 0) {
            buffer.position(buffer.position() + bytesRead);
            while (buffer.position() >= HEAD_LENGTH + TYPE_LENGTH + LENGTH_LENGTH + CRC_LENGTH) {
                buffer.flip();
                byte[] headBytes = new byte[HEAD_LENGTH];
                buffer.get(headBytes);
                String head = new String(headBytes);
                if (head.equals(HEAD)) {
                    byte[] typeBytes = new byte[TYPE_LENGTH];
                    buffer.get(typeBytes);
                    short type = ByteBuffer.wrap(typeBytes).getShort();
                    byte[] lengthBytes = new byte[LENGTH_LENGTH];
                    buffer.get(lengthBytes);
                    int length = Integer.reverseBytes(ByteBuffer.wrap(lengthBytes).getInt());
                    if (buffer.remaining() >= length + CRC_LENGTH) {
                        byte[] dataBytes = new byte[length];
                        buffer.get(dataBytes);
                        byte[] crcBytes = new byte[CRC_LENGTH];
                        buffer.get(crcBytes);
                        int crc = Integer.reverseBytes(ByteBuffer.wrap(crcBytes).getInt());
                        // do something with the data
                        out.write(dataBytes);
                    } else {
                        buffer.compact();
                        break;
                    }
                } else {
                    buffer.compact();
                    break;
                }
                buffer.compact();
            }
        }
    }
}

这个实现使用了 ByteBuffer 来处理输入流中的数据，首先读取尽可能多的数据到缓冲区中，然后循环处理缓冲区中的数据，直到无法再读取出一个完整的数据包为止。对于每个数据包，先读取头部，如果头部不匹配就跳过，否则读取类型、长度、数据和 CRC 值，然后可以对数据进行处理。如果缓冲区中的数据不足以构成一个完整的数据包，就将剩余的数据移到缓冲区的开头，等待下一次读取。