Analyser l'utilisation du module de domaine dans l'exception Node.js handler_node.js

NodeJS fournit le module de domaine pour simplifier la gestion des exceptions dans le code asynchrone. Avant d'introduire ce module, nous devons d'abord comprendre le concept de « domaine ». En termes simples, un domaine est un environnement d'exécution JS, si une exception n'est pas interceptée, elle sera générée comme une exception globale. NodeJS fournit une méthode pour capturer les exceptions globales via l'objet de processus. L'exemple de code est le suivant

.

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

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

Error: undefined is not a function

Bien que les exceptions globales aient un endroit où intercepter, pour la plupart des exceptions, nous espérons les intercepter le plus tôt possible et décider du chemin d'exécution du code en fonction des résultats. Nous utilisons le code du serveur HTTP suivant à titre d'exemple :

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);
    }
  });
});

Le code ci-dessus transmet l'objet de requête à la fonction asynchrone pour traitement, puis renvoie la réponse en fonction du résultat du traitement. Ici, nous utilisons une fonction de rappel pour transmettre les exceptions, donc s'il y a quelques appels de fonction asynchrones supplémentaires dans la fonction asynchrone, le code ressemblera à celui ci-dessus. Afin d'améliorer l'apparence du code, nous pouvons utiliser le module de domaine pour créer un sous-domaine (environnement de sous-exécution JS) à chaque fois qu'une requête est traitée. Le code exécuté dans un sous-domaine peut générer des exceptions à volonté, et ces exceptions peuvent être capturées uniformément via l'événement d'erreur de l'objet sous-domaine. Le code ci-dessus peut donc être modifié comme suit :

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);
    });
  });
});

Comme vous pouvez le voir, nous utilisons la méthode .create pour créer un objet de sous-domaine et utilisons la méthode .run pour saisir le point d'entrée du code qui doit être exécuté dans le sous-domaine. Puisque la fonction de rappel de fonction asynchrone située dans le sous-domaine n'a plus besoin d'intercepter les exceptions, le code est soudain beaucoup plus mince.

Piège
Qu'une exception globale soit capturée via l'événement uncaughtException de l'objet de processus ou qu'une exception de sous-domaine soit capturée via l'événement d'erreur de l'objet de sous-domaine, la documentation officielle de NodeJS recommande fortement de redémarrer le programme immédiatement après avoir traité l'exception, plutôt que laisser le programme continuer à fonctionner. Selon la documentation officielle, le programme après qu'une exception se produit est dans un état d'exécution incertain. S'il ne se termine pas immédiatement, le programme peut avoir une grave fuite de mémoire ou se comporter étrangement.

Mais certains faits doivent être clarifiés ici. Le mécanisme de gestion des exceptions throw..try..catch de JS lui-même ne provoquera pas de fuites de mémoire et les résultats d'exécution du programme ne seront pas inattendus, mais NodeJS n'est pas du pur JS. Un grand nombre d'API dans NodeJS sont implémentées en interne en C/C++. Par conséquent, lors de l'exécution du programme NodeJS, le chemin d'exécution du code fait la navette entre l'intérieur et l'extérieur du moteur JS, et le mécanisme de lancement d'exceptions de JS peut interrompre le processus. flux d'exécution de code normal. Cela entraîne un comportement anormal du code dans la partie C/C++, entraînant des fuites de mémoire et d'autres problèmes.

Par conséquent, utilisez uncaughtException ou domain pour intercepter les exceptions. Lorsque le chemin d'exécution du code implique du code C/C++, si vous n'êtes pas sûr que cela provoquera des fuites de mémoire et d'autres problèmes, il est préférable de redémarrer le programme après avoir traité l'exception. . Lorsque vous utilisez l'instruction try pour intercepter des exceptions, celles-ci sont généralement les propres exceptions de JS, vous n'avez donc pas à vous soucier des appels.