Koa2 源码分析

.
├── AUTHORS
├── CODE_OF_CONDUCT.md
├── History.md
├── LICENSE
├── Makefile
├── Readme.md
├── benchmarks
├── docs
├── lib
│   ├── application.js
│   ├── context.js
│   ├── request.js
│   └── response.js
├── package.json
└── test

const Koa = require('koa'); // 导入 Koa, 即导入 Application 类
const app = new Koa(); // 创建 Application 类的实例

/**
 * Shorthand for:
 *
 *    http.createServer(app.callback()).listen(...)
 *
 * @param {Mixed} ...
 * @return {Server}
 * @api public
 */
 
listen(...args) {
  debug('listen');
  const server = http.createServer(this.callback());
  return server.listen(...args);
}

/**
 * Use the given middleware `fn`.
 *
 * Old-style middleware will be converted.
 *
 * @param {Function} fn
 * @return {Application} self
 * @api public
 */
 
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;
}

app
  .use(function (ctx, next) {
    // do some thing
  })
  .use(function (ctx, next) {
    // do some thing
  });
// ...

  /**
   * Return a request handler callback
   * for node's native http server.
   *
   * @return {Function}
   * @api public
   */
 
  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;
  }

/**
 * Initialize a new context.
 *
 * @api private
 */
 
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;
}

if (false === ctx.respond) return;
// ...
if (!ctx.writable) return;

// 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();
}

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

function compose(middleware) {
  if (!Array.isArray(middleware))
    throw new TypeError('Middleware stack must be an array!');
  for (const fn of middleware) {
    if (typeof fn !== 'function')
      throw new TypeError('Middleware must be composed of functions!');
  }
 
  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, function next() {
            return dispatch(i + 1);
          }),
        );
      } catch (err) {
        return Promise.reject(err);
      }
    }
  };
}

async function middleware1() {
    console.log('middleware1 begin');
    await middleware2();
    console.log('middleware1 end');
}
 
async function middleware2() {
    console.log('middleware2 begin');
    await middleware3();
    console.log('middleware2 end');
}
 
function middleware3() {
    console.log('middleware3 begin');
    console.log('middleware3 end');
}
 
middleware1();
// 执行结果
middleware1 begin
middleware2 begin
middleware3 begin
middleware3 end
middleware2 end
middleware1 end

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

const onerror = (err) => ctx.onerror(err);
const handleResponse = () => respond(ctx);
onFinished(res, onerror);
return fn(ctx).then(handleResponse).catch(onerror);

if (null == err) return;
 
if (!(err instanceof Error)) err = new Error(`non-error thrown: ${err}`);

let headerSent = false;
if (this.headerSent || !this.writable) {
  headerSent = err.headerSent = true;
}
 
// delegate
this.app.emit('error', err, this);
 
// nothing we can do here other
// than delegate to the app-level
// handler and log.
if (headerSent) {
  return;
}

// first unset all headers
if (typeof res.getHeaderNames === 'function') {
  res.getHeaderNames().forEach((name) => res.removeHeader(name));
} else {
  res._headers = {}; // Node < 7.7
}

// then set those specified
this.set(err.headers);
 
// force text/plain
this.type = 'text';
 
// ENOENT support
if ('ENOENT' == err.code) err.status = 404;
 
// default to 500
if ('number' != typeof err.status || !statuses[err.status]) err.status = 500;

const code = statuses[err.status];
const msg = err.expose ? err.message : code;
this.status = err.status;
this.length = Buffer.byteLength(msg);
this.res.end(msg);

const request = (context.request = Object.create(this.request));
// ...
context.req = request.req = response.req = req;
// ...
request.response = response;

const response = (context.response = Object.create(this.response));
// ...
context.res = request.res = response.res = res;
// ...
response.request = request;