我应该如何在节点 js 中使用对 db + http 调用的承诺

Question

我需要实现的系统

• 从父集合中获取数据。
• 检查是否在 redis 中找到特定键
• 如果没有，则执行 http 调用并获取 json 数据，然后设置缓存
• 如果是，则从缓存中获取数据
• 将数据保存到父 ID 的子集合中。

我有使用类似回调的工作解决方案。

MongoClient.connect(dsn).then(function(db) {
    parentcollection.findOne({"_id" : new ObjectId(pid)}, function(err, data) {

    var redis = require("redis"),
    client = redis.createClient();

    client.on("error", function (err) {
        console.log("Error " + err);
    });

    // If not set

    client.get(cacheKey, function(err, data) {
        // data is null if the key doesn't exist
        if(err || data === null) {
            var options = {
                host: HOST,
                port: 80,
                path: URI
            };

            var req = http.get(options, function(res) {
                res.setEncoding('utf8');
                res.on('data', function (chunk) {
                    body += chunk;
                    //console.log('CHUNK: ' + chunk);
                });
                res.on('end', function () {
                    data = JSON.parse(body);


                    // Get childdata After process of data

                    childcollection.save(childdata, {w:1}, function(cerr, inserted) {
                        db.close();

                    });
                });
            }); 
        } else {
            // Get childdata from cache data
            childcollection.save(childdata, {w:1}, function(cerr, inserted) {
                db.close();
            });
        }
    });
});

我想使用 promise（原生的，而不是像 bluebird / request 这样的外部的）而不是回调。我检查手册并考虑是否需要这样实施

var promise1 = new Promise((resolve, reject) => {

    MongoClient.connect(dsn).then(function(db) {
        parentcollection.findOne({"_id" : new ObjectId(pid)}, function(err, data) {


    });

}}.then(function(data){
   var promise2 = new Promise((resolve, reject) => {
     var redis = require("redis"),
        client = redis.createClient();

        client.on("error", function (err) {
            console.log("Error " + err);
        });

        // If not set

        client.get(cacheKey, function(err, data) {
            // data is null if the key doesn't exist
            if(err || data === null) {
                var options = {
                    host: HOST,
                    port: 80,
                    path: URI
                };

                var promise3 = new Promise((resolve, reject) => {
                        var req = http.get(options, function(res) {
                            res.setEncoding('utf8');
                            res.on('data', function (chunk) {
                                body += chunk;
                                //console.log('CHUNK: ' + chunk);
                            });
                            res.on('end', function () {
                                data = JSON.parse(body);


                            // Get childdata After process of data


                        });
                    })
                }).then(function(data){
                    childcollection.save(childdata, {w:1}, function(cerr, inserted) {
                                db.close();

                            });
                });
            } else {
                // Get childdata from cache data
                childcollection.save(childdata, {w:1}, function(cerr, inserted) {
                    db.close();
                });
            }
        });

}}.then(function(data){
});
});              

哪个看起来像回调地狱一样肮脏，或者没有使用上述承诺的任何更好的方法？

Answer 1

一个问题是您永远不会调用提供给 promise 构造函数回调的 resolve 函数。如果不调用它们，promise 永远不会解决。

我建议在单独的、可重用的函数中创建这些新的 Promise。另一方面，当你不提供回调参数时，一些 MongoDb 方法已经返回了 Promise。

你可以像下面那样做。

// Two promisifying functions:
function promiseClientData(client, key) {
    return new Promise(function (resolve, reject) {
        return client.get(key, function (err, data) {
            return err ? reject(err) : resolve(data); // fulfull the promise
        });
    });
}

function promiseHttpData(options) {
    return new Promise(function (resolve, reject) {
        return http.get(options, function(res) {
            var body = ''; // You need to initialise this...
            res.setEncoding('utf8');
            res.on('data', function (chunk) {
                body += chunk;
                //console.log('CHUNK: ' + chunk);
            });
            res.on('end', function () {
                data = JSON.parse(body);
                resolve(data);  // fulfull the promise
            });
        );
    });
}

// Declare the db variable outside of the promise chain to avoid 
// having to pass it through
var db;

// The actual promise chain:
MongoClient.connect(dsn).then(function (dbArg) {
    db = dbArg;
    return parentcollection.findOne({"_id" : new ObjectId(pid)}); // returns a promise
}).then(function (data) {
    var redis = require("redis"),
    client = redis.createClient();
    client.on("error", function (err) {
        console.log("Error " + err);
    });
    // Get somehow cacheKey...
    // ...
    return promiseClientData(client, cacheKey);
}).then(function (data) {
    // If not set: data is null if the key doesn't exist
    // Throwing an error will trigger the next `catch` callback
    if(data === null) throw "key does not exist"; 
    return data;
}).catch(function (err) {
    var options = {
        host: HOST,
        port: 80,
        path: URI
    };
    return promiseHttpData(options);
}).then(function (data) {
    // Get childdata by processing data (in either case)
    // ....
    // ....
    return childcollection.save(childdata, {w:1}); // returns a promise
}).then(function () {
    db.close();
});

我假设 MongoDb 返回的承诺是完全合规的。如有疑问，您可以通过在它们上调用 Promise.resolve() 将它们转换为原生 JavaScript 承诺，例如：

return Promise.resolve(parentcollection.findOne({"_id" : new ObjectId(pid)}));

或：

return Promise.resolve(childcollection.save(childdata, {w:1}));