Skip to content

6. 数据作用域

Web 应用程序同时为许多用户提供服务,每个用户还会发出大量请求。因此,数据可以在多个层级上共享,这些层级称为数据的作用域:

  • 应用程序作用域:数据在服务器的整个生命周期内由所有用户共享(例如医生列表);
  • 请求作用域:数据仅在单个请求期间存在(视图的模型,以及为该请求所识别出的已登录用户);
  • 客户端作用域:数据专属于某个用户,并且必须在一个请求到下一个请求之间保持(所选语言、已登录用户)。

对于最后这种作用域,Web 应用程序长期以来使用由服务器维护的会话:即为每个浏览器专设的一块内存,通过标识 Cookie 来识别([JSESSIONID] 用于 [Java],[PHPSESSID] 用于 [PHP])。[Flask] 的会话则不同:正如我们在示例 20 中看到的,它存储在客户端的已签名 Cookie 中。服务器在同一用户的两次请求之间不存储任何东西:这称为无状态。例如,这使得可以在负载均衡器后面运行多个相同的服务器:其中任何一个都可以处理任何请求。代价是 Cookie 受用户控制;用户可以读取它,并尝试修改它。因此,这里只存放非敏感数据,并且——如果数据必须可信——由服务器对其签名,服务器随后便能检测到任何修改:[Flask] 的会话和身份验证令牌就是这种情况(见身份验证一章)。

在 [Flask] 中,每种作用域都有自己的容器:

作用域
载体
生命周期
应用程序
启动时创建的对象,存储在 [app.extensions] 中,并通过 [current_app] 获取(示例 06)
整个服务器生命周期,由所有请求共享
请求
对象 [g],以及对象 [request] 本身(示例 16)
处理请求期间
会话
对象 [session],一个存储在已签名 Cookie 中的字典
直到浏览器关闭(默认情况)
客户端
由 [set_cookie] 设置的标准 Cookie(示例 22)
由 [max_age] 设定的时长

对象 [current_app]、[g]、[request] 和 [session] 都是从包 [flask] 中导入的。它们是代理 (示例 05):在请求期间,每个代理都指向该请求(或处理该请求的应用程序)的对象。

6.1. 示例 23:作用域

1
2
3
4
5
6
7
8
9
23-scopes/
├── app.py
├── controllers/
│   └── scopes.py
├── services/
│   └── counter.py
└── templates/
    └── scopes/
        └── scopes.html

6.1.1. 对象:services/counter.py

# services/counter.py:一个共享计数器,以及一次请求的信息
from itertools import count
from threading import Lock


# APPLICATION 作用域:唯一的实例(见 app.py)
class CounterService:

    def __init__(self):
        self._total = 0
        # 多个请求可能同时运行:锁保证
        # 两次同时进行的递增不会丢失
        self._lock = Lock()

    def increment(self) -> int:
        with self._lock:
            self._total += 1
            return self._total


# REQUEST 作用域:每个请求一个实例(见 app.py,start 函数)
class RequestInfo:

    # 由所有实例共享的计数器(类属性);
    # next(...) 是原子的:两个线程绝不会得到同一个数字
    _instances = count(1)

    def __init__(self, start: str):
        self.number = next(RequestInfo._instances)
        self.start = start
  • 第 7–18 行:一个访问计数器,具有应用程序作用域:只有一个对象,由所有请求共享。与示例 20 中的任务列表一样,由一把锁保护递增操作:[self._total += 1] 语句不是原子的 (它先读取值,再递增,然后写回),两个线程同时执行它可能会读到相同的值——导致丢失一次访问;
  • 第 22–30 行:请求作用域的信息:每个请求一个对象,包含一个编号和请求的时间。编号来自所有实例共享的计数器:标准模块 [count(1)] 的 [itertools] 是一个迭代器 ,每次调用 [next] 时依次产生 1、2、3……这是一个类属性 (在类级别而不是构造函数中声明):它由所有实例共享。

6.1.2. 配置:app.py

# app.py:示例 23 的应用
from datetime import datetime
from pathlib import Path

from flask import Blueprint, Flask, g

from controllers.scopes import scopes
from services.counter import CounterService, RequestInfo

BOOTSTRAP = Path(__file__).resolve().parent.parent / "common" / "bootstrap"


def create_app():
    app = Flask(__name__)
    app.jinja_env.trim_blocks = True
    app.jinja_env.lstrip_blocks = True
    # 为会话 Cookie 签名的密钥(SESSION 作用域)
    app.config["SECRET_KEY"] = "a-secret-key-for-example-23"
    # APPLICATION 作用域:单一对象,在启动时创建,由所有用户的
    # 所有请求共享
    app.extensions["counter"] = CounterService()
    app.register_blueprint(Blueprint("bootstrap", __name__, static_folder=BOOTSTRAP,
                                     static_url_path="/bootstrap"))
    app.register_blueprint(scopes)

    # REQUEST 作用域:g 对象随每个请求而生,随请求而灭。这个
    # 在动作之前执行的函数,在其中存入一个对象,动作和
    # 视图会在本次请求中再次找到它
    @app.before_request
    def start():
        g.info = RequestInfo(datetime.now().strftime("%H:%M:%S.%f")[:-3])

    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • 第 18 行:用于对会话 Cookie 签名的密钥;
  • 第 21 行:应用程序作用域的对象;
  • 第 29–31 行:在每个请求之前,一个 [RequestInfo] 对象被存储在 [g] 中。动作和视图会获取它,但只限于本次请求期间。[strftime("%H:%M:%S.%f")] 把时间格式化为带微秒的形式([%f],六位数字);[[:-3]] 去掉字符串的最后三个字符,只留下毫秒。

6.1.3. 控制器:controllers/scopes.py

# controllers/scopes.py:四种数据作用域
from flask import Blueprint, current_app, g, make_response, render_template, request, session

scopes = Blueprint("scopes", __name__)


@scopes.get("/")
def display():
    # APPLICATION:共享计数器
    total = current_app.extensions["counter"].increment()
    # SESSION:本浏览器专属的字典,Flask 将其存放在
    # 签名的 Cookie(session)中;它持续到浏览器关闭为止
    session["visits"] = session.get("visits", 0) + 1
    # CLIENT:由浏览器保存在普通 Cookie 中的一份数据,
    # 每次请求都会回传给服务器
    my_visits = to_integer(request.cookies.get("myVisits")) + 1
    response = make_response(render_template(
        "scopes/scopes.html", total=total, instance=g.info.number,
        session_visits=session["visits"], my_visits=my_visits))
    response.set_cookie("myVisits", str(my_visits), httponly=True, samesite="Lax")
    return response


# "41" -> 41;None 或 "abc" -> 0
def to_integer(text: str | None) -> int:
    try:
        return int(text)
    except (TypeError, ValueError):
        return 0
  • 第 10 行:应用程序作用域。[current_app] 指向正在处理当前请求的应用程序;
  • 第 13 行:会话作用域。[session] 像字典一样使用:[session.get("visits", 0)] 返回该键的值,如果该键不存在则返回 0。当动作修改会话时,[Flask] 会在响应中附带发送一个新的 Cookie [session],其中包含已签名的字典;
  • 第 16 行:客户端作用域,使用一个普通 Cookie [myVisits],读取自 [request.cookies]。它的值是浏览器提供的字符串,因此可能缺失或无效;函数 [to_integer] 在这两种情况下都返回 0;
  • 第 17–20 行:要设置 Cookie,需要响应对象:[make_response] 用视图生成的页面构造它(示例 05),然后 [set_cookie] 向其添加头部 [Set-Cookie]。如果没有 [max_age],Cookie 会持续到浏览器关闭(它是浏览器所定义的“会话”Cookie);
  • 第 18 行:请求作用域:存储在 [g] 中的对象,由函数 [start] 存入。

6.1.4. 视图:templates/scopes/scopes.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Scopes</title>
  <link rel="stylesheet" href="{{ url_for('bootstrap.static', filename='css/bootstrap.min.css') }}">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
    {# g 和 session 在同一个请求期间可在视图中访问 #}
    <ul>
      <li>application: {{ total }} visit(s) to the site, all browsers combined</li>
      <li>request: object no. {{ instance }} (no. {{ g.info.number }} in the view),
        request received at {{ g.info.start }}</li>
      <li>session: {{ session_visits }} visit(s) from this browser ({{ session["visits"] }} in the view)</li>
      <li>client: {{ my_visits }} visit(s) from this browser</li>
    </ul>
  </div>
</body>
</html>

对象 [g] 和 [session] 在视图中同样可以访问。视图显示从动作收到的值,并在括号中显示直接从 [g] 和 [session] 读取的相同的值:在同一个请求期间,动作和视图看到的是相同的对象。

6.1.5. 执行

在浏览器中访问两次之后:

Image

让我们用 [curl] 来跟踪这些请求,它充当第一个浏览器,把 Cookie 存储在文件 [a.txt] 中:

curl -i -c a.txt -b a.txt http://localhost:5000/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 581
Set-Cookie: myVisits=1; HttpOnly; Path=/; SameSite=Lax
Set-Cookie: session=eyJ2aXNpdHMiOjF9.arfKwA.YK-2GACLdbCJ_NXM5dYJYlqEF-4; HttpOnly; Path=/
...
      <li>application: 1 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 2 (no. 2 in the view),
        request received at 15:38:08.779</li>
      <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser</li>
...

响应设置了两个 Cookie。第一个 [myVisits] 以明文形式包含该值。第二个 [session] 包含会话字典:第一个句点之前的部分是 JSON [{"visits":1}],经过 Base64 编码(与示例 20 中一样未压缩,因为它很短);后面是日期和签名。

请求作用域的对象编号为 2,尽管这是第一次访问该页面:这是因为 [start] 函数会在应用程序收到的每个请求之前运行,包括没有对应动作的请求(这里是刚才发出的对不存在的 URL 的请求)以及对静态文件的请求。在浏览器中,每个页面因此会再触发一个对 [Bootstrap] 样式表的请求:这就是截图中编号为奇数的原因。使用相同的 Cookie 进行第二次访问:

curl -i -c a.txt -b a.txt http://localhost:5000/
1
2
3
4
5
6
7
8
Set-Cookie: myVisits=2; HttpOnly; Path=/; SameSite=Lax
Set-Cookie: session=eyJ2aXNpdHMiOjJ9.arfKwA.l68wWEMYpKTfN3xPp_lysXPExO8; HttpOnly; Path=/
...
      <li>application: 2 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 3 (no. 3 in the view),
        request received at 15:38:08.799</li>
      <li>session: 2 visit(s) from this browser (2 in the view)</li>
      <li>client: 2 visit(s) from this browser</li>

第二个“浏览器”,拥有自己的 Cookie 文件,最初为空:

curl -c b.txt -b b.txt http://localhost:5000/
1
2
3
4
5
      <li>application: 3 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 4 (no. 4 in the view),
        request received at 15:38:08.813</li>
      <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser</li>

应用程序计数器一直在继续累加;第二个浏览器的会话和 Cookie 则从 1 重新开始。最后,一个恶意用户伪造了自己的 Cookie:[myVisits] 中有 1,000 次访问,以及一个声称包含 [{"visits":999}] (Base64 编码为 [eyJ2aXNpdHMiOjk5OX0])的会话,并附上了另一个会话的签名:

curl -b "myVisits=1000;session=eyJ2aXNpdHMiOjk5OX0.arfKwA.YK-2GACLdbCJ_NXM5dYJYlqEF-4" http://localhost:5000/
1
2
3
4
      <li>application: 4 visit(s) to the site, all browsers combined</li>
      ...
      <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1001 visit(s) from this browser</li>

普通 Cookie 被原样接受:1,001 次访问。然而,伪造的会话被拒绝了:它的签名与其内容不匹配,[Flask] 将其忽略,就好像它不存在一样。这正是普通 Cookie 与已签名 Cookie 之间的关键区别。让我们记住这条规则:来自客户端的数据只有在经过服务器签名时才值得信任;即使经过签名,它仍然是可读的:我们不在其中放任何机密。