# Socket immer Verbunden halten



## tapsus (22. Dez 2008)

Hallo zusammen!

ich programmiere eine Applikation die jede 10 sec durchgeführt sein soll, Aber die Socket verbindung soll nur einmal gemacht werden und verbunden bleiben.

Ich die in und out streams von der socket klasse auch jede 10 sec verwenden ohne jedesmal eine neue socket verbindung zu machen, hier ist meine Socket klasse:

```
public class ConnectToTarget {

	
    
    public static void connecting()
    {
    	Socket echoSocket = null;
        PrintWriter out = null;
        BufferedReader in = null;
        
        LoadConfiguration lc = new LoadConfiguration();
        String host = lc.destinationHost;  
        int port = Integer.valueOf(lc.destinationPort).intValue();
    	try {
    		
            echoSocket = new Socket(host, port);
            out = new PrintWriter(echoSocket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(
                    echoSocket.getInputStream()));
            
            
        } catch (UnknownHostException e) {
            System.err.println("Don't know about host: " + host);
            System.exit(1);
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for "
                               + "the connection to: " + host);
            System.err.println("Verify target connectivity!");
            System.exit(1);
            
        }
    }
    
}
```

wie kann ich von dierser klasse in und out in einer anderen klasse verwenden


----------



## Murray (22. Dez 2008)

1. in und out nicht als lokale Variablen, sondern als statische Member deklarieren
2. public get-Methoden für diese Member bauen


----------



## tapsus (22. Dez 2008)

Murray hat gesagt.:
			
		

> 1. in und out nicht als lokale Variablen, sondern als statische Member deklarieren
> 2. public get-Methoden für diese Member bauen



Vielen Dank Murray!

könntest mir bitte sagen wie ich das schreiben soll, bin och anfänger 
vielen Dank!


----------



## Murray (22. Dez 2008)

Etwa so:

```
public class ConnectToTarget {

    private static Writer out;
    private static Reader in;
   
    private static void connect() {
       Socket echoSocket = null;
       
        LoadConfiguration lc = new LoadConfiguration();
        String host = lc.destinationHost; 
        int port = Integer.valueOf(lc.destinationPort).intValue();
       try {
          
            echoSocket = new Socket(host, port);
            out = new PrintWriter(echoSocket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(
                    echoSocket.getInputStream()));
           
           
        } catch (UnknownHostException e) {
            System.err.println("Don't know about host: " + host);
            System.exit(1);
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for "
                               + "the connection to: " + host);
            System.err.println("Verify target connectivity!");
            System.exit(1);
           
        }
    }

    public static synchronized Writer getOutput() {
      if ( out == null) connect();
      return out;
    }

    public static synchronized Reader getInput() {
      if ( in == null) connect();
      return in;
    }
}
```

Ob es allerdings in Deinem Anwendungsfall in Ordnung ist, diese Verbindung statisch zu halten (weil es in der Natur dieser Verbindung gibt, dass es niemals zwei verschiedene Verbindungen geben kann) und ob die Fehlerbehandlung per Konsolenausgabe und System.exit hinreichen (in ernsthaften Anwendungen eher nicht), musst Du selbst entscheiden.


----------



## tapsus (22. Dez 2008)

Murray hat gesagt.:
			
		

> Etwa so:
> 
> 
> Ob es allerdings in Deinem Anwendungsfall in Ordnung ist, diese Verbindung statisch zu halten (weil es in der Natur dieser Verbindung gibt, dass es niemals zwei verschiedene Verbindungen geben kann) und ob die Fehlerbehandlung per Konsolenausgabe und System.exit hinreichen (in ernsthaften Anwendungen eher nicht), musst Du selbst entscheiden.



Dieses Code hat super funktionniert vielen Dank!!

Wenn ich eine nachricht schicke erwarte ich eine ACK message vom Target. wenn ich diese lese kommt das raus : "@149a794"
wauch wenn ich schreibe
	
	
	
	





```
ackMessage = ConnectToTarget.getInput().toString();
```


----------



## Murray (22. Dez 2008)

ConnectToTarget#getInput liefert ja einen Reader - und dessen toString-Methode liefert eben nicht die Daten, die man über diesen Reader lesen kann.
Unter der Voraussetzung, dass der Server die AKN-Meldung mit einem CR und/oder LF abschließt, könnte es so gehen:


```
String akn = ConnectToTarget.getInput().readLine();
System.out.println( "akn=" + akn);
```

Achtung: dazu muss in ConnectToTraget der Typ von in und der Rückgabewert von getInput von Reader auf *Buffered*Reader geändert werden.


----------



## tapsus (22. Dez 2008)

Ich habe es geändert und hats gut funktioniert. 
wie kann ich nach einmal ausführen den bufferedReader entleeren??.


----------



## Murray (22. Dez 2008)

Das gibt es nichts zu "entleeren" - durch das Auslesen ("readLine") sind die Daten nicht mehr im Buffer.


----------



## tapsus (22. Dez 2008)

Vieeeeeeeelen Dank Murray
du bist der JavaGott!


----------



## tapsus (23. Dez 2008)

Sevus Murray!

ich würde gerne die static synchronized methode verstehen, was machen die ??
vielen Dank!


----------



## Murray (23. Dez 2008)

Das sind erstmal normale Zugriffsmethoden (auch "Getter" genannt):

```
public static Writer getOutput() {
      return out;
    }

    public static Reader getInput() {
      return in;
    }
```
Die Methoden müssen static deklariert sein, weil sie ja unabhängig von konkreten Instanzen aufgerufen werden sollen.

Damit man mit diesen Methoden auch etwas anfangen kann, müssen in und out auch irgendwie initialisiert werden; man müsste also connect aufrufen. Und damit man sich darum nicht kümmern muss, habe ich das in die get-Methoden gepackt; so wird connect a) nur einmal und b) vor der ersten Benutzung des Streams oder des Reader aufgerufen (so etwas nennt man auch "lazy initialization": ein Objekt wird nicht sofort, aber vor seiner ersten Verwendung angelegt).


```
public static Writer getOutput() {
      if ( out == null) connect();
      return out;
    }

    public static Reader getInput() {
      if ( in == null) connect();
      return in;
    }
```

Und das synchronized kommt jetzt ins Spiel für den Fall, falls mehrere Threads im Spiel sind. In dem Fall könnte es nämlich passieren, dass ein Thread einen Getter aufruft, feststellt dass das Member noch null ist und dann connect aufruft. Wird dieser Thread jetzt unterbrochen und ein zweiter Thread ruft ebenfalls einern der Getter auf, so ist das Member immer noch null, und connect würde ein zweites Mal aufgerufen. Um das zu vermeiden, muss die Sequenz "Prüfung des Members und ggfs. Aufruf der connect-Methode so gekapselt werden, dass sie von einem Thread nur dann ausgeführt werden kann, wenn kein anderer Thread diesen Block gerade bearbeitet.


----------



## tapsus (23. Dez 2008)

Vielen Dank Murray,

bist echt viel besser als einen Prof. an der TU München!


----------

