EXpress - web开发框架

Express基本使用

1.安装

在项目所处的目录中，运行如下的终端命令，即可将 express 安装到项目中使用

npm i express@4.17.1

2. 创建基本的 Web 服务器

// 1.导入express
const express = require('express')

// 2.创建web服务器
const app = express()

//请求和路由都写在这里

// 3.调用app.listen(端口号，启动成功后的回调函数），启动服务器
app.listen(80,() => {
    console.log('express server running at hettp://127.0.0.1')
})

3. 监听 GET 请求

通过 app.get() 方法，可以监听客户端的 GET 请求，具体的语法格式如下

// 参数1：客户端请求的URL地址
// 参数2：请求对应的处理函数，req:请求对象。res:响应对象
app.get('请求URL',(req,res) => { // 处理函数 })
})

4. 监听 POST 请求

通过 app.post() 方法，可以监听客户端的 POST 请求，具体的语法格式如下

app.post('请求URL',(req,res) => {  //处理函数  })

5. 把内容响应给客户端

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

app.get('/user',(req,res) => {
    // 向客户端发送了JSON对象
    res.send({name:'zs' ,age:20,gender:'男'})
})

app.post('/user',(req,res) => {
    // 向客户发送文本内容
    res.send('请求成功')
})

6. 获取 URL 中携带的查询参数

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

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

7. 获取 URL 中的动态参数

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

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

Express路由

Express 中的路由分 3 部分组成，分别是请求的类型、请求的 URL 地址、处理函数，格式如下

app.method(path,handler)

1.最简单的写法

在 Express 中使用路由最简单的方式，就是把路由挂载到 app 上，示例代码如下：

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

// 挂载路由
app.get('/',(req,res) => {
    res.send('Hello World.')
})
app.post('/',(req,res) => {
    res.send('Post Request.')
})

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

2. 模块化路由

为了方便对路由进行【模块化的管理】，Express 不建议将路由直接挂载到 app 上，而是推荐将路由抽离为单独的模块

【1】创建路由模块对应的 .js 文件

     ---`Router.js`文件

【2】调用 `express.Router()` 函数创建路由对象

【3】向路由对象上挂载具体的路由

【4】使用 `module.exports` 向外共享路由对象

var express = require('express')

// 【2】创建路由对象
var router = express.Router()

// 【3】挂载获取用户列表的路由
router.get('/user/list',function(req,res){
    res.send('Get user list.')
})
// 【3】挂载添加用户的路由
router.post('/user/add',function(req,res){
    res.send('Add newnuser')
})

// 【4】向外到处路由对象
module.exports = router

【5】在目标js页面中，使用 app.use() 函数注册路由模块

// 【1】导入路由模块
const router = require('./6Router')
// 【2】注册路由模块,为路由模块添加前缀
app.use(router)

【6】为路由模块添加前缀

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

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

// 【1】导入路由模块
const router = require('./6Router')
// 【2】注册路由模块,为路由模块添加前缀
app.use('/api',router)

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

Express中间件

1.定义简单中间件函数

const mv = (req,res,next)=>{
    console.log('这是一个最简单的中间件函数')
    //必须在最后调用next()，表示把流转关系转交给一个中间件或路由
    next()
}

2. 全局生效的中间件和其【简化模式】

客户端发起的任何请求，到达服务器之后，都会触发的中间件，叫做全局生效的中间件。通过调用 app.use(中间件函数)，即可定义一个全局生效的中间件

const mv = function(req,res,next){
    console.log('这是最简单的中间件函数')
    next()
}
// 定义全局生效的中间件
app.use(mv)

//【简化模式】
app.use(function(req,res,next){
    console.log('这是简单模式定义的全局中间件')
    next()
})

3. 局部生效的中间件

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

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

// 定义中间件函数
const mw1 = (req,res,next)=>{
    console.log('调用了局部生效的中间件')
    next()
}
// 创建路由
app.get('/', mw1,(req,res)=>{
    res.send('Home page.')
})
app.get('/user', (req,res)=>{
    res.send('User page.')
})
//只有'/'这个路由器可以使用中间件函数，'/user'不可以使用

app.listen(80,function(){
    console.log('Express server running at http://127.0.0.1 ')
})

4.错误级别的中间件

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

const express = require('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(80,function(){
    console.log('http://127.0.0.1')
})

5.第三方的中间件

例如：body-parser

运行 npm install body-parser 安装中间件
使用 require 导入中间件
调用 app.use() 注册并使用中间件

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

// 【导入】body-parser中间件
const parser = require('body-parser')
// 【使用】app.use()注册中间件
app.use(parser.urlencoded({extended:false}))

app.post('/user',(req,res)=>{
    // 如果没有配置任何解析表单数据的中间件，则 req.body 默认等于 undefined
    console.log(req.body)
    res.send('ok')
})

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

6.自定义中间件

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

// 导入querystring模板
const qs= require('querystring')

// 【1】定义解析表单数据的中间件
const bodyParser = (req,res,next)=>{
    // 【2】监听req的data事件
    let str = ''
    req.on('data',(chunk)=>{
        str += chunk
    })
    // 【3】监听req的end事件
    req.on('end',()=>{
        // console.log(str)
        // 【4】调用qs.parse()方法，把查询字符串解析为对象
        const body = qs.parse(str)
        // 【5】将解析出来的数据对象挂载为req.body
        req.body = body
        next()
    })
}
module.exports = bodyParser

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

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

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

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

使用 Express 写接口

创建基本的服务器
创建 API 路由模块
编写 GET 接口
编写 POST 接口
CORS 解决跨域
创建 JSONP 接口的注意事项(必须在配置 CORS 中间件之前)

//【 1.创建基本的服务器】
const express = require('express')
const app = express()

// 配置解析表单数据的中间件
app.use(express.urlencoded({extended:false}))

//【6.】 必须在配置 cors 中间件之前，配置 JSONP 的接口
app.get('/api/jsonp', (req, res) => {
    // TODO: 定义 JSONP 接口具体的实现过程
    // 1. 得到函数的名称
    const funcName = req.query.callback
    // 2. 定义要发送到客户端的数据对象
    const data = { name: 'zs', age: 22 }
    // 3. 拼接出一个函数的调用
    const scriptStr = `${funcName}(${JSON.stringify(data)})`
    // 4. 把拼接的字符串，响应给客户端
    res.send(scriptStr)
})

// 【5】一定要在路由之前，配置cors这个中间件，从而解决接口跨域的问题
const cors =require('cors')
app.use(cors())

// 【2】导入路由模块
const router = require('./21apiRouter')
app.use('/api',router)


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

// 【2.创建 API 路由模块】
const express = require('express')
const router = express.Router()

// 在这里挂载对应的路由
// 【3】定义 GET 接口
router.get('/get',(req,res)=>{
    // 通过req.query获取客户端通过查询字符串，发送到服务器的数据
    const query =req.query
    // 调用res.send()方法，向客户端响应处理的结果
    res.send({
        status:0, //0 表示处理成功， 1表示处理失败
        msg:'GET请求成功', //状态的描述
        data:query, //需要响应给客户端的数据
    })
})
// 【4】定义POST接口
router.post('/post',(req,res)=>{
    // 通过req.body获取请求体中包含的url-encoded格式的数据
    const body = req.body
    // 调用res.send()方法，向客户端响应结果
    res.send({
        status:0,
        msg:'POST请求成功',
        data:body,
    })
})

// 定义DELETE接口
router.delete('/delete',(req,res)=>{
    res.send({
        status:0,
        mag:'DELETE请求成功',
    })
})

module.exports = router

Node.js(3)-Express