var ws = new WebSocket('ws://localhost:8080');
ws.onopen = function () {
  ws.send(JSON.stringify({
      .... some message the I must send when I connect ....
  }));

};

ws.onmessage = function (e) {
  console.log('Got a message')
  console.log(e.data);
};

ws.onclose = function(e) {  
  console.log('socket closed try again'); 

}

ws.onerror = function(err) {
  console.error(err)
};

Wenn ich mich zum ersten Mal mit dem Socket verbinde, muss ich zuerst eine Nachricht an den Server senden, um mich zu authentifizieren und Kanäle zu abonnieren.

Das Problem, das ich habe, ist, dass der Socket-Server manchmal unzuverlässig ist und die onerrorund oncloseEreignisse des 'ws'Objekts auslöst .

Frage: Was ist ein gutes Entwurfsmuster, das es mir ermöglicht, bei jedem Schließen des Sockets oder bei Auftreten eines Fehlers 10 Sekunden zu warten und dann erneut eine Verbindung zum Socket-Server herzustellen (und die ursprüngliche Nachricht erneut an den Server zu senden)?

Hier ist, was ich am Ende hatte. Es funktioniert für meine Zwecke.

function connect() {
  var ws = new WebSocket('ws://localhost:8080');
  ws.onopen = function() {
    // subscribe to some channels
    ws.send(JSON.stringify({
        //.... some message the I must send when I connect ....
    }));
  };

  ws.onmessage = function(e) {
    console.log('Message:', e.data);
  };

  ws.onclose = function(e) {
    console.log('Socket is closed. Reconnect will be attempted in 1 second.', e.reason);
    setTimeout(function() {
      connect();
    }, 1000);
  };

  ws.onerror = function(err) {
    console.error('Socket encountered error: ', err.message, 'Closing socket');
    ws.close();
  };
}

connect();

Dies hat bei mir funktioniert setInterval, da die Clientverbindung unterbrochen werden kann.

ngOnInit(): void {
    if (window.location.protocol.includes('https')) {
        this.protocol = 'wss';
    }

    this.listenChanges();
}


listenChanges(): void {
    this.socket = new WebSocket(`${this.protocol}://${window.location.host}/v1.0/your/url`);

    this.socket.onmessage = (event): void => {
        // your subscription stuff
        this.store.dispatch(someAction);
    };

    this.socket.onerror = (): void => {
        this.socket.close();
    };


    this.socket.onopen = (): void => {
        clearInterval(this.timerId);

        this.socket.onclose = (): void => {
            this.timerId = setInterval(() => {
                this.listenChanges();
            }, 10000);
        };
    };
}

Vergessen Sie nicht anzurufen, clearIntervalwenn die Steckdose geöffnet wurde.

AKTUALISIERTE Antwort:

Endlich (wenn Sie kein Java verwenden) habe ich festgestellt, dass Sie besser Ihre eigene "Ping / Pong" -Strategie implementieren sollten. (Wenn Sie Java verwenden, werfen Sie bitte einen Blick auf Ping / Pong "Aktionstyp", ich erinnere mich nicht sehr klar ...)

1. Der Client hat alle 5 Sekunden einen "Ping" an den Server gesendet.
2. Der Server sollte dem Client ein "Pong" zurückgeben, sobald er "Ping" erhält.
3. Der Client sollte den Server erneut verbinden, wenn er innerhalb von 5 Sekunden kein "Pong" erhält.

Verlassen Sie sich nicht auf Bibliotheken von Drittanbietern.

WARNUNG: Verwenden Sie diese Werkzeuge NICHT:

1. Überprüfen Sie, ob das Netzwerk verfügbar ist: https://github.com/hubspot/offline
2. Zum erneuten Verbinden: https://github.com/joewalnes/reconnecting-websocket

Ein zu interessanter Wrapper über der nativen Websocket-API, um das hinzuzufügen und schön

https://github.com/joewalnes/reconnecting-websocket