类视图
在 Flask 中,除了使用函数视图外,你还可以使用类视图来处理请求。类视图提供了一种更为结构化和面向对象的方式来编写视图函数,使得代码组织更清晰,并且提供了更多的灵活性和可扩展性。
创建类视图
要创建一个类视图,你需要定义一个类,并继承 Flask 提供的视图类之一(如 FlaskView
、MethodView
等)。然后,你可以在这个类中定义 HTTP 请求方法的处理函数,每个函数对应一个 HTTP 请求方法(GET、POST、PUT、DELETE 等)。
下面是一个简单的示例,演示了如何使用类视图处理 GET 请求:
from flask import Flask, request
from flask.views import Viewapp = Flask(__name__)class HelloWorld(View):def dispatch_request(self):return 'Hello, World!'app.add_url_rule('/', view_func=HelloWorld.as_view('hello')) # 设置标识为helloif __name__ == '__main__':app.run(debug=True)
在这个示例中,我们创建了一个名为 HelloWorld
的类,继承了 Flask 提供的 View
类。然后,我们定义了一个名为 dispatch_request
的方法,它处理请求并返回响应。最后,我们使用 as_view
方法将类视图转换为可在路由中使用的视图函数,并将其添加到根路径的路由上。
- 注意
- 必须继承原生类
- 必须且只能使用
app.add_url_rule
方法做视图映射- 必须使用
as_view
把类转化成视图,并设置标识
基于调度方法的类视图
在Flask中,基于调度方法的类视图可以通过继承Flask提供的类视图基类(如flask.views.MethodView
)来实现。每个HTTP请求方法都有对应的类方法(如get()
、post()
、put()
、delete()
等),当接收到对应的HTTP请求时,Flask会自动调用相应的方法来处理请求。
下面是一个简单的示例:
from flask import Flask, request
from flask.views import MethodViewapp = Flask(__name__)class UserAPI(MethodView):def get(self, user_id):# 处理GET请求return f"获取用户 {user_id} 的信息"def post(self):# 处理POST请求data = request.jsonreturn f"创建新用户: {data['name']}"def put(self, user_id):# 处理PUT请求data = request.jsonreturn f"更新用户 {user_id} 的信息为: {data['name']}"def delete(self, user_id):# 处理DELETE请求return f"删除用户 {user_id}"# 将类视图绑定到URL
user_view = UserAPI.as_view('user_api')
app.add_url_rule('/users/', defaults={'user_id': None}, view_func=user_view, methods=['GET', 'POST'])
app.add_url_rule('/users/<int:user_id>', view_func=user_view, methods=['GET', 'PUT', 'DELETE'])if __name__ == '__main__':app.run()
在上面的示例中,我们定义了一个UserAPI
类,继承自MethodView
基类。
每个HTTP请求方法(GET、POST、PUT、DELETE)都对应于类中的一个方法。
然后,我们将这个类视图绑定到了不同的URL,并指定了对应的HTTP请求方法。当客户端发起请求时,Flask会根据请求的方法自动调用相应的方法来处理请求。
defaults
设置变量的默认值methods
指定请求方法
类视图的优势
使用类视图相比于函数视图有一些优势:
- 更好的代码组织:类视图将相似功能的代码组织到一个类中,使得代码更易于维护和管理。
- 支持更多的功能:类视图提供了更多的功能和灵活性,例如可以使用类属性来共享数据,可以通过类方法来实现重复使用的逻辑等。
- 支持类继承:你可以继承已有的类视图,并在子类中进行定制,从而实现代码的复用和扩展。
装饰器/钩子函数
Flask 是一个 Python Web 框架,使用装饰器(decorators)是其核心特性之一。装饰器可以在函数或方法的定义前使用 @
符号,用于修改或者增强函数的功能。在 Flask 中,装饰器通常用于路由的定义,以及在请求处理过程中执行额外的逻辑。
下面是 Flask 中最常见的装饰器及其作用:
@app.route('/')
这是定义路由最常用的装饰器,用于指定 URL 和请求方法与视图函数的关联。例如:
from flask import Flaskapp = Flask(__name__)@app.route('/')
def index():return 'Hello, World!'
当用户访问网站根目录时,Flask 将调用 index
函数来处理请求。
@app.before_request
和 @app.after_request
当您使用 Flask 框架时,@app.before_request
和 @app.after_request
这两个装饰器可以帮助您在请求处理前后执行特定的逻辑。下面是它们的简单示例用法:
from flask import Flask, request, jsonifyapp = Flask(__name__)# 这个函数将在每个请求处理前执行
@app.before_request
def before_request_func():# 在这里你可以执行一些准备工作,比如验证用户身份或记录请求信息print("Before Request")# 这里我们简单地打印请求路径print("Request Path:", request.path)# 这个函数将在每个请求处理后执行
@app.after_request
def after_request_func(response):# 在这里你可以执行一些清理工作或修改响应print("After Request")# 这里我们简单地打印响应状态码print("Response Status Code:", response.status_code)return response# 一个简单的路由,用于演示
@app.route('/')
def index():return jsonify(message="Hello, World!")if __name__ == '__main__':app.run(debug=True)
在上面的示例中,@app.before_request
装饰器用于注册 before_request_func
函数,该函数在每个请求处理前执行。@app.after_request
装饰器用于注册 after_request_func
函数,该函数在每个请求处理后执行。这两个函数可以执行与请求和响应相关的任何操作。
您可以根据需要扩展这些函数,比如添加身份验证、请求日志记录、跨域请求处理等。
@app.errorhandler
当您使用 Flask 框架时,@app.errorhandler
装饰器可以用来处理特定类型的错误。下面是一个简单的示例,演示如何使用 @app.errorhandler
:
from flask import Flask, jsonifyapp = Flask(__name__)# 404 错误处理函数
@app.errorhandler(404)
def not_found_error(error):return jsonify({'error': 'Not found'}), 404# 500 错误处理函数
@app.errorhandler(500)
def internal_server_error(error):return jsonify({'error': 'Internal Server Error'}), 500# 一个简单的路由,用于演示 404 错误
@app.route('/not_found')
def not_found():# 该路由总是返回 404 错误return 'This page does not exist', 404# 一个简单的路由,用于演示 500 错误
@app.route('/internal_server_error')
def internal_server_error_route():# 该路由总是触发 500 错误# 请注意这是一个故意触发错误的示例,实际开发中应该避免这样的代码1 / 0if __name__ == '__main__':app.run(debug=True)
在上面的示例中,我们定义了两个错误处理函数,分别处理 404 和 500 错误。@app.errorhandler(404)
装饰器用于注册 not_found_error
函数,该函数处理 404 错误;@app.errorhandler(500)
装饰器用于注册 internal_server_error
函数,该函数处理 500 错误。
当 Flask 应用收到对应类型的错误时,它将调用相应的错误处理函数,并返回该函数返回的响应给客户端。
需要注意的是,404 错误处理函数会在路由找不到的情况下触发,而 500 错误处理函数会在应用内部发生异常时触发。
在Flask中,钩子函数是一种在请求处理过程中插入自定义代码的机制。Flask提供了一系列钩子函数,允许你在请求处理的不同阶段执行特定的操作。这些钩子函数可以用于执行预处理、后处理、错误处理等任务,以及在请求周期中执行其他自定义逻辑。
以下是一些常用的Flask钩子函数及其应用场景:
@app.before_first_request
- 在处理第一个请求之前执行,通常用于初始化应用的全局状态或加载配置信息。
@app.before_first_request
def initialize_app():# 初始化应用状态print("Initializing the application...")
@app.teardown_request
- 在每个请求处理之后执行,无论是否发生了异常。通常用于执行资源释放或清理操作,例如关闭数据库连接。
@app.teardown_request
def close_db_connection(exception):db.session.close()
@app.context_processor
- 注册一个上下文处理器,可以在模板中访问的变量。这个钩子函数通常用于在所有模板中添加全局变量,例如当前用户或应用配置。
from flask import Flask, render_templateapp = Flask(__name__)# 定义上下文处理器,注入全局变量到模板上下文中
@app.context_processor
def inject_global_variables():# 返回一个字典,包含要注入到模板上下文中的变量return {'global_var_1': 'value_1','global_var_2': 'value_2'}# 定义视图函数,渲染模板
@app.route('/')
def index():return render_template('index.html')if __name__ == '__main__':app.run(debug=True)
在这个示例中,inject_global_variables
函数是一个上下文处理器,它返回一个包含要注入到模板上下文中的变量的字典。
在这个例子中,我们注入了两个全局变量global_var_1
和global_var_2
。
然后,我们在index()
视图函数中渲染了一个模板index.html
,这个模板可以直接访问global_var_1
和global_var_2
这两个全局变量,而无需在视图函数中传递它们。
下面是一个简单的index.html
模板示例,演示了如何在模板中使用上下文处理器注入的全局变量:
<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Flask Context Processor Example</title>
</head>
<body><h1>Global Variables</h1><p>Global variable 1: {{ global_var_1 }}</p><p>Global variable 2: {{ global_var_2 }}</p>
</body>
</html>
通过使用context_processor
,你可以在Flask应用中方便地注入全局变量到模板中,以便在所有模板中都可以访问到它们。
自定义装饰器
除了 Flask 提供的内置装饰器外,你还可以自定义装饰器来实现特定的功能,例如身份验证、性能监控等。例如,一个简单的自定义装饰器可以用来打印函数的执行时间:
**from flask import Flask
import time
from functools import wrapsapp = Flask(__name__)def timeit(func):@wraps(func)def wrapper(*args, **kwargs):start_time = time.time()result = func(*args, **kwargs)end_time = time.time()print(f'{func.__name__} executed in {end_time - start_time} seconds')return resultreturn wrapper# 使用 timeit 装饰器测量路由函数执行时间
@app.route('/')
@timeit
def index():# 模拟一个耗时操作time.sleep(1)return "Hello, World!"if __name__ == '__main__':app.run(debug=True)
**
然后你可以将这个装饰器应用到任何你想要监测执行时间的函数上。
主要注意的是,在使用自定义装饰器的时候,一定要放在
@app.route('/')
之后
类视图使用装饰器
以下是一个简单的示例,演示了如何在 Flask 中使用装饰器来扩展类视图的功能:
from flask import Flask, jsonify
from flask.views import MethodViewapp = Flask(__name__)# 装饰器函数,用于验证用户权限
def check_admin_permission(func):def wrapper(*args, **kwargs):# 在这里执行权限验证逻辑# 这里简单地假设有一个名为 `check_admin_permission` 的函数来检查用户权限if check_admin_permission():return func(*args, **kwargs)else:return jsonify({'error': 'Permission denied'}), 403return wrapper# 定义一个类视图
class MyView(MethodView):decorators = [check_admin_permission] # 使用装饰器def get(self):return jsonify({'message': 'GET request processed'})def post(self):return jsonify({'message': 'POST request processed'})# 将类视图添加到路由中
app.add_url_rule('/myview', view_func=MyView.as_view('myview'))if __name__ == '__main__':app.run(debug=True)
在 类视图中使用 decorators
列表属性将该装饰器应用于整个类视图。
蓝图
在 Flask 中,蓝图( Blueprint
)是一种组织和管理应用路由的方式,它可以帮助您将应用拆分为更小的模块,提高代码的可维护性和可扩展性。蓝图允许您将相关的视图、模板和静态文件组织到单独的模块中,并将它们注册到应用中。
蓝图使用
以下是使用蓝图的一般步骤:
-
创建蓝图: 在 Flask 应用中创建一个蓝图对象,通常在一个单独的 Python 模块中定义。
-
定义视图: 在蓝图中定义视图函数,处理特定的 URL 请求。
-
注册蓝图: 在应用对象上注册蓝图,使其生效。
-
使用蓝图: 在应用中使用蓝图定义的路由和视图。
下面是一个简单的示例,演示如何在 Flask 中使用蓝图:
# app/auth/routes.pyfrom flask import Blueprint, render_template# 创建蓝图
auth_bp = Blueprint('auth', __name__)@auth_bp.route('/login')
def login():return render_template('login.html')@auth_bp.route('/register')
def register():return render_template('register.html')
创建蓝图 auth_bp
,并且使用 @blueprint_name.route('/path')
创建该蓝图下的子模块 login
和 register
# app/user/routes.pyfrom flask import Blueprint, render_template# 创建蓝图
user_bp = Blueprint('user', __name__)@user_bp.route('/play')
def play():return render_template('user/play.html')@user_bp.route('/about')
def about():return render_template('user/about.html')
创建蓝图 user_bp
,并且使用 @blueprint_name.route('/path')
创建该蓝图下的子模块 index
和 about
# app/app.pyfrom flask import Flask
from app.auth.routes import auth_bp
from app.main.routes import main_bpapp = Flask(__name__)# 注册蓝图
app.register_blueprint(auth_bp, url_prefix="/auth")
app.register_blueprint(user_bp, url_prefix="/user")if __name__ == '__main__':app.run(debug=True)
- 在上面的示例中,我们创建了两个蓝图,分别是
auth_bp
和main_bp
。每个蓝图都定义了一组路由,分别处理身份验证和主页的请求,然后,我们将这些蓝图注册到应用中,并且使用url_prefix
设置了对应子模块的前缀。 - 例如想要访问
about
则需要访问http://127.0.0.1:5000/user/about
- 这个
url_prefix
是可选的,如果没加前缀则依然是访问http://127.0.0.1:5000/about
通过使用蓝图,我们可以将不同功能的代码模块化,并更好地组织和管理项目代码。
修改蓝图的资源文件夹和模板文件夹
- 创建蓝图的时候,可以使用
template_folder
参数设置当前蓝图使用的模板文件夹- 优先级: 全局
templates
> 当前蓝图templates
- 优先级: 全局
- 创建蓝图的时候,可以使用
static_folder
参数设置当前蓝图使用的资源文件夹- 优先级: 全局
static
> 当前蓝图static
- 优先级: 全局
- 并且非常值得一提的是,当使用了前缀
url_prefix
并且修改了static_folder
的时候,想要引用资源,每个资源文件前面需要拼接前缀! - 创建蓝图的时候,可以使用
static_url_path
参数设置当前蓝图使用的资源文件夹的应用路径,意思是假设资源文件原本放在文件夹user_static
下,但是设置了static_url_path = "u_static"
则需要使用u_static
才能正确访问到资源文件
使用蓝图的项目文件架构
用以上蓝图作为案例
My_project
│
├─.idea
│ │
│ └─...
│
│
├─user
│ __init__.py
│ view.py
│
├─auth
│ __init__.py
│ view.py
│
│
│ app.py
│
├─static
│ ├─css
│ ├─img
│ └─js
├─templates
│ │ index.html
│ │
│ ├─auth
│ │ login.html
│ │ register.html
│ │
│ ├─macros
│ │ macros.html
│ │
│ └─user
│ about.html
│ play.html
│
│
│
└─...
在软件包的__init__.py
中实现创建蓝图
# auth/__init__.py
from flask import Blueprint# 创建蓝图
auth_bp = Blueprint('auth', __name__)from auth import views
在 views.py
中定义路由
# auth/view.py
from flask import render_templatefrom auth import auth_bp@auth_bp.route('/login')
def login():return render_template('auth/login.html')@auth_bp.route('/register')
def register():return render_template('auth/register.html')
在 app.py
中注册蓝图,以及其他的应用配置
# app.py
from flask import Flaskfrom auth import auth_bp
from user import user_bpapp = Flask(__name__)@app.route('/')
def hello_world():return '你好'# 注册蓝图
app.register_blueprint(auth_bp, url_prefix="/auth")
app.register_blueprint(user_bp, url_prefix="/user")if __name__ == '__main__':app.run(debug=True)
通常的做法会在
my_project
根目录下创建一个__init__.py
文件,然后把app.py
的应用主程序放进去,但我的习惯是使用app.py
,读者自由选择。
注意文件结构是为了方便管理,符合规范,个人习惯不同,使用方式也不尽相同,但是大体规范还是要遵守的,有助于代码的组织和维护。
蓝图中使用url_for
函数
from flask import Flask, Blueprint, url_for# 创建 Flask 应用
app = Flask(__name__)# 创建一个蓝图
blueprint = Blueprint('my_blueprint', __name__, url_prefix='/blueprint')# 在蓝图中添加路由
@blueprint.route('/hello')
def hello():return 'Hello from the blueprint!' + "-----------" + url_for('my_blueprint.hello')# 将蓝图注册到应用中
app.register_blueprint(blueprint)# 运行应用
if __name__ == '__main__':app.run(debug=True)
- 效果
在这个例子中,url_for
函数的参数是路由的名称,格式为 <蓝图名称>.<路由名称>
。这样,url_for('my_blueprint.hello')
就会生成蓝图中 /hello
路由的 URL 地址。
此处需要区分 蓝图名称
my_blueprint
和 蓝图对象blueprint
,要使用的是蓝图名称而不是蓝图对象。
蓝图使用子域名
使用子域名(Subdomains)可以使您的 Flask 应用程序在不同的子域名下提供不同的内容或服务。
要在 Flask 中使用子域名,您可以使用 Flask 的 Blueprint
类创建蓝图,并通过 subdomain
参数指定子域名。以下是一个简单的示例:
from flask import Flask, Blueprintapp = Flask(__name__)# 创建蓝图
subdomain_blueprint = Blueprint('subdomain_blueprint', __name__, subdomain='sub')# 将路由添加到蓝图
@subdomain_blueprint.route('/')
def subdomain_home():return 'Hello from the subdomain!'# 将蓝图注册到应用程序
app.register_blueprint(subdomain_blueprint)if __name__ == '__main__':app.run(debug=True)
在这个示例中创建了一个名为 subdomain_blueprint
的蓝图,并将其指定为子域名为 sub
。然后,我们定义了一个路由 /
,在子域名中返回简单的消息。最后,我们通过 app.register_blueprint()
将蓝图注册到应用程序,并指定子域名为 sub
。
现在,当用户访问 http://sub.example.com/
时,将会看到来自子域名的消息。
请注意,在开发环境中,您可能需要将子域名映射到本地主机(例如,在 hosts
文件中),以便在本地测试子域名。
- hosts文件配置
要在本地测试子域名,您可以通过修改操作系统的 hosts 文件来将子域名映射到本地主机。以下是在常见操作系统中修改 hosts 文件的方法:
Windows
- 打开资源管理器,转到以下路径:
C:\Windows\System32\drivers\etc\
- 找到 hosts 文件,并用文本编辑器(如 Notepad)以管理员身份打开。
- 在文件末尾添加一行,格式为
127.0.0.1 sub.example.com
,其中sub.example.com
是您要映射的子域名。 - 保存文件并关闭编辑器。
macOS
- 打开终端应用(可以在应用程序 -> 实用工具中找到)。
- 输入以下命令以编辑 hosts 文件:
sudo nano /etc/hosts
- 输入您的管理员密码并按下 Enter。
- 在文件末尾添加一行,格式为
127.0.0.1 sub.example.com
,其中sub.example.com
是您要映射的子域名。 - 按下
Ctrl + O
保存文件,然后按下 Enter。 - 按下
Ctrl + X
关闭编辑器。
Linux
- 打开终端。
- 输入以下命令以编辑 hosts 文件(您可能需要使用 sudo 提升权限):
sudo nano /etc/hosts
- 输入您的管理员密码(如果需要)并按下 Enter。
- 在文件末尾添加一行,格式为
127.0.0.1 sub.example.com
,其中sub.example.com
是您要映射的子域名。 - 按下
Ctrl + O
保存文件,然后按下 Enter。 - 按下
Ctrl + X
关闭编辑器。
在修改 hosts 文件后,您应该能够在本地访问您设置的子域名,并将其映射到本地主机上的 Flask 应用程序。请注意,这些更改可能需要一些时间才能生效,因此您可能需要清除 DNS 缓存或重启浏览器。