Question

我正在使用带有connect-redis的nodej来存储会话数据。

我在会话中保存用户数据，并在会话生命周期中使用它。

我注意到在两个更改会话数据的请求之间可能存在竞争条件。

我尝试使用redis-lock锁定会话，但这对我来说有点问题。

我不想锁定整个会话，而只是锁定特定的会话变量。

我觉得这是不可能的，我想到了解决问题的方向：

停止使用会话对象存储用户数据，并在使用之前将变量直接保存在redis中并锁定。

我知道它可以工作，但它需要我手动管理所有对象，而不是只通过会话对象访问redis。

您能否与我分享最佳做法和建议？

谢谢，利奥尔

Answer 1

好吧，实现自己的存储可能是您的选择。 This documentation表明您需要做的就是实现三种方法：.get，.set和.destroy（请参阅最后一段）。它会是这样的（使用node-redis library并稍微修改the original connect-redis store）：

var redis = require("redis"),
    redis_client = redis.createClient(),
    session_prefix = 'session::',
    lock_suffix = '::lock',
    threshold = 5000,
    wait_time = 250,
    oneDay = 86400;

/* If timeout is greater then threshold, then we assume that
   one of the Redis Clients is dead and he cannot realese
   the lock. */

function CustomSessionStore(opts) {
    opts = opts || {};
    var self = this;
    self.ttl = opts.ttl; // <---- used for setting timeout on session

    self.lock = function(sid, callback) {
        callback = callback || function(){};
        var key = session_prefix + sid + lock_suffix;
        // try setting the lock with current Date
        redis_client.setnx(key, Date.now( ), function(err, res) {
            // some error handling?
            if (res) {
                // Everything's fine, call callback.
                callback();
                return;
            }

            // setnx failed, look at timeout
            redis_client.get(key, function(err, res) {
                // some error handling?
                if (parseInt(res) + threshold > Date.now( )) {
                    // timeout, release the old lock and lock it
                    redis_client.getset(key, Date.now( ), function(err, date) {
                        if (parseInt(date) + threshold > Date.now()) {
                            // ups, some one else was faster in acquiring lock
                            setTimeout(function() {
                                self.lock(sid, callback);
                            }, wait_time);
                            return;
                        }
                        callback();
                    });
                    return;
                }
                // it is not time yet, wait and try again later
                setTimeout(function() {
                    self.lock(sid, callback);
                }, wait_time);
            });
        });
    };

    self.unlock = function(sid, callback) {
        callback = callback || function(){};
        var key = session_prefix + sid + lock_suffix;
        redis_client.del(key, function(err) {
            // some error handling?
            callback();
        });
    };

    self.get = function(sid, callback) {
        callback = callback || function(){};
        var key = session_prefix + sid;
        // lock the session
        self.lock(sid, function() {
            redis_client.get(key, function(err, data) {
                if (err) {
                    callback(err);
                    return;
                }
                try {
                    callback(null, JSON.parse(data));
                } catch(e) {
                    callback(e);
                }
            });
        });
    };

    self.set = function(sid, data, callback) {
        callback = callback || function(){};
        try {
            // ttl used for expiration of session
            var maxAge = sess.cookie.maxAge
              , ttl = self.ttl
              , sess = JSON.stringify(sess);

            ttl = ttl || ('number' == typeof maxAge
                  ? maxAge / 1000 | 0
                  : oneDay);

        } catch(e) {
            callback(e);
            return;
        }
        var key = session_prefix + sid;
        redis_client.setex(key, ttl, data, function(err) {
            // unlock the session
            self.unlock(sid, function(_err) {
                callback(err || _err);
            });
        });
    };

    self.destroy = function(sid, callback) {
        var key = session_prefix + sid;
        redis_client.del(key, function(err) {
            redis_client.unlock(sid, function(_err) {
                callback(err || _err);
            });
        });
    };
}

旁注：我没有对.lock和.unlock实施错误处理。我要把它留给你了！ :)可能会有一些小错误（我目前没有NodeJS，而且我正在记忆中写这个：D），但你应该理解这个想法。这里是the link，其中包含有关如何使用setnx锁定/解锁Redis的讨论。

另一个注释：您可能希望对路由进行一些自定义错误处理，因为如果任何路由抛出异常，则Redis会话将不会被解锁。 .set方法始终被称为路由中的最后一个方法 - 与.get方法相反，Express方式在路径开始时调用（这就是为什么我锁定.get并解锁{ {1}}）。你仍然会被锁定5秒钟，所以它不一定是个问题。请记住根据您的需求进行调整（尤其是.set和threshold变量）。

最后的注意事项：使用此机制，您的请求处理程序将只为每个用户一个接一个地触发。这意味着，您将无法为每个用户运行并发处理程序。这可能是一个问题，因此另一个想法是将数据保存在会话之外并手动处理锁定/解锁。毕竟，有一些事情需要手动处理。

我希望它有所帮助！祝你好运！

connect-redis - 如何保护会话对象免受竞争条件的影响

1 个答案: