Flask入门第二天

　　一、请求钩子

　　在客户端和服务器交互的过程中，有些准备工作或稍微工作是需要处理的，比如：在请求开始时，建立数据库连接；在请求开始时，根据需求进行权限校验；在请求结束时，指定数据的交互格式等。为了让每个视图函数避免编写重复功能的代码，flask提供了通用设施的功能，即请求钩子。

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

- before_first_request
  - 在处理第一个请求前执行
- before_request
  - 在每次请求前执行
  - 如果在某修饰的函数中返回了一个响应，视图函数将不再被调用
- after_request
  - 如果没有抛出错误，在每次请求后执行
  - 接受一个参数：视图函数作出的响应
  - 在此函数中可以对响应值在返回之前做最后一步修改处理
  - 需要将参数中的响应在此参数中进行返回
- 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


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

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

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

　　运行结果：

　　第1次请求时结果：

----before_first_request----
系统初始化的时候,执行这个钩子方法
会在接收到第一个客户端请求时,执行这里的代码
----before_request----
每一次接收到客户端请求时,执行这个钩子方法
一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据
----视图函数----
视图函数被运行了
----after_request----
在处理请求以后,执行这个钩子方法
一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作
----teardown_request----
在每一次请求以后,执行这个钩子方法,如果有异常错误,则会传递错误异常对象到当前方法的参数中
none

　　第2次请求时的结果：

----before_request----
127.0.0.1 - - [08/apr/2019 09:23:53] "get / http/1.1" 200 -
每一次接收到客户端请求时,执行这个钩子方法
一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据
----视图函数----
视图函数被运行了
----after_request----
在处理请求以后,执行这个钩子方法
一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作
----teardown_request----
在每一次请求以后,执行这个钩子方法,如果有异常错误,则会传递错误异常对象到当前方法的参数中
none

　　二、异常捕获

　　1，抛http异常

abort方法：抛出一个给定状态代码的httpexception或者指定响应
abort(500)

　　2，捕获错误

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

处理错误状态码为500的，自定义返回内容，如果不做这步，就返回自带的异常模板
@app.errorhandler(500)
def internal_server_error(e):
    return '服务器出问题了'


处理指定异常，如zerodivisionerror，除数为0的异常
@app.errorhandler(zerodivisionerror)
def zero_division_error(e):
    return '除数不能为0'

　　三、上下文

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

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*

　　1，请求上下文（request context）

在 flask 中，可以直接在视图函数中使用 **request** 这个对象进行获取相关数据，而 **request** 就是请求上下文的对象，保存了当前本次请求的相关数据，请求上下文对象有：request、session
- request： 封装了http请求的内容，针对的是http请求。举例：user = request.args.get('user')，获取的是get请求的参数。
- session：用来记录请求会话中的信息，针对的是用户信息。举例：session['name'] = user.id，可以记录用户信息。还可以通过session.get('name')获取用户信息

　　2，应用上下文（application context）

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

　　2.1 current_app

应用程序上下文,用于存储应用程序中的变量，可以通过current_app.name打印当前app的名称，也可以在current_app中存储一些变量，例如：
- 应用的启动脚本是哪个文件，启动时指定了哪些参数
- 加载了哪些配置文件，导入了哪些配置
- 连接了哪个数据库
- 有哪些可以调用的工具类、常量
- 当前flask应用在哪个机器上，哪个ip上运行，内存多大

current_app.name
current_app.test_value='value'

　　2.2 g变量

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

g.name='abc'

　　3，两者的区别

- 请求上下文：保存了客户端和服务器交互的数据
- 应用上下文：flask 应用程序运行过程中，保存的一些配置信息，比如程序名、数据库连接、应用信息等

　　四、flask-script扩展

　　1，安装

　　在flask_demo的虚拟环境中输入：pip install flask-script

　　2，集成flask-script到flask应用中

from flask import flask
from flask_script import manager

app = flask(__name__)

# 把 manager 类和应用程序实例进行关联
manager = manager(app)

@app.route('/')
def index():
    return 'hello world'

if __name__ == "__main__":
    manager.run()

　　3，flask-script可以为当前应用程序添加脚本命令

class hello(command):
    "prints hello world"
    def run(self):
        print("hello world")

manager.add_command('hello', hello())

　　五、jinja2模板引擎

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

　　渲染模板函数：

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

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

　　1，模板的基本使用

from flask import flask, render_template,g
from settings.dev import devconfig

app = flask(__name__,template_folder="templates",static_folder='static')
app.config.from_object(devconfig)

def func():
    return "hello, func"

@app.route("/")
def index():
    g.name="首页"
    dict1 = {
        "username":"xiaohui",
        "age":22,
        "sex":2,
    }
    list1 = ["张三","李四","王五"]
    return render_template("index.html",title = "我的flask网页",dict1=dict1,list1=list1,func=func)

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

　　index.html

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>title</title>
</head>
<body>
我的模板html内容
{{list1}}    #这是变量代码块，里面放视图传递的变量
{% if %}     #这是控制代码块，里面放if，for等逻辑语句。这两种模板语法使用和django中一模一样
</body>
</html>

　　2，特有的变量和函数

　　可以在模板中使用flask默认的内置函数和对象

　　2.1 config

可以直接访问flask当前的config对象
{{config.sqlalchemy_database_uri}}

　　2.2 request

flask中当前请求的request对象
{{request.url}}

　　2.3 session对象

flask的session对象
{{session.new}}

　　2.4 g变量

在视图函数中设置g变量的 name 属性的值，然后在模板中直接可以取出
{{ g.name }}

　　2.5 url_for()

url_for会根据传入的路由器函数名,返回该路由对应的url,在模板中始终使用url_for()就可以安全的修改路由绑定的url,则不比担心模板中渲染出错的链接:
{{url_for('home')}}
当url带参数时：
{{ url_for('post', post_id=1)}}

　　3，流程控制

　　3.1 if语句

{%if user.is_logged_in() %}
    <a href='/logout'>logout</a>
{% else %}
    <a href='/login'>login</a>
{% endif %}

　　3.2 for语句

{% for post in posts %}
    <div>
        <h1>{{ post.title }}</h1>
        <p>{{ post.text | safe }}</p>
    </div>
{% endfor %}

　　for循环中可以使用特殊的变量

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

　　{% for post in posts%}
　　{{loop.index}}, {{post.title}}
　　{% endfor %}

　　for循环和if语句嵌套

{% for post in posts if post.text %}
    <div>
        <h1>{{ post.title }}</h1>
        <p>{{ post.text | safe }}</p>
    </div>
{% endfor %}

　　4，过滤器

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

过滤器的使用方式为：变量名 | 过滤器
{{variable | filter_name(*args)}}

如果没有任何参数传给过滤器,则可以把括号省略掉
{{variable | filter_name }}

在 jinja2 中，过滤器是可以支持链式调用的，示例如下：
{{ "hello world" | reverse | upper }}

　　4.1字符串操作

safe：禁用转义
<p>{{ '<em>hello</em>' | safe }}</p>

capitalize：把变量值的首字母转成大写，其余字母转小写
<p>{{ 'hello' | capitalize }}</p>

lower：把值转成小写
<p>{{ 'hello' | lower }}</p>

upper：把值转成大写
<p>{{ 'hello' | upper }}</p>

title：把值中的每个单词的首字母都转成大写
<p>{{ 'hello' | title }}</p>

reverse：字符串反转
<p>{{ 'olleh' | reverse }}</p>

format：格式化输出
<p>{{ '%s is %d' | format('name',17) }}</p>

striptags：渲染之前把值中所有的html标签都删掉
<p>{{ '<em>hello</em>' | striptags }}</p>

truncate: 字符串截断
<p>{{ 'hello every one' | truncate(9)}}</p>

　　4.2 列表操作

first：取第一个元素
<p>{{ [1,2,3,4,5,6] | first }}</p>

last：取最后一个元素
<p>{{ [1,2,3,4,5,6] | last }}</p>

length：获取列表长度
<p>{{ [1,2,3,4,5,6] | length }}</p>

sum：列表求和
<p>{{ [1,2,3,4,5,6] | sum }}</p>

sort：列表排序
<p>{{ [6,2,3,1,5,4] | sort }}</p>

　　4.3 自定义过滤器

过滤器的本质是函数。当模板内置的过滤器不能满足需求，可以自定义过滤器。自定义过滤器有两种实现方式：
- 一种是通过flask应用对象的 **add_template_filter** 方法
- 通过装饰器来实现自定义过滤器
**重要：自定义的过滤器名称如果和内置的过滤器重名，会覆盖内置的过滤器。**

　　添加列表反转的过滤器：方法一

通过调用应用程序实例的 add_template_filter 方法实现自定义过滤器。该方法第一个参数是函数名，第二个参数是自定义的过滤器名称：
def do_listreverse(li):
    # 通过原列表创建一个新列表
    temp_li = list(li)
    # 将新列表进行返转
    temp_li.reverse()
    return temp_li

app.add_template_filter(do_listreverse,'lireverse')

　　方法二：

用装饰器来实现自定义过滤器。装饰器传入的参数是自定义的过滤器名称。
@app.template_filter('lireverse')
def do_listreverse(li):
    # 通过原列表创建一个新列表
    temp_li = list(li)
    # 将新列表进行返转
    temp_li.reverse()
    return temp_li

　　5，模板继承

和django中使用方法一样，用extends
{% extends 'base.html' %}
{% block content %}
 需要填充的内容
{% endblock content %}

　　六、flask中加csrf

设置应用程序的 secret_key，用于加密生成的 csrf_token 的值
app.secret_key = "#此处可以写随机字符串#"
导入 flask_wtf.csrf 中的 csrfprotect 类，进行初始化，并在初始化的时候关联 app
from flask.ext.wtf import csrfprotect
csrfprotect(app)
在表单中使用 csrf 令牌:
<form method="post" action="/">
    <input type="hidden" name="csrf_token" value="{{ csrf_token() }}" />
</form>