So verbessern Sie die Stabilität von NodeJS

Methoden zur Verbesserung der Stabilität von nodejs: 1. Behalten Sie eine gute Codestruktur bei. 2. Verwenden Sie „try~catch“, um Ausnahmen abzufangen. 3. Verwenden Sie das Domänenmodul, um Programmausnahmen zu behandeln. 4. Verwenden Sie das log4js-Modul, um Protokolle aufzuzeichnen 5. Verwenden Sie das Forever-Modul, um NodeJS zu verwalten.

Die Betriebsumgebung dieses Tutorials: Windows7-System, NodeJS-Version 12.19.0, DELL G3-Computer.

Verbessern Sie die Stabilität und Robustheit des NodeJS-Programms

Ich habe einige Beiträge im Internet gesehen, in denen die Stabilität des NodeJS-Programms beschwert und in Frage gestellt wurde. Warum? Erstens hat das vielleicht etwas mit JavaScript zu tun. Node ist auch als „die am meisten missverstandene Sprache der Welt“ bekannt. Wir können einen Blick darauf werfen, was der Gründer von nodejs gesagt hat Warum verwendet Node in diesem Artikel Javascript, um es zu implementieren? Schließlich ist NodeJS noch jung und die offizielle Website markiert auch den aktuellen Status dieses Moduls.

Ich habe mir in den letzten zwei Tagen etwas Zeit genommen, über dieses Problem nachzudenken. Ich denke, dass die erste Funktion unseres Programms unabhängig sein sollte, aber keine Auswirkungen auf eine andere normale Funktion haben sollte Zweitens sollten wir ein Programm zum automatischen Starten haben, damit wir das Problem leichter verfolgen können. Ich denke, dass die Stabilität von NodeJS vor allem unter folgenden Aspekten verbessert werden kann:

1) Behalten Sie eine gute Codestruktur bei:

Wir wissen, dass der Node Single-Threaded, nicht blockierendes Io, standardmäßig asynchron ist und nachfolgende Prozesse verarbeitet Wenn es zu viele verschachtelte Ebenen gibt, führt dies unweigerlich zu Verwirrung in der logischen Struktur des Codes und ist der Wartung und Aktualisierung nicht förderlich. Sie können Async, ein asynchrones Prozesssteuerungsmodul, verwenden, um unsere Codelogik zu verdeutlichen.

2) Verwenden Sie Process.on('uncaughtException', function(err){...}); um nicht abgefangene Fehler zu behandeln.

3) Verwenden Sie try~catch, um Ausnahmen abzufangen:

Dies kann nur einen Teil des Problems lösen, nicht alles. Wie oben erwähnt, ist der Standardwert asynchron, da es sich bei dem Knoten um ein Single-Threaded-, nicht blockierendes IO handelt. Durch Rückrufe kann try~catch den Fehler im Rückruf nicht erfassen. Wie kann der Fehler im Rückruf erfasst werden?

4) Verwenden Sie das Domänenmodul, um Programmausnahmen zu behandeln

Schauen Sie sich zunächst die Erklärung von domain an: domain ist eine Unterklasse der EventEmitter-Klasse. Hören Sie auf das Fehlerereignis, um die erfassten Fehler zu behandeln. Es bietet eine Möglichkeit, mehrere verschiedene E/A-Vorgänge als eine einzige Gruppe abzuwickeln. Wenn ein in der Domäne registrierter Ereignisauslöser oder Rückruf ein Fehlerereignis auslöst oder einen Fehler auslöst, wird das Domänenobjekt benachrichtigt. Anstatt den Kontext dieses Fehlers direkt aus dem Handler „process.on('uncaughtException')“ zu verlieren, führt dies nicht dazu, dass das Programm aufgrund dieses von einem Fehlercode begleiteten Fehlers sofort beendet wird.

Wie verwende ich das Domänenmodul? Schauen Sie sich ein Beispiel an:

serverDomain.run(function() {
  // 服务器在serverDomain的作用域内被创建
  http.createServer(function(req, res) {
    // req和res同样在serverDomain的作用域内被创建
    // 但是，我们想对于每一个请求使用一个不一样的域。
    // 所以我们首先创建一个域，然后将req和res添加到这个域上。
    var reqd = domain.create();
    reqd.add(req);
    reqd.add(res);
    reqd.on('error', function(er) {
      console.error('Error', er, req.url);
      try {
        res.writeHead(500);
        res.end('Error occurred, sorry.');
      } catch (er) {
        console.error('Error sending 500', er, req.url);
      }
    });
  }).listen(1337);    
});
```

Beschreibung: Erstellen Sie zunächst eine Domäne (domain.create()), fügen Sie dann den zu überwachenden Verteiler zur Domäne hinzu und binden Sie schließlich ein Fehlerereignis an die Domäne, damit diese überwacht werden kann .

Sehen Sie sich ein anderes Beispiel an:

var d = domain.create();
d.on('error', function(er) {
  console.error('Caught error!', er);
});
d.run(function() {
  process.nextTick(function() {
    setTimeout(function() { // 模拟几个不同的异步的东西
      fs.open('non-existent file', 'r', function(er, fd) {
        if (er) throw er;
        // 继续。。。
      });
    }, 100);
  });
});

Erklärung: Erstellen Sie zunächst eine Domäne, binden Sie ein Fehlerereignis an die Domäne und stellen Sie dann eine Funktion bereit, die im Kontext der Domäne ausgeführt werden kann.

Was passiert, wenn ein Rückruf erfolgt? Sie können es so verwenden

var d = domain.create();

function readSomeFile(filename, cb) {
  fs.readFile(filename, 'utf8', d.bind(function(er, data) {
    // if this throws, it will also be passed to the domain
    return cb(er, data ? JSON.parse(data) : null);
  }));
}

d.on('error', function(er) {
  // an error occurred somewhere.
  // if we throw it now, it will crash the program
  // with the normal line number and stack message.
});

Natürlich können Sie es auch so verwenden

var d = domain.create();

function readSomeFile(filename, cb) {
  fs.readFile(filename, 'utf8', d.bind(function(er, data) {
    // if this throws, it will also be passed to the domain
    return cb(er, data ? JSON.parse(data) : null);
  }));
}

d.on('error', function(er) {
  // an error occurred somewhere.
  // if we throw it now, it will crash the program
  // with the normal line number and stack message.
});

Diese Funktion ist fast genau die gleiche wie domain.bind(callback). Es fängt jedoch nicht nur ausgelöste Fehler ab, sondern fängt auch das als erstes Argument an diese Funktion übergebene Error-Objekt ab.

5) Verwenden Sie das log4js-Modul zum Aufzeichnen von Protokollen

Log4js ist ein sehr leistungsstarkes Protokollverwaltungstool. Sie können sich dieses Github-Projekt ansehen: https://github.com/nomiddlename/log4js-node

6) Verwenden Sie das Modul „Forever“, um NodeJS zu verwalten

　Forever ist ein Modul für die serverseitige Verwaltung von NodeJS, einem Befehlszeilentool, das App-Anwendungen starten und stoppen kann. Forever basiert vollständig auf Befehlszeilenvorgängen. Unter der Verwaltung des Forever-Prozesses wird ein Unterprozess des Knotens erstellt und der Ausführungsstatus des Knoten-Unterprozesses über den Monitor überwacht, sobald die Datei aktualisiert wird Wenn es hängt, wird der Knotenserver für immer automatisch neu gestartet, um sicherzustellen, dass die Anwendung normal ausgeführt wird. Sehr einfach zu bedienen.

Sie können auf dieses Projekt achten: https://github.com/nodejitsu/forever

Aber Forever ist kein Allheilmittel und weist außerdem die folgenden Probleme auf:

Eingeschränkte Überwachung und Protokollierungsfunktionen
• Schlechte Unterstützung für die Prozessverwaltungskonfiguration
• Unterstützt keine Cluster
• Die Codebasis ist veraltet (was zu häufigen Fehlern beim Upgrade von node.js führt)

Anbei ist der Testcode dieses Artikels: https://github .com/yupeng528/node-error

Weitere Informationen zu Knoten finden Sie unter:

nodejs-Tutorial! !

Das obige ist der detaillierte Inhalt vonSo verbessern Sie die Stabilität von NodeJS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!