Echo Server

[Padawan]

Hallo Leute,

ich hab mir folgenden EchoServer programmiert, der Kleinbuchstaben in Großbuchstaben und Umgekehrt umwandelt:

import java.io.*;
import java.net.*;

public class EchoServer {
	  public static void main(String[] args)throws IOException{

	    int port = 4711;

	    //Knotenpunkt für den Server
	    ServerSocket sock = new ServerSocket(port);

	    //verbindungskanal zum Client
	    Socket stream = sock.accept();
	    
	   
	    	//Aufruf des Threats bzw. übergabe von parametern
		    Thread echoServ = new EchoThread(stream, sock);
		    echoServ.start();   //Starten des Threads
	    
	    
	  }


}

import java.io.*;
import java.net.*;
//Es wir eine Klasse erzeugt, die von einem Thread abgeleitet wurde
public class EchoThread extends Thread {
		private Socket stream;
		private ServerSocket socke;

		public EchoThread(Socket stream, ServerSocket sock){
			//Hier im Konstruktor werden Variablen definiert, die
			//in der Klasse definiert werden
			this.stream = stream;   //
			this.socke =sock;
	    }

		public void run(){
			try{
			//Anlegen der kommunikations Stream Objekte
			BufferedReader in = new BufferedReader(new InputStreamReader(stream.getInputStream()));   //für die zum Server ankommenden Streams/Daten
			BufferedWriter out = new BufferedWriter(new OutputStreamWriter(stream.getOutputStream()));   //Für die zum Client gehenden Streams/Daten

			//nachricht vom Client lesen
			StringBuffer daten = new StringBuffer();


			//Ein und Ausgabe in einer endlosschleife
			while(true){
				String tmp = in.readLine();  //Einlesen der ankommenen Zeichen in den String tmp
					for (int i = 0; i < tmp.length(); i++) {
						String zeichen = tmp.substring(i, i + 1);
						if (!zeichen.equals(zeichen.toUpperCase())) {  //Umwandeln der kleinbuchstaben in großbuchstaben
							daten.append(zeichen.toUpperCase());
						}else if(!zeichen.equals(zeichen.toLowerCase())) {//Umwandeln der großbuchstaben in kleinbuchstaben
								daten.append(zeichen.toLowerCase());
						}else {
						daten.append(tmp);   //Anhängen der Strings an den StringBuffer daten
						}
					}
					daten.append("\0");
				
	
				System.out.println("Socket-Server: Client: " + daten.toString());   //Ausgabe der Daten, welche vom Client Empfangen wurden
	
				//public static String swapUpperLower(String in) {
				out.write("Server-Socket: Client deine Nchricht:");
				out.write(daten.toString());   //schickt dem Client seine daten zurück
				out.write("\n");
				out.flush();   //leeren bzw. schieben des Zwischenpuffers zum Client
				daten.delete(0,daten.length());
				//Schließen der verbindung
				if(tmp.contains("end") ||tmp.contains("END")){   //Verbindung Schließen
					stream.close();
					socke.close();
					this.interrupt();
		        }
				if(tmp.contains("stop") ||tmp.contains("STOP")){   //Server beenden
					socke.close();
					System.out.close();
					System.exit(0);
				}
			}   //Ende While

			}catch(IOException e){
					System.err.println("Fehler in der Socket Verbindung");
					e.printStackTrace();
		}

	}

}

Meine frage ist, wie kann man das so gestallten, dass der Server bis zu 5 Client/telnet anfragen annehmen kann bzw. für jeden Client, der anfragt/akzeptiert wird ein Thread erstellt wird?

Lg Padawan

 

[melmager]

Mir fehlt irgenwie die Endlosschleife wo sock.accept(); abgefragt wird.

zum erstellen eines Threats kann ich nix sagen - habe ich noch nie gebraucht.

anyway meine erste Serverversion sah so aus:

public class Main {

    private static void handleConnection( Socket client ) throws IOException
  {
    Scanner     in  = new Scanner( client.getInputStream() );
    PrintWriter out = new PrintWriter( client.getOutputStream(), true );

    out.println( "<xmlnet/>" );
    while (in.hasNext()) {
       System.out.println( in.nextLine() );
    }
  }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        // TODO code application logic here
        ServerSocket server = new ServerSocket( 4224 );
        while ( true )  {
           Socket client = null;
        try   {
         client = server.accept();
         handleConnection ( client );
        }
        catch ( IOException e ) {
          e.printStackTrace();
        }
        finally {
         if ( client != null )
           try { client.close(); } catch ( IOException e ) { }
        }
        }
    }
}

hilft ja eventuell weiter
sprich in handleConnection oder stattdessen machst du dann dein Thread auf

 

[tuney]

Hallo,

 //verbindungskanal zum Client
        Socket stream = sock.accept();
        
       
            //Aufruf des Threats bzw. übergabe von parametern
            Thread echoServ = new EchoThread(stream, sock);
            echoServ.start();   //Starten des Threads

So wie dein Programm momentan aufgebaut ist wartet (blockiert) der Server bei der Methode accept(), bis sich ein Client verbindet. Sobald sich jemand verbindet wird der EchoThread gestartet. Wenn der EchoThread mit der Arbeit fertig ist, ist Essig. D.h. der Server beendet sich.

So wie mein Vorredner das Ganze bereits erklärt hat musst du zuerst eine Schleife um accept und die Erstellung des EchoThreads machen.

 //verbindungskanal zum Client
        while(true) {
        Socket stream = sock.accept();
        
       
            //Aufruf des Threats bzw. übergabe von parametern
            Thread echoServ = new EchoThread(stream, sock);
            echoServ.start();   //Starten des Threads
        }

Wenn du zählen möchtest, dass nur x Clients sich verbinden dürfen, dann kannst du das while(true) auch gegen ein while(anzClient < 5) schreiben und am Ende der while ein anzClient++. Somit könntest du die Verbindungen zählen.


Was mit noch auffällt, ist dass du den ServerSocket im EchoThread selbst schliesst. Das solltest du rausnehmen, weil sich die Threads die Resourcen teilen. D.h. wenn du den ServerSocket bei der ersten Verbindung schließt, dann haben Client x+1,...,x+n keine Möglichkeit mehr sich mit dem Server zu verbinden.

bye