ServerSocket und Socket - Netzwerkgrundlagen - Versionsgeschichte

L-ectron-X am 8. März 2018 um 19:47 Uhr

2018-03-08T19:47:38Z

← Nächstältere Version		Version vom 8. März 2018, 19:47 Uhr
Zeile 15:		Zeile 15:
	=Socketverbindungen=		=Socketverbindungen=
	Eine simple Verbindung zu einem anderen Rechner (hier allerdings der lokale Host) kann so aussehen:		Eine simple Verbindung zu einem anderen Rechner (hier allerdings der lokale Host) kann so aussehen:
	<~~code~~=java>		<syntaxhighlight lang="java">
	[...]		[...]

Zeile 28:		Zeile 28:
	out.newLine();		out.newLine();
	out.flush();		out.flush();
	</~~code=java~~>		</syntaxhighlight>

	Soweit noch ganz einfach, um den OutputStream den der Socket auf Anfrage liefert (über den auch sämtliche Kommunikation 'in' den Socket läuft) wird ein BufferedWriter konstruiert, damit wir ganze Zeilen senden können.		Soweit noch ganz einfach, um den OutputStream den der Socket auf Anfrage liefert (über den auch sämtliche Kommunikation 'in' den Socket läuft) wird ein BufferedWriter konstruiert, damit wir ganze Zeilen senden können.
Zeile 37:		Zeile 37:

	Der Socket kann natürlich nicht nur mit ausgehenden Daten umgehen, sondern auch mit eingehenden:		Der Socket kann natürlich nicht nur mit ausgehenden Daten umgehen, sondern auch mit eingehenden:
	<~~code~~=java>		<syntaxhighlight lang="java">
	// BufferedReader konstruieren		// BufferedReader konstruieren
	BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));		BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
Zeile 51:		Zeile 51:
	out.close();		out.close();
	in.close();		in.close();
	</~~code=java~~>		</syntaxhighlight>

	Hier ist eine bereits angesprochene Sache zu beachten:		Hier ist eine bereits angesprochene Sache zu beachten:
Zeile 60:		Zeile 60:
	=Socket-Server=		=Socket-Server=
	Auf der anderen Seite brauchen wir nun natürlich einen Server, der mit unserem kleinen Client 'reden' kann. Dazu brauchen wir einen ServerSocket der sich an den entsprechenden Port bindet um dort auf Clients zu warten.		Auf der anderen Seite brauchen wir nun natürlich einen Server, der mit unserem kleinen Client 'reden' kann. Dazu brauchen wir einen ServerSocket der sich an den entsprechenden Port bindet um dort auf Clients zu warten.
	<~~code~~=java>		<syntaxhighlight lang="java">
	[...]		[...]

Zeile 82:		Zeile 82:
	in.close();		in.close();
	server.close();		server.close();
	</~~code=java~~>		</syntaxhighlight>

	An sich kein Problem, bis auf den ServerSocket tut das Programm genau dasselbe wie der Client.		An sich kein Problem, bis auf den ServerSocket tut das Programm genau dasselbe wie der Client.
Zeile 101:		Zeile 101:

	'''Server'''		'''Server'''
	<~~code~~=java>		<syntaxhighlight lang="java">
	[...]		[...]

Zeile 120:		Zeile 120:

	}		}
	</~~code=java~~>		</syntaxhighlight>

	ServerThread		ServerThread
	<~~code~~=java>		<syntaxhighlight lang="java">
	public class ServerThread extends Thread {		public class ServerThread extends Thread {
	private Socket s;		private Socket s;
Zeile 146:		Zeile 146:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	Dies ist natürlich nur ein einfaches Konzept, echte Socketverbindungen können zB. über längere Zeit aufbleiben (damit sich die Threads auch lohnen), aber es macht deutlich wie ein Server mit nebenläufigen Threads funktionieren kann.		Dies ist natürlich nur ein einfaches Konzept, echte Socketverbindungen können zB. über längere Zeit aufbleiben (damit sich die Threads auch lohnen), aber es macht deutlich wie ein Server mit nebenläufigen Threads funktionieren kann.
Zeile 155:		Zeile 155:

	'''Server:'''		'''Server:'''
	<~~code~~=java>		<syntaxhighlight lang="java">
	import java.net.*;		import java.net.*;
	import java.io.*;		import java.io.*;
Zeile 270:		Zeile 270:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

	'''Client:'''		'''Client:'''

	<~~code~~=java>		<syntaxhighlight lang="java">
	import java.net.*;		import java.net.*;
	import java.io.*;		import java.io.*;
Zeile 359:		Zeile 359:
	}		}
	}		}
	</~~code=java~~>		</syntaxhighlight>

L-ectron-x: /* Beispiel: Chat */

2013-11-10T09:38:44Z

Beispiel: Chat

← Nächstältere Version		Version vom 10. November 2013, 09:38 Uhr
Zeile 159:		Zeile 159:
	import java.io.*;		import java.io.*;
	import java.util.*;		import java.util.*;

	public class Server {		public class Server {
	private Hashtable clients;		private Hashtable clients;
	private int port;		private int port;

	public Server(int port) {		public Server(int port) {
	this.port=port;		this.port=port;
	clients = new Hashtable();		clients = new Hashtable();
	}		}

	private void startServerListener() {		private void startServerListener() {
	ServerSocket ss ;		ServerSocket ss ;
Zeile 176:		Zeile 179:
	e.printStackTrace();		e.printStackTrace();
	}		}
	}		}

	public void addClient(String name, ServerBody body) {		public void addClient(String name, ServerBody body) {
	clients.put(name, body);		clients.put(name, body);
	}		}

	public void removeClient(String name) {		public void removeClient(String name) {
	clients.remove(name);		clients.remove(name);
	}		}

	public String getUsers() {		public String getUsers() {
	String users;		String users;
Zeile 192:		Zeile 198:
	return users;		return users;
	}		}

	public void broadcast(String name, String msg) throws Exception {		public void broadcast(String name, String msg) throws Exception {
	for (Enumeration e = clients.keys();e.hasMoreElements();)		for (Enumeration e = clients.keys();e.hasMoreElements();)
	((ServerBody) clients.get((String) e.nextElement())).send(name + ": " + msg);		((ServerBody) clients.get((String) e.nextElement())).send(name + ": " + msg);
	}		}

	public void send(String name, String targetname, String msg) throws Exception {		public void send(String name, String targetname, String msg) throws Exception {
	((ServerBody) clients.get(targetname)).send(name + ": " + msg);		((ServerBody) clients.get(targetname)).send(name + ": " + msg);
	}		}

	public boolean isClient(String name) {		public boolean isClient(String name) {
	return clients.containsKey(name);		return clients.containsKey(name);
	}		}

	public static void main(String[] x) {		public static void main(String[] x) {
	if (x.length != 1) {		if (x.length != 1) {
Zeile 210:		Zeile 220:
	}		}
	}		}

	class ServerBody extends Thread {		class ServerBody extends Thread {
	private Socket cs;		private Socket cs;
	private Server server;		private Server server;
	private PrintWriter out;		private PrintWriter out;

	public ServerBody(Socket cs, Server server) {		public ServerBody(Socket cs, Server server) {
	this.cs=cs;		this.cs=cs;
	this.server=server;		this.server=server;
	}		}

	public void run() {		public void run() {
	BufferedReader in;		BufferedReader in;
Zeile 251:		Zeile 264:
	}		}
	}		}

	public void send(String msg) throws Exception {		public void send(String msg) throws Exception {
	out.println(msg);		out.println(msg);
Zeile 264:		Zeile 278:
	import java.io.*;		import java.io.*;
	import java.util.*;		import java.util.*;

	public class Client {		public class Client {
	private String ip;		private String ip;
	private int port;		private int port;

	public Client(String ip, int port) {		public Client(String ip, int port) {
	this.ip=ip;		this.ip=ip;
	this.port=port;		this.port=port;
	}		}

	private void startClient() throws Exception {		private void startClient() throws Exception {
	Socket s;		Socket s;
Zeile 307:		Zeile 324:
	out.close();		out.close();
	}		}

	public static void main(String[] x) throws Exception {		public static void main(String[] x) throws Exception {
	if (x.length != 2) {		if (x.length != 2) {
Zeile 318:		Zeile 336:
	class ClientBody extends Thread {		class ClientBody extends Thread {
	private InputStream i;		private InputStream i;

	public ClientBody(InputStream i) {		public ClientBody(InputStream i) {
	this.i=i;		this.i=i;
	}		}

	public void run() {		public void run() {
	String buffer;		String buffer;

L-ectron-x am 10. November 2013 um 09:36 Uhr

2013-11-10T09:36:41Z

Änderungen zeigen

L-ectron-x: Die Seite wurde neu angelegt: „=Theorie, ServerSocket = Socket?= Ein Socket stellt einen logischen 'Sockel' für TCP- oder UDP-Netzwerkkommunikation dar. Hier wird nur TCP-Kommunikation behande…“

2013-11-10T09:29:38Z

Die Seite wurde neu angelegt: „=Theorie, ServerSocket = Socket?= Ein Socket stellt einen logischen 'Sockel' für TCP- oder UDP-Netzwerkkommunikation dar. Hier wird nur TCP-Kommunikation behande…“

Neue Seite

=Theorie, ServerSocket = Socket?=
Ein Socket stellt einen logischen 'Sockel' für TCP- oder UDP-Netzwerkkommunikation dar. Hier wird nur TCP-Kommunikation behandelt.

TCP-Kommuniktion basiert auf sogenannten Ports, Ports benutzen Betriebssysteme um mehrere Verbindungen auseinanderhalten zu können. Jeder Port kann nur für eine Verbindung gleichzeitig benutzt werden.
Merke: Ports sind wie Sockets nur logische Konstrukte, in der Hardware sind weder Sockets noch Ports umgesetzt, beides sind lediglich Funktionen die das Betriebssystem zur Verfügung stellt.

Ein Socket kann benutzt werden um von einem lokalen Port eine Verbindung zu einem entferntem Port (dieser kann auf jedem über das Netzwerk erreichbaren Rechner sein, auch dem eigenen!) zu benutzen. Dazu muss ein neuer Socket mindestens mit zwei Angaben konstruiert werden: Zielrechner und Zielport. Der Quellport (auf dem eigenen Rechner, von dem die Kommunikation abgeht) wird vom Betriebssystem automatisch gewählt.

Es ist also nicht möglich auf eine neue Verbindung zu 'warten'. Diese Aufgabe übernimmt ein sog. ServerSocket, welcher automatisch an einen (anzugebenen) Port gebunden wird, auch hier gilt, nur ein Socket/Verbindung pro Port. Der ServerSocket selbst ist für keine wirkliche Kommunikation zuständig, er ist lediglich dafür zuständig neue Verbindungen anzunehmen. Diese werden dann automatisch auf einen neuen Port "umgeleitet" um den Server-Port wieder für neue Verbindungen freizumachen.

Zusammenfassung: Netzwerkkommunikation passiert über Ports die über Sockets angesprochen werden. Um auf neue Verbindungen zu warten wird ein ServerSocket benutzt, der für jede Verbindung einen neuen Socket liefert.

=Socketverbindungen=
Eine simple Verbindung zu einem anderen Rechner (hier allerdings der lokale Host) kann so aussehen:
<code=java>
[...]

// socket auf localhost port 1234 konstruieren
Socket s = new Socket("localhost",1234);

// etwas über den socket versenden
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
out.write("Hello World");

// zeilenumbruch senden
out.newLine();
out.flush();
</code=java>

Soweit noch ganz einfach, um den OutputStream den der Socket auf Anfrage liefert (über den auch sämtliche Kommunikation 'in' den Socket läuft) wird ein BufferedWriter konstruiert, damit wir ganze Zeilen senden können.

Zu beachten sind zwei Dinge:
*Damit auf der anderen Seite auch das Ende der Zeile erkannt werden kann, müssen wir explizit einen Zeilenumbruch mitschicken!
*Wenn Streams oder Writer mit Puffer (Buffer) benutzt werden, dann sollte, sofern es gewünscht wird das der gerade übergebene Text sofort gesendet wird _immer_ die Methode flush() aufgerufen werden, die alles was gerade im Puffer ist weiterleitet. Unter Umständen passiert sonst eine ganze Zeit lang keine Kommunikation da der Puffer noch nicht voll ist und so nicht weitergeleitet wird.

Der Socket kann natürlich nicht nur mit ausgehenden Daten umgehen, sondern auch mit eingehenden:
<code=java>
// BufferedReader konstruieren
BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));

// eine zeile lesen
String text = in.readLine()

// und ausgeben
System.out.print("Received: ");
System.out.println(text);

// am ende schliessen wir alle offenen Reader und Writer, der Socket wird dabei automatisch geschlossen
out.close();
in.close();
</code=java>

Hier ist eine bereits angesprochene Sache zu beachten:
*readLine() wartet (blockiert) so lange, bis ein Zeilenumbruch empfangen wird! Wird keiner gesendet, wartet die Methode ewig!

=Socket-Server=
Auf der anderen Seite brauchen wir nun natürlich einen Server, der mit unserem kleinen Client 'reden' kann. Dazu brauchen wir einen ServerSocket der sich an den entsprechenden Port bindet um dort auf Clients zu warten.
<code=java>
[...]

// Server starten
ServerSocket server = new ServerSocket(1234);

// warten auf eine neue Verbindung
Socket s = server.accept();

// neue Verbindung ist da, wir lesen einfach aus,
// was sie uns so schickt und schicken dann alles in grossbuchstaben wieder zurück
BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
String text = in.readLine();
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
out.write(text.toUpperCase());
out.newLine();
out.flush();

// aufräumen
out.close();
in.close();
server.close();
</code=java>

An sich kein Problem, bis auf den ServerSocket tut das Programm genau dasselbe wie der Client.

Die Methode accept() blockiert das Programm solange bis eine neue Verbindung ankommt. Für diese Verbindung wird dann ein neuer Socket zurückgegeben der genauso wie ein normaler Socket funktioniert. Zu beachten ist, das accept() immer nur _eine_ Verbindung liefert, soll der Server auf weitere Verbindungen warten, so muss accept() wieder aufgerufen werden!

Zu bedenken ist auch, das in.readLine() zwar eine Zeile liest, der String aber _keinen_ Zeilenumbruch am Ende besitzt (also wieder explizit einen senden!)

=Threads und Server=
Es wird schnell klar das obiger Server nicht recht tauglich ist:

*Es wird nur eine Verbindung angenommen, danach beendet sich der Server
*Selbst wenn, zB. über eine while(true)-Schleife accept() wieder aufgerufen werden sollte, ist der Server für die Dauer der Bearbeitung einer Verbindung nicht erreichbar.

Sinnvoller wäre es, wenn der Server sich nur um neue Verbindungen kümmern würde und die Arbeit die eine eigentliche Verbindung macht an einen nebenläufigen Thread abgeben könnte.

'''Server'''
<code=java>
[...]

// Server aufbauen
ServerSocket server = new ServerSocket(1234);
Socket s;

while(true) {

// Auf verbindung warten
s = server.accept();

// kommunikation an einen nebenläufigen Thread abgeben
ServerThread t = new ServerThread(s);
t.start();

// und wieder auf neue Verbindungen warten

}
</code=java>

ServerThread
<code=java>
public class ServerThread extends Thread {
private Socket s;
public ServerThread(Socket s) {
this.s = s;
}
public void run() {

// lesen
BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
String text = in.readLine();

// schreiben
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
out.write(text.toUpperCase());
out.newLine();
out.flush();

// aufräumen
out.close();
in.close();
}
}
</code=java>

Dies ist natürlich nur ein einfaches Konzept, echte Socketverbindungen können zB. über längere Zeit aufbleiben (damit sich die Threads auch lohnen), aber es macht deutlich wie ein Server mit nebenläufigen Threads funktionieren kann.