Node.js 异步回调工厂

Question

我正在使用 Node.js、Express 和 MySql 开发一个RESTful API。未使用 ORM。

我想重用尽可能多的代码来处理资源请求。

我将实现一个回调工厂，我想听听您对我的方法的看法。

api.js

它是主应用程序文件。

'use strict';

var
  http = require('http'),
  express = require('express'),
  app = express(),

  env = app.get('env'),
  config = require('./config')[env],
  pool = require('./pool')(config.database), /* node-mysql pool */

  people = require('./routes/people')(pool); /* route handlers for people resource */

app.use(express.json());
app.use(express.urlencoded());
app.use(app.router);

app.get('/people', people.findAll); /* middleware handling request for the resource */

http.createServer(app).listen(8000);

路线/people.js

它是包含处理 /people 资源请求的代码的文件。

'use strict';

module.exports = {
  var
    async = require('async'),
    CallbackFactory = require('../CallbackFactory'),
    people = {};

  people.findAll = function (req, res, next) {
    async.waterfall(
      [
        CallbackFactory.createCallback('getPoolConnection', pool),
        CallbackFactory.createCallback('lastQuery', 'SELECT * FROM person'),
        CallbackFactory.createCallback('json', res)
      ],
      CallbackFactory.getCallback('next', next);
    );
  };

  return people;
};

CallbackFactory.js

该模块仅导出 createCallback 方法。

createCallback 的第一个参数始终是回调名称。
其他参数特定于要创建的回调。

'use strict';

var
  factoryMethods: {
    getPoolConnection: function (pool) {
      return function (callback) {
        pool.getConnection(function (err, connection) {
          callback(err, connection);
        };
      };
    },
    lastQuery: function (sql, values) {
      return function (connection, callback) {
        connection.query(sql, values, function (err, result) {
          connection.release();
          callback(err, result);
        });
      };
    },
    json: function (res) {
      return function (result, callback) {
        res.json(result);
        callback();
      };
    },
    next: function (next) {
      return function (err) {
        if (err) {
          return next(err);
        }
      };
    },
  };

module.exports = {
  createCallback: function () {
    var
      args = Array.prototype.slice.call(arguments),
      name = args.shift();

    return factoryMethods[name].apply(null, args);
  }
};

结论

我在谷歌上进行了搜索，以便找到对代码重用有用的方法。
我什么也没找到。也许这不是正确/最好的方法。 你对此有何看法？

Answer 1

我认为你走错了路。回调工厂不是一种常见的模式，因为它添加了一个抽象层，但没有以任何方式降低复杂性。换句话说，将 async.waterfall 视为已经提供了您正在寻找的抽象层。或者，如果您喜欢命名函数，我推荐 async.auto ，它还会根据您指定的依赖关系自动确定哪些函数可以串行和并行操作。

我建议让 async.waterfall 或 async.auto 直接调用您的函数。如果您想要额外的抽象和更少的代码，请使用像 Sequelize 这样的 ORM。但我发现你的工厂让后来的其他人理解你的代码变得复杂。