6. 数据作用域
Web 应用程序同时为许多用户提供服务,每个用户都会发出大量请求。因此,数据可以在多个层级上共享,这些层级称为数据的作用域:
- 应用程序作用域:数据在应用程序的整个生命周期内由所有用户共享(例如医生列表);
- 请求作用域:数据仅在一次请求期间存在(模板的模型,该请求所识别出的已登录用户);
- 会话作用域:数据专属于某个用户,并且必须在请求之间保持(所选语言、购物车);
- 客户端作用域:存储在浏览器本身中的数据,位于 Cookie 中。
在 [Python] 中,这些作用域的性质与 [Symfony] 课程的读者所熟悉的有所不同,因为应用程序在请求之间一直驻留在内存中(示例 01)。存储在模块变量中的数据(示例 06、20 和 21)天然具有应用程序作用域:这既方便又非常快。但这种作用域有两个局限。第一,它只在进程存续期间有效:服务器重启会将其清除。第二,它是进程专属的:在生产环境中,通常会启动多个应用程序进程(例如 [gunicorn] 的多个“工作进程”),甚至在负载均衡器后面运行多台服务器,每个进程或服务器都会有自己的数据副本。因此,真正需要共享并长期保存的数据应存储在数据库或共享缓存中([Redis]、[Memcached],[Django] 可通过其 [CACHES] 设置使用它们)。为换取速度,共享需要严格的纪律:一个进程会跨多个线程同时处理多个请求,由一个进程修改的共享数据对所有线程可见;它必须由锁保护(示例 20),并且属于特定用户的数据绝不能存储在其中。
在 [Django] 中,每种作用域都有自己的容器:
作用域 | 容器 | 生命周期 |
应用程序 | 模块变量(单个进程)、[Django] 缓存([CACHES] 设置)或数据库 | 进程的生命周期;为缓存选定的时长;数据库则没有限制 |
请求 | [HttpRequest] 对象,中间件组件可以为其添加属性(示例 12);视图的局部变量 | 一次请求的处理期间 |
会话 | 会话([request.session],应用 [django.contrib.sessions]),由服务器维护,通过 Cookie 检索 | 默认两周(设置 [SESSION_COOKIE_AGE]) |
客户端 | Cookie([set_cookie],示例 22),可以是明文,也可以是签名的([set_signed_cookie]) | Cookie 所指定的持续时间 |
[Django] 的会话默认是服务器端会话,与 [Java] ([JSESSIONID])或 [PHP]([PHPSESSID])的会话一样:其数据存储在服务器上,浏览器只在 [sessionid] Cookie 中保存标识符——一个无法猜测的随机数。[SESSION_ENGINE] 设置决定数据的存储位置:数据库(默认选项,存储在名为 [django_session] 的表中)、缓存、文件(我们的示例所使用的选项),甚至像 [Flask] 那样,完全存储在客户端设备的签名 Cookie 中。
6.1. 示例 23:作用域
| 23-scopes/
├── config/
│ ├── settings.py
│ └── ...
├── scopes/
│ ├── __init__.py
│ ├── counters.py
│ ├── middleware.py
│ └── views.py
├── templates/
│ └── scopes/
│ └── scopes.html
├── var/
│ └── sessions/
└── manage.py
|
6.1.1. 配置:config/settings.py
| # config/settings.py:示例 23 的配置
from pathlib import Path
BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-1zxb1%#mksmtg+m&rsp_e6&i7@6sbtm_i=lqjq_+rg#-=i5r-p"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"
INSTALLED_APPS = [
"django.contrib.staticfiles",
# 会话
"django.contrib.sessions",
"scopes",
]
MIDDLEWARE = [
# 会话中间件:它在请求开始时找到浏览器的会话(借助
# sessionid Cookie),并在请求结束时保存它
"django.contrib.sessions.middleware.SessionMiddleware",
# 请求作用域:每个请求一个对象(见 scopes/middleware.py)
"scopes.middleware.RequestInfoMiddleware",
]
# 会话数据存储在服务器上的文件中(每个
# 会话一个),位于示例的 var/sessions 文件夹,若不存在则创建
SESSION_ENGINE = "django.contrib.sessions.backends.file"
SESSION_FILE_PATH = BASE_DIR / "var" / "sessions"
SESSION_FILE_PATH.mkdir(parents=True, exist_ok=True)
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [BASE_DIR / "templates"],
"OPTIONS": {
"context_processors": [
# request 变量,因此也包括 request.session 和 request.info
"django.template.context_processors.request",
],
},
},
]
STATIC_URL = "static/"
STATICFILES_DIRS = [
BASE_DIR.parent / "common" / "static",
]
|
- 第 17 行:会话处理;
- 第 21–27 行:两个中间件组件。[SessionMiddleware] 在请求开始时通过 [sessionid] Cookie 检索浏览器的会话,并将其存储在 [request.session] 中;在请求结束时,如果会话已被修改,则保存会话并发送 Cookie。它只在第一次访问 [request.session] 时才真正读取数据:不使用它的视图不会产生任何开销。第二个中间件是我们自己的(见下文);
- 第 31–33 行:会话数据存储在文件中——每个会话一个文件——位于示例的 [var/sessions] 文件夹中,我们可以检查这些文件。第 33 行在该文件夹不存在时创建它([parents=True]:包括父文件夹;[exist_ok=True]:如果已存在则不报错):设置文件是 [Python] 文件,可以执行代码。默认选项即数据库,需要有数据库(下一章);
- 第 42 行:上下文处理器 [request]:模板将使用 [request.session] 和 [request.info]。
6.1.2. 对象:scopes/counters.py 和 scopes/middleware.py
| # scopes/counters.py:应用作用域,由所有用户的所有
# 请求共享的计数器
import threading
from collections import Counter
# 一个 Counter:字典 {键: 数字},不存在的键值为 0。它在
# 模块加载时创建,与服务器进程同寿命
_counters = Counter()
_lock = threading.Lock()
# 在 [key] 键下加一;+= 不是原子操作:两个
# 同时发生的请求可能读到相同的值。锁可以避免这种情况
def next_value(key: str) -> int:
with _lock:
_counters[key] += 1
return _counters[key]
|
- 第 5 行:来自模块 [Counter] 的类 [collections]:一个值为数字的字典,其缺失的键被设置为 0;
- 第 9–10 行:计数器及其锁,在模块加载时创建;它们在服务器进程运行期间一直存在。这就是应用程序作用域;
- 第 15–18 行:给某个键下的数字加一。运算 [+=] 不是原子的:它先读取值,再递增,然后写入,两个同时发生的请求可能读到同一个值——这样就会丢失一次访问。锁(示例 20)可以防止这种情况。
| # scopes/middleware.py:请求作用域,一个请求的信息
from dataclasses import dataclass
from django.utils import timezone
from . import counters
@dataclass(frozen=True)
class RequestInfo:
number: int
start: str
# 中间件为每个请求创建一个 RequestInfo 对象,并将其存储在请求中:
# 视图和模板通过 request.info 找到它。它随请求一起消失
class RequestInfoMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
request.info = RequestInfo(
# 每创建一个对象就有一个编号,取自所有请求共用的计数器
number=counters.next_value("instances"),
# 时间,精确到毫秒
start=timezone.localtime().strftime("%H:%M:%S.%f")[:-3])
return self.get_response(request)
|
- 第 10–13 行:请求作用域的信息:一个编号和请求时间;
- 第 18–28 行:中间件为每个请求创建一个 [RequestInfo] 对象,并将其存储在请求中(示例 12)。编号取自所有请求共享的计数器(即上一个模块,使用不同的键);因此,每个对象的编号都不同。时间写作包含毫秒的形式:[%f] 表示微秒(六位数字),[[:-3]] 从中去掉最后三位(字符串切片:除最后三个字符之外的所有字符)。该对象会随请求一起被删除。
[Django] 没有服务容器,因此也没有“请求作用域服务”:是请求本身携带着这一作用域中的对象。学过 [Symfony] 课程的读者会记得情况恰恰相反:在 [PHP] 中,每个服务都是请求作用域的,需要缓存才能获得应用程序作用域。
6.1.3. 签名 Cookie
Cookie 是托付给客户端的一段数据,客户端可以读取和修改它。要让 Cookie 值得信任,只需对其签名:它的值以明文传输,但后面跟着一个只有服务器才知道如何计算的签名,因为该签名依赖于一个密钥。被客户端修改过的值不再具有正确的签名,服务器会拒绝它。[Django] 为我们处理了这一切:[response.set_signed_cookie(name, value)] 设置签名 Cookie,而 [request.get_signed_cookie(name, default=...)] 在签名正确时返回其值;否则返回默认值。该签名是 HMAC(Hash-based Message Authentication Code,基于哈希的消息认证码):即值的哈希(SHA-256),使用应用程序的密钥([SECRET_KEY],示例 01)和特定于 Cookie 名称的“盐”计算得出。[Django] 会添加签名日期,这样就可以拒绝过期的 Cookie([get_signed_cookie(..., max_age=3600)])。验证过程比较签名所用的时间与相同字符的数量无关:标准比较会在第一个不同的字符处停止,攻击者可以通过测量响应时间逐个字符地猜出签名。[django.core.signing] 模块提供了对任意数据进行签名的相同功能([signing.dumps]、[signing.loads]):示例 20 中的闪现消息正是由该模块签名的。
这就是 JWT 令牌背后的原理,下一章将使用它进行身份验证。
6.1.4. 视图:scopes/views.py
| # scopes/views.py:数据的四种作用域
from django.shortcuts import render
from django.views.decorators.http import require_GET
from . import counters
@require_GET
def scopes(request):
# 应用:共享计数器
total = counters.next_value("visits")
# 会话:专属于此浏览器的数据,由服务器保存(var/sessions 中的
# 一个文件),借助会话 Cookie 找到;会话
# 像字典一样使用
request.session["visits"] = request.session.get("visits", 0) + 1
# 客户端:由浏览器保存在 Cookie 中的数据,每次请求时回传给
# 服务器;一个是明文的,另一个带签名
my_visits = int(request.COOKIES.get("myVisits", 0)) + 1
# get_signed_cookie:若签名正确则返回值;否则返回默认值
my_visits_signed = int(request.get_signed_cookie("myVisitsSigned", default=0)) + 1
response = render(request, "scopes/scopes.html", {
"total": total,
"instance": request.info.number,
"session_visits": request.session["visits"],
"my_visits": my_visits,
"my_visits_signed": my_visits_signed,
})
response.set_cookie("myVisits", str(my_visits))
# set_signed_cookie:值,后跟用 SECRET_KEY 计算的签名
response.set_signed_cookie("myVisitsSigned", str(my_visits_signed))
return response
|
- 第 12 行:应用程序作用域;
- 第 16 行:会话作用域。[request.session] 像字典一样使用:[get(key, default)] 读取值,赋值则写入值。[Django] 在请求结束时保存会话。值必须可转换为 JSON(字符串、数字、列表、字典):这就是它们的存储方式;
- 第 19–21 行:客户端作用域,使用两个 Cookie。[request.COOKIES] 是浏览器所发送 Cookie 的字典。它们的值是浏览器提供的字符串,因此可能缺失或无效:[int] 对其进行转换(名为 [myVisits=abc] 的 Cookie 在这里会抛出 [ValueError] 异常并导致 500 错误;真实的应用程序会验证该值;参见示例 07)。只有签名正确时,才接受签名 Cookie 的值;
- 第 22–28 行:模板上下文;
- 第 29–31 行:要设置 Cookie,需要响应对象:[render] 构造它(示例 13),然后 [set_cookie] 和 [set_signed_cookie] 将 Cookie 添加到其中。如果没有过期时间([max_age]),Cookie 会持续到浏览器关闭为止(这是浏览器所定义的“会话”Cookie)。
6.1.5. 模板:templates/scopes/scopes.html
| <!doctype html>
{% load static %}
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Scopes</title>
<link rel="stylesheet" href="{% static 'bootstrap/css/bootstrap.min.css' %}">
</head>
<body>
<div class="container py-3">
<h1 class="h3">The scopes of data</h1>
{# request.info:中间件存放在请求中的对象;与视图中的是同一个 #}
<ul>
<li>application: {{ total }} visit(s) to the site, all browsers combined</li>
<li>request: object no. {{ instance }} (no. {{ request.info.number }} in the template),
request received at {{ request.info.start }}</li>
{# request.session:会话,在模板中也可访问 #}
<li>session: {{ session_visits }} visit(s) from this browser ({{ request.session.visits }} in the template)</li>
<li>client: {{ my_visits }} visit(s) from this browser (plain cookie),
{{ my_visits_signed }} (signed cookie)</li>
</ul>
</div>
</body>
</html>
|
- 第 16 行:[request.info],由中间件存储在请求中的对象:它与视图中的 [RequestInfo] 对象是同一个对象;模板显示它的编号,该编号必须与从视图收到的编号一致;
- 第 19 行:会话也可以在模板中通过 [request.session] 访问。
6.1.6. 执行
在浏览器中访问三次之后:

请求对象的编号大于访问次数:首次访问时,浏览器还请求了站点图标([/favicon.ico]),而它并不存在。这个导致 404 错误的请求也经过了中间件,因此有它自己的 [RequestInfo] 对象。
让我们用 [curl] 跟踪请求,它充当第一个浏览器,将其 Cookie 存储在文件 [a.txt] 中(服务器刚刚启动):
| curl -i -c a.txt -b a.txt http://localhost:8000/
|
| HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Vary: Cookie
Set-Cookie: myVisits=1; Path=/
Set-Cookie: myVisitsSigned=1:1xAspT:iu2OlkhoUcBt0QBGkt_Gkjm2PoYfUeS6WSsO5KEHt0k; Path=/
Set-Cookie: sessionid=ij72qd9hyuhwoqlplawuxycwg6ggccsq; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
<li>application: 1 visit(s) to the site, all browsers combined</li>
<li>request: object no. 1 (no. 1 in the template),
request received at 19:38:23.123</li>
<li>session: 1 visit(s) from this browser (1 in the template)</li>
<li>client: 1 visit(s) from this browser (plain cookie),
1 (signed cookie)</li>
...
|
响应设置了三个 Cookie。第一个 [myVisits] 以明文包含该值。第二个 [myVisitsSigned] 包含相同的值,后面依次是冒号、签名日期(以 62 进制表示)和签名本身。第三个 [sessionid] 是会话 ID,有效期两周([Max-Age=1209600] 秒)、[HttpOnly]、并且 [SameSite=Lax] (示例 20)。会话数据存储在服务器上的一个文件中,[var/sessions/sessionidij72qd9hyuhwoqlplawuxycwg6ggccsq],其名称源自该标识符:
| eyJ2aXNpdHMiOjF9:1xAspT:mYytMt_81vJlDI_gaKudIqPgoxAvrGUZbnk578MZr3I
|
在这里,我们可以认出来自 [Django] 的签名数据格式:数据、日期和签名。数据来自 JSON,以 Base64 编码:[eyJ2aXNpdHMiOjF9] 解码为 [{"visits":1}]。服务器甚至会对自己的会话文件签名:被第三方修改过的文件会被拒绝。第二次访问,使用相同的 Cookie:
| curl -i -c a.txt -b a.txt http://localhost:8000/
|
| ...
Set-Cookie: myVisits=2; Path=/
Set-Cookie: myVisitsSigned=2:1xAspT:E9lE-GK-yE7WfT5Ak58h2tufzXQ5vLWcWz5UBAS-dLA; Path=/
Set-Cookie: sessionid=ij72qd9hyuhwoqlplawuxycwg6ggccsq; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
<li>application: 2 visit(s) to the site, all browsers combined</li>
<li>request: object no. 2 (no. 2 in the template),
request received at 19:38:23.150</li>
<li>session: 2 visit(s) from this browser (2 in the template)</li>
<li>client: 2 visit(s) from this browser (plain cookie),
2 (signed cookie)</li>
...
|
会话是同一个(ID 相同);由于会话已被修改,其 Cookie 被再次发送,这会延长其生存期。第二个“浏览器”,使用它自己的 Cookie 文件,起初为空:
| curl -c b.txt -b b.txt http://localhost:8000/
|
| <li>application: 3 visit(s) to the site, all browsers combined</li>
<li>request: object no. 3 (no. 3 in the template),
request received at 19:38:23.167</li>
<li>session: 1 visit(s) from this browser (1 in the template)</li>
<li>client: 1 visit(s) from this browser (plain cookie),
1 (signed cookie)</li>
|
应用程序计数器继续累加;第二个浏览器的会话和 Cookie 则从 1 重新开始。每个请求都有它自己的 [RequestInfo] 对象,而在每个请求中,视图和模板都是相同的。最后,恶意用户伪造了自己的 Cookie:[myVisits] 中 1,000 次访问,[myVisitsSigned] 中 999 次(带有伪造的签名),以及一个他自己编造的会话 ID:
| curl -i -b "myVisits=1000;myVisitsSigned=999:abc;sessionid=abc" http://localhost:8000/
|
| ...
Set-Cookie: myVisits=1001; Path=/
Set-Cookie: myVisitsSigned=1:1xAspT:iu2OlkhoUcBt0QBGkt_Gkjm2PoYfUeS6WSsO5KEHt0k; Path=/
Set-Cookie: sessionid=l4316xnwacgz81f7yemjar89cfe05jm3; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
<li>session: 1 visit(s) from this browser (1 in the template)</li>
<li>client: 1001 visit(s) from this browser (plain cookie),
1 (signed cookie)</li>
...
|
明文 Cookie 被原样接受:1,001 次访问。然而,Cookie [myVisitsSigned] 没有正确的签名:它被忽略,就像缺失一样。从另一个值(例如 [1] 的签名)复制签名,并把它放在值 [999] 旁边,效果也好不到哪里去:签名取决于值。至于编造的会话 ID,它不指向任何现有的会话:[Django] 会忽略它,并创建一个新会话,使用它自己选择的新 ID。因此,用户无法选择其他用户的会话。
让我们记住这条规则:来自客户端的数据,只有在受到服务器保护(如这里那样签名,或如身份验证一章中的令牌那样签名,或加密)时才值得信任;没有什么需要隐藏、且其值由服务器验证的数据(示例 22 中的语言)可以保持明文。签名保证值没有被篡改,但并不会隐藏它:绝不能把机密托付给客户端,即使它已被签名。