03_Express-学习笔记

2026 年 4 月 24 日

4156 字

14 分钟

Node.js

Express · Node.js 学习笔记

基于 03_Express.pdf 整理
适合作为 Express 入门、路由、中间件与接口开发的结构化笔记。


1. 课程结构总览

这份 PDF 主要分成四部分:

  1. 初识 Express
  2. Express 路由
  3. Express 中间件
  4. 使用 Express 写接口

如果说前两天的重点是:

  • Node.js 是什么
  • 模块如何拆分
  • 包如何管理

那么这一天的重点就是:

如何用 Express 更高效地搭建 Web 服务器和 API 服务器。


2. 初识 Express

2.1 什么是 Express

Express 官方定义:

Express 是基于 Node.js 平台,快速、开放、极简的 Web 开发框架。

通俗理解:

  • 它和 Node.js 原生 http 模块一样,都可以创建 Web 服务器
  • 但 Express 更简单、更高效、更适合开发真实项目

Express 的本质:

它是 npm 上的一个第三方包,是对 Node.js 原生 http 模块的进一步封装。

2.2 为什么有了 http 还要学 Express

因为原生 http 虽然能写服务器,但使用起来较繁琐。

而 Express 做了很多封装:

  • 更方便的路由定义
  • 更清晰的请求处理流程
  • 更丰富的中间件机制
  • 更适合接口开发与工程化组织

课程里的类比非常好记:

http 和 Express 的关系,有点像浏览器原生 Web API 和 jQuery 的关系。

2.3 Express 能做什么

Express 最常见的两个使用场景:

1)Web 网站服务器

用于:

  • 返回 HTML
  • 托管 CSS / JS / 图片等静态资源

2)API 接口服务器

用于:

  • 对外提供数据接口
  • 处理前后端分离项目中的数据请求

一句话总结:

Express 既能做网站服务器,也能做接口服务器。


3. Express 的基本使用

3.1 安装

npm install express

3.2 创建最基本的 Web 服务器

Express 的最小可运行示例:

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

app.listen(3000, () => {
  console.log('server running at http://127.0.0.1:3000')
})

核心步骤:

  1. 导入 express
  2. 调用 express() 创建服务器实例
  3. 调用 app.listen() 启动服务

3.3 监听 GET 请求

app.get('/user', (req, res) => {
  res.send({ name: 'zs', age: 20 })
})

3.4 监听 POST 请求

app.post('/user', (req, res) => {
  res.send('请求成功')
})

3.5 使用 res.send() 响应客户端

res.send() 是 Express 中最常用的响应方法。

它可以发送:

  • 字符串
  • 对象
  • 数组
  • HTML

例如:

res.send('Hello Express')
res.send({ code: 0, msg: 'ok' })

4. 获取请求参数

4.1 获取查询参数:req.query

当客户端通过 URL 查询字符串传参时,可以通过 req.query 获取。

例如:

/user?id=1&name=zs

服务端:

app.get('/user', (req, res) => {
  console.log(req.query)
  res.send(req.query)
})

得到:

{ id: '1', name: 'zs' }

4.2 获取动态参数:req.params

当 URL 中使用动态占位符时,可以通过 req.params 获取。

例如:

app.get('/user/:id', (req, res) => {
  console.log(req.params)
  res.send(req.params)
})

如果访问:

/user/123

则可得到:

{ id: '123' }

这也是后面做 RESTful 接口非常常见的写法。


5. 托管静态资源

5.1 express.static()

Express 提供了一个非常实用的内置中间件:

express.static()

可以把某个目录直接托管为静态资源目录。

例如:

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

这样 public 目录下的文件就能直接访问,例如:

  • /images/bg.jpg
  • /css/style.css
  • /js/login.js

5.2 一个重要特点

当托管静态资源时:

静态目录名本身不会出现在 URL 中。

也就是说:

  • 本地目录是 public/images/bg.jpg
  • 浏览器访问可能是 /images/bg.jpg

5.3 托管多个静态资源目录

可以多次调用:

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

Express 会按照注册顺序查找资源。

5.4 挂载访问前缀

如果希望静态资源带统一前缀,可以这样写:

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

这时访问路径会变成:

  • /public/images/kitten.jpg
  • /public/css/style.css

6. nodemon

6.1 为什么需要 nodemon

在 Node 项目开发中,如果每次改代码都要手动重启服务,会非常低效。

nodemon 的作用就是:

监听文件变化,并在代码修改后自动重启项目。

6.2 安装

课程中介绍的是全局安装:

npm install -g nodemon

6.3 使用

以前启动:

node app.js

现在可以换成:

nodemon app.js

这样改完代码后,服务会自动重启。


7. Express 路由

7.1 什么是路由

广义上,路由就是:

映射关系

在 Express 中,路由表示:

客户端请求与服务器处理函数之间的映射关系。

一个完整路由通常由三部分组成:

  1. 请求方式
  2. 请求 URL
  3. 处理函数

例如:

app.get('/user', (req, res) => {
  res.send('获取用户信息')
})

7.2 路由的匹配规则

每当请求到达服务器时,Express 会依次进行路由匹配。

匹配规则:

  1. 按照定义顺序匹配
  2. 请求方法和 URL 都匹配成功,才会执行对应处理函数

因此,路由顺序很重要。


8. 路由的使用方式

8.1 最简单的路由写法

直接挂到 app 上:

app.get('/user', (req, res) => {
  res.send('获取用户信息')
})

app.post('/user', (req, res) => {
  res.send('新增用户信息')
})

8.2 为什么要做路由模块化

如果所有路由都直接写在 app.js 里,项目一大就会混乱。

因此 Express 推荐:

把路由拆成独立模块。

8.3 模块化路由的步骤

课程给出的步骤非常标准:

  1. 创建路由模块文件
  2. 调用 express.Router() 创建路由对象
  3. 在路由对象上挂载具体路由
  4. 通过 module.exports 导出路由对象
  5. 在主程序中通过 app.use() 注册路由模块

8.4 示例

路由模块文件

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

主程序中注册

const express = require('express')
const app = express()
const router = require('./router')

app.use(router)

8.5 为路由模块添加统一前缀

app.use('/api', router)

这样原本的:

  • /user/list

会变成:

  • /api/user/list

这在实际项目里非常常见。


9. Express 中间件

9.1 什么是中间件

中间件(Middleware)就是:

请求处理流程中的中间处理环节。

也可以把它理解为:

  • 请求到达路由前
  • 先经过的一层或多层处理逻辑

9.2 Express 中间件的本质

本质上,中间件就是一个函数。

基本格式:

const mw = function (req, res, next) {
  // 中间件逻辑
  next()
}

注意:

  • 中间件函数必须有 next
  • 路由处理函数通常只有 req 和 res

9.3 next() 的作用

next() 是 Express 中间件机制的关键。

它表示:

把处理权交给下一个中间件或路由。

如果不调用 next(),请求通常会卡住。


10. 中间件初体验

10.1 定义全局中间件

全局中间件会对所有请求生效。

app.use((req, res, next) => {
  console.log('触发了中间件')
  next()
})

10.2 中间件的作用

课程特别强调一个非常重要的点:

多个中间件之间,共享同一份 req 和 res。

因此可以在上游中间件中给 req / res 挂自定义属性,供下游使用。

例如:

app.use((req, res, next) => {
  req.startTime = Date.now()
  next()
})

app.get('/', (req, res) => {
  res.send('请求时间:' + req.startTime)
})

10.3 多个全局中间件

可以连续注册多个:

app.use((req, res, next) => {
  console.log('中间件 1')
  next()
})

app.use((req, res, next) => {
  console.log('中间件 2')
  next()
})

执行顺序按注册顺序来。

10.4 局部中间件

如果某个中间件只想服务某条路由,就可以写成局部中间件:

const mw = (req, res, next) => {
  console.log('局部中间件')
  next()
}

app.get('/', mw, (req, res) => {
  res.send('Home page.')
})

10.5 多个局部中间件

可以写成数组,也可以按参数顺序传多个。

例如:

app.get('/', [mw1, mw2], (req, res) => {
  res.send('Home page.')
})

11. 中间件使用注意事项

课程总结了 5 个高频注意点:

  1. 一定要在路由之前注册中间件
  2. 一个请求可以连续经过多个中间件
  3. 业务逻辑结束后别忘了调用 next()
  4. 调用 next() 后尽量不要再写额外逻辑
  5. 多个中间件之间共享 req 和 res

这些点非常重要,后面做登录校验、日志记录、权限判断时都会频繁碰到。


12. 中间件的分类

课程把常见中间件分成 5 类:

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

12.1 应用级别中间件

绑定到 app 实例上的中间件,例如:

app.use((req, res, next) => {
  next()
})

12.2 路由级别中间件

绑定到 router 实例上的中间件。

它和应用级别中间件用法一样,只是挂载对象不同。

12.3 错误级别中间件

用于捕获全局错误,防止项目崩溃。

格式必须是:

app.use((err, req, res, next) => {
  console.log('发生了错误:' + err.message)
  res.send('Error: ' + err.message)
})

关键特点:

  • 必须有 4 个参数:err, req, res, next
  • 必须注册在所有路由之后

12.4 Express 内置中间件

从 Express 4.16.0 开始,常见内置中间件有:

  1. express.static():托管静态资源
  2. express.json():解析 JSON 请求体
  3. express.urlencoded():解析表单格式请求体

12.5 第三方中间件

例如:

  • body-parser
  • cors

在旧版本 Express 中,body-parser 很常用于解析请求体。

如今 express.urlencoded() 本质上就是对此类能力的进一步封装。


13. 自定义中间件:解析表单数据

课程设计了一个练习:

手写一个类似 express.urlencoded() 的中间件,解析客户端 POST 提交的表单数据。

13.1 核心思路

  1. 定义中间件
  2. 监听 req 的 data 事件
  3. 拼接请求体数据
  4. 监听 req 的 end 事件
  5. 使用 querystring.parse() 解析数据
  6. 把结果挂载到 req.body
  7. 调用 next()

13.2 为什么 data 事件可能触发多次

因为当请求体较大时,客户端可能会把数据分多次发送。

所以:

  • data 事件获取到的是片段
  • 需要手动拼接

13.3 querystring 的作用

Node.js 内置 querystring 模块,可以把 URL-encoded 格式的字符串解析成对象。

例如:

const qs = require('querystring')
const body = 'name=zs&age=20'
console.log(qs.parse(body))

得到:

{ name: 'zs', age: '20' }

13.4 简化示例

const querystring = require('querystring')

app.use((req, res, next) => {
  let str = ''

  req.on('data', chunk => {
    str += chunk
  })

  req.on('end', () => {
    req.body = querystring.parse(str)
    next()
  })
})

13.5 为什么要挂到 req.body

因为:

  • 中间件和路由共享同一个 req
  • 挂到 req.body 后,下游路由就能直接用

这就是中间件“预处理请求”的经典用法。


14. 使用 Express 写接口

14.1 创建基本服务器

Express 写接口的起点仍然是:

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

14.2 创建 API 路由模块

接口项目中,非常推荐把 API 路由单独拆成模块,例如:

  • router/apiRouter.js

再统一挂到:

app.use('/api', apiRouter)

这样接口路径会更清晰,例如:

  • /api/get
  • /api/post

14.3 编写 GET 接口

app.get('/api/get', (req, res) => {
  res.send({
    status: 0,
    msg: 'GET 请求成功',
    data: req.query,
  })
})

14.4 编写 POST 接口

如果要解析表单格式请求体,必须先注册:

app.use(express.urlencoded({ extended: false }))

然后:

app.post('/api/post', (req, res) => {
  res.send({
    status: 0,
    msg: 'POST 请求成功',
    data: req.body,
  })
})

这里的重点是:

写接口前,先把请求体解析中间件注册好。


15. CORS 跨域资源共享

15.1 为什么会有跨域问题

前端页面和接口服务器如果不是同源,浏览器会触发同源策略限制。

课程中给出了两种解决方案:

  1. CORS(主流,推荐)
  2. JSONP(有缺陷,仅支持 GET)

15.2 使用 cors 中间件解决跨域

步骤:

  1. 安装
npm install cors
  1. 导入
const cors = require('cors')
  1. 注册
app.use(cors())

注意:

  • 一般要在路由之前注册

15.3 什么是 CORS

CORS 全称:

Cross-Origin Resource Sharing(跨域资源共享)

它本质上依赖一组 HTTP 响应头,由服务器告诉浏览器:

  • 哪些来源能访问我
  • 允许带哪些请求头
  • 允许使用哪些请求方法

也就是说:

CORS 主要是服务端配置,客户端浏览器通常不需要额外处理。


16. 常见 CORS 响应头

16.1 Access-Control-Allow-Origin

用于指定允许访问资源的外域。

例如只允许某个域:

res.setHeader('Access-Control-Allow-Origin', 'http://itcast.cn')

允许所有域:

res.setHeader('Access-Control-Allow-Origin', '*')

16.2 Access-Control-Allow-Headers

如果客户端发送了额外自定义请求头,服务器必须显式声明允许。

否则请求可能失败。

16.3 Access-Control-Allow-Methods

默认情况下,CORS 主要支持:

  • GET
  • POST
  • HEAD

如果要支持:

  • PUT
  • DELETE
  • PATCH
  • 等更多方法

就需要通过该响应头显式声明。


17. CORS 请求的分类

课程把 CORS 请求分为两类:

  1. 简单请求
  2. 预检请求

17.1 简单请求

满足这些条件之一组时,属于简单请求:

  • 方法是 GET / POST / HEAD
  • 请求头不超出规定范围
  • Content-Type 仅限于以下三种之一:
    • application/x-www-form-urlencoded
    • multipart/form-data
    • text/plain

特点:

浏览器和服务器之间只发生一次请求。

17.2 预检请求

以下任一情况通常会触发预检:

  • 请求方法不是 GET / POST / HEAD
  • 带了自定义请求头
  • 发送的是 application/json

浏览器会先发送一个:

  • OPTIONS

请求去询问服务器是否允许。

如果服务器允许,浏览器才会再发送真正请求。

特点:

服务器和浏览器之间会发生两次请求:预检 + 真正请求。


18. JSONP 接口

18.1 什么是 JSONP

JSONP 的本质是:

  • 浏览器通过 <script> 标签的 src 发请求
  • 服务器返回一段函数调用代码
  • 浏览器把这段代码当 JS 执行

所以 JSONP:

  • 不是真正的 Ajax
  • 不依赖 XMLHttpRequest
  • 只支持 GET 请求

18.2 JSONP 的使用场景

它是早期跨域方案之一。

但因为限制太多,现在更多是用于理解历史方案,实际项目优先用 CORS。

18.3 实现 JSONP 的步骤

课程给出的步骤:

  1. 获取客户端传来的回调函数名
  2. 准备要返回的数据
  3. 拼接成函数调用字符串
  4. 把字符串响应给浏览器的 <script> 标签

18.4 简化示例

app.get('/api/jsonp', (req, res) => {
  const funcName = req.query.callback
  const data = { name: 'zs', age: 20 }
  const scriptStr = `${funcName}(${JSON.stringify(data)})`
  res.send(scriptStr)
})

18.5 JSONP 和 CORS 的关系

课程提醒:

如果项目中同时配置了 CORS 和 JSONP:

JSONP 路由要写在 CORS 中间件之前。

否则 JSONP 接口会被当成普通开启了 CORS 的接口处理。


19. 本节课核心知识清单

如果只看这份 PDF,最少要掌握这些内容:

Express 基础

  • Express 是什么
  • Express 和原生 http 的关系
  • 会创建最基本的 Express 服务器
  • 会使用 app.get() / app.post()
  • 会使用 res.send()
  • 会获取 req.query / req.params

静态资源

  • 会使用 express.static()
  • 知道可以托管多个目录
  • 知道可以挂载访问前缀

路由

  • 理解路由的本质是映射关系
  • 知道路由匹配和顺序有关
  • 会写模块化路由
  • 会给路由模块统一加前缀

中间件

  • 知道中间件是什么
  • 知道 next() 的作用
  • 会写全局中间件和局部中间件
  • 理解多个中间件共享 req / res
  • 会写错误处理中间件
  • 知道 Express 内置中间件和第三方中间件

接口开发

  • 会写 GET / POST 接口
  • 知道 express.urlencoded() 的作用
  • 会用 cors 解决跨域
  • 理解简单请求与预检请求
  • 知道 JSONP 的原理和局限

20. 一页速查表

20.1 创建服务器

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

app.listen(3000)

20.2 GET / POST 路由

app.get('/user', (req, res) => {
  res.send(req.query)
})

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

20.3 获取动态参数

app.get('/user/:id', (req, res) => {
  res.send(req.params)
})

20.4 托管静态资源

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

20.5 注册中间件

app.use((req, res, next) => {
  next()
})

20.6 解析表单数据

app.use(express.urlencoded({ extended: false }))

20.7 解析 JSON 数据

app.use(express.json())

20.8 注册路由模块

app.use('/api', router)

20.9 处理跨域

const cors = require('cors')
app.use(cors())

20.10 错误处理中间件

app.use((err, req, res, next) => {
  res.send('Error: ' + err.message)
})

21. 学完这节后的建议

建议你按这个顺序自己再练一遍:

  1. 手写一个最基础的 Express 服务器
  2. 写 2 个 GET 路由和 2 个 POST 路由
  3. 自己练一遍 req.query 和 req.params
  4. 托管一个静态资源目录
  5. 把路由拆成模块再注册回来
  6. 写一个全局中间件和一个局部中间件
  7. 手写一个 POST 接口并解析表单数据
  8. 给接口配置 cors
  9. 最后尝试理解 JSONP 的实现原理

22. 一句话总结

这份 PDF 的核心目标,可以概括成一句话:

Express 通过路由和中间件,把原本繁琐的 Node.js 服务器开发流程变成了结构清晰、效率很高的工程化开发方式。

03_Express-学习笔记
https://blog.yagami.top/blog/nodejs/day3/03_express-学习笔记/
作者
Nekode
发布时间
2026 年 4 月 24 日
许可协议
CC BY-NC-SA 4.0

正在加载评论...

目录

输入关键词开始搜索