Question

我的问题是如何从服务器示例“切割”1024个字节的包裹中接收数据，因为当答案来自服务器时，如2个部分的数据包，我不知道如何解决这个问题。防爆。当第一个数据包到达时，服务器通知的大小是1988，接收的是1444，那没关系，但是当第二个数据包到达时，通知的大小是808333347并且收到540，1444 + 540 = 1984的总和是正确的。我不知道这个号码808333347来自哪里。我正在谷歌搜索这个解决方案然后所有教授使用udp我需要这个为TCP / IP连接。请帮帮我解决。

班级：

public class Connection implements Runnable {
    private static  Connection     instance;
    private         SocketChannel  channel        = null;
    private         int            port           = 0;
    private         int            service        = 0;
    private final   int            SOCKET_TIMEOUT = 15 * 1000;
    private final   int            SOCKET_BYTES   = 16 * 1024;
    private final   Charset        CHARSET        = Charset.forName("ISO-8859-1");
    private         String         host           = null; 
    private         String         message        = "";

public Connection(String host, String port){
    this.host       = host;
    this.port       = Integer.parseInt(port);
}
public static Connection createConnection(String host, String port) {
     if(instance == null){
        instance = new Conexao(host, port);
     }
     return instance;
}
public void connect(){
    try{
        instance.channel = SocketChannel.open();
        instance.channel.socket().setSoTimeout(SOCKET_TIMEOUT);
        instance.channel.socket().setTcpNoDelay(false);
        instance.channel.socket().setKeepAlive(true);
        instance.channel.connect(new InetSocketAddress(host, port));
        instance.channel.configureBlocking(false);
    } catch (IOException ioe){
        Log.d(TAG, ioe.getMessage() + " " + ioe.toString());
    }
}
@Override public void run() {
    if(null != instance.channel){
        if(instance.channel.isConnected()){
            Log.d(TAG, "CHANNEL CONNECTED = TRUE");
        } else {
            Log.d(TAG, "CHANNEL CONNECTED = FALSE");
        }
    } else {
        instance.connect();
        Log.d(TAG, "CHANNEL CONNECTED");
    }
    sendMessage();
    while(true){
        receiveMessage();
    }
}
public void sendMessage() {
    int         size    = message.length();
    ByteBuffer  buffer  = ByteBuffer.allocate(4 + 4 + size);
    buffer.putInt(service).putInt(size).put(message.getBytes());
    buffer.flip();
    for(int i = 0; i < size; i++){
        try {
            instance.channel.write(buffer);
        } catch (IOException ioe) {
            Log.d(TAG, ioe.getMessage() + " " + ioe.toString());
        }
    }
}
public void receiveMessage(){
    ByteBuffer  buffer      = ByteBuffer.allocateDirect(SOCKET_BYTES);
    int         bytesReaded = 0;
    String      received    = "";
    buffer.clear();
    try {
        do {
            bytesReaded = instance.channel.read(buffer);
        } while (bytesReaded == 0);
    } catch (IOException ioe) {
        Log.d(TAG, ioe.getMessage() + " " + ioe.toString());
    }
    buffer.flip();
    int size    =  buffer.getInt();
    received    += CHARSET.decode(buffer);
    Log.d(TAG,"SERVIÇE: " + size + "/" + received.length() + " MSG: " + received);
}
public int getService() {
    return service;
}
public void setService(int service) {
    this.service = service;
}
public String getMessage() {
    return message;
}
public void setMessage(String message) {
    this.message = message;
}

我改变了这样的功能：

public void receiveMessage(){
    ByteBuffer  buffer      = ByteBuffer.allocateDirect(SOCKET_BYTES);
    int         bytesReaded = 0;
    String      received    = "";
    buffer.clear();
    try {
        bytesReaded = instance.channel.read(buffer);
    } catch (IOException ioe) {
        Log.d(TAG, ioe.getMessage() + " " + ioe.toString());
    }
    buffer.flip();
    if(bytesReaded >= 4){
        if(size == 0 && size < 5000) size = buffer.getInt();
        received    += CHARSET.decode(buffer);
        answer      += received;
        if(size == answer.length()){
            Log.d(TAG,"SERVICE: " + size + "/" + answer.length() + " " + answer);
        }
    }
}

但现在它非常难看。

Answer 1

您无法控制数据从任何一端到达TCP连接的方式。它可以一次到达一个字节或以任何其他量子到达数据大小。您必须在接收端循环，直到您拥有所需的一切。您需要对套接字的大小使用相同的读取缓冲区，以便为此循环累积数据，并保留可能属于后续消息的任何数据。

'尺寸通知'不能像你说的那么大。这只是一个错误造成的。可能你会失去同步。

Answer 2

问题是，使用TCP，您无法控制数据的发送方式（碎片化）。您不知道使用channel.read(...)读取了多少数据。

您在循环中调用receiveMessage()，在那里将读取数据填充到缓冲区中。

你无法确定

int size    =  buffer.getInt();

是您收到的邮件的大小（仅在第一次调用时，，如果您收到至少4个字节。）。你必须记住前4个接收的字节，大小，（因为你使用getInt()），然后你必须channel.read(...)，直到你收到 size bytes ，之后 - ＆GT;处理下一条消息。

还要重复使用缓冲区。由于您使用NIO（和非阻止），我还建议您使用select()，而不是忙于阅读。

Java nio从通道读取bytebuffer

2 个答案: