将功能注入其他Node.js模块

Inject functionality into other Node.js module

本文关键字：js 模块 Node 其他 功能 注入      更新时间：2023-09-26

我有一个Node.js应用程序（使用sequelize作为orm），我试图将其分离成不同的模块，这些模块可以很容易地重用。这意味着我需要删除它们之间的一些依赖关系，但我有一点很困难：

有一个名为"Account"的模块，它应该（几乎）对其他模块没有依赖性。它只提供基本的帐户功能。

还有其他模块，它们依赖于帐户模块（这是可以的）。

目前，Account模块依赖于其他模块，我想解决这个问题。现在，当创建帐户时，其他模块也必须在数据库中创建一些对象。这应该发生在同一笔交易中，并且账户模块不了解其他模块。

目前，情况如下：

AccountController.prototype.createAccount = function (data) {
   // validation checks etc. omited
   return db.sequelize.transaction(function (t) {
      return Q.Promise(function (resolve, reject, notify) {
         _createHash(pw, 10)
            .then(function (hash) {
               data.passwordHash = hash;
               return _createAccount(data, t);
            })
            .then(function (account) {
               // create user
               return [account, _createUser(account, t)];
            })
            .spread(function (account, user) {
               // create another object
               return [account, user, _createXXX(account, t)]
            })
            .spread(function(account, user, xxx) {
                // create 1 more object
               return [account, user, xxx, _createYYY(account, t)];
            })
            .spread(function (account, user, xxx, yyy) {
               resolve([account, user, xxx, yyy]);
            })
            .catch(reject);
      });
   });
};

现在，我只想在这个模块中创建Account对象，并让其他模块独立地创建它们的对象，但在同一事务中。

首先，我考虑让AccountController在promise链中发出一个"createAccount"事件，移交事务对象并让模块注册一些侦听器。但后来我注意到EventEmitter是异步工作的。

Node.js中做这样的事情的最佳实践是什么？

好的，让我自己回答这个问题：

  • 尽管我读到了一些不同的东西，但我意识到EventEmitter不是异步的
  • 因此，将事件用于此任务基本上有效
  • 但我遇到了一个问题，由于数据库调用，我的事件侦听器在异步位置。因此，我需要一种方法来等待所有事件侦听器"真正"完成
  • 我在EventEmitter的一个子类中引入了promisedEmit（）函数，它允许侦听器返回一个promise并返回一个promise本身，只有当所有侦听器promise都完成时，它才会完成

这是我想出的代码：

'use strict';
var EventEmitter = require('events');
var util = require('util');
var Q = require('q');
function PromisedEventEmitter() {
}
util.inherits(PromisedEventEmitter, EventEmitter);
PromisedEventEmitter.prototype.promisedEmit = function promisedEmit(type) {
   var er, handler, len, args, i, listeners;
   var promises = [];
   if (!this._events)
      this._events = {};
   // If there is no 'error' event listener then throw.
   if (type === 'error' && !this._events.error) {
      er = arguments[1];
      if (this.domain) {
         if (!er)
            er = new Error('Uncaught, unspecified "error" event.');
         er.domainEmitter = this;
         er.domain = this.domain;
         er.domainThrown = false;
         this.domain.emit('error', er);
      } else if (er instanceof Error) {
         throw er; // Unhandled 'error' event
      } else {
         throw Error('Uncaught, unspecified "error" event.');
      }
      return Q.all(promises);
   }
   handler = this._events[type];
   if (util.isUndefined(handler))
      return Q.all(promises);
   if (this.domain && this !== process)
      this.domain.enter();
   var promise;
   if (util.isFunction(handler)) {
      switch (arguments.length) {
         // fast cases
         case 1:
            promise = handler.call(this);
            break;
         case 2:
            promise = handler.call(this, arguments[1]);
            break;
         case 3:
            promise = handler.call(this, arguments[1], arguments[2]);
            break;
         // slower
         default:
            len = arguments.length;
            args = new Array(len - 1);
            for (i = 1; i < len; i++)
               args[i - 1] = arguments[i];
            promise = handler.apply(this, args);
      }
      promises.push(promise);
   } else if (util.isObject(handler)) {
      len = arguments.length;
      args = new Array(len - 1);
      for (i = 1; i < len; i++)
         args[i - 1] = arguments[i];
      listeners = handler.slice();
      len = listeners.length;
      for (i = 0; i < len; i++) {
         promise = listeners[i].apply(this, args);
         promises.push(promise);
      }
   }
   if (this.domain && this !== process)
      this.domain.exit();
   return Q.all(promises);
};

module.exports = PromisedEventEmitter;

这基本上只是原始的.emit代码，我只添加了一些promise处理。我现在可以像原始的EventEmitter一样使用它，只需调用

XXXController
    .promisedEmit("eventName", arg1, arg2, argN)]
    .then(function(){
        //...
    });
相关文章：