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

类视图

在 Flask 中，除了使用函数视图外，你还可以使用类视图来处理请求。类视图提供了一种更为结构化和面向对象的方式来编写视图函数，使得代码组织更清晰，并且提供了更多的灵活性和可扩展性。

创建类视图

要创建一个类视图，你需要定义一个类，并继承 Flask 提供的视图类之一（如 FlaskView、MethodView 等）。然后，你可以在这个类中定义 HTTP 请求方法的处理函数，每个函数对应一个 HTTP 请求方法（GET、POST、PUT、DELETE 等）。

下面是一个简单的示例，演示了如何使用类视图处理 GET 请求：

from flask import Flask, request
from flask.views import View

app = Flask(__name__)

class HelloWorld(View):
    def dispatch_request(self):
        return 'Hello, World!'

app.add_url_rule('/', view_func=HelloWorld.as_view('hello')) # 设置标识为hello

if __name__ == '__main__':
    app.run(debug=True)
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个示例中，我们创建了一个名为 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 MethodView

app = Flask(__name__)

class UserAPI(MethodView):
    def get(self, user_id):
        # 处理GET请求
        return f"获取用户 {user_id} 的信息"

    def post(self):
        # 处理POST请求
        data = request.json
        return f"创建新用户: {data['name']}"

    def put(self, user_id):
        # 处理PUT请求
        data = request.json
        return 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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

在上面的示例中，我们定义了一个UserAPI类，继承自MethodView基类。
每个HTTP请求方法（GET、POST、PUT、DELETE）都对应于类中的一个方法。
然后，我们将这个类视图绑定到了不同的URL，并指定了对应的HTTP请求方法。当客户端发起请求时，Flask会根据请求的方法自动调用相应的方法来处理请求。

• defaults设置变量的默认值
• methods指定请求方法

---

类视图的优势

使用类视图相比于函数视图有一些优势：

• 更好的代码组织：类视图将相似功能的代码组织到一个类中，使得代码更易于维护和管理。
• 支持更多的功能：类视图提供了更多的功能和灵活性，例如可以使用类属性来共享数据，可以通过类方法来实现重复使用的逻辑等。
• 支持类继承：你可以继承已有的类视图，并在子类中进行定制，从而实现代码的复用和扩展。

装饰器

Flask 是一个 Python Web 框架，使用装饰器（decorators）是其核心特性之一。装饰器可以在函数或方法的定义前使用 @ 符号，用于修改或者增强函数的功能。在 Flask 中，装饰器通常用于路由的定义，以及在请求处理过程中执行额外的逻辑。

下面是 Flask 中最常见的装饰器及其作用：

@app.route('/')

这是定义路由最常用的装饰器，用于指定 URL 和请求方法与视图函数的关联。例如：

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello, World!'
1
2
3
4
5
6
7

当用户访问网站根目录时，Flask 将调用 index 函数来处理请求。

@app.before_request 和 @app.after_request

当您使用 Flask 框架时，@app.before_request 和 @app.after_request 这两个装饰器可以帮助您在请求处理前后执行特定的逻辑。下面是它们的简单示例用法：

from flask import Flask, request, jsonify

app = 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

在上面的示例中，@app.before_request 装饰器用于注册 before_request_func 函数，该函数在每个请求处理前执行。@app.after_request 装饰器用于注册 after_request_func 函数，该函数在每个请求处理后执行。这两个函数可以执行与请求和响应相关的任何操作。

您可以根据需要扩展这些函数，比如添加身份验证、请求日志记录、跨域请求处理等。

@app.errorhandler

当您使用 Flask 框架时，@app.errorhandler 装饰器可以用来处理特定类型的错误。下面是一个简单的示例，演示如何使用 @app.errorhandler：

from flask import Flask, jsonify

app = 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 / 0

if __name__ == '__main__':
    app.run(debug=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在上面的示例中，我们定义了两个错误处理函数，分别处理 404 和 500 错误。@app.errorhandler(404) 装饰器用于注册 not_found_error 函数，该函数处理 404 错误；@app.errorhandler(500) 装饰器用于注册 internal_server_error 函数，该函数处理 500 错误。

当 Flask 应用收到对应类型的错误时，它将调用相应的错误处理函数，并返回该函数返回的响应给客户端。

需要注意的是，404 错误处理函数会在路由找不到的情况下触发，而 500 错误处理函数会在应用内部发生异常时触发。

自定义装饰器

除了 Flask 提供的内置装饰器外，你还可以自定义装饰器来实现特定的功能，例如身份验证、性能监控等。例如，一个简单的自定义装饰器可以用来打印函数的执行时间：

**from flask import Flask
import time
from functools import wraps

app = 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 result
 return wrapper

# 使用 timeit 装饰器测量路由函数执行时间
@app.route('/')
@timeit
def index():
 # 模拟一个耗时操作
 time.sleep(1)
 return "Hello, World!"

if __name__ == '__main__':
 app.run(debug=True)
**
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

然后你可以将这个装饰器应用到任何你想要监测执行时间的函数上。

主要注意的是，在使用自定义装饰器的时候，一定要放在 @app.route('/')之后

类视图使用装饰器

以下是一个简单的示例，演示了如何在 Flask 中使用装饰器来扩展类视图的功能：

from flask import Flask, jsonify
from flask.views import MethodView

app = 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'}), 403
    return 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

在 类视图中使用 decorators 列表属性将该装饰器应用于整个类视图。

---

蓝图

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

蓝图使用

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

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

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

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

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

下面是一个简单的示例，演示如何在 Flask 中使用蓝图：

# app/auth/routes.py

from 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')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

创建蓝图 auth_bp ，并且使用 @blueprint_name.route('/path')创建该蓝图下的子模块 login和 register

# app/user/routes.py

from 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')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

创建蓝图 user_bp，并且使用 @blueprint_name.route('/path')创建该蓝图下的子模块 index和 about

# app/app.py

from flask import Flask
from app.auth.routes import auth_bp
from app.main.routes import main_bp

app = 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 在上面的示例中，我们创建了两个蓝图，分别是 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
│
│    
│
└─...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

在软件包的__init__.py 中实现创建蓝图

# auth/__init__.py
from flask import Blueprint

# 创建蓝图
auth_bp = Blueprint('auth', __name__)

from auth import views

1
2
3
4
5
6
7
8

在 views.py中定义路由

# auth/view.py
from flask import render_template

from 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')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在 app.py中注册蓝图，以及其他的应用配置

# app.py
from flask import Flask

from auth import auth_bp
from user import user_bp

app = 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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

---

通常的做法会在 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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 效果
  

在这个例子中，url_for 函数的参数是路由的名称，格式为 <蓝图名称>.<路由名称>。这样，url_for('my_blueprint.hello') 就会生成蓝图中 /hello 路由的 URL 地址。

此处需要区分 蓝图名称 my_blueprint 和 蓝图对象 blueprint，要使用的是蓝图名称而不是蓝图对象。

蓝图使用子域名

使用子域名（Subdomains）可以使您的 Flask 应用程序在不同的子域名下提供不同的内容或服务。

要在 Flask 中使用子域名，您可以使用 Flask 的 Blueprint 类创建蓝图，并通过 subdomain 参数指定子域名。以下是一个简单的示例：

from flask import Flask, Blueprint

app = 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个示例中创建了一个名为 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 缓存或重启浏览器。