koa && koa-router

一个简单的示例

const Koa = require('koa');
const app = new Koa();
app.use(async ctx => {
    ctx.body = 'hello world'
})

app.listen(3000);

koa是对node请求响应进行封装，从这个示例中我们不难猜出通过listen方法进行http.createServer的调用。
koa的是基于中间件的思想，在调用use的时候会将一系列的中间件进行存储，启用server的时候回调经过中间件包装的函数。

其主要的几个代码如下

new 实例

new的时候进行一些属性的设置，包括context、request、response等。

constructor(options) {
    super();
    options = options || {};
    this.proxy = options.proxy || false;
    this.subdomainOffset = options.subdomainOffset || 2;
    this.proxyIpHeader = options.proxyIpHeader || 'X-Forwarded-For';
    this.maxIpsCount = options.maxIpsCount || 0;
    this.env = options.env || process.env.NODE_ENV || 'development';
    if (options.keys) this.keys = options.keys;
    this.middleware = [];
    this.context = Object.create(context);
    this.request = Object.create(request);
    this.response = Object.create(response);
    // util.inspect.custom support for node 6+
    /* istanbul ignore else */
    if (util.inspect.custom) {
      this[util.inspect.custom] = this.inspect;
    }
  }

use

进行中间件的挂载

use(fn) {
    this.middleware.push(fn);
    return this;
  }

listen

调用http.createServer时会对回调函数进行封装，通过compose将中间件包装成高阶函数，最后在this.handleRequest中进行调用。
respond将返回的结果进行处理，最终返回至客户端。

listen(...args) {
    debug('listen');
    const server = http.createServer(this.callback());
    return server.listen(...args);
  }
  callback() {
    const fn = compose(this.middleware);

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

    const handleRequest = (req, res) => {
      const ctx = this.createContext(req, res);
      return this.handleRequest(ctx, fn);
    };

    return handleRequest;
  }

  handleRequest(ctx, fnMiddleware) {
    const res = ctx.res;
    res.statusCode = 404;
    const onerror = err => ctx.onerror(err);
    const handleResponse = () => respond(ctx);
    onFinished(res, onerror);
    return fnMiddleware(ctx).then(handleResponse).catch(onerror);
  }
  
  function respond(ctx) {
    // allow bypassing koa
    if (false === ctx.respond) return;

    if (!ctx.writable) return;

    const res = ctx.res;
    let body = ctx.body;
    const code = ctx.status;
    ...
    res.end(body);
 }

compose

compose返回的是个高阶函数，在函数内设置dispatch方法的返回值为promise对象， fn的调用参数为ctx和 next。
通过 ctx获取上下文信息，通过next的调用可触发下一个中间件（其过程为通常说的剥洋葱效果）。

function compose (middleware) {
  return 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, dispatch.bind(null, i + 1)));
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }
}

koa-router

示例

const parentRouter = new Router();
const nestedRouter = new Router();

nestedRouter
    .get(/^\/\w$/i, function (ctx, next) {
         return next();
    })
    .get('/first-nested-route', function (ctx, next) {
        return next();
    })
    .get('/second-nested-route', function (ctx, next) {
        ctx.body = 'hello sub';
        return next();
    });

parentRouter.use('/parent-route', function (ctx, next) {
    return next();
}, nestedRouter.routes());

app.use(parentRouter.routes());

app.listen(3000);

如果在不用router插件的话，对于不同的URL走不同的分支，我们需要自己去做判断解决这些问题。
koa-router很好的帮我们解决了路由匹配的问题。

new 一个router

new 一个router的时候会对一些属性做初始化或者赋值操作。其中params用来保存参数信息， stack则用来存储layer信息。

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 = [];
};

get过程

该方法主要是获取中间件，然后调用register方法。

Router.prototype[method] = function(name, path, 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;
    };

register

从该方法可以看出每次对path设置get、post等方法都会new一个Layer作为rout对象返回，最终把route放入stack数组中。
layer用来存储单个路由信息，包括URL、 params、生成正则匹配regexp以及match方法。
从代码上还可以看出如果path为数组则对该数组进行递归的注册。

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

  const router = this;
  const stack = this.stack;

  // support array of paths
  if (Array.isArray(path)) {
    for (let i = 0; i < path.length; i++) {
      const curPath = path[i];
      router.register.call(router, curPath, methods, middleware, opts);
    }

    return this;
  }

  // create route
  const route = new Layer(path, methods, middleware, {...});

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

  // add parameter middleware
  for (let i = 0; i < Object.keys(this.params).length; i++) {
    const param = Object.keys(this.params)[i];
    route.param(param, this.params[param]);
  }

  stack.push(route);

  debug('defined route %s %s', route.methods, route.path);

  return route;
};

中间件注册过程

在koa中通过use进行中间件的注册，而use中注册的是一个包括ctx、next的方法。从app.use(parentRouter.routes());中我们不难推测调用routes方法即返回这样一个对象。

routes调用

通过该方法的调用返回一个带有ctx、next参数的方法。 dispatch的主要功能点：

获取当前的path，通过router.match获取匹配后的信息。
获取所以匹配到的layer，依次遍历将其内容封装成中间件，push到数组中。
通过compose方法将已封装的中间件数组进行粘合，然后调用。即实现路由功能。

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

  let dispatch = function dispatch(ctx, next) {
    debug('%s %s', ctx.method, ctx.path);

    const path = router.opts.routerPath || ctx.routerPath || ctx.path;
    const matched = router.match(path, ctx.method);
    let layerChain;

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

    ctx.router = router;

    if (!matched.route) return next();

    const matchedLayers = matched.pathAndMethod
    const 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 = ctx.request.params = layer.params(path, ctx.captures, ctx.params);
        ctx.routerPath = layer.path;
        ctx.routerName = layer.name;
        ctx._matchedRoute = layer.path;
        if (layer.name) {
          ctx._matchedRouteName = layer.name;
        }
        return next();
      });
      return memo.concat(layer.stack);
    }, []);

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

  dispatch.router = this;

  return dispatch;
};

router.use

在示例中我们还看到，在父路由上通过use方法可以注册子路由，从而实现多级路由功能。
接下来我们可以大致看一下use的过程。

在use中可以传递多个middleare参数。

当middleare为数组时，进行递归调用
当middleare上包含router属性时，说明是通过router.routes()返回的，此时为一个子路由的注册。
针对这种情况，首先对子路由的信息进行copy，对其layer信息进行copy，然后将copy后的layer信息push的父路由的stack中；
如果是单个middleare 中间件方法时，则直接执行注册。

Router.prototype.use = function () {
  const router = this;
  const middleware = Array.prototype.slice.call(arguments);
  let path;

  // support array of paths
  if (Array.isArray(middleware[0]) && typeof middleware[0][0] === 'string') {
    let arrPaths = middleware[0];
    for (let i = 0; i < arrPaths.length; i++) {
      const p = arrPaths[i];
      router.use.apply(router, [p].concat(middleware.slice(1)));
    }

    return this;
  }

  const hasPath = typeof middleware[0] === 'string';
  if (hasPath) path = middleware.shift();

  for (let i = 0; i < middleware.length; i++) {
    const m = middleware[i];
    if (m.router) { // 子路由判断
      const cloneRouter = Object.assign(Object.create(Router.prototype), m.router, {
        stack: m.router.stack.slice(0)
      });

      for (let j = 0; j < cloneRouter.stack.length; j++) {
        const nestedLayer = cloneRouter.stack[j];
        const cloneLayer = Object.assign(
          Object.create(Layer.prototype),
          nestedLayer
        );

        if (path) cloneLayer.setPrefix(path);
        if (router.opts.prefix) cloneLayer.setPrefix(router.opts.prefix);
        // 将克隆后的layer push到当前路由的stack中
        router.stack.push(cloneLayer);
        cloneRouter.stack[j] = cloneLayer;
      }

      if (router.params) {
        function setRouterParams(paramArr) {
          const routerParams = paramArr;
          for (let j = 0; j < routerParams.length; j++) {
            const key = routerParams[j];
            cloneRouter.param(key, router.params[key]);
          }
        }
        setRouterParams(Object.keys(router.params));
      }
    } else {
      const keys = [];
      pathToRegexp(router.opts.prefix || '', keys);
      const routerPrefixHasParam = router.opts.prefix && keys.length;
      router.register(path || '([^\/]*)', [], m, { end: false, ignoreCaptures: !hasPath && !routerPrefixHasParam });
    }
  }

  return this;
};