使用AcknoEdgement从java中的tcp套接字读取数据包

我们正在创建一个java侦听器来读取在特定服务器ip和端口上配置的多个设备数据

设备发送一个登录包

服务器将返回ack数据包作为响应

接收到ack后，设备将发送信息包

服务器读取该数据 在最后一步中，我们卡住了，我们正在发送ack，但无法从设备中获取信息包（尽管我们通过开源软件检查生成的ack）。对于ref，我们正在附加代码。（如果我们删除while（true）然后获取登录数据包，但在此之后，套接字连接将关闭，设备将再次发送登录数据包，但如果我们保留该数据包，则不会获取任何数据包）

//--------------主类------------------------------------------

公共班机{

public static void main(String[] args) {
    Server server = new Server(listen_port, pool_size, pm);
    new Thread(server).start();
    logger.info("Server Started .....");
}

} //--------------------------------------------------------------

公共类服务器实现可运行{

private ServerSocket serverSocket = null;
public void run()

private Socket m_clientSocket;
private String imei;

public Handler(Socket socket) {
    this.m_clientSocket = socket;
}

public void run() {
    DataOutputStream clientDataOS = null;
    DataInputStream clientDataIS = null;
    try {
        logger.info("data is coming");
        m_clientSocket.setSoTimeout(300000);
        clientDataIS = new DataInputStream(this.m_clientSocket.getInputStream());
        clientDataOS = new DataOutputStream(this.m_clientSocket.getOutputStream());
        while (true) {
            String pkt = "";
            logger.info("Waiting for input strem");
            byte[] byte_pkt = IOUtils.toByteArray(clientDataIS);
            logger.info("Got input stream");
            for (byte b : byte_pkt) {
                pkt += String.format("%02X ", b);
            }
            logger.info(pkt);
            if (byte_pkt.length > 0) {
                logger.info("");
                if (Byte.valueOf(byte_pkt[3]) == 1) {
                    imei = "xyz";
                    logger.info("login packet");
                    byte[] rep_pkt = Utils.getReceptionPacket(byte_pkt);//send back to device
                    clientDataOS.write(rep_pkt);
                    clientDataOS.flush();
                } else if (Byte.valueOf(byte_pkt[3]) == 34) {
                    logger.info("information packet");
                    Utils.processPackets(byte_pkt);
                } else {
                    logger.info("Unkown packet format");
                }
                logger.info(imei);
            } else {
                logger.info("InputStream is empty.");
            }
        }
    } catch (SocketException se) {
        logger.error("Failure on reading data", se);
    } catch (IOException e) {
        logger.error("Failure on reading data", e);
    } catch (Exception e) {
        logger.error("Error while processing data", e);
    } finally {
        try {
            IOUtils.closeQuietly(clientDataOS);
            IOUtils.closeQuietly(clientDataIS);
            this.m_clientSocket.close();
        } catch (IOException e) {
            logger.debug("Error when sending out response ::", e);
        }
    }
}

{ 此.m_停止=错误

while (!this.m_stop)
  try {
    this.m_pool.execute(new Handler(this.serverSocket.accept()));
  } catch (IOException e) {
    LOGGER.debug("Unable to accept connection ", e);
  }

} }

//--------------------------------------------------------------

公共类处理程序实现可运行{

private ServerSocket serverSocket = null;
public void run()

private Socket m_clientSocket;
private String imei;

public Handler(Socket socket) {
    this.m_clientSocket = socket;
}

public void run() {
    DataOutputStream clientDataOS = null;
    DataInputStream clientDataIS = null;
    try {
        logger.info("data is coming");
        m_clientSocket.setSoTimeout(300000);
        clientDataIS = new DataInputStream(this.m_clientSocket.getInputStream());
        clientDataOS = new DataOutputStream(this.m_clientSocket.getOutputStream());
        while (true) {
            String pkt = "";
            logger.info("Waiting for input strem");
            byte[] byte_pkt = IOUtils.toByteArray(clientDataIS);
            logger.info("Got input stream");
            for (byte b : byte_pkt) {
                pkt += String.format("%02X ", b);
            }
            logger.info(pkt);
            if (byte_pkt.length > 0) {
                logger.info("");
                if (Byte.valueOf(byte_pkt[3]) == 1) {
                    imei = "xyz";
                    logger.info("login packet");
                    byte[] rep_pkt = Utils.getReceptionPacket(byte_pkt);//send back to device
                    clientDataOS.write(rep_pkt);
                    clientDataOS.flush();
                } else if (Byte.valueOf(byte_pkt[3]) == 34) {
                    logger.info("information packet");
                    Utils.processPackets(byte_pkt);
                } else {
                    logger.info("Unkown packet format");
                }
                logger.info(imei);
            } else {
                logger.info("InputStream is empty.");
            }
        }
    } catch (SocketException se) {
        logger.error("Failure on reading data", se);
    } catch (IOException e) {
        logger.error("Failure on reading data", e);
    } catch (Exception e) {
        logger.error("Error while processing data", e);
    } finally {
        try {
            IOUtils.closeQuietly(clientDataOS);
            IOUtils.closeQuietly(clientDataIS);
            this.m_clientSocket.close();
        } catch (IOException e) {
            logger.debug("Error when sending out response ::", e);
        }
    }
}

---

}

在循环中调用

IOUtils.toByteArray（）

没有意义。我正在使用它从inputstream读取第二次数据。如果它不正确，那么如何使用它。它将读取流，直到流结束。只有一端。两次调用它不会提供更多的数据。在这种情况下，你根本不能使用这种方法。如何正确操作取决于您的应用程序协议。你需要阅读回复信息，当你拥有所有信息时停止阅读。