Django-视图

这篇讲什么

  • 视图就是「收一个 HttpRequest 对象、还一个 HttpResponse 对象」的 Python 函数或类,URLconf 负责把 URL 指到它。
  • 这篇覆盖 URL 分派与视图参数、404 / 500 / 403 错误页、HttpRequest 与 QueryDict、CSRF、HttpResponse、装饰器与类视图、以及 cookie 和 session 两种状态保持。结论来自本机 Django 5.2.19 实测。

视图是什么

  • 视图就是一个 Python 函数(也可以是类),做两件事:收一个 HttpRequest 对象,还一个 HttpResponse 对象。

  • 它定义在应用的 views.py 里(业务大了可以拆成多个 py 文件,路由那边照样能指到)。

  • 返回的东西可以是网页 HTML、一次重定向、一段 JSON 数据、一个 404/403/500 错误,甚至一个文件流。

  • 请求处理过程:
    过程图

  • 本篇所有结论都是本机实测出来的:Django 5.2.19 + Python 3.14.10 + MySQL 9.7.4(驱动 mysqlclient 2.3.0)。

URLconf:把 URL 分派给视图

  • 根路由由设置决定

    • settings.py 里的 ROOT_URLCONF 指向哪个模块,Django 就读哪个模块的 urlpatterns。新项目默认是 工程名/urls.py。
  • urlpatterns 里到底装了什么(实测)

    • 老笔记说它是「一个 RegexURLResolver 实例的列表」,这句话在 Django 5.2 上已经不成立了:

      1
      2
      3
      4
      urlpatterns[0] 类型: URLResolver
      include() 那项类型: URLResolver
      RegexURLResolver 还在: False | cannot import name 'RegexURLResolver' from 'django.urls.resolvers'
      RoutePattern: RoutePattern | RegexPattern: RegexPattern
      • 现在只有两个类型:URLPattern(一条路由)和 URLResolver(include() 出来的子路由)。
      • 匹配模式也分两种:path() 生成 RoutePattern,re_path() 生成 RegexPattern。
    • 官方推荐的写法(path 优先,正则只在真的需要时才用):

      proj/urls.py
      1
      2
      3
      4
      5
      6
      7
      from django.contrib import admin
      from django.urls import include, path

      urlpatterns = [
      path("admin/", admin.site.urls),
      path("blog/", include("blog.urls")),
      ]
      blog/urls.py
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      from django.urls import path, re_path

      from blog import views

      app_name = "blog" # 命名空间来自这里

      urlpatterns = [
      path("", views.home, name="home"),
      path("p/<int:pk>/", views.params, name="params"),
      re_path(r"^re/(?P<num>\d+)/$", views.re_num, name="re"),
      ]
  • 子路由要 include(),而且别忘了应用没有 urls.py

    • startapp 不会自动生成 urls.py,include("blog.urls") 会直接:

      1
      ModuleNotFoundError: No module named 'blog.urls'
      • 手动建一个就行,这是新手最常卡的第一下。
  • APPEND_SLASH:少写一个斜杠是 301,不是 404(实测)

    1
    2
    缺斜杠(APPEND_SLASH=True): 301 -> /blog/home/
    缺斜杠带查询串: 301 -> /blog/home/?a=1
    • 由 CommonMiddleware 干的活,查询串会一起带过去。
    • 关掉它(APPEND_SLASH = False)就会变成 404,别指望它替你补拼错的 URL。
  • 反解:reverse() 与命名空间(实测)

    1
    2
    3
    4
    5
    6
    reverse('blog:home'): /blog/
    reverse('blog:params', args=[7]): /blog/p/7/
    reverse('blog:params2', kwargs): /blog/p/8/s/
    视图里不写命名空间: NoReverseMatch Reverse for 'params' not found. 'params' is not a valid view function or pattern name.
    同名多条时 kwargs 反解: NoReverseMatch Reverse for 'params' with keyword arguments '{'pk': 8, 'slug': 's'}' not found. 1 pattern(s) tried: ['blog/p/(?P<pk>[0-9]+)/\Z']
    反解不存在的名字: NoReverseMatch Reverse for '不存在' not found. '不存在' is not a valid view function or pattern name.
    • 应用里写了 app_name,模板和视图里就必须用 blog:home 这种带命名空间的名字,只写 home 会 NoReverseMatch。
    • 一个 name 只该对应一条路由;重复了 reverse 只会试第一条,参数对不上就报错。
    • 模板里用 {% url 'blog:params' pk=student.id %},别手拼 URL。

视图参数:转换器与正则分组

  • path() 的内置转换器(实测收到的类型)

    写法 请求 视图收到的值
    <int:pk> /blog/p/7/ pk=7(int)
    <slug:slug> /blog/p/7/abc/ slug='abc'
    <str:x> /blog/str/中文/ str='中文'(不含 /)
    <uuid:u> /blog/uuid/12345678-1234-5678-1234-567812345678/ UUID 对象,不是字符串
    <path:rest> /blog/path/a/b/c.txt/ rest='a/b/c.txt'(含 /)
    • 默认(不写转换器)等价于 str,但匹配到下一个 / 为止;要吞掉斜杠必须显式用 path。
    • int 只匹配正整数,/blog/p/-3/ 直接 404,不会进视图。
  • re_path() 的分组一律是字符串(实测)

    1
    re_path 命名组: body=re num='42'(str)
    • 正则组不会帮你转成 int,要自己 int(num);这也是优先用 path + 转换器的理由。
    • 命名组 (?P<num>\d+) → 视图用关键字参数接;只写括号 (\d+) → 用位置参数接,顺序要和路由一致。
  • 视图函数的签名怎么写

    views.py
    1
    2
    3
    4
    5
    6
    7
    8
    def params(request, pk, slug="default"):
    # /blog/p/7/ 时 slug 用默认值,/blog/p/7/abc/ 时 slug='abc'
    return HttpResponse("pk=%r(%s) slug=%r" % (pk, type(pk).__name__, slug))


    def kwonly(request, *, year=None):
    # 命名组只能走关键字,视图这里也必须用 * 之后的关键字形式
    return HttpResponse("year=%r" % (year,))

    第一个参数永远是 request,后面按路由传;参数名要和命名组一致,不一致会 TypeError。

错误页:404、500、403

  • DEBUG 决定你看到什么(实测)

    场景 DEBUG=True DEBUG=False
    URL 没匹配上 技术版 404 页(列出试过的 pattern) templates/404.html,实测页面里是「自定义 404 页面」
    视图里抛异常 技术版 500 页(含 ZeroDivisionError) templates/500.html
    模板不存在 500 + TemplateDoesNotExist at /blog/missing/ 同上,走 500 模板
    • 老笔记那句「DEBUG 为 True 时永远不会使用 404 页面」要说准:True 时用的是 Django 内置的技术版页面,你的 404.html 不生效。

    • DEBUG=False 时必须配 ALLOWED_HOSTS,否则每个请求都是 500:

      1
      DisallowedHost: Invalid HTTP_HOST header: 'testserver'. You may need to add 'testserver' to ALLOWED_HOSTS.
  • 404 的正确姿势

    views.py
    1
    2
    3
    4
    5
    6
    7
    from django.http import Http404
    from django.shortcuts import get_object_or_404


    def grade(request, pk):
    obj = get_object_or_404(Grade, pk=pk) # 查不到就 raise Http404
    return render(request, "blog/grade.html", {"obj": obj})
    • 实测 get_object_or_404(Category, pk=999999) 的结果是 404,异常原文:

      1
      Http404: No Category matches the given query.
    • Http404 是 Exception 的子类,str(Http404("没有这行")) 就是那句自定义提示(这句只进日志和 DEBUG 页,DEBUG=False 的用户看到的是你的 404 模板)。

  • 400 来自客户端(实测原文)

    • 表单请求声明了非 UTF-8 的字符集,Django 在读 request.POST 时直接拒:

      1
      django.core.exceptions.BadRequest: HTTP requests with the 'application/x-www-form-urlencoded' content type must be UTF-8 encoded.
      • 响应是 400,这就是老笔记「400 错误来自客户端的操作」的具体样子之一(篡改会话 cookie、上传超限 RequestDataTooBig 也都在这里)。
  • 500 的唯一来源是视图里没兜住的异常;503 另有用途

    想让站点临时维护,官方做法是中间件/ALLOWED_HOSTS 之外返回 HttpResponse(status=503),不要靠抛异常。

HttpRequest 对象

  • 属性(实测值,请求 /blog/meta/?x=1&y=2)

    属性 实测 说明
    path /blog/meta/ 不含域名和端口,含脚本前缀
    method "GET" 大写字符串
    encoding None 请求头没声明字符集时就是 None,此时 Django 用 settings.DEFAULT_CHARSET(实测 utf-8)解表单;它可写
    content_type ""(GET 时为空) 形如 application/x-www-form-urlencoded
    scheme / is_secure() http / False 反向代理后要配 SECURE_PROXY_SSL_HEADER
    get_host() testserver 受 ALLOWED_HOSTS 校验
    get_full_path() /blog/meta/?x=1&y=2 带查询串
    build_absolute_uri() http://testserver/blog/meta/?x=1&y=2 拼绝对地址
    GET / POST QueryDict 见下一节
    FILES MultiValueDict 上传文件,见《Django-上传文件》
    COOKIES 普通 dict,键值都是字符串 只读语义,别改它
    session SessionStore(类字典) 要 SessionMiddleware 在 MIDDLEWARE 里才有
    headers HttpHeaders 大小写不敏感,request.headers["Content-Type"] 和 ["CONTENT-TYPE"] 等价
    META 普通 dict WSGI 环境变量,HTTP_* 是原始请求头
  • 两个「以为有其实没有」的属性(实测)

    1
    2
    request.content_length -> AttributeError: 'WSGIRequest' object has no attribute 'content_length'
    request.is_ajax() -> hasattr(request, "is_ajax") 为 False
    • 长度要看 request.META.get("CONTENT_LENGTH")(或 len(request.body))。

    • is_ajax() 在 Django 4.0 就被删了,官方替代是自己看请求头:

      1
      2
      if request.headers.get("X-Requested-With") == "XMLHttpRequest":
      ...
      • 实测带这个头访问时视图能读到 XMLHttpRequest;但这个头是前端自己加的,不是标准,别拿它做安全判断。
  • 请求体:body 与 read()

    1
    2
    body(GET):  len=0 type=bytes
    body(POST): len=7 type=bytes
    • request.body 是原始字节(bytes),重复访问不会报错(内部有缓存);request.read() 也还在,但用了它就再也拿不到 body,一般别碰。
    • JSON 请求要自己解:json.loads(request.body),request.POST 里是空的。

QueryDict:一个键带多个值

  • request.GET、request.POST 都是 QueryDict,和普通字典最大的区别是一个键可以有多个值。

    1
    2
    3
    请求 /blog/get/?a=1&a=2&c=3
    get='2' getlist=['1', '2']
    items: [('a', '2')] | lists: [('a', ['1', '2'])] | urlencode: a=1&a=2
    • get() 只给最后一个值(老笔记这句是对的),要全取用 getlist()。
    • items() 也是「每键一个值」,看全部要用 lists()。
  • 取不存在的键的两种结果(实测):

    1
    2
    request.GET["没有这个键"] -> MultiValueDictKeyError: '没有这个键'
    request.GET.get("没有这个键") -> None
    • 所以永远用 .get(键, 默认值),别让一个空表单把页面打成 500。
  • QueryDict 默认不可写(实测):

    1
    request.GET["a"] = "9" -> AttributeError: This QueryDict instance is immutable
    • 想改就先复制:q = request.GET.copy()(copy() 出来的是可变的 QueryDict)。
  • 复选框这类同名多值,前端写 name="hobby",后端用 getlist:

    views.py
    1
    2
    3
    4
    5
    6
    def login(request):
    if request.method == "GET":
    return render(request, "blog/form.html")
    username = request.POST.get("username")
    hobbies = request.POST.getlist("hobby")
    return HttpResponse("u=%r h=%r" % (username, hobbies))
    1
    带 token POST: 200 | u='sunck' h=['power', 'money']

CSRF:表单必须带 token

  • 模板里 POST 表单必须写 {% csrf_token %}:

    1
    2
    3
    4
    5
    6
    7
    <form action="/blog/post/" method="POST">
    {% csrf_token %}
    账号:<input type="text" name="username" value=""><br>
    爱好:<input type="checkbox" name="hobby" value="power">权利
    <input type="checkbox" name="hobby" value="money">金钱<br>
    <input type="submit" value="提交">
    </form>
  • 不带 token 会怎样(实测,enforce_csrf_checks=True 模拟真实浏览器):

    1
    裸 POST: 403 | 页面含 CSRF: True | Forbidden (CSRF cookie not set.)
    • 老笔记说「需要在 settings.py 中注释掉 csrf」,那是关掉全站防护的写法,别学。正确做法是加 {% csrf_token %}。

    • 确实需要豁免(比如给外部系统做回调接口)时,只给那一个视图加装饰器,实测可用:

      views.py
      1
      2
      3
      4
      5
      6
      from django.views.decorators.csrf import csrf_exempt


      @csrf_exempt
      def hook(request):
      return HttpResponse("csrf_exempt ok")
      1
      csrf_exempt POST: 200 | csrf_exempt ok
  • Ajax 提交时把 token 放进请求头 X-CSRFToken(配合 csrftoken cookie),细节见《Django-Ajax》。

HttpResponse 对象

  • 三个能改、两个改了没用的属性(实测)

    views.py
    1
    2
    3
    4
    5
    6
    7
    def demo(request):
    response = HttpResponse()
    response.content = "换成中文" # 有效
    response.status_code = 201 # 有效
    response.content_type = "application/json" # 无效,别这么写
    response.charset = "gbk" # 无效,别这么写
    return response
    1
    2
    3
    属性赋值: 201 | CT=text/html; charset=utf-8 | body=换成中文
    赋值 response.content_type 之后: 'text/html; charset=utf-8' | 构造参数才有效: 'application/json'
    赋值 response.charset 之后: 'text/html; charset=utf-8'
    • content、status_code 是「写了就生效」的;content_type、charset 只是普通属性,请求头早在构造时按 content_type= 参数定好了。要改类型就写 HttpResponse("x", content_type="application/json")。
    • content 存的是 bytes:HttpResponse("中文").content 是 b'\xe4\xb8\xad\xe6\x96\x87',charset 默认 utf-8,Content-Type 头是 text/html; charset=utf-8。
    • 老笔记把 content_type 说成「指定输出的 MIME 类型」,方向没错,写法错了。
  • 方法(实测)

    1
    2
    3
    HttpResponse 方法: ['write', 'flush', 'getvalue']
    有 write: True | 有 flush: True
    write(): 200 | body=写进去的
    • write(content) 能往响应里追加文本;flush() 存在但对普通响应没有实际意义(它是给文件式响应准备的)。

    • 老笔记里的 dalete_cookie(key) 是拼写错误,正确是 delete_cookie();实测它的实现是把过期时间设成 1970:

      1
      gone(删除) 的 expires: 'Thu, 01 Jan 1970 00:00:00 GMT' | 值: ''
  • views.py
    1
    2
    3
    4
    5
    6
    def cookie_view(request):
    resp = HttpResponse("cookie")
    resp.set_cookie("k1", "v1", max_age=60, httponly=True, samesite="Strict")
    resp.set_signed_cookie("k2", "v2")
    resp.delete_cookie("gone")
    return resp
    1
    2
    3
    response.cookies 键: ['k1', 'k2', 'gone']
    k1 属性: {'max-age': 60, 'httponly': True, 'samesite': 'Strict', 'path': '/'}
    k2(签名 cookie) 值前缀: v2:1xOdRS:AFLStBiMFjxQ5M
    • set_signed_cookie 的值是「原文:时间戳:签名」三段,客户端改了就验不过;读的时候用 request.get_signed_cookie("k2")。

    • 一个反直觉的点(实测):response.headers 里没有 Set-Cookie,serialize_headers() 也不会带上 cookie:

      1
      2
      headers 里有 Set-Cookie 吗: False
      serialize_headers 里的 Set-Cookie 行数: 0
      • cookie 存在 response.cookies,真正的响应头是 WSGI 处理器拼出来的(django/core/handlers/wsgi.py:131 那行 *(("Set-Cookie", c.output(header="")) for c in response.cookies.values()))。
      • 所以写测试时判 cookie 用 response.cookies / client.cookies,不要去 grep 响应头。
  • JsonResponse(实测)

    1
    2
    3
    JsonResponse([1, 2, 3])            -> TypeError: In order to allow non-dict objects to be serialized set the safe parameter to False.
    JsonResponse([{"id": 1}], safe=False) -> 200 | CT=application/json | [{"id": 1}]
    JsonResponse({"t": date(2026, 11, 4)}) -> 200 | {"t": "2026-11-04"}
    • 顶层默认只允许字典(防 JSON 劫持),列表要显式 safe=False。
    • 编码器默认是 DjangoJSONEncoder,日期、Decimal、UUID 都能直接出。
  • 重定向的几种写法(实测)

    1
    2
    3
    return HttpResponseRedirect("/home/")            # 302,手写地址
    return redirect("blog:home") # 302,用名字反解(推荐)
    return redirect("blog:home", permanent=True) # 301
    1
    2
    3
    4
    HttpResponseRedirect: 302 -> /home/
    redirect(名字): 302 -> /blog/
    redirect(permanent=True): 301 -> /blog/
    RedirectView: 302 -> /blog/
    • redirect() 的实测签名:(to, *args, permanent=False, preserve_request=False, **kwargs)。其中 preserve_request 是 4.0 之后才有的参数(把原请求对象交给下一步),老笔记里没有。
    • to 可以是 URL、视图名(记得带命名空间)、模型对象(走 get_absolute_url())。
  • 状态快捷类与流式响应(实测)

    1
    2
    状态类: 400 403 404        # HttpResponseBadRequest / Forbidden / NotFound
    StreamingHttpResponse: 200 | CT=text/plain
    • HttpResponse(status=400) 也能直接用,构造签名实测是 (content=b'', *args, **kwargs),status、content_type、headers 都走 **kwargs。
    • StreamingHttpResponse 给生成器就能分块吐,大文件/慢导出才用得上(普通 HttpResponse 会一次性占内存)。

装饰器与类视图

  • 限定请求方法(实测 405 一定带 Allow 头)

    views.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    from django.views.decorators.http import require_GET, require_POST, require_http_methods


    @require_POST
    def only_post(request):
    return HttpResponse("ok")


    @require_http_methods(["DELETE", "PUT"])
    def only_two(request):
    return HttpResponse("ok")
    1
    2
    3
    4
    GET 打 require_POST: 405 | Allow: POST | body 为空
    POST 打 require_POST: 200 | ok
    POST 打 require_GET: 405
    GET 打 require_http_methods: 405 | Allow: DELETE, PUT
    • 405 的响应体是空的,判断要靠状态码和 Allow 头;日志里会打一行 Method Not Allowed (GET): /blog/only_post/。
  • 登录与权限(实测)

    1
    2
    3
    login_required 匿名: 302 -> /accounts/login/?next=/blog/need_login/
    permission_required 匿名: 403 | <title>403 Forbidden</title>
    settings.LOGIN_URL 默认: /accounts/login/
    • login_required 会把原地址放进 next,登录成功后要记得回跳(redirect(request.GET.get("next")),但要校验域名,防开放重定向)。
    • permission_required("blog.view_category", raise_exception=True):不加 raise_exception=True 时是重定向到登录页,加了才返回 403。
  • 类视图(CBV):as_view() 是唯一入口(实测)

    views.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    from django.views import View
    from django.views.generic import ListView


    class PlainView(View):
    def get(self, request, *args, **kwargs):
    return HttpResponse("PlainView.get")

    def post(self, request, *args, **kwargs):
    return HttpResponse("PlainView.post")


    class CatList(ListView):
    model = Category
    template_name = "blog/list.html"
    1
    2
    3
    CBV GET: 200 | PlainView.get
    CBV POST: 200 | PlainView.post
    ListView: 200 | 分页: False(object_list 为空)
    • 路由里必须写 PlainView.as_view(),直接写类名会 TypeError。
    • ListView 的上下文键是 object_list / paginator / page_obj / is_paginated(分页细节见《Django-分页》)。
    • CBV 上加装饰器要用 method_decorator,直接贴在类上不管用。

状态保持

  • 先说清楚为什么需要它

    • HTTP 是无状态的:每个请求都是独立的一次,服务端不记得上一个请求。
    • 想「在一段时间内跟踪同一个访问者」,只有两个存放点:客户端(cookie) 和 服务端(session)。
    • cookie 里的东西用户看得见、改得动,不要放敏感数据;session 只把一串 session_key 放在 cookie 里,数据留在服务端,是默认推荐做法。
    • 不同访问者的 session 互相看不到(一人一份)。
  • 启用 session 需要两处配置

    settings.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    INSTALLED_APPS = [
    ...,
    "django.contrib.sessions",
    ]

    MIDDLEWARE = [
    ...,
    "django.contrib.sessions.middleware.SessionMiddleware",
    ]
    • 新项目的 startproject 模板里这两处默认就有;少了中间件时 request.session 直接不存在。
  • 默认配置实测值

    1
    2
    3
    4
    5
    6
    7
    8
    SESSION_COOKIE_AGE: 1209600
    SESSION_COOKIE_NAME: sessionid
    SESSION_COOKIE_HTTPONLY: True
    SESSION_COOKIE_SAMESITE: 'Lax'
    SESSION_EXPIRE_AT_BROWSER_CLOSE: False
    SESSION_SAVE_EVERY_REQUEST: False
    SESSION_SERIALIZER: django.contrib.sessions.serializers.JSONSerializer
    SESSION_ENGINE: django.contrib.sessions.backends.db
    • 「默认两个星期后过期」这句老话是准的:1209600 秒 = 14 天。
    • 序列化器是 JSON,不是 pickle(PickleSerializer 能伪造对象,别开)。
  • 用法:类字典 + 几个专门方法

    views.py
    1
    2
    3
    4
    5
    6
    7
    def cart(request):
    request.session["counter"] = request.session.get("counter", 0) + 1
    name = request.session.get("username", default="未登录")
    request.session.setdefault("from", "cart")
    request.session.pop("counter", None)
    request.session.set_expiry(30)
    return render(request, "blog/cart.html", {"name": name})
    • 实测公开方法清单(dir(request.session) 去掉下划线)包含 get、setdefault、pop、keys、clear、flush、cycle_key、set_expiry、get_expiry_age、save、load、modified、session_key 等。

    • clear() 只清数据不删会话,flush() 连数据带 session_key 一起作废(实测):

      1
      2
      clear(): clear 后键: []
      flush(): flush 后 session_key=None
  • 一个必须知道的时序坑:session_key 在视图里先是 None(实测)

    1
    2
    第一次请求:session_key 在赋值前: None | 赋值后: None
    第二次请求:session_key 在赋值前: 'gmqogorauor3bt3i18l9xxctt8d9i84i' | 赋值后: 同一个值
    • 会话是响应结束时由中间件写库并发 cookie 的,所以在同一个视图里刚赋值完去读 session_key 仍是 None。
    • 想拿它做后续动作(比如自己拼 cookie、立刻查库),要在赋值后手动 request.session.save()。
  • 过期时间的几种取值(实测)

    1
    2
    3
    set_expiry(30) 之后:cache: {'counter': 2, '_session_expiry': 30} | get_expiry_age(): 30
    sessionid cookie 属性: {'httponly': True, 'samesite': 'Lax', 'max-age': 30, 'path': '/'}
    不调 set_expiry 时:expiry_age: 1209600
    • set_expiry(value) 的四种取值:整数=秒;timedelta=按对象时长;0=浏览器关掉就失效(cookie 变会话级);None=按 SESSION_COOKIE_AGE 走(不是永不过期,老笔记那句「None 表示永不过期」要更正,永不过期要配 SESSION_COOKIE_AGE = None 并自担风险)。
    • 过期信息是存在会话数据里的(_session_expiry 键),不是数据库列。
  • 五种存储引擎(实测都可用)

    1
    2
    3
    4
    5
    引擎 db             SessionStore 可用: True
    引擎 cache SessionStore 可用: True
    引擎 cached_db SessionStore 可用: True
    引擎 file SessionStore 可用: True
    引擎 signed_cookies SessionStore 可用: True
    配置 数据放哪 特点
    django.contrib.sessions.backends.db 数据库表 django_session 默认,可靠,读写多一次查询
    ...backends.cache 缓存(内存/Redis) 快,但缓存丢了会话就没了
    ...backends.cached_db 先缓存后数据库 兼顾速度与持久
    ...backends.file 磁盘文件 单机够用,多实例不共享
    ...backends.signed_cookies 全在 cookie 里 不查库,但内容只有签名没有加密
    • 实测 signed_cookies 时 sessionid 的值有 97 个字符,开头是 eyJjb3VudGVyIjoxLCJf——base64 解一下就能读出 {"counter":1,...},所以别把敏感数据塞进会话。
    • 用 Redis 存会话的官方路线是把缓存配成 Redis 再用 backends.cache(见《Django-缓存》),老笔记那种 pip install django-redis-sessions + SESSION_ENGINE = 'redis_sessions.session' 是第三方死包,不推荐。
  • 会话与登录的关系(实测)

    1
    2
    3
    login() 返回: True
    登录后 need_login: 200 secret
    django_session 行数: 3 -> 5
    • django.contrib.auth.login() 内部会 cycle_key()(换一个新的会话键,防会话固定攻击),所以库里行数会增长。
    • 退出用 django.contrib.auth.logout(request),它会 flush 当前会话并清 cookie,即使这个用户本来没登录过也会清(这是安全设计,不是 bug)。

新手卡点清单

  • 全部是实测踩过的:

    卡点 症状(实测原文) 正确做法
    应用没建 urls.py 就 include() ModuleNotFoundError: No module named 'blog.urls' 手动建 urls.py 并写 app_name
    反解不写命名空间 NoReverseMatch: Reverse for 'params' not found. 写 blog:params
    以为 urlpatterns 是 RegexURLResolver 列表 导入就 ImportError 记住 URLPattern / URLResolver
    用 request.is_ajax() AttributeError(4.0 起删除) request.headers.get("X-Requested-With")
    用 request.content_length AttributeError: 'WSGIRequest' object has no attribute 'content_length' request.META.get("CONTENT_LENGTH")
    POST 表单忘写 {% csrf_token %} 403 Forbidden (CSRF cookie not set.) 加 token,而不是关中间件
    request.GET["键"] 直接取值 MultiValueDictKeyError request.GET.get("键", 默认值)
    同名多值只拿到最后一个 get='2',看不到 1 getlist("a")
    改 request.GET AttributeError: This QueryDict instance is immutable request.GET.copy() 再改
    用 response.content_type = "..." 改类型 头还是 text/html; charset=utf-8 构造时传 content_type=
    JsonResponse(列表) TypeError: In order to allow non-dict objects... JsonResponse(列表, safe=False)
    在测试里 grep 响应头找 cookie KeyError: 'set-cookie' 用 response.cookies
    视图里刚写 session 就读 session_key 拿到 None,切片直接 TypeError 需要就 request.session.save()
    以为 set_expiry(None) 是永不过期 实际按 SESSION_COOKIE_AGE(两周) 明确写秒数或 timedelta
    DEBUG=False 没配 ALLOWED_HOSTS 每个请求 500,DisallowedHost 配域名白名单
    老笔记的 render_to_response ImportError: cannot import name 'render_to_response' 用 render(request, ...)
    类视图直接写类名进路由 TypeError: as_view() 没调 PlainView.as_view()

参考

本文结束 感谢您的阅读
正在加载今日诗词....