Koa - 中间件

前言

Koa 应用程序是一个包含一组中间件函数的对象,它是按照类似堆栈的方式组织和执行的。

当一个中间件调用 next() 则该函数暂停并将控制传递给定义的下一个中间件。当在下游没有更多的中间件执行后,堆栈将展开并且每个中间件恢复执行其上游行为。

以上两句话,是我在官方文档中找到其对 Koa 中间件的描述。

在Koa中,中间件是一个很有意思的设计,它处于request和response中间,被用来实现某种功能。像上篇文章所使用的 koa-router 、koa-bodyparser 等都是中间件。

可能有些人喜欢把中间件理解为插件,但我觉得它们两者并不是同一种概念的东西。插件像是一个独立的工具,而中间件更像是流水线,将加工好的材料继续传递下一个流水线。所以中间件给我的感觉更灵活,可以像零件一样自由组合。

单看中间件有堆栈执行顺序的特点,两者就出现质的区别。

中间件的概念

这张图是 Koa 中间件执行顺序的图示,被称为“洋葱模型”。

中间件按照栈结构的方式来执行,有“先进后出“的特点。

一段简单的代码来理解上图:

app.use(async (ctx, next)=
   console.log(‘--> 1‘)
   next()
   console.log(‘<-- 1‘)
})

app.use(async (ctx, next)=>{
   console.log(‘--> 2‘)
   //这里有一段异步操作
   await  new Promise((resolve)=>{
       ....
   })
   await  next()
   console.log(‘<-- 2‘)
})

app.use(async (ctx, next)=>{
   console.log(‘--> 3‘)
   next()
   console.log(‘<-- 3‘)
})  
app.use(async (ctx, next)=>{
   console.log(‘--> 4‘)
}) 

当我们运行这段代码时,得到以下结果

--> 1

--> 2

--> 3

--> 4

<-- 3

<-- 2

<-- 1

中间件通过调用 next 一层层执行下去,直到没有执行权可以继续传递后,在以冒泡的形式原路返回,并执行 next 函数之后的行为。可以看到 1 第一个进去,却是最后一个出来,也体现出中间件栈执行顺序的特点。

在第二个中间件有一段异步操作,所以要加上await,让执行顺序按照预期去进行,否则可能会出现一些小问题。

中间件的使用方式

1.应用中间件

const Koa = require(‘koa‘);
const Router = require(‘koa-router‘);

const app = new Koa();
const router = new Router();
app.use(async (ctx,next)=>{
    console.log(new Date());
    await next();
})
router.get(‘/‘, function (ctx, next) {
    ctx.body="Hello koa";
})
router.get(‘/news‘,(ctx,next)=>{
    ctx.body="新闻页面"
});
app.use(router.routes()); //作用:启动路由
app.use(router.allowedMethods()); //作用: 当请求出错时的处理逻辑
app.listen(3000,()=>{
    console.log(‘starting at port 3000‘);
});

2.路由中间件

router.get(‘/‘, async(ctx, next)=>{
    console.log(1)
    next()
})
router.get(‘/‘, function (ctx) {
    ctx.body="Hello koa";
})

3.错误处理中间件

app.use(async (ctx,next)=> {
    next();
    if(ctx.status==404){
        ctx.status = 404;
        ctx.body="这是一个404页面"
    }
});

4.第三方中间件

const bodyParser = require(‘koa-bodyparser‘);
app.use(bodyParser());

实现验证token中间件

实现一个基于 jsonwebtoken 验证token的中间件,这个中间件由两个文件组成 extractors.js 、index.js,并放到check-jwt文件夹下。

生成token

const Router = require(‘koa-router‘)
const route = new Router()
const jwt = require(‘jsonwebtoken‘)

route.get(‘/getToken‘, async (ctx)=>{
    let {name,id} = ctx.query
    if(!name && !id){
        ctx.body = {
            msg:‘不合法‘,
            code:0
        }
        return
    }
    //生成token
    let token = jwt.sign({name,id},‘secret‘,{ expiresIn: ‘1h‘ })
    ctx.body = {
        token: token,
        code:1
    }
})

module.exports = route

使用 jwt.sign 生成token:

第一个参数为token中携带的信息;

第二个参数为key标识(解密时需要传入该标识);

第三个为可选配置选项,这里我设置过期时间为一小时;

详细用法可以到npm上查看。

使用中间件

app.js:

const {checkJwt,extractors} = require(‘./check-jwt‘)

app.use(checkJwt({
  jwtFromRequest: extractors.fromBodyField(‘token‘), secretOrKeyL: ‘secret‘,
  safetyRoutes: [‘/user/getToken‘]
}))
  是否必选 接收类型 备注
jwtFromRequest 函数
默认验证 header 的 authorization

extractors提供的提取函数,支持get、post、header方式提取

这些函数都接收一个字符串参数(需要提取的key)

对应函数:

fromUrlQueryParameter、

fromBodyField、

fromHeader

secretOrKey 字符串 与生成token时传入的标识保持一致
safetyRoutes 数组 不需要验证的路由

使用该中间件后,会对每个路由都进行验证

路由中获取token解密的信息

route.get(‘/getUser‘, async ctx=>{
    let {name, id} = ctx.payload
    ctx.body = {
        id,
        name,
        code:1
    }
})

通过ctx.payload来获取解密的信息

实现代码

extractors.js 工具函数(用于提取token)

let extractors = {}

extractors.fromHeader = function(header_name=‘authorization‘){
    return function(ctx){
        let token   = null,
            request = ctx.request;
        if (request.header[header_name]) {
            token = header_name === ‘authorization‘ ?
            request.header[header_name].replace(‘Bearer ‘, ‘‘) :
            request.header[header_name];
        }else{
            ctx.body = {
                msg: `${header_name} 不合法`,
                code: 0
            }
        }
        return token;
    }
}

extractors.fromUrlQueryParameter = function(param_name){
    return function(ctx){
        let token   = null,
            request = ctx.request;
        if (request.query[param_name] && Object.prototype.hasOwnProperty.call(request.query, param_name)) {
            token = request.query[param_name];
        }else{
            ctx.body = {
                msg: `${param_name} 不合法`,
                code: 0
            }
        }
        return token;
    }
}

extractors.fromBodyField = function(field_name){
    return function(ctx){
        let token   = null,
            request = ctx.request;
        if (request.body[field_name] && Object.prototype.hasOwnProperty.call(request.body, field_name)) {
            token = request.body[field_name];
        }else{
            ctx.body = {
                msg: `${field_name} 不合法`,
                code: 0
            }
        }
        return token;
    }
}

module.exports = extractors

index.js  验证token

const jwt = require(‘jsonwebtoken‘)
const extractors = require(‘./extractors‘)

/**
 *
 * @param {object} options
 *    @param {function} jwtFromRequest
 *    @param {array} safetyRoutes
 *    @param {string} secretOrKey
 */

function checkJwt({jwtFromRequest,safetyRoutes,secretOrKey}={}){
    return async function(ctx,next){
        if(typeof safetyRoutes !== ‘undefined‘){
            let url = ctx.request.url
            //对安全的路由 不验证token
            if(Array.isArray(safetyRoutes)){
                for (let i = 0, len = safetyRoutes.length; i < len; i++) {
                    let route = safetyRoutes[i],
                        reg = new RegExp(`^${route}`);
                    //若匹配到当前路由 则直接跳过  不开启验证
                    if(reg.test(url)){
                        return await next()
                    }
                }
            }else{
                throw new TypeError(‘safetyRoute 接收类型为数组‘)
            }
        }
        if(typeof secretOrKey === ‘undefined‘){
            throw new Error(‘secretOrKey 为空‘)
        }
        if(typeof jwtFromRequest === ‘undefined‘){
            jwtFromRequest = extractors.fromHeader()
        }
        let token = jwtFromRequest(ctx)
        if(token){
            //token验证
            let err = await new Promise(resolve=>{
                jwt.verify(token, secretOrKey,function(err,payload){
                    if(!err){
                        //将token解码后的内容 添加到上下文
                        ctx.payload = payload
                    }
                    resolve(err)
                })
            })
            if(err){
                ctx.body = {
                    msg: err.message === ‘jwt expired‘ ? ‘token 过期‘ : ‘token 出错‘,
                    err,
                    code:0
                }
                return
            }
            await next()
        }
    }
}

module.exports = {
    checkJwt,
    extractors
}

Demo: https://gitee.com/ChanWahFung/koa-demo

原文地址:https://www.cnblogs.com/chanwahfung/p/11427205.html

时间: 2024-11-08 10:09:49

Koa - 中间件的相关文章

koa中间件分析

转载请注明: TheViper http://www.cnblogs.com/TheViper  另外可以参考http://purplebamboo.github.io/2014/05/24/koa-source-analytics-3/,作者用简单的方式造了一个山寨koa. koa是什么? koa是从2013年11月开始发布,更新的.和express相比,koa太年轻了.但它(用文档上的话说)通过组合不同的 generator,可以免除重复繁琐的回调函数嵌套,并极大地提升常用错误处理效率.Ko

KOA中间件实现原理

1 //基本原理 2 var empty=(function *(){})(); 3 //中间件3 4 var mid2=function *(){ 5 console.log("2:before yield"); 6 yield empty; 7 console.log("2:after yield"); 8 } 9 //中间件2 10 var mid1=function *(){ 11 console.log("1:before yield"

Koa中间件(middleware)级联原理

前言 上次看到了koa-compose的代码,今天来说一下koa中间件的级联以及工作原理. 中间件工作原理 初始化koa实例后,我们会用use方法来加载中间件(middleware),会有一个数组来存储中间件,use调用顺序会决定中间件的执行顺序. 每个中间件都是一个函数(不是函数将报错),接收两个参数,第一个是ctx上下文对象,另一个是next函数(由koa-compose定义) 在建立好http服务器后,会调用koa-compose模块对middleware中间件数组进行处理.具体代码这里就

koa中间件实现分析

最近团队内部做了一个web app,用koa做服务端,一直对他中间件实现很感兴趣,对他的源码研究之后,写了一份简化版本的中间件实现.代码除了用到ES6的Generator和Promise,没有用到其他三方库,总共不到一百行,希望能帮助大家理解! 'use strict'; var middleware = []; //向数据库请求数据 var getDataPromise = new Promise(function(resolve,reject){ setTimeout(function(){

傻瓜式解读koa中间件处理模块koa-compose

最近需要单独使用到koa-compose这个模块,虽然使用koa的时候大致知道中间件的执行流程,但是没仔细研究过源码用起来还是不放心(主要是这个模块代码少,多的话也没兴趣去研究了). koa-compose看起来代码少,但是确实绕.闭包,递归,Promise...看了一遍脑子里绕不清楚.看了网上几篇解读文章,都是针对单行代码做解释,还是绕不清楚.最后只好采取一种傻瓜的方式: koa-compose去掉一些注释,类型校验后,源码如下: function compose (middleware) {

nextjs作为koa中间件的使用

react客户端渲染的缺点:首屏速度慢,对SEO不友好 浏览器请求步骤                                                        客户端跳转 1. 浏览器发起请求 /index                                           1.  点击按钮 2. koa接受请求,并且调用nextjs                                 2. 异步加载组件的js 3. nextjs开始渲染   

koa2入门--03.koa中间件以及中间件执行流程

//中间件:先访问app的中间件的执行顺序类似嵌套函数,由外到内,再由内到外 //应用级中间件 const koa = require('koa'); var router = require('koa-router')(); var app = new koa(); //匹配任意路由之前打印日期 app.use(async (ctx,next)=>{ console.log(new Date()); await next(); }); router.get('/',async (ctx)=>

koa 中间件 koa-art-template 的使用

例子 const Koa = require('koa'); const render =require('koa-art-template'); const path= require('path'); //创建服务器 const app=new Koa(); //渲染 render(app, { root: path.join(__dirname, 'view'), extname: '.html', debug: process.env.NODE_ENV !== 'production'

koa中间件

function pv(ctx){ global.console.log(ctx.path); } module.exports=function(){ return async function(ctx,next){ pv(ctx); await next(); //next是继续执行下面的中间件,如果不写会直接跳出,不会继续执行 } } //app.js const pv = require('./middleware/koa-pv'); app.use(pv()) 原文地址:https:/