源码结构

|- application.js
|- context.js
|- request.js
|- response.js

context.js
context 是使用delegates将节点request和response对象封装到单个对象中，为编写 Web 应用程序和 API 提供了许多有用的方法。

delegate(proto, 'response')
  .method('attachment')
  .method('redirect')
  .method('remove')
  .method('vary')
  .method('has')
  .method('set')
  .method('append')
  .method('flushHeaders')
  .access('status')
  .access('message')
  .access('body')
  .access('length')
  .access('type')
  .access('lastModified')
  .access('etag')
  .getter('headerSent')
  .getter('writable');

// context 对象
koa-context, {
  inspect: [Function: inspect],
  toJSON: [Function: toJSON],
  assert: [Function: assert] {
    equal: [Function (anonymous)],
    notEqual: [Function (anonymous)],
    ok: [Function (anonymous)],
    strictEqual: [Function (anonymous)],
    notStrictEqual: [Function (anonymous)],
    deepEqual: [Function (anonymous)],
    notDeepEqual: [Function (anonymous)]
  },
  throw: [Function: throw],
  onerror: [Function: onerror],
  cookies: [Getter/Setter],
  attachment: [Function (anonymous)],
  redirect: [Function (anonymous)],
  remove: [Function (anonymous)],
  vary: [Function (anonymous)],
  has: [Function (anonymous)],
  set: [Function (anonymous)],
  append: [Function (anonymous)],
  flushHeaders: [Function (anonymous)],
  status: [Getter/Setter],
  message: [Getter/Setter],
  body: [Getter/Setter],
  length: [Getter/Setter],
  type: [Getter/Setter],
  lastModified: [Getter/Setter],
  etag: [Getter/Setter],
  headerSent: [Getter],
  writable: [Getter],
  ......
}

application.js
其中主要实现了use和listen方法。

• 在 craeteServer 结束后，会触发 callback。
• 在 cakllback 中调用 compose 将 middleware 传入进去。
• 当监听到请求的时候，就会按照顺序执行 middleware。

class Application extends Emitter {
constructor(options){
   ...
  }
  listen(...args) {
    debug('listen');
    const server = http.createServer(this.callback());
    return server.listen(...args);
  }
/**
   * Return a request handler callback
   * for node's native http server.
   *
   * @return {Function}
   * @api public
   */

  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;
  }
}

编写自己的中间件并解析koa-static-server的实现原理

中间件是一个方法，且第一个参数是context，第二个参数是next。
koa-static-server进行了参数处理和路径解析，然后调用koa-send的send方法。
koa-send根据路径使用fs.createReadStream(path)读出文件内容，并且setHeaders。

// koa-static-server/index.js
const send = require("koa-send");
module.exports = function serve(opts) {
  // 解析路径
  let options = opts || {};
  const rootPath = normalize(options.rootPath ? options.rootPath + "/" : "/");
  options.root = resolve(options.rootDir || process.cwd());
  return async (ctx, next) => {
    let path = ctx.path;
    /* Serve folders as specified
        eg. for options:
        rootDir = 'web/static'
        rootPath = '/static'
    'web/static/file.txt' will be served as 'http://server/static/file.txt'
    */

    path = normalize(path.replace(rootPath, "/"));
    /* In case of error from koa-send try to serve the default static file
        eg. 404 error page or image that illustrates error
    */
    try {
      sent = await send(ctx, path, options);
    } catch (error) {
      if (!options.notFoundFile) {
        if (options.last) ctx.throw(404);
      } else {
        sent = await send(ctx, options.notFoundFile, options);
      }
    }

    if (sent && options.last) {
      return;
    } else {
      return next();
    }
  };
};

// koa-send/index.js
module.exports = async function send(ctx, path, opts = {}) {
  const setHeaders = opts.setHeaders;
  if (setHeaders && typeof setHeaders !== "function") {
    throw new TypeError("option setHeaders must be function");
  }
  const root = opts.root ? normalize(resolve(opts.root)) : "";
  path = resolvePath(root, path);
  // 检测文件是否存在,node官网不推荐使用该方式,推荐直接read/write，如果文件不存在就处理错误。
  // 检查文件是否存在而不操作它之后，推荐fs.access()。
  stats = await stat(path);
  if (setHeaders) setHeaders(ctx.res, path, stats);
  // 将文件内容返回
  ctx.set('Content-Length', stats.size)
  ctx.body = fs.createReadStream(path);
  return path;
};

koa-compose

执行步骤：

• 执行第一个中间件，传入context和next(通过 dispatch.bind(null, i + 1)获得，在中间件中执行next()函数，即执行了第二个中间件)
• 执行第二个中间件时，如果方法体中没有执行next()方法，所以不会继续调用dispatch.bind(null, i + 1)方法
• 执行第二个中间件时，如果方法体中执行next()方法，由于middlewareArray中只有两个中间件，所以执行fn = next,由于koa源码中执行的是fn(ctx).then(handleResponse).catch(onerror);,没有传入next,所以直接执行return Promise.resolve();

// koa 源码
const fn = compose(this.middleware);
fn(ctx).then(handleResponse).catch(onerror);

// koa-compose 源码
var middlewareArray = [
  function(context, next) {
    console.log(1);
    next();
    console.log(3);
  },
  function(context, next) {
    console.log(2);
  }
];
function compose(middleware) {
  // 此处的next 是执行完所有中间件之后执行的回调函数
  return function(context, next) {
    let index = -1;
    return dispatch(0);
    function dispatch(i) {
      // 如果在一个 middleware 中调用了 2 次 next 方法，则会报错
      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);
      }
    }
  };
}

var fn = compose(middlewareArray);
fn();
// 1
// 2
// 3