设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

NodeJS+Redis实现分布式Session方案

2016-12-20 13:17| 发布者: zhangjf| 查看: 455| 评论: 0

摘要: Session是什么？ Session 是面向连接的状态信息，是对 Http 无状态协议的补充。 Session 怎么工作？ Session 数据保留在服务端，而为了标识具体 Session 信息指向哪个连接，需要客户端传递向服务端发送一个连接标识 ...
Session是什么？

Session 是面向连接的状态信息，是对 Http 无状态协议的补充。

Session 怎么工作？

Session 数据保留在服务端，而为了标识具体 Session 信息指向哪个连接，需要客户端传递向服务端发送一个连接标识，比如存在Cookies 中的session_id值（也可以通过URL的QueryString传递），服务端根据这个id 存取状态信息。

在服务端存储 Session，可以有很多种方案：

内存存储 数据库存储 分布式缓存存储 分布式Session

随着网站规模（访问量/复杂度/数据量）的扩容，针对单机的方案将成为性能的瓶颈，分布式应用在所难免。所以，有必要研究一下 Session 的分布式存储。

如前述， Session使用的标识其实是客户端传递的 session_id，在分布式方案中，一般会针对这个值进行哈希，以确定其在 hashing ring 的存储位置。

Session_id

在 Session 处理的事务中，最重要的环节莫过于 客户端与服务端 关于 session 标识的传递过程：

服务端查询客户端Cookies 中是否存在 session_id 有session_id，是否过期？过期了需要重新生成；没有过期则延长过期 没有 session_id，生成一个，并写入客户端的 Set-Cookie 的 Header，这样下一次客户端发起请求时，就会在 Request Header 的 Cookies带着这个session_id

比如我用 Express， 那么我希望这个过程是自动完成的，不需要每次都去写 Response Header，那么我需要这么一个函数（摘自朴灵的《深入浅出Node.js》）：

  1. var setHeader = function (req, res, next) {
  2. var writeHead = res.writeHead;
  3. res.writeHead = function () {
  4. var cookies = res.getHeader('Set-Cookie');
  5. cookies = cookies || [];
  6. console.log('writeHead, cookies: ' + cookies);
  7. var session = serialize('session_id', req.session.id);
  8. cookies = Array.isArray(cookies) ? cookies.concat(session) :
  9. [cookies, session];
  10. res.setHeader('Set-Cookie', cookies);
  11. return writeHead.apply(this, arguments);
  12. };
  14. next();
  15. };
复制代码

这个函数替换了writeHead，在每次Response写Header时它都会得到执行机会，所以它是自动化的。这个req.session.id 是怎么得到的，稍候会有详细的代码示例。

Hashing Ring

hashing ring 就是一个分布式结点的回路（取值范围：0到232 -1，在零点重合）：Session 应用场景中，它根据 session_id 的哈希值，按顺时针方向就近安排一个大于其值的结点进行存储。

Hashing Ring

实现这个回路的算法多种多样，比如 一致性哈希。

我的哈希环实现（ hashringUtils.js：

  1. var INT_MAX = 0x7FFFFFFF;
  3. var node = function (nodeOpts) {
  4. nodeOpts = nodeOpts || {};
  5. if (nodeOpts.address) this.address = nodeOpts.address;
  6. if (nodeOpts.port) this.port = nodeOpts.port;
  7. };
  8. node.prototype.toString = function () {
  9. return this.address + ':' + this.port;
  10. };
  12. var ring = function (maxNodes, realNodes) {
  13. this.nodes = [];
  14. this.maxNodes = maxNodes;
  15. this.realNodes = realNodes;
  17. this.generate();
  18. };
  19. ring.compareNode = function (nodeA, nodeB) {
  20. return nodeA.address === nodeB.address &&
  21. nodeA.port === nodeB.port;
  22. };
  23. ring.hashCode = function (str) {
  24. if (typeof str !== 'string')
  25. str = str.toString();
  26. var hash = 1315423911, i, ch;
  27. for (i = str.length - 1; i >= 0; i--) {
  28. ch = str.charCodeAt(i);
  29. hash ^= ((hash << 5) + ch + (hash >> 2));
  30. }
  31. return (hash & INT_MAX);
  32. };
  33. ring.prototype.generate = function () {
  34. var realLength = this.realNodes.length;
  35. this.nodes.splice(0); //clear all
  37. for (var i = 0; i < this.maxNodes; i++) {
  38. var realIndex = Math.floor(i / this.maxNodes * realLength);
  39. var realNode = this.realNodes[realIndex];
  40. var label = realNode.address + '#' +
  41. (i - realIndex * Math.floor(this.maxNodes / realLength));
  42. var virtualNode = ring.hashCode(label);
  44. this.nodes.push({
  45. 'hash': virtualNode,
  46. 'label': label,
  47. 'node': realNode
  48. });
  49. }
  51. this.nodes.sort(function(a, b){
  52. return a.hash - b.hash;
  53. });
  54. };
  55. ring.prototype.select = function (key) {
  56. if (typeof key === 'string')
  57. key = ring.hashCode(key);
  58. for(var i = 0, len = this.nodes.length; i<len; i++){
  59. var virtualNode = this.nodes[i];
  60. if(key <= virtualNode.hash) {
  61. console.log(virtualNode.label);
  62. return virtualNode.node;
  63. }
  64. }
  65. console.log(this.nodes[0].label);
  66. return this.nodes[0].node;
  67. };
  68. ring.prototype.add = function (node) {
  69. this.realNodes.push(node);
  71. this.generate();
  72. };
  73. ring.prototype.remove = function (node) {
  74. var realLength = this.realNodes.length;
  75. var idx = 0;
  76. for (var i = realLength; i--;) {
  77. var realNode = this.realNodes[i];
  78. if (ring.compareNode(realNode, node)) {
  79. this.realNodes.splice(i, 1);
  80. idx = i;
  81. break;
  82. }
  83. }
  84. this.generate();
  85. };
  86. ring.prototype.toString = function () {
  87. return JSON.stringify(this.nodes);
  88. };
  90. module.exports.node = node;
  91. module.exports.ring = ring;
复制代码
配置

配置信息是需要根据环境而变化的，某些情况下它又是不能公开的（比如Session_id 加密用的私钥），所以需要一个类似的配置文件（ config.cfg：

  1. {
  2. "session_key": "session_id",
  3. "SECRET": "myapp_moyerock",
  4. "nodes":
  5. [
  6. {"address": "127.0.0.1", "port": "6379"}
  7. ]
  8. }
复制代码

在Node 中序列化/反序列化JSON 是件令人愉悦的事，写个配置读取器也相当容易（configUtils.js：

  1. var fs = require('fs');
  2. var path = require('path');
  4. var cfgFileName = 'config.cfg';
  5. var cache = {};
  7. module.exports.getConfigs = function () {
  8. if (!cache[cfgFileName]) {
  9. if (!process.env.cloudDriveConfig) {
  10. process.env.cloudDriveConfig = path.join(process.cwd(), cfgFileName);
  11. }
  12. if (fs.existsSync(process.env.cloudDriveConfig)) {
  13. var contents = fs.readFileSync(
  14. process.env.cloudDriveConfig, {encoding: 'utf-8'});
  15. cache[cfgFileName] = JSON.parse(contents);
  16. }
  17. }
  18. return cache[cfgFileName];
  19. };
复制代码
分布式Redis 操作

有了上述的基础设施，实现一个分布式 Redis 分配器就变得相当容易了。为演示，这里只简单提供几个操作 Hashes 的方法（redisMatrix.js：

  1. var hashringUtils = require('../hashringUtils'),
  2. ring = hashringUtils.ring,
  3. node = hashringUtils.node;
  5. var config = require('../configUtils');
  7. var nodes = config.getConfigs().nodes;
  8. for (var i = 0, len = nodes.length; i < len; i++) {
  9. var n = nodes[i];
  10. nodes[i] = new node({address: n.address, port: n.port});
  11. }
  13. var hashingRing = new ring(32, nodes);
  15. module.exports = hashingRing;
  16. module.exports.openClient = function (id) {
  17. var node = hashingRing.select(id);
  18. var client = require('redis').createClient(node.port, node.address);
  19. client.on('error', function (err) {
  20. console.log('error: ' + err);
  21. });
  22. return client;
  23. };
  24. module.exports.hgetRedis = function (id, key, callback) {
  25. var client = hashingRing.openClient(id);
  26. client.hget(id, key, function (err, reply) {
  27. if (err)
  28. console.log('hget error:' + err);
  29. client.quit();
  30. callback.call(null, err, reply);
  31. });
  32. };
  33. module.exports.hsetRedis = function (id, key, val, callback) {
  34. var client = hashingRing.openClient(id);
  35. client.hset(id, key, val, function (err, reply) {
  36. if (err)
  37. console.log('hset ' + key + 'error: ' + err);
  38. console.log('hset [' + key + ']:[' + val + '] reply is:' + reply);
  39. client.quit();
  41. callback.call(null, err, reply);
  42. });
  43. };
  44. module.exports.hdelRedis = function(id, key, callback){
  45. var client = hashingRing.openClient(id);
  46. client.hdel(id, key, function (err, reply) {
  47. if (err)
  48. console.log('hdel error:' + err);
  49. client.quit();
  50. callback.call(null, err, reply);
  51. });
  52. };
复制代码
分布式Session操作

session_id 的事务和 分布式的Redis都有了，分布式的 Session 操作呼之欲出（sessionUtils.js：

  1. var crypto = require('crypto');
  2. var config = require('../config/configUtils');
  4. var EXPIRES = 20 * 60 * 1000;
  5. var redisMatrix = require('./redisMatrix');
  7. var sign = function (val, secret) {
  8. return val + '.' + crypto
  9. .createHmac('sha1', secret)
  10. .update(val)
  11. .digest('base64')
  12. .replace(/[/+=]/g, '');
  13. };
  14. var generate = function () {
  15. var session = {};
  16. session.id = (new Date()).getTime() + Math.random().toString();
  17. session.id = sign(session.id, config.getConfigs().SECRET);
  18. session.expire = (new Date()).getTime() + EXPIRES;
  19. return session;
  20. };
  21. var serialize = function (name, val, opt) {
  22. var pairs = [name + '=' + encodeURIComponent(val)];
  23. opt = opt || {};
  25. if (opt.maxAge) pairs.push('Max-Age=' + opt.maxAge);
  26. if (opt.domain) pairs.push('Domain=' + opt.domain);
  27. if (opt.path) pairs.push('Path=' + opt.path);
  28. if (opt.expires) pairs.push('Expires=' + opt.expires);
  29. if (opt.httpOnly) pairs.push('HttpOnly');
  30. if (opt.secure) pairs.push('Secure');
  32. return pairs.join('; ');
  33. };
  35. var setHeader = function (req, res, next) {
  36. var writeHead = res.writeHead;
  37. res.writeHead = function () {
  38. var cookies = res.getHeader('Set-Cookie');
  39. cookies = cookies || [];
  40. console.log('writeHead, cookies: ' + cookies);
  41. var session = serialize(config.getConfigs().session_key, req.session.id);
  42. console.log('writeHead, session: ' + session);
  43. cookies = Array.isArray(cookies) ? cookies.concat(session) : [cookies, session];
  44. res.setHeader('Set-Cookie', cookies);
  45. return writeHead.apply(this, arguments);
  46. };
  48. next();
  49. };
  51. exports = module.exports = function session() {
  52. return function session(req, res, next) {
  53. var id = req.cookies[config.getConfigs().session_key];
  54. if (!id) {
  55. req.session = generate();
  56. id = req.session.id;
  57. var json = JSON.stringify(req.session);
  58. redisMatrix.hsetRedis(id, 'session', json,
  59. function () {
  60. setHeader(req, res, next);
  61. });
  62. } else {
  63. console.log('session_id found: ' + id);
  64. redisMatrix.hgetRedis(id, 'session', function (err, reply) {
  65. var needChange = true;
  66. console.log('reply: ' + reply);
  67. if (reply) {
  68. var session = JSON.parse(reply);
  69. if (session.expire > (new Date()).getTime()) {
  70. session.expire = (new Date()).getTime() + EXPIRES;
  71. req.session = session;
  72. needChange = false;
  73. var json = JSON.stringify(req.session);
  74. redisMatrix.hsetRedis(id, 'session', json,
  75. function () {
  76. setHeader(req, res, next);
  77. });
  78. }
  79. }
  81. if (needChange) {
  82. req.session = generate();
  83. id = req.session.id; // id need change
  84. var json = JSON.stringify(req.session);
  85. redisMatrix.hsetRedis(id, 'session', json,
  86. function (err, reply) {
  87. setHeader(req, res, next);
  88. });
  89. }
  90. });
  91. }
  92. };
  93. };
  95. module.exports.set = function (req, name, val) {
  96. var id = req.cookies[config.getConfigs().session_key];
  97. if (id) {
  98. redisMatrix.hsetRedis(id, name, val, function (err, reply) {
  100. });
  101. }
  102. };
  103. /*
  104. get session by name
  105. @req request object
  106. @name session name
  107. @callback your callback
  108. */
  109. module.exports.get = function (req, name, callback) {
  110. var id = req.cookies[config.getConfigs().session_key];
  111. if (id) {
  112. redisMatrix.hgetRedis(id, name, function (err, reply) {
  113. callback(err, reply);
  114. });
  115. } else {
  116. callback();
  117. }
  118. };
  120. module.exports.getById = function (id, name, callback) {
  121. if (id) {
  122. redisMatrix.hgetRedis(id, name, function (err, reply) {
  123. callback(err, reply);
  124. });
  125. } else {
  126. callback();
  127. }
  128. };
  129. module.exports.deleteById = function (id, name, callback) {
  130. if (id) {
  131. redisMatrix.hdelRedis(id, name, function (err, reply) {
  132. callback(err, reply);
  133. });
  134. } else {
  135. callback();
  136. }
  137. };
复制代码
结合 Express 应用

在 Express 中只需要简单的 use 就可以了（ app.js：

  1. var session = require('../sessionUtils');
  2. app.use(session());
复制代码

这个被引用的 session 模块暴露了一些操作 session 的方法，在需要时可以这样使用：

  1. app.get('/user', function(req, res){
  2. var id = req.query.sid;
  3. session.getById(id, 'user', function(err, reply){
  4. if(reply){
  5. //Some thing TODO
  6. }
  7. });
  8. res.end('');
  9. });
复制代码
小结

虽然本文提供的是基于 Express 的示例，但基于哈希算法和缓存设施的分布式思路，其实是放之四海而皆准的

来源：Ye Mo

收藏 邀请
上一篇：node.js之mysql包使用说明下一篇：Node.js中间件规范你发送HTTP响应状态的方式：http-responses

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-12 13:45

Copyright 2015-2025 djqfx

返回顶部