Node.js全栈电商开发实战：NodeJs-ShoppingMall详解

本文还有配套的精品资源，点击获取

简介：Node.js已成为构建高效电商平台的首选工具，利用JavaScript实现前后端协同开发。本项目"NodeJs-ShoppingMall"通过展示关键技术栈，如Express框架、MongoDB数据库、Mongoose库、RESTful API设计、模板引擎、用户认证、支付集成、购物车与订单系统等，向开发者教授如何从零开始创建一个全栈电商平台。

1. Node.js核心优势与特性

Node.js自诞生以来，就因其独特的核心优势和特性，在IT业界引起了广泛的兴趣和关注。作为基于Chrome V8引擎的JavaScript运行环境，Node.js允许开发者使用JavaScript在服务器端进行编程，实现全栈JavaScript开发。

1.1 Node.js的非阻塞I/O模型

Node.js的一个显著特性是其非阻塞I/O模型，这使得它能够在处理大量并发连接时表现出色。在传统的阻塞模型中，一个请求需要等待前一个请求完成后才能继续执行，而Node.js则采用事件循环（event loop）机制，允许应用程序继续处理其他任务，当I/O操作完成后，相应的回调函数会被触发。

1.2 Node.js的生态系统

Node.js的生态系统由一个庞大的模块库构成，这个库被称作npm（Node Package Manager）。npm使得开发者可以轻松安装和使用各种包，从而加速开发过程。从简单的模块到复杂的框架，npm社区的丰富资源极大地促进了Node.js的普及和应用。

1.3 Node.js的运行效率

Node.js的运行效率得益于其运行时环境和高性能的事件驱动I/O模型。V8引擎在执行JavaScript代码时表现出色，使得Node.js能够快速处理高并发的网络请求，这对于实时性要求高的应用场景来说非常关键。此外，Node.js在数据密集型的实时应用（如聊天服务器或实时分析）中表现尤为突出。

Node.js的这些优势与特性，使得它成为构建高性能服务器端应用程序的理想选择，尤其适用于I/O密集型和网络密集型的应用场景。接下来的章节，我们将深入探讨如何使用Express框架，这是Node.js最流行的Web开发框架，进一步发挥Node.js的潜力。

2. Express框架应用

2.1 Express框架入门

2.1.1 Express框架概述

Express是一个灵活的Node.js Web应用框架，提供了一系列强大的特性，用于开发单页、多页和混合Web应用。它是一个最小且灵活的Node.js Web应用开发框架，为Web和移动应用提供了大量的HTTP工具和中间件。Express的特性包括路由处理、中间件的支持、模板引擎集成以及开发Web服务器的能力，使得开发者可以专注于应用的业务逻辑，而非底层细节。

2.1.2 创建第一个Express应用

要创建一个基本的Express应用，首先需要安装Node.js和npm。一旦安装完成，可以使用npm来安装Express框架：

npm install express --save

安装完成后，创建一个名为 app.js 的文件，并写入以下代码：

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`Example app listening at ***${port}`);
});

此代码段创建了一个简单的Express服务器，监听3000端口，并对根URL的GET请求做出响应，返回文本 Hello World! 。

2.2 Express中间件机制

2.2.1 中间件的概念与作用

中间件是应用程序中的一个函数，能够访问请求对象(req)，响应对象(res)和应用程序的请求-响应周期中的下一个中间件函数。在Express中，中间件可以执行以下任务：

• 执行任何代码。
• 修改请求和响应对象。
• 结束请求-响应周期。
• 调用下一个中间件函数。

中间件函数可以接收三个参数：请求对象、响应对象以及next函数。next函数用于调用堆栈中的下一个中间件。

2.2.2 中间件的类型和应用实例

中间件函数可以是异步的，也可以是同步的，并且可以分为以下几种类型：

• 应用级中间件
• 路由器级中间件
• 错误处理中间件
• 内置中间件
• 第三方中间件

例如，一个简单的日志记录中间件可以这样实现：

app.use((req, res, next) => {
  console.log(`Request: ${req.method} ${req.url}`);
  next();
});

这个中间件会在控制台中打印出每个请求的相关信息，并调用next()函数，以继续执行后续的中间件或路由。

2.3 路由与控制器设计

2.3.1 路由的定义和处理

在Express中，路由是指如何处理客户端的请求。路由在Express应用程序中定义为：

app.METHOD(PATH, HANDLER);

其中：

• METHOD是HTTP请求方法，如GET、POST、PUT、DELETE等。
• PATH是服务器上的路径。
• HANDLER是一个函数，当路由匹配时执行。

例如：

app.get('/about', (req, res) => {
  res.send('About page');
});

此路由匹配对/about的GET请求，并将一个文本响应发送回客户端。

2.3.2 控制器的创建与组织

控制器是处理特定请求处理逻辑的JavaScript函数。它们通常组织在单独的文件或模块中，并在路由文件中引用。例如：

// controllers/about.js
module.exports = function(req, res) {
  res.send('About page');
};

// app.js
const aboutController = require('./controllers/about');
app.get('/about', aboutController);

以上示例展示了如何将关于页面的请求处理逻辑抽离到独立的控制器文件中，使得路由文件结构更清晰。

2.4 Express高级特性探究

2.4.1 动态视图渲染

动态视图渲染是Web开发中的一个关键特性，允许服务器根据不同的数据动态生成HTML页面。在Express中，可以使用模板引擎（如EJS、Pug）来渲染视图。

首先，安装并配置EJS模板引擎：

npm install ejs --save

然后在Express应用中设置视图引擎：

app.set('view engine', 'ejs');

现在，可以创建EJS模板文件并使用 res.render 方法渲染动态HTML：

app.get('/users/:id', (req, res) => {
  res.render('user', { name: 'John Doe' });
});

2.4.2 安全性和性能优化

为了提高应用的安全性和性能，Express提供了多种策略和工具：

• 使用安全中间件，如helmet，以设置HTTP头来增强应用的安全性。
• 使用body-parser中间件解析请求体数据。
• 利用缓存控制响应头，减少服务器负载。
• 使用Express的静态文件中间件提供静态文件服务。

例如，使用helmet中间件：

npm install helmet --save

const helmet = require('helmet');
app.use(helmet());

这将为应用提供多个安全增强。

3. MongoDB数据库运用

MongoDB是现代NoSQL数据库技术的代表之一，以其灵活的文档存储模型和高性能、高可用性而广泛应用于各种项目中。它的非关系型数据库特性，以及类似于JSON的BSON数据格式，让Node.js开发者能够在构建复杂的后端服务时更加得心应手。本章节将深入探讨如何在Node.js应用中集成和运用MongoDB数据库。

3.1 MongoDB基础与CRUD操作

3.1.1 MongoDB简介与安装

MongoDB是一个面向文档的数据库管理系统，由C++编写而成，旨在提供可扩展的高性能数据存储解决方案。与传统的关系型数据库如MySQL相比，MongoDB不需要固定的表结构，每个文档都是一个自包含的数据单元，使得数据的存储和访问更加灵活。

在Node.js项目中集成MongoDB的第一步通常是安装MongoDB数据库服务器。在Linux、macOS或Windows上，可以访问MongoDB官网下载安装包进行安装，或者使用包管理器如apt、brew或choco来安装。

接下来，在Node.js中，我们通常会使用 mongodb 包来连接和操作MongoDB。你可以通过npm进行安装：

npm install mongodb

3.1.2 文档的增删改查操作

一旦安装了 mongodb 包，我们就可以开始编写代码来操作MongoDB了。以下是一个简单的CRUD（创建、读取、更新、删除）操作示例，我们将创建一个名为 users 的集合，并对其中的文档进行操作。

const { MongoClient } = require('mongodb');

async function main() {
  // 连接到MongoDB
  const client = await MongoClient.connect('mongodb://localhost:27017', {
    useUnifiedTopology: true,
  });

  // 选择数据库和集合
  const db = client.db('mydatabase');
  const collection = db.collection('users');

  // 创建文档
  await collection.insertOne({ name: 'Alice', age: 25 });
  console.log('Document inserted!');

  // 读取文档
  const readResult = await collection.findOne({ name: 'Alice' });
  console.log(readResult);

  // 更新文档
  await collection.updateOne({ name: 'Alice' }, { $set: { age: 26 } });
  console.log('Document updated!');

  // 删除文档
  await collection.deleteOne({ name: 'Alice' });
  console.log('Document deleted!');

  // 关闭连接
  await client.close();
}

main().catch(console.error);

在上述代码中，我们首先创建了一个MongoClient实例来连接数据库，然后选择了 mydatabase 数据库和 users 集合。接着，我们使用 insertOne 方法插入了一个文档， findOne 方法查询了一个文档， updateOne 方法更新了一个文档，以及 deleteOne 方法删除了一个文档。这展示了MongoDB的基本CRUD操作。

3.2 MongoDB索引和聚合框架

3.2.1 索引的创建与优化

索引是数据库中用于提高查询效率的重要工具。在MongoDB中，创建索引可以显著提升数据查询的速度，尤其是在处理大量数据和复杂的查询操作时。MongoDB支持多种类型的索引，例如单字段索引、复合索引、地理空间索引等。

创建索引的语法如下：

await collection.createIndex({ fieldName: 1 });

其中 fieldName 是你希望创建索引的字段名称， 1 表示升序排列，如果你想要降序排列则使用 -1 。

例如，如果我们要为 users 集合中的 age 字段创建一个升序索引：

await collection.createIndex({ age: 1 }, { name: 'age_index' });

索引创建后，MongoDB会自动利用该索引来优化查询，但需要注意的是，索引也会占用存储空间，并且可能会减慢写入操作的速度。因此，在创建索引时，需要在查询效率和存储空间消耗之间做出平衡。

3.2.2 聚合管道的使用

MongoDB的聚合框架是一个强大的工具，它可以处理复杂的数据转换任务。聚合框架由多个阶段组成，每个阶段都可以对数据进行处理，比如过滤、排序、分组、投影等。

一个聚合管道的基本结构如下：

await collection.aggregate([
  {
    $match: { /* 条件 */ }
  },
  {
    $sort: { /* 排序规则 */ }
  },
  {
    $group: { /* 分组规则 */ }
  },
  {
    $project: { /* 投影规则 */ }
  }
]);

每个阶段的处理结果会传递给下一个阶段，最终返回处理结果。例如，假设我们需要对 users 集合中的文档按 age 字段进行分组，并计算每个年龄组的人数：

const results = await collection.aggregate([
  {
    $group: {
      _id: "$age",
      count: { $sum: 1 }
    }
  }
]).toArray();

console.log(results);

这个聚合管道将会输出类似于 [{ _id: 25, count: 3 }, { _id: 26, count: 2 }] 这样的结果，表示年龄为25的用户有3个，年龄为26的用户有2个。

3.3 MongoDB在Node.js中的集成

3.3.1 Mongoose库介绍

Mongoose是一个MongoDB对象模型工具，它是MongoDB官方推荐的Node.js的ODM（Object Data Modeling）库。使用Mongoose可以简化数据库操作，让开发者能够通过定义Schema来验证数据格式，并提供了一套丰富的API来进行数据操作。

3.3.2 使用Mongoose操作MongoDB

为了集成Mongoose，首先需要通过npm安装它：

npm install mongoose

安装完成后，我们可以定义一个Schema来描述我们的 users 集合：

const mongoose = require('mongoose');

// 连接到MongoDB
mongoose.connect('mongodb://localhost:27017/mydatabase', { useNewUrlParser: true });

// 定义用户Schema
const UserSchema = new mongoose.Schema({
  name: String,
  age: Number,
  email: String
});

// 创建用户模型
const User = mongoose.model('User', UserSchema);

// 创建用户
const newUser = new User({
  name: 'Alice',
  age: 25,
  email: '***'
});

newUser.save(err => {
  if (!err) console.log('User created!');
  else console.error(err);
});

// 查询用户
User.findOne({ name: 'Alice' }, (err, user) => {
  if (!err && user) {
    console.log(user);
  } else {
    console.error(err);
  }
});

这段代码展示了如何使用Mongoose创建和查询用户。首先我们定义了一个UserSchema，然后通过这个Schema创建了一个用户模型User。通过这个模型，我们可以调用 save 方法来创建新用户，或者使用 findOne 方法来查询特定用户。

Mongoose不仅简化了对MongoDB的操作，还提供了一系列有用的特性，例如中间件、虚拟属性、文档验证等。这些特性在构建复杂的应用时显得尤为重要，能够帮助开发者写出更加健壮和可维护的代码。

通过Mongoose的集成，Node.js应用与MongoDB数据库的交互变得更加高效和简洁。开发者可以更加专注于业务逻辑的实现，而无需过多地关注数据库操作的具体细节。

4. RESTful API设计原则

4.1 RESTful架构理念

4.1.1 RESTful设计的六原则

在Web开发中，RESTful架构是一个用来创建Web服务的架构风格和设计模式的集合。REST（Representational State Transfer）不是一种技术标准，而是一组约束条件和属性。通过遵循这些原则，RESTful API设计能够提供一致、直观且可预测的接口，从而提高系统的互操作性。

• 客户端-服务器分离 : 确保了用户界面的展示和数据存储的分离，允许服务器和客户端独立演进。
• 无状态 : 服务器不需要保存客户端的状态信息，这样可以减轻服务器的压力，提升系统的可扩展性和简化服务器设计。
• 可缓存 : 通过让资源响应包含是否可缓存的信息，可以减少延迟，提升性能。
• 统一接口 : 使用标准化的接口和方法，确保了所有资源都通过相同的接口被访问。
• 按需进行分层 : 允许在架构中添加中间层来实现安全、负载均衡、缓存等策略。
• 按需代码 : 允许服务器提供可执行代码，如JavaScript应用，使客户端功能进一步增强。

4.1.2 资源的状态转换与表述

RESTful API通过HTTP方法定义对资源的操作，包括获取（GET）、创建（POST）、更新（PUT/PATCH）、删除（DELETE）。每个方法对应资源的CRUD操作。

资源表述是通过数据格式如JSON或XML来传递，通常使用GET请求来获取资源的状态表述。这不仅适用于数据的读取，也适用于数据的创建和修改，只是其中的数据表述不同罢了。

例如，一个获取用户信息的GET请求返回的是用户对象的JSON表述，而一个创建用户的POST请求则可能包含一个JSON格式的用户对象作为请求体。

4.2 RESTful API的设计实践

4.2.1 设计用户友好的API

设计RESTful API时，首要原则是API应该易于理解和使用。这就要求开发者遵循一致性原则，确保所有的资源都采用相同的命名约定和结构，这在设计之初需要制定一套命名规范。

另外，每个资源的URL应该直观地反映出其代表的资源类型，并且URL结构应当简洁明了。比如， /users/{id} 和 /orders/{id} 就直观地指出了资源的类型。

错误处理也是API设计中不可忽视的一部分。通过HTTP状态码清晰地表达错误信息，例如404表示资源未找到，400表示请求无效。

4.2.2 使用Express创建RESTful接口

在Node.js中使用Express框架可以非常方便地创建RESTful API。下面是一个简单的Express服务器的代码示例，它提供了RESTful接口来操作用户资源：

const express = require('express');
const app = express();
const port = 3000;

// 用于解析请求体中的JSON格式数据
app.use(express.json());

// 获取所有用户列表
app.get('/users', (req, res) => {
    // 这里应该从数据库中查询用户数据，并返回JSON格式的用户列表
    res.json([{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]);
});

// 创建新用户
app.post('/users', (req, res) => {
    const newUser = req.body; // 从请求体中获取新用户数据
    // 这里应该将新用户数据保存到数据库，并返回创建成功的响应
    res.status(201).json(newUser);
});

// 获取单个用户信息
app.get('/users/:id', (req, res) => {
    const userId = req.params.id; // 获取URL参数中的用户ID
    // 这里应该根据用户ID查询数据库，并返回该用户信息
    res.json({ id: userId, name: 'Alice' });
});

// 更新用户信息
app.put('/users/:id', (req, res) => {
    const userId = req.params.id; // 获取URL参数中的用户ID
    const updatedUser = req.body; // 从请求体中获取更新后的用户信息
    // 这里应该更新数据库中的用户信息，并返回更新结果
    res.json(updatedUser);
});

// 删除用户
app.delete('/users/:id', (req, res) => {
    const userId = req.params.id; // 获取URL参数中的用户ID
    // 这里应该从数据库中删除对应用户，并返回响应结果
    res.json({ message: 'User deleted' });
});

app.listen(port, () => {
    console.log(`Server running at ***${port}`);
});

4.3 RESTful API的版本管理

4.3.1 版本控制的策略与实践

随着API的不断发展，为了向后兼容，API版本管理成为RESTful API设计的重要组成部分。API版本可以是URL的一部分，也可以是请求头中的一个字段。

• URL版本化 : 最常见的方式是在API的URL中加入版本号，如 /api/v1/users 。这样可以直接指向特定版本的API，且易于在新旧版本间切换。
• 媒体类型版本化 : 在HTTP请求头中使用 Accept 字段指定版本，如 Accept: application/vnd.example.v1+json 。这种方法能够使URL保持干净，但需要在服务器端正确处理不同的媒体类型。

4.3.2 应对API变更的兼容性处理

在处理API变更时，需要考虑向后兼容性。这意味着新版本的API应该允许旧版本的客户端正常工作。以下是一些处理API变更的策略：

• 增量变更 : 只在必要时添加新的端点，而不是修改现有端点的行为。
• 弃用通知 : 对于需要弃用的旧端点，提前通知客户端，并提供新端点的使用示例。
• 灵活的查询参数 : 使用查询参数来实现额外的过滤或排序功能，而不是更改已有端点的响应。
• 清晰的文档 : 提供清晰的API文档，并及时更新文档以反映API的最新状态。

通过合理设计和维护API版本，可以确保API的长期稳定性，同时保持向用户的服务能力。

5. 模板引擎的使用

5.1 模板引擎的概念与作用

5.1.1 模板引擎的角色

模板引擎在Web开发中扮演着至关重要的角色。它作为服务器端与客户端之间沟通的桥梁，可以将后端的数据按照预定的格式动态地嵌入到HTML页面中。通过模板引擎，开发者能够将业务逻辑与页面展示分离，使得代码更加清晰、易于维护，同时保持前后端开发的协同效率。

5.1.2 模板引擎的选择标准

选择模板引擎时，开发者通常会考虑如下几个标准：

• 易用性 ：语法是否简单直观，上手是否容易。
• 性能 ：处理模板的效率，包括编译速度和渲染速度。
• 功能 ：支持的功能和扩展性，如自定义过滤器、局部模板等。
• 社区与文档 ：社区活跃度和文档的完善程度。
• 安全性 ：防范XSS攻击等安全问题的能力。

5.2 EJS模板引擎实战

5.2.1 EJS模板基础

EJS（Embedded JavaScript Templates）是一种广泛使用的模板引擎，它允许开发者在HTML模板中嵌入JavaScript代码。EJS的语法简洁，易于上手，并且与Express框架有着良好的集成性。

示例代码展示：

<!DOCTYPE html>
<html>
<head>
    <title><%= title %></title>
</head>
<body>
    <h1><%= title %></h1>
    <p>Welcome to <%= title %>, <%= user %>!</p>
</body>
</html>

在这个EJS模板例子中， <%= %> 用于输出变量的内容。当这个模板被渲染时， title 和 user 变量将被替换为相应的值。

5.2.2 EJS与Express的集成

在Express中集成EJS非常简单，只需执行几个步骤：

1. 安装EJS模板引擎： npm install ejs
2. 在Express应用中设置模板引擎为EJS：

const express = require('express');
const app = express();

app.set('view engine', 'ejs');

1. 设置模板文件所在的目录：

app.set('views', './views');

1. 启动Express服务器，并使用 res.render 方法渲染EJS模板：

app.get('/', (req, res) => {
    res.render('index', { title: 'Hello World', user: 'Users' });
});

5.3 模板引擎的高级用法

5.3.1 动态内容与布局管理

动态内容是指在模板中根据传入的数据动态改变的部分。EJS允许我们通过条件语句和循环来处理动态内容：

<% if (products.length > 0) { %>
    <% products.forEach(function(product) { %>
        <li><%= product.name %> - <%= product.price %></li>
    <% }); %>
<% } else { %>
    <p>No products found.</p>
<% } %>

布局管理是指在不同的页面间共享布局结构。EJS提供了包含文件的方式来实现布局管理：

<%- include('header.ejs') %>
<!-- 页面内容 -->
<%- include('footer.ejs') %>

5.3.2 模板继承与局部模板

模板继承允许我们创建一个基础模板，并让其他模板继承这个基础模板，这样可以避免重复编写相同的代码。EJS使用 block 标签来实现继承：

<!-- 基础模板 base.ejs -->
<!DOCTYPE html>
<html>
<head>
    <title><%= title %></title>
    <% block 'styles' %>
    <% end %>
</head>
<body>
    <%- body %>
    <% block 'scripts' %>
    <% end %>
</body>
</html>

局部模板是指模板中可复用的部分，可以单独保存在另一个文件中，并在需要的地方引入使用：

<%- include('partial/signup_form.ejs') %>

通过这些高级用法，模板引擎可以帮助开发者构建出更加模块化、可维护的Web应用。

6. 用户认证与授权实现

随着Web应用的发展，用户认证与授权变得越来越重要。无论是在社交网络、博客、电子商务还是企业应用中，合理的认证与授权机制不仅可以提升用户体验，还能保障系统的安全性和可管理性。本章节将深入探讨用户认证与授权的概念、技术实现以及相关的最佳实践。

6.1 用户认证基础

6.1.1 认证与授权的区别

在深入技术之前，我们必须明确区分认证和授权这两个概念。认证（Authentication）是验证用户身份的过程，比如登录时输入用户名和密码。而授权（Authorization）则是确认用户在经过认证之后，对系统的访问权限，即用户能否执行某个操作或访问某个资源。

6.1.2 常见的认证机制

常见的认证机制包括基本认证（Basic Auth）、表单认证（Form-based Auth）、摘要认证（Digest Auth）、令牌认证（Token-based Auth）、OAuth认证等。每种机制有其适用的场景，如基本认证简单易用，适用于内部或受信任的环境；而令牌认证则更适合于开放、分布式的系统。

6.2 使用Passport进行用户认证

6.2.1 Passport概述与安装

Passport是一个用于Node.js的简单、灵活且模块化的用户认证中间件，支持多种认证策略。安装Passport非常简单，使用npm安装命令：

npm install passport --save
npm install passport-local --save # 如果你打算使用用户名和密码进行认证

6.2.2 实现本地认证与社交登录

接下来，我们将通过一个例子演示如何使用Passport实现本地登录认证和社交登录（例如使用Google账户登录）。

首先，初始化Passport本地认证策略：

const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;

passport.use(new LocalStrategy(
  function(username, password, done) {
    // 在这里连接你的数据库，验证用户名和密码
    User.findOne({ username: username }, function (err, user) {
      if (err) { return done(err); }
      if (!user) {
        return done(null, false, { message: '用户名不存在' });
      }
      if (!user.validPassword(password)) {
        return done(null, false, { message: '密码错误' });
      }
      return done(null, user);
    });
  }
));

对于社交登录，我们可以利用Passport提供的策略来实现，例如Google登录策略：

const GoogleStrategy = require('passport-google-oauth20').Strategy;

passport.use(new GoogleStrategy({
    clientID: process.env.GOOGLE_CLIENT_ID,
    clientSecret: process.env.GOOGLE_CLIENT_SECRET,
    callbackURL: "/auth/google/callback"
  },
  function(accessToken, refreshToken, profile, cb) {
    // 在这里处理登录成功后的逻辑
  }
));

6.3 用户授权与权限控制

6.3.1 授权策略的配置与应用

在用户通过认证后，我们通常需要根据用户的权限来限制对其数据或功能的访问。在Express应用中，这通常通过中间件来实现，如下所示：

function ensureAuthenticated(req, res, next) {
  if (req.isAuthenticated()) {
    return next();
  }
  res.redirect('/login');
}

function ensureAdmin(req, res, next) {
  if (req.user && req.user.isAdmin) {
    return next();
  }
  res.status(403).send('无权访问');
}

app.get('/admin', ensureAuthenticated, ensureAdmin, function(req, res) {
  // 只有认证过的管理员才能访问此路由
});

6.3.2 基于角色的访问控制（RBAC）

在复杂的应用中，基于角色的访问控制（RBAC）模型可以帮助我们更高效地管理权限。在RBAC模型中，权限是与角色关联的，而用户则是被分配到不同的角色。通过定义和应用角色和权限的映射，可以简化权限控制的复杂度。

function authorize(role) {
  return function(req, res, next) {
    const userRole = req.user.role; // 假设用户信息中包含role属性
    if (userRole === role) {
      return next();
    }
    res.status(403).send('无权访问');
  }
}

app.get('/user/profile', ensureAuthenticated, authorize('user'), function(req, res) {
  // 普通用户可以访问此路由
});

app.get('/admin/profile', ensureAuthenticated, authorize('admin'), function(req, res) {
  // 管理员可以访问此路由
});

在本章中，我们首先讲解了用户认证与授权的基本概念和区别，随后介绍了如何使用Passport中间件实现用户认证，包括本地认证和社交登录。最后，我们探讨了授权策略的配置和应用，以及RBAC模型在实际开发中的应用。

在下一章中，我们将继续深入探讨集成第三方支付服务，如支付宝和微信支付，如何为Web应用添加支付功能。

本文还有配套的精品资源，点击获取

简介：Node.js已成为构建高效电商平台的首选工具，利用JavaScript实现前后端协同开发。本项目"NodeJs-ShoppingMall"通过展示关键技术栈，如Express框架、MongoDB数据库、Mongoose库、RESTful API设计、模板引擎、用户认证、支付集成、购物车与订单系统等，向开发者教授如何从零开始创建一个全栈电商平台。

本文还有配套的精品资源，点击获取