2.（基础）tornado的请求与响应

之前我们介绍了tornado 的基础流程，但是还遗留了一些问题，今天我们就来解决这些遗留问题并学习新的内容

settings，使用tornado.web.Application(handler, **settings),我们却不知道这个settings到底是什么，究竟有什么作用，今天就来介绍一下。

settings是一个字典，主要保存一些配置选项

debug

设置tornado是否在调试模式下，默认为False，即在生产模式下。

debug设置为True的生活，具有如下特点：

　　　　自动重启，tornado应用会监控源代码文件，当有保存改动时便会自动重启服务器，类似于Django，可以减少手动重启的次数，提高开发效率，如果保存代码后有错误会导致重启失败，修改错误需要手动重启，可以通过autoreload = True设置

　　　  取消缓存编译的模板：有时候我们明明修改了模板文件，但是页面显示的内容并没有变化，就是因为用的还是缓存文件。因此debug = True，可以保证每次加载的模板文件都是最新的，也可以通过compiled_template_cache=False单独设置，表示不使用已经编译好的模板缓存

　　　  取消缓存静态文件的hash值：这和取消编译模板是类似的，有时候我们修改css，但是页面颜色或者字体并没有发生变化。 有了debug=True，可以保证每次加载的静态文件都是最新的，也可以通过static_hash_cache=False单独设置，表示不使用静态文件的哈希缓存

　　　  提供追踪信息：可以通过server_traceback=True单独设置

从源码也能看出来

static_path

设置静态文件目录，

注意：寻找静态文件是tornado去找，类似Django，你要告诉tornado要去什么地方去找静态文件

template_path

设置模板文件目录，和设置静态文件目录类似

配置文件如下：

import os

options = {"port": 7777}

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

settings = {"static_path": os.path.join(BASE_DIR, "static"),

            "template_path": os.path.join(BASE_DIR, "templates"),

            "compiled_static_cache": True,

            "compiled_template_cache": True,

            "server_traceback": True}

关于静态文件路径和模板文件路径，再次强调，是tornado去找。而且后面还会用到模板语言，必须要让tornado知道相应的路径在哪里。

在settings中指定static_path和template_path，那么tornado便会到相应的路径下去寻找。

下面介绍一下tornado的路由，路由在上一章我们知道，是用来指定url和handler之间的映射关系。当一个url过来会进行解析，然后执行对应的handler，tornado的路由还可以加一些别的参数

view.py

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    # 该方法会在执行http方法之前执行

    # 可以传入参数，这个参数则是我们在定义路由的时候指定

    def initialize(self, girl1, girl2):

        self.girl1 = girl1

        self.girl2 = girl2

    def get(self, *args, **kwargs):

        print(self.girl1, self.girl2)

        self.write("my name is satori")

class MashiroHandler(tornado.web.RequestHandler):

    def get(self, *args, **kwargs):

        # url的反向解析

        # 我们在定义路由的时候可以指定一个name="xxx"，那么self.reverse_url(name),便会获取相应的url

        # 这便是url的反向解析，通过指定的name获取定义的url

        url = self.reverse_url("satori")

        self.write(f'<h1><a href="{url}">还是喜欢satori</a></h1>')

application.py

import tornado.web

from views import view

import config

# 我们可以自定义一个Application，但是要继承tornado.web下的Application

class Application(tornado.web.Application):

    def __init__(self):

        handlers = [

            # 我们在SatoriHandler的initialize中定义了girl1和girl2

            # 那么girl1和girl2就在包含相应handler的路由中定义

            # 以字典的形式传值即可

            (r"/satori", view.SatoriHandler, {"girl1": "satori", "girl2": "koishi"}),

            # 由于我们指定了name,那么name也要在包含相应handler的路由中定义

            # 但是name比较特殊，我们不能用一般的路由定义，要使用tornado.web.url()

            # 然后使用self.reverse_url(name)获取到的便是name所在路由的url

            # 那么在页面渲染出来的便是一个a标签

            tornado.web.url(r"/koishi", view.SatoriHandler, {"girl1": "satori", "girl2": "koishi"},

                            name=r"satori"),

            (r"/mashiro", view.MashiroHandler)

        ]

        super(Application, self).__init__(handlers=handlers, **config.settings)

输入localhost:7777/satori,得到页面如下

同时在pycharm中也打印了girl1和girl2的值

两个url的handler是一样的

最后再来输入localhost:7777/mashiro,也显示了相应的字符串，而且是一个被渲染为一个a标签，我们点击一下

又跳转回去了，因为name="satori"所在路由的url是r"/koishi",那么通过在MashiroHandler中进行反向解析获取到的url就是r"/koishi"

那么点击之后会再次跳转到localhost:7777/koishi,从而执行SatoriHandler

从而在pycharm中再次输出，总共三次

利用http协议向服务器传递参数

1.提取url当中的特定部分

application.py

import tornado.web

from views import view

import config

# 我们可以自定义一个Application，但是要继承tornado.web下的Application

class Application(tornado.web.Application):

    def __init__(self):

        handlers = [

            # 可以支持正则表达式，我们定义了三个分组

            # 那么用户输入的内容会根据分组依次对应传到handler的get函数里面

            (r"/satori/(\w+)/(\w+)/(\w+)", view.SatoriHandler),

            # 由于我们指定了分组的名字，就类似于关键字参数

            # adj1、adj2、adj3会分别对应get函数里面的adj1、adj2、adj3

            (r"/mashiro/(?P<adj1>\w+)/(?P<adj2>\w+)/(?P<adj3>\w+)", view.MashiroHandler)

        ]

        super(Application, self).__init__(handlers=handlers, **config.settings)

view.py

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self, adj1, adj2, adj3):

        # 这里的参数会和分组的顺序保持一致

        self.write(f"<h1>satori {adj1}, {adj2}, {adj3}</h1>")

class MashiroHandler(tornado.web.RequestHandler):

    def get(self, adj2, adj3, adj1):

        # 由于在路由中指定了名称，那么函数中参数的顺序便无所谓了

        self.write(f"<h1>mashiro {adj1}, {adj2}, {adj3}</h1>")

在浏览器中输入满足路由映射的url，会发现按照顺序依次打印了出来

再来试试另一个路由

可以看到即便我们在MashiroHandler中定义的参数没有什么顺序，但是在页面中依旧按照我们输入url的顺序打印了出来，

这是因为我们定义路由的时候指定了名字，那么在执行get函数的时候，相当于adj1="elegant", adj2="beautiful", adj3="cute",

2.get方式传递参数

当我们输入localhost:7777/satori?a=1&b=2&c=3的时候，可以在程序当中获取相应的a,b,c的值。

可以回想一下requests，requests.get函数中有一个params参数，传入{"a": 1, "b": 2, "c": 3}，便会自动和请求的url进行组合，从而得到类似于上面的新的url

那么反过来获取相应的a,b,c的值也是可以的

application.py

import tornado.web

from views import view

import config

# 我们可以自定义一个Application，但是要继承tornado.web下的Application

class Application(tornado.web.Application):

    def __init__(self):

        handlers = [

            (r"/satori", view.SatoriHandler),

        ]

        super(Application, self).__init__(handlers=handlers, **config.settings)

view.py

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        '''

        函数的原型是self.get_argument(name, strip=True)

        其实这个函数是self.get_query_argument(用于获取get请求的参数)和self.get_body_argument(用于获取post请求的参数)两个的函数的组合

        而self.get_argument既可以用于get也可以用于post，因此我们一般都使用self.get_argument

        参数:

            name：返回get请求参数字符串中指定参数的值

                  如果出现多个同名参数，返回最后一个

            strip：是否过滤掉两边的空格，默认为True表示过滤

        '''

        a = self.get_argument("a")

        b = self.get_argument("b")

        c = self.get_argument("c")

        d = self.get_arguments("d")

        self.write(f"参数a={a}, 参数b={b}, 参数c={c}, 参数d={d}")

首先a,b无需解释，至于c，由于我们是self.get_argument,所以只会获取最后一个，但是对于d，使用self.get_arguments,会获取一个列表，如果只有一个值，获取的仍是个列表，列表只有一个元素

3.post方式传递参数

首先templates目录里面创建一个html文件 ,satori.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>古明地觉</title>

</head>

<body>

    <form action="/satori" method="post">

        姓名:<input type="text" name="name">

        <p></p>

        性别:<input type="text" name="gender">

        <p></p>

        登场:<input type="text" name="from">

        <p></p>

        昵称:

        <input type="checkbox" name="nickname" value="少女觉">少女觉

        <input type="checkbox" name="nickname" value="觉大人">觉大人

        <input type="checkbox" name="nickname" value="小五">小五

        <input type="submit" value="提交">

    </form>

</body>

</html>

application.py

import tornado.web

from views import view

import config

# 我们可以自定义一个Application，但是要继承tornado.web下的Application

class Application(tornado.web.Application):

    def __init__(self):

        handlers = [

            (r"/satori", view.SatoriHandler),

        ]

        super(Application, self).__init__(handlers=handlers, **config.settings)

view.py

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        # self.write表示写入字符串

        # self.render表示将一个模板读取进来，进行渲染(替换掉模板语言)，返回给用户

        # 而且我们只是指定了文件名，tornado居然能找得到，因为我们在settings中定义了template_path

        # 因此在执行self.render的时候tornado会自动到相应目录下去寻找模板文件

        self.render("satori.html")

    def post(self, *args, **kwargs):

        # 我们在表单中定义了name="xxx"

        # 因此self.get_argument的参数就是name

        gender = self.get_argument("gender")

        name = self.get_argument("name")

        _from = self.get_argument("from")

        nickname = self.get_arguments("nickname")

        self.write(f"你的名字是{name}, 性别是{gender}, 来自于{_from}, 昵称是{' '.join(nickname)}")

浏览器中输入如下：

点击提交之后

HTTPServerRequest对象

想一下我们使用requests模块访问得到的response一样，这个response是服务端给我们返回的信息，如果加上了request表示客户端向服务端请求时的信息

因此request：请求，response：响应

所以tornado的request作用就是储存了请求的相关信息

method：http请求的方式
host：请求的主机名
uri：请求的完整资源地址，包括路径和get参数查询部分,注意是uri不是url
path：请求的路径部分
query：请求参数部分
version：使用的http版本
headers：请求的协议头是一个字典类型
body：请求体数据
remote_ip：客户端ip

view.py,其他的文件不变

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        self.write("<h1>请求的信息如下:</h1>")

        self.write(f"<h2>self.request.method={self.request.method}</h2>")

        self.write(f"<h2>self.request.host={self.request.host}</h2>")

        self.write(f"<h2>self.request.uri={self.request.url}</h2>")

        self.write(f"<h2>self.request.path={self.request.path}</h2>")

        self.write(f"<h2>self.request.version={self.request.version}</h2>")

        self.write(f"<h2>self.request.headers={self.request.headers}</h2>")

        self.write(f"<h2>self.request.body={self.request.body}</h2>")

        self.write(f"<h2>self.request.remote_ip={self.request.remote_ip}</h2>")

输入localhost:7777/satori,得到页面如下

tornado.httputil.HTTPFile对象

接收到的是一个文件对象，属性有name，body，content_type

filename: 文件名

body: 文件的数据实体

content_type: 文件类型

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>古明地觉</title>

</head>

<body>

    <!--如果想上传文件，那么必须要加上enctype="multipart/form-data"-->

    <form action="/satori" method="post" enctype="multipart/form-data">

        <input type="file" name="picture">

        <input type="file" name="picture">

        <input type="file" name="txt">

        <input type="submit" value="提交">

    </form>

</body>

</html>

import tornado.web

import os

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        self.render("satori.html")

    def post(self, *args, **kwargs):

        BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

        file_dict = self.request.files

        '''

        关于这里的file_dict，要详细的说一下

        首先我们在html文件中，写了如下代码

        <input type="file" name="picture">

        <input type="file" name="picture">

        <input type="file" name="txt">

        那么在文件上传提交之后，我们获取file_dict便是一个字典

        file_dict = {

            "picture": [{"filename": "xxx", "body": "xxx", "content_type": "xxx"},

                        {"filename": "xxx", "body": "xxx", "content_type": "xxx"}],

            "txt": [{"filename": "xxx", "body": "xxx", "content_type": "xxx"}]

        }

        我们在html中定义了name="picture"和name="txt"两个上传文件的input，那么"picture"和"txt"就是这个file_dict的两个key

        每个key，分别对应一个列表。每个列表中存储的字典，便包含了上传文件的信息。因为可能上传多个文件，所以有多个字典。

        比如我们这里的picture，列表里面就有两个字典，因为我们以name="picture"上传两个文件。

        如果只有一个文件，那么key对应的value仍是一个列表，只不过这个列表里面只有一个字典，比如我们这里的txt

        example：我们上传了，satori.jpg(name="picture")、koishi.jpg(name="picture")、mmp.txt(name="txt")

        那么file_dict如下：

            file_dict = {

            "picture": [{"filename": "satori.jpg", "body": b"二进制文件内容", "content_type": "img/jpeg"},

                        {"filename": "koishi.jpg", "body": b"二进制文件内容", "content_type": "img/jpeg"}],

            "txt": [{"filename": "mmp.txt", "body": b"二进制文本内容", "content_type": "text/plain"}]

            }

        '''

        # 接下来便以上面的example进行上传

        '''

        name依次循环--->"picture","txt"

        '''

        for name in file_dict:

            '''

            file_arr依次循环--->[{"filename": "satori.jpg", "body": b"二进制文件内容", "content_type": "img/jpeg"},

                                {"filename": "koishi.jpg", "body": b"二进制文件内容", "content_type": "img/jpeg"}],

                               [{"filename": "mmp.txt", "body": b"二进制文本内容", "content_type": "text/plain"}]

            '''

            file_arr = file_dict[name]

            '''

            file_obj依次循环--->"{filename": "satori.jpg", "body": b"二进制文件内容", "content_type": "img/jpeg"},

                                {"filename": "koishi.jpg", "body": b"二进制文件内容", "content_type": "img/jpeg"},

                                {"filename": "mmp.txt", "body": b"二进制文本内容", "content_type": "text/plain"}

            '''

            for file_obj in file_arr:

                # filename：文件名

                filename = file_obj["filename"]

                # body：文件内容

                body = file_obj["body"]

                # 文件类型

                content_type = file_obj["content_type"]

                # 创建了一个upload_files目录，专门用来存放上传的文件

                with open(os.path.join(BASE_DIR, "upload_files", filename), "wb") as f:

                    f.write(body)

                self.write(f"{filename}上传成功,文件类型为{content_type}<br>")

点击提交

再来看看upload_files目录，有没有上传的文件

显然上传是成功了的，以上操作便可以完成文件的上传

响应输出

1.self.write

原型：self.write(chunk)

作用：将数据写到缓冲区

import tornado.web

import json

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        self.write("我是self.write")

        self.write("我的作用是将数据写到缓冲区")

        # self.write还可以写入json文件

        dic = {"name": "古明地觉", "from": "东方地灵殿"}

        # 可以手动转化为json文件，那么Content-Type属性值为text/html

        self.write(json.dumps(dic))

        # 也可以直接利用write方法写入字典,那么Content-Type属性值为application/json

        self.write(dic)

        # self.finish()，表示手动关闭当次请求通道

        # 在self.finish()下面就不要在self.write了,否则报错

        self.finish()

2.self.set_header(name, value)

作用：手动设置一个名为name，值为value的响应头字段

参数：name，字段名称，value，字段值

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        self.set_header("satori", "koishi")

        self.write("我设置了一个响应头字段，可以检查元素看看")

3. set_default_header()

作用：在执行http方法之前被调用，可重写该方法预先设置默认的headers

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def set_default_headers(self):

        self.set_header("zgg", 666)

        self.set_header("mmp", 250)

    def get(self):

        self.set_header("satori", "koishi")

        self.set_header("love", "satori")

        self.write("我在两个地方设置了响应头字段")

4. self.set_status(status_code, reason=None)

作用：为相应设置状态码

参数：status_code,状态码值，为int，如果reason=None，那么状态码必须合法。

　　  reason，描述状态码的词组，为string

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        self.set_header("satori", "koishi")

        self.set_header("love", "satori")

        # 404是合法的状态码，所以可以不指定reason

        self.set_status(status_code=404)

        self.write("我设置了状态码，去看看")

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        self.set_header("satori", "koishi")

        self.set_header("love", "satori")

        # 404是合法的状态码，指定一下reason

        self.set_status(status_code=404, reason="success")

        self.write("我设置了404,但是reason是success，去看看")

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        self.set_header("satori", "koishi")

        self.set_header("love", "satori")

        # 指定一个不存在的状态码，这时候要指定reason，否者状态码后面的描述是Unknow

        # 因为我们在指定404的时候，这些合法的状态码都是有意义的

        # 如404代表页面未找到，200代表成功，所以即使我们不指定reason，也会自动帮你添加

        # 但是如果指定一个不存在的状态码，那么最好指定reason

        self.set_status(status_code=666, reason="you 666")

        self.write("我设置了一个不合法的状态码，去看看")

5. self.redirect(url)

作用：重定向到某个url

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def get(self):

        self.redirect("http://www.baidu.com")

输入网址回车，会自动跳转到百度

6. self.send_error(status_code=500, **kwargs)

作用：抛出http错误状态码，默认为500，抛出错误后，tornado会自动调用write_error进行处理，并返回给页面

注意：在self.send_error之后就不要再响应输出了

7. self.write_error(status_code=500, **kwargs)

作用：用来处理self.send_error抛出的异常，并返回给浏览器错误界面

import tornado.web

class SatoriHandler(tornado.web.RequestHandler):

    def write_error(self, status_code, **kwargs):

        # self.send_error传入的状态码，会自动传入write_error当中

        # self.write_error和self.send_error中的status_code是相同的

        if status_code == 404:

            self.set_status(404, "damn it!!!")

            self.write("你妹的，活该资源找不到")

    def get(self):

        DoesSatoriLoveMe = self.get_argument("DoesSatoriLoveMe")

        if DoesSatoriLoveMe in ["yes", "YES", "Yes"]:

            self.write("哼。。给你个正常页面吧")

        else:

            self.send_error(404)

tornado请求与响应就先到这，下一节将介绍tornado的接口调用顺序与模板

巴特西

2.（基础）tornado的请求与响应

最新文章

热门文章