Express 中间件

最新推荐文章于 2024-04-26 13:07:22 发布
最新推荐文章于 2024-04-26 13:07:22 发布
阅读量346 收藏
点赞数
分类专栏： node.js 文章标签： 中间件 java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang1509123907/article/details/122780190
版权

中间件（Middleware ），特指业务流程的中间处理环节，本质上就是一个function处理函数。

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

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

定义中间件函数

// 常量mw所指向的，就是一个中间件函数
const mw = function (req, res, next) {
  console.log('这是一个最简单的中间件函数')
  // 注意：在当前中间件的业务处理完毕后，必须调用next（）函数
  // 表示把流转关系转交给下一个中间件或路由
  next()
}

全局生效的中间件

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

// 将mw注册为全局生效的中间件
app.use(mw)

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

//这是定义全局中间件的简化形式
app.use((req, res, next) => {
    console.log('这是最简单的中间件函数')
    next()
})

中间件的作用

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

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

//这是定义全局中间件的简化形式
app.use((req, res, next) => {
    const time = Date.now()
    req.startTime = time
    next()
})

app.get('/', (req, res) => {
    console.log('调用了/这个路由')
    res.send('Home page.' + req.startTime)
})

app.get('/user', (req, res) => {
    console.log('调用了/user这个路由')
    res.send('User page.' + req.startTime)
})

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

 定义多个全局中间件

可以使用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('/user', (req, res) => {
    res.send('User page.')
})

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

局部生效的中间件

不使用 app.use() 定义的中间件，叫做局部生效的中间件。

// 导入express模块
const express = require('express')
// 创建express的服务器实例
const app = express()

// 1.调用中间件函数
const mw1 = (req, res, next) => {
    console.log('调用了局部生效的中间件')
    next()
}

//2.创建路由
app.get('/', mw1, (req, res) => {
    res.send('Home page.')
})
app.get('/user', (req, res) => {
    res.send('Home page.')
})

// 调用app.listen方法，指定端口号并启动web服务器
app.listen(80, () => {
    console.log('http://127.0.0.1')
})

定义多个局部中间件

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

// 导入express模块
const express = require('express')
// 创建express的服务器实例
const app = express()

// 1.调用中间件函数
const mw1 = (req, res, next) => {
    console.log('调用了第一个局部生效的中间件')
    next()
}

const mw2 = (req, res, next) => {
    console.log('调用了第二个局部生效的中间件')
    next()
}

//2.创建路由
app.get('/', mw1, mw2, (req, res) => {
    res.send('Home page.')
})
app.get('/user', (req, res) => {
    res.send('User page.')
})

// 调用app.listen方法，指定端口号并启动web服务器
app.listen(80, () => {
    console.log('http://127.0.0.1')
})
// 以下两种写法是“完全等价”的，可根据自己的喜好，选择任意一种方式进行使用
app.get('/', mw1, mw2, (req, res) => {res.send('Home page.') })
app.get('/', [mw1, mw2], (req, res) => { res.send('Home page.') })

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

  1. 一定要在路由之前注册中间件
  2. 客户端发送过来的请求，可以连续调用多个中间件进行处理
  3. 执行完中间件的业务代码之后，不要忘记调用 next() 函数
  4. 为了防止代码逻辑混乱，调用 next() 函数后不要再写额外的代码
  5. 连续调用多个中间件时，多个中间件之间，共享 req 和 res 对象

中间件的分类


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

  1. 应用级别的中间件
  2. 路由级别的中间件
  3. 错误级别的中间件
  4. Express 内置的中间件
  5. 第三方的中间件

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)。

// 导入express模块
const express = require('express')
// 创建express的服务器实例
const app = express()

//1.调用路由
app.get('/', (req, res) => {
//    1.1人为的制造错误
    throw new Error('服务器内部发生了错误！')
    res.send('Home page.')
})

// 2.定义错误级别的中间件，捕获整个项目的异常错误，从而防止程序的崩溃
app.use((err, req, res, next) => {
    console.log('发生了错误！' + err.message)
    res.send('Error:' + err.message)
})

// 调用app.listen方法，指定端口号并启动web服务器
app.listen(80, () => {
    console.log('http://127.0.0.1')
})

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

4. Express内置的中间件


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

  1. express.static 快速托管静态资源的内置中间件，例如： HTML 文件、图片、CSS 样式等（无兼容性）
  2. express.json 解析 JSON 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）
  3. express.urlencoded 解析 URL-encoded 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）
// 导入express模块
const express = require('express')
// 创建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.boby这个属性，来接收客户端发送过来的请求体数据
//    默认情况下，如果不配置解析表单数据的中间件，则req.body默认等于undefined
    console.log(req.body)
    res.send('OK')
})

app.post('/book', (req, res) => {
    console.log(req.body)
    res.send('OK')
})

// 调用app.listen方法，指定端口号并启动web服务器
app.listen(80, () => {
    console.log('http://127.0.0.1')
})

5. 第三方的中间件


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

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

  1. 运行 npm install body-parser 安装中间件
  2. 使用 require 导入中间件
  3. 调用 app.use() 注册并使用中间件
// 导入express模块
const express = require('express')
// 创建express的服务器实例
const app = express()

//1.导入解析表单数据的中间件 bady-parser
const parser = require('body-parser')
//2.使用app.use()注册中间件
app.use(parser.urlencoded({extended: false}))
// app.use(express.urlencoded({extended: false}))

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

// 调用app.listen方法，指定端口号并启动web服务器
app.listen(80, () => {
    console.log('http://127.0.0.1')
})

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

自定义中间件(原理)


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

实现步骤：

  1. 定义中间件
  2. 监听 req 的 data 事件
  3. 监听 req 的 end 事件
  4. 使用 querystring 模块解析请求体数据
  5. 将解析出来的数据对象挂载为 req.body
  6. 将自定义中间件封装为模块

 定义中间件

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

 监听 req 的 data 事件

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

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

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

监听 req 的 end 事件

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

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

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

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

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

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

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

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

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

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

模块化的自定义中间件

// 导入express模块
const express = require('express')
// 创建express的服务器实例
const app = express()

//1.导入自己封装的中间件模块
const customBodyParser = require('./14.custom-body-parser')
//2.将自定义的中间件函数，注册为全局可用的中间件
app.use(customBodyParser)

app.post('/user', (req, res) => {
    res.send(req.body)
})

// 调用app.listen方法，指定端口号并启动web服务器
app.listen(80, () => {
    console.log('http://127.0.0.1')
})
// 导入Node.js内置的querystring模块
const qs = require('querystring')

const bodyParser = (req, res, next) => {
//    定义中间件具体的业务逻辑
//    1.定义一个str字符串，专门用来存储客户端发送过来的请求体数据
    let str = ''
//    2.监听req的data事件
    req.on('data', (chunk) => {
        str += chunk
    })
//    3.监听req的end事件
    req.on('end', () => {
        //    在str中存放的是完整的请求体数据
        // console.log(str)
        // //    TODO:把字符串格式的请求体数据，解析成对象格式
        const body = qs.parse(str)
        req.body = body
        next()
    })
}

module.exports = bodyParser

麦多馅饼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈express 中间件机制及实现原理
08-29
本篇文章主要介绍了浅谈express 中间件机制及实现原理，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Express中间件
世界和我们都不该止步于此
04-07 3686
目录 一.了解中间件 二.定义中间件 1.定义一个局部生效的中间件 2.定义一个全局生效的中间件 3.定义多个中间件遇到的问题 4.中间件有什么作用？ 5.总结 三.中间件的分类 1.应用级别中间件 2.路由级别中间件 3.错误级别中间件 4.Express内置中间件 5.第三方中间件 一.了解中间件 中间件（Middleware）是一个概念 用来特指业务流程的中间处理环节 在我们的Express服务器中，也是这样的道理，当客户端请求到达Express服务器后...
Express 路由和中间件 的详细介绍及使用
最新发布
m0_57184906的博客
04-26 1005
中间件（Middleware ），特指业务流程的中间处理环节需求描述与实现步骤自己手动模拟一个类似于 express.urlencoded 这样的中间件，来解析 POST 提交到服务器的表单数据。
【express】中间件
liuqinhou的博客
03-18 359
console.log('这是最简单的中间件函数');// 把流转关系转交给下一个中间件或路由next()可以使用app.use()连续定义多个全局中间件。客户请求到达服务器之后，会按照中间件定义的先后顺序依次进行调用console.log('调用了第一个中间件');next()})console.log('调用了第二个中间件');next()})})当请求http://127.0.0.1/时如上两种写法是等价的。
node.js:＜5＞中间件简单入门
aiwanchengxu的博客
04-05 401
之前我们讲到了中间件，那么我们就来了解一下到底什么是中间件： 就拿上面RFID设备通讯的实现原理来说，我们的读写器就看成是客户端发起的请求，请求会先到达中间的一大块处理模块，可以看到这些模块之间有相互的练习，我们就称这些模块为中间件，当然请求终究会到达路由； 也就是说我们的中间件的作用就是对请求的一些处理操作，它是在路由功能函数实现之前的一种预处理； 好了，接下来进入正题： 1、中间件分类： 1）全局中间件：这类中间件会在请求之前使用，而且还是所有请求； //2.1 构建一个全局中间件 a
详解vue+webpack+express中间件接口使用
12-09
原理：本地代码请求->express中间件（处理，添加headers后转发）->服务器 express中间件 medical 本地代码文件目录 pacs #########配置接口 在服务器中间件配置 medical/routes/home.js 没有需要新建home.js // ...
express中间件.xmind
07-04
express中间件.xmind
Express中间件的应用-路由保护(登录限制)、网站维护、页面404示例代码.zip
07-12
Express中间件的应用-路由保护(登录限制)、网站维护、页面404示例代码;Express中间件的应用-路由保护(登录限制)、网站维护、页面404示例代码
5、express路由和express中间件
weixin_48137421的博客
04-10 1802
自定义一个中间件，来实现客户端的请求和服务器端的映射关系。
koa-router，将路由抽取分离出去
lert707的博客
09-26 4043
Koa-router 先是app.js文件中的代码 const Koa = require('koa') const router = require('./router/router.js') const app = new Koa() app.use(router.routes()) .use(router.allowedMethods()) app.listen(3000, () ...
Node中Express中间件详解
qq_44741577的博客
03-04 677
console.log("这是一个中间件");// 把流转关系转交给下一个中间件或者路由next();// 全局生效中间件简写形式-----第一个中间件console.log("调用了第一个全局中间件");next();});// 第二个中间件console.log("调用了第二个全局中间件");next();});res.end("成功");});});自己手动模拟一个类似于这样的中间件，来解析POST提交到服务器的表单数据定义中间件。
node中间件
weixin_45445537的博客
12-07 484
node笔记
node.js常用中间件
weixin_45805570的博客
03-06 870
body-parser 用于接收前端发送post请求传过来的数据。 var bodyParser = require('body-parser') app.use(bodyParser.urlencoded({ extended: false })) app.use(bodyParser.json()) //app为express框架实例对象。 //在路由里使用req.body即可接收到前端传过来的数据。 koa-bodyparser koa框架里用来接收前端发送post请求传过来的数据。 var bo
可能是全网最详细的express-middleware
weixin_33827590的博客
05-25 257
写在前面 hello，小伙伴们，我是你们的pubdreamcc，本篇博文出至于我的GitHub仓库node学习教程资料，欢迎小伙伴们点赞和star，你们的点赞是我持续更新的动力。 GitHub仓库地址：node学习教程 好了，废话不多说了，今天继续我们express的学习~ 开篇 今天我们来聊一聊express中非常重要的一个概念——express middleware （express中间件...
Node.js（五、express中间件）
weixin_44767973的博客
03-13 2008
Node.js（五、express中间件）1、Express框架简介1.1、Express框架是什么1.2、Express框架特性1.3、Express框架基本使用2、Express中间件2.1、什么是中间件2.2、app.use中间件用法2.3、中间件应用2.4、错误处理中间件2.5、捕获错误3、Express框架请求处理3.1、构建模块化路由3.2、GET参数的获取3.3、POST参数的获取3.4、Express路由参数3.5、静态资源的处理3.6、express-art-template模板引擎3.7
【Nodejs】深入理解Express框架之如何使用各类中间件_04
青春木鱼的博客
05-10 1407
中间件为路由服务的，用于拦截对路由的请求，也可以作出响应。在nodejs中，中间件主要是指封装所有Http请求细节处理的方法，是从Http请求发起到响应结束过程中的处理方法。中间件的行为比较类似Java中过滤器的工作原理，就是在进入具体的业务处理之前，先让过滤器处理。中间件分为5大类，应用级中间件、路由级中间件、内置中间件、第三方中间件、错误处理中间件
express中间件
09-17
总之，Express中间件是一个强大的工具，它在请求到达最终处理函数之前允许你对请求和响应进行预处理和转换。通过使用中间件，你可以更好地组织和重用代码，简化开发过程，提高应用程序的可维护性和性能。 ### 回答...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值