const express = require('express');
 const app = express();
 const PORT = process.env.PORT || 3000;

 app.get('/', (req, res) => {
  const message = doSomething();
  res.send(message);
 });

 // 错误处理中间件
 app.use(function (err, req, res, next) {
  return res.status(500).send('内部错误！');
 });

 app.listen(PORT, () => console.log(`app listening on port ${PORT}`));

 app.get('/', async (req, res) => {
  const message = doSomething();
  res.send(message);
 });

 app.get('/', async (req, res, next) => {
  try {
   const message = doSomething();
   res.send(message);
  } catch(err) {
   next(err);
  }
 });

 function asyncUtil(fn) {
  return function asyncUtilWrap(...args) {
   const fnReturn = fn(args);
   const next = args[args.length - 1];
   return Promise.resolve(fnReturn).catch(next);
  }
 }

 app.use(asyncUtil(async (req, res, next) => {
  const message = doSomething();
  res.send(message);
 }));

app.use = function use(fn) {
 var path = '/';

 // 省略参数处理逻辑
 ...

 // 初始化内置中间件
 this.lazyrouter();
 var router = this._router;

 fns.forEach(function (fn) {
  // non-express app
  if (!fn || !fn.handle || !fn.set) {
   return router.use(path, fn);
  }

  ...

 }, this);

 return this;
};

proto.use = function use(fn) {
 var offset = 0;
 var path = '/';

 // 省略参数处理逻辑
 ...

 var callbacks = flatten(slice.call(arguments, offset));

 for (var i = 0; i < callbacks.length; i++) {
  var fn = callbacks[i];

  ...

  // add the middleware
  debug('use %o %s', path, fn.name || '<anonymous>')

  var layer = new Layer(path, {
   sensitive: this.caseSensitive,
   strict: false,
   end: false
  }, fn);

  layer.route = undefined;

  this.stack.push(layer);
 }

 return this;
};

// 部分核心代码
proto.handle = function handle(req, res, out) {
 var self = this;
 var idx = 0;
 var stack = self.stack;

 next();

 function next(err) {
  var layerError = err === 'route'
   "htmlcode">

Layer.prototype.handle_error = function handle_error(error, req, res, next) {
 var fn = this.handle;

 if (fn.length !== 4) {
  // not a standard error handler
  return next(error);
 }

 try {
  fn(error, req, res, next);
 } catch (err) {
  next(err);
 }
};




「内部通过判断函数的形参个数过滤掉非错误处理中间件」。

如果 next 函数内部没有异常情况，则调用 layer 实例的 handle_request 方法：


Layer.prototype.handle_request = function handle(req, res, next) {
 var fn = this.handle;

 if (fn.length > 3) {
  // not a standard request handler
  return next();
 }

 try {
  fn(req, res, next);
 } catch (err) {
  next(err);
 }
};




 「 handle 方法初始化执行了一次 next 方法，但是该方法每次调用最多只能匹配一个中间件 」 ，所以在执行 handle_error 和 handle_request 方法时，会将 next 方法透传给中间件，这样开发者就可以通过手动调用 next 方法的方式来执行接下来的中间件。
从上述中间件的执行流程中可以知晓， 「 用户注册的中间件方法在执行的时候都会包裹一层 try/catch，但是 try/catch 无法捕获 async 函数内部的异常，这也就是为什么 Express 中无法通过注册错误处理中间件来拦截到 async 语法声明的中间件的异常的原因 」 。
修改源码


找到本质原因之后，可以通过修改源码的方法来进行适配：


Layer.prototype.handle_request = function handle(req, res, next) {
 var fn = this.handle;

 if (fn.length > 3) {
  // not a standard request handler
  return next();
 }
 // 针对 async 语法函数特殊处理
 if (Object.prototype.toString.call(fn) === '[object AsyncFunction]') {
  return fn(req, res, next).catch(next);
 }

 try {
  fn(req, res, next);
 } catch (err) {
  next(err);
 }
};




上述代码在 handle_request 方法内部判断了中间件方法通过 async 语法声明的情况，从而采用 Promise 对象的 catch 方法来向下传递异常。
「 这种方式可以减少上层冗余的代码，但是实现该方式，可能需要 fork 一份 Express4.x 的源码，然后发布一个修改之后的版本，后续还要跟进官方版本的新特性，相应的维护成本非常高。 」
express5.x 中将 router 部分剥离出了单独的路由库 -- router
AOP（面向切面编程）


为了解决上述方案存在的问题，我们可以尝试利用 AOP 技术在不修改源码的基础上对已有方法进行增强。


app.use(async function () {
 const message = doSomething();
 res.send(message);
})




以注册应用级别中间件为例，可以对 app.use 方法进行 AOP 增强：


const originAppUseMethod = app.use.bind(app);
app.use = function (fn) {
 if (Object.prototype.toString.call(fn) === '[object AsyncFunction]') {
  const asyncWrapper = function(req, res, next) {
   fn(req, res, next).then(next).catch(next);
  }
  return originAppUseMethod(asyncWrapper);
 }
 return originAppUseMethod(fn);
}




前面源码分析的过程中，app.use 内部是有 this 调用的，所以这里需要 「 利用 bind 方法来避免后续调用过程中 this 指向出现问题。 」
然后就是利用 AOP 的核心思想，重写原始的 app.use 方法，通过不同的分支逻辑代理到原始的 app.use 方法上。
「 该方法相比较修改源码的方式，维护成本低。但是缺点也很明显，需要重写所有可以注册中间件的方法，不能够像修改源码那样一步到位。 」
写在最后


本文介绍了 Express 中使用 async 语法的四种解决方案：

  
try/catch
  
高阶函数
  
修改源码
  
AOP

除了 try/catch 方法性价比比较低，其它三种方法都需要根据实际情况去取舍，举个栗子：
如果你需要写一个 Express 中间件提供给各个团队使用，那么修改源码的方式肯定走不通，而 AOP 的方式对于你的风险太大，相比较下，第二种方案是最佳的实践方案。