# MultiClient Server - Senden an alle Clients



## mastercoll5 (8. Jul 2014)

Hey,

ich habe einen einfachen Chat-Server erstellt. Jeder Client bekommt einen neuen Thread und wird in einer ArrayList eingetragen. Nun möchte ich eine Nachricht an alle Client senden lassen. Jedoch sendet der Server nur die selbe Nachricht so oft wie viele Clients verbunden sind zu den letzten Client, der sich zum Server verbunden hat.



Spoiler: Server-Code





```
package main;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Scanner;

import UI.Frame;

public class Server {
	
	static ServerSocket ss = null;
	static Socket s = null;
	static Scanner in = null;
	static Thread t;
	static ArrayList<ClientThread> al = new ArrayList<ClientThread>();
	static Frame frm;
	
	public static void main(String[] args) {
		frm = new Frame();
		try {
			ss = new ServerSocket(1010);
		} catch (IOException e) {
			e.printStackTrace();
		}
		frm.write("[Server] Server gestartet");
		frm.write("[Server] Warte auf Clients ...");
		while(!ss.isClosed()) {
			try {
				s = ss.accept();
				ClientThread chat = new ClientThread(s);
				al.add(chat);
				chat.start();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void send(String os) {
		frm.write(os);
		for(ClientThread ct : al) {
			ct.writemsg(os);
		}
	}
	
	public static void close() {
		if(al.size() != 0) send("exit");
		System.exit(0);
	}
}
```


```
package main;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class ClientThread extends Thread {

	static Socket s;
	String n;
	Scanner in;
	static PrintWriter out;
	
	public ClientThread(Socket so) {
		s = so;
	}
	
	public void writemsg(String s) {
		out.println(s);
		out.flush();
	}
	
	@Override
	public void run() {	
		try {
			in = new Scanner(s.getInputStream());
			out = new PrintWriter(s.getOutputStream());
			while(true) {
				if(in.hasNext()) {
					 n = in.nextLine();
					 System.out.println(n);
					 if(n.contains("exit")) {
						 s.close();
						 String name = n.replaceAll("exit", "");
						 Server.al.remove(this);
						 Server.send(name + "Server verlassen");
     				 } else  if(n.contains("ping")) {
     					 this.writemsg("pong");
     				 } else Server.send(n);
				 }
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
```




Vielen Dank schon mal.

mistercoll


----------



## Anti-Banane (8. Jul 2014)

nimm mal das ganze STATIC da raus ... dann wird es funktionieren ... mehr hinweise geb ich nicht

tipp : normalerweise sollte in sauberen OOP-code nur genau EINMAL static vorkommen ... und zwar bei main() ... oder halt konstanten

[ot]ist eigentlich egal ... weil irgendwer ja mal wieder kommen und direkt die lösung rausprügeln wird[/ot]


----------



## mastercoll5 (8. Jul 2014)

Danke hat schon geholfen! ;D


----------



## Anti-Banane (8. Jul 2014)

schön ... dann poste den jetzt funktionierenden code damit alle was von haben und setze das thema auf erledigt


----------



## mastercoll5 (8. Jul 2014)

```
package main;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class Server {
	
	static ArrayList<ClientThread> al = new ArrayList<ClientThread>();
	
	public static void main(String[] args) {
		new Server();
	}
	
	public Server() {
		ServerSocket ss = null;
		Socket s = null;
		try {
			ss = new ServerSocket(1010);
		} catch (IOException e) {
			e.printStackTrace();
		}	
		System.out.println("Server gestartet!");
		System.out.println("Warte auf Clinets...");
		while(!ss.isClosed()) {
			try {
				s = ss.accept();
				ClientThread chat = new ClientThread(s);
				al.add(chat);
				chat.start();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void send(String os) {
		if(!os.equalsIgnoreCase("exit")) System.out.println(os);
		for(ClientThread ct : al) ct.writemsg(os);
	}
	
	public static void close() {
		write("Server wird beendet!");
		if(al.size() != 0) send("exit");
		System.exit(0);
	}
}
```


```
package main;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class ClientThread extends Thread {

	Socket s;
	String n;
	Scanner in;
	PrintWriter out;
	
	public ClientThread(Socket so) {
		s = so;
	}
	
	public void writemsg(String s) {
		out.println(s);
		out.flush();
	}
	
	@Override
	public void run() {	
		try {
			in = new Scanner(s.getInputStream());
			out = new PrintWriter(s.getOutputStream());
			while(true) {
				if(in.hasNext()) {
					n = in.nextLine();
					String[] nsplitt = n.split(" ");
					if(nsplitt[1].equalsIgnoreCase("/exit")) {
					s.close();
			    	Server.al.remove(this);
					Server.send(nsplitt[0] + " Server verlassen");
					 
					} else if(nsplitt[1].equalsIgnoreCase("/ping")) {
						writemsg("pong");
						 
					} else if(nsplitt[1].equalsIgnoreCase("/whois")) {
						writemsg("Im Chat sind :");
						
					} else if(nsplitt[1].equalsIgnoreCase("/befehle")) {
						writemsg("Verfügbare Befehle :");
						writemsg("    - /ping   : Sendet einen Ping an den Server(Antwort: Pong)");
						writemsg("    - /exit   : Verlässt den Server und schließt den Chat");
						writemsg("    - /whois  : Zeigt an wer im Chat online ist");
						 
					} else Server.send(n);
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
```


----------



## Anti-Banane (9. Jul 2014)

naja ... immer noch absoluter schrott ... und ich wette DU weist immer noch nicht warum es jetzt funktioniert da dir mit sicherheit der unterschied zwischen "mit static" und "ohne static" in diesem zusammenhang nicht klar sein wird ... aber naja ... man kann es stehen lassen


----------



## mastercoll5 (9. Jul 2014)

Könntest du mich aufklären, wieso man static nicht benutzen sollte (besonders in diesen Fall) . Ein hilfreicher Link währe auch schon nett.


----------



## Anti-Banane (9. Jul 2014)

wird zwar eigentlich in jedem anfänger-buch ausführlich erklärt ... aber bitte

STATIC , oder zu deutsch "statisch" bedeutet in java das eine variable oder eine methode nicht an ein objekt sondern an die klasse gebunden ist

das beste beispiel ist main selbst

public static void main(String[])

es ist der grundsätzliche "einstiegspunkt" eines jeden java-codes und muss "von außen" zugänglich sein

was aber bedeutet nun "muss von außen zugänglich sein" genau ?

1) man braucht den sog. access-modifier, im fall von main ist das immer public
neben public gibt es noch protected und private sowie gar kein modifier was dann package-private / default ist
zu den modifiern aber hier eher weniger
2) die variable / methode muss unabhängig von einem objekt sein sondern zum klassen-kontext gehören
und hier kommt das keyword "static" ins spiel

ist etwas static so sagt man damit das diese variable bzw methode nicht an eine bestimmte instanz gebunden ist sondern global zur klasse gehört und für alle instanzen gilt
soweit ja kein problem ... hat aber den haken : wenn man den wert für eine static-variable setzt gilt dieser für JEDE instanz

und genau das ist das problem was dein code hatte : du hast in der handler-klasse sowohl den socket als auch den stream als static makiert ... es gibt also nur ein feld für alle instanze

was passiert nun bei mehreren instanzen ?

sagen wir es einfach : der wert der als letztes reingepackt wird gilt dann halt auch für alle anderen
und das ist passiert : du hast den letzten socket und den letzten stream als letztes reingepackt ... deshalb galten beide auch für die anderen instanzen so das du letzten endes immer nur mit dem letzten kommuniziert hast


was ist der unterschied zu "ohne static"

ohne static ist eine variable / methode an ein objekt und nicht mehr an die klasse gebunden
heißt also : du brauchst erstmal ein objekt > new
nun hat jede instanz ihren eigenen speicher und damit auch eigenen socket und eigenen stream ... weshalb jetzt wenn du über die handler iterierst auch korrekt mit jedem einzelnen kommuniziert wird ... da jetzt alle nötigen objekt zugreibar sind



wie wird static "korrekt" verwendet

wie bereits gesagt : eigentlich nur ein einziges mal im ganzen code : nämlich bei main()
zusätzlich aber noch bei konstanten : public static final <T>
oder factories <T>.getInstance() oder ähnliche

natürlich könnte man beschriebenes auch mit objekten und ohne static lösen .. aber es haben sich in java halt gewisse eingebürgert



alles nachzulesen in den "Java Coding Conventions" sowie dem "official Java Tutorial"


----------



## mastercoll5 (9. Jul 2014)

Danke für die lange, umfangreiche Erklärung, hat mir sehr geholfen.

Ich habe den Text nochmal überarbeitet. Ist er nun besser?



Spoiler





```
package main;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Scanner;

public class Server implements Runnable {
	
	ArrayList<ClientThread> al = new ArrayList<ClientThread>();
	ArrayList<String> names = new ArrayList<String>();
	ServerSocket ss;
	Socket s;
	String passw;
	
	public Server() {
		try {
			ss = new ServerSocket(1010);
		} catch (IOException e) {
			e.printStackTrace();
		}	
	}
	
	@Override
	public void run() {
		write("Warte auf Clinets...");
		while(!ss.isClosed()) {
			try {
				s = ss.accept();
				ClientThread chat = new ClientThread(s, this);
				al.add(chat);
				chat.start();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	public void write(String s) {
		System.out.println("[Server] " + s);
	}
	
	public void send(String os) {
		if(!(os.equalsIgnoreCase("exit") || os.equalsIgnoreCase("exitkick"))) System.out.println(os);
		for(ClientThread ct : al) ct.writemsg(os);
	}
	
	public void start() {
		new Thread(this).start();
		this.write("Server gestartet!");
	}
	
	public void close() {
		write("Server wird beendet!");
		if(al.size() != 0) send("exit");
		System.exit(0);
	}
	
	public static void main(String[] args) {
		Server srv = new Server();
		System.out.println("Gebe ein Passwort ein: ");
		@SuppressWarnings("resource")
		Scanner sc = new Scanner(System.in);
		srv.passw = sc.nextLine();
		System.out.println("Danke ;D");
		srv.start();
	}
	
}
```






Spoiler





```
package main;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class ClientThread extends Thread {

	Socket s;
	String n;
	Scanner in;
	PrintWriter out;
	Server srv;
	
	public ClientThread(Socket s, Server srv) {
		this.s = s;
		this.srv = srv;
	}

	public void writemsg(String s) {
		out.println(s);
		out.flush();
	}
	
	@Override
	public void run() {	
		try {
			in = new Scanner(s.getInputStream());
			out = new PrintWriter(s.getOutputStream());
			while(true) {
				if(in.hasNext()) {
					n = in.nextLine();
					String[] nsplit = n.split(" ");
					if(!srv.names.contains(nsplit[0])) srv.names.add(nsplit[0]);
					if(nsplit[1].equalsIgnoreCase("/exit")) {
						s.close();
				    	srv.al.remove(this);
					    srv.names.remove(nsplit[0]);
						srv.send(nsplit[0] + " Server verlassen");
					 
					} else if(nsplit[1].equalsIgnoreCase("/ping")) {
						writemsg("pong");
						 
					} else if(nsplit[1].equalsIgnoreCase("/whois")) {
						writemsg("Im Chat sind :");
						for(String n : srv.names) writemsg("    - " + n);	
						
					} else if(nsplit[1].equalsIgnoreCase("/close")) {
						if(nsplit.length != 3) writemsg("Benutze /close <passwort>!");
						else if(!nsplit[2].equalsIgnoreCase(srv.passw)) writemsg("Falsches Passwort!");
						else srv.close();
						
					} else if(nsplit[1].equalsIgnoreCase("/kickall")) {
						if(nsplit.length != 3) writemsg("Benutze /kickall <passwort>!");
						else if(!nsplit[2].equalsIgnoreCase(srv.passw)) writemsg("Falsches Passwort!");
						else srv.send("exitkick");
						
					} else if(nsplit[1].equalsIgnoreCase("/befehle")) {
						writemsg("Verfügbare Befehle :");
						writemsg("    - /ping   : Sendet einen Ping an den Server(Antwort: Pong)");
						writemsg("    - /exit   : Verlässt den Server und schließt den Chat");
						writemsg("    - /whois  : Zeigt an wer im Chat online ist");
						writemsg("--------------------------------------------------------------");
						writemsg("    - /close <passwort>   : Schließt den Server");
						writemsg("    - /kickall <passwort> : Kickt alle Clients");
						 
					} else srv.send(n);
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
```


----------

