Writing to SocketChannel in Java repeats unexpectedly

I have been trying to work with NIO SocketChannels for some time now, and I am stumped regarding writing out to a SocketChannel. The following code is from my client:

    public class nbClient {

/**
 * @param args
 */
static int id;
static int delay = 1000;
static int port;
public static void main(String[] args) throws Exception{

    if (args.length > 0){
        id = Integer.parseInt(args[0]);
        port = Integer.parseInt(args[1]);

    }
    else{
        id = 99;
        port = 4444;
    }
    // Create client SocketChannel
    SocketChannel client = SocketChannel.open();

    // nonblocking I/O
    client.configureBlocking(false);

    // Connection to host port 8000
    client.connect(new java.net.InetSocketAddress("localhost",port));       

    // Create selector
    Selector selector = Selector.open();

    //SelectionKey clientKey = client.register(selector, SelectionKey.OP_CONNECT);
    SelectionKey clientKey = client.register(selector, client.validOps());

    // Waiting for the connection

    while (selector.select(1000) > 0) {

      // Get keys
      Set keys = selector.selectedKeys();
      Iterator i = keys.iterator();

      // For each key...
      while (i.hasNext()) {
        SelectionKey key = (SelectionKey)i.next();

        // Remove the current key
        i.remove();      

        // Get the socket channel held by the key
        SocketChannel channel = (SocketChannel)key.channel();

        // Attempt a connection
        if (key.isConnectable()) {

          // Connection OK
          System.out.println("Server Found");

          // Close pendency connections
          if (channel.isConnectionPending())
            channel.finishConnect();
          //channel.close();

          channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ);

        }
        if (key.isWritable()){
            System.out.println("Ready for writing");

              // Write on the buffer
              ByteBuffer buffer = null;
              int counter = 0;                
                buffer = 
                  ByteBuffer.wrap(
                    new String(" This is a very long message from Client " + id + " that should exceed the bufer by a bit").getBytes());
                int outBytes = channel.write(buffer);
                System.out.println(channel.isConnectionPending());
                System.out.println(outBytes);
                buffer.clear();
                counter++;

        }

        if (key.isReadable()){
            System.out.println("Ready for reading");
        }

      }
    }

}

}

My issue has to do when I try to write out to the channel. Whenever this part of the code is run, it loops around numerous times, writing the data out during each iteration without waiting for the server to process it. When I run the debugger with my code, the server seems to be able to catch up and process the transfer (the client keeps resending the requests, but at least the server displays the bytes transferred). When the code is just run as-is without any forced delays, though, the client code runs a couple dozen times then the connection is dropped, while the server seemingly ignores the transfer. Here is my server code section - note that it is run from a Runnable class:

try {
            readwriteSelector.select();
            // Once the event occurs, get keys
            Set<SelectionKey> keys = readwriteSelector.selectedKeys();
            Iterator<SelectionKey> i = keys.iterator();     


            // For each keys...
            while(i.hasNext()) {

              // Get this most recent key
              SelectionKey key = i.next();      

              if (key.isReadable()){
                  System.out.println("Is Readable");
              }

              if (key.isWritable()){
                  System.out.println("Is Writable");
                  SocketChannel client = (SocketChannel) key.channel();
                  buf.clear();

                  int numBytesRead = client.read(buf);

                  if (numBytesRead == -1){
                        client.close();
                    }
                    else {
                        buf.flip();
                        byte[] tempb = new byte[buf.remaining()];

                        buf.get(tempb); 

                        String s = new String(tempb);

                        System.out.println(s);
                    }
              }

              // Remove the current key
              i.remove();
              //readwriteSelector.selectedKeys().clear();
            }


        } catch (IOException e) {
            e.printStackTrace();
        }

I know this is a good deal of code, but 开发者_JS百科at this point I can't pinpoint where the problem is. Can anyone deduce why the client and server seemingly cannot communicate despite the fact that transfer occur fine if I force delays?

Thanks.

The server read() method should be in a loop also. SocketChannel.read() will read up to the size of the buffer, but may read less, including 0 bytes.

Replace the block starting

int numBytesRead = client.read(buf);

with

   StringBuilder msg = new StringBuilder();
   for (;;) {
    int numBytesRead = client.read(buf);
    if (numBytesRead==-1)
        break;
    if (numBytesRead>0) {
        buf.flip();
        byte[] tempb = new byte[buf.remaining()];
        buf.get(tempb); 
        String s = new String(tempb);
        msg.append(s);
    }
   }
   client.close();
   System.out.prinltn(msg);