Tornado初见（一）

已于 2022-11-13 07:48:10 修改
阅读量454 收藏 2
点赞数
分类专栏： Tornado 文章标签： tornado
于 2022-10-22 22:24:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rhx_qiuzhi/article/details/127467616
版权

在之前的其他博客中介绍了Django，这里介绍一下Tornado。两者的区别可以总结为：

  1. django大而全，适合小型的压力不大的项目，一旦压力上来其是扛不住的，毕竟一是太重，而是非异步。 但是好处就是什么都有，你能想到的功能其都有对应contrib组件给你用
  2. tornado好处是epoll异步性能高，还支持长连接。 坏处是：功能/第三方库相对少，而且想多实例还要自己去配置，再者没有很成熟的配套framework,而只是提供了核心的功能，其余的都需要你自己来做。

1.tornado初见

使用Tornado之前需要pip安装

pip3 install tornado

参考教程，tornado书写如下app.py脚本

import tornado.ioloop
from tornado.web import RequestHandler, Application
from tornado.httpserver import HTTPServer
from tornado.options import options, define

define('port', default=8000, help='监听端口')


class HelloHandler(RequestHandler):
    def get(self):
        self.write('hello world')


if __name__ == '__main__':
    options.parse_command_line()
    handlers_routes = [
        (r'/', HelloHandler)
    ]
    app = Application(handlers=handlers_routes)
    http_server = HTTPServer(app)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

运行python app.py，在浏览器中输入http://127.0.0.1:8000。展示结果如下
在这里插入图片描述
这一点来看和Django比较相似，很“容易”展示出需要的首个web请求界面

Tornado中最重要的一个模块是web， 它就是包含了 Tornado 的大部分主要功能的 Web 框架。其它的模块都是工具性质的， 以便让 web 模块更加有用 后面的 Tornado 攻略 详细讲解了 web 模块的使用方法。Tornado中主要有以下模块信息：
主要模块

  • web - FriendFeed 使用的基础 Web 框架，包含了 Tornado 的大多数重要的功能
  • escape - XHTML,JSON, URL 的编码/解码方法
  • database - 对 MySQLdb 的简单封装，使其更容易使用
  • template - 基于Python 的 web 模板系统
  • httpclient - 非阻塞式 HTTP 客户端，它被设计用来和 web 及 httpserver协同工作
  • auth - 第三方认证的实现（包括 Google OpenID/OAuth、Facebook Platform、YahooBBAuth、FriendFeed OpenID/OAuth、Twitter OAuth）
  • locale - 针对本地化和翻译的支持
  • options - 命令行和配置文件解析工具，针对服务器环境做了优化

底层模块

  • httpserver - 服务于 web 模块的一个非常简单的 HTTP 服务器的实现
  • iostream - 对非阻塞式的 socket 的简单封装，以方便常用读写操作
  • ioloop - 核心的 I/O 循环

2.释义

2.1.RequestHandler

RequestHandler 是专门用来处理客户端请求的类，需要自定义一个类并继承它并实现对应的方法。我在示例里只实现了get方法，用它来处理get请求，如果你需要处理post请求就需要实现post方法。在RequestHandler类，一共定义了7个处理请求的方法

def _unimplemented_method(self, *args: str, **kwargs: str) -> None:
    raise HTTPError(405)

head = _unimplemented_method  # type: Callable[..., Optional[Awaitable[None]]]
get = _unimplemented_method  # type: Callable[..., Optional[Awaitable[None]]]
post = _unimplemented_method  # type: Callable[..., Optional[Awaitable[None]]]
delete = _unimplemented_method  # type: Callable[..., Optional[Awaitable[None]]]
patch = _unimplemented_method  # type: Callable[..., Optional[Awaitable[None]]]
put = _unimplemented_method  # type: Callable[..., Optional[Awaitable[None]]]
options = _unimplemented_method  # type: Callable[..., Optional[Awaitable[None]]]

Tornado 的 Web 程序会将 URL 或者 URL 范式映射到 tornado.web.RequestHandler 的子类上去。在其子类中定义了 get() 或 post() 等如上的各种方法，用以处理不同的 HTTP 请求。

2.2.Application

Application对应整个web应用，在创建Application时需要指定handlers参数，它是一个列表，列表里的元素是元组，元组的第一个元素是正则表达式，用来匹配请求的path，元组的第二个元素是自定义的Handler， 这个Handler用来处理与正则表达式相匹配的请求，因此Application的功能是用来匹配请求路由映射。

handlers参数解决的是请求与处理请求类之间的映射关系，它的作用等同于flask的路由。

2.3.HTTPServer

tornado 既是一个web框架也是一个web服务器，web框架让我们专注于处理业务逻辑，Application是web框架体现，HTTPServer是web服务器的体现。

怎么区分他们呢？你就看在哪里设置监听host和端口号，host与端口号是一组和服务器相关的概念，web框架不涉及这些东西，web框架只帮助你快速的进行web应用的开发，而host和端口号是部署的时候用的。http_server.listen(8000) 表明要监听8000端口，listen方法还可以设置address参数，默认是空字符串，表示监听地址是0.0.0.0。

def listen(self, port: int, address: str = "") -> None:

引入了tornado.httpserver模块，顾名思义，它就是tornado的HTTP服务器实现。

这里创建了一个HTTP服务器实例http_server，因为服务器要服务于我们刚刚建立的web应用，将接收到的客户端请求通过web应用中的路由映射表引导到对应的handler中，所以在构建http_server对象的时候需要传出web应用对象app。http_server.listen(8000)将服务器绑定到8000端口

2.4 ioloop

ioloop模块是tornado的精髓所在，tornado之所以具有较高的性能，全赖ioloop提供的异步io能力。对于ioloop，在初学阶段，你只需要掌握这一行代码就足够了

tornado.ioloop.IOLoop.current().start()

2.5 define 与 options

define和options相互配合以实现tornado web应用的配置，define定义web启动时的各项参数，options.parse_command_line()函数解析启动命令中的参数，port参数设置有默认值，如果我在启动时不指定端口，则使用默认端口号8000，我也可以指定端口号

python web.py --port=8001

程序启动后，options.port的值是8001

3.路由模块

所谓路由模块是指域名后的资源定位符，比如get请求为域名+查询字符串串。tornado中路由系统建立请求path和处理该类请求代码（函数，类）之间的映射关系。

3.1.路由系统示例

import tornado.ioloop
from tornado.web import RequestHandler, Application
from tornado.httpserver import HTTPServer
from tornado.options import options, define

define('port', default=8000, help='监听端口')


class HelloHandler(RequestHandler):
    def get(self):
        self.write('hello world')

class IndexHandler(RequestHandler):
    def get(self):
        self.write('welcome to IndexHandler')

if __name__ == '__main__':
    options.parse_command_line()
    handlers_routes = [
        (r'/', HelloHandler),
        (r'/index', IndexHandler)
    ]
    app = Application(handlers=handlers_routes)
    http_server = HTTPServer(app)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

运行之后，在浏览器中输入 http://127.0.0.1:8000/index 结果如下所示：
在这里插入图片描述
在创建Application对象时，需要设置handlers参数，如上代码所示，handlers_routes 是一个列表，列表里的元素是元组，元素第一个元素是正则表达式，描述的是请求的path，第二个元素是RequestHandler类，处理path符合前面正则表达式的请求。

3.2.动态路由

动态路由比较典型的例子就是实用Django访问一个blog的示例。这个帖子比较常见。tornado 也支持动态路由，结合正则表达式分组的知识

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# This module is ***
# @Time : 2022/10/22 21:59
# @Author : renhuaxi
# @Site : 
# funciton:
# @File : pathdemo.py
import tornado.ioloop
from tornado.web import RequestHandler, Application
from tornado.httpserver import HTTPServer
from tornado.options import options, define


define('port', default=8000, help='监听端口')


class HelloHandler(RequestHandler):
    def get(self, name):
        self.write('hello world')

class IndexHandler(RequestHandler):
    def get(self):
        self.write('welcome to IndexHandler')

# 新增用户指定的路由请求
class UserHandler(RequestHandler):
    def get(self, name):
        self.write(f'welcome {name}')

if __name__ == '__main__':
    options.parse_command_line()
    handlers_routes = [
        (r'/', HelloHandler),
        (r'/index', IndexHandler),
        # 新增一个路由转发关系
        (r'/user/(.*)', UserHandler)
    ]
    app = Application(handlers=handlers_routes)
    http_server = HTTPServer(app)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

输出结果如下所示：
在这里插入图片描述
r’/user/(.)’ 是一个正则表达式，(.) 是一个分组，其匹配到的内容将传递给UserHandler类的get方法中的name参数。正则表达式里有几个分组，在对应的处理请求的方法里就要有几个参数。

下面的正则表达式也成立，而且代码更利于阅读，你可以根据正则表达式里的捕获分组准确的理解path里每一个分组的含义

(r'/user/(?P<name>.*)', UserHandler)

3.3.URLSpec

from tornado.routing import URLSpec

handlers_routes = [
        (r'/', HelloHandler),
        URLSpec(r'/index', IndexHandler),
        (r'/user/(?P<name>.*)', UserHandler)
    ]

可以使用URLSpec类来确定路径和处理请求类之间的映射关系，这与使用元组在效果上是相同的。使用元组，tornado会根据元组里的数据生成Rule对象，而URLSpec是Rule的子类

3.4.add_handlers

Application 类的add_handlers方法允许你自由添加路由规则，不仅如此，还可以向指定的host进行添加。

app = Application(handlers=handlers_routes)
    app.add_handlers(r'.*', [(r'/user/(?P<name>.*)', UserHandler)])

add_handlers的第一个参数是host_pattern，根据host_pattern生成Matcher对象，只有请求头里的host匹配了host_pattern才会生效，r’.’ 表示任意字符重复0次或多次，任意host都可以使用这些路由规则。app = Application(handlers=handlers_routes) 这种写法在源码里生成的是AnyMatches对象，同r’.'一样，匹配任意host。

如果你的web服务有多个域名，而且希望不同的域名有不同的路由规则，那么你可以使用add_handlers方法来实现，在/etc/hosts里配置如下域名解析

  • 127.0.0.1 mycool.com
  • 127.0.0.1 mypythonweb.com
    修改web应用如下所示
app = Application(handlers=handlers_routes)
    app.add_handlers(r'mycool.com', [(r'/user/(?P<name>.*)', UserHandler)])

访问http://mycool.com:8000/user/dongsheng 可以得到正确响应，而访问http://mypythonweb.com:8000/user/dongsheng ，得到的就是一个404 not found， host_pattern 可以匹配mycool.com，但不能匹配mypythonweb.com，因此(r’/user/(?P.*)’ 对于mypythonweb.com是不可见的

4.RequestHandler子类处理http请求

使用tornado进行web编程的关键是自定义继承RequestHandler的子类并实现特定的方法，RequestHandler等价于flask框架里的视图，对RequestHandler的理解和使用将决定你能否掌握tornado框架。这是连接请求与web服务的关键环节之一。

4.1.self.request对象

处理客户端的请求，最重要的当然是获的请求的参数，这一点已经在获取请求参数那一篇教程中进行了讲解，除此以外，请求的headers也是十分重要的信息，与请求有关的信息都存储在self.request对象中.

import tornado.ioloop
from tornado.web import RequestHandler, Application
from tornado.httpserver import HTTPServer
from tornado.options import options, define

define('port', default=8000, help='监听端口')


class HelloHandler(RequestHandler):
    def get(self):
        print('************输出headers信息************')
        print(self.request.headers)             # 字典形式存储的headers信息
        print('************输出host信息************')
        print(self.request.headers['host'])     # 获取某一个首部
        print('************输出path信息************')
        print(self.request.path)                # 请求的path
        self.write('ok')


if __name__ == '__main__':
    options.parse_command_line()
    handlers_routes = [
        (r'/', HelloHandler)
    ]
    app = Application(handlers=handlers_routes)
    http_server = HTTPServer(app)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

浏览器输入http:127.0.0.1:8000之后，在控制台查看输出信息
在这里插入图片描述
self.request 对象的类型是HTTPServerRequest， 存在于tornado.httputil模块中，这个对象的属性不仅仅包含headers，还包括请求的method，uri， version，body, protocol, remote_ip,与请求有关的所有信息都包含在这个对象里，甚至包括最底层的socket连接，你所需要的信息都可以通过self.reqeust对象获取。

4.2 每一个请求关联一个Requesethandler对象

tornado每收到一个请求都会创建出一个RequestHandler对象对请求进行处理，这一点，可以通过实验来证实，我在处理get请求的方法里输出self对象的内存地址，每次请求到来时，输出的内存地址都是不相同的

# @File : requesthandlerdemo.py
import tornado.ioloop
from tornado.web import RequestHandler, Application
from tornado.httpserver import HTTPServer
from tornado.options import options, define

define('port', default=8000, help='监听端口')


class HelloHandler(RequestHandler):
    def get(self):
        print('************输出headers信息************')
        print(self.request.headers)             # 字典形式存储的headers信息
        print('************输出host信息************')
        print(self.request.headers['host'])     # 获取某一个首部
        print('************输出path信息************')
        print(self.request.path)                # 请求的path
        print('************输出id信息************')
        print(id(self))
        self.write(str(id(self)))


if __name__ == '__main__':
    options.parse_command_line()
    handlers_routes = [
        (r'/', HelloHandler)
    ]
    app = Application(handlers=handlers_routes)
    http_server = HTTPServer(app)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

输出信息如下所示：
在这里插入图片描述

4.3.initial 和 prepare

initialize和prepare 是RequestHandler的两个很重要的方法，他们有什么功能作用，又有什么区别呢？

initialize 是框架预留的一个初始化时加载自定义内容的钩子,其会在http请求方法之前调用，prepare 在执行对应的请求方法之前调用。在执行顺序上，先是initialize而后是prepare方法。

initialize 处理从URLSpec接收到的参数，你可以在创建app时对initialize所能接收的参数进行设置，除此以外，你不能在initialize中做更多的事情，比如调用write, finish方法。

而在prepare里，你可以调用这些方法，假设你要写一个根据IP进行过滤的逻辑，那么你应该写在prepare方法里。在执行get或post之前在prepare方法里对客户端的IP进行过滤，如果发现IP不符合要求，则可以调用finish方法结束请求。注意，不要使用write方法，write方法在这里不会结束请求，你在这里write的内容会和后续处理请求的方法（get,或post）所返回的内容连接在一起返回。

下面的示例中，我在prepare方法里结束请求

# @File : initialAndPrepareDemo.py
import tornado
import tornado.ioloop
from tornado.web import RequestHandler
from tornado.web import URLSpec



class HelloHandler(RequestHandler):

    def initialize(self, db):
        print('initialize')
        self.db = db
        #  self.finish('over')  这里不可以调用finish

    def prepare(self):
        print('prepare')
        self.finish('over')

    def get(self):
        self.write(f'{self.db} ok')


url_handlers = [
    URLSpec(r'/hello', HelloHandler, {'db': 'mysql'})
]

app = tornado.web.Application(url_handlers)
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(8990)
http_server.start()

tornado.ioloop.IOLoop.instance().start()

4.4.write与finish的区别

在第三节的例子里，处理请求的get方法使用write方法返回响应数据，而prepare方法里使用finish返回数据，这两个方法的区别是什么呢？

write和finish都可以向客户端返回数据，不同之处在于finish执行时，返回动作终结，如果你还有一些逻辑且这些逻辑和返回数据无关，那么你可以放在finish后面执行，对于客户端来说，它已经收到响应结果，你放在finish后面的逻辑所占用的时间与客户端无关。

write也是向客户端返回数据，但只有在遇到finish或者return后才会真正的向前端返回数据。因此，在处理请求的方法结束以前，你可以多次调用write方法，而finish则不可以。

止语---
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值