second_请求钩子_异常捕获_上下文及g变量_flask-script

 

 

2. 请求钩子

在客户端和服务器交互的过程中，有些准备工作或扫尾工作需要处理，比如：

• 在请求开始时，建立数据库连接；

• 在请求开始时，根据需求进行权限校验；

• 在请求结束时，指定数据的交互格式；

为了让每个视图函数避免编写重复功能的代码，Flask提供了通用设置的功能，即请求钩子。

请求钩子是通过装饰器的形式实现，Flask支持如下四种请求钩子：

• before_first_request

  • 在处理第一个请求前执行

• before_request

  • 在每次请求前执行

  • 如果在某修饰的函数中返回了一个响应，视图函数将不再被调用

• after_request

  • 如果没有抛出错误，在每次请求后执行

  • 接受一个参数：视图函数作出的响应

  • 在此函数中可以对响应值在返回之前做最后一步修改处理

  • 需要将参数中的响应在此参数中进行返回

• teardown_request：

  • 在每次请求后执行

  • 接受一个参数：错误信息，如果有相关错误抛出

  • 需要设置flask的配置DEBUG=False，teardown_request才会接受到异常对象

from flask import Flask
from settings.dev import DevConfig

app = Flask(__name__)
# 项目配置
app.config.from_object(DevConfig)

@app.before_first_request
def before_first_request():
    print("----before_first_request----")
    print("系统初始化的时候,执行这个钩子方法")
    print("会在接收到第一个客户端请求时,执行这里的代码")

@app.before_request
def before_request():
    print("----before_request----")
    print("每一次接收到客户端请求时,执行这个钩子方法")
    print("一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据")

@app.after_request
def after_request(response):
    print("----after_request----")
    print("在处理请求以后,执行这个钩子方法")
    print("一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作")
    response.headers["Content-Type"] = "application/json"
    # 必须返回response参数
    return response

class APIError(Exception):
    print("-----111111111")

@app.teardown_request
def teardown_request(exc):
    print("----teardown_request----")
    print("在每一次请求以后,执行这个钩子方法,如果有异常错误,则会传递错误异常对象到当前方法的参数中")
    print(exc)

@app.route("/")
def index():
    print("----视图函数----")
    raise APIError("报错了")
    print("视图函数被运行了")
    return "视图函数被运行了<br>"

if __name__ == '__main__':
    app.run()
    # app.run(host="0.0.0.0", port=80)

 

3. 异常捕获

　　主动抛出HTTP异常

• abort 方法

  • 抛出一个给定状态代码的 HTTPException 或者 指定响应，例如想要用一个页面未找到异常来终止请求，你可以调用 abort(404)。

• 参数：

  • code – HTTP的错误状态码

# abort(404) 抛出状态码的话，只能抛出 HTTP 协议的错误状态码
abort(500)

　　捕获错误

• errorhandler 装饰器

  • 注册一个错误处理程序，当程序抛出指定错误状态码的时候，就会调用该装饰器所装饰的方法

• 参数：

  • code_or_exception – HTTP的错误状态码或指定异常

• 例如统一处理状态码为500的错误给用户友好的提示：

@app.errorhandler(500)
def internal_server_error(e):
    return '服务器搬家了'

　　捕获指定异常类型

@app.errorhandler(ZeroDivisionError)
def zero_division_error(e):
    return '除数不能为0'

 

4. 上下文及g变量

上下文：即语境，语意，在程序中可以理解为在代码执行到某一时刻时，根据之前代码所做的操作以及下文即将要执行的逻辑，可以决定在当前时刻下可以使用到的变量，或者可以完成的事情。

Flask中有两种上下文，请求上下文(request context)和应用上下文(application context)。

Flask中上下文对象：相当于一个容器，保存了 Flask 程序运行过程中的一些信息。

 

1. application 指的就是当你调用app = Flask(__name__)创建的这个对象app；

2. request 指的是每次http请求发生时，WSGI server(比如gunicorn)调用Flask.__call__()之后，在Flask对象内部创建的Request对象；

3. application 表示用于响应WSGI请求的应用本身，request 表示每次http请求；

4. application的生命周期大于request，一个application存活期间，可能发生多次http请求，所以，也就会有多个request

请求上下文(request context)

思考：在视图函数中，如何取到当前请求的相关数据？比如：请求地址，请求方式，cookie等等

在 flask 中，可以直接在视图函数中使用 request 这个对象进行获取相关数据，而 request 就是请求上下文的对象，保存了当前本次请求的相关数据，请求上下文对象有：request、session

• request

  • 封装了HTTP请求的内容，针对的是http请求。举例：user = request.args.get('user')，获取的是get请求的参数。

• session

  • 用来记录请求会话中的信息，针对的是用户信息。举例：session['name'] = user.id，可以记录用户信息。还可以通过session.get('name')获取用户信息。

应用上下文(application context)

它的字面意思是 应用上下文，但它不是一直存在的，它只是request context 中的一个对 app 的代理(人)，所谓local proxy。它的作用主要是帮助 request 获取当前的应用，它是伴 request 而生，随 request 而灭的。

应用上下文对象有：current_app，g

 

current_app

应用程序上下文,用于存储应用程序中的变量，可以通过current_app.name打印当前app的名称，也可以在current_app中存储一些变量，例如：

• 应用的启动脚本是哪个文件，启动时指定了哪些参数

• 加载了哪些配置文件，导入了哪些配置

• 连接了哪个数据库

• 有哪些可以调用的工具类、常量

• 当前flask应用在哪个机器上，哪个IP上运行，内存多大

current_app.name
current_app.test_value='value'

from flask import Flask
from config import Config
from flask import request

app = Flask(__name__)
app.config.from_object(Config)


@app.route('/')
def index():
    return "the views was run"


from flask import g


@app.route("/context2")
class Model2(object):
    def __init__(self):
        print("model receive data, num = %s" % g.username)

from flask import current_app
@app.route("/context3")
def context3():
    print(current_app.username)
    return "apply the before and next contents"

@app.route("/context4")
def context4():
    g.username = request.args.get("username")
    Model2()
    return "应用上下文4"


if __name__ == '__main__':
    app.username = "apply the before and next contents"
    app.run()

此时测试访问/context3或/context4

g变量

g 作为 flask 程序全局的一个临时变量,充当者中间媒介的作用,我们可以通过它传递一些数据，g 保存的是当前请求的全局变量，不同的请求会有不同的全局变量，通过不同的thread id区别

g.name='abc'
# 注意：不同的请求，会有不同的全局变量

两者区别：

• 请求上下文：保存了客户端和服务器交互的数据

• 应用上下文：flask 应用程序运行过程中，保存的一些配置信息，比如程序名、数据库连接、应用信息等

 

5. Flask-Script 扩展

# 安装命令:
pip install flask-script

 

# main.py
from flask import Flask
from config import Config
from flask import request

app = Flask(__name__)
app.config.from_object(Config)

from flask_script import Manager

manage = Manager(app)

from flask_script import Command
class HelloCommand(Command):
    def run(self):
        with open("text.txt", "w")as f:
            f.write("hello\r\nhello")
            pass
        print("this is run the order of hello")


manage.add_command("hello", HelloCommand())


@app.route('/')
def index():
    return "the views was run"


if __name__ == '__main__':
    manage.run()

 

# manage.py
import sys


if __name__ == "__main__":
    print(sys.argv)

 

集成 Flask-Script到flask应用中

 

Flask-Script 可以为当前应用程序添加脚本命令

 

Jinja2模板引擎

Flask内置的模板语言，它的设计思想来源于 Django 的模板引擎，并扩展了其语法和一系列强大的功能。

渲染模版函数

• Flask提供的 render_template 函数封装了该模板引擎

• render_template 函数的第一个参数是模板的文件名，后面的参数都是键值对，表示模板中变量对应的真实值。

模板基本使用

1. 在视图函数中设置渲染模板

2. 在项目下创建 templates 文件夹，用于存放所有的模板文件，并在目录下创建一个模板html文件 index.html

{{}} 来表示变量名，这种 {{}} 语法叫做变量代码块

 

Jinja2 模版中的变量代码块可以是任意 Python 类型或者对象，只要它能够被 Python 的 str() 方法转换为一个字符串就可以，比如，可以通过下面的方式显示一个字典或者列表中的某个元素:

用 {%%} 定义的控制代码块，可以实现一些语言层次的功能，比如循环或者if语句

使用 {# #} 进行注释，注释的内容不会在html中被渲染出来

模板中特有的变量和函数

你可以在自己的模板中访问一些 Flask 默认内置的函数和对象

g变量

流程控制

变量	描述
loop.index	当前循环迭代的次数（从 1 开始）
loop.index0	当前循环迭代的次数（从 0 开始）
loop.revindex	到循环结束需要迭代的次数（从 1 开始）
loop.revindex0	到循环结束需要迭代的次数（从 0 开始）
loop.first	如果是第一次迭代，为 True 。
loop.last	如果是最后一次迭代，为 True 。
loop.length	序列中的项目数。
loop.cycle	在一串序列间期取值的辅助函数。见下面示例程序。

在循环内部,你可以使用一个叫做loop的特殊变量来获得关于for循环的一些信息

• 比如：要是我们想知道当前被迭代的元素序号，并模拟Python中的enumerate函数做的事情，则可以使用loop变量的index属性,例如:

过滤器

过滤器的本质就是函数。有时候我们不仅仅只是需要输出变量的值，我们还需要修改变量的显示，甚至格式化、运算等等，而在模板中是不能直接调用 Python 中的某些方法，那么这就用到了过滤器。

自定义过滤器

过滤器的本质是函数。当模板内置的过滤器不能满足需求，可以自定义过滤器。自定义过滤器有两种实现方式：

• 一种是通过Flask应用对象的 add_template_filter 方法

• 通过装饰器来实现自定义过滤器

重要：自定义的过滤器名称如果和内置的过滤器重名，会覆盖内置的过滤器。

# main.py
from flask import Flask
from config import Config
from flask import request

app = Flask(__name__, template_folder="templates")
# app = Flask(__name__)
app.config.from_object(Config)

# g过滤器的注册及使用
from flask import g
# 渲染模块的调用
from flask import render_template


@app.route('/')
def index():
    title = "网页标题"
    dict1 = {"id": 1, "username": "xiaoming", "money": 10.5}
    g.list1 = ["睡觉", "吹牛", "敲代码"]
    g.book_list = [
        {"id": 11, "name": "浪潮之巅", "price": 88.5},
        {"id": 22, "name": "数学之美", "price": 68.5},
        {"id": 33, "name": "流畅的Python", "price": 118.5},
        {"id": 44, "name": "五年高考三年模拟", "price": 78.5},
    ]
    # 返回渲染模块
    return render_template("index.html", title=title, dict1=dict1)


# 自定义过滤器
def rev(data):
    data.reverse()
    return data


# 注册过滤器
app.add_template_filter(rev, "myrev")


@app.route("/filter")
def myfileter():
    g.list1 = ["睡觉", "吹牛", "敲代码"]
    return render_template("f.html")


if __name__ == '__main__':
    app.run()

 

# templates/f.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{#自带过滤器的使用#}
{{ "hello world" | reverse | upper }}
{{ g.list1 }}<br>
{#自定义过滤器的使用#}
{{ g.list1 |myrev }}

</body>
</html>

 

# templates/index.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{{ title }}</title>
</head>
<body>
<h1>{{ title }}</h1>
{#g 本次全局变量的使用#}
<p>{{ g.list1 }}</p>
<table>
    <tr>
        <th>order</th>
        <th>ID</th>
        <th>name</th>
        <th>price</th>
    </tr>
{#判断语句的使用#}
    {% for book in g.book_list %}
        {% if loop.first %}
            <tr style="color: red">
        {% elif loop.last %}
            <tr style="color: blue">
        {% else %}
            <tr>
        {% endif %}
    <td>{{ loop.index }}</td>
    <td>{{ book.id }}</td>
    <td>{{ book.name }}</td>
    <td>{{ book.price }}</td>
    </tr>
    {% endfor %}
</table>
{#模板中特有的变量和函数#}
{{ request.url }}
{{ session.new }}
{{ g.name }}
</body>
</html>