# Chat Socketserver/Client. wo ist das Problem?



## DamienX (20. Mai 2008)

Hallo!

Habe mir auf die schnelle mal nen SocketServer zusammengestöpselt und dazu nen kleinen
Client geschrieben....

So eigentlich sollte auch alles prima laufen aber leider Gottes gibts probleme bei der Kommunikation
zwischen der Connection und dem Client.

Zum Aufbau:
Wie die meisten Chatbauten halt so aussehen habe ich eine Server Klasse, eine Session Klasse (quasi
der Verwalter der einzelnen Verbindungen) und eine Client Klasse die nix macht ausser erst mal
Nachrichten empfangen!

Ich habe mal einen Testfall konstruiert in dem der Client die Session mit Nachrichten BOMBADIERT!!!
und die Session eigentlich auf jede eingehende Nachricht zurückantworten sollte aber das ist nicht der Fall.
Nach mitlerweile 4 Stunden debuggen hab ich das große Problem immer noch nich gefunden.

Ich habe die Vermutung das die Threads sich irgendwann totwarten... (warum weiß ich allerdings nicht).
Da mir langsam die Ideen ausgehen poste ich hier mal die wichtigsten Codeteile... 


Server:

```
public class Server extends Thread  {
	
	protected final int port;
	private ServerSocket serverSocket;
	private Vector<Session> sessions;              //Session Vector zum broadcasten
	private boolean end = false;
	
	public Server(Config config) {                 
		
		sessions = new Vector<Session>();
		
		System.out.println("Starting Server...");     //hier werden nur die wete aus der Config gezogen
		port = Integer.parseInt(config.getValue("clientport"));
		
		try {
			
			System.out.println("binding Serversocket...");
			serverSocket = new ServerSocket(port);          //ServerSocket
			System.out.println("complete!");
			
		} catch (IOException e) {
			System.out.println("Cannot bind Serversocket on port " +port);
		}
		
		this.start();         //Thread starten
	}
	
	public void run(){
		while(!end){
			try {
				System.out.println("Server is listening on port "+port);
				Socket clientSocket = serverSocket.accept(); //bei neuem connect
				
				sessions.addElement(new Session(this, clientSocket)); 
				sessions.lastElement().start();                      //neue Session starten
					
				System.out.println("New session at "+
						sessions.elementAt(sessions.size()-1).getConnectionTime());
				
				
			} catch (IOException e) {
				e.printStackTrace();
			}			
		}		
	}
	
	public void broadcast(String message){
		for(Session s : sessions){
				s.send(message+"\n\r");
		}
	}
}
```


Session:

```
public class Session extends Thread{
	
	private Socket client;
	private Server server;
	private BufferedReader in;
	private PrintWriter out;
	private Date connectionTime;
	private String Login;
	private boolean end = false;
	
	public Session(Server server, Socket client) {
		this.server = server;
		this.client = client;
		
		this.connectionTime = new Date();
		
		try {
			this.in = new BufferedReader(new InputStreamReader(client.getInputStream()));
			this.out = new PrintWriter(new OutputStreamWriter(client.getOutputStream()));
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	
	public void send(String msg){
		this.out.println(msg);
	}
	
	

	@Override
	public void run() {
		
		String inc;
		
		while(!end){
			try {
				inc = in.readLine();
				out.println("Antwort");	
					//server.broadcast(inc);
					
			} catch (IOException e) {
				e.printStackTrace();
			}
		}		
	}
}
```

Client:

```
public class Client extends Thread{
	
	private BufferedReader in;
	private PrintWriter out; 
	private Socket socket;
	private boolean end = false;
	
	public Client(Config config) {
		try {
			System.out.println("Binding Socket on serverport...");
			socket = new Socket(config.getValue("serverip")
					,Integer.parseInt(config.getValue("clientport")));
			
			System.out.println("complete!");
			
			System.out.println("Getting streams...");
			in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
			System.out.println("complete!");
			
			this.setPriority(Thread.MIN_PRIORITY);
			
		} catch (NumberFormatException e) {
		} catch (UnknownHostException e) {
			System.out.println("Could not find Server!");
		} catch (IOException e) {
		}
	}
	
	public void send(String msg){
		this.out.println(msg);
	}
	
	@Override
	public void run() {

		String inc;
		
		while(!end){
			try {
				inc = in.readLine();
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(inc);
			
			out.println("KOMM SCHON?\n\r");	
		}
	}	
}
```

Ich weiß... ich hasse es auch mich durch mehrteilige Surces durchzugraben aber ich wäre sehr dankbar wenn
mir jemand einen Tipp geben könnte.

Grüße Alex


----------



## CyD (20. Mai 2008)

Nabend,

ich hab deinen Source nur mal kurz überflogen.


```
protected final int port; // Zeile 4
port = Integer.parseInt(config.getValue("clientport")); // Zeile 14
```

Mit dem kleinen Wörtchen "final" macht du die Variable "port" im Endeffekt zu einer Konstanten. 
Andersgesagt: port kannst du keinen anderen Wert mehr zu weisen.

Nur so als Tipp: 
Versuchs mal hiermit.
(hilft in 90% der Fälle :wink: )

gruß
CyD


----------



## Guest (21. Mai 2008)

Sry da liegst du falsch! 
port wird nich bei Deklarierung initialisiert sondern im Konstruktor. 
Diese Möglichkeit ist meiner Meinung auch sauberer weil ich im Falle von unterschiedlichen Konfigurationen
die Werte anders setzen kann (Bsp Konstruktor mit default Werten und einer mit Daten aus nem configfile)!

Die Config Klasse arbeitet auch 1a! Mit dem hat das nix zu tun...
Der Client und die Session sind auch verbunden... in seltenen Fällen funktioniert auch die übertragung...
zb wenn ich this.send im Session-Mainloop aufrufe bekomm ich nach einiger Zeit auch ausgaben...
aber halt nicht immer... und daran verzweifel ich imo Moment!


----------

