# Socketverbundung aufrecht halten



## timtrucker (4. Nov 2012)

Hallo 
Ich habe mal ne Frage zu den Sockets in Java:
wie kann ich eine Socketverbindung aufrecht halten?
also dass ich die Position eines Spielers in meinem Spiel imm aktualiesieren kann, ohne eine neue Verbindung jedes mal einzugehen? ich weiss dieses Thema gibt es schon, aber ich kriege es einfach nicht raus ;/

lg timtrucker


----------



## Volvagia (4. Nov 2012)

Solange du nicht close aufrufst oder die Anwendung beendest müsste die Verbindung immer aufrecht bleiben. Denke, dass nichtmal der GC einen offenen Socket wegräumen würde.


----------



## timtrucker (4. Nov 2012)

aber wie läuft das dann genau mit dem Client? wenn ich so zum beispiel vom Server im Sekundentakt immer die nachricht ausgebe "Hello World" und die Vom Client auch direkt im Sekundentakt empfangen will, läuft das dann schon automatisch wenn ich mit ner Whileschleife read.line auslese?


----------



## Volvagia (4. Nov 2012)

Ich baue meistens 2 Verbindungen auf. Das muss vermutlich nicht sein, aber ich bin wenn ich programmiere ein Ordnungsfanatiker.

z. B.
Client baut Verbindung auf
Server beginnt auf der Verbindung zu lesen
Client sendet Authentifikation
Server sendet Ja oder Nein, je nach dem ob die Auth. passt
Wenn nicht wird die Verbindung gekappt.
Wenn schon generiert der Server einen Code für die 2. Verbindung (da gibts bestimmt einen besseren Weg aber mir reicht es)
Server sendet Client den Code.
Client baut eine zweite Verbindung auf und sendet den Authentifikationscode. (Server sollte imho wegen Routern keine Verbindung aufbauen)
Server ordnet mit dem Code die 2. Verbindung der ersten zu und löscht den Code wieder um Hijacking nicht möglich zu machen und genügend Code-Möglichkeiten zu Verfügung zu stellen.

Bis hier her läuft alles in einer Linie gerade runter.

Nun startet Server einen Thread, der von der ersten Verbindung ließt
Client startet einen Thread der von der zweiten Verbindung ließt.

Nun hat Client die erste Verbindung, mit der er dem Server etwas schicken kann. Der Server ließt in einen Thread das und schickt eine eventuelle Antwort über die erste, so kann die erste in einen Programmcode nacheinander verwendet werden.

Falls der Server dem Client etwas sagen will, schickt er es über die zweite Verbindung. Der Client ließt das in der Schleife und reagiert darauf.


----------



## TKausL (4. Nov 2012)

Volvagia ich verstehe nicht warum du Server->Client UND Client->Server nicht über eine einzige Verbindung laufen lässt..


----------



## Volvagia (4. Nov 2012)

Sags doch, Ordnungsfanatiker. xD
Es ist zwar ressourcenmäßig nicht so optimal, aber ich habe immer eine Verbindung über die ich der Gegenstelle etwas mitteile und eine Verbindung falls mir die Gegenstelle etwas mitteilen will, vergleichbar zu einen Listener.

Falls ich nur eine Verbindung hätte und Informationen von beiden Seiten ausgehend gesendet werden müsste auch bei einer einfachen Anfrage die Antwort im Thread der allgemein vom Socket liest lesen, so kann ich die Antwort immer direkt nach der Anfrage lesen und im Thread nur, falls die Gegenstelle mir eine Information schickt, die selbst wieder auch direkt nach der Anfrage ihre Antwort erhalten kann.

Client:

```
private Socket requestCon; //1
private Socket callbackCon; //2

public int readMilkCountInFridge() {
	//synchronized
	sendToServer("How_many_milk_is_in_fridge", requestCon);
	String milkCount = readFromServer(requestCon);
	//int check
	return(Integer.parseInt(milkCount));
}
```

Server:

```
//Thread
private Socket requestCon; //2
private Socket callbackCon; //1

public int run() {
	//Schleife/try
	String input = readFromClient(callbackCon);
	//null check etc.

	if(input.equals("How_many_milk_is_in_fridge")) {
		sendToClient(getMilkCountInFridge(), callbackCon);
	}
}
```


Wenn jetzt jemand anders die Milchmenge im Kühlschrank ändert:

Server:

```
private Socket requestCon; //2
private Socket callbackCon; //1

public int updateMilkCountOnClient() {
	//synchronized
	sendToClient("Milk_count_has_changed", requestCon);
	//Auf Bestätigung des Clients warten
}
```

Client:

```
//Thread
private Socket requestCon; //1
private Socket callbackCon; //2

public int run() {
	//Schleife/try
	String input = readFromServer(callbackCon);
	//null check etc.

	if(input.equals("Milk_count_has_changed")) {
		//Lokale Milchanzahl updaten
	}
}
```


----------



## trööhööt (4. Nov 2012)

@Volvagia
sorry .. aber ich ralls auch irgendwie immer noch nich ...
deine zwei verbindungen ergeben keinen sinn und deinen "verbindungsaufbau" könnte man sogar mit telnet hijaken ... das ist mist
außerdem bist du auch mit zwei verbindungen immer noch selbst für die sync und das zuordnen von anfrage > antwort verantwortlich ...
gleich ob man multi-theading nutzt oder prozedual arbeitet ...

@TO
so lange keine von beiden seiten die verbindung trennt bleibt diese auch offen ...
ich vermute eher du zielst hier auf etwas in richtung HTTP ab oder so ...


----------

