Analysieren Sie die Verwendung des Domänenmoduls in Node.js Ausnahmebehandlung_node.js

NodeJS stellt das Domänenmodul bereit, um die Ausnahmebehandlung in asynchronem Code zu vereinfachen. Bevor wir dieses Modul einführen, müssen wir zunächst das Konzept der „Domäne“ verstehen. Einfach ausgedrückt ist eine Domäne eine JS-Laufumgebung. Wenn eine Ausnahme in einer Laufumgebung nicht abgefangen wird, wird sie als globale Ausnahme ausgelöst. NodeJS bietet eine Methode zum Erfassen globaler Ausnahmen über das Prozessobjekt. Der Beispielcode lautet wie folgt

process.on('uncaughtException', function (err) {
  console.log('Error: %s', err.message);
});

setTimeout(function (fn) {
  fn();
});

Error: undefined is not a function

Obwohl globale Ausnahmen einen Ort zum Abfangen haben, hoffen wir, sie bei den meisten Ausnahmen so früh wie möglich abzufangen und den Ausführungspfad des Codes basierend auf den Ergebnissen festzulegen. Als Beispiel verwenden wir den folgenden HTTP-Servercode:

function async(request, callback) {
  // Do something.
  asyncA(request, function (err, data) {
    if (err) {
      callback(err);
    } else {
      // Do something
      asyncB(request, function (err, data) {
        if (err) {
          callback(err);
        } else {
          // Do something
          asyncC(request, function (err, data) {
            if (err) {
              callback(err);
            } else {
              // Do something
              callback(null, data);
            }
          });
        }
      });
    }
  });
}

http.createServer(function (request, response) {
  async(request, function (err, data) {
    if (err) {
      response.writeHead(500);
      response.end();
    } else {
      response.writeHead(200);
      response.end(data);
    }
  });
});

Der obige Code übergibt das Anforderungsobjekt zur Verarbeitung an die asynchrone Funktion und gibt dann die Antwort basierend auf dem Verarbeitungsergebnis zurück. Hier verwenden wir eine Rückruffunktion, um Ausnahmen zu übergeben. Wenn es also noch ein paar weitere asynchrone Funktionsaufrufe innerhalb der asynchronen Funktion gibt, sieht der Code wie oben aus. Um den Code besser aussehen zu lassen, können wir das Domänenmodul verwenden, um bei jeder Verarbeitung einer Anfrage eine Subdomäne (JS-Sublaufzeitumgebung) zu erstellen. Code, der in einer Subdomäne ausgeführt wird, kann nach Belieben Ausnahmen auslösen, und diese Ausnahmen können einheitlich durch das Fehlerereignis des Subdomänenobjekts erfasst werden. Daher kann der obige Code wie folgt geändert werden:

function async(request, callback) {
  // Do something.
  asyncA(request, function (data) {
    // Do something
    asyncB(request, function (data) {
      // Do something
      asyncC(request, function (data) {
        // Do something
        callback(data);
      });
    });
  });
}

http.createServer(function (request, response) {
  var d = domain.create();

  d.on('error', function () {
    response.writeHead(500);
    response.end();
  });

  d.run(function () {
    async(request, function (data) {
      response.writeHead(200);
      response.end(data);
    });
  });
});

Wie Sie sehen können, verwenden wir die .create-Methode, um ein Subdomain-Objekt zu erstellen, und verwenden die .run-Methode, um den Einstiegspunkt des Codes einzugeben, der in der Subdomain ausgeführt werden muss. Da die Callback-Funktion der asynchronen Funktion in der Subdomäne keine Ausnahmen mehr abfangen muss, ist der Code plötzlich viel schlanker.

Falle
Unabhängig davon, ob eine globale Ausnahme durch das uncaughtException-Ereignis des Prozessobjekts erfasst wird oder eine Subdomänenausnahme durch das Fehlerereignis des Subdomänenobjekts erfasst wird, empfiehlt die offizielle NodeJS-Dokumentation dringend, das Programm sofort nach der Behandlung der Ausnahme neu zu starten, anstatt Lassen Sie das Programm weiterlaufen. Der offiziellen Dokumentation zufolge befindet sich das Programm nach dem Auftreten einer Ausnahme in einem unsicheren Betriebszustand. Wenn es nicht sofort beendet wird, liegt möglicherweise ein schwerwiegender Speicherverlust vor oder es verhält sich seltsam.

Aber hier müssen einige Sachverhalte geklärt werden. Der Ausnahmebehandlungsmechanismus throw..try..catch von JS selbst verursacht weder Speicherverluste noch sind die Ausführungsergebnisse des Programms unerwartet, aber NodeJS ist kein reines JS. Eine große Anzahl von APIs in NodeJS sind intern in C/C implementiert. Daher wechselt der Codeausführungspfad während der Ausführung des NodeJS-Programms zwischen der Innenseite und der Außenseite der JS-Engine, und der Ausnahmeauslösungsmechanismus von JS kann dies unterbrechen Normaler Codeausführungsprozess. Dies führt dazu, dass sich der Code im C/C-Teil abnormal verhält, was zu Speicherverlusten und anderen Problemen führt.

Verwenden Sie daher uncaughtException oder domain, um Ausnahmen abzufangen. Wenn der Codeausführungspfad den C/C-Teil des Codes umfasst und Sie nicht sicher sind, ob dies zu Speicherverlusten und anderen Problemen führt, ist es besser, das Programm neu zu starten nach der Behandlung der Ausnahme. Wenn Sie die try-Anweisung zum Abfangen von Ausnahmen verwenden, handelt es sich bei den abgefangenen Ausnahmen im Allgemeinen um die eigenen Ausnahmen von JS, sodass Sie sich keine Gedanken über Einsprüche machen müssen.