官方的概念：Express 是基于 Node.js 平台，快速、开放、极简的 Web 开发框架。
Express 的本质：就是一个 npm 上的第三方包，提供了快速创建 Web 服务器的便捷方法。
使用 Express 框架的原因：
http 内置模块用起来很复杂，开发效率低；Express 是基于内置的 http 模块进一步封装出来的，能够极大的提高开发效率。
最常见的两种服务器，分别是：
使用 Express，可以方便、快速的创建 Web 网站的服务器或 API 接口的服务器。
在项目所处的目录中，运行如下的终端命令，即可将 express 安装到项目中使用：
npm i express
// 1. 导入 express
const express = require('express')
// 2. 创建 web 服务器
const app = express()
// 3. 启动 web 服务器
app.listen(80, () => {
console.log('express server running at http://127.0.0.1')
})
其中开启的是默认主机IP为：127.0.0.1
80端口也是默认端口，也可以输入其他数字开启其他端口
开启服务需要此文件所在目录下打开终端，输入下面命令：
node app.js
其中 app.js 为你所命名的文件名。
通过 app.get() 方法，可以监听客户端的 GET 请求，具体的语法格式如下：
app.get('/user', (req, res) => {
// 调用 express 提供的 res.send() 方法，向客户端响应一个 JSON 对象
res.send({ name: 'zs', age: 20, gender: '男' })
})
通过 app.post() 方法，可以监听客户端的 POST 请求，具体的语法格式如下：
app.post('/user', (req, res) => {
// 调用 express 提供的 res.send() 方法，向客户端响应一个 文本字符串
res.send('请求成功！')
})
通过 req.query 对象，可以访问到客户端通过查询字符串的形式，发送到服务器的参数：
app.get('/', (req, res) => {
// 通过 req.query 可以获取到客户端发送过来的 查询参数
// 注意：默认情况下，req.query 是一个空对象
console.log(req.query)
res.send(req.query)
})
// 客户端发送 ?name=zs&age=20
// req.query.name req.query.age获取
通过 req.params 对象，可以访问到 URL 中，通过 : 匹配到的动态参数：
// 注意：这里的 :ids 是一个动态的参数,命名可以任意的, 通过 / 来分割多个参数
app.get('/user/:ids/:username', (req, res) => {
// req.params 是动态匹配到的 URL 参数，默认也是一个空对象
console.log(req.params)
res.send(req.params)
})
// 服务端输入http://127.0.0.1/1/zs
// 会动态匹配 {ids = 1,username = zs}
express.static()，通过它，我们可以创建一个静态资源服务器，
例如，通过如下代码就可以将 app 目录下的HTML、图片、CSS 文件、JavaScript 文件对外开放访问了：
app.use(express.static('./app'))
现在，你就可以访问 public 目录中的所有文件了：
http://localhost:80/index.html
http://localhost:80/images/bg.jpg
http://localhost:80/css/index.css
http://localhost:80/js/indxe.js
注意：Express 在指定的静态目录中查找文件，并对外提供资源的访问路径。因此，存放静态文件的目录名不会出现在 URL 中。即 app 这个目录名不会出现在 URL 中。
如果要托管多个静态资源目录，可以多次调用 express.static() 函数：
// 在这里，调用 express.static() 方法，快速的对外提供静态资源
app.use(express.static('./files'))
app.use(express.static('./app'))
访问静态资源文件时，express.static() 函数会根据目录的添加顺序查找所需的文件。遇到同名目录时安添加静态资源的顺序加载。
如果希望在托管的静态资源访问路径之前，挂载路径前缀，则可以使用如下的方式：
app.use('/app', express.static('./app'))
现在，你就可以通过带有 /app 前缀地址来访问 app 目录中的文件了：
http://localhost:80/app/index.html
http://localhost:80/app/images/bg.jpg
http://localhost:80/app/css/index.css
http://localhost:80/app/js/indxe.js
在编写调试 Node.js 项目的时候，如果修改了项目的代码，则需要频繁的手动关掉，然后再重新启动，这样的操作过于繁琐。
nodemon ，它能够监听项目文件的变动，当代码被修改后，nodemon 会自动帮我们重启项目，极大方便了开发和调试。
在终端中，运行如下命令，即可将 nodemon 安装为全局可用的工具：
npm install -g nodemon
建议安装在全局的环境中，在其他项目也可以使用这个这个模块。
和之前启动服务器的方法相同，只是开始的命令不同，将 node 换成 nodemon
nodemon app.js
广义上来讲，路由就是映射关系。
在 Express 中，路由指的是客户端的请求与服务器处理函数之间的映射关系。
Express 中的路由分 3 部分组成，分别是请求的类型、请求的 URL 地址、处理函数，格式如下：（这个只是格式，不是具体命令）
app.METHOD(PATH, HANDLER)
METHOD 代表具体客户端请求，比如 GET 、 POST ；
PATH 代表请求的 URL 地址；
HANDLER 代表处理函数；
每当一个请求到达服务器之后，需要先经过路由的匹配，只有匹配成功之后，才会调用对应的处理函数。
在匹配时，会按照路由的顺序进行匹配，如果请求类型和请求的 URL 同时匹配成功，则 Express 会将这次请求，转交给对应的 function 函数进行处理。
路由匹配的注意点：
① 按照定义的先后顺序进行匹配
② 请求类型和请求的URL同时匹配成功，才会调用对应的处理函数
把路由挂载到 app 上，示例代码如下：
const express = require('express')
const app = express()
// 挂载路由
app.get('/user', (req, res) => {
res.send('hello world.')
})
app.post('/login', (req, res) => {
res.send('Post Request.')
})
app.listen(80, () => {
console.log('http://127.0.0.1')
})
开启服务器后，浏览器中输入 http://127.0.0.1/user 可以获取到 hello world.
为了方便对路由进行模块化的管理，不建议将路由直接挂载到 app 上，而是推荐将路由抽离为单独的模块。
将路由抽离为单独模块的步骤如下：
创建路由模块对应的 router.js 文件
调用 express.Router() 函数创建路由对象
向路由对象上挂载具体的路由
使用 module.exports 向外共享路由对象
在 app.js 文件中使用 app.use() 函数注册路由模块
router.js
使用 router 命名只是为了易于理解，实际开发中，不一定要用 router 命名。
// 这是路由模块
// 1. 导入 express
const express = require('express')
// 2. 创建路由对象
const router = express.Router()
// 3. 挂载具体的路由
router.get('/user/list', (req, res) => {
res.send('Get user list.')
})
router.post('/user/add', (req, res) => {
res.send('Add new user.')
})
// 4. 向外导出路由对象
module.exports = router
app.js
const express = require('express')
const app = express()
// 1. 导入路由模块
const router = require('./router')
// 2. 注册路由模块
app.use(router)
app.listen(80, () => {
console.log('http://127.0.0.1')
})
注意： app.use() 函数的作用，就是来注册全局中间件，有关中间件内容，下面文章会介绍。
类似于托管静态资源时，为静态资源统一挂载访问前缀方式一样：
app.use('/api', router)
使用 app.ues( ) 注册路由模块，并添加统一的访问前缀 /API
比如：在上面步骤中所创建的 router.js 文件里面所编写的请求中，在没有为路由模块添加前缀前，调用接口的 URL 地址是：http://127.0.0.1/user/list
而为路由模块添加前缀后，调用接口的 URL 地址是：
http://127.0.0.1/api/user/list
中间件特指业务流程的中间处理环节。
当一个请求到达 Express 的服务器之后，可以连续调用多个中间件，从而对这次请求进行预处理。
Express 的中间件，本质上就是一个 function 处理函数，Express 中间件的格式如下：
app.get('/', function(req, res, next){
next();
})
注意：
中间件函数的形参列表中，必须包含 next 参数。
而路由处理函数中只包含 req 和 res。
next 函数是实现多个中间件连续调用的关键，它表示把流转关系转交给下一个中间件或路由。
可以通过如下的方式，定义一个中间件函数：
// 定义一个最简单的中间件函数
const mw = function (req, res, next) {
console.log('这是中间件函数')
// 把流转关系，转交给下一个中间件或路由
next()
}
客户端发起的任何请求，到达服务器之后，都会触发的中间件，叫做全局生效的中间件。
通过调用 app.use(中间件函数)，即可定义一个全局生效的中间件，示例代码如下：
const express = require('express')
const app = express()
// 这是定义全局中间件的简化形式
app.use((req, res, next) => {
console.log('这是中间件函数')
next()
})
app.get('/', (req, res) => {
console.log('调用了 / 这个路由')
res.send('Home page.')
})
app.get('/user', (req, res) => {
console.log('调用了 /user 这个路由')
res.send('User page.')
})
app.listen(80, () => {
console.log('http://127.0.0.1')
})
多个中间件之间，共享同一份 req 和 res。基于这样的特性，我们可以在上游的中间件中，统一为 req 或 res 对象添加自定义的属性或方法，供下游的中间件或路由进行使用。
const express = require('express')
const app = express()
// 这是定义全局中间件的简化形式
app.use((req, res, next) => {
// 获取到请求到达服务器的时间
const time = Date.now()
// 为 req 对象，挂载自定义属性，从而把时间共享给后面的所有路由
req.startTime = time
next()
})
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() 连续定义多个全局中间件。客户端请求到达服务器之后，会按照中间件定义的先后顺序依次进行调用，示例代码如下：
const express = require('express')
const app = express()
// 定义第一个全局中间件
app.use((req, res, next) => {
console.log('调用了第1个全局中间件')
next()
})
// 定义第二个全局中间件
app.use((req, res, next) => {
console.log('调用了第2个全局中间件')
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 mw = (req, res, next) => {
console.log('调用了局部生效的中间件')
next()
}
// 2. 创建路由
app.get('/', mw, (req, res) => {
res.send('Home page.')
})
app.get('/user', (req, res) => {
res.send('User page.')
})
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(80, function () {
console.log('Express server running at 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.')
})
// 导入 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, function () {
console.log('Express server running at http://127.0.0.1')
})
一定要在路由之前注册中间件
客户端发送过来的请求，可以连续调用多个中间件进行处理
执行完中间件的业务代码之后，不要忘记调用 next() 函数
为了防止代码逻辑混乱，调用 next() 函数后不要再写额外的代码
连续调用多个中间件时，多个中间件之间，共享 req 和 res 对象
在中间件不可以发送多个响应，否则会报错。
Express 官方把常见的中间件用法，分成了 5 大类，分别是：
应用级别的中间件
路由级别的中间件
错误级别的中间件
Express 内置的中间件
第三方的中间件
通过 app.use() 或 app.get() 或 app.post() ，绑定到 app 实例上的中间件，叫做应用级别的中间件，代码示例如下：
// 应用级别的中间件，全局中间件
app.use((req, res, next) => {
next()
})
// 应用级别的中间件，局部中间件
app.get('/', mw1, (req, res) => {
res.send()
})
绑定到 express.Router() 实例上的中间件，叫做路由级别的中间件。它的用法和应用级别中间件没有任何区别。只不过，应用级别中间件是绑定到 app 实例上，路由级别中间件绑定到 router 实例上，代码示例如下：
var app = express()
var router = express.Router()
// 路由级别的中间件
router.use((req, res, next) => {
next()
})
app.use('/', router)
错误级别中间件的作用：专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。
格式：错误级别中间件的 function 处理函数中，必须有 4 个形参，形参顺序从前到后，分别是 (err, req, res, next)。
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// 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)
})
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(80, function () {
console.log('Express server running at http://127.0.0.1')
})
**注意：**错误级别的中间件，必须注册在所有路由之后！
自 Express 4.16.0 版本开始，Express 内置了 3 个常用的中间件：
express.static 快速托管静态资源的内置中间件，例如： HTML 文件、图片、CSS 样式等（无兼容性）
express.json 解析 JSON 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）
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.body 这个属性，来接收客户端发送过来的请求体数据
// 默认情况下，如果不配置解析表单数据的中间件，则 req.body 默认等于 undefined
console.log(req.body)
res.send('ok')
})
app.post('/book', (req, res) => {
// 在服务器端，可以通过 req,body 来获取 JSON 格式的表单数据和 url-encoded 格式的数据
console.log(req.body)
res.send('ok')
})
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(80, function () {
console.log('Express server running at http://127.0.0.1')
})
非 Express 官方内置的，而是由第三方开发出来的中间件，叫做第三方中间件。在项目中，大家可以按需下载并配置第三方中间件，从而提高项目的开发效率。
例如：在 express@4.16.0 之前的版本中，经常使用 body-parser 这个第三方中间件，来解析请求体数据。使用步骤如下：
运行 npm install body-parser 安装中间件
使用 require 导入中间件
调用 app.use() 注册并使用中间件
注意：Express 内置的 express.urlencoded 中间件，就是基于 body-parser 这个第三方中间件进一步封装出来的。现在好像是不建议使用body-parser ，而是使用 express.urlencoded
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// 1. 导入解析表单数据的中间件 body-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.body 默认等于 undefined
console.log(req.body)
res.send('ok')
})
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(80, function () {
console.log('Express server running at http://127.0.0.1')
})
router.get('/uesr', (req, res) => {
// 处理过程
res.send({
status: 200,
msg: '请求成功！',
data: data // 数据
})
})
其中
router目录 是路由级别中间件
router_handle目录 是路由级别中间件处理函数
app.js 文件 是应用级别中间件
有关更多文件结构的内容将在下一遍文章介绍，敬请期待～
端点路由(Endpoint Routing)最早出现在ASP.NET Core2.2，在ASP.NET Core3.0提升...
为什么我们需要它 不得不说，在知道这个命令的时，以及之后的使用中，我都超级热...
博主最近在做一个个人的博客网站，准备用 thymeleaf 实现一个动态加载一二级文章...
目录中出现 jsconfig.json 文件表明该目录是 JavaScript 项目的根目录。 Json 文...
详解JSP中使用过滤器进行内容编码的解决办法 问题 当通过JSP页面，向数据库中插...
一、GIF图 二、前台代码 // 调用方法 hotlineLine(); // 定时刷新 setInterval(f...
MySQL的binlog相信大家都有所耳闻，但是可能没有真正日常使用过。 因此，本文结...
通过ImageMagickObject的identify获取图片的信息，在命令行下好用，但是放到程序...
前言 静态文件（如 HTML、CSS、图像和 JavaScript）等是Web程序的重要组成部分。...
本文转载自微信公众号「三太子敖丙」，作者三太子敖丙。转载本文请联系三太子敖...
