1

我有一个客户端/服务器应用程序，它使用BufferedOutputStream / BufferedInputStream. 通信协议如下：

  1. 发送部分：

    • 第一个字节是要执行的动作
    • 接下来的 4 个字节是消息的长度
    • 接下来的 x 个字节（x=消息长度）是消息本身

  2. 接收部分：

    • 读取第一个字节以获取操作
    • 读取接下来的 4 个字节以获取消息长度
    • 读取 x（在上一步中获得）字节以获取消息

现在的问题是，有时当我在服务器部分发送消息的长度（例如：23045）时，当我收到它时，我会得到一个巨大的整数（例如：123106847）。

一个重要的线索是，只有当消息超过多个字符（在我的情况下 > 10K）时才会发生这种情况，如果我发送了一条较小的消息（例如 4-5k），一切都会按预期工作。

客户端发送部分（outputStream/inputStream 为 BufferedXXXStream 类型）：

    private String getResponseFromServer( NormalizerActionEnum action, String message) throws IOException{

        writeByte( action.id());
        writeString( message);
        flush(;

        return read();
    }

    private String read() throws IOException{
        byte[] msgLen = new byte[4];
        inputStream.read(msgLen);
        int len = ByteBuffer.wrap(msgLen).getInt();
        byte[] bytes = new byte[len];
        inputStream.read(bytes);

        return new String(bytes);
    }

    private void writeByte( byte msg) throws IOException{
        outputStream.write(msg);
    }

    private void writeString( String msg) throws IOException{

        byte[] msgLen = ByteBuffer.allocate(4).putInt(msg.length()).array();

        outputStream.write(msgLen);
        outputStream.write(msg.getBytes());
    }

    private void flush() throws IOException{
        outputStream.flush();
    }

服务器部分（_input/_output 是 BufferedXXXStream 类型）

private byte readByte() throws IOException, InterruptedException {
    int b =  _input.read();
    while(b==-1){
        Thread.sleep(1);
        b = _input.read();
    }

    return (byte) b;
}

private String readString() throws IOException, InterruptedException {
    byte[] msgLen = new byte[4];
    int s = _input.read(msgLen);
    while(s==-1){
        Thread.sleep(1);
        s = _input.read(msgLen);
    }   

    int len = ByteBuffer.wrap(msgLen).getInt();     
    byte[] bytes = new byte[len];
    s = _input.read(bytes);
    while(s==-1){
        Thread.sleep(1);
        s = _input.read(bytes);
    }

    return new String(bytes);
}

private void writeString(String message) throws IOException {
    byte[] msgLen = ByteBuffer.allocate(4).putInt(message.length()).array();
    _output.write(msgLen);
    _output.write(message.getBytes());
    _output.flush();
}

....

byte cmd = readByte();
String message = readString();

任何帮助将不胜感激。如果您需要更多详细信息，请告诉我。

更新：由于Jon Skeet和EJP的评论，我意识到服务器上的读取部分有一些毫无意义的操作，但抛开这一点，我终于明白了问题所在：关键是我保持流全长打开应用程序和前几次我发送的消息长度我能够在服务器端读取它但是正如Jon Skeet指出的那样，数据不会一次全部到达所以当我尝试再次读取消息长度时我我实际上是从消息本身中读取信息，这就是为什么我有虚假消息长度的原因。

〜而不是发送数据长度然后一次读取它，我发送它没有长度，我一次读取一个字节，直到完美工作的字符串结尾

private String readString() throws IOException, InterruptedException {
    StringBuilder sb = new StringBuilder();
    byte[] bytes = new byte[100];
    int s = 0;
    int index=0;
    while(true){
        s = _input.read();
        if(s == 10){
            break;
        }
        bytes[index++] = (byte) (s);
        if(index == bytes.length){
            sb.append(new String(bytes));
            bytes = new byte[100];
            index=0;
        }           
    }
    if(index > 0){
        sb.append(new String(Arrays.copyOfRange(bytes, 0, index)));
    }

    return sb.toString();
}
4

2 回答 2

4

看这个：

byte[] bytes = new byte[len];
s = _input.read(bytes);
while(s==-1){
    Thread.sleep(1);
    s = _input.read(bytes);
}

return new String(bytes);

首先，循环是没有意义的：唯一read会返回 -1 的时间是它是否关闭，在这种情况下循环不会帮助你。

其次，您忽略了数据包含多个数据块的可能性。您假设如果您设法获得任何数据，那么您已经获得了所有数据。相反，您应该像这样循环：

int bytesRead = 0;
while (bytesRead < bytes.length) {
    int chunk = _input.read(bytes, bytesRead, bytes.length - bytesRead);
    if (chunk == -1) {
        throw new IOException("Didn't get as much data as we should have");
    }
    bytesRead += chunk;
}

请注意，您所有其他 InputStream.read调用也假定您已设法读取数据，并且确实已读取您需要的所有数据。

哦，您正在使用平台默认编码在二进制数据和文本数据之间进行转换——这不是一个好主意。

你有什么理由不使用DataInputStream这个DataOutputStream吗？目前，您正在重新发明轮子，并在处理错误时这样做。

于 2013-06-19T07:38:00.543 回答
1

您发送的代码被窃听：

byte[] msgLen = ByteBuffer.allocate(4).putInt(message.length()).array();
_output.write(msgLen);
_output.write(message.getBytes());

您将字符数作为消息长度发送，但之后将消息转换为字节。根据平台编码 String.getBytes() 可以给你比字符更多的字节。

你永远不应该假设 String.length() 与 String.getBytes().length 有任何关系！这些是不同的概念，绝不能混为一谈。

于 2013-06-19T13:34:44.707 回答