express 自定义间件

1.如何自己动手定制中间件

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

2.实现步骤：

• 定义中间件

• 监听 req 的 data 事件

• 监听 req 的 end 事件

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

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

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

 2.1 定义中间件

使用 app.use() 来定义全局生效的中间件

1.  
   const express=require('express')
2.  
   const app=express();
3.  
   // 解析表单数据的中间件
4.  
   app.use((req,res,next)=>{
5.  
   // 定义中间价具体的业务逻辑
6.  
   })
7.  
    
8.  
   app.listen(8080,()=>{
9.  
   console.log('running....')
10.  
    })

2.2  监听 req 的 data 事件

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

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

1.  
   //定义变量 ,用来存储客户端响应过来的请求数据
2.  
   let str='';
3.  
   //监听req对象的data事件
4.  
   app.on('data',(chunk)=>{
5.  
   str =chunk
6.  
   })

2.3 监听req.end()事件

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

我们可以在req的end事件中,拿到并处理完整的请求体数据

1.  
   app.on('end',()=>{
2.  
   //打印完整的请求体数据
3.  
   console.log(str)
4.  
   {)

2.4 用 querystring 模块解析请求体数据

node.js内置了一个querystring模块, 专门用来处查询字符串. 通过这个模块提供的parse  ()函数,可以轻松的把查询字符串解析成对象的格式.

1.  
   //导入 querystring 模块
2.  
   const qs=require('querystring');
3.  
   //调用parse()方法
4.  
   const body=qs.parse(str)

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

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

1.  
   req.on('end',()=>{
2.  
   const body=qs.parse(str);
3.  
   req.body=body;
4.  
   next()
5.  
   })

整体代码:

1.  
   // 导入 express 模块
2.  
   const express = require('express')
3.  
   // 创建 express 的服务器实例
4.  
   const app = express()
5.  
   // 4. 导入 Node 内置模块 querystring
6.  
   const qs = require('querystring')
7.  
    
8.  
   // 解析表单数据的中间件
9.  
   app.use((req, res, next) => {
10.  
    // 定义中间价具体的业务逻辑
11.  
    // 1. 定义一个 str 字符串，专门用来存储客户端发送过来的请求体数据
12.  
    let str = ''
13.  
    // 2. 监听 req 的 data 事件
14.  
    req.on('data', (chunk) => {
15.  
    str = chunk
16.  
    })
17.  
     
18.  
    // 3. 监听 req 的 end 事件
19.  
    req.on('end', () => {
20.  
    // 在 str 中存放的是完整的请求体数据
21.  
    console.log(str)
22.  
    // 将字符串格式的请求体数据，解析成对象
23.  
    // 5. 调用 qs.parse() 方法，将查询字符串解析成对象
24.  
    const body = qs.parse(str)
25.  
     
26.  
    // 6. 将解析出来的数据对象挂载为 req.body 属性
27.  
    req.body = body
28.  
    next()
29.  
    })
30.  
    })
31.  
     
32.  
    app.post('/user', (req, res) => {
33.  
    res.send(req.body)
34.  
    })
35.  
     
36.  
    // 调用 app.listen方法，指定端口号并启动 web 服务器
37.  
    app.listen(3000, () => {
38.  
    console.log('running……')
39.  
    })

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

新建一个 custom-body-parser.js文件, 将中间件函数，封装为独立的模块

1.  
   //导入 Node 内置模块 querystring
2.  
   const qs = require('querystring')
3.  
    
4.  
   // 解析表单数据的中间件
5.  
   module.exports=function badyParse(req, res, next){
6.  
   // 定义中间价具体的业务逻辑
7.  
   // 1. 定义一个 str 字符串，专门用来存储客户端发送过来的请求体数据
8.  
   let str = ''
9.  
   // 2. 监听 req 的 data 事件
10.  
    req.on('data', (chunk) => {
11.  
    str = chunk
12.  
    })
13.  
     
14.  
    // 3. 监听 req 的 end 事件
15.  
    req.on('end', () => {
16.  
    // 在 str 中存放的是完整的请求体数据
17.  
    console.log(str)
18.  
    // 将字符串格式的请求体数据，解析成对象
19.  
    // 5. 调用 qs.parse() 方法，将查询字符串解析成对象
20.  
    const body = qs.parse(str)
21.  
     
22.  
    // 6. 将解析出来的数据对象挂载为 req.body 属性
23.  
    req.body = body
24.  
    next()
25.  
    })
26.  
    }

 对自定义的中间件进行模块化拆分:

1.  
    
2.  
   // 导入 express 模块
3.  
   const express = require('express')
4.  
   // 创建 express 的服务器实例
5.  
   const app = express()
6.  
    
7.  
   // 导入自己封装的中间件模块
8.  
   app.use(require('./custom-body-parser'))
9.  
    
10.  
    app.post('/user', (req, res) => {
11.  
    res.send(req.body)
12.  
    })
13.  
     
14.  
    // 调用 app.listen方法，指定端口号并启动 web 服务器
15.  
    app.listen(3000, () => {
16.  
    console.log('running……')
17.  
    })

这篇好文章是转载于：学新通技术网