koa源码阅读[2]-koa-router

其3篇,有关koa生态中比较重要的1当中间件:koa-router

第一篇:koa源码阅读-0
第二篇:koa源码阅读-一-koa与koa-compose

Koa
应用程序是三个涵盖一组中间件函数的对象,它是根据类似货仓的秘诀组织和实施的。


此种类文章会不停革新。。。

koa-router是什么

率先,因为koa是三个管理中间件的阳台,而注册三个中间件使用use来执行。
无论什么请求,都会将具有的中间件实施三次(即使未有中途结束的话)
之所以,那就能够让开荒者很麻烦,要是我们要做路由该怎么写逻辑?

app.use(ctx => {
  switch (ctx.url) {
    case '/':
    case '/index':
      ctx.body = 'index'
      break
    case 'list':
      ctx.body = 'list'
      break
    default:
      ctx.body = 'not found'
  }
})

 

确实,那样是贰个简练的办法,不过毫无疑问不适用于大型项目,数10个接口通过三个switch来决定未免太繁琐了。
再者说请求恐怕只支持get或者post,以及那种办法并不能够很好的支持ULacrosseL中涵盖参数的央求/info/:uid
express中是不会有那样的标题标,自己已经提供了getpost等等等的与METHOD同名的函数用来注册回调:
express

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

app.get('/', function (req, res) {
  res.send('hi there.')
})

 

但是koa做了无数的简练,将众多逻辑都拆分出来作为独立的中间件来存在。
因而导致众多express品种搬迁为koa时,需求卓殊的安装一些中间件,koa-router相应算得最常用的贰个。
所以在koa中则需求卓殊的装置koa-router来达成类似的路由功用:
koa

const Koa = require('koa')
const Router = require('koa-router')

const app = new Koa()
const router = new Router()

router.get('/', async ctx => {
  ctx.body = 'hi there.'
})

app.use(router.routes())
  .use(router.allowedMethods())

 

看起来代码确实多了1部分,终归将过多逻辑都从框架之中转移到了中间件中来管理。
也毕竟为了保全2个简练的koa框架所取舍的一些东西吗。
koa-router的逻辑确实要比koa的繁杂一些,可以将koa想象为一个市面,而koa-router则是个中3个小摊
koa仅须求保障市镇的身布帆无恙康运维,而真正和买主打交道真的是在里头摆摊的koa-router

那是 koa 对友好的牵线,别的 koa 注重的库其实都能够算是中间件,koa-router
也不例外。

使用体验

那篇首要讲 koa二 的路由

koa-router的大概结构

koa-router的组织并不是很复杂,也就分了多个文件:

.
├── layer.js
└── router.ja

 

layer重大是对准有的新闻的包裹,首要路基由router提供:

tag desc
layer 信息存储:路径、METHOD、路径对应的正则匹配、路径中的参数、路径对应的中间件
router 主要逻辑:对外暴露注册路由的函数、提供处理路由的中间件,检查请求的URL并调用对应的layer中的路由处理

ps: 本文代码中的粤语表明是对代码的讲课,省略号(…)代表省略部分代码
小说最终有简版router的门类地址

koa

const Koa = require('koa');
const app = new Koa();
app.use(ctx => {
   ctx.body = 'Hello Koa';
 });
app.listen(3000);

首先,我们先用 koa二 原生实现3个大致的路由然后再使用 koa-router
中间件深切学习,学路由自然先从 UHavalL 入手,请看上边包车型客车例子

koa-router的运作流程

能够拿上面所抛出的基本例子来证实koa-router进修笔记,koa源码阅读。是什么样的三个推行流程:

const router = new Router() // 实例化一个Router对象

// 注册一个路由的监听
router.get('/', async ctx => {
  ctx.body = 'hi there.'
})

app
  .use(router.routes()) // 将该Router对象的中间件注册到Koa实例上,后续请求的主要处理逻辑
  .use(router.allowedMethods()) // 添加针对OPTIONS的响应处理,一些预检请求会先触发 OPTIONS 然后才是真正的请求

 

对 koa-router 的猜想

经过 koa 最简便的 hellow world 例子能够看出原生对请求的处理形式:

const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  ctx.body = 'Hello World';
});

app.listen(3000);

要是我们想大概的兑现路由的话,能够加上一些剖断标准

app.use(async ctx => {
  if (ctx.path === '/one' && ctx.method === 'get') {
    ctx.body = 'Hello World';
  } else {
    ctx.status = 404;
    ctx.body = '';
  }
});

那样的话能落到实处轻巧对路由的得以达成,不过路由愈来愈多的话消耗的性质也就越大,而且不轻便对新鲜路由增添中间件。而更加好的章程是采纳面向对象的措施,依照请求的
path 和 method 重临相应的中间件管理函数和试行函数。

express

const app = require("express")();
app.use((req,res,next)=>{
    res.status(200).send("<h1>headers ...</h1>");
});
app.listen(3001);

注意:本文全部利用es陆语法编写,假如条件不帮忙请自行进级node或许选用babel进行转码。

const koa = require('koa');
const fs = require('fs');
const app = new koa();

app.use(ctx => {
    console.log(ctx.request.url);
});

app.listen(3000);

创设实例时的一些事务

首先,在koa-router实例化的时候,是可以传递三个布置项参数作为起初化的布局消息的。
只是那一个布局项在readme中只是简短的被描述为:

Param Type Description
[opts] Object  
[opts.prefix] String prefix router paths(路由的前缀)

告知大家得以增添一个Router注册时的前缀,也正是说假使依照模块化分,能够不用在每一个路径相称的前端都增加巨长的前缀:

const Router = require('koa-router')
const router = new Router({
  prefix: '/my/awesome/prefix'
})

router.get('/index', ctx => { ctx.body = 'pong!' })

// curl /my/awesome/prefix/index => pong!

 

P.S.
可是要铭记在心,如果prefix/最终,则路由的挂号就足以省去前缀的/了,不然会并发/重复的景况

实例化Router时的代码:

function Router(opts) {
  if (!(this instanceof Router)) {
    return new Router(opts)
  }

  this.opts = opts || {}
  this.methods = this.opts.methods || [
    'HEAD',
    'OPTIONS',
    'GET',
    'PUT',
    'PATCH',
    'POST',
    'DELETE'
  ]

  this.params = {}
  this.stack = []
}

 

足见的唯有2个methods的赋值,不过在翻看了别样源码后,发掘除了prefix再有一些参数是实例化时传递进入的,但是不太驾驭怎么文书档案中从不涉及:

Param Type Default Description
sensitive Boolean false 是否严格匹配大小写
strict Boolean false 如果设置为false则匹配路径后边的/是可选的
methods Array[String] ['HEAD','OPTIONS','GET','PUT','PATCH','POST','DELETE'] 设置路由可以支持的METHOD
routerPath String null  

解读思路

那边要介绍下自家解读 koa-router 源码的法子,小编会先把 koa-router
的源码下载到本地,然后通读一遍(因为源码算是比较少的),从概略上上明白koa-router 实施流程,然后经过单元测试去 debug 分析。

初始方式

  1. koa采用了new Koa()的不2诀要,而express选拔古板的函数方式,比较源码如下:

//koa
const Emitter = require('events');
module.exports = class Application extends Emitter {
...
}
//express
exports = module.exports = createApplication;
function createApplication() {
...
}

能够看看koa@贰选拔了es6的语法落成,承袭了Emitter类,具体信息能够参照Emitter说明。那就表示koa@一头能在es陆上述的遭逢下运转,低版本能够思量选用koa@1.x。而express则比较古板,使用的是function的样式导出。

  1. 中间件格局2者不一致,那是由两岸管理中间件的逻辑差距导致的,实际上那也是三头最根本的异样,具体的辨析留作后边举办自己检查自纠,这里关键比较两者的选用上的差异,如下所示:

当大家进入
http://localhost:3000/index
地址时能够发掘 Iterm 中打字与印刷出了 /index 表明大家得以由此ctx.request.url 属性得到 U昂科拉L
的渠道,那样大家就可以使用这么些渠道找到相应的页面落成路由。

sensitive

假定设置了sensitive,则会以更严谨的合作规则来监听路由,不会忽略UQashqaiL中的大小写,完全依照注册时的来合营:

const Router = require('koa-router')
const router = new Router({
  sensitive: true
})

router.get('/index', ctx => { ctx.body = 'pong!' })

// curl /index => pong!
// curl /Index => 404

 

Router 实行流程图

金沙注册送58 1

koa-router 流程.png

自小编认为 koa-router 最大旨且基本的API有七个:

  1. router.match
    能够依照请求的 path 和 method 筛选出合营的 route
  2. router.register
    注册 route
  3. router.routes
    归来用于 koa 加载的中间件,通过 koa-compose 将middlewares
    压缩成3个函数
  4. router.method(get、post等)
    能够依照path、method 定义 router,并且能够将middleware绑定在路由上

express处理伍在那之中间件

const app = require("express")();
app.use((req,res,next)=>{
    console.log("first");
    //next();
});
app.use((req,res,next)=>{
    console.log("second");
    //next();
});
app.use((req,res,next)=>{
    console.log("third");
    res.status(200).send("<h1>headers ...</h1>");
});
app.listen(3001);

若果写成这么,终端只会打印出first,而且不会反悔,前端请求会直接等候到过期,导致那壹标题标来由是:express必须积极调用next()技能让中间价继续施行,松手注释就可以。那也保险了我们能够独立决定什么响应请求。

下边落成2个简约的路由,文件目录如下

strict

strictsensitive功能周边,也是用来设置让路线的合作变得愈加严苛,在默许情状下,路线结尾处的/是可选的,假诺翻开该参数以往,假使在注册路由时尾巴部分未有增进/,则相称的路由也必将不可见增添/结尾:

const Router = require('koa-router')
const router = new Router({
  strict: true
})

router.get('/index', ctx => { ctx.body = 'pong!' })

// curl /index  => pong!
// curl /Index  => pong!
// curl /index/ => 404

 

解读

大家得以结合代码和单元测试对源码进行驾驭,由最简便易行的测试开头debug:

it('router can be accecced with ctx', function (done) {
      var app = new Koa();
      var router = new Router();
      router.get('home', '/', function (ctx) {
          ctx.body = {
            url: ctx.router.url('home')
          };
      });

      console.log(router.routes()); // 这是我加的,查看最后加载的routes
      app.use(router.routes());
      request(http.createServer(app.callback()))
          .get('/')
          .expect(200)
          .end(function (err, res) {
              if (err) return done(err);
              expect(res.body.url).to.eql("/");
              done();
          });
  });

router.routes() 返回:

function dispatch(ctx, next) {
    debug('%s %s', ctx.method, ctx.path);
    var path = router.opts.routerPath || ctx.routerPath || ctx.path;
    var matched = router.match(path, ctx.method);
    var layerChain, layer, i;
    ...
    ctx.router = router;
    if (!matched.route) return next();
    // 获取已匹配的 routes (实例化 Layer 对象)
    var matchedLayers = matched.pathAndMethod
    ...
    // 若匹配了多个 route,则将多个执行函数 push 进一个数组
    layerChain = matchedLayers.reduce(function(memo, layer) {
      ...
      return memo.concat(layer.stack);
    }, []);

    return compose(layerChain)(ctx, next);
  }

router.routes() 再次来到贰个 dispatch 函数,从中能够观看请求进来会经过
router.match(前边有分析),然后将同盟到的 route 的执行函数 push
进数组,并透过 compose(koa-compose) 函数合并重返。

下一场在打印出 compose(layerChain)
方法,能够看到实际聊起底呼吁实践的函数是对ctx.body = {url: ctx.router.url('home')};
的 compose 封装函数,在功用上一定于

app.use(ctx => {
  ctx.body = {
    url: ctx.router.url('home')
  };
});
  • Router 构造函数

function Router(opts) {
  if (!(this instanceof Router)) {
    return new Router(opts);
  }

  this.opts = opts || {};
  // 定义各方法
  this.methods = this.opts.methods || [
    'HEAD',
    'OPTIONS',
    'GET',
    'PUT',
    'PATCH',
    'POST',
    'DELETE'
  ];

  this.params = {};
  // 初始化定义 route 栈
  this.stack = [];
};
  • 分析 router.method 方法

// methods ['get', 'post', 'delete', 'put', 'patch', ...]
methods.forEach(function (method) {
  Router.prototype[method] = function (name, path, middleware) {
    var middleware;

    if (typeof path === 'string' || path instanceof RegExp) {
      // 若第二个参数是 string 或 正则表达式,则将后面的参数归为 middleware
      middleware = Array.prototype.slice.call(arguments, 2);
    } else {
      // 否则说明没有传 name 参数,将第一个参数置为path,之后的参数归为 middleware
      middleware = Array.prototype.slice.call(arguments, 1);
      path = name;
      name = null;
    }

    // 注册 route(下面会讲到 register 方法)
    this.register(path, [method], middleware, {
      name: name
    });

    // 返回 Router 对象,可以链式调用
    return this;
  };
});
  • 分析 router.register 方法

Router.prototype.register = function (path, methods, middleware, opts) {
  opts = opts || {};

  var stack = this.stack;
  ...
  // create route
  // 实例化一个 Layer 对象,Layer 对象将 path 转为 regexp,并增加了匹配 path 的可选 ops 参数
  var route = new Layer(path, methods, middleware, {
    end: opts.end === false ? opts.end : true,
    name: opts.name,
    sensitive: opts.sensitive || this.opts.sensitive || false,
    strict: opts.strict || this.opts.strict || false,
    prefix: opts.prefix || this.opts.prefix || "",
    ignoreCaptures: opts.ignoreCaptures
  });

  console.log(route);
  /**
   * Layer {
   * ...省略部分属性
   * methods: [ 'HEAD', 'GET' ],
   * stack: [ [Function] ],
   * path: '/',
   * regexp: { /^(?:\/(?=$))?$/i keys: [] } } // 用于匹配 path
   */
  ...
  // 将注册的 route 存放在 stack 队列中
  stack.push(route);

  return route;
};

register 方法首要用于实例化 Layer 对象,并帮忙多各 path
同时登记、增多路由前缀等作用(体今世码忽略)。

  • 分析 router.match

Router.prototype.match = function (path, method) {
  // 获取已经注册的 routes (实例化Layer对象)
  var layers = this.stack;
  var layer;
  var matched = {
    path: [],
    pathAndMethod: [],
    route: false
  };

  // 循环查找能够匹配的route
  for (var len = layers.length, i = 0; i < len; i++) {
    layer = layers[i];

    debug('test %s %s', layer.path, layer.regexp);

    // 根据layer.regexp.test(path) 匹配
    if (layer.match(path)) {
      matched.path.push(layer);

      // todo ~操作符暂时没懂
      if (layer.methods.length === 0 || ~layer.methods.indexOf(method)) {
        matched.pathAndMethod.push(layer);
        // 将匹配标志 route 设为 true,这里我觉得改为 hitRoute 更容易理解
        if (layer.methods.length) matched.route = true;
      }
    }
  }

  return matched;
};

koa管理两当中间件

const Koa = require('koa');
const app = new Koa();
app.use((ctx,next) => {
   ctx.body = 'Hello Koa-1';
   next();
 });
 app.use((ctx,next) => {
   ctx.body = 'Hello Koa-2';
   next();
 });
 app.use((ctx,next) => {
   ctx.body = 'Hello Koa-3';
   next();
 });
app.listen(3000);

与express类似,koa中间件的入参也有七个,后2个正是next。next的效应与express同样,这里不再赘述。

地方介绍了koa的next()的功能,这里的next()要求共同调用,千万不要采纳异步调用,不要写成上面包车型客车花样,那样也等于未调用next(),具体原因前边源码部分会分析:

    app.use((ctx,next) => {
   ctx.body = 'Hello Koa-2';
   setTimeout(()=>next(),3000);
   //next();
 });

纵然上边分析了两边的应用逻辑不雷同,但是出于koa在入参处给出了context,而该结构体蕴含了笔者们回去请求的具备消息,所以大家还是能够写出下边包车型地铁代码:

const Koa = require('koa');
const app = new Koa();

app.use((ctx)=>{
    const res = ctx.res;
    res.writeHead(200, {'Content-Type': 'text/html;charset=utf-8','Accept-Language':'zh-CN,zh;q=0.8,en;q=0.6'});
    res.end('<h1>标题</h1>');
});

// response
 app.use(ctx => {
   ctx.body = 'Hello Koa';
 });
app.listen(3000);

这么的逻辑就和express很类似了,原理也百折不挠。那样写今后,前端的央浼获得的结果就是<h1>标题</h1>,而继续的app.use实质上并不曾拿走实行。

.
├── index.js
├── package.json
└── view
    ├── 404.html
    ├── index.html
    └── todo.html

methods

methods配备项存在的意思在于,假设大家有二个接口供给同时支持GETPOSTrouter.getrouter.post如此的写法必然是丑陋的。
据此大家恐怕会想到利用router.all来简化操作:

const Router = require('koa-router')
const router = new Router()

router.all('/ping', ctx => { ctx.body = 'pong!' })

// curl -X GET  /index  => pong!
// curl -X POST /index  => pong!

 

那几乎是太周密了,能够很自在的落到实处大家的必要,但是假使再多实验一些其它的methods日后,狼狈的专门的职业就时有产生了:

> curl -X DELETE /index  => pong!
> curl -X PUT    /index  => pong!

 

那鲜明不是切合大家预料的结果,所以,在那种状态下,基于最近koa-router亟需展开如下修改来兑现大家想要的机能:

const Koa = require('koa')
const Router = require('router')

const app = new Koa()
// 修改处1
const methods = ['GET', 'POST']
const router = new Router({
  methods
})

// 修改处2
router.all('/', async (ctx, next) => {
  // 理想情况下,这些判断应该交由中间件来完成
  if (!~methods.indexOf(ctx.method)) {
    return await next()
  }

  ctx.body = 'pong!'
})

 

那般的两处改换,就可以实现大家所梦想的功用:

> curl -X GET    /index  => pong!
> curl -X POST   /index  => pong!
> curl -X DELETE /index  => Not Implemented
> curl -X PUT    /index  => Not Implemented

 

小编个人认为那是allowedMethods达成的3个逻辑难点,然则恐怕是本身未有get到小编的点,allowedMethods中比较关键的局地源码:

Router.prototype.allowedMethods = function (options) {
  options = options || {}
  let implemented = this.methods

  return function allowedMethods(ctx, next) {
    return next().then(function() {
      let allowed = {}

      // 如果进行了ctx.body赋值,必然不会执行后续的逻辑
      // 所以就需要我们自己在中间件中进行判断
      if (!ctx.status || ctx.status === 404) {
        if (!~implemented.indexOf(ctx.method)) {
          if (options.throw) {
            let notImplementedThrowable
            if (typeof options.notImplemented === 'function') {
              notImplementedThrowable = options.notImplemented() // set whatever the user returns from their function
            } else {
              notImplementedThrowable = new HttpError.NotImplemented()
            }
            throw notImplementedThrowable
          } else {
            ctx.status = 501
            ctx.set('Allow', allowedArr.join(', '))
          }
        } else if (allowedArr.length) {
          // ...
        }
      }
    })
  }
}

 

首先,allowedMethods是用作三个前置的中间件存在的,因为在回去的函数中先调用了next,其次才是针对METHOD的论断,而那般拉动的2个结果正是,借使大家在路由的回调中开始展览类似ctx.body = XXX的操作,实际上会修改这一次请求的status值的,使之并不会成为404,而马尘不及精确的触发METHOD反省的逻辑。
想要准确的触发METHOD逻辑,就须求自身在路由监听中手动判别ctx.method是或不是为我们想要的,然后在跳过当前中间件的实行。
而那壹判定的步骤实际上与allowedMethods中间件中的!~implemented.indexOf(ctx.method)逻辑完全是重新的,不太领会koa-router为啥会如此处理。

当然,allowedMethods是无法作为3个放置中间件来存在的,因为一个Koa中可能会挂在四个RouterRouter中间的配置恐怕不尽同样,不能够确定保障具有的Router都和脚下Router可管理的METHOD是同样的。
于是,个人认为methods参数的存在意义并不是相当的大。。

贯彻简版Router

透过下边的剖析,其实早就讲授了 koa-router 主旨的一些:构造 Router 对象
=> 定义 router 入口 => 相称路由 =>
合并中间件和实践函数输出;那几个API能够管理大致的 restful
请求,额外的API比如重定向、router.use、路由前缀等在领悟基本代码后阅读起来就差不离许多了;简版其实就是上面api的精简版,原理一致,能够到自己的类型看下
simple-koa-router:https://github.com/masongzhi/simple-koa-router

express分路由拍卖

express的代码一般如下:

const app = require("express")();
app.use("/first",(req,res,next)=>{
    console.log("first");
    res.status(200).send("<h1>headers-first ...</h1>");
});
app.use("/second",(req,res,next)=>{
    console.log("second");
    res.status(200).send("<h1>headers-second ...</h1>");
});
app.use("/third",(req,res,next)=>{
    console.log("third");
    res.status(200).send("<h1>headers-third ...</h1>");
});
app.listen(3001);

那很好精通,根据请求路线再次回到分裂结果,koa呢?

404.html

routerPath

这么些参数的存在。。感觉会招致某个极美丽妙的情形。
那就要提及在登记完全中学间件今后的router.routes()的操作了:

Router.prototype.routes = Router.prototype.middleware = function () {
  let router = this
  let dispatch = function dispatch(ctx, next) {
    let path = router.opts.routerPath || ctx.routerPath || ctx.path
    let matched = router.match(path, ctx.method)
    // 如果匹配到则执行对应的中间件
    // 执行后续操作
  }
  return dispatch
}

 

因为我们其实向koa登记的是如此的贰当中间件,在每便请求发送过来时,都会实践dispatch,而在dispatch中决断是还是不是命中有个别router时,则会用到这么些布局项,那样的一个表明式:router.opts.routerPath || ctx.routerPath || ctx.pathrouter意味着当前Router实例,相当于说,假诺大家在实例化八个Router的时候,假若填写了routerPath,这会招致无论任何请求,都会先行利用routerPath来作为路由检查:

const router = new Router({
  routerPath: '/index'
})

router.all('/index', async (ctx, next) => {
  ctx.body = 'pong!'
})
app.use(router.routes())

app.listen(8888, _ => console.log('server run as http://127.0.0.1:8888'))

 

假如有这么的代码,无论请求什么UWranglerL,都会认为是/index来拓展相称:

> curl http://127.0.0.1:8888
pong!
> curl http://127.0.0.1:8888/index
pong!
> curl http://127.0.0.1:8888/whatever/path
pong!

 

总结

koa-router
帮大家定义并选取相应的路由,对路由增添中间件和部分金童玉女和认证的工作;在
koa 中间件应用的底子上,比较轻巧驾驭中间件的兑现,koa-router
为大家做了越来越好的路由层管理,在统一筹算上得以参见实现,同时研究精粹源码也是对和煦的1种提高。

koa分路由拍卖

const Koa = require('koa');
const app = new Koa();
app.use("/",ctx => {
   ctx.body = 'Hello Koa';
 });
app.listen(3000);

诸如此类写会报错,因为koa自身并不援救按路由相应,假使急需如此做,能够通过引进第一方包达成。在koajs中有一个简约的router包。
具体写法如下:

//摘抄自Koa Trie Router
const Koa = require('koa')
const Router = require('koa-trie-router')

let app = new Koa()
let router = new Router()

router
  .use(function(ctx, next) {
    console.log('* requests')
    next()
  })
  .get(function(ctx, next) {
    console.log('GET requests')
    next()
  })
  .put('/foo', function (ctx) {
    ctx.body = 'PUT /foo requests'
  })
  .post('/bar', function (ctx) {
    ctx.body = 'POST /bar requests'
  })

app.use(router.middleware())
app.listen(3000)

在现实使用中也足以运用其余的路由包来做,在github上能搜到不少。
别的,由于完结的原因,下边介绍三个有趣的场地,看下边两段代码,初衷是打字与印刷请求管理耗费时间。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>404</title>
</head>
<body>
    404.html
</body>
</html>

巧用routerPath落成转发功效

平等的,那一个短路运算符1共有八个表明式,第二个的ctx则是眼前恳请的上下文,也正是说,即使我们有1个早于routes实施的中间件,也足以打开赋值来修改路由剖断所使用的URL

const router = new Router()

router.all('/index', async (ctx, next) => {
  ctx.body = 'pong!'
})

app.use((ctx, next) => {
  ctx.routerPath = '/index' // 手动改变routerPath
  next()
})
app.use(router.routes())

app.listen(8888, _ => console.log('server run as http://127.0.0.1:8888'))

 

那般的代码也能够得以达成均等的成效。
实例化中流传的routerPath令人捉摸不透,然则在中间件中更换routerPath的那几个还可以够找到合适的光景,这么些能够回顾的知道为转载的一种落成,转载的历程是对客户端不可知的,在客户端看来依旧访问的是中期的U奥迪Q伍L,然则在中间件中改造ctx.routerPath能够很自由的使路由至极到大家想转载的地点去

// 老版本的登录逻辑处理
router.post('/login', ctx => {
  ctx.body = 'old login logic!'
})

// 新版本的登录处理逻辑
router.post('/login-v2', ctx => {
  ctx.body = 'new login logic!'
})

app.use((ctx, next) => {
  if (ctx.path === '/login') { // 匹配到旧版请求,转发到新版
    ctx.routerPath = '/login-v2' // 手动改变routerPath
  }
  next()
})
app.use(router.routes())

 

那般就完结了三个总结的转向:

> curl -X POST http://127.0.0.1:8888/login
new login logic!

 

koa版本

const Koa = require('koa');
const app = new Koa();
app.use((ctx,next) => {
   ctx.body = 'Hello Koa-1';
   let start = new Date();
   next().then(()=>{
        console.log("time cost:",new Date()-start);
   });
 });
 app.use((ctx,next) => {
   ctx.body = 'Hello Koa-2';
   next();
 });
 app.use((ctx,next) => {
   ctx.body = 'Hello Koa-3';
   next();
 });
app.listen(3000);

出于koa选用了promise的章程管理中间件,next()实在重临的是一个promise对象,所以能够用地点轻松的格局记录管理耗费时间。如若在es七下,可以运用更简便的写法:

const Koa = require('koa');
const app = new Koa();
app.use(async (ctx,next) => {
   ctx.body = 'Hello Koa-1';
   let start = new Date();
   await next();
   console.log("time cost:",new Date()-start);
 });
 app.use(async (ctx,next) => {
   ctx.body = 'Hello Koa-2';
   //这里用了一个定时器表示实际的操作耗时
   await new Promise((resolve,reject)=>setTimeout(()=>{next();resolve();},3000));
 });
 app.use((ctx,next) => {
   ctx.body = 'Hello Koa-3';
   next();
 });
app.listen(3000);

那般只须求在输入放置二其中间件就能够完毕耗费时间记下。

todo.html

注册路由的监听

上述总体是关于实例化Router时的一些操作,下边就来讲一下用到最多的,注册路由相关的操作,最领会的自然就是router.getrouter.post那个的操作了。
但实质上这个也只是三个飞速格局罢了,在内部调用了来自Routerregister方法:

Router.prototype.register = function (path, methods, middleware, opts) {
  opts = opts || {}

  let router = this
  let stack = this.stack

  // support array of paths
  if (Array.isArray(path)) {
    path.forEach(function (p) {
      router.register.call(router, p, methods, middleware, opts)
    })

    return this
  }

  // create route
  let route = new Layer(path, methods, middleware, {
    end: opts.end === false ? opts.end : true,
    name: opts.name,
    sensitive: opts.sensitive || this.opts.sensitive || false,
    strict: opts.strict || this.opts.strict || false,
    prefix: opts.prefix || this.opts.prefix || '',
    ignoreCaptures: opts.ignoreCaptures
  })

  if (this.opts.prefix) {
    route.setPrefix(this.opts.prefix)
  }

  // add parameter middleware
  Object.keys(this.params).forEach(function (param) {
    route.param(param, this.params[param])
  }, this)

  stack.push(route)

  return route
}

 

该措施在批注中标为了 private
不过中间的局地参数在代码中各类地点都尚未彰显出来,鬼知道为何会留着那多少个参数,但既然存在,就须要驾驭她是为啥的

其1是路由监听的功底艺术,函数签字大约如下:

Param Type Default Description
path String/Array[String] 一个或者多个的路径
methods Array[String] 该路由需要监听哪几个METHOD
middleware Function/Array[Function] 由函数组成的中间件数组,路由实际调用的回调函数
opts Object {} 一些注册路由时的配置参数,上边提到的strictsensitiveprefix在这里都有体现

能够见见,函数大约正是贯彻了这么的流程:

  1. 检查path是还是不是为数组,借使是,遍历item进展调用本身
  2. 实例化1个Layer对象,设置有个别初步化参数
  3. 安装针对少数参数的中间件管理(倘若局地话)
  4. 将实例化后的靶子放入stack中存储

故此在介绍这多少个参数之前,简单的叙述一下Layer的构造函数是很有不可缺少的:

function Layer(path, methods, middleware, opts) {
  this.opts = opts || {}
  this.name = this.opts.name || null
  this.methods = []
  this.paramNames = []
  this.stack = Array.isArray(middleware) ? middleware : [middleware]

  methods.forEach(function(method) {
    var l = this.methods.push(method.toUpperCase());
    if (this.methods[l-1] === 'GET') {
      this.methods.unshift('HEAD')
    }
  }, this)

  // ensure middleware is a function
  this.stack.forEach(function(fn) {
    var type = (typeof fn)
    if (type !== 'function') {
      throw new Error(
        methods.toString() + " `" + (this.opts.name || path) +"`: `middleware` "
        + "must be a function, not `" + type + "`"
      )
    }
  }, this)

  this.path = path
  this.regexp = pathToRegExp(path, this.paramNames, this.opts)
}

 

layer是负责储存路由监听的音讯的,每一次注册路由时的U大切诺基L,U冠道L生成的正则表明式,该U奥德赛L中存在的参数,以及路由对应的中间件。
统统交由Layer来存储,入眼须要关心的是实例化进度中的这多少个数组参数:

  • methods
  • paramNames
  • stack

methods存款和储蓄的是该路由监听对应的有用METHOD,并会在实例化的进程中针对METHOD开展高低写的改造。
paramNames因为用的插件难题,看起来不那么清楚,实际上在pathToRegExp内部会对paramNames本条数组实行push的操作,这么看或然会清爽一下pathToRegExp(path, &this.paramNames, this.opts),在拼接hash结构的渠道参数时会用到那几个数组
stack仓库储存的是该路由监听对应的中间件函数,router.middleware有的逻辑会信赖于那些数组

express版本

由于express并不曾行使promise而是采纳了回调的法子管理中间件,所以不可能运用地点那样有利于的点子取得耗费时间。即正是对next()实行包装,也对事情未有啥协理,因为必须保险后续的next()全部都被打包才具获得正确的结果。
上面给出三个参阅落成:

let time = null;
.use('/', (req, res, next) => {
      time = Date.now();
      next()
    })
    .use('/eg', bidRequest)
    .use('/', (req, res, next) => {
      console.log(`<= time cost[${req.baseUrl}] : `, Date.now() - time, 'ms');
    })
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>todo</title>
</head>
<body>
    todo.html
</body>
</html>

path

在函数尾部的拍卖逻辑,首借使为着扶助多路线的还要登记,要是开掘第2个path参数为数组后,则会遍历path参数进行调用自己。
之所以本着多个URL的同样路由得以这样来拍卖:

router.register(['/', ['/path1', ['/path2', 'path3']]], ['GET'], ctx => {
  ctx.body = 'hi there.'
})

 

那般完全是二个使得的安装:

> curl http://127.0.0.1:8888/
hi there.
> curl http://127.0.0.1:8888/path1
hi there.
> curl http://127.0.0.1:8888/path3
hi there.

 

总结

koa和express的区别依然不小的,koa的始末很少,就是对nodejs本人的createServer函数做了总结的包装,未有做过多的延伸;而express首假若比koa多了router。二者的的代码思路依旧很分化等的,不过事实上选择中并不会有太大阻力。

index.html

methods

而关于methods参数,则暗中认可感觉是三个数组,尽管是只监听四个METHOD也急需传入八个数组作为参数,假若是空数组的话,就算URL非凡,也会直接跳过,执行下2当中间件,这几个在三番五回的router.routes中会提到

源码分析

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>index</title>
</head>
<body>
    <h1>koa2 demo index page</h1>
    <p>this is a index page</p>
    <ul>
        <li>
            <a href="/">/</a>
        </li>
        <li>
            <a href="/index">/index</a>
        </li>
        <li>
            <a href="/todo">/todo</a>
        </li>
        <li>
            <a href="/404">/404</a>
        </li>
        <li>
            <a href="/nofund">/nofund</a>
        </li>
    </ul>
</body>
</html>

middleware

middleware则是三次路由真正施行的作业了,仍旧是吻合koa正规的中间件,能够有七个,依照荷兰葱模型的方法来施行。
这也是koa-router中最根本的地方,能够让大家的壹对中间件只在一定的URL时执行。
此间写入的陆当中间件皆以针对性该URL生效的。

P.S.
koa-router中,还提供了二个艺术,叫做router.use,这几个会登记一个根据router实例的中间件

koa

koa的源码重要有三个文本:application.js, context.js, request.js,
response.js

重点是 index.js

opts

opts则是用来设置某个路由生成的计划规则的,包罗如下多少个可选的参数:

Param Type Default Description
name String 设置该路由所对应的name,命名router
prefix String 非常鸡肋的参数,完全没有卵用,看似会设置路由的前缀,实际上没有一点儿用
sensitive Boolean false 是否严格匹配大小写,覆盖实例化Router中的配置
strict Boolean false 是否严格匹配大小写,如果设置为false则匹配路径后边的/是可选的
end Boolean true 路径匹配是否为完整URL的结尾
ignoreCaptures Boolean 是否忽略路由匹配正则结果中的捕获组

context.js

context未有实际效大4代码,只是部分基础函数和变量,下边是代码片段。

inspect() {
    return this.toJSON();
  },
  toJSON() {
    return {
      request: this.request.toJSON(),
      response: this.response.toJSON(),
      app: this.app.toJSON(),
      originalUrl: this.originalUrl,
      req: '<original node req>',
      res: '<original node res>',
      socket: '<original node socket>'
    };
  },
const koa = require('koa');
const fs = require('fs');
const app = new koa();

/**
 * 用 Promise 封装一个异步读取文件的方法
 * @param {String} page html 文件名称
 * @returns {Object} Promise 实例对象
 */
function render(page) {
    return new Promise((resolve, reject) => {
        let viewUrl = `./view/${page}`;
        fs.readFile(viewUrl, 'binary', (err, data) => {
            if (err) {
                reject(err);
            } else {
                resolve(data);
            }
        });
    });
}

/**
 * 根据 URL 获取 HTML 内容
 * @param {String} url ctx.request.url
 * @returns {String} 获取到的 HTML 内容
 */
async function route(url) {
    let view = '404.html';
    switch (url) {
        case '/':
        case '/index':
            view = 'index.html';
            break;
        case '/todo':
            view = 'todo.html';
        case '/404':
            view = '404.html';
        default:
            break;
    }
    let html = await render(view);
    return html;
}

app.use( async(ctx) => {
    const html = await route(ctx.request.url);
    ctx.response.body = html;
});

app.listen(3000);
console.log('server is starting at prot 3000!');
name

首先是name,重要是用于这多少个地点:

  1. 抛出11分时更便宜的固化
  2. 能够经过router.url(<name>)router.route(<name>)赢获得对应的router信息
  3. 在中间件推行的时候,name会被塞到ctx.routerName

    router.register(‘/test1’, [‘GET’], _ => {}, {
    name: ‘module’
    })

    router.register(‘/test2’, [‘GET’], _ => {}, {
    name: ‘module’
    })

    console.log(router.url(‘module’) === ‘/test1’) // true

    try {
    router.register(‘/test2’, [‘GET’], null, {

    name: 'error-module'
    

    })
    } catch (e) {
    console.error(e) // Error: GET error-module: middleware must be a function, not object
    }

 

假如四个router应用一样的命名,则经过router.url调用重临先河注册的那个:

// route用来获取命名路由
Router.prototype.route = function (name) {
  var routes = this.stack

  for (var len = routes.length, i=0; i<len; i++) {
    if (routes[i].name && routes[i].name === name) {
      return routes[i] // 匹配到第一个就直接返回了
    }
  }

  return false
}

// url获取该路由对应的URL,并使用传入的参数来生成真实的URL
Router.prototype.url = function (name, params) {
  var route = this.route(name)

  if (route) {
    var args = Array.prototype.slice.call(arguments, 1)
    return route.url.apply(route, args)
  }

  return new Error('No route found for name: ' + name)
}

 

request.js

该公文中关键是一批set和get函数,首假若用来获取请求结构体的一定字段可能涂改特定字段,比方上边获取ip的函数,代码很好驾驭:

get ips() {
    const proxy = this.app.proxy;
    const val = this.get('X-Forwarded-For');
    return proxy && val
      ? val.split(/\s*,\s*/)
      : [];
  },

推行脚本

跑题说下router.url的那些事儿

如果在项目中,想要针对一些URL张开跳转,使用router.url来生成path则是三个正确的选料:

router.register(
  '/list/:id', ['GET'], ctx => {
    ctx.body = `Hi ${ctx.params.id}, query: ${ctx.querystring}`
  }, {
    name: 'list'
  }
)

router.register('/', ['GET'], ctx => {
  // /list/1?name=Niko
  ctx.redirect(
    router.url('list', { id: 1 }, { query: { name: 'Niko' } })
  )
})

// curl -L http://127.0.0.1:8888 => Hi 1, query: name=Niko

 

能够看出,router.url其实调用的是Layer实例的url艺术,该措施首假若用来管理生成时传入的局地参数。
源码地址:layer.js#L116
函数接收三个参数,paramsoptions,因为小编Layer实例是积攒了相应的path等等的新闻,所以params尽管积累的在路径中的一些参数的更迭,options在日前的代码中,仅仅存在1个query字段,用来拼接search背后的数额:

const Layer = require('koa-router/lib/layer')
const layer = new Layer('/list/:id/info/:name', [], [_ => {}])

console.log(layer.url({ id: 123, name: 'Niko' }))
console.log(layer.url([123, 'Niko']))
console.log(layer.url(123, 'Niko'))
console.log(
  layer.url(123, 'Niko', {
    query: {
      arg1: 1,
      arg2: 2
    }
  })
)

 

上述的调用格局都以实用的,在源码中有对应的管理,首先是针对性多参数的决断,就算params不是贰个object,则会以为是透过layer.url(参数, 参数, 参数, opts)那种方法来调用的。
将其转移为layer.url([参数, 参数], opts)形式的。
那时候的逻辑仅供给管理二种情景了:

  1. 数组方式的参数替换
  2. hash情势的参数替换
  3. 无参数

其一参数替换指的是,二个URL会通过3个其三方的库用来管理链接中的参数部分,也正是/:XXX的那壹局地,然后传入1个hash落成类似模版替换的操作:

// 可以简单的认为是这样的操作:
let hash = { id: 123, name: 'Niko' }
'/list/:id/:name'.replace(/(?:\/:)(\w+)/g, (_, $1) => `/${hash[$1]}`)

 

然后layer.url的拍卖正是为了将各类参数生成类似hash那般的构造,最后替换hash获得完整的URL

response.js

response与request对应,首即便1对甩卖res的工具类,上面是代码片段,用于安装和获取res的content-length:

set length(n) {
    this.set('Content-Length', n);
  },
  get length() {
    const len = this.header['content-length'];
    const body = this.body;

    if (null == len) {
      if (!body) return;
      if ('string' == typeof body) return Buffer.byteLength(body);
      if (Buffer.isBuffer(body)) return body.length;
      if (isJSON(body)) return Buffer.byteLength(JSON.stringify(body));
      return;
    }

    return ~~len;
  },

个中使用了~~len,这些略带看头,四回取反,能够确认保障输出为数字,假若len为字符串则重临0。(第一次见…)

node index.js
prefix

下面实例化Layer的经过中就像是opts.prefix的权重越来越高,不过随着在底下就有了一个决断逻辑举办调用setPrefix再也赋值,在翻遍了方方面面包车型地铁源码后发觉,那样独占鳌头的3个区分就在于,会有一条debug行使的是登记router时传入的prefix,而别的地点都会被实例化Router时的prefix所覆盖。

同时只要想要路由不利的采纳prefix,则供给调用setPrefix,因为在Layer实例化的经过中有关path的贮存正是来源于远传入的path参数。
而应用prefix前缀则要求手动触发setPrefix

// Layer实例化的操作
function Layer(path, methods, middleware, opts) {
  // 省略不相干操作
  this.path = path
  this.regexp = pathToRegExp(path, this.paramNames, this.opts)
}

// 只有调用setPrefix才会应用前缀
Layer.prototype.setPrefix = function (prefix) {
  if (this.path) {
    this.path = prefix + this.path
    this.paramNames = []
    this.regexp = pathToRegExp(this.path, this.paramNames, this.opts)
  }

  return this
}

 

其一在爆出给使用者的多少个主意中都有呈现,类似的getset以及use
当然在文书档案中也提供了足以一贯设置有着router前缀的点子,router.prefix
文书档案中就那样归纳的告诉您可以安装前缀,prefix在里头会循环调用全数的layer.setPrefix

router.prefix('/things/:thing_id')

 

唯独在翻看了layer.setPrefix源码后才察觉这里实在是带有多个暗坑的。
因为setPrefix的落到实处是得到prefix参数,拼接到当前path的头部。
那般就能带来一个主题材料,若是我们1再调用setPrefix会促成数次prefix叠加,而非替换:

router.register('/index', ['GET'], ctx => {
  ctx.body = 'hi there.'
})

router.prefix('/path1')
router.prefix('/path2')

// > curl http://127.0.0.1:8888/path2/path1/index
// hi there.

 

prefix方法会叠加前缀,而不是覆盖前缀

application.js

上文中用到的app正是在该文件中定义的,也是koa的主干所在,这里挑选多少个成员函数进行分析(整个文件代码也就不到250行,自个儿看完压力也比异常的小)。

module.exports = class Application extends Emitter {
/*
    构造函数:把req,res,env等常用的变量全都塞进了context,所以我们在中间件中拿到context以后,就可以随心所欲地操作req和res了。
*/
  constructor() {
    super();
    this.proxy = false;
    this.middleware = [];
    this.subdomainOffset = 2;
    this.env = process.env.NODE_ENV || 'development';
    this.context = Object.create(context);
    this.request = Object.create(request);
    this.response = Object.create(response);
  }
/*
    实际就是调用了nodejs本身的createServer,没有任何区别。
*/
  listen() {
    debug('listen');
    const server = http.createServer(this.callback());
    return server.listen.apply(server, arguments);
  }
  //下面分析
  use(fn) {
    if (typeof fn !== 'function') throw new TypeError('middleware must be a function!');
    if (isGeneratorFunction(fn)) {
      deprecate('Support for generators will be removed in v3. ' +
                'See the documentation for examples of how to convert old middleware ' +
                'https://github.com/koajs/koa/blob/master/docs/migration.md');
      fn = convert(fn);
    }
    debug('use %s', fn._name || fn.name || '-');
    this.middleware.push(fn);
    return this;
  }
  //下面分析
  callback() {
    const fn = compose(this.middleware);

    if (!this.listeners('error').length) this.on('error', this.onerror);

    const handleRequest = (req, res) => {
      res.statusCode = 404;
      const ctx = this.createContext(req, res);
      const onerror = err => ctx.onerror(err);
      const handleResponse = () => respond(ctx);
      onFinished(res, onerror);
      return fn(ctx).then(handleResponse).catch(onerror);
    };

    return handleRequest;
  }

  //新建context
  createContext(req, res) {
    const context = Object.create(this.context);
    const request = context.request = Object.create(this.request);
    const response = context.response = Object.create(this.response);
    context.app = request.app = response.app = this;
    context.req = request.req = response.req = req;
    context.res = request.res = response.res = res;
    request.ctx = response.ctx = context;
    request.response = response;
    response.request = request;
    context.originalUrl = request.originalUrl = req.url;
    context.cookies = new Cookies(req, res, {
      keys: this.keys,
      secure: request.secure
    });
    request.ip = request.ips[0] || req.socket.remoteAddress || '';
    context.accept = request.accept = accepts(req);
    context.state = {};
    return context;
  }
//下面分析
function respond(ctx) {
  // allow bypassing koa
  if (false === ctx.respond) return;

  const res = ctx.res;
  if (!ctx.writable) return;

  let body = ctx.body;
  const code = ctx.status;

  // ignore body
  if (statuses.empty[code]) {
    // strip headers
    ctx.body = null;
    return res.end();
  }

  if ('HEAD' == ctx.method) {
    if (!res.headersSent && isJSON(body)) {
      ctx.length = Buffer.byteLength(JSON.stringify(body));
    }
    return res.end();
  }

  // status body
  if (null == body) {
    body = ctx.message || String(code);
    if (!res.headersSent) {
      ctx.type = 'text';
      ctx.length = Buffer.byteLength(body);
    }
    return res.end(body);
  }

  // responses
  if (Buffer.isBuffer(body)) return res.end(body);
  if ('string' == typeof body) return res.end(body);
  if (body instanceof Stream) return body.pipe(res);

  // body: json
  body = JSON.stringify(body);
  if (!res.headersSent) {
    ctx.length = Buffer.byteLength(body);
  }
  res.end(body);
}

下边入眼看use,callback,respond那多个函数,实际上精晓koa的音信流看那多个函数的源码就基本上充裕了。
use :
内容不多,当中第贰个if用于安检,第一个if用以落到实处对generator函数的相配,具体完结进度在is-generator-function以此包里面,风乐趣能够看看,依然挺有才具的,参考借用。use最后然而正是把中间件push到了this.middleware数组里,并不曾别的实质的逻辑操作。
respond :
该函数正是响应请求的地点,那也是干吗大家能够不用积极地响应请求。函数里做了许多确定,主假使防卫二回响应以及特种特定的响应的请求。
callback :
callback用于转移createServer函数的回调,即handleRequest函数。handleRequest的再次来到值正是四个promise对象。注意这里调用了3个compose艺术,该办法的功效正是把中间件数组转变来1个函数,以方便使用。具体的贯彻在koa-compose这几个包里,这里摘抄当中的1段来分析。

//这就是compose(...)返回的函数
function (context, next) {
    // last called middleware #
    let index = -1
    return dispatch(0)
    function dispatch (i) {
      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        return Promise.resolve(fn(context, function next () {
          return dispatch(i + 1)
        }))
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }

能够看看,实际上这里正是用闭包达成了对中间件数组的遍历。具体思路会把第i+一当中间件作为next传给第i个中间件,那也正是干吗必须积极调用next金沙注册送58 ,的原因,认为只要不积极调用next那一巡回就能够提前结束了,后续的中间件就不只怕赢得实践。

到此甘休,koa源码分析就结束了,koa源码很少,未有剩余的事物,以致连路由都亟需引进别的的包。

咱俩得以看到

sensitive与strict

那俩参数没啥好说的,正是会覆盖实例化Router时所传递的那俩参数,效果都1模同样。

express

express的源码比koa多了无数事物,这里仅仅相比宗旨部分,忽略别的一些的始末。

//express.js
function createApplication() {
  var app = function(req, res, next) {
    app.handle(req, res, next);
  };

  mixin(app, EventEmitter.prototype, false);
  mixin(app, proto, false);

  // expose the prototype that will get set on requests
  app.request = Object.create(req, {
    app: { configurable: true, enumerable: true, writable: true, value: app }
  })

  // expose the prototype that will get set on responses
  app.response = Object.create(res, {
    app: { configurable: true, enumerable: true, writable: true, value: app }
  })

  app.init();
  return app;
}

这里的express就是我们上文中引入的express对象,可以看来,实际上该函数就是把一些常用的效应和变量绑定到了app对象中去,大家在代码中运用的app.eg_funcs等等的不二法门都是从这里继续获得的。实际上该对象并不囿于于选择app.listen()来运行四个服务,下边是listen函数的代码。

//application.js
app.listen = function listen() {
  var server = http.createServer(this);
  return server.listen.apply(server, arguments);
};

调用app.listen能够运行二个服务器,实际上我们也可以直接手动写出那两句代码来运行三个服务。在socket.iohttps服务中就必要团结来成功这一进程。
下面是app.use的源码:

app.use = function use(fn) {
  var offset = 0;
  var path = '/';

  // default path to '/'
  // disambiguate app.use([fn])
  if (typeof fn !== 'function') {
    var arg = fn;

    while (Array.isArray(arg) && arg.length !== 0) {
      arg = arg[0];
    }

    // first arg is the path
    if (typeof arg !== 'function') {
      offset = 1;
      path = fn;
    }
  }

  var fns = flatten(slice.call(arguments, offset));

  if (fns.length === 0) {
    throw new TypeError('app.use() requires middleware functions');
  }

  // setup router
  this.lazyrouter();
  var router = this._router;

  fns.forEach(function (fn) {
    // non-express app
    if (!fn || !fn.handle || !fn.set) {
      return router.use(path, fn);
    }

    debug('.use app under %s', path);
    fn.mountpath = path;
    fn.parent = this;

    // restore .app property on req and res
    router.use(path, function mounted_app(req, res, next) {
      var orig = req.app;
      fn.handle(req, res, function (err) {
        setPrototypeOf(req, orig.request)
        setPrototypeOf(res, orig.response)
        next(err);
      });
    });

    // mounted an app
    fn.emit('mount', this);
  }, this);

  return this;
}

此地有一双肾草数判断的逻辑,比方第二个参数要是是路子依然函数,可是平时很少这么写。

从中能够看到实际上express是调用了router的use方法对中间件进行拍卖。router.use定义在/router/index.js中,
源码如下:

proto.use = function use(fn) {
  var offset = 0;
  var path = '/';

  // default path to '/'
  // disambiguate router.use([fn])
  if (typeof fn !== 'function') {
    var arg = fn;

    while (Array.isArray(arg) && arg.length !== 0) {
      arg = arg[0];
    }

    // first arg is the path
    if (typeof arg !== 'function') {
      offset = 1;
      path = fn;
    }
  }

  var callbacks = flatten(slice.call(arguments, offset));

  if (callbacks.length === 0) {
    throw new TypeError('Router.use() requires middleware functions');
  }

  for (var i = 0; i < callbacks.length; i++) {
    var fn = callbacks[i];

    if (typeof fn !== 'function') {
      throw new TypeError('Router.use() requires middleware function but got a ' + gettype(fn));
    }

    // add the middleware
    debug('use %o %s', path, fn.name || '<anonymous>')

    var layer = new Layer(path, {
      sensitive: this.caseSensitive,
      strict: false,
      end: false
    }, fn);

    layer.route = undefined;

    this.stack.push(layer);
  }

  return this;
};

其间前大概段重若是有的备选工作(那种写法在express貌似很广阔)。前边看到与koa直接把中间件push到数组的做法不一的是,express会把中间件封装成二个Layer,那样做也是为了更加好地决定中间件的进行。Layer的代码在/router/layer.js中。(这里不再分析)

上边早先分析express是怎么响应请求的,从地方listen部分的代码能够见见,我们给createServer传了三个this,而以此this正是express()的再次回到值,定义在application.js里,源码如下:

var app = function(req, res, next) {
    app.handle(req, res, next);
  };

能够观望实际app是调用了handle方法,而该情势是从application对象承袭过来的,而查看application.js发现了下边代码:

//初始化 this._router
this._router = new Router({
      caseSensitive: this.enabled('case sensitive routing'),
      strict: this.enabled('strict routing')
    });

    this._router.use(query(this.get('query parser fn')));
    this._router.use(middleware.init(this));
//使用 this._router
app.handle = function handle(req, res, callback) {
  var router = this._router;

  // final handler
  var done = callback || finalhandler(req, res, {
    env: this.get('env'),
    onerror: logerror.bind(this)
  });

  // no routes
  if (!router) {
    debug('no routes defined on app');
    done();
    return;
  }

  router.handle(req, res, done);
};

能够看看实际这里调用的是router.handle,上边看router的源码:

proto.handle = function handle(req, res, out) {
  var self = this;

  debug('dispatching %s %s', req.method, req.url);

  var idx = 0;
  var protohost = getProtohost(req.url) || ''
  var removed = '';
  var slashAdded = false;
  var paramcalled = {};

  // store options for OPTIONS request
  // only used if OPTIONS request
  var options = [];

  // middleware and routes
  var stack = self.stack;

  // manage inter-router variables
  var parentParams = req.params;
  var parentUrl = req.baseUrl || '';
  var done = restore(out, req, 'baseUrl', 'next', 'params');

  // setup next layer
  req.next = next;

  // for options requests, respond with a default if nothing else responds
  if (req.method === 'OPTIONS') {
    done = wrap(done, function(old, err) {
      if (err || options.length === 0) return old(err);
      sendOptionsResponse(res, options, old);
    });
  }

  // setup basic req values
  req.baseUrl = parentUrl;
  req.originalUrl = req.originalUrl || req.url;

  next();

  function next(err) {
    var layerError = err === 'route'
      ? null
      : err;

    // remove added slash
    if (slashAdded) {
      req.url = req.url.substr(1);
      slashAdded = false;
    }

    // restore altered req.url
    if (removed.length !== 0) {
      req.baseUrl = parentUrl;
      req.url = protohost + removed + req.url.substr(protohost.length);
      removed = '';
    }

    // signal to exit router
    if (layerError === 'router') {
      setImmediate(done, null)
      return
    }

    // no more matching layers
    if (idx >= stack.length) {
      setImmediate(done, layerError);
      return;
    }

    // get pathname of request
    var path = getPathname(req);

    if (path == null) {
      return done(layerError);
    }

    // find next matching layer
    var layer;
    var match;
    var route;

    while (match !== true && idx < stack.length) {
      layer = stack[idx++];
      match = matchLayer(layer, path);
      route = layer.route;

      if (typeof match !== 'boolean') {
        // hold on to layerError
        layerError = layerError || match;
      }

      if (match !== true) {
        continue;
      }

      if (!route) {
        // process non-route handlers normally
        continue;
      }

      if (layerError) {
        // routes do not match with a pending error
        match = false;
        continue;
      }

      var method = req.method;
      var has_method = route._handles_method(method);

      // build up automatic options response
      if (!has_method && method === 'OPTIONS') {
        appendMethods(options, route._options());
      }

      // don't even bother matching route
      if (!has_method && method !== 'HEAD') {
        match = false;
        continue;
      }
    }

    // no match
    if (match !== true) {
      return done(layerError);
    }

    // store route for dispatch on change
    if (route) {
      req.route = route;
    }

    // Capture one-time layer values
    req.params = self.mergeParams
      ? mergeParams(layer.params, parentParams)
      : layer.params;
    var layerPath = layer.path;

    // this should be done for the layer
    self.process_params(layer, paramcalled, req, res, function (err) {
      if (err) {
        return next(layerError || err);
      }

      if (route) {
        return layer.handle_request(req, res, next);
      }

      trim_prefix(layer, layerError, layerPath, path);
    });
  }

  function trim_prefix(layer, layerError, layerPath, path) {
    if (layerPath.length !== 0) {
      // Validate path breaks on a path separator
      var c = path[layerPath.length]
      if (c && c !== '/' && c !== '.') return next(layerError)

      // Trim off the part of the url that matches the route
      // middleware (.use stuff) needs to have the path stripped
      debug('trim prefix (%s) from url %s', layerPath, req.url);
      removed = layerPath;
      req.url = protohost + req.url.substr(protohost.length + removed.length);

      // Ensure leading slash
      if (!protohost && req.url[0] !== '/') {
        req.url = '/' + req.url;
        slashAdded = true;
      }

      // Setup base URL (no trailing slash)
      req.baseUrl = parentUrl + (removed[removed.length - 1] === '/'
        ? removed.substring(0, removed.length - 1)
        : removed);
    }

    debug('%s %s : %s', layer.name, layerPath, req.originalUrl);

    if (layerError) {
      layer.handle_error(layerError, req, res, next);
    } else {
      layer.handle_request(req, res, next);
    }
  }
};

以此函数相当长,可是事实上海大学部分剧情都以相配路由,类型检查实验等操作,实际的操作聚焦在next()函数中,与koa同样,这里也是使用闭包来循环遍历中间件数组。看next()中的推行部分能够看到,符合规律状态下,实际的操作是由layer.handle_request完成的,下面看layer.js源码:

//初始化
function Layer(path, options, fn) {
  if (!(this instanceof Layer)) {
    return new Layer(path, options, fn);
  }

  debug('new %o', path)
  var opts = options || {};

  this.handle = fn;
  this.name = fn.name || '<anonymous>';
  this.params = undefined;
  this.path = undefined;
  this.regexp = pathRegexp(path, this.keys = [], opts);

  // set fast path flags
  this.regexp.fast_star = path === '*'
  this.regexp.fast_slash = path === '/' && opts.end === false
}
//处理单元
Layer.prototype.handle_request = function handle(req, res, next) {
  var fn = this.handle;

  if (fn.length > 3) {
    // not a standard request handler
    return next();
  }

  try {
    fn(req, res, next);
  } catch (err) {
    next(err);
  }
};

bingo,这里就是大家在调用use的时候起先化的Layer结构体,能够看出,实际上大家把中间件函数赋给了layer.handle,而在实际上的管理函数handle_request中,正是调用了this.handle,总算找到了数额管理的来源了….
此处看看实际router中的next()只是运维了中间件回调的经过,然后把团结传给下二其中间件,后续的中间件主动调用next()如此那般就足以传递下去了。

在管理中间件的逻辑上express能够知晓为每一遍1在那之中间件推行落成就去主动去文告“中央”去运维下叁当中间件;而koa能够知道为链式过程,每叁其中间件会运营后两当中间件。

到此截至,大家着力做到了koa和express的相比分析,二者各有友好的特点,在应用中得以依赖供给选取最契合的消除方案。

金沙注册送58 2

end

end是三个很风趣的参数,那个在koa-router中援引的任何模块中有反映到,path-to-regexp:

if (end) {
  if (!strict) route += '(?:' + delimiter + ')?'

  route += endsWith === '$' ? '$' : '(?=' + endsWith + ')'
} else {
  if (!strict) route += '(?:' + delimiter + '(?=' + endsWith + '))?'
  if (!isEndDelimited) route += '(?=' + delimiter + '|' + endsWith + ')'
}

return new RegExp('^' + route, flags(options))

 

endWith能够归纳地知道为是正则中的$,也便是协作的最终。
看代码的逻辑,差不离正是,借使设置了end: true,则不管任何情状都会在最终增多$意味着极度的最终。
而如果end: false,则唯有在同时安装了strict: false或者isEndDelimited: false时才会接触。
所以我们能够透过那三个参数来实现USportageL的模糊相配:

router.register(
  '/list', ['GET'], ctx => {
    ctx.body = 'hi there.'
  }, {
    end: false,
    strict: true
  }
)

 

也正是说上述代码最后生成的用于相称路由的正则表明式大概是如此的:

/^\/list(?=\/|$)/i

// 可以通过下述代码获取到正则
require('path-to-regexp').tokensToRegExp('/list/', {end: false, strict: true})

 

结尾的$是可选的,那就能够促成,大家若是发送任何开端为/list的伸手都会被那在那之中间件所取获得。

route

ignoreCaptures

ignoreCaptures参数用来设置是或不是供给重临URL中格外的门径参数给中间件。
而假若设置了ignoreCaptures从此那四个参数就能够变为空对象:

router.register('/list/:id', ['GET'], ctx => {
  console.log(ctx.captures, ctx.params)
  // ['1'], { id: '1' }
})

// > curl /list/1

router.register('/list/:id', ['GET'], ctx => {
  console.log(ctx.captures, ctx.params)
  // [ ], {  }
}, {
  ignoreCaptures: true
})
// > curl /list/1

 

那么些是在中间件推行时期调用了来自layer的四个主意赢得的。
首先调用captures获取具备的参数,假使设置了ignoreCaptures则会导致一贯回到空数组。
然后调用params将注册路由时所生成的富有参数以及参数们其实的值传了进入,然后生成二个完全的hash注入到ctx对象中:

// 中间件的逻辑
ctx.captures = layer.captures(path, ctx.captures)
ctx.params = layer.params(path, ctx.captures, ctx.params)
ctx.routerName = layer.name
return next()
// 中间件的逻辑 end

// layer提供的方法
Layer.prototype.captures = function (path) {
  if (this.opts.ignoreCaptures) return []
  return path.match(this.regexp).slice(1)
}

Layer.prototype.params = function (path, captures, existingParams) {
  var params = existingParams || {}

  for (var len = captures.length, i=0; i<len; i++) {
    if (this.paramNames[i]) {
      var c = captures[i]
      params[this.paramNames[i].name] = c ? safeDecodeURIComponent(c) : c
    }
  }

  return params
}

// 所做的事情大致如下:
// [18, 'Niko'] + ['age', 'name']
// =>
// { age: 18, name: 'Niko' }

 


router.param的作用

上述是有关心册路由时的有的参数描述,能够看来在register中实例化Layer目标后并从未直接将其放入stack中,而是实行了那样的贰个操作之后才将其推入stack

Object.keys(this.params).forEach(function (param) {
  route.param(param, this.params[param])
}, this)

stack.push(route) // 装载

 

此间是作为增多针对某些URL参数的中间件管理的,与router.param两者关联性很强:

Router.prototype.param = function (param, middleware) {
  this.params[param] = middleware
  this.stack.forEach(function (route) {
    route.param(param, middleware)
  })
  return this
}

 

多头操作看似,前者用于对新添的路由监听增添全体的param中间件,而后者用于针对现存的全数路由增添param中间件。
因为在router.param中有着this.params[param] = XXX的赋值操作。
如此那般在后续的新扩充路由监听中,直接循环this.params就足以得到全部的中间件了。

router.param的操作在文书档案中也有介绍,文档地址
大概正是足以用来做一些参数校验之类的操作,然则因为在layer.param中有了某个奇怪的拍卖,所以我们不要忧虑param的试行顺序,layer会保证param必然是早于注重那几个参数的中间件实践的:

router.register('/list/:id', ['GET'], (ctx, next) => {
  ctx.body = `hello: ${ctx.name}`
})

router.param('id', (param, ctx, next) => {
  console.log(`got id: ${param}`)
  ctx.name = 'Niko'
  next()
})

router.param('id', (param, ctx, next) => {
  console.log('param2')
  next()
})


// > curl /list/1
// got id: 1
// param2
// hello: Niko

 

手写路由很艰难,所以要求用中间件的花样管理路由,用到了 koa-router

最常用的get/post之类的神速格局

以及说完了上边的根基艺术register,大家得以来看下揭示给开辟者的多少个router.verb方法:

// get|put|post|patch|delete|del
// 循环注册多个METHOD的快捷方式
methods.forEach(function (method) {
  Router.prototype[method] = function (name, path, middleware) {
    let middleware

    if (typeof path === 'string' || path instanceof RegExp) {
      middleware = Array.prototype.slice.call(arguments, 2)
    } else {
      middleware = Array.prototype.slice.call(arguments, 1)
      path = name
      name = null
    }

    this.register(path, [method], middleware, {
      name: name
    })

    return this
  }
})

Router.prototype.del = Router.prototype['delete'] // 以及最后的一个别名处理,因为del并不是有效的METHOD

 

令人失望的是,verb措施将大量的opts参数都砍掉了,默许只留下了三个name字段。
只是一点也不细略的拍卖了一下命名name路由相关的逻辑,然后开始展览调用register成就操作。

本人的学习思路是先用法后原理,所以先读书用法

router.use-Router内部的中间件

以及上文中也事关的router.use,可以用来注册5个中间件,使用use登记中间件分为三种情景:

  1. 普普通通的中间件函数
  2. 将长存的router实例作为中间件传入

安装 koa-router

普通的use

这里是use办法的根本代码:

Router.prototype.use = function () {
  var router = this
  middleware.forEach(function (m) {
    if (m.router) { // 这里是通过`router.routes()`传递进来的
      m.router.stack.forEach(function (nestedLayer) {
        if (path) nestedLayer.setPrefix(path)
        if (router.opts.prefix) nestedLayer.setPrefix(router.opts.prefix) // 调用`use`的Router实例的`prefix`
        router.stack.push(nestedLayer)
      })

      if (router.params) {
        Object.keys(router.params).forEach(function (key) {
          m.router.param(key, router.params[key])
        })
      }
    } else { // 普通的中间件注册
      router.register(path || '(.*)', [], m, { end: false, ignoreCaptures: !hasPath })
    }
  })
}

// 在routes方法有这样的一步操作
Router.prototype.routes = Router.prototype.middleware = function () {
  function dispatch() {
    // ...
  }

  dispatch.router = this // 将router实例赋值给了返回的函数

  return dispatch
}

 

先是种是比较寻常的不二等秘书籍,传入1个函数,一个可选的path,来进展注册中间件。
不过有几许要专注的是,.use('path')那般的用法,中间件不能够独立存在,必供给有贰个得以与之门路相相称的路由监听存在:

router.use('/list', ctx => {
  // 如果只有这么一个中间件,无论如何也不会执行的
})

// 必须要存在相同路径的`register`回调
router.get('/list', ctx => { })

app.use(router.routes())

 

案由是这般的:

  1. .use.get都以基于.register来促成的,可是.usemethods参数中传送的是二个空数组
  2. 在贰个门路被相配到时,会将有所匹配到的中档件抽取来,然后检核查应的methods,如果length !== 0则会对当下相配组标志二个flag
  3. 在推行中间件在此之前会先判断有未有这一个flag,假诺没有则证实该路径全部的中间件都尚未安装METHOD,则会直接跳过进入其余流程(比如allowedMethod

    Router.prototype.match = function (path, method) {
    var layers = this.stack
    var layer
    var matched = {

    path: [],
    pathAndMethod: [],
    route: false
    

    }

    for (var len = layers.length, i = 0; i < len; i++) {

    layer = layers[i]
    
    if (layer.match(path)) {
      matched.path.push(layer)
    
      if (layer.methods.length === 0 || ~layer.methods.indexOf(method)) {
        matched.pathAndMethod.push(layer)
    
        // 只有在发现不为空的`methods`以后才会设置`flag`
        if (layer.methods.length) matched.route = true
      }
    }
    

    }

    return matched
    }

    // 以及在routes中有那般的操作
    Router.prototype.routes = Router.prototype.middleware = function () {
    function dispatch(ctx, next) {

    // 如果没有`flag`,直接跳过
    if (!matched.route) return next()
    

    }

    return dispatch
    }

 

npm i -S koa-router
将其他router实例传递进入

能够见到,纵然选取了router.routes()来方式来复用中间件,会遍历该实例的兼具路由,然后设置prefix
并将修改完的layer推出到当下的router中。
这便是说今后就要注意了,在上头其实早已提到了,LayersetPrefix是拼接的,而不是覆盖的。
use是会操作layer目的的,所以这么的用法会导致前面包车型大巴中间件路径也被涂改。
并且1旦传入use的中间件已经登记在了koa中就能够导致同样的中间件会奉行五次(举个例子有调用next的话):

const middlewareRouter = new Router()
const routerPage1 = new Router({
  prefix: '/page1'
})

const routerPage2 = new Router({
  prefix: '/page2'
})

middlewareRouter.get('/list/:id', async (ctx, next) => {
  console.log('trigger middleware')
  ctx.body = `hi there.`
  await next()
})

routerPage1.use(middlewareRouter.routes())
routerPage2.use(middlewareRouter.routes())

app.use(middlewareRouter.routes())
app.use(routerPage1.routes())
app.use(routerPage2.routes())

 

就如上述代码,实际上会有四个难题:

  1. 终极有效的访问路线为/page2/page1/list/1,因为prefix会拼接而非覆盖
  2. 当我们在中间件中调用next以后,console.log会一而再输出一遍,因为有着的routes都是动态的,实际上prefix都被退换为了/page2/page1

一定要小心使用,不要感到那样的秘技得以用来促成路由的复用

举叁个简约例子:

恳请的处理

以及,终于赶到了最后一步,当1个请求来了后来,Router是什么管理的。
一个Router实例可以抛出两当中间件注册到koa上:

app.use(router.routes())
app.use(router.allowedMethods())

 

routes担负重大的逻辑。
allowedMethods承担提供一个后置的METHOD反省立中学间件。

allowedMethods不妨好说的,正是依据方今恳请的method进展的一些校验,并重返一些错误音信。
而上面介绍的广大方法其实都以为着最后的routes服务:

Router.prototype.routes = Router.prototype.middleware = function () {
  var router = this

  var dispatch = function dispatch(ctx, next) {
    var path = router.opts.routerPath || ctx.routerPath || ctx.path
    var matched = router.match(path, ctx.method)
    var layerChain, layer, i

    if (ctx.matched) {
      ctx.matched.push.apply(ctx.matched, matched.path)
    } else {
      ctx.matched = matched.path
    }

    ctx.router = router

    if (!matched.route) return next()

    var matchedLayers = matched.pathAndMethod
    var mostSpecificLayer = matchedLayers[matchedLayers.length - 1]
    ctx._matchedRoute = mostSpecificLayer.path
    if (mostSpecificLayer.name) {
      ctx._matchedRouteName = mostSpecificLayer.name
    }

    layerChain = matchedLayers.reduce(function(memo, layer) {
      memo.push(function(ctx, next) {
        ctx.captures = layer.captures(path, ctx.captures)
        ctx.params = layer.params(path, ctx.captures, ctx.params)
        ctx.routerName = layer.name
        return next()
      })
      return memo.concat(layer.stack)
    }, [])

    return compose(layerChain)(ctx, next)
  };

  dispatch.router = this

  return dispatch
}

 

率先能够看来,koa-router再者还提供了叁个外号middleware来达成均等的成效。
以及函数的调用最终会再次回到三个中间件函数,那些函数才是真的被挂在到koa上的。
koa的中间件是彻彻底底的中间件,不管什么请求都会举行所含有的中间件。
故此不提议为了选择prefix而创建四个Router实例,那会促成在koa上挂载五个dispatch用来检查U奥迪Q五L是不是合乎规则

跻身中间件今后会进展U本田CR-VL的判别,便是我们上面提到的能够用来做foraward福寿无疆的地点。
杰出调用的是router.match措施,虽说看似赋值是matched.path,而事实上在match办法的得以落成中,里边全体是相当到的Layer实例:

Router.prototype.match = function (path, method) {
  var layers = this.stack // 这个就是获取的Router实例中所有的中间件对应的layer对象
  var layer
  var matched = {
    path: [],
    pathAndMethod: [],
    route: false
  }

  for (var len = layers.length, i = 0; i < len; i++) {
    layer = layers[i]

    if (layer.match(path)) { // 这里就是一个简单的正则匹配
      matched.path.push(layer)

      if (layer.methods.length === 0 || ~layer.methods.indexOf(method)) {
        // 将有效的中间件推入
        matched.pathAndMethod.push(layer)

        // 判断是否存在METHOD
        if (layer.methods.length) matched.route = true
      }
    }
  }

  return matched
}

// 一个简单的正则匹配
Layer.prototype.match = function (path) {
  return this.regexp.test(path)
}

 

而因此会存在说推断是还是不是有ctx.matched来开始展览管理,而不是一向对这些性情进行赋值。
这是因为上边也涉及过的,一个koa实例可能会登记八个koa-router实例。
那就产生三个router实例的中间件施行实现后,后续只怕还会有任何的router实例也命中了有些URL,不过那样会有限支撑matched一贯是在增加的,而非每回都会覆盖。

pathpathAndMethod都是match归来的七个数组,两者的差别在于path回到的是相称URAV四L成功的多少,而pathAndMethod则是相配U福特ExplorerL且相配到METHOD的数据

const router1 = new Router()
const router2 = new Router()

router1.post('/', _ => {})

router1.get('/', async (ctx, next) => {
  ctx.redirectBody = 'hi'
  console.log(`trigger router1, matched length: ${ctx.matched.length}`)
  await next()
})

router2.get('/', async (ctx, next) => {
  ctx.redirectBody = 'hi'
  console.log(`trigger router2, matched length: ${ctx.matched.length}`)
  await next()
})

app.use(router1.routes())
app.use(router2.routes())

// >  curl http://127.0.0.1:8888/
// => trigger router1, matched length: 2
// => trigger router2, matched length: 3

 

有关中间件的试行,在koa-router中也使用了koa-compose来统一玉葱:

var matchedLayers = matched.pathAndMethod

layerChain = matchedLayers.reduce(function(memo, layer) {
  memo.push(function(ctx, next) {
    ctx.captures = layer.captures(path, ctx.captures)
    ctx.params = layer.params(path, ctx.captures, ctx.params)
    ctx.routerName = layer.name
    return next()
  })
  return memo.concat(layer.stack)
}, [])

return compose(layerChain)(ctx, next)

 

那坨代码会在装有相称到的中间件从前增加一个ctx性格赋值的中间件操作,相当于说reduce的施行会让球葱模型对应的中间件函数数量最少X2
layer中或然含有多少个中间件,不要忘了middleware,那正是为啥会在reduce中使用concat而非push
因为要在每二在那之中间件试行此前,修改ctx为这一次中间件触发时的1部分新闻。
包蕴相称到的U宝马X三L参数,以及当前中间件的name等等的音信。

[
  layer1[0], // 第一个register中对应的中间件1
  layer1[1], // 第一个register中对应的中间件2
  layer2[0]  // 第二个register中对应的中间件1
]

// =>

[
  (ctx, next) => {
    ctx.params = layer1.params // 第一个register对应信息的赋值  
    return next()
  },
  layer1[0], // 第一个register中对应的中间件1
  layer1[1], // 第一个register中对应的中间件2
  (ctx, next) => {
    ctx.params = layer2.params // 第二个register对应信息的赋值  
    return next()
  },
  layer2[0]  // 第二个register中对应的中间件1
]

 

routes最后,会调用koa-compose来合并reduce所生成的中间件数组,以及使用了事先在koa-compose中提到了的第三个可选的参数,用来做洋葱实行到位后最后的回调解和管理理。


// app.js
const Koa = require('Koa');
const koaRrouter = require('koa-router');

const app = new Koa();
// 这里可以直接调用函数也可以使用构造函数,const router = new koaRouter();
const router = koaRouter();

router.get(('/', next) => {
  ctx.body = 'this this the home page';
});

app
  .use(router.routes())
  .use(router.allowMethods());

app.listen(3000);

小记

至此,koa-router的重任就已经到位了,完成了路由的注册,以及路由的监听管理。
在阅读koa-router的源码进程中认为到很吸引:

  • 明显代码中曾经完结的功用,为啥在文书档案中就一贯不反映出来吗。
  • 即便文书档案中不写明能够那样来用,为啥还要在代码中有打点的达成呢?

多个最简便易行的举例证明:

  1. 能够通过更改ctx.routerPath来实现forward效益,可是在文书档案中不会报告您
  2. 可以经过router.register(path, ['GET', 'POST'])来极快的监听七个METHOD,但是register被标识为了@private

参考资料:

  • koa-router |
    docs
  • path-to-regexp |
    docs

以身作则代码在仓房中的地点:learning-koa-router

执行 node app.js 打开 http://localhost:3000/ 可以看到

金沙注册送58 3

koa-router

那般二个最简单易行的路由就安排好了~

下边针对地方的例证做一些评释:

  1. get 方法表示一多种 HTTP 的动词方法,如 get | put | post | patch |
    delete | del。每壹种 HTTP 动词对应一种方法,也能够连接写:

router
  .get('/', (ctx, next) => {
    ctx.body = 'Hello World!';
  })
  .post('/users', (ctx, next) => {...})
  .put('/users/:id', (ctx, next) => {...})
  .del('/users/:id', (ctx, next) => {...})
  .all('/users/:id', (ctx, next) => {...})

注:router.all() 用于表示上述全体的动词方法

  1. 地方代码中,router.get()
    方法的率先个参数是协作的路径,第四个参数对应的函数方法。

还要介绍一下动态路由

// 同时打开网址:http://localhost:3000/user/111
router.get('/user/:id', (ctx, next) => {
  console.log(ctx); // 实际就是 context 对象,但是打印出的结果中并没有看到 params 属性,如果有童鞋知道麻烦指点一二,不胜感激~
  console.log(ctx.params); // { id: '111' }
  console.log(ctx._matchedRoute); // /user/:id
})

使用 ctx._matchedRoute
可以得到相当的原路由地方,固然这一个路由被取名了也可以通过
ctx. _matchedRouteName 获得路由的名号,比方:

// 同时打开网址:http://localhost:3000/user/111
router.get('user', '/user/:id', (ctx, next) => {
  console.log(ctx._matchedRouteName); // user
})

下边讲一下 koa-router 的 middleware(中间件)

那是法定给出的实例代码:

router.get(
  '/users/:id',
  (ctx, next) => {
    return User.findOne(ctx.params.id).then(function(user) {
      ctx.user = user;
      next();
    });
  },
  ctx => {
    console.log(ctx.user);
    // => { id: 17, name: "Alex" }
  }
);

middleware
类似于1个过滤器,在客户端和应用程序之间的叁个管理请求和对应的措施,举个例子上边包车型客车实例代码,千万不要纠结这几个
User 是个什么样鬼,那是1段伪代码,User.findOne(ctx.params.id)
能够知晓为从数据库中异步的获得到内定 id 的用户音讯,然后 .then
获取到那么些用户音信赋值给 ctx.user,然后实行
next()主意那么下二个中间件就足以得到具有用户新闻的
ctx,当然还足现在下传,可是须要注意的是中间件的实行顺序,它很像二个球葱,但并不是一层1层外下拨,而是先实践顺序层中
next 在此以前的代码,然后再从最后1层往上返实行 next
前边的代码,听着是或不是有点晕+_+,有一张图能够比较明晰的看懂中间件的进行种种:

金沙注册送58 4

middleware 的实行各样

const Koa = require('koa');
const app = new Koa();

app.use((ctx, next) => {
  console.log(1);
  next(); // next 不写会报错
  console.log(5);
});

app.use((ctx, next) => {
  console.log(2);
  next();
  console.log(4);
});

app.use((ctx, next) => {
  console.log(3)
  ctx.body = 'Hello World';
});

app.listen(3000);
// 打印出1、2、3、4、5,但是好像会打印两遍12345,这个还没有深入了解为啥

上述轻巧的利用打字与印刷出壹、二、3、四、伍,这几个实际上正是koa中间件调整的骨干,一个玉葱结构,从上往下一层1层进来,再从下往上一层一层回去,乍一看很复杂,为啥不直接壹层1层下来就终止吗,就好像express/connect同样,大家就假若next就去下二在这之中间件,干嘛还要回去?

事实上那正是为了减轻复杂应用中1再的回调而布署的级联代码,并不直接把调整权完全交给下1个中间件,而是碰着next去下贰当中间件,等下部都实践完了,还会实行next以下的内容

减轻频仍的回调,那又有怎样依附吗?举个大致的例证,假诺大家须要知道通过中间件的时辰,我们运用koa能够轻巧地写出来,不过使用express呢,能够去看下express
reponse-time的源码,它就只可以通过监听header被write
out的时候然后触发回调函数总括时间,不过koa完全不用写callback,大家只须求在next前边加几行代码就减轻了(直接使用.then()都能够)

莫不如故会不太掌握这么做的补益,小编认为那种思路在实质上采纳中还会不时利用,后边赶过再结合实际应用场景来细读一下~

未完待续…

相关文章

网站地图xml地图