Express 中间件

最新推荐文章于 2024-08-07 09:38:08 发布

小小段

最新推荐文章于 2024-08-07 09:38:08 发布

阅读量624

点赞数 1

分类专栏： Express 前后端交互

本文链接：https://blog.csdn.net/weixin_43563864/article/details/109303673

版权

前后端交互同时被 2 个专栏收录

16 篇文章 2 订阅

订阅专栏

Express

4 篇文章 0 订阅

订阅专栏

1. Express 中间件

1.1 中间件的概念

1. 什么是中间件

中间件（Middleware ），特指业务流程的中间处理环节。

2. 现实生活中的例子

在处理污水的时候，一般都要经过三个处理环节，从而保证处理过后的废水，达到排放标准。

在这里插入图片描述

处理污水的这三个中间处理环节，就可以叫做中间件。

3. Express 中间件的调用流程

当一个请求到达 Express 的服务器之后，可以连续调用多个中间件，从而对这次请求进行预处理。

在这里插入图片描述

4. Express 中间件的格式

Express 的中间件，本质上就是一个 function 处理函数，Express 中间件的格式如下：

在这里插入图片描述

注意：中间件函数的形参列表中，必须包含 next 参数。而路由处理函数中只包含 req 和 res。

5. next 函数的作用

next 函数是实现多个中间件连续调用的关键，它表示把流转关系转交给下一个中间件或路由。

在这里插入图片描述

1.2 Express 中间件的初体验

1. 定义中间件函数

可以通过如下的方式，定义一个最简单的中间件函数：

// 定义一个最简单的中间件函数
const xx = function(req, res, next) {
    console.log('这是最简单的中间件函数');
    // 把流转关系，转交给下一个中间件或路由
    next();
};

2. 全局生效的中间件

客户端发起的任何请求，到达服务器之后，都会触发的中间件，叫做全局生效的中间件。

通过调用 app.use(中间件函数)，即可定义一个全局生效的中间件，示例代码如下：

// 定义一个最简单的中间件函数
const xx = function(req, res, next) {
    console.log('这是最简单的中间件函数');
    // 把流转关系，转交给下一个中间件或路由
    next();
};

// 注册全局生效的中间件
app.use(xx);

3. 定义全局中间件的简化形式

// 中间件简化形式
app.use((req, res, next) => {
    console.log('这是最简单的中间件函数');
    // 把流转关系，转交给下一个中间件或路由
    next();
})

4. 中间件的作用

多个中间件之间，共享同一份 req 和 res。基于这样的特性，我们可以在上游的中间件中，统一为 req 或 res 对象添加自定义的属性或方法，供下游的中间件或路由进行使用。

在这里插入图片描述

const express = require('express');

const app = express();


// 中间件简化形式
app.use((req, res, next) => {
    const time = Date.now();
    req.nowTime = time;
    // 把流转关系，转交给下一个中间件或路由
    next();
});

app.get('/', (req, res) => {
    res.send('Home page' + req.nowTime);
});

app.get('/user', (req, res) => {
    res.send('User page' + req.nowTime);
});

app.listen(80, () => {
    console.log('express server running at http://127.0.0.1');
});

5. 定义多个全局中间件

可以使用 app.use() 连续定义多个全局中间件。客户端请求到达服务器之后，会按照中间件定义的先后顺序依次进行调用，示例代码如下：

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

// 定义第一个中间件
app.use((req, res, next) => {
    console.log('这是第一个中间件');
    next();
});

// 定义第二个中间件
app.use((req, res, next) => {
    console.log('这是第二个中间件');
    next();
});

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

app.listen(80, () => {
    console.log('server running at http://127.0.0.1');
});

6. 局部生效的中间件

不使用 app.use() 定义的中间件，叫做局部生效的中间件，示例代码如下：

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

const xx = function(req, res, next) {
    console.log('局部中间件');
    next();
};

app.get('/', xx, (req, res) => {
    res.send('badyoungman');
});

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

app.listen(80, () => {
    console.log('server running at http://127.0.0.1');
});

7. 定义多个局部中间件

可以在路由中，通过如下两种等价的方式，使用多个局部中间件：

app.get('/',xx1,xx2,(req,res)=>{
	res.send('Home page');
});
app.get('/',[xx1,xx2],(req,res)=>{
	res.send('Home page');
});

8. 了解中间件的5个使用注意事项

①一定要在路由之前注册中间件

②客户端发送过来的请求，可以连续调用多个中间件进行处理

③执行完中间件的业务代码之后，不要忘记调用 next() 函数

④为了防止代码逻辑混乱，调用 next() 函数后不要再写额外的代码

⑤连续调用多个中间件时，多个中间件之间，共享 req 和 res 对象

1.3 中间件的分类

为了方便大家理解和记忆中间件的使用，Express 官方把常见的中间件用法，分成了 5 大类，分别是：

① 应用级别的中间件

② 路由级别的中间件

③ 错误级别的中间件

④ Express 内置的中间件

⑤ 第三方的中间件

1. 应用级别的中间件

通过 app.use() 或 app.get() 或 app.post() ，绑定到 app 实例上的中间件，叫做应用级别的中间件，代码示例如下：

// 应用级别的中间件（全局中间件）
app.use((req,res,next)=>{
	next();
});

// 应用级别的中间件（局部中间件）
app.get('/',xx1,(req,res)=>{
	res.send('Home Page.');
});

2. 路由级别的中间件

绑定到 express.Router() 实例上的中间件，叫做路由级别的中间件。它的用法和应用级别中间件没有任何区别。只不过，应用级别中间件是绑定到 app 实例上，路由级别中间件绑定到 router 实例上，代码示例如下：

var app = express();
var router = express.Router();

// 路由级别的中间件
router.use(function(req,res,next){
	console.log('Time:',Date.now());
	next();
});

app.use('/',router);

3. 错误级别的中间件

错误级别中间件的作用：专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。

格式：错误级别中间件的 function 处理函数中，必须有 4 个形参，形参顺序从前到后，分别是 (err, req, res, next)。

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

app.get('/', (req, res) => {
    throw new Error('服务器内部发生错误！');
    res.send('Home page.');
});

app.use((err, req, res, next) => {
    console.log('发生了错误：' + err.message);
    res.send('Erroe:' + err.message);
});

app.listen(80, () => {
    console.log('错误中间件启动成功!');
})

**注意：**错误级别的中间件，必须注册在所有路由之后！

4. Express内置的中间件

自 Express 4.16.0 版本开始，Express 内置了 3 个常用的中间件，极大的提高了 Express 项目的开发效率和体验：

① express.static 快速托管静态资源的内置中间件，例如： HTML 文件、图片、CSS 样式等（无兼容性）

② express.json 解析 JSON 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）

③ express.urlencoded 解析 URL-encoded 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）

// 配置解析 application/json 格式数据的中间件
app.use(express.json());
// 配置解析 application/x-www-form-urlencoded 格式数据的内置中间件
app.use(express.urlencoded({extended:false}));

案例：

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

// 注意：除了错误级别的中间件，其他中间件必须在路由之前进行配置
// 通过 express.json() 这个中间件，解析表单中的 JSON 格式的数据
app.use(express.json());

// 通过 express.urlencoded() 这个中间件，来解析表单中的 url-encoded 格式的数据
app.use(express.urlencoded({ extended: false }));

app.post('/user', (req, res) => {
    // 在服务器，可以使用 req.body 这个属性，来接收客户端发送过来的请求数据
    // 默认情况下，如果不配置解析表单的中间件，则 req.body 默认值为 undefined
    console.log(req.body);
    res.send('Hello World!')
});

app.post('/book', (req, res) => {
    // 在服务端，可以通过 req.body 来获取 JSON 格式的表单数据和 url-encoded 格式的数据
    console.log(req.body);
    res.send('ojbk');
})

app.listen(80, () => {
    console.log(`Example app listening on port port!`);
});

5. 第三方的中间件

非 Express 官方内置的，而是由第三方开发出来的中间件，叫做第三方中间件。在项目中，大家可以按需下载并配置第三方中间件，从而提高项目的开发效率。

例如：在 express@4.16.0 之前的版本中，经常使用 body-parser 这个第三方中间件，来解析请求体数据。使用步骤如下：

①运行 npm install body-parser 安装中间件

②使用 require 导入中间件

③调用 app.use() 注册并使用中间件

const express = require('express')
const app = express();
// 1.导入解析表单数据的中间件 body-parser
const parser = require('body-parser');

// 2.使用app.user()注册中间件
app.use(parser.urlencoded({ extended: false }));

app.post('/user', (req, res) => {
    console.log(req.body);
    res.send('嗨~第三方插件！');
});

app.listen(80, () => console.log(`Example app listening on port port!`));

注意:Express 内置的 express.urlencoded 中间件，就是基于 body-parser 这个第三方中间件进一步封装出来的。

1.4 自定义中间件(原理)

1. 需求描述与实现步骤

自己手动模拟一个类似于 express.urlencoded 这样的中间件，来解析 POST 提交到服务器的表单数据。

实现步骤：

①定义中间件

②监听 req 的 data 事件

③监听 req 的 end 事件

④使用 querystring 模块解析请求体数据

⑤将解析出来的数据对象挂载为 req.body

⑥将自定义中间件封装为模块

2. 定义中间件

使用 app.use() 来定义全局生效的中间件，代码如下：

app.use((req,res,next)=>{
	// 中间件业务逻辑
})

3. 监听 req 的 data 事件

在中间件中，需要监听 req 对象的 data 事件，来获取客户端发送到服务器的数据。

如果数据量比较大，无法一次性发送完毕，则客户端会把数据切割后，分批发送到服务器。所以 data 事件可能会触发多次，每一次触发 data 事件时，获取到数据只是完整数据的一部分，需要手动对接收到的数据进行拼接。

// 1.定义一个 str 字符串，用来专门储存客户端送过来的请求体数据
let str = '';
// 2.监听 req 的 data 事件
req.on('data', (chunk) => {
    str += chunk;
});

4. 监听 req 的 end 事件

当请求体数据接收完毕之后，会自动触发 req 的 end 事件。

因此，我们可以在 req 的 end 事件中，拿到并处理完整的请求体数据。示例代码如下：

// 3.监听 req 的 end 事件
req.on('end', () => {
    // 在 str 中存放的是完整的请求体数据
    // TODO:把字符串格式的请求体数据，解析成对象格式
    const body = qs.parse(str);
    console.log(body);
});

5. 使用 querystring 模块解析请求体数据

Node.js 内置了一个 querystring 模块，专门用来处理查询字符串。通过这个模块提供的 parse() 函数，可以轻松把查询字符串，解析成对象的格式。示例代码如下：

// 导入处理 querystring 的 Node.js 内置模块
const qs = require('querystring');

// 调用 qs.parse() 方法，把查询字符串解析为对象
const body = qs.parse(str);

6. 将解析出来的数据对象挂载为 req.body

上游的中间件和下游的中间件及路由之间，共享同一份 req 和 res。因此，我们可以将解析出来的数据，挂载为 req 的自定义属性，命名为 req.body，供下游使用。示例代码如下：

// 3.监听 req 的 end 事件
req.on('end', () => {
    // 在 str 中存放的是完整的请求体数据
    // TODO:把字符串格式的请求体数据，解析成对象格式
    const body = qs.parse(str);
    req.body = body;
    next();
});