Socket Verbindung Überprüfen

[Aruetiise]

Hey
Kann ich mit einer Methode die Verbindung zum Server vom Client aus feststellen oder muss ich Dateien vom Server an denn Client senden solange er verbunden ist, so zu sagen als Bestätigung?

 

[Robat]

Eine Methode gibt es glaub ich nicht. Kannst du ja aber ganz einfach mit einem heartbeat feststellen.

 

[Aruetiise]

Ich kenne mich nicht so gut mit Netzwerkprogramierung aus... Was ist ein Heartbeat?

 

[Robat]

Hab gerade gesehen dass diese Heartbeat Funktion schon implementiert ist.
Schau dir dazu mal die setKeepAlive(..) und getKeepAlive() Methoden an.
Mehr dazu findest du eventuell hier.

 

[mrBrown]

Hab gerade gesehen dass diese Heartbeat Funktion schon implementiert ist.
Schau dir dazu mal die setKeepAlive(..) und getKeepAlive() Methoden an.
Mehr dazu findest du eventuell hier.

Für so ziemlich jeden Zweck ist aber ein eigener "Heartbeat" besser geeignet, das vorhanden keepAlive hat einen variablen Zeitraum und muss nicht mal überhaupt implementiert sein

 

[Robat]

@mrBrown Ich persönlich hätte es auch selber implementiert.
Wollte nur meine Aussage aus dem ersten Post richtig stellen

 

[Aruetiise]

Also konkret geht es mir darum, das ich will, das der Client solange versucht zum Server eine Verbindung auf zu nehmen, bis die Verbindung steht. Dies wollte ich dadurch erreichen, was aber nicht geht, weil immer eine Exception ausgelöst wird, wenn der Server nicht online ist. Kann man das auch anders erreichen, das er immer wieder versucht die Verbindung aufzunehmen?

Und Danke für eure Antworten zu meiner ursprünglichen Frage.

 

[mrBrown]

Du kannst die Exception fangen, und dann einfach noch mal versuchen?

 

[Aruetiise]

An sich ja. Aber es müsste unendlich lang sein und unendlich verschachtelt sein. Deshalb geht es nicht

 

[mrBrown]

Das ganze natürlich in einer Schleife und nicht ausgeschrieben

 

[Aruetiise]

Muss ich morgen mal testen habe eben nicht so gut überlegt, ob ich das in eine schleife verpackenkann aber das ist ja kein Problem. Sollte schlafen gehen

 

[Aruetiise]

Hast natürlich recht sollte mal schlafen gehen

 

[Aruetiise]

Mit der schleife geht nicht. Hatte recht muss unendlich verschachtelt werden. Denn es muss mit try und catch abgefangen werden und kann somit nicht einfach in eine schleife... zudem beendet sich das Programm sofort im catch block ohne es zu versuchen, neu zu verbinden.

Bekomme die Exception

java.net.ConnectException: Connection refused: connect
at java.net.DualStackPlainSocketImpl.waitForConnect(Native Method)
at java.net.DualStackPlainSocketImpl.socketConnect(Unknown Source)
at java.net.AbstractPlainSocketImpl.doConnect(Unknown Source)
at java.net.AbstractPlainSocketImpl.connectToAddress(Unknown Source)
at java.net.AbstractPlainSocketImpl.connect(Unknown Source)
at java.net.PlainSocketImpl.connect(Unknown Source)
at java.net.SocksSocketImpl.connect(Unknown Source)
at java.net.Socket.connect(Unknown Source)
at client_t.Client_senden.main(Client_senden.java:21)

 

[lant]

wie hast du es denn implementiert?
du müsstest es eigentlich so implementieren

while(failed){
    try{
           //connect to server
    } catch (Exception e){
           //handle exception
    }
}

dann müsste es auch so lange versuchen zu connecten bis es geklappt hat oder durch ein Event außerhalb dieser while Schleife das Programm gestoppt wird.

 

[Aruetiise]

Mein Client Versucht jetzt weiter zu verbinden. Danke.

Jedoch nimmt mein Server die Verbindung nur an, wenn er vor dem Client gestartet wurden.Wenn er danach gestartet wurde, laufen Server und Client einfach weiter ohne eine Verbindung aufzubauen.

//Code Server
public static void main(String[] args) {
    try{
        ServerSocket serverSocket = new ServerSocket(5555);
        System.out.println("Server gestartet");
        Socket clientSocket_1 = new Socket();
      
        try{
        clientSocket_1 = serverSocket.accept();
        System.out.println("Client 1 Verbunden");
        }catch(IOException e){
        System.out.println("Verbindungsaufbau auf port 5555 nicht möglich");
        e.printStackTrace();
        System.exit(0);
        }
      
      
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket_1.getInputStream()));
      
        FileWriter writer = new FileWriter("D:/JavaProgrammieren/Test.txt");
        BufferedWriter bw = new BufferedWriter(writer);
      
      
        String clientInput_1 = null;
        while(true){
            while ((clientInput_1 = in.readLine()) != null ){
                bw.flush();
                bw.write(clientInput_1 + "\n");
                System.out.println(clientInput_1);
                clientInput_1 = null;
            }
        }
      
      
    }catch(IOException e){
        System.out.println("Fehler IO");
        e.printStackTrace();
        System.exit(0);
    }
    }

//Code Client
public static void main(String[] args) {
    Socket Socket = new Socket();
    String Ip = "127.0.0.1";
    int port = 5555;
    SocketAddress Adresse = new InetSocketAddress(Ip, port);
  
    try{
        Socket.connect(Adresse, 10*1000);

        System.out.println("Verbinde zu server...");
        PrintWriter out = new PrintWriter(Socket.getOutputStream());

        FileReader fr = new FileReader("D:/JavaProgrammieren/Test_2.txt");
        BufferedReader br = new BufferedReader(fr);
          
        while(true){
        try{
            String Zeile;
            int Zeilen = 0;
          
            while(true){
            Thread.sleep(20);
            Zeile=null;
            Zeile = br.readLine();
            if(Zeile != null){
                out.write(Zeile + "\n");
                Zeilen++;
                System.out.println(Zeilen);
            }
            if(Zeilen == 10){
                out.close();
                br.close();
                fr.close();
                Socket.close();
            }
        }
        }catch(Exception e){
            System.exit(0);
        }
        }
    }catch( UnknownHostException e){
        System.out.println("Server nicht ereichbar");
        e.printStackTrace();
    }catch (IOException e){
        System.out.println("Fehler reconnect");
       
boolean Verbunden =false;
       while(Verbunden == false){
           try{
            Socket.connect(Adresse, 10*1000);
            Verbunden = true;
            } catch (Exception f){
            try{
                       Thread.sleep(5*1000);
                       }catch(Exception g){
                           System.out.println("Fehler Wait");
                       }
          
                   System.out.println("Fehler reconnect");
            }
        }
    }
    }

 

[mrBrown]

Generell würde ich den gesamten Code für die Verbindung in der Schleife laufen lassen, aktuell wiederholst du das Verbinden nur dann, wenn es eine IOException gibt, und bekommst von einer dann erfolgreichen Verbindung auch nichts mit, weil du weder auf Client noch auf Serverseite irgendetwas ausgibst.

 

[Aruetiise]

boolean Verbunden =false;
        while(Verbunden == false){
            try{
            Socket.connect(Adresse, 10*1000);
            Verbunden = true;
            } catch (Exception f){
            try{
                       Thread.sleep(5*1000);
                       }catch(Exception g){
                           System.out.println("Fehler Wait");
                       }
           
                   System.out.println("Fehler reconnect2");
            }
        }

Bei diesem Code müsste er doch die Schleife so lange ausführen, bis der Server online geht und dann hinter der Schleife weiter machen, oder?

 

[mrBrown]

Macht er auch, aber was kommt denn nach dieser Schleife?

 

[Meniskusschaden]

Außerdem ist der Socket nach dem ersten fehlgeschlagenen connect ohnehin geschlossen und kann nicht wieder geöffnet werden. Du musst in der Schleife also auch einen neuen Socket erstellen.
Ich würde in den catch-Blöcken auch die Exception ausgeben, damit du merkst, was jeweils die Ursache für das Fehlschlagen eines connect-Aufrufs ist. Das ist beim zweiten Aufruf nämlich eine andere, als beim ersten Aufruf.