app.use(async function (ctx, next) {
let start = new Date()
await next()
let ms = new Date() - start
console.log('%s %s - %s', ctx.method, ctx.url, ms)
})

  /**
   * 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;
  }
  /**
   * 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;
  }
  /**
   * Handle request in callback.
   *
   * @api private
   */
  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 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)
            }
        }
    }
}

Promise.resolve(function(context, next){
    //中间件一第一部分代码
    await/yield next();
 
    //中间件一第二部分代码}());

Promise.resolve(function(context, 中间件2){
    //中间件一第一部分代码
    await/yield Promise.resolve(function(context, next){
 
        //中间件二第一部分代码
        await/yield next();
 
        //中间件二第二部分代码
    }())
    //中间件一第二部分代码}());

Promise.resolve(function(context, 中间件2){
    //中间件一第一部分代码
    await/yield Promise.resolve(function(context, 中间件3){
 
        //中间件二第一部分代码
        await/yield Promise(function(context){
 
            //中间件三代码
        }());
        //中间件二第二部分代码
    })
    //中间件一第二部分代码}());

const compose = require('koa-compose')
const middleware1 = (ctx, next) => {
    console.log('here is in middleware1, before next:');
    next();
    console.log('middleware1 end');
}
const middleware2 = (ctx, next) => {
    console.log('here is in middleware2, before next:');
    next();
    console.log('middleware2 end');
}
const middleware3 = (ctx, next) => {
    console.log('here is in middleware3, before next:');
    next();
    console.log('middleware3 end');
}
const middlewares = compose([middleware1, middleware2, middleware3])
console.dir(middlewares())