// 第一步 - 初始化app對象
var koa = require('koa');
var app = koa();
// 第二步 - 監聽端口
app.listen(1995);

初始化

執行koa()的時候初始化了一些很有用的東西，包括初始化一個空的中間件集合，基于Request，Response，Context為原型，生成實例等操作。Request和Response的屬性和方法委托到Context中也是在這一步進行的。在這一步并沒有啟動Server。

module.exports = class Application extends Emitter {
    /**
    * Initialize a new 'Application'.
    *
    * @api public
    */
    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);
    }
    ...

幾項配置的含義：
env 環境，默認為 NODE_ENV 或者 development
proxy 如果為 true，則解析 "Host" 的 header 域，并支持 X-Forwarded-Host
subdomainOffset 默認為2，表示 .subdomains 所忽略的字符偏移量。

啟動Server

app.listen = function () {
    debug('listen');
    var server = http.createServer(this.callback());
    return server.listen.apply(server, arguments);
};

在執行app.listen(1995)的時候，啟動了一個server，并且監聽端口。
http.createServer接收一個函數作為參數，每次服務器接收到請求都會執行這個函數，并傳入兩個參數（request和response，簡稱req和res），那么現在重點在this.callback這個方法上。

callback

app.callback = function () {
    if (this.experimental) {
        console.error('Experimental ES7 Async Function support is deprecated. Please look into Koa v2 as the middleware signature has changed.')
    }
    var fn = this.experimental
        ? compose_es7(this.middleware)
        : co.wrap(compose(this.middleware));
    var self = this;
    if (!this.listeners('error').length) this.on('error', this.onerror);
    return function (req, res) {
        res.statusCode = 404;
        var ctx = self.createContext(req, res);
        onFinished(res, ctx.onerror);
        fn.call(ctx).then(function () {
            respond.call(ctx);
        }).catch(ctx.onerror);
    }
};

上述代碼完成了兩件事情：初始化中間件，接收處理請求。

初始化中間件

其中，compose的全名叫koa-compose，他的作用是把一個個不相干的中間件串聯在一起。

// 有3個中間件
this.middlewares = [function *m1() {}, function *m2() {}, function *m3() {}];
// 通過compose轉換
var middleware = compose(this.middlewares);
// 轉換后得到的middleware是這個樣子的
function *() {
yield *m1(m2(m3(noop())))
}

上述是V1的代碼，跟V2意思差不多。generator函數的特性是，第一次執行并不會執行函數里的代碼，而是生成一個generator對象，這個對象有next，throw等方法。
這就造成了一個現象，每個中間件都會有一個參數，這個參數就是下一個中間件執行后，生成出來的generator對象，沒錯，這就是大名鼎鼎的 next。
那compose是如何實現這樣的功能的呢？我們看一下代碼:

module.exports = compose
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)
            }
        }
    }

這里的邏輯就是：先把中間件從后往前依次執行，并把每一個中間件執行后得到的值賦值給變量next，當下一次執行中間件的時候（也就是執行前一個中間件的時候），把next傳給第二個參數。這樣就保證前一個中間件的參數是下一個中間件生成的值，第一次執行的時候next為underfined。

compose(this.middleware)() = this.middleware[0](context, this.middleware[1](context, this.middleware[2](context, null)))
有一個問題，什么時候會出現i <= index的情況？答案是當一個中間件中兩次調用next時。比如，當第二個中間件里兩次調用next，那執行結果就變成了這樣。

可以看出，當第二次執行next時，index===i，就會拋出異常。

注意：一個中間件里是不能多次調用next的。

接收請求

return function(req, res){
    res.statusCode = 404;
    var ctx = self.createContext(req, res);
    onFinished(res, ctx.onerror);
    fn.call(ctx).then(function () {
        respond.call(ctx);
    }).catch(ctx.onerror);
}

創建上下文

var ctx = self.createContext(req, res);

對應的源碼是：

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

koa中的this其實就是app.createContext方法返回的完整版context。
又由于這段代碼的執行時間是接受請求的時候，所以表明:
每一次接受到請求，都會為該請求生成一個新的上下文。
可以看看，經過這一步處理后他們之間的關系是怎樣的，可以用這個圖來表示：

從上圖中，可以看到分別有五個箭頭指向ctx，表示ctx上包含5個屬性，分別是request，response，req，res，app。request和response也分別有5個箭頭指向它們，所以也是同樣的邏輯。

介紹一下這幾個概念：
ctx，就是上下文，context 在每個 request 請求中被創建，在中間件中作為接收器(receiver)來引用，或者通過 this 標識符來引用：

app.use(function *(){
    this; // is the Context
    this.request; // is a koa Request
    this.response; // is a koa Response
});

node里有request和response兩個對象，分別有處理請求和響應的API。在koa里，將這兩個對象封裝在了ctx里，可以通過ctx.req(=noderequest)和ctx.res(=node request)來使用。
Koa Request 對象(=ctx.request)是對 node 的 request 進一步抽象和封裝，提供了日常 HTTP 服務器開發中一些有用的功能。
Koa Response 對象(=ctx.response)是對 node 的 response 進一步抽象和封裝，提供了日常 HTTP 服務器開發中一些有用的功能。
許多 context 的訪問器和方法為了便于訪問和調用，簡單的委托給他們的 ctx.request 和 ctx.response 所對應的等價方法，比如說 ctx.type 和 ctx.length 代理了 response 對象中對應的方法，ctx.path 和 ctx.method 代理了 request 對象中對應的方法。
app是應用實例引用。
具體API看http://koa.bootcss.com/

錯誤監視

onFinished(res, ctx.onerror);

這行代碼的作用是監聽response，如果response有錯誤，會執行ctx.onerror中的邏輯，設置response類型，狀態碼和錯誤信息等。

執行中間件

fn.call(ctx).then(function () {
    respond.call(ctx);
}).catch(ctx.onerror);

fn是compose（初始化中間件）執行后的結果，fn.call(ctx)執行中間件邏輯，執行成功則接著執行response.call(ctx)，否則進行錯誤處理。
請求的時候會經過一次中間件，響應的時候又會經過一次中間件。

var koa = require('koa');
var app = koa();
app.use(function* f1(next) {
    console.log('f1: pre next');
    yield next;
    console.log('f1: post next');
    yield next;
    console.log('f1: fuck');
});
app.use(function* f2(next) {
    console.log(' f2: pre next');
    yield next;
    console.log(' f2: post next');
    yield next;
    console.log(' f2: fuck');
});
app.use(function* f3(next) {
    console.log(' f3: pre next');
    yield next;
    console.log(' f3: post next');
    yield next;
    console.log(' f3: fuck');
});
app.use(function* (next) {
    console.log('hello world')
    this.body = 'hello world';
});
app.listen(3000);

打印如下：

f1: pre next
f2: pre next
f3: pre next
hello world
f3: post next
f3: fuck
f2: post next
f2: fuck
f1: post next
f1: fuck

用一張圖表示如下：

由于每次接收請求，都會執行callback，所以每次接收請求以下操作都會被執行：

• 初始化中間件
• 生成新的上下文
• 執行中間件邏輯
• 響應請求或錯誤處理