Wie führe ich zwei Instanzen von Java-Socket-Servern aus, die auf zwei verschiedenen Ports gelauscht werden?

Question

Szenario:
a) Dauerhafte Verbindungen
b) Verwalten von jedem Kommunikationsserver-Client einzeln
c)

-System von ausbreitende Ausnahmen/Fehler Schützen ich erstellt zwei Instanzen von Server-Socket-Listener versucht, mit Mit dem folgenden Code:

SimpleSocketServers.java

public class SimpleSocketServers { 

    public static void main(String[] args) throws Exception { 
     int port1 = 9876; 
     SimpleSocketServer server1 = new SimpleSocketServer(port1); 
     server1.startAndRunServer(); 
     System.out.println("Servers : server1 Listening on port: " + port1); 

     int port2 = 9875; 
     SimpleSocketServer server2 = new SimpleSocketServer(port2); 
     server2.startAndRunServer(); 
     System.out.println("Servers : server2 Listening on port: " + port2); 
    } 
} 

und

SimpleSocketServer.java

import java.io.BufferedReader; 
    import java.io.InputStreamReader; 
    import java.io.PrintWriter; 
    import java.net.ServerSocket; 
    import java.net.Socket; 

    public class SimpleSocketServer { 

     private ServerSocket serverSocket; 
     private int port; 

     public SimpleSocketServer(int port) { 
      this.port = port; 
     } 

     public void startAndRunServer() { 
      try { 
       System.out.println("Starting Server at port " + port + " ..."); 
       serverSocket = new ServerSocket(port); 
       System.out.println("Listening for client connection ..."); 
       Socket socket = serverSocket.accept(); 
       RequestHandler requestHandler = new RequestHandler(socket); 
       requestHandler.start(); 
      } catch (Exception e) { 
       e.printStackTrace(); 
      } 
     } 
    } 

class RequestHandler extends Thread { 

    private Socket socket; 

    RequestHandler(Socket socket) { 
     this.socket = socket; 
    } 

    @Override 
    public void run() { 
     try { 
      System.out.println("Client Request Response being processed..."); 
      BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
      PrintWriter out = new PrintWriter(socket.getOutputStream()); 


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

Aber, es schafft nur eine Instanz als Kontrolle nicht aus dem Konstruktor der ersten Instanz zurück. Gibt es eine Möglichkeit, die Kontrolle zurückzuerlangen und beide Instanzen von Server-Socket-Listenern gleichzeitig auszuführen? (ps: Entschuldigung, wenn es falsch oder trivial ist!)

Answer 1

Sie benötigen SimpleSocketServer implementieren Runnable; starte einen Thread mit sich selbst als Runnable im Konstruktor; und führen Sie eine accept()Schleife in der run() Methode. Gegenwärtig blockieren Sie im Konstruktor, indem Sie auf eine Verbindung warten, und Ihre Server werden auch nur eine einzige Verbindung verarbeiten.

Die interessantere Frage ist, warum Sie denselben Dienst auf zwei Ports bereitstellen möchten.

Answer 2

Verwenden Sie 2 verschiedene Threads, hören Sie 2 verschiedene Ports.

Thread ServerThread1 = new Thread(new Runnable() { 

    @Override 
    public void run() { 
     ServerSocket ServerSocketObject = null; 
     while(true) 
     { 
     try { 
      ServerSocketObject = new ServerSocket(Your_Port_Number1); 

       Socket SocketObject = ServerSocketObject.accept(); 
       // Your Code Here 
       SocketObject.close(); 

     } catch (IOException e) { 
       try { 
        ServerSocketObject.close(); 
       } catch (IOException e1) { 
        e1.printStackTrace(); 
       } 
      e.printStackTrace(); 
     } 
     } 
    } 
}); 

Thread ServerThread2 = new Thread(new Runnable() { 

    @Override 
    public void run() { 
     ServerSocket ServerSocketObject = null; 
     while(true) 
     { 
     try { 
      ServerSocketObject = new ServerSocket(Your_Port_Number2); 

       Socket SocketObject = ServerSocketObject.accept(); 
       // Your Code Here 
       SocketObject.close(); 

     } catch (IOException e) { 
       try { 
        ServerSocketObject.close(); 
       } catch (IOException e1) { 
        e1.printStackTrace(); 
       } 
      e.printStackTrace(); 
     } 
     } 
    } 
}); 

ServerThread1.start(); 
ServerThread2.start();