Node.js学习之Express框架(一)

Express简介与安装

  Express是基于Node.js平台，快速、开放、极简的Web开发框架。通俗来说Express的作用就和Node.js内置的http模块类似，是专门用来创建Web服务器的。因为http内置模块用起来很复杂，开发效率低; Express是基于内置的 http模块进一步封装出来的，能够极大的提高开发效率。使用Express，我们可以方便、快速的创建Web网站的服务器（专门对外提供Web 网页资源的服务器）或API接口的服务器（专门对外提供API接口的服务器）。官方文档：Express框架。

//终端输入安装命令
npm i express  //如果要具体安装哪个版本,在后面加上@[版本号]即可

Express的基本使用

创建最基本的web服务器

const express = require('express')
const app = express()  //http模块要调用http.createServer()方法来创建web服务器实例
app.listen(80,function (){
	console.log('express server running at http://127.0.0.1')
})

监听GET/POST请求及其他方法

1、通过app.get()方法，可以监听客户端的GET请求（以下app都是用来接收express的参数名）：

//它包含两个参数，一个是客户端请求的url地址,另一个是请求对应的处理函数
//req是请求对象,包含了与请求相关的属性与方法
//res是响应对象,包含了与响应相关的属性与方法
app.get('请求URL',function(req,res) { /*处理函数*/ }

2、通过app.post()方法，可以监听客户端的POST请求：

//它包含两个参数，一个是客户端请求的url地址,另一个是请求对应的处理函数
//req是请求对象,包含了与请求相关的属性与方法
//res是响应对象,包含了与响应相关的属性与方法
app.post('请求URL',function(req,res){ /*处理函数*/ }

3、通过res.send()方法，可以把处理好的内容发送给客户端：

app.get('/user',(req,res) => { 
	//向客户端发送JSON对象
	res.send({name:'zhangsan',age:'18'})
})
app.post('/user',(req,res) => { 
	//向客户端发送文本内容
	res.send('请求成功')
})

在终端运行js文件，再在Postman中分别测试GET/POST请求：

4、通过req.query对象，可以访问到客户端通过查询字符串的形式发送到服务器的参数：

app.get('/', (req,res) => {
	//req.query 默认是一个空对象
	//客户端使用name=zhangsan&age=18这种查询字符串的形式,发送到服务器的参数
	//可以通过req.query对象访问到:req.query.name  req.query.age
	console.log(req.query)
	res.send(req.query)
})

5、通过req.params对象，可以访问到url中通过:匹配到的动态参数：

//url地址中,可以通过:参数名 的形式,匹配动态参数值
app.get('/user/:id', (req,res) => {
	//req.params默认是一个空对象
	//里面存放着通过:动态匹配到的参数值
	console.log(req.params)
})

托管静态资源

1、express.static()：express提供的一个非常好用的函数。通过它，我们可以非常方便地创建一个静态资源服务器。例如，通过如下代码就可以将public目录下的图片、CSS文件、JavaScript文件对外开放访问：

app.use(express.static('public')

注意：Express在指定的静态目录中查找文件，并对外提供资源的访问路径。但是存放静态文件的目录名（如例子中的public）不会出现在URL中。

2、托管多个静态资源目录
  如果要托管多个静态资源目录，多次调用express.static()函数即可。访问静态资源文件时，express.static()函数会根据目录的添加顺序查找所需的文件。

3、挂载路径前缀
如果希望在托管的静态资源访问路径之前，挂载路径前缀（即url中会出现托管的文件目录名），则可以使用如下的方式：

app.use('/public', express.static('public'))

4、nodemon
  在编写调试Node.js项目的时候，如果修改了项目的代码，则需要频繁的手动来关掉，然后再重新启动，非常繁琐。现在我们可以使用nodemon这个工具，它能够监听项目文件的变动，当代码被修改后，nodemon 会自动帮我们重启项目，极大方便了开发和调试。官方地址：nodemon
在终端中运行如下命令，即可将nodemon安装为全局可用的工具：

npm install -g nodemon

  当基于Node.js编写了一个网站应用的时候，传统的方式是使用node ×××.js命令来启动项目。这样做的坏处是当代码被修改之后需要手动重启项目。现在我们可以将node命令替换为nodemon命令，使用nodemon ×××.js来启动项目。这样做的好处是当代码被修改之后，会被nodemon监听到，从而实现自动重启项目的效果。

Express路由

路由的基本使用

  在Express中，路由指的是客户端的请求与服务器处理函数之间的映射关系。Express中的路由三部分组成，分别是请求的类型、请求的URL地址和处理函数。

//METHOD是请求类型,PATH是请求url地址,HANDLER是处理函数
app.METHOD(PATH,HANDLER)
//eg:
const express = require('express')
const app = express()
//匹配GET请求,且请求URL为/
app.get('/', (req,res) => {
	res.send('Hello world!')
})
//匹配POST请求,且请求URL为/
app.post('/', (req,res) => {
	res.send('Got a PoST request')
})
app.listen(80,() => {
	console.log('express server running at http://127.0.0.1')
})

每当一个请求到达服务器，都需要先经过路由的匹配，只有匹配成功之后才会调用对应的处理函数。在匹配时会按照路由的顺序进行匹配，如果请求类型和请求的URL同时匹配成功则Express会将这次请求转交给对应的 function函数进行处理。

模块化路由

  为了方便对路由进行模块化的管理，Express不建议将路由直接挂载到app上，而是推荐将路由抽离为单独的模块。将路由抽离为单独模块的步骤如下:①创建路由模块对应的.js 文件；②调用express.Router()函数创建路由对象；③向路由对象上挂载具体的路由；④使用module.exports向外共享路由对象；⑤使用app.use()函数注册路由模块。

创建路由模块

//router.js
const express = require('express')
const express = require('express')
//创建路由对象
const router = express.Router()
//挂载具体的路由
router.get('/user/list', (req,res) => {
	res.send('get user list')
})
router.post('/user/add', (req,res) => {
	res.send('add new user')
})
//向外导出路由对象
module.exports = router

注册路由模块

//模块化路由.js
const express = require('express')
const app = express()
//导入路由模块
const router = require('./router')
//注册路由模块
app.use(router)  //app.use()函数作用：注册全局中间件
app.listen(80,() => {
	console.log('http://127.0.0.1')
})

为路由模块添加后缀

与托管静态资源时为静态资源统一挂载访问前缀一样，路由模块添加前缀的方式也非常简单：

//导入路由模块
const router = require('./router')
//注册路由模块
app.use('[×××]',router)

中间件

中间件的概念

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

中间件的格式

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

const express = require('express')
const app = express()
app.get('/', function(req,res,next){
	next();
})
app.listen(3000)

注意：中间件函数的形参列表中必须包含next 参数，而路由处理函数中只包含req和res。
next函数的作用：next函数是实现多个中间件连续调用的关键，它表示把流转关系转交给下一个中间件或路由。

定义中间件函数

const express = require('express')
const app = express()
//定义一个最简单的中间件函数
const mw = function(req,res,next) {
    console.log('这是最简单的中间件函数');
    next()
}
app.listen(80,() => {
    console.log('http://127.0.0.1');
})

全局中间件函数

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

const express = require('express')
const app = express()
//定义一个最简单的中间件函数
const mw = function(req,res,next) {
    console.log('这是最简单的中间件函数');
    next()
}
app.use(mw)
//全局中间件的简写形式
// app.use(function(req,res,next) {
//     console.log('这是最简单的中间件函数');
//     next()
// })

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

示例：在Postman中成功显示。

const express = require('express')
const app = express()
const mw = function(req,res,next) {
    const time = Date.now()  //获取到请求到达服务器的时间
    req.startTime = time  //为req对象挂载自定义属性,从而把时间共享给后面所有的路由
    next()
}
app.use(mw)
app.get('/',(req,res) => {
    res.send('Home page' + req.startTime)
})
app.get('/user',(req,res) => {
    res.send('User page' + req.startTime)
})
app.listen(80,() => {
    console.log('http://127.0.0.1');
})

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

局部中间件函数

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

const express = require('express')
const app = express()
const mw = function(req,res,next) {
    console.log('这是局部中间件函数');
    next()
}
//局部中间件mw只在这个路由生效
app.get('/',mw,(req,res) => {
    res.send('Home page')
})
app.get('/user',(req,res) => {
    res.send('User page')
})
app.listen(80,() => {
    console.log('http://127.0.0.1');
})

定义多个局部中间件并使用：

//两种写法完全等价
app.get('/',[mw,mw1],(req,res) => { res.send('Home page') })
app.get('/',mw,mw1,(req,res) => { res.send('Home page') })

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

中间件的分类

Express把常见的中间件的用法分成了五大类，分别是：应用级别、路由级别、错误级别、Express内置和第三方的中间件。

应用级别的中间件

  通过app.use()或app.get()或 app.post()绑定到 app实例上的中间件，叫做应用级别的中间件；

路由级别的中间件

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

错误级别的中间件

  错误级别的中间件是专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。错误级别的中间件的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('Error：' + err.message)  //向客户端响应错误的内容
})
app.listen(80,() => {
    console.log('http://127.0.0.1');
})

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

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+版本中可用)。

//语法
app.use(express.json())  //配置解析 application/json格式数据的内置中间件
app.use(express.urlencoded({ extended: false })) //配置解析 application/x-www-form-urlencoded 格式数据的内置中间件
// 1、express.json()、express.urlencoded()使用
const express = require('express')
const app = express()
//除了错误级别的中间件，其他的必须在路由之前注册
app.use(express.json())
app.use(express.urlencoded({ extended: false }))
app.post('/user',(req,res) => {
    //在服务器中可以使用req.body这个属性来接收客户端发送过来的请求体数据
    //默认情况下，如果不配置内置的解析表单数据的中间件，则req.body默认为undefined
    console.log(req.body);
    res.send('ok')
})
app.listen(80,() => {
    console.log('http://127.0.0.1');
})

在Postman中分别发送一个json(body-raw，右边text类型选择json)和x-www-form-urlencoded，查看终端输出:

第三方的中间件

  指不是官方内置的，而是由第三方开发出来的中间件。比如在express@4.16.0之前的版本中，经常使用body-parser这个第三方中间件，来解析请求体数据。先下载再require导入最后使用app.use()注册并使用中间件。
注意：Express 内置的 express.urlencoded中间件，就是基于body-parser这个第三方中间件进一步封装出来的。

const parser = require('body-parser')
app.use(parser.urlencoded({ extended: false }))

自定义中间件

  1、监听req的data事件：在中间件中需要监听req对象的data事件来获取客户端发送到服务器的数据。如果数据量比较大，无法一次性发送完毕，则客户端会把数据切割后分批发送到服务器，所以data事件可能会触发多次。每一次触发data事件时，获取到数据只是完整数据的一部分，需要手动对接收到的数据进行拼接。
  2、监听req的end事件：当请求体数据接收完毕之后会自动触发req的end事件。因此我们可以在req的end事件中，拿到并处理完整的请求体数据。
  3、使用querystring模块解析请求体数据：Node.js 内置了一个querystring模块，专门用来处理查询字符串。通过这个模块提供的parse()函数，可以轻松把字符串格式解析成对象的格式。
  4、将解析出来的数据对象挂载为req.body：上游的中间件和下游的中间件及路由之间共享同一份req和res。因此我们可以将解析出来的数据挂载为req的自定义属性并命名为req.body，供下游使用。
  5、将自定义中间件封装为模块：为了优化代码的结构，我们可以把自定义的中间件函数封装为独立的模块。
总体示例代码如下：

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

// 导入Node.js内置的querystring模块
const qs = require('querystring')
app.use((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);
        //调用qs.parse()方法把字符串格式的请求体数据解析成对象格式
        const body = qs.parse(str)
        // console.log(body);
        req.body = body //将解析出来的请求体对象挂载为req.body属性
        next()  //调用next()函数执行后续
    })
})
//模块化拆分
//将以上app.use内的(req,res,next)放到14-custom-body-parser.js并导出，然后再在原来的页面导入该模块
//const customBodyParser = require('./14-custom-body-parser')
//app.use(customBodyParser)
app.post('/user',(req,res) => {
    console.log(req.body);
    res.send(req.body)
})
app.listen(80,() => {
    console.log('http://127.0.0.1');
})