Node.js学习笔记——Express篇（3.Express 中间件）

目录

概念

初体验

分类

自定义中间件

---

概念

1. 什么是中间件
   中间件(Middleware)，特指业务流程的中间处理环节。
2. 现实生活中的例子
   
3. Express 中间件的调用流程
   
4. Express 中间件的格式
   
5. next 函数的作用
   

初体验

1. 定义中间件函数

   const express = require('express')
   const app = express()
   
   // 定义个简单的中间函数
   const mmb = function(req,res,next){
       console.log("简单的中间函数");
       // 把流转关系，转交给下一个中间件或路由
       next()
   }
   
   app.listen(80, () => { console.log('http://127.0.0.1') })  

2. 全局生效的中间件函数
   客户端发起的任何请求，到达服务器之后，都会触发的中间件，叫做全局生效的中间件。
   通过调用 app.use(中间件函数)，即可定义一个全局生效的中间件，示例代码如下：

   // 定义个简单的中间函数
   const mmb = function (req, res, next) {
       console.log("简单的中间函数");
       // 把流转关系，转交给下一个中间件或路由
       next()
   }
   
   // 将 mmb 注册为全局生效的中间件
   app.use(mmb)
   
   app.get('/', function (req, res) {
       console.log("调用了 / 这个路由");
       res.send('Home pgae.')
   })
   
   app.get('/user', function (req, res) {
       console.log("调用了 /user 这个路由");
       res.send('User page.')
   })

   

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

   app.use(function (req, res, next) {
       console.log("简单的中间函数");
       // 把流转关系，转交给下一个中间件或路由
       next()
   })

4. 中间件的作用
   

   // 定义全局中间件的简化形式
   app.use(function (req, res, next) {
       // 获取请求到达服务器的时间
       const time = Date.now()
       // 为 req 对象，挂载自定义属性，从而把时间共享给后面的所有luyou
       req.startTime = time
       next()
   })
   app.get('/', function (req, res) {
       // console.log("调用了 / 这个路由");
       res.send('Home pgae ' + req.startTime)
   })
   
   app.get('/user', function (req, res) {
       // console.log("调用了 /user 这个路由");
       res.send('User page ' + req.startTime)
   })

   

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

   // 定义第一个全局中间件
   app.use(function (req, res, next) {
       console.log("调用了第一个全局中间件");
       next()
   })
   
   // 定义第二个全局中间件
   app.use(function (req, res, next) {
       console.log("调用了第二个全局中间件");
       next()
   })
   
   // 请求触发这个路由，会依次调用上面两个中间件
   app.get('/', function (req, res) {
       res.send('Home pgae')
   })
   

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

   // 定义中间件函数
   const mmb1 = (req, res, next){
       console.log('这是局部生效中间件');
       next()
   }
   
   // mmb1 这个中间件只在 当前路由生效 ，这种用法属于 局部生效的中间件
   app.get('/', mmb1, function (req, res) {
       res.send('Home pgae')
   })
   
   // mmb1 这个中间件不会影响这个路由↓↓↓
   app.get('/user', function (req, res) {
       res.send('User page')
   })
   

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

   // 以下两种写法都可行
   app.get('/', mmb1,mmb2, function (req, res) { res.send('Home pgae') })
   app.get('/', [mmb1,mmb2], function (req, res) { res.send('Home pgae') })

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

分类

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

• 应用级别的中间件
• 路由级别的中间件
• 错误级别的中间件
• Express 内置的中间件
• 第三方的中间件

1. 应用级别的中间件
   通过 app.use0 或 app.get0 或 app.post0，绑定到app实例上的中间件，叫做应用级别的中间件，代码示例如下：

   // 应用级别的中间件（全局中间件）
   app.use((req, res, next) => {
       next()
   })
   
   // 应用级别的中间件（局部中间件）
   app.get('/', mmb1, function (req, res) { res.send('Home pgae') })

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

   var express = require("express");
   var router = express.Router();
   
   // 路由级别的中间间
   router.use(function (req, res, next) {
       console.log("TIME:", Date.now());
       next();
   });
   
   app.use("/api", router);

3. 错误级别的中间件
   错误级别中间件的作用：专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。
   格式：错误级别中间件的function处理函数中，必须有4个形参，形参顺序从前到后，分别是(err,req,res,next)。

   // 1.定义路由
   app.get('/', (req, res) => {
       // 人为的制造错误
       throw new Error("服务器内部发生错误");
       res.send('Home page.')
   })
   
   // 2.定义错误级别的中间件，捕获整个项目的异常错误，从而防止程序的崩溃
   app.use((err, req, res, next) => {
       // 在服务端打印错误信息
       console.log("发生了错误！" + err.message);
       // 向客户端响应错误相关的内容
       res.send('Error：' + err.message);
   });

   
   
   注意：错误级别的中间件，必须注册在所有路由之后！！！
4. Express 内置的中间件

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

5. 第三方的中间件
   

自定义中间件

1. 需求描述与实现步骤
   
2. 定义中间件

   app.use(function (res, res, next) {
       // 中间件的业务逻辑
   })

3. 监听 req 的 data 事件
   

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

4. 监听 req 的 end 事件
   当请求体数据接收完毕之后，会自动触发req的end事件。
   因此，我们可以在req的end事件中，拿到并处理完整的请求体数据。示例代码如下：

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

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

   // 导入处理querystring的Node.js内置模块
   const qs = require('querystring')
   // 调用qs.parse()方法，把查询字符串解析为对像
   const body = qs.parse(str)
   

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

   req.on('end', () => {
       //调用qs.parse()方法，把渣询字符串解析为对像
       const body = qs.parse(str)
       // 将解析出来的请求体对像，挂载为 req.body 属性
       req.body = body
       //最后，一定要调用next()函数，执行后续的业务逻辑
       next()
   })

7. 将自定义中间件封装为模块
   为了优化代码的结构，我们可以把自定义的中间件函数，封装为独立的模块，示例代码如下：

   // 自定义中间件模块.js 中的代码
   const qs = require('querystring')
   const bodyParser = (req, res, next) => { /**省略内容 */ }
   // 向外导出解析请求体数据的中间件函数
   module.exports = bodyParser;
   

   // 导入自定义中间件模块
   const mybodyParser=require(/** 自定义中间件模块.js */)
   // 注册自定义中间件模块
   app.use(mybodyParser)
   

---

学习视频：https://www.bilibili.com/video/BV1a34y167AZ?spm_id_from=333.999.0.0