Envoi d'un message à partir du serveur NIO

Question

Le code ci-dessous crée un serveur et accepte un client entrant.

package socket; 

import java.nio.*; 
import java.nio.channels.*; 
import java.net.*; 
import java.util.*; 
import java.io.IOException; 

public class NonBlockingServer { 

    public static void main(String[] args) throws InterruptedException, IOException { 

     // Create a new Thread 
     Server s = new Server(); 
     new Thread(s).start(); 

     // Give 10 seconds for client to connect 
     Thread.sleep(10000); 

// This Doesn't work? 

     s.Write("Hello, Client!"); 

     System.out.println("Done"); 
    } 
} 

//A class which implements Runnable Interface 
class Server implements Runnable { 

    SocketChannel AcceptedClient; 
    ServerSocketChannel serverChannel; 
    Selector selector; 

    void Write(String s) throws IOException { 
     ByteBuffer buffer = ByteBuffer.allocate(s.length()); 
     buffer.put(s.getBytes()); 

     int numWrite = -1; 
     numWrite = AcceptedClient.write(buffer); 

     while (buffer.hasRemaining()) 
     { 
      numWrite += AcceptedClient.write(buffer); 
     } 

     System.out.println(numWrite); 
    } 

    @Override 
    public void run() 
    { 

     int port = 4041; 

     System.out.println("Listening for connections on port " + port); 

     try { 
      // Bind the port 
      serverChannel = ServerSocketChannel.open(); 
      ServerSocket ss = serverChannel.socket(); 
      InetSocketAddress address = new InetSocketAddress(port); 
      ss.bind(address); 

      // Non-blocking Server 
      serverChannel.configureBlocking(false); 

      // Register with Selector 
      selector = Selector.open(); 
      serverChannel.register(selector, SelectionKey.OP_ACCEPT); 

     } catch (IOException ex) { 
      ex.printStackTrace(); 
      return; 
     } 

     while (true) { 

      try { 

       // Blocks until a 'socket' is ready registered with selector is ready. 
       selector.select(); 

      } catch (IOException ex) { 
       ex.printStackTrace(); 
       break; 
      } 

      Set<SelectionKey> readyKeys = selector.selectedKeys(); 
      Iterator<SelectionKey> iterator = readyKeys.iterator(); 

      while (iterator.hasNext()) { 

       SelectionKey key = iterator.next(); 
       iterator.remove(); 

       try { 

        if (key.isAcceptable()) { 

         ServerSocketChannel server = (ServerSocketChannel) key.channel(); 
         SocketChannel client = server.accept(); 
         System.out.println("Accepted connection from " + client); 
         client.configureBlocking(false); 

         // Client accepted by server can read. 
         SelectionKey key2 = client.register(selector, SelectionKey.OP_READ); 

         AcceptedClient = (SocketChannel) key2.channel(); 

        } 

       } catch (IOException ex) { 
        key.cancel(); 
        try { 
         key.channel().close(); 
        } catch (IOException cex) { 
        } 
       } 
      } 
     } 
    } 
} 

Mais lorsque je tente d'envoyer un message au client après qu'il a été connecté au serveur, il ne fonctionne pas dire le message ne reçoit pas client.

Quelle est la bonne façon d'envoyer un message du serveur à un client spécifique?

J'ai regardé sur Internet et n'ai trouvé aucun exemple dans lequel le serveur envoie un message au client.

Answer 1

Vous devez flip() le tampon avant le write(), et si vous allez le garder vous devez ensuite le compact(). NB La fermeture du canal annule la touche.

NB