Detaillierte Erläuterung der Gründe für die Trennung von JS WebSocket und des Heartbeat-Mechanismus

ws.onclose = Funktion (e) {
  console.log('WebSocket getrennt: ' + e.code + ' ' + e.reason + ' ' + e.wasClean)
  console.log(e)
}

var lockReconnect = false; // Wiederholte ws-Verbindungen vermeiden var ws = null; // Feststellen, ob der aktuelle Browser WebSocket unterstützt
var wsUrl = serverConfig.socketUrl;
createWebSocket(wsUrl); //Mit ws verbinden

Funktion erstelleWebSocket(URL) {
    versuchen{
        if('WebSocket' im Fenster){
            ws = neuer WebSocket(URL);
        }
        : InitEventHandle();
    }fangen(e){
        erneut verbinden (URL);
        konsole.log(e);
    }     
}

Funktion initEventHandle() {
    ws.onclose = Funktion () {
        erneut verbinden(wsUrl);
        console.log("llws-Verbindung geschlossen!"+new Date().toLocaleString());
    };
    ws.onerror = Funktion () {
        erneut verbinden(wsUrl);
        console.log("llws-Verbindungsfehler!");
    };
    ws.onopen = Funktion () {
        heartCheck.reset().start(); //Zurücksetzen der Herzschlagerkennung console.log("llws-Verbindung erfolgreich!"+new Date().toLocaleString());
    };
    ws.onmessage = function (event) { //Wenn eine Nachricht empfangen wird, wird die Heartbeat-Erkennung zurückgesetzt heartCheck.reset().start(); //Der Empfang einer beliebigen Nachricht bedeutet, dass die aktuelle Verbindung normal ist console.log("llws hat die Nachricht empfangen:" + event.data);
        wenn(event.data!='pong'){
            let Daten = jsON.parse(Ereignis.Daten);
        }
    };
}
// Auf Fensterschließereignisse achten. Wenn das Fenster geschlossen wird, schließen Sie aktiv die WebSocket-Verbindung, um zu verhindern, dass der Server eine Ausnahme auslöst, wenn das Fenster geschlossen wird, bevor die Verbindung getrennt wird.
window.onbeforeunload = Funktion() {
    ws.schließen();
}  

Funktion erneut verbinden(URL) {
    wenn (lockReconnect) zurückgeben;
    lockReconnect = wahr;
    setTimeout(function () { //Wenn die Verbindung fehlschlägt, wird die Verbindung immer wieder hergestellt. Legen Sie eine Verzögerung fest, um zu viele Anfragen zu vermeiden. createWebSocket(url);
        lockReconnect = falsch;
    }, 2000);
}

//Herzschlagerkennung var heartCheck = {
    timeout: 1000, //Sende jede Minute einen Heartbeat timeoutObj: null,
    serverTimeoutObj: null,
    zurücksetzen: Funktion(){
        Zeitüberschreitung löschen(dieses.timeoutObj);
        Zeitüberschreitung löschen(dieses.ServerTimeoutObj);
        gib dies zurück;
    },
    Start: Funktion(){
        var selbst = dies;
        dies.timeoutObj = setTimeout(Funktion(){
            //Hier wird ein Heartbeat gesendet und nachdem das Backend ihn empfangen hat, wird eine Heartbeat-Nachricht zurückgegeben.
            //onmessage erhält den zurückgegebenen Heartbeat, was bedeutet, dass die Verbindung normal istws.send("ping");
            console.log("Ping!")
            self.serverTimeoutObj = setTimeout(function(){//Wenn es nach einer bestimmten Zeit nicht zurückgesetzt wird, bedeutet dies, dass das Backend die Verbindung aktiv getrennt hat ws.close(); //Wenn onclose eine erneute Verbindung ausführt, müssen wir nur ws.close() ausführen. Wenn die erneute Verbindung direkt ausgeführt wird, wird onclose ausgelöst, was zu zwei erneuten Verbindungen führt}, self.timeout)
        }, dieses.Timeout)
    }
}
    //Methode, die nach dem Empfang der Client-Nachricht aufgerufen wird @OnMessage  
    public void onMessage(String Nachricht, Session Sitzung) {  
        wenn (Nachricht.equals("ping")) {
        }anders{
        . . . .
        }
   }