使用Node.js和Redis构建在线投票应用：如何处理高并发-猿码集

1. 简介

随着互联网的迅速发展，越来越多的网站需要应对高并发的情况，以保证用户的体验和服务质量。本文将介绍如何使用Node.js和Redis构建一个在线投票应用，并探讨如何处理高并发。

2. Node.js和Redis介绍

2.1 Node.js

Node.js是一个基于Chrome V8引擎的JavaScript运行环境。Node.js使用事件驱动、非阻塞I/O等技术来实现高效的服务器端应用程序，特别适用于I/O密集型应用程序。

console.log("Hello, World!");

Node.js具有以下优点：

高效性：事件驱动、非阻塞I/O、单线程模型；

可扩展性：模块化设计、NPM生态系统；

跨平台性：支持多种操作系统。

2.2 Redis

Redis是一个开源的高性能键值存储系统，支持多种数据结构，包括字符串、哈希、列表、集合和有序集合。

// 存储字符串 SET key value // 存储哈希 HSET key field value // 存储列表 LPUSH key value // 存储集合 SADD key value // 存储有序集合

ZADD key score value

Redis具有以下优点：

高效性：内存存储、单线程模型、非阻塞I/O；

可扩展性：主从复制、哨兵模式、集群模式；

功能丰富：支持多种数据结构和操作。

3. 在线投票应用

3.1 架构设计

如图所示，我们将使用Node.js作为应用程序的运行环境，Redis作为数据存储和共享的工具。


  +------------+         +------------+
  |            |         |            |
  |   Client   |         |   Node.js  |
  |            |         |            |
  +------------+         +------------+
         |                       |
         |       +--------+      |
         +------>| Redis  |<-----+
                 +--------+

3.2 功能模块

应用程序包含以下功能模块：

投票列表：显示所有的投票主题；

投票详情：显示投票主题的详细信息和选项；

投票操作：为投票主题的选项投票。

3.3 数据结构设计

我们使用Redis的哈希、列表和有序集合来存储投票应用的数据。

// 投票主题哈希 HSET poll:id title "Favorite color" HSET poll:id options 3 HSET poll:id:options 1 "Red" HSET poll:id:options 2 "Green" HSET poll:id:options 3 "Blue" // 投票结果有序集合 ZADD poll:id:results 0 "1" ZADD poll:id:results 0 "2"

ZADD poll:id:results 0 "3"

3.4 实现代码

下面是投票应用程序的部分实现代码，使用了Node.js和Redis模块。

const http = require('http');
const redis = require('redis');
// 创建Redis客户端
const client = redis.createClient();
// 处理获取投票列表请求
function handlePollList(req, res) {
  // 从Redis中获取所有投票主题
  client.keys('poll:*', (err, keys) => {
    if (err) return console.error(err);
    // 获取每个投票主题的信息
    client.mget(keys, (err, polls) => {
      if (err) return console.error(err);
      // 构造投票列表页面
      res.writeHead(200, {'Content-Type': 'text/html'});
      res.write('Poll List');
      res.write('');
      polls.forEach((poll, i) => {
        const id = keys[i].split(':')[1];
        const title = poll.split(':')[1];
        res.write(`${title}`);
      });
      res.write('');
      res.write('');
      res.end();
    });
  });
}
// 处理获取投票详情请求
function handlePollDetail(req, res, id) {
  // 从Redis中获取投票主题的信息和选项
  client.hgetall(`poll:${id}`, (err, poll) => {
    if (err) return console.error(err);
    // 构造投票详情页面
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write('Poll Detail');
    res.write(`${poll.title}`);
    res.write('
');
    for (let i = 1; i <= poll.options; i++) {
      res.write(`${poll[`options:${i}`]}`);
    }
    res.write('');
    res.write('
');
    res.write('');
    res.end();
  });
}
// 处理投票请求
function handlePollVote(req, res, id) {
  // 从请求中获取投票选项
  let option = '';
  req.on('data', chunk => { option += chunk; });
  req.on('end', () => {
    // 尝试为该选项投票
    client.zincrby(`poll:${id}:results`, 1, option, (err, result) => {
      if (err) return console.error(err);
      // 投票成功，重定向到结果页面
      res.writeHead(302, {'Location': `/poll/${id}/results`});
      res.end();
    });
  });
}
// 处理获取投票结果请求
function handlePollResults(req, res, id) {
  // 从Redis中获取投票结果
  client.zrevrange(`poll:${id}:results`, 0, -1, 'WITHSCORES', (err, results) => {
    if (err) return console.error(err);
    // 构造投票结果页面
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write('Poll Results');
    res.write(`Results for ${id}`);
    res.write('');
    for (let i = 0; i < results.length; i += 2) {
      const option = results[i];
      const count = results[i+1];
      res.write(`${option}: ${count}`);
    }
    res.write('');
    res.write('');
    res.end();
  });
}
// 创建HTTP服务器
const server = http.createServer((req, res) => {
  // 处理获取投票列表请求
  if (req.url === '/') {
    handlePollList(req, res);
  }
  // 处理获取投票详情请求
  else if (req.url.match(/^\/poll\/(\d+)$/)) {
    const id = req.url.split('/')[2];
    handlePollDetail(req, res, id);
  }
  // 处理投票请求
  else if (req.url.match(/^\/poll\/(\d+)\/vote$/)) {
    const id = req.url.split('/')[2];
    handlePollVote(req, res, id);
  }
  // 处理获取投票结果请求
  else if (req.url.match(/^\/poll\/(\d+)\/results$/)) {
    const id = req.url.split('/')[2];
    handlePollResults(req, res, id);
  }
  // 处理未知请求
  else {
    res.writeHead(404, {'Content-Type': 'text/html'});
    res.write('Not FoundNot Found');
    res.end();
  }
});
// 监听端口
server.listen(3000);
console.log('Server started on port 3000.');

4. 处理高并发

应对高并发的方法有很多，下面介绍一些常用的方法：

缓存：将常用的数据缓存在内存中或Redis中，减少对数据库的访问。

负载均衡：使用负载均衡器将请求分发到多台服务器上，分摊单台服务器的负担。

异步处理：使用异步I/O和事件驱动模型，提高请求的响应速度和处理能力。

集群化部署：使用多台服务器组成集群，提高系统的可用性和容错性。

优化数据库：使用索引、分区、缓存等技术，提高数据库的访问效率。

4.1 缓存热点数据

将热点数据缓存在Redis中，可以减少对数据库的访问，提高读写性能。

// 读取投票详情
function getPollDetail(id, callback) {
  // 尝试从Redis中读取投票详情
  client.hgetall(`poll:${id}`, (err, poll) => {
    if (err || !poll) {
      // 从数据库中读取投票详情
      db.get(`SELECT * FROM polls WHERE id=${id}`, (err, row) => {
        if (err) return callback(err);
        // 将投票详情缓存到Redis中
        client.hmset(`poll:${id}`, row, err => {
          if (err) return callback(err);
          // 设置过期时间，避免缓存数据过旧
          client.expire(`poll:${id}`, 30);
          callback(null, row);
        });
      });
    } else {
      // 从Redis中读取到了投票详情
      callback(null, poll);
    }
  });
}

4.2 使用负载均衡器

使用负载均衡器可以将请求分发到多台服务器上，分摊单台服务器的负担，并提高系统的可用性和容错性。

const http = require('http');
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
// 创建HTTP服务器
function createServer() {
  const server = http.createServer((req, res) => {
    // 处理请求
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');
  });
  // 监听端口
  server.listen(3000);
  console.log(`Server ${process.pid} started on port 3000.`);
}
if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
  // 创建多个子进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  // 监听子进程退出事件，重新创建子进程
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork();
  });
} else {
  console.log(`Worker ${process.pid} started`);
  createServer();
}

4.3 使用异步处理

使用异步I/O和事件驱动模型，能够提高请求的响应速度和处理能力。

const http = require('http');
// 创建HTTP服务器
const server = http.createServer((req, res) => {
  // 处理请求
  setTimeout(() => {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');
  }, 5000);
});
// 监听端口
server.listen(3000);
console.log('Server started on port 3000.');

4.4 集群化部署

使用多台服务器组成集群，可以提高系统的可用性和容错性。

const http = require('http');
const redis = require('redis');
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
// 创建Redis客户端
const client = redis.createClient();
// 处理获取投票列表请求
function handlePollList(req, res) {
  // 从Redis中获取所有投票主题
  client.keys('poll:*', (err, keys) => {
    if (err) return console.error(err);
    // 获取每个投票主题的信息
    client.mget(keys, (err, polls) => {
      if (err) return console.error(err);
      // 构造投票列表页面
      res.writeHead(200, {'Content-Type': 'text/html'});
      res.write('Poll List');
      res.write('');
      polls.forEach((poll, i) => {
        const id = keys[i].split(':')[1];
        const title = poll.split(':')[1];
        res.write(`${title}`);
      });
      res.write('');
      res.write('');
      res.end();
    });
  });
}
if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
  // 创建多个子进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  // 监听子进程退出事件，重新创建子进程
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork();
  });
} else {
  console.log(`Worker ${process.pid} started`);
  // 创建HTTP服务器
  const server = http.createServer((req, res) => {
    // 处理获取投票列表请求
    if (req.url === '/') {
      handlePollList(req, res);
    }
    // 处理未知请求
    else {
      res.writeHead(404, {'Content-Type': 'text/html'});
      res.write('Not FoundNot Found');
      res.end();
    }
  });
  // 监听端口
  server.listen(3000);
  console.log(`Server ${process.pid} started on port 3000.`);
}

4.5 优化数据库

使用索引、分区、缓存等技术可以提高数据库的访问效率。

CREATE TABLE polls (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  title TEXT NOT NULL,
  options INTEGER NOT NULL
);
-- 使用缓存提高投票结果的访问效率
CREATE TABLE poll_results (
  poll_id INTEGER NOT NULL,
  option INTEGER NOT NULL,
  count INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (poll_id, option)
);
-- 使用索引提高投票结果的查询效率
CREATE INDEX idx_poll_results_poll_id ON poll_results (poll_id);
-- 使用分区提高大量数据的读写效率
CREATE TABLE polls (id INTEGER, title TEXT, options INTEGER)
PARTITION BY RANGE (id) (
  PARTITION p0 VALUES LESS THAN (100),
  PARTITION p1 VALUES LESS THAN (200),
  PARTITION p2 VALUES LESS

使用Node.js和Redis构建在线投票应用：如何处理高并发