• 异步化

    异步化

    在前面的例子中，我们并没有对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，这些都是支持异步操作的三方库。