# erste Client - Server Anwendung, paar Fragen wie Socketverbindung checken usw.



## Vilkazzz (31. Aug 2014)

Hallo,

google sei dank hab ich das meiste gefunden und mein erstes server/client Pärchen geschrieben.

die beiden finden sich, alles gut.

nun hab ich frage ob ich mit der Client struktur alles richtig gemacht habe ?

ich habe eine JavaFXUI in der HauptMethode,
dann hab ich eine "Connector" die aufgerufen wird, wenn ein Knopf aufder UI gelickt wird.

dann steht erstmalls die Verbindung zwischen server und client app, werden ein paar Begrüssungen ausgetauscht, alles Tutorial like.

nun, da die Verbindung steht, möchte ich beim klicken von anderen Knöpfen daten mit dem Server auszutauschen, jenachdem welcher knopf keklickt wird, soll was anderes zurück.

nennen wir mal die methode "MatrixWasClicked".

bisher ist die bei mir lediglich eine testmethode.


```
public static void MatrixWasClicked(Integer id){
        System.out.println("Matrix number "+id+" was clicked");

    }
```


meine Fragen sind nun wie folgt, kann die "matrixWasclicked" methode überprüfen, ob die Verbindung zwischen dem server und client aktiv ist ? die verbindung wurde ja in einer anderer methode aufgebaut !

kann ich überhaupt mit einer Methode die Verbindung aufbauen, und dann durch andere Methoden die Daten dem Server schicken / von server empfangen ?


dies wäre meine Verbindungs Methode

```
public static void Connector(String serverName) {

        {
            int port = 9980;
            try {
                System.out.println("Connecting to " + serverName
                        + " on port " + port);
                Socket client = new Socket(serverName, port);
                System.out.println("Just connected to "
                        + client.getRemoteSocketAddress());
                OutputStream outToServer = client.getOutputStream();
                DataOutputStream out;
                out = new DataOutputStream(outToServer);

                out.writeUTF("Hello from "
                        + client.getLocalSocketAddress());
                InputStream inFromServer = client.getInputStream();
                DataInputStream in =
                new DataInputStream(inFromServer);
                System.out.println("Server says " + in.readUTF());

                //client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
```

und so rufe ich sie in der GUI auf


```
connectBtn.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                Connector(topServeradressField.getPromptText());
                        }
        });
```


damit nicht zuviel brei in einem Code ist, woltle ich die aufgaben ein bissle verteilen, 
daher wollteich ursprünglich beim clicken eines buttons lediglich 


```
MatrixWasClicked(i);
```

aktivieren, und dort dann in Abhängigkeit von der ID entsprechend mit dem server weiter komunizieren.

nur kann ich in der "matrixWasClicked"  auf die im "connector" erstellte verbindung, und die ganzen StreamWriter usw zugreifen ?


----------



## turtle (31. Aug 2014)

> kann ich überhaupt mit einer Methode die Verbindung aufbauen, und dann durch andere Methoden die Daten dem Server schicken / von server empfangen ?


Klar geht das

Du kannst dir ja den Socket speichern/merken und dann jederzeit den Input/Outputstream holen. Neben dem Socket (oder dessen In/Out-Streams) kannst du dir natürlich auch merken, ob bereits eine Verbindung hergestellt wurde obwohl dies wohl immer der Fall sein dürfte wenn der Socket null ist.


----------



## Vilkazzz (31. Aug 2014)

Sonntag, 17h, Turtle hillft 

mein Problem ist dann wohl, das ich noch nicht weiss wie ich das mache, aber schonmal gut zu wissen dass es geht, sonst hab ich mal wieder ein Code-Brei.

in meiner connector methode hab ich 


```
Socket client = new Socket(serverName, port);
```

wenn ich ausserhalb der Methode versuche auf Client zuzugreifen geht dies natürlich nicht.

Soll ich eine copy von dem socket irgendwie in der hauptmethode erzeugen, und dann beim Buttonclick 
es als parameter weitergeben ? geht es ?

hast du irgendwo ein tutorial oder ein code beispiel wo sowas gemacht wird ?
(socket speichern und auf die VErbindung zugreifen?

ich bin da halt noch total grün -.-  aber ist eine Aufgabe für eine Azubi-Bewerbung, will es möglichst schön machen 

ich hab mir schon socket adresse ausgedrückt 


```
System.out.println(client.getLocalSocketAddress());
```

um anfangs es manuell zu erzwingen, und wäre für jeden weiteren hinweis dankbar 

sonst google ich heute abend weiter, jetzt weiss ich ja , dass es geht, nur noch rausfinden wie


----------



## turtle (31. Aug 2014)

Socket client würde ich als Member-Attribut der Klasse machen.
Dann verkürzt sich die Zeile zu

```
client = new Socket(serverName, port);
```
und dann vielleicht noch einen getter dafür schreiben. Bitte KEINE copy von dem socket machen, da ja "unterliegend" feststeht, welche TCP/IP-Eigenschaften verknüpft sind.


----------



## Vilkazzz (1. Sep 2014)

so, habe einiges rumprobiert, am ende versuch ich es so zu vereinfachen wie es nur geht 

also, hab eine methode gemacht, die nichts weiteres macht als einen Socket herzustellen und es als Return gibt




```
public Socket MakeSocket(String serverName) {
        Socket socket;
        socket = null;
        int port = 9980;
        try {
            socket = new Socket(serverName, port);
            } 
        catch (IOException e) {
            e.printStackTrace();
        }
        return socket;
    }
```

soweit sogut, problem ist ja nur, dass es jedes mal einen neuen socket mir erstellt wenn ich es aufrufe.

einen getter, konnte ich da nicht einabauen ! 

den geter hab ich mir so vorgestellt


```
public Socket getSocket(){
                try{return socket;
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
```

aber unabhängig davon in welchen Teil der Methode MakeSocket eingefügt habe,
hab ich nur Fehler bekommen :/

ok dann, evtl muss ich mit classes arbeiten.

also hab ich eine 


```
public class CreateSocket {
        int port = 9980;
        String serverName = "";
        Socket socket;

        {
            try {
                socket = new Socket(serverName, port);
            } catch (IOException e1) {
                e1.printStackTrace();
            }

        }

        public String getServerName() {
            return serverName;
        }
        public void setServerName(String serverName) {
            this.serverName = serverName;
        }
        public Socket getSocket() {
            return socket;
        }

  
    }
```

gemacht, teoretisch, sollte ich mit setSocket dort einen socket erschaffen (richtige name und port vorausgesetzt)

und von da könnte ich mit "getSocket" es immer abrufen, evtl kann ich dann da gleich in IN und OUT methoden beschreiben. nur da bekomme ich diese Meldung



oder ist es ehe unratsam sockets weiterzugeben ?

evtl ist es klüger lediglich die


```
socket.getOutputStream()
socket.getInputStream()
```

irgendwie zu vererben ?

nun hab ich halben Tag damit verbracht, aber ich schaff nicht mit den socket von einer methode mit anderen methoden zu teilen 

ich versuch mal die clientdatei von anfang an neu zu schreiben, evtl ist meine Architektur oder Denkweise falsch.


----------

