使用Node.js同步数据库查询

Question

我有一个Node.js /
Express应用程序，该应用程序查询路由内的MySQL数据库，并将结果显示给用户。我的问题是如何在将用户重定向到他们请求的页面之前运行查询并阻止直到两个查询都完成？

在我的示例中，我有2个查询需要在呈现页面之前完成。如果将查询2嵌套在查询1的“结果”回调中，则可以使查询同步运行。但是，当查询数量增加时，这将变得非常复杂。

如何在不将后续查询嵌套在先前查询的“结果”回调中的情况下同步运行多个（在本例中为2个）数据库查询？

我已经查看了Node模块中的“流控制/异步好东西”，并尝试了flow-js，但我无法使其与异步查询一起使用。

下面列出的是我尝试从“ / home”路由执行的2个查询。Node专家可以解释这样做的“正确”方法吗？

app.get('/home', function (req,res) {
    var user_array = [];
    var title_array = [];

    // first query
    var sql = 'select user_name from users';
    db.execute(sql)
        .addListener('row', function(r) {
            user_array.push( { user_name: r.user_name } );
        })
        .addListener('result', function(r) {
            req.session.user_array = user_array;
        });

    // second query
    var sql = 'select title from code_samples';
    db.execute(sql)
        .addListener('row', function(r) {
            title_array.push( { title: r.title } );
        })
        .addListener('result', function(r) {
            req.session.title_array = title_array;
        });

        // because the queries are async no data is returned to the user
        res.render('home.ejs', {layout: false, locals: { user_name: user_array, title: title_array }});
});

Answer 1

节点的目的不是在乎事情发生的顺序。这会使某些情况变得复杂。嵌套回调没有可耻之处。一旦习惯了它的外观，您可能会发现自己实际上更喜欢这种样式。我做;
很清楚将触发什么顺序的回调。如果需要的话，可以放弃匿名函数以使其不再那么冗长。

如果您愿意稍微重构代码，则可以使用“典型”嵌套回调方法。如果您想避免回调，可以使用许多异步框架来尝试并帮助您做到这一点。您可能要检查的一种是async.js（https://github.com/fjakobs/async.js）。每个示例：

app.get('/home', function (req,res) {
    var lock = 2;
    var result = {};
    result.user_array = [];
    result.title_array = [];

    var finishRequest = function(result) {
        req.session.title_array = result.title_array;
        req.session.user_array = result.user_array;
        res.render('home.ejs', {layout: false, locals: { user_name: result.user_array, title: result.title_array }});
    };

    // first query
    var q1 = function(fn) {
      var sql = 'select user_name from users';
      db.execute(sql)
          .addListener('row', function(r) {
              result.user_array.push( { user_name: r.user_name } );
          })
          .addListener('result', function(r) {
              return fn && fn(null, result);
        });
    };

    // second query
    var q2 = function(fn) {
      var sql = 'select title from code_samples';
      db.execute(sql)
          .addListener('row', function(r) {
              result.title_array.push( { title: r.title } );
          })
          .addListener('result', function(r) {
              return fn && fn(null, result);
          });
    }

    //Standard nested callbacks
    q1(function (err, result) {
      if (err) { return; //do something}

      q2(function (err, result) {
        if (err) { return; //do something}

        finishRequest(result);
      });
    });

    //Using async.js
    async.list([
        q1,
        q2,
    ]).call().end(function(err, result) {
      finishRequest(result);
    });

});

一次性，我可能只使用引用计数类型方法。只需跟踪要执行的查询数量，并在查询全部完成后呈现响应即可。

app.get('/home', function (req,res) {
    var lock = 2;
    var user_array = [];
    var title_array = [];

    var finishRequest = function() {
        res.render('home.ejs', {layout: false, locals: { user_name: user_array, title: title_array }});
    }

    // first query
    var sql = 'select user_name from users';
    db.execute(sql)
        .addListener('row', function(r) {
            user_array.push( { user_name: r.user_name } );
        })
        .addListener('result', function(r) {
            req.session.user_array = user_array;
            lock -= 1;

            if (lock === 0) {
              finishRequest();
            }
        });

    // second query
    var sql = 'select title from code_samples';
    db.execute(sql)
        .addListener('row', function(r) {
            title_array.push( { title: r.title } );
        })
        .addListener('result', function(r) {
            req.session.title_array = title_array;
            lock -= 1;

            if (lock === 0) {
              finishRequest();
            }
        });
});

更好的方法是在呈现响应之前，在每个“结果”回调中简单地调用finishRequest（）以检查非空数组。在您的情况下是否可行取决于您的要求。