之前一直使用Express搭建web服务端，从3.x到4.x，最近开始接触KOA2,突然有种如沐春风的感觉，除了相比Express更加简洁的语法外，他的异常处理机制也是让我眼前一亮。
之前用Express的时候异常的捕获常用到的方法有：
- 在代码块中通过try catch来捕获异常，这种方法对于异步处理无法捕获。
- 采用捕获进程中的uncaughtException事件，这种处理方式一方面发生请求错误的时候无法响应请求，這可能会导致服 务器内存溢出。
- 采用domain的是方式，但是目前Nodejs官方已经放弃这个API了，具体原因不详。
综上所述Express在异常的捕获和处理上是比较繁琐的，需要结合上面的三种方法，才能写出健壮性比较好的代码。但KOA的异常处理就相对简单明了多了。
异常捕获
来看一下KOA是怎样捕获异常的：
const http = require('http');
const https = require('https');
const Koa = require('koa');
const app = new Koa();
app.use((ctx)=>{
str="hello koa2";//沒有声明变量
ctx.body=str;
})
app.on("error",(err,ctx)=>{//捕获异常记录错误日志
console.log(new Date(),":",err);
});
http.createServer(app.callback()).listen(3000); 上面的代码运行后在浏览器访问返回的结果是“Internal Server error”;我们发现当错误发生的时候后端程序并没有死掉，只是抛出了异常，前端也同时接收到了错误反馈，是不是感觉比express简单多了？
其实不管是KOA还是Express其实异常都是发生在请求的处理过程中，对于KOA来说，异常发生在中间件的执行过程中，所以只要我们在中间件执行过程中将异常捕获并处理就OK了。
下面我们来看看中间件的执行过程，首先就是添加中间件use方法:
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;
}fn可以是三种类型的函数，普通函数，generator函数，还有async函数。最后generator会被转成async函数，关于async和generator可以看看]async 函数的含义和用法这篇文章。所以最终中间件数组只会有普通函数和async函数。
下面我们在来看看中间件对象middleware在的使用：
const fn = compose(this.middleware);koa-compose
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)
}
}
}
}
compose的作用就是将所有的中间件生成一个中间件自执行链，有点类似co模块。这样我们只需要执行第一个中间件，后面的中间件就会依次执行。可以发现每个中间件都被被封装成了一个Promise，其实这里我刚刚开始看的时候还是有一点蒙圈，主要还是对async和Promise.resolve和new Promise这之间的区别傻傻分不清。Promise.resolve和其实就是返回一个成功状态的Promise对象,相当于:
new Promise((resolve)=>resolve()); 同理Promise.reject就相当于
new Promise((resolve,reject)=>reject())具体KOA2中中间件的自执行实现我后面会专门分析，我还是接着分析在执行过程中的异常捕获和处理。
前面我们说了middleware里面只有两类函数普通函数和async函数,所以，我们在中间件中就考虑这两类函数在执行时的异常捕获。
首先是普通函数，普通函数的正常异常可以直接被try catch捕获，然后返回一个失败状态的Promise，但是但是如果在普通函數中写异步代码，在异步代码中发生的异常时没法捕获的，会直接导致服务断掉，比如：
app.get("/",(ctx,next)=>{setTimeout(()=> new Error("this is an error"),1000)})在KOA2 中是不推荐使用这种异步程序的，异步程序全部可以使用asyn函数来将异步转换成同步代码块。
第二种就是async函数了：
async function getFile(){
console.info(`start time[${new Date()}]`);
try{
await readFile();
}catch(e){
console.log("occur error:",e);
}
console.info(`endtime[${new Date()}]`);
}
function readFile(){
return new Promise((resolve,reject)=>{
setTimeout(()=>{resolve("ok")},1000)
})
}
getFile();其实async 函数中的await是在等待一个resolved状态的Promise对象，简单来说await就是一个then的语法糖，并沒有catch,所以不会捕获异常, 那就需要使用try/catch来捕获异常，并进行相应的逻辑处理。
在説以我們在dispatch中看見了這一段代碼
try {
return Promise.resolve(fn(context, function next () {
return dispatch(i + 1)
}))
} catch (err) {
return Promise.reject(err)
}通过这一段代码就可以在中间件执行链顺利执行结束时返回一个resolved状态的Promise,在发生异常的时候返回一个rejected状态的Promise，在application.js中通过下面这段代码处理这两种状态
return fnMiddleware(ctx).then(handleResponse).catch(onerror);通过最终通过Promise对象的catch来捕获到异常。
异常处理
当异常捕获是有两种处理方式，一种就是响应错误请求，而就是触发注册注册全局错误事件，比如记录错误日志…,先来看看我们前面提到的发生异常的时候前端收到的“Internal Server error”是怎么来的。
catch后交给了ctx.onerror处理,ctx.onerror在context.js中有定义：
context.js
onerror(err) {
//判断err是否存在
if (null == err) return;
if (!(err instanceof Error)) err = new Error(util.format('non-error thrown: %j', err));
let headerSent = false;
if (this.headerSent || !this.writable) {
headerSent = err.headerSent = true;
}
//通过Node的事件机制触发全局的error事件
this.app.emit('error', err, this);
if (headerSent) {
return;
}
const { res } = this;
// 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);
// 设置响应类型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);
}
};
通过这样法，当异常发生时程序就会主动的抛出异常，同时发生错误的请求响应，不需要我们在去手动的返回错误信息。
然后就是触发全局的自定义异常处理，在上面这段代码中出现了 this.app.emit(‘error’, err, this);这里触发了全局的error事件，我们再看看在哪里注册的事件，在application中出现了
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;
}this是继承了node的事件对象的，所以可以通过on来注册全局事件，服务在启动的时候会默认注册一个error全局事件，我们知道node的事件机制可以同一个事件多次注册的，它维护的是这个事件的一个事件数组，所以我们可以自定error事件。这样我们在最前面写的
app.on("error",(err,ctx)=>{//捕获异常记录错误日志
console.log(new Date(),":",err);
});也就能在异常发生时执行了。
总的来說KOA异常捕获和处理的核心就是try catch和nodejs的事件机制。什么？try catch，沒錯，就是他，前面不是說他不能捕获异步异常吗？他是不能捕获异步异常，但是KOA里面使用了async await他相当于把当前异步代码变成了同步处理，so,我们可以当做其实是在处理同步代码的异常。
大概就是这样了。不知道这么理解对不对，欢迎更正。