【koa】原理

koa 是一个简易实用的框架，尤其是中间件的设计思想，我并说不出哪里好或者不好，因为我没有实际的使用。大致体会下，就是上一个中间件可以控制下一个，但是顺序紧密结合，从而导致的问题是没有一个好的流程跳转。

当然，这个中间件设计思路对我的影响是有意义的，比如在写业务的时候，设计了一个事件模型，假如有一个事件，在基础代码中预置了逻辑，暴露给业务使用时，提供一个此事件前、后回调并且可以决定是否执行预置逻辑，那么就可以通过 next 机制实现，伪代码如下：

// async or common
Save(next, props){
    // before
    next()
    // after
}

在了解 koa 这个主要的思想之后，下面看下它的大致流程，文件结构划分很简单，只有四个文件，代码量也很少：

application

context

request

response

入口 application

首先是 createServer 启动一个服务，紧接着创建 createContext 关系，再次是中间件调度执行，最后做出响应，按照这个步骤可以实现一套简单的代码：

let http = require('http');
let context = require('./context');
let request = require('./request');
let response = require('./response');

class Koa{
    constructor(){
        this.context = context;
        this.request = request;
        this.response = response;
        this.middlewares = [];
    }
    use(cb){}
    createContext(req, res){
        // 多个示例 避免数据共享
        let ctx = Object.create(this.context);
        ctx.request = Object.create(this.request);
        ctx.response = Object.create(this.response);
        ctx.req = ctx.request.req = req;
        ctx.res = ctx.response.res = res;
        return ctx;
    }
    compose(ctx, middlewares){}
    handleRequest(req, res) {
        res.statusCode = 404;
        let ctx = this.createContext(req, res)
        let composeMiddleware = this.compose(ctx, this.middlewares); //执行后ctx.body会被修改
        ...
    }
    listen(...arg){
        let server = http.createServer(this.handleRequest.bind(this))
        server.listen(...arg)
    }
}

module.exports = Koa;

创建 context 关系时，通过 Object.create 避免多个 koa 实例中 ctx 数据共享。

关于中间件其实没那么神秘，当 use 的时候，收集中间件方法进入一个队列，通过 compose 方法来执行，之前在写 js 进阶部分中有介绍 redux 中的 compose 实现 ，但是这里的中间件执行和 redux 中是不一样的，这是一种异步洋葱模型，原理如下：

    // middlewares 队列包含所有的中间件方法
    compose(ctx, middlewares){
        let dispatch = (index) => {
            // 到达最后一个
            if(index === middlewares.length){
                return Promise.resolve();
            }
            let mid = middlewares[index];
            // next  
            return Promise.resolve(mid(ctx, () => dispatch(index + 1)))
        }
        return dispatch(0);
    }

request/response

对 http 原生方法的一层封装，源码中实现很全面，大致意思如下，：

let parse = require('parseurl');

let request = {
    get url(){
        return this.req.url;
    },
    get path(){
        return parse(this.req).pathname;
    }
}

let response = {
    set body(value){
        this.res.statusCode = 200;
        this._body = value;
    },
    get body(){
        return this._body;
    }
}

context

这个方法主要是对 request/response 中方法的劫持，直接操作 ctx.xxx 即可，无需 ctx.response.xxx，所以思路也很清晰，大致原理如下，就是对 request/response 添加一层代理：

class Delegator{
    constructor(proto, target){
        this.proto = proto;
        this.target = target;
    }

    getters(name) {
        let { proto, target }  = this;
        Object.defineProperty(proto, name, {
            get() {
                return this[target][name];
            },
            configurable: true
          });
        return this;
    }

    setters(name) {
        let { proto, target }  = this;
        Object.defineProperty(proto, name, {
            set(v) {
                this[target][name] = v;
            },
            configurable: true
        });
        return this;
    }
}

let proto = {}

new Delegator(proto, 'request')
    .getters('url')
    .getters('path')

new Delegator(proto, 'response')
    .getters('body')
    .setters('body')

module.exports = proto;

错误机制 

如上的方法中介绍了 koa 一个大致的思路，还有一个很重要的点，那就是错误处理机制。koa 类继承自 event 模块，可以监听错误；错误的处理在 application 和 context 中都有，他们的区别是前者处理的是用户没有进行 app.on('error') 时，则默认帮助监听错误，实现原理如下：

    application.js:
    
    onerror(err){
        //非原生错误拦截掉，否则会正常启动服务 app.onerror('some error')
        const isNativeError = Object.prototype.toString.call(err) === '[object Error]' || err instanceof Error;
        if (!isNativeError){
            throw new TypeError('non-error thrown: ' + err)
        };

        // 原生错误输入日志提示
        const msg = err.stack || err.toString();
        console.error(`\n${msg.replace(/^/gm, '  ')}\n`);
    }
    
    handleRequest(){
        // 如果用户没有 app.on('error') 监听，进行内置的处理
        if (!this.listenerCount('error')){
            this.on('error', this.onerror)
        };
    }

再去看下 context 中的错误处理，它的目的是在中间件中有错误丢出时，可以帮助你处理这个错误，并通过 event 的 emit 通知，这样也可以监听，原理如下：

let proto = {
    throw(...arg){
        const err = new Error();
        err.status = arg[0];
        err.message = arg[1];
        throw err;
    },
    onerror(err) {
        if (null == err) return;
        this.app.emit('error', err, this);
        const { res } = this;
        if (typeof res.getHeaderNames === 'function') {
            res.getHeaderNames().forEach(name => res.removeHeader(name));
        }
        // respond
        this.type = 'text/plain;charset=utf-8';
        this.status = err.status;
        res.end(err.message);
    }
}

测试用例：

app.use(async (ctx, next)=>{
    // 通过这个方法丢出错误
    ctx.throw(403, '暂无权限')
    await next()
})

在上面的 onerror 中仅仅是根据错误作出响应，那么如何捕获到中间件中的错误，这个就需要回到 compose 方法，因为中间件中有错误（执行 ctx.throw 时丢出的），所以可以通过 try catch 进行捕获，并且在执行中间件的时候进行 catch：

    compose(ctx, middlewares){
        let dispatch = (index) => {
            ...
            // next  
            try{
                return Promise.resolve(mid(ctx, ()=> dispatch(index + 1)))
            }catch(err){
                return Promise.reject(err)
            }
        }
        return dispatch(0);
    }
    
    handleRequest(req, res) {
        ...
        const onerror = err => ctx.onerror(err);
        // 通过 catch 调用 context 中的错误处理
        this.compose(ctx, this.middlewares).then(...).catch(onerror)
    }

koa 的设计中主要还是围绕 response/request 的处理，从而展开的一些轻量封装。