Explication détaillée de la gestion des exceptions asynchrones dans js et de l'utilisation du didacticiel Domian

Cet article présente principalement Node.js le traitement des exceptions asynchrones et l'analyse des modules de domaine, qui ont une certaine valeur de référence. Les amis intéressés peuvent s'y référer

Gestion des exceptions asynchrones

Caractéristiques des exceptions asynchrones

En raison de la nature asynchrone de rappel du nœud, il est impossible d'intercepter toutes les exceptions via try catch Exceptions :

try {
 process.nextTick(function () {
  foo.bar();
 });
} catch (err) {
 //can not catch it
}

Pour les services Web, il est en fait très souhaitable d'avoir ceci :

//express风格的路由
app.get('/index', function (req, res) {
 try {
  //业务逻辑
 } catch (err) {
  logger.error(err);
  res.statusCode = 500;
  return res.json({success: false, message: '服务器异常'});
 }
});

Si try catch peut intercepter toutes les exceptions, alors nous pouvons avoir des erreurs dans le code Lorsqu'un Une erreur inattendue se produit, il peut enregistrer l'erreur et renvoyer une erreur 500 à l'appelant de manière conviviale. Malheureusement, try catch ne peut pas intercepter les exceptions dans des situations asynchrones. Donc tout ce que nous pouvons faire c'est :

app.get('/index', function (req, res) {
 // 业务逻辑 
});

process.on('uncaughtException', function (err) {
 logger.error(err);
});

À ce stade, même si nous pouvons enregistrer le journal des erreurs et que le processus ne

se termine anormalement, nous ne pouvons en aucun cas si une demande qui trouve une erreur est renvoyé de manière conviviale, elle ne peut être renvoyée qu'avec un délai d'attente.

domaine

Dans le nœud v0.8+, un domaine de module a été publié. Ce module fait ce que try catch ne peut pas faire : intercepter les exceptions qui se produisent dans les rappels asynchrones.

Depuis, notre exemple impuissant ci-dessus semble avoir une solution :

var domain = require('domain');

//引入一个domain的中间件，将每一个请求都包裹在一个独立的domain中
//domain来处理异常
app.use(function (req,res, next) {
 var d = domain.create();
 //监听domain的错误事件
 d.on('error', function (err) {
  logger.error(err);
  res.statusCode = 500;
  res.json({sucess:false, messag: '服务器异常'});
  d.dispose();
 });
 
 d.add(req);
 d.add(res);
 d.run(next);
});

app.get('/index', function (req, res) {
 //处理业务
});

Nous introduisons le domaine sous forme de middleware pour gérer les exceptions asynchrones. Bien sûr, même si le domaine a détecté l'exception, la perte de pile causée par l'exception entraînera toujours des fuites de mémoire. Par conséquent, lorsque cela se produit, vous devez toujours redémarrer le processus. Les étudiants intéressés peuvent consulter le middleware de domaine. . pièces.

Échec étrange

Notre test était tout à fait normal lorsqu'il a été officiellement utilisé dans l'environnement de production, nous avons constaté que le domaine échouait soudainement ! Il n’a pas intercepté l’exception asynchrone, ce qui a finalement provoqué la fermeture anormale du processus. Après quelques investigations, il a finalement été découvert que le problème était dû à l'introduction de Redis dans le magasin

session.

var http = require('http');
var connect = require('connect');
var RedisStore = require('connect-redis')(connect);
var domainMiddleware = require('domain-middleware');

var server = http.createServer();
var app = connect();
app.use(connect.session({
 key: 'key',
 secret: 'secret',
 store: new RedisStore(6379, 'localhost')
}));
//domainMiddleware的使用可以看前面的链接
app.use(domainMiddleware({
 server: server,
 killTimeout: 30000
}));

À ce moment-là, lorsqu'une exception se produisait dans notre code de logique métier, nous avons constaté qu'elle n'était pas capturée par le domaine ! Après quelques tentatives, le problème a finalement été localisé :

var domain = require('domain');
var redis = require('redis');
var cache = redis.createClient(6379, 'localhost');

function error() {
 cache.get('a', function () {
  throw new Error('something wrong');
 });
}

function ok () {
 setTimeout(function () {
  throw new Error('something wrong');
 }, 100);
}
var d = domain.create();
d.on('error', function (err) {
 console.log(err);
});

d.run(ok);  //domain捕获到异常
d.run(error); //异常被抛出

Etrange ! Ce sont tous deux des appels asynchrones. Pourquoi le premier est-il capturé mais pas le second ?

Analyse du domaine

Avec le recul, regardons ce que fait le domaine pour nous permettre de capturer les requêtes asynchrones (le code vient du nœud v0.10.4, cette partie Peut être en cours d'optimisation de changement rapide).

événement de nœudbouclemécanisme

Avant d'examiner le principe du domaine, nous devons d'abord comprendre nextTick et _tickC

allDeux méthodes de retour.

function laterCall() {
 console.log('print me later');
}

process.nextTick(laterCallback);
console.log('print me first');

Quiconque a écrit node dans le code ci-dessus le connaît. La fonction de nextTick est de placer laterCallback dans la prochaine boucle d'événement pour exécution. La méthode _tickCallback est une méthode non publique. Cette méthode consiste à appeler la fonction d'entrée

pour continuer la boucle d'événement suivante après la fin de la boucle temporelle actuelle.

En d'autres termes, le nœud maintient une file d'attente pour la boucle d'événements, nextTick est mis en file d'attente et _tickCallback est retiré de la file d'attente.

Implémentation du domaine

Après avoir compris le mécanisme de boucle d'événements du nœud, jetons un coup d'œil à ce que fait le domaine.

Le domaine lui-même est en fait un objet EventEmitter, qui transmet les erreurs capturées via des événements. De cette façon, lorsque nous l'étudions, nous le simplifions en deux points :

Quand l'événement d'erreur du domaine est-il déclenché :

Le processus a lancé une exception, qui n'a été interceptée par aucun try catch.À ce moment, le processFatal de l'ensemble du processus sera déclenché s'il est dans le package de domaine, l'événement d'erreur sera déclenché sur le domaine. Sinon, l'événement uncaughtException sera déclenché sur le processus.

Comment le domaine est transmis dans plusieurs boucles d'événements différentes :

1. Lorsqu'un domaine est instancié, nous appelons généralement sa méthode d'exécution (telle que Précédemment utilisé dans le Web services) pour exécuter une fonction dans le package de cet exemple de domaine. Lorsque la fonction encapsulée est exécutée, la variable globale

   de process.domain sera pointée vers cette instance de domaine. Lorsque dans cette boucle d'événements, lève une exception et appelle processFatal et constate que process.domain existe, l'événement d'erreur sera déclenché sur le domaine.

2. Après que require ait introduit le module de domaine, les nextTick et _tickCallback globaux seront réécrits et du code lié au domaine sera injecté :

//简化后的domain传递部分代码
function nextDomainTick(callback) {
 nextTickQueue.push({callback: callback, domain: process.domain});
}

function _tickDomainCallback() {
 var tock = nextTickQueue.pop();
 //设置process.domain = tock.domain
 tock.domain && tock.domain.enter();
 callback();
 //清除process.domain
 tock.domain && tock.domain.exit();    
 }
};

这个是其在多个事件循环中传递domain的关键：nextTick入队的时候，记录下当前的domain，当这个被加入队列中的事件循环被_tickCallback启动执行的时候，将新的事件循环的process.domain置为之前记录的domain。这样，在被domain所包裹的代码中，不管如何调用process.nextTick, domain将会一直被传递下去。

当然，node的异步还有两种情况，一种是event形式。因此在EventEmitter的构造函数有如下代码：

 if (exports.usingDomains) {
  // if there is an active domain, then attach to it.
  domain = domain || require('domain');
  if (domain.active && !(this instanceof domain.Domain)) {
   this.domain = domain.active;
  }
 }

实例化EventEmitter的时候，将会把这个对象和当前的domain绑定，当通过emit触发这个对象上的事件时，像_tickCallback执行的时候一样，回调函数将会重新被当前的domain包裹住。

而另一种情况，是setTimeout和setInterval，同样的，在timer的源码中，我们也可以发现这样的一句代码:

 if (process.domain) timer.domain = process.domain;

跟EventEmmiter一样，之后这些timer的回调函数也将被当前的domain包裹住了。

node通过在nextTick, timer, event三个关键的地方插入domain的代码，让它们得以在不同的事件循环中传递。

更复杂的domain

有些情况下，我们可能会遇到需要更加复杂的domain使用。

domain嵌套：我们可能会外层有domain的情况下，内层还有其他的domain，使用情景可以在文档中找到

// create a top-level domain for the server
var serverDomain = domain.create();
serverDomain.run(function() {
 // server is created in the scope of serverDomain
 http.createServer(function(req, res) {
  // req and res are also created in the scope of serverDomain
  // however, we'd prefer to have a separate domain for each request.
  // create it first thing, and add req and res to it.
  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);
});

为了实现这个功能，其实domain还会偷偷的自己维持一个domain的stack，有兴趣的童鞋可以在这里看到。

回头解决疑惑

回过头来，我们再来看刚才遇到的问题：为什么两个看上去都是同样的异步调用，却有一个domain无法捕获到异常？理解了原理之后不难想到，肯定是调用了redis的那个异步调用在抛出错误的这个事件循环内，是不在domain的范围之内的。我们通过一段更加简短的代码来看看，到底在哪里出的问题。

var domain = require('domain');
var EventEmitter = require('events').EventEmitter;

var e = new EventEmitter();

var timer = setTimeout(function () {
 e.emit('data'); 
}, 10);

function next() {
 e.once('data', function () {
  throw new Error('something wrong here');
 });
}

var d = domain.create();
d.on('error', function () {
 console.log('cache by domain');
});

d.run(next);

此时我们同样发现，错误不会被domain捕捉到，原因很清晰了：timer和e两个关键的对象在初始化的时候都时没有在domain的范围之内，因此，当在next函数中监听的事件被触发，执行抛出异常的回调函数时，其实根本就没有处于domain的包裹中，当然就不会被domain捕获到异常了！

其实node针对这种情况，专门设计了一个API：domain.add。它可以将domain之外的timer和event对象，添加到当前domain中去。对于上面那个例子：

d.add(timer);
//or
d.add(e);

将timer或者e任意一个对象添加到domain上，就可以让错误被domain捕获了。

再来看最开始redis导致domain无法捕捉到异常的问题。我们是不是也有办法可以解决呢？

其实对于这种情况，还是没有办法实现最佳的解决方案的。现在对于非预期的异常产生的时候，我们只能够让当前请求超时，然后让这个进程停止服务，之后重新启动。graceful模块配合cluster就可以实现这个解决方案。

domain十分强大，但不是万能的。希望在看过这篇文章之后，大家能够正确的使用domian，避免踩坑。

【相关推荐】

1. 免费js在线视频教程

2. JavaScript中文参考手册

3. php.cn独孤九贱（3）－JavaScript视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!