异步化

在前面的例子中，我们并没有对RequestHandler中的get或post方法进行异步处理，这就意味着，一旦在get或post方法中出现了耗时间的操作，不仅仅是当前请求被阻塞，按照Tornado框架的工作模式，其他的请求也会被阻塞，所以我们需要对耗时间的操作进行异步化处理。

在Tornado稍早一些的版本中，可以用装饰器实现请求方法的异步化或协程化来解决这个问题。

  • 给RequestHandler的请求处理函数添加@tornado.web.asynchronous装饰器，如下所示：

    1. class AsyncReqHandler(RequestHandler):
    3.     @tornado.web.asynchronous
    4.     def get(self):
    5.        http = httpclient.AsyncHTTPClient()
    6.        http.fetch("http://example.com/", self._on_download)
    8.     def _on_download(self, response):
    9.        do_something_with_response(response)
    10.        self.render("template.html")

  • 给RequestHandler的请求处理函数添加@tornado.gen.coroutine装饰器，如下所示：

    1. class GenAsyncHandler(RequestHandler):
    3.     @tornado.gen.coroutine
    4.     def get(self):
    5.         http_client = AsyncHTTPClient()
    6.         response = yield http_client.fetch("http://example.com")
    7.         do_something_with_response(response)
    8.         self.render("template.html")

  • 使用@return_future装饰器，如下所示：

    1. @return_future
    2. def future_func(arg1, arg2, callback):
    3.     # Do stuff (possibly asynchronous)
    4.     callback(result)
    6. async def caller():
    7.     await future_func(arg1, arg2)

在Tornado 5.x版本中，这几个装饰器都被标记为deprcated（过时），我们可以通过Python 3.5中引入的async和await（在Python 3.7中已经成为正式的关键字）来达到同样的效果。当然，要实现异步化还得靠其他的支持异步操作的三方库来支持，如果请求处理函数中用到了不支持异步操作的三方库，就需要靠自己写包装类来支持异步化。

下面的代码演示了在读写数据库时如何实现请求处理的异步化。我们用到的数据库建表语句如下所示：

  1. create database hrs default charset utf8;
  3. use hrs;
  5. /* 创建部门表 */
  6. create table tb_dept
  7. (
  8.     dno     int not null comment '部门编号',
  9.     dname   varchar(10) not null comment '部门名称',
  10.     dloc    varchar(20) not null comment '部门所在地',
  11.     primary key (dno)
  12. );
  14. insert into tb_dept values
  15.     (10, '会计部', '北京'),
  16.     (20, '研发部', '成都'),
  17.     (30, '销售部', '重庆'),
  18.     (40, '运维部', '深圳');

我们通过下面的代码实现了查询和新增部门两个操作。

  1. import json
  3. import aiomysql
  4. import tornado
  5. import tornado.web
  7. from tornado.ioloop import IOLoop
  8. from tornado.options import define, parse_command_line, options
  10. define('port', default=8000, type=int)
  13. async def connect_mysql():
  14.     return await aiomysql.connect(
  15.         host='120.77.222.217',
  16.         port=3306,
  17.         db='hrs',
  18.         user='root',
  19.         password='123456',
  20.     )
  23. class HomeHandler(tornado.web.RequestHandler):
  25.     async def get(self, no):
  26.         async with self.settings['mysql'].cursor(aiomysql.DictCursor) as cursor:
  27.             await cursor.execute("select * from tb_dept where dno=%s", (no, ))
  28.             if cursor.rowcount == 0:
  29.                 self.finish(json.dumps({
  30.                     'code': 20001,
  31.                     'mesg': f'没有编号为{no}的部门'
  32.                 }))
  33.                 return
  34.             row = await cursor.fetchone()
  35.             self.finish(json.dumps(row))
  37.     async def post(self, *args, **kwargs):
  38.         no = self.get_argument('no')
  39.         name = self.get_argument('name')
  40.         loc = self.get_argument('loc')
  41.         conn = self.settings['mysql']
  42.         try:
  43.             async with conn.cursor() as cursor:
  44.                 await cursor.execute('insert into tb_dept values (%s, %s, %s)',
  45.                                      (no, name, loc))
  46.             await conn.commit()
  47.         except aiomysql.MySQLError:
  48.             self.finish(json.dumps({
  49.                 'code': 20002,
  50.                 'mesg': '添加部门失败请确认部门信息'
  51.             }))
  52.         else:
  53.             self.set_status(201)
  54.             self.finish()
  57. def make_app(config):
  58.     return tornado.web.Application(
  59.         handlers=[(r'/api/depts/(.*)', HomeHandler), ],
  60.         **config
  61.     )
  64. def main():
  65.     parse_command_line()
  66.     app = make_app({
  67.         'debug': True,
  68.         'mysql': IOLoop.current().run_sync(connect_mysql)
  69.     })
  70.     app.listen(options.port)
  71.     IOLoop.current().start()
  74. if __name__ == '__main__':
  75.     main()

上面的代码中，我们用到了aiomysql这个三方库，它基于pymysql封装，实现了对MySQL操作的异步化。操作Redis可以使用aioredis，访问MongoDB可以使用motor，这些都是支持异步操作的三方库。