Flask 综合认证 上下文 蓝图 请求钩子
请求钩子
请求钩子可以对请求的各阶段进行监听, 方便开发者 针对请求完成一些统一的处理, 以便减少重复代码, 作用类比Django中的中间件
开发中中主要会用到以下四种请求钩子：
before_request
- 每次执行视图函数之前调用
- 对请求进行一些准备处理
- 如果在该函数中返回了一个响应，视图函数将不再被调用
after_request
- 如果没有抛出错误，每次执行视图函数之后(已经包装为响应对象)调用
- 在此函数中可以对响应值在返回之前做最后一步修改处理
- 接受一个参数：包装好的响应对象
- 需要将修改后的响应对象返回
before_first_reques
- web应用被第一次请求前调用
- 可以进行web应用初始化处理
teardown_request：
- 每次执行视图函数之后调用
- 无论是否出现异常都会执行, 一般用于请求收尾
- 接受一个参数：错误信息，如果有相关错误抛出
from flask import Flask, Response
# 请求钩子: 类比django中间件 ,请求钩子可以对请求的各阶段进行监听, 方便开发者针对请求完成一些统一的处理
app = Flask(__name__)
# 每次执行视图函数之前调用, 对请求进行一些准备处理, 如参数解析, 黑名单过滤, 数据统计等
@app.before_request
def prepare():
print('before_request')
# 每次执行视图函数之后(已经包装为响应对象)调用, 对响应进行一些加工处理, 如设置统一响应头, 设置数据的外层包装
@app.after_request
def process(response:Response): # 必须定义形参接收响应对象
print('after_request:')
# print(response.headers)
# print(response.data)
# print(response.status_code)
return response
# web应用被第一次请求前调用, 可以进行web应用初始化处理, 如数据库连接
@app.before_first_request
def initial():
print('before_first_request')
# 每次执行视图函数之后调用, 无论是否出现异常都会执行, 一般用于请求收尾, 如资源回收, 异常统计
@app.teardown_request # 测试时不要开启调试模式
def request_handle(error): # 必须定义形参来接收具体错误信息, 如果没有错误, error=None
print('teardown_request : %s' % error)
@app.route('/')
def index():
print('执行视图')
a = 1 / 0
return "index"
if __name__ == '__main__':
app.run()
- 请求钩子可以通过两种方式进行添加, 装饰器形式 或者 直接方法调用
from flask import Flask, Response
app = Flask(__name__)
# 每次执行视图函数之前调用
# @app.before_request
# def prepare():
# print('before_request')
# 另一种语法
def prepare():
print('before_request')
app.before_request(prepare)
@app.route('/')
def index():
print('执行视图')
a = 1 / 0
return "index"
if __name__ == '__main__':
app.run()
蓝图
- 蓝图的作用: 实现Flask项目 模块化
- 项目模块化主要是 将业务以功能模块进行划分, 每个功能模块对应一个包, 用于存放和其有关的视图/工具/模型文件等, 如home, user
- 对于大型项目, 一般 每个功能模块对应创建一个蓝图, 由多个蓝图代替应用来分别管理各模块的视图
--------- project # 工程目录
|------ main.py # 启动文件
|------ user # 用户模块
| |— init.py # 包的初始化文件, 此处创建管理用户模块的蓝图对象
| |— views.py # 视图文件
| |— …
|
|------ home # 首页模块
| |— init.py # 包的初始化文件, 此处创建管理首页模块的蓝图对象
| |— views.py # 视图文件
| |— …
|…
在 home包 的初始化文件 init.py 中, 创建蓝图对象
# home/__init__.py
from flask import Blueprint
# 1. 创建蓝图对象
home_blu = Blueprint("home_b", __name__)
在 home包中创建 views文件, 存放视图函数
定义视图函数时, 使用蓝图对象来定义路由.
# home/views.py
from home import home_blu
# 2. 使用蓝图对象来定义路由
@home_blu.route('/')
def index():
return "index"
想要让蓝图对象能够完成路由定义, 还需要 Flask应用注册蓝图对象
# main.py
from flask import Flask
from home import home_blu
app = Flask(__name__)
# 3.应用注册蓝图对象
app.register_blueprint(home_blu)
if __name__ == '__main__':
print(app.url_map)
app.run(debug=True)
使用细节
蓝图的三个使用细节
- 创建蓝图时, 可以通过 url_prefix参数 给蓝图定义的路由添加 统一的URL资源段前缀
- 蓝图定义的路由, 其函数标记为 蓝图名.函数
- 蓝图也可以 设置请求钩子
只有访问该蓝图定义的路由时才会触发
实现局部监听
# home/__init__.py
from flask import Blueprint
# 细节1: 可以通过url_prefix参数给蓝图定义的路由添加统一的URL资源段前缀
home_blu = Blueprint("home_b", __name__, url_prefix='/home')
# 细节3: 蓝图也可以设置请求钩子 只有访问该蓝图定义的路由时才会触发 局部监听
@home_blu.before_request
def home_prepare():
print('home_prepare')
from . import views
# home/views.py
from flask import url_for
from home import home_blu
@home_blu.route('/')
def index():
return "index"
@home_blu.route('/demo1')
def demo1():
# 细节2: 蓝图定义的路由, 其函数标记为 蓝图名.函数名
url1 = url_for('home_b.demo1')
# print(url1)
return 'demo1'
上下文 (context)
- 上下文：是一个 数据容器，保存了 Flask 程序运行过程中的一些信息。
- Flask中有两种上下文，请求上下文 和 应用上下文
- 两种上下文的使用范围相同, 从请求开始到请求结束, 在范围外使用会报错
1. 请求上下文
- 记录一些和请求有关的数据, 包括request和session两个变量
request
- 封装了HTTP请求的内容，针对的是http请求。
session
- 用来记录请求会话中的信息，针对的是用户信息。
2. 应用上下文
记录一些和应用有关的数据, 包括current_app和g两个变量
current_app
- 会自动引用创建的Flask对象, 需要在项目的其他文件中使用app时, 应该通过current_app来获取, 可以减少循环导入问题
g
- flask给开发者预留的一个容器, 用于记录自定义数据
- g变量每次请求会重置数据
- g使用场景: 1> 在钩子函数和视图函数之间传递数据 2> 函数嵌套调用时传递数据
# main.py
from flask import Flask, request, current_app, g
# 上下文变量: 有使用范围 [请求开始, 请求结束]
# 请求上下文: 记录一些和请求有关的数据 request session
# 应用上下文: 记录一些和应用有关的数据 current_app g
import tool
app = Flask(__name__)
@app.route('/')
def index():
# print(request.url)
g.name = 'zs'
tool.func1()
return "index"
@app.route('/demo1')
def demo1():
print(g.name) # 会报错
return 'demo1'
if __name__ == '__main__':
# print(request.url) # 使用范围外, 会报错
app.run(debug=True)
如果是多层函数嵌套，可以使用g变量因为在一个请求内，如果每层嵌套都传参的话会很麻烦
# tool.py
from flask import g, current_app
def func1():
print(g.name)
print(current_app.url_map)
# tool2.func2()
上下文机制 (理解)
问题1: 上下文变量是否为全局变量?
- 不是全局变量, web服务器会通过多线程并发调用web应用, 而全局变量会被所有线程共享, 无法记录并发的多个请求数据
- 上下文机制实现了线程隔离(LocalStack类型, 本质是字典, key是线程id, 值是上下文变量), 每个线程存取自己的数据, 相互不影响
- 请求1 -> 线程1 -> request = 请求1
- 请求2 -> 线程2 -> request = 请求2
问题2: 上下文为什么设置使用范围?
- 主要目的为节省内存
- 请求开始时, 创建上下文(记录上下文变量);
- 请求结束时, 销毁上下文(将上下文变量删除, 数据占用的空间被释放)
综合认证
1. 统一处理
- 需求: 获取用户身份
- 分析: 除了静态资源, 基本所有视图都需要获取用户身份, 每个视图单独获取出现大量的代码冗余
- 解决办法: 设置 请求钩子, 并通过 g变量 将数据传递给视图函数
from flask import Flask, session, g
app = Flask(__name__)
app.secret_key = 'test'
# 需求1: 所有视图都需要获取用户身份
# 解决办法: 用钩子函数进行封装 减少代码冗余
@app.before_request
def prepare():
# 必须使用g变量来传递数据, 使用全局变量不能记录并发的多个请求数据
g.name = session.get('username')
@app.route('/')
def index():
if g.name:
return "欢迎回来, %s" % g.name
else:
return '首页'
@app.route('/demo1/')
def demo1():
print(g.name)
return 'demo1'
@app.route('/login')
def login():
"""登录"""
session['username'] = 'zs'
return '登录成功'
if __name__ == '__main__':
app.run(debug=True)
2. 访问限制
- 需求: 对指定的路由进行访问限制
- 分析: 部分视图需要身份校验, 这部分视图每个单独校验仍会出现大量的代码冗余
- 解决办法: 封装 装饰器 完成身份校验逻辑, 对指定视图函数设置装饰器
from flask import Flask, session, g, abort
from functools import wraps
app = Flask(__name__)
app.secret_key = 'test'
@app.before_request
def prepare():
g.name = session.get('username')
@app.route('/')
def index():
if g.name:
return "欢迎回来, %s" % g.name
else:
return '首页'
@app.route('/login')
def login():
"""登录"""
session['username'] = 'zs'
return '登录成功'
# 需求2: 对部分视图进行访问限制 如个人中心必须登录才能访问
# 解决方案: 使用装饰器封装访问限制 减少代码冗余
def login_required(f): # f = user
def wrapper(*args, **kwargs):
# 获取函数名
print(wrapper.__name__)
if g.name: # 用户已登录
return f(*args, **kwargs) # 正常访问视图函数
else: # 用户未登录
abort(401) # 400 语法/参数错误 401 未认证 403 已认证, 权限不足 404 资源不存在 405 请求方式不支持 500 服务器错误
return wrapper
@app.route('/user')
@login_required # user = login_required(user)
def user():
"""个人中心"""
return '访问 %s 的个人中心' % g.name
if __name__ == '__main__':
print(app.url_map)
app.run(debug=True)
functools.wraps
- 系统内置的装饰器, 主要用于装饰器中的闭包函数
- 作用是 将被装饰的函数(wrapper)的函数信息 替换为 指定函数(f)的函数信息 (包括name 函数名, doc 函数注释等)
未设置wraps装饰器的情况:
def decorater1(f): # f = demo
def wrapper(*args, **kwargs):
# 获取函数名
print(wrapper.__name__)
return f(*args, **kwargs)
return wrapper
@decorater1
def demo():
print("哈哈")
# 调用函数
demo()
# 运行结果
wrapper # 打印闭包函数名
哈哈
设置wraps装饰器的情况:
from functools import wraps
def decorater1(f): # f = demo
@wraps(f) # 设置装饰器
def wrapper(*args, **kwargs):
# 获取函数名
print(wrapper.__name__)
return f(*args, **kwargs)
return wrapper
@decorater1
def demo():
print("哈哈")
# 调用函数
demo()
# 运行结果
demo # 打印原函数名
哈哈
- flask中的函数标记是根据函数名生成的
- 视图函数添加装饰器login_required 后, 函数标记都会使用闭包函数名wrapper, 这样会出现函数标记冲突, 程序报错
- 解决办法: 给闭包函数添加装饰器functools.wraps(f), 让函数标记使用原视图函数名生成
from flask import Flask, session, g, abort
from functools import wraps
app = Flask(__name__)
app.secret_key = 'test'
@app.before_request
def prepare():
g.name = session.get('username')
@app.route('/')
def index():
if g.name:
return "欢迎回来, %s" % g.name
else:
return '首页'
@app.route('/login')
def login():
"""登录"""
session['username'] = 'zs'
return '登录成功'
# 使用装饰器封装访问限制
def login_required(f): # f = user
@wraps(f) # 会将被装饰的函数(wrapper)的函数信息替换为指定函数(f)的函数信息(__name__ 函数名, __doc__ 函数注释)
# 设置该装饰器后, 可以让闭包函数使用原函数名, 避免函数标记出现冲突(函数标记是根据函数名来生成的)
def wrapper(*args, **kwargs):
if g.name:
return f(*args, **kwargs)
else:
abort(401)
return wrapper
@app.route('/user')
@login_required
def user():
"""个人中心"""
return '访问 %s 的个人中心' % g.name
@app.route('/demo1')
@login_required
def demo1():
return 'demo1'
if __name__ == '__main__':
print(app.url_map)
app.run(debug=True)
应用配置
1. 加载配置
- app.config 用于设置配置, 该属性继承自 dict, 可以以字典形式赋值取值
rom datetime import timedelta
from flask import Flask, session
app = Flask(__name__)
app.secret_key = 'test'
# config属性用于设置配置
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7)
@app.route('/')
def index():
# 设置session 用于测试配置是否生效
session['name'] = 'zs'
# 读取配置
print(app.config.get('PERMANENT_SESSION_LIFETIME'))
return "index"
if __name__ == '__main__':
app.run(debug=True)
- 实际开发中, 应该将配置封装起来, 方便进行统一的管理, 类似Django的settings文件
- Flask提供了多种封装方式, 这里先介绍一种常用的方案 – 从对象中加载配置
从对象中加载配置
实际开发中, 项目往往存在多套配置
- 开发环境配置
- 生产环境配置
- 测试环境配置
各种环境的配置既有相同也有不同, 大量相同的配置会出现代码冗余
从对象中加载配置
配置封装方案之一, 以面向对象的形式 封装配置, 有利于 减少重复代码 以及 代码解耦合
定义配置文件 config.py, 在文件中将应用配置 以类的形式 封装起来
config.py
from datetime import timedelta
class BaseConfig:
"""配置基类 可以将相同的配置抽取到基类中, 减少重复代码"""
# 定义和配置同名的类属性
PERMANENT_SESSION_LIFETIME = timedelta(days=7)
class DevelopmentConfig(BaseConfig):
"""开发环境"""
SQL_URL = '127.0.0.1:3306/test1' # 数据库地址
class ProductionConfig(BaseConfig):
"""生产环境"""
SQL_URL = '222.10.15:3306/users' # 数据库地址
主文件 main.py 从对象中加载封装的配app.config.from_object()
main.py
from datetime import timedelta
from flask import Flask
app = Flask(__name__)
# 从对象中加载配置
# 优点: 面向对象的设计有利于 减少重复代码 以及 代码解耦合
from config import DevelopmentConfig
app.config.from_object(DevelopmentConfig)
@app.route('/')
def index():
print(app.config.get('PERMANENT_SESSION_LIFETIME'))
return "index"
if __name__ == '__main__':
app.run(debug=True)
切换配置
- 虽然封装了多套配置, 但需要 修改代码才能切换配置, 这种方式并不利于开发和测试
- Flask提供了切换配置的更好方案, 需要进行以下两步
定义工厂函数, 封装应用的创建过程
利用环境变量, 调用工厂函数, 指定配置并动态创建应用
定义工厂函数
定义工厂函数, 封装应用的创建过程
# config.py
from datetime import timedelta
class BaseConfig:
"""配置基类 可以将相同的配置抽取到基类中, 减少重复代码"""
# 定义和配置同名的类属性
PERMANENT_SESSION_LIFETIME = timedelta(days=7)
class DevelopmentConfig(BaseConfig):
"""开发环境"""
SQL_URL = '127.0.0.1:3306/test1' # 数据库地址
class ProductionConfig(BaseConfig):
"""生产环境"""
SQL_URL = '222.10.15:3306/users' # 数据库地址
# 定义字典来记录 配置类型 和 配置子类 之间的映射关系
config_dict = {
'dev': DevelopmentConfig,
'pro': ProductionConfig
}
在主文件 main.py 中, 定义工厂函数封装应用的创建过程, 并通过参数指定应用对应的配置类型
工厂函数：根据需求在函数的内部封装对象的创建过程
from flask import Flask, current_app, Config
from config import config_dict
# 工厂函数: 根据参数需求, 内部封装对象的创建过程
def create_app(config_type):
"""封装应用的创建过程"""
# 创建应用
flask_app = Flask(__name__)
# 根据配置类型取出对应的配置子类
config_class = config_dict[config_type]
# 加载普通配置
flask_app.config.from_object(config_class)
return flask_app
# 创建应用对象
app = create_app('dev')
@app.route("/")
def index():
print(app.config.get('SQL_URL'))
return "index"
if __name__ == '__main__':
app.run()
动态创建应用
- 通过代码调用函数 create_app(‘dev’) 创建应用, 仍然在代码中写死了 配置类型dev
- 通过代码调用函数 create_app(‘dev’) 创建应用, 仍然在代码中写死了 配置类型dev
格式: FLASK_APP=“应用所在模块:工厂函数(参数)”
$ export FLASK_APP="main:create_app('dev')" # 设置环境变量, 通过调用函数 设置配置并动态创建Flask应用
$ flask run # 运行web程序
- 注意: 如果动态创建应用, 通过 app = create_app(‘dev’) 代码生成的Flask应用将会失效
- 需要使用 app 的时候, 可以使用 current_app来代替 (只能在请求范围中使用)
- 将无法通过 app.route()来定义路由, 但是 蓝图定义路由仍然有效
