StreamCorruptedException:无效类型代码：64

Question

我试图发送消息对象从服务器模块到客户端模块。不幸的是，它抛出java.io.StreamCorruptedExctive：无效类型代码：64错误。有人知道下面的代码有什么问题吗？

客户端来自服务器模块的类

    private boolean needToRun;
    public final Socket socket;
    private OutputStream outputStream;
    private InputStream inputStream;
    private ObjectOutputStream objOut;
    private ObjectInputStream objIn;

    public Client(Socket socket) {
        this.needToRun = true;
        this.socket = socket;
        try {
            this.outputStream = socket.getOutputStream();
            this.inputStream = socket.getInputStream();
            this.objOut = new ObjectOutputStream(outputStream);
            this.objIn = new ObjectInputStream(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        run();
    }

    public void send(Message msg) {
        try {
            objOut.writeObject(msg);
            objOut.flush();
            objOut.reset();
        } catch (Exception ex){
            ex.printStackTrace();
        }

    }

    public void close() {
        needToRun = false;
    }

    public void run() {
        new Thread(() -> {
            while(needToRun) {
                try {
                    int amount = inputStream.available();
                    if (amount != 0) {
                        Message msg = (Message) objIn.readObject();
                        receivedContent(msg);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

    public void receivedContent(Message msg) {
        for (Client connection : Server.clients) {
            connection.send(msg);
        }
    }

客户端模块中的Client类看起来相同，但receivedContent看起来如下所示：

    public void receivedContent(Message msg) {
        String errorName = msg.content().trim();
        MainPane.addLabel(errorName);
    }

最后一个Server类，它接受套接字连接：

            while (true) {
                System.out.println("running");
                try {
                    System.out.println("Waiting for client...");
                    Socket socket = serverSocket.accept();
                    clients.add(new Client(socket));

                } catch (Exception e) {
                    if (!serverSocket.isClosed()) {
                        stopServer();
                    }
                    break;
                }
            }

Answer 1

在客户端类的run方法中

public void run() {
        new Thread(() -> {
            while(needToRun) {
                try {
                    int amount = inputStream.available();
                    if (amount != 0) {
                        Message msg = (Message) objIn.readObject();
                        receivedContent(msg);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

这个代码

int amount = inputStream.available();
if (amount != 0) {
  Message msg = (Message) objIn.readObject();
  receivedContent(msg);
}

这很不可靠。即使inputStream。available（）返回1，即1字节可用，然后假设整个对象已准备好读取，因此会得到损坏的数据

假设您知道对象的最大大小，您可以创建一个标准大小的字节数组，并按如下方式读取

byte[] buffer=new byte[8192] //byte array of size 8KB

int length;
while((length=inputStream.read(buffer))>0) //read as much data into this buffer as possible
{
 try(ObjectInputStream objIn=new ObjectInputStream(new ByteArrayInputStream(buffer,0,length)))  //read length bytes of data from this buffer
 {
   Message msg = (Message) objIn.readObject();
   receivedContent(msg);
 }
}

未来的一个建议是将字节数据编码到一个头文件中，可能是这样的

give an byte array of any length encode it as follows

 4 bytes [Integer]         N bytes
------------------------|-------------- 
length of your array    | Your actual data

这样，如果没有足够的数据可用，您可以知道何时等待，还可以将多个对象编码到outputstream中