警告: 不要忽视错误!

当发生错误时，域（domain）的错误处理程序不是用于代替停歇你的进程。

根据 JavaScript 中 throw 的工作机制，几乎从来没有任何方式可以安全地“从你离开的地方重新拾起（pick up where you left off）”，无泄漏的引用，或创造一些其他种类的不确定脆弱状态。

对抛出的错误响应最安全的方式就是关闭进程。当然，在正常的 Web 服务器中，你可能有许多的连接打开着，因为错误是由别人引起的，就突然关闭进程，这是不合理的。

更好的方法是发送一个错误响应以触发错误的请求，而让其他人在正常的时间内完成，并停止监听该工作进程的新请求。

通过这种方式，domain 的用法是与集群模块携手，因为在工作进程遇到一个错误时，主进程可以产生一个新的工作进程。对于扩展到多台机器的 Node.js 程序而言，在终止代理或服务注册可以记录失败，并作出相应的响应。

例如，这不是一个好主意：

  1. // XXX WARNING!  BAD IDEA!
  3. var d = require('domain').create();
  4. d.on('error', (er) => {
  5.     // The error won't crash the process, but what it does is worse!
  6.     // Though we've prevented abrupt process restarting, we are leaking
  7.     // resources like crazy if this ever happens.
  8.     // This is no better than process.on('uncaughtException')!
  9.     console.log('error, but oh well', er.message);
  10. });
  11. d.run(() => {
  12.     require('http').createServer((req, res) => {
  13.         handleRequest(req, res);
  14.     }).listen(PORT);
  15. });

通过使用域（domain）的上下文和弹性分离我们的程序到多个工作进程中，我们可以做到更合理地响应，并且更安全地处理错误。

  1. // Much better!
  3. const cluster = require('cluster');
  4. const PORT = +process.env.PORT || 1337;
  6. if (cluster.isMaster) {
  7.     // In real life, you'd probably use more than just 2 workers,
  8.     // and perhaps not put the master and worker in the same file.
  9.     //
  10.     // You can also of course get a bit fancier about logging, and
  11.     // implement whatever custom logic you need to prevent DoS
  12.     // attacks and other bad behavior.
  13.     //
  14.     // See the options in the cluster documentation.
  15.     //
  16.     // The important thing is that the master does very little,
  17.     // increasing our resilience to unexpected errors.
  19.     cluster.fork();
  20.     cluster.fork();
  22.     cluster.on('disconnect', (worker) => {
  23.         console.error('disconnect!');
  24.         cluster.fork();
  25.     });
  27. } else {
  28.     // the worker
  29.     //
  30.     // This is where we put our bugs!
  32.     const domain = require('domain');
  34.     // See the cluster documentation for more details about using
  35.     // worker processes to serve requests.  How it works, caveats, etc.
  37.     const server = require('http').createServer((req, res) => {
  38.         var d = domain.create();
  39.         d.on('error', (er) => {
  40.             console.error('error', er.stack);
  42.             // Note: we're in dangerous territory!
  43.             // By definition, something unexpected occurred,
  44.             // which we probably didn't want.
  45.             // Anything can happen now!  Be very careful!
  47.             try {
  48.                 // make sure we close down within 30 seconds
  49.                 var killtimer = setTimeout(() => {
  50.                     process.exit(1);
  51.                 }, 30000);
  52.                 // But don't keep the process open just for that!
  53.                 killtimer.unref();
  55.                 // stop taking new requests.
  56.                 server.close();
  58.                 // Let the master know we're dead.  This will trigger a
  59.                 // 'disconnect' in the cluster master, and then it will fork
  60.                 // a new worker.
  61.                 cluster.worker.disconnect();
  63.                 // try to send an error to the request that triggered the problem
  64.                 res.statusCode = 500;
  65.                 res.setHeader('content-type', 'text/plain');
  66.                 res.end('Oops, there was a problem!\n');
  67.             } catch (er2) {
  68.                 // oh well, not much we can do at this point.
  69.                 console.error('Error sending 500!', er2.stack);
  70.             }
  71.         });
  73.         // Because req and res were created before this domain existed,
  74.         // we need to explicitly add them.
  75.         // See the explanation of implicit vs explicit binding below.
  76.         d.add(req);
  77.         d.add(res);
  79.         // Now run the handler function in the domain.
  80.         d.run(() => {
  81.             handleRequest(req, res);
  82.         });
  83.     });
  84.     server.listen(PORT);
  85. }
  87. // This part isn't important.  Just an example routing thing.
  88. // You'd put your fancy application logic here.
  89. function handleRequest(req, res) {
  90.     switch (req.url) {
  91.     case '/error':
  92.         // We do some async stuff, and then...
  93.         setTimeout(() => {
  94.             // Whoops!
  95.             flerb.bark();
  96.         });
  97.         break;
  98.     default:
  99.         res.end('ok');
  100.     }
  101. }