• Express

    目录

    Express介绍

    测试最基本的服务器

    Express基本使用

    托管静态资源

    2. 挂载路径前缀 

    nodemon

    路由

    模块化路由 

    2.注册使用路由模块

    中间件的概念

    ​编辑1.next函数的作用

    2.app.use(全局中间件) 

    4.连续多个中间件

    5.局部生效中间件

     中间件的分类

    1.应用级别的中间件：绑定在路由上 

     2.路由级别的中间件：绑定在router上

    8.错误级别的中间件

    9.express内置的中间件

    例子：发送一组json数据

     自定义中间件

    监听前端请求不断传来的数据

    1，将解析出来的数据挂载到req.body上

     

    Express介绍

    测试最基本的服务器

    1. // 1.导入express
    2. const express=require('express')
    3.  
    4. // 2. 创建web服务器
    5. const app=express()
    6.  
    7. // 3. 启动web服务器
    8. app.listen(8080,()=>{
    9.     console.log('express server running at http://127.0.0.1:8080');
    10. })

    Express基本使用

    1.我们可以通过req.query得到客户端发送过来的查询参数 

    2.可以通过req.params得到url的动态参数

    1. //:id为动态参数
    2. app.get('/user/:id',(req,res){
    3.    console.log(req.params);
    4.    res.send(req.params);
    5. })

    1. // 1.导入express
    2. const express=require('express')
    3.  
    4. // 2. 创建web服务器
    5. const app=express()
    6.  
    7. // 4.监听客户端的GET和POST请求，并向客户端响应具体的内容
    8. app.get('/',(req,res)=>{
    9.     // 调用express提供的res.send()方法，向客户端发送 JSON 对象
    10.     res.send({
    11.         name:'zs',
    12.         age:20,
    13.         gender:'男'
    14.     })
    15.     
    16. })
    17.  
    18. app.post('/',(req,res)=>{
    19.     // 调用express提供的res.send()方法,向客户端响应一个文本字符串
    20.     res.send('请求成功')
    21. })
    22.  
    23. // 获取url中携带的查询参数
    24.  
    25. app.get('/',(req,res)=>{
    26.     /*
    27.          通过req.query可以获取到客户端发送过来的 查询参数
    28.             注意：默认情况下，req.query是一个空对象
    29.     */
    30.  
    31.     console.log(req.query);
    32.     res.send(req.query)
    33. })
    34.  
    35. /*
    36.     获取url中的动态参数，可以有多个动态参数
    37.         注意：这里的:id等是一个动态参数
    38. */
    39.  
    40. app.get('/user/:id/:username',(req,res)=>{
    41.     // req.params 是动态匹配到的URL参数，默认是一个空对象
    42.     console.log(req.params);
    43.     res.send(req.params)
    44.  
    45. })
    46.  
    47.  
    48. // 3. 启动web服务器
    49. app.listen(8080,()=>{
    50.     console.log('express server running at http://127.0.0.1:8080');
    51. })

    托管静态资源

    app.use(express.static('静态资源目录'))

    1. const express=require('express')
    2. const app=express()
    3.  
    4. //1.快速对外调用提供的外部资源
    5. app.use(express.static('./clock'))
    6.  
    7. app.listen(80,()=>{
    8.     console.log('express server running at http://127.0.0.1')
    9. })

    2. 挂载路径前缀 

    1. const express=require('express')
    2. const app=express()
    3.  
    4. //1.快速对外调用提供的外部资源
    5. app.use('/hearts',express.static('./clock'))
    6.  
    7. app.listen(80,()=>{
    8.     console.log('express server running at http://127.0.0.1')
    9. })

    nodemon

     nodemon能够监听项目文件的变动，帮助自动重启项目（热部署）

     1.全局安装nodemon

     npm i -g nodemon

    2.启动项目:（能够帮忙自动重启项目，相当于一个守护线程起到热部署的效果）

    nodemon xx.js

    路由

     2.Express中的路由

     

     3.路由的匹配过程

    1. const express=require('express')
    2.  
    3. const app=express()
    4.  
    5. //将路由挂载到app上
    6. app.get('/',(req,res)=>{
    7.     res.send('hello word')
    8. })
    9.  
    10. app.post('/',(req,res)=>{
    11.     res.send('Post request')
    12. })
    13.  
    14. app.listen(8080,()=>{
    15.     console.log('http://127.0.0.1:8080');
    16. })

    模块化路由 

    1.流程：将express创建的服务器app——>app进行监听但是并不挂载路由——>我们再创建一个路由模块，然后向外暴露即可（express.Router()）

    1. // 这是路由模块
    2.  
    3. // 1.导入express
    4. const express=require('express')
    5.  
    6. // 2.创建路由对象
    7. const router=express.Router()
    8.  
    9. // 3.挂在具体的路由
    10. router.get('/',(req,res)=>{
    11.     res.send('Get user list')
    12. })
    13. router.post('/',(req,res)=>{
    14.     res.send('Add new user')
    15. })
    16.  
    17. // 4.向外导出路由对象
    18. module.exports=router

    2.注册使用路由模块

    利用app.use()使用路由模块，这个路由就能正常生效

    app.use():注册全局中间件，第一个参数可以为全局统一的访问路径

    1. const express=require('express')
    2. const app=express()
    3.  
    4. // 1.导入路由模块
    5. const router=require('./03_router.js')
    6. // 2.注册路由模块 app.use()函数用来注册全局中间件
    7. app.use('/api',router)
    8.  
    9. app.listen(8080,()=>{
    10.     console.log('http://127.0.0.1:8080');
    11. })

    中间件的概念

    1.next函数的作用

     链式调用，实现多个中间件连续调用，把流转关系给到下一个中间件

    2.app.use(全局中间件) 

    1. const express=require('express')
    2. const app=express()
    3.  
    4. // 定义第一个全局中间件
    5. app.use((res,req,next)=>{
    6.     console.log('调用了第一个全局中间件');
    7.     next()
    8. })
    9.  
    10.  
    11. // 定义第二个全局中间件
    12. app.use((res,req,next)=>{
    13.     console.log('调用了第二个全局中间件');
    14.     next()
    15. })
    16.  
    17. app.get('/',(req,res)=>{
    18.     res.send('User page')
    19. })
    20.  
    21. app.listen(8080,()=>{
    22.     console.log('http://127.0.0.1:8080');
    23. })

     

     3.中间件的作用

    4.连续多个中间件

     

    1. const express=require('express')
    2. const app = express()
    3.  
    4. app.use((req,res,next)=>{
    5.     console.log('调用第一个全局中间件')
    6.     next()
    7. })
    8. app.use((req,res,next)=>{
    9.     console.log('调用第两个全局中间件')
    10.     next()
    11. })
    12. app.get('/user',(req,res)=>{
    13.     res.send('User page')
    14. })
    15. app.listen(8080,()=>{
    16.     console.log('http://127.0.0.1:8080');
    17. })

    5.局部生效中间件

    先是将结果给到我们的中间件，然后再传递给res，app.use()是中间件全局挂载，我们可以在请求中设置中间件

    1. const express=require('express')
    2. const app=express()
    3.  
    4. // 1.定义局部中间件函数
    5. const mw1=(req,res, next)=>{
    6.     console.log('调用了第一个局部生效中间件');
    7.     next()
    8. }
    9. const mw2=(req,res, next)=>{
    10.     console.log('调用了第二个局部生效中间件');
    11.     next()
    12. }
    13.  
    14. // 2.创建路由
    15. // mw1只在第一个app.get()中生效
    16. app.get('/',mw1,mw2,(req,res)=>{
    17.     res.send('home page')
    18. })
    19.  
    20. app.get('/user',(req,res)=>{
    21.     res.send('user page')
    22. })
    23.  
    24. app.listen(8080,()=>{
    25.     console.log('http://127.0.0.1:8080');
    26. })

     

     6.定义多个局部中间件

     中间件的分类

    1.应用级别的中间件：绑定在路由上 

     2.路由级别的中间件：绑定在router上

    1. // 这是路由模块
    2.  
    3. // 1.导入express
    4. const express=require('express')
    5.  
    6. // 2.创建路由对象
    7. const router=express.Router()
    8.  
    9. // 3.挂在具体的路由
    10. router.get('/',(req,res)=>{
    11.     res.send('Get user list')
    12. })
    13. router.post('/',(req,res)=>{
    14.     res.send('Add new user')
    15. })
    16.  
    17. // 4.向外导出路由对象
    18. module.exports=router
    1. const express=require('express')
    2. const app=express()
    3.  
    4. // 1.导入路由模块
    5. const router=require('./03_router.js')
    6. // 2.注册路由模块 app.use()函数用来注册全局中间件
    7. app.use('/api',router)
    8.  
    9. app.listen(8080,()=>{
    10.     console.log('http://127.0.0.1:8080');
    11. })

    8.错误级别的中间件

    利用中间件对错误进行拦截——>下面定义了一个全局中间件作为错误的拦截，发生错误就进入中间件进行捕获

    注意错误级别的中间件需要放在所有路由之后

    1. const express=require('express')
    2. const app=express()
    3.  
    4. // 定义路由
    5. app.get('/',(req,res)=>{
    6.     // 人为制造错误
    7.     throw new Error('人为制造错误')
    8.     res.send('homepage')
    9. })
    10.  
    11. // 错误级别中间件放在所有路由之后 
    12. // 定义错误级别中间件，捕获整个项目的异常错误，防止程序的崩溃
    13. app.use((err,req,res,next)=>{
    14.     console.log('发生了错误'+err.message);
    15.     res.send('error:'+err.message)
    16. })
    17.  
    18. app.listen(8080,()=>{
    19.     console.log('http://127.0.0.1:8080');
    20. })

    9.express内置的中间件

    例子：发送一组json数据

    在服务器我们可以用request.body去接收客户端传来的请求体数据

    需要配置一个express.json的中间件进行解析请求的json数据 

    1. const express=require('express')
    2. const app=express()
    3. //通过express.json()解析表单中的JSON格式数据
    4. app.use(express.json)
    5. app.post('/user',(req,res)=>{
    6.   //接收客户端传来的请求体数据
    7.   console.log(req,body)
    8.   res.send('OK')
    9. })

    例子2：定义express.urlencoded()中间件，来解析表单中url-encoded格式的数据

     例子3：解析表单对象

     自定义中间件

    监听前端请求不断传来的数据

    1. //1.导入模块
    2. const express=require('express')
    3. const app=express()
    4. //2.逻辑
    5. app.use((req,res,next)=>{
    6.    // 定义具体业务逻辑
    7.    let str=''
    8.    //监听req的data
    9.    req.on('data',(chunk)=>{
    10.     str+=chunk
    11.    })
    12.    //监听req的end事件
    13.    req.on('end',()=>{
    14.     console.log(str)
    15.    }) 
    16. })
    17.  
    18.  
    19.  
    20. //3.指定端口号并且启动web服务器
    21. app.listen(80,()=>{
    22.     console.log();
    23. })

    1，将解析出来的数据挂载到req.body上

    使用express内置的模块querystring——>parse(）将请求体数据解析为对象格式

     

    1. // 导致内置的querystring模块
    2. const qs=require('querystring')
    3.  
    4. const bodyParser=(req,res,next)=>{
    5.     // 1.定义str字符串，用来存储客户端发送过来的数据
    6.     let str=''
    7.     // 2.监听req的data时间
    8.     req.on('data',(chunk)=>{
    9.         str += chunk
    10.     })
    11.  
    12.     // 3.监听req对象的end事件(请求体发送完毕后自动触发)
    13.     req.on('end',()=>{
    14.         // 在str中存放的是完整的请求体数据据
    15.         // console.log(str);
    16.         // 把字符串格式的请求体数据，解析成为对象格式
    17.         const body=qs.parse(str)
    18.         req.body=body
    19.         next()
    20.     })
    21. }
    22.  
    23. module.exports=bodyParser

    引入自己封装的中间件模块

    1. const express = require("express");
    2. const app=express()
    3. // 1.导入自己封装的中间件模块
    4. const customBodyParser=require('./10_拆分自定义中间件')
    5. // 2.将自定义的中间件函数，注册为全局可用的中间件
    6. app.use(customBodyParser)
    7.  
    8. app.get('/',(req,res)=>{
    9.     res.send(req.body)
    10. })
    11.  
    12. app.listen(8080,()=>{
    13.     console.log('Express server running st http://127.0.0.1:8080');
    14. })

  • 相关阅读:
    宇宙始终处于完美状态
    使用Tomcat Maven插件产生的疑惑
    SpringBoot开发之Spring基础
    Python是信奥的基础吗，学习信奥要不要先学python
    【毕业设计】单片机 宠物自动喂食系统 - stm32 物联网 嵌入式
    mysql日志
    数据仓库的设计开发应用（三）
    使用ASM修改组件化 ARouter
    app拉新渠道整合 一手地推、网推拉新平台整理
    OSI模型与数据的封装
  • 原文地址：https://blog.csdn.net/weixin_57128596/article/details/127857917