[java.nio] StreamCorruptedException when deserializing objects

Question

Hello everybody!
I made a messaging (chat) program using java.io where all the client-server communication is done by serializing small objects. Now I would like to covert the server side to the NIO concept and I'm already struck. I successfully pass objects to the client and the client deserializes them, but only the first one! When it try to read the second it fails with a StreamCorruptedException.
Here�s a sample (testing) code. In the server run() method I first serialize a string, then get its byte array from ByteArrayOutputStream and in the loop periodically send this byte array through the channel. On the client side I just read the deserialized object.
Server run():
public void run() {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject("abcdefgh");
            byte[] objectArr = baos.toByteArray();
            baos.close();
            oos.close();
            ByteBuffer buff = ByteBuffer.allocate(objectArr.length);
            buff.put(objectArr);
            buff.flip();
            while(true) {
                selector.select();
                Set keys = selector.selectedKeys();
                for (Object o : keys) {
                    SelectionKey key = (SelectionKey)o;
                    if (key.isAcceptable()) {
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        clientChannel = server.accept();
                        if (clientChannel == null)
                            continue;
                        clientChannel.configureBlocking(false);
                        SelectionKey clientKey = clientChannel.register(selector, SelectionKey.OP_WRITE);
                    } else if (key.isWritable()) {
                        SocketChannel client = (SocketChannel) key.channel();
                        if (buff.hasRemaining()) {
                            client.write(buff);
                        } else {
                            buff.clear();
                            buff.put(objectArr);
                            buff.flip();
                try {
                    Thread.currentThread().sleep(2000);
                } catch (InterruptedException e) {
                    return;
        } catch (IOException e) {
            e.printStackTrace();
    }Client run():
public void run() {
        try {
            soc = new Socket("localhost", 4000);
            ObjectInputStream ois = new ObjectInputStream(soc.getInputStream());
            while(true) {
                Object d = ois.readObject();
                System.out.println("data = " + d.toString());
        } catch (Exception ex) {
            ex.printStackTrace();
    }At the second read I get a StreamCorruptedException.
Apart from this I would like some hints in how to implement the application with NIO. For example how can I tell the objects apart on the client side � should I send every time a byte array before the object, which tells the length of the next coming object? This is probably not a 100% bulletproof solution and presents additional data transfer?
Than you in advance!

Answer 1

OK, I found a solution but I don't like it, because I don't understand it.
The ObjectOutputStream adds a header (4 bytes) to the stream - if I send the array with those four bytes I get an StreamCorruptedException. If I send the array without the header I also get a StreamCorruptedException: "invalid stream header".
If I reconstruct the object, by calling ObjectOutputStream.writeObject() and get it's byte array from ByteArrayOutputStream.toByteArray(), every time I have to fill the ByteBuffer, then it works.
Here's the modified sending block, for the above example:
} else if (key.isWritable()) {
                        SocketChannel client = (SocketChannel) key.channel();
                        if (buff.hasRemaining()) {
                            client.write(buff);
                        } else {
                            //* ---- added code ---------
                            baos.reset();
                            oos.writeObject("abcdefgh");
                            objectArr = baos.toByteArray();
                            buff.clear();
                            buff.put(objectArr);
                            buff.flip();
                    }   I really don't understand why I have to write the object in the object stream every time. I used ObjectOS and ByteArrayOS, to get the object byte array and then I thought I could forget about those streams and use this array to fill the ByteBuffer. What changes if I send the object through this process with every iteration (and how this harms speed - it's like sending everything twice)? If someone would explain this to me I would appreciate it much.