Ho creato un server Java con socket, come si fa a stampare su TUTTI i socket?

Question

Ci sto provando da un po 'e voglio che più client ricevano più input contemporaneamente.
C'è un problema, voglio che il server stampi "Ciao" su tutti i client se un client dice "print2all Hi".
So come elaborarlo per stamparlo, solo stampare per TUTTI i clienti è il problema.

Ecco quello che ho finora.
Server

try{ 
    try{ 
     server = new ServerSocket(25565); 
    } catch (Exception e){ 
     e.printStackTrace(); 
    } 
    while (isListening){ 
     new SocketThread(server.accept()).start(); 
    } 
    server.close(); 
} catch (Exception e){ 
    e.printStackTrace(); 
} 

SocketThread

try { 
    PrintWriter out = new PrintWriter(socket.getOutputStream(), true); 
    BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 

    String inputLine, outputLine; 
    Processor kkp = new Processor(); 
    out.println("Hi!"); 

    while ((inputLine = in.readLine()) != null) { 
     outputLine = kkp.Proccess(inputLine,this.socket); 
     out.println(outputLine); 
    } 
    out.close(); 
    in.close(); 
    socket.close(); 

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

client

  Processor p = new Processor(); 
      socket = new Socket("localhost",25565); 
      out = new PrintWriter(socket.getOutputStream(), true); 
      in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 

  BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in)); 
      String fromServer; 
      String fromUser; 

      out.println("print2all Hi") 

      socket.close(); 

Ragazzi. Se si desidera utilizzare questo come un server di antipasto, do il permesso pieno = P

Answer 1

primo luogo è necessario tenere traccia di tutti i client connessi:

final List<SocketThread> clients = new ArrayList<>(); 

while (isListening){ 
    SocketThread client = new SocketThread(server.accept()).start(); 
    clients.add(client); 
} 

Avendo tale lista, se un cliente riceve "print2all Hi" esso semplicemente itera su tutto clients e invia un messaggio a ciascuno di essi. Per fare questo è molto probabile che tu debba esporre qualche metodo su SocketThread che accederà al socket del client. Ciò significa che dovrai modificare la variabile out in campo.

approccio alternativo è quello di tenere un elenco di socket client. Ma questo rompe l'incapsulamento male. Inoltre potresti incorrere in problemi di sicurezza di IO/thread se i socket vengono esposti direttamente. Meglio nasconderlo dietro qualche API (come il metodo SocketThread) e fare la sincronizzazione correttamente all'interno.

Answer 2

Un'implementazione completa di ciò che stai cercando.

Server

package tcpserver; 

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.PrintWriter; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.StringTokenizer; 
import java.util.logging.Level; 
import java.util.logging.Logger; 

public class TCPServer { 

    private int serverPort = 25565; 
    private ServerSocket serverSocket; 
    private List<ConnectionService> connections = new ArrayList<ConnectionService>(); 

    public TCPServer() { 
     try { 
      serverSocket = new ServerSocket(serverPort); 
      System.out.println("Waiting..."); 
      while (true) { 
       Socket socket = serverSocket.accept(); 
       System.out.println("Connected: " + socket); 
       ConnectionService service = new ConnectionService(socket); 
       service.start(); 
      } 

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

    } 

    public static void main(String[] args) { 
     new TCPServer(); 
    } 

    class ConnectionService extends Thread { 

     private Socket socket; 
     private BufferedReader inputReader; 
     private PrintWriter outputWriter; 
     //private String username; 

     public ConnectionService(Socket socket) { 
      this.socket = socket; 
      try { 
       inputReader = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
       outputWriter = new PrintWriter(socket.getOutputStream(), true); 
      } catch (IOException e) { 
       System.out.println(e.getMessage()); 
      } 
     } 

     @Override 
     public void run() { 
      while (true) { 
       try { 
        String receivedMessage = inputReader.readLine(); 
        System.out.println(receivedMessage); 
        StringTokenizer stoken = new StringTokenizer(receivedMessage); 
        String fargument = stoken.nextToken(); 
        if (fargument.equals("print2all")) { 
         this.sendToAnyone(stoken.nextToken()); 
        } 
       } catch (IOException ex) { 
        Logger.getLogger(TCPServer.class.getName()).log(Level.SEVERE, null, ex); 
       } catch (NullPointerException e) { 
        System.out.println(e.getMessage()); 
       } finally { 
        outputWriter.close(); 
       } 

      } 
     } 

     protected void sendMessage(String message) { 
      outputWriter.println(message); 
     } 

     private void sendToAnyone(String message) { 

      for (ConnectionService connection : connections) { 
       connection.sendMessage(message); 
      } 
     } 
    } 
} 

client

package tcpclient; 

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.PrintWriter; 
import java.net.InetAddress; 
import java.net.Socket; 

public class tcpClient extends javax.swing.JFrame { 

    private Socket socket; 
    private BufferedReader inputReader; 
    private PrintWriter outputWriter; 

    public tcpClient() { 
     connectToServer(); 
    } 

    private void connectToServer() { 
     try { 
      socket = new Socket(InetAddress.getByName("localhost"), 25565); 
      inputReader = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
      outputWriter = new PrintWriter(socket.getOutputStream(), true); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 

     new Thread() { 
      @Override 
      public void run() { 
       receiveData(); 
      } 
     }.start(); 
    } 

    private void receiveData() { 
     try { 
      while (true) { 
       System.out.println(inputReader.readLine()); 
      } 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    public void sendData(String messageToSend) { 
     outputWriter.println(messageToSend); 
    } 

    public void closeSocket() { 
     if (socket != null) { 
      try { 
       socket.close(); 
      } catch (IOException ex) { 
       ex.printStackTrace(); 
      } 
     } 
    } 

    public static void main(String args[]) { 
     java.awt.EventQueue.invokeLater(new Runnable() { 
      @Override 
      public void run() { 
       tcpClient client = new tcpClient(); 
       client.sendData("print2all Hi"); 
       client.closeSocket(); 
      } 
     }); 
    } 
}