【Flask 系统教程 5】视图进阶

类视图

在 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）是一种组织和管理应用路由的方式，它可以帮助您将应用拆分为更小的模块，提高代码的可维护性和可扩展性。蓝图允许您将相关的视图、模板和静态文件组织到单独的模块中，并将它们注册到应用中。

蓝图使用

以下是使用蓝图的一般步骤：

1. 创建蓝图： 在 Flask 应用中创建一个蓝图对象，通常在一个单独的 Python 模块中定义。

2. 定义视图： 在蓝图中定义视图函数，处理特定的 URL 请求。

3. 注册蓝图： 在应用对象上注册蓝图，使其生效。

4. 使用蓝图： 在应用中使用蓝图定义的路由和视图。

下面是一个简单的示例，演示如何在 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

通过使用蓝图，我们可以将不同功能的代码模块化，并更好地组织和管理项目代码。

---

修改蓝图的资源文件夹和模板文件夹

1. 创建蓝图的时候，可以使用 template_folder参数设置当前蓝图使用的模板文件夹
   • 优先级： 全局 templates > 当前蓝图 templates
2. 创建蓝图的时候，可以使用 static_folder参数设置当前蓝图使用的资源文件夹
   • 优先级： 全局 static> 当前蓝图 static
3. 并且非常值得一提的是，当使用了前缀 url_prefix 并且修改了 static_folder 的时候，想要引用资源，每个资源文件前面需要拼接前缀！
4. 创建蓝图的时候，可以使用 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

1. 打开资源管理器，转到以下路径：C:\Windows\System32\drivers\etc\
2. 找到 hosts 文件，并用文本编辑器（如 Notepad）以管理员身份打开。
3. 在文件末尾添加一行，格式为 127.0.0.1 sub.example.com，其中 sub.example.com 是您要映射的子域名。
4. 保存文件并关闭编辑器。

macOS

1. 打开终端应用（可以在应用程序 -> 实用工具中找到）。
2. 输入以下命令以编辑 hosts 文件：sudo nano /etc/hosts
3. 输入您的管理员密码并按下 Enter。
4. 在文件末尾添加一行，格式为 127.0.0.1 sub.example.com，其中 sub.example.com 是您要映射的子域名。
5. 按下 Ctrl + O 保存文件，然后按下 Enter。
6. 按下 Ctrl + X 关闭编辑器。

Linux

1. 打开终端。
2. 输入以下命令以编辑 hosts 文件（您可能需要使用 sudo 提升权限）：sudo nano /etc/hosts
3. 输入您的管理员密码（如果需要）并按下 Enter。
4. 在文件末尾添加一行，格式为 127.0.0.1 sub.example.com，其中 sub.example.com 是您要映射的子域名。
5. 按下 Ctrl + O 保存文件，然后按下 Enter。
6. 按下 Ctrl + X 关闭编辑器。

在修改 hosts 文件后，您应该能够在本地访问您设置的子域名，并将其映射到本地主机上的 Flask 应用程序。请注意，这些更改可能需要一些时间才能生效，因此您可能需要清除 DNS 缓存或重启浏览器。