node koa常用属性、方法和常用中间件

╰半夏微凉° 2023-07-07 05:39 1阅读 0赞

> # request #
> 
> ### 常用API: ###
> 
> 例子：[http://localhost:4000/index?name=lxc&age=20][http_localhost_4000_index_name_lxc_age_20]
> 
> **ctx.request.query  ->** 获取简析的查询字符串，无则返回空对象  *\{ name: 'lxc', age: '20' \}*
> 
> **ctx.request.querystring  -> **获取原始查询字符串**  ***[name=lxc&age=20][http_localhost_4000_index_name_lxc_age_20]*
> 
> **ctx.request.url   ->  **获取请求的url  *[/index?name=lxc&age=20][http_localhost_4000_index_name_lxc_age_20]*
> 
> **ctx.request.path  ->  **获取path路径名  * /index*
> 
> **ctx.request.method  ->  **获取请求方法 * GET*
> 
> **ctx.request.host  ->  **获取主机 *localhost:4000*
> 
> **ctx.request.hostname  ->  **获取主机名 * localhost*
> 
> 例子：[http://localhost:4000/index][http_localhost_4000_index_name_lxc_age_20]/:id
> 
> **ctx.request.params->  **获取动态请求参数 * \{ id: xxx \}*
> 
> **ctx.request.header ->** 设置请求头 （等于ctx.request.headers）
> 
> **ctx.request.originalUrl ->** 获取原始的URL（与ctx.request.url 相同）
> 
> **ctx.request.href->** 获取完整的请求url    *[http://localhost:4000/index?name=lxc&age=20][http_localhost_4000_index_name_lxc_age_20]*
> 
> **ctx.request.search ->** 获取原始的查询字符串   *[?name=lxc&age=20][http_localhost_4000_index_name_lxc_age_20]*
> 
> **ctx.request.type ->** 获取请求的 content-type，不含 ‘charset’等参数  *application/json*
> 
> **ctx.request.protocol ->** 获取请求协议   *[http][http_localhost_4000_index_name_lxc_age_20] 或 [http][http_localhost_4000_index_name_lxc_age_20]s*
> 
> *post请求 \{username: 'lxc', password: '123456'\}*
> 
> **ctx.request.body->** 获取请求body  ( 前提需要安装koa-bodyparser )  *\{username: 'lxc', password: '123456'\}*

> ## ##
> 
> # response #
> 
> **ctx.response.status  ->  设置**响应状态（默认为404 - Not Found ,原生node的res.statusCode为200）
> 
> **ctx.response.header  ->  设置**响应头对象 （等于ctx.response.headers）
> 
> **ctx.response.body  ->   ** ，设置响应体内容  ===  ctx.body  可设置以下类型：
> 
> **· string ** *（Content-Type 默认为 `text/html` 或 `text/plain`, 同时默认字符集是 utf-8）*
> 
> **· Buffer** *（Content-Type 默认为 `application/octet-stream）`*
> 
> **· Stream管道 ** *** （**Content-Type 默认为 `application/octet-stream）`*
> 
> **· Object || Array** *（需要JSON.stringify( ) ，Content-Type 默认为 `application/json`）*
> 
> **· null 无响应内容**
> 
> *tips: 如果未设置ctx.response.status,koa自动设置状态为200或204*
> 
> **ctx.response.redirect( url, \[alt\] )->   ** 设置重定向 参数二可选
> 
> **ctx.response.set( 'key', 'value' )->   ** 设置响应头, 参数也可以是一个对象，设置多个响应头
> 
> **ctx.response.append( 'link', 'http://127.0.0.1' )->   ** 附加额外的消息头
> 
> **ctx.response.type = xxx ->   ** 设置响应的content-type 
> 
>     ctx.type = 'text/plain; charset=utf-8';
> 
>

# 实例属性： #

**app.context ** \-> 它就是创建ctx的原型，可以通过编辑app.context 为ctx添加属性或方法（就是在ctx的原型上添加属性）

> # 上下文： #
> 
> koa中的上下文封装了Request对象和Response对象，详情见koa源码或者我写的一个简易的koa：
> 
> [https://github.com/lvxingchenGit/LKoa][https_github.com_lvxingchenGit_LKoa]
> 
> **ctx.state -> 命名空间，传递信息的。**
> 
>     // eg:
>     ctx.state.user = await User.find(id)
> 
> **ctx.app -> 实例的引用（就是实例）**

> ### 多个中间件组合成单一中间件： ###
> 
> **koa-compose - 包**
> 
>     // npm i koa-compose --save
>     const compose = require('koa-compose')
>     async function m1(ctx, next){
>         console.log('1')
>         await next()
>     }
>     async function m2(ctx, next){
>         console.log('2')
>         await next()
>     }
>     async function m3(ctx, next){
>         console.log('3')
>         await next()
>     }
>     const all = componse([m1, m2, m3])
>     app.use(all) // 总之中间件最后需要挂载到app.use()中
> 
> **小案例：**
> 
> 前端请求 - 计算服务器响应时间
> 
>     app.use(async (ctx, next) => {
>         const prevTime = new Date().getTime()
>         await next()
>         const nowTime = new Date().getTime()
>         console.log('time:', nowTime - prevTime + 'ms') // 4ms
>         ctx.body = {
>             name: 'lxc'
>         }
>     })
>     app.use(async (ctx, next) => {
>         console.log('1')
>     })
> 
>

补充：

# koa中使用原生的node request对象、response对象,还有几个常用属性： #

*  ctx.request： koa 封装的 request 对象，中间件应该尽量使用
 *  ctx.req：Node.js 原生的 request 对象
 *  ctx.response：koa 封装的 response 对象，中间件应该尽量使用
 *  ctx.res：Node.js 原生的 response 对象
 *  ctx.state：koa 推荐的命名空间，用于通过中间件传递信息到前端视图
 *  ctx.app：对应用实例 app 的引用
 *

# 常用的koa中间件 #

** koa-bodyparser **

这个中间件可以将post请求的参数转为json格式返回。

koa接收到的post请求参数并不是json格式，我们需要将其转换为json  
**使用方法：**安装后直接在ctx.request.body内获取POST请求参数，中间件自动给我们解析为json

// 解析post请求中的参数
    const bdparser = require('koa-bodyparser')
    app.use(bdparser()) // 加载koa-bodyparser中间件

**koa-router**

// koaRouter.js 路由请求
    const Router= require('koa-router')
    const user = new Router({prefix: '/v1'}) // prefix 可在prefix定义公共前缀路径
    user.get('/user', ctx => {
        ctx.body = {
            err_code = 'OK'
        }
    })
    user.post('/addOne', ctx => {})
    module.exports = {
        user
    }
    // --------------------------------------------
    // app.js
    const koa = require('koa')
    const { user } = require('./koaRouter')
    const app = koa()
    app.use(user.routes())  // 加载user中间件

![20200221102940876.png][]

## ##

**nodemon**

// 自动加载服务: Terminal 运行:
    nodemon projectName.js

**require-directory**

// 自动查找文件夹 - 加载文件路径
    // 在项目开发过程中，往往各个路由模块会有多个文件，使用require 导入路由很麻烦，require-derectory可自动查找一个文件夹下的所有模块
    const requireDirectory = require('require-directory')
    const ABSOLUTE_URL = `${proccess.cwd()}/user`
    requireDirectory(module, ABSOLUTE_URL, {
                visit(){}
            })
    /**
    参数一：module 不需要修改
    参数二：要查找的文件夹，绝对路径,proccess.cwd()输出当前项目的绝对路径；
            __dirname：输出当前文件所在文件夹的绝对路径。
    参数三：对象options配置项，如下：
    */
    
    /**
    {
        include: /name+\.js/g, // 白名单，只加载符合条件的，可使用正则或函数（参数为path - 模块的绝对路径）
        // include 值也可以是一个函数，返回true表示符合加载条件：
        include(path) {
            if(/.+\.js$/g.test(path)) {
               return true
            }
        },
        exclude(path){ // 黑名单，不加载的模块
            return  /name+\.js/g.test(path) // 返回Boolean
        },
        visit(obj) { // 每个模块加载时执行的加载函数，参数为 module.exports 导出的模块
            app.use(obj) // 在这里边通常会把所有路由中间件挂载到app.use()中
        },
        rename: function(name) { // 重命名键名
            console.log(name) 会把所有的文件夹名及文件名打印出来！！！
            return name.toUpperCase()
        },
        recurse: true // 是否遍历文件夹，默认为true，嵌套文件夹下的模块也会被加载
    }
    */

### 封装自动导出路由文件 ###

const Router = require('koa-router')
    const requireDirectory = require('require-directory')
    const baseULR = process.cwd()
    
    class InitRouter {
        static InitRouterFn(app) {
            InitRouter.app = app
            InitRouter.runRouterMounting()
        }
        static runRouterMounting() {
            let whiteRulesReg = /.+\.js/g // 正则制定规则 - 哪些js文件可以导出
            requireDirectory(module, `${baseULR}/api`, {
                include(path) {
                    if(whiteRulesReg.test(path)) {
                        console.log('path', path) // 这里可以打印出符合匹配规则的文件路径
                        return true // 返回true为白名单；返回false为黑名单
                    }
                },
                visit(exportRouters) { // 兼容 module.exports = xxx 和 module.exports = {}
                    if(exportRouters instanceof Router) {
                        InitRouter.app.use(exportRouters.routes())
                    }else {
                        Object.keys(exportRouters).forEach(ele => {
                            if(exportRouters[ele] instanceof Router) {
                                InitRouter.app.use(exportRouters[ele].routes())
                            }
                        })
                    }
                }
            })
        }
    }
    // 导出类
    module.exports = {
        InitRouter
    }

[http_localhost_4000_index_name_lxc_age_20]: http://localhost:4000/index?name=lxc&age=20
[https_github.com_lvxingchenGit_LKoa]: https://github.com/lvxingchenGit/LKoa
[20200221102940876.png]: https://img-blog.csdnimg.cn/20200221102940876.png