Django 框架 深度学习

Django

Django概述

** Django** 是一个用 Python 编写的免费开源、功能完备、高效安全 的 Web 后端框架 ，专门用来快速开发企业级、高质量、可维护的网站和 Web 应用。

它的核心定位：让开发者用最少的代码，最快完成功能强大的 Web 项目。

Django项目的环境搭建

方式一 命令行创建

pip install Django==4.2 
pip uninstall Django==4.2 

创建Django 项目

Django-admin start project 项目名字

启动项目 python mange.py run server 默认检测 8000

方式二 PyCharm 创建

Django项目静态资源

Django项目常见错误

一、HTTP 状态码错误（浏览器直接可见）

1. 404 Not Found

• 原因：访问的 URL 不存在；路由配置写错；视图函数名不匹配；静态文件路径错误。

• 排查 ：检查 urls.py 路由、视图名称、请求地址拼写。

2. 403 Forbidden（权限拒绝）

• 原因 ：未登录访问需要登录的页面；CSRF 校验失败；用户权限不足；@login_required/@permission_required 限制。

• 排查：登录状态、CSRF token、用户权限、中间件配置。

3. 400 Bad Request（请求错误）

• 原因：POST 参数缺失 / 格式错误；URL 参数类型不匹配；请求头非法。

4. 500 Internal Server Error（服务器崩溃）

• 原因：代码语法错误、空指针异常、数据库连接失败、视图逻辑报错。

• 排查：看控制台日志，定位报错代码行。

---

二、路由 / 视图错误

1. NoReverseMatch

• 最常见 ：reverse() 或模板 {% url %} 解析路由失败。

• 原因 ：路由 name 写错；缺少必填参数；参数类型不匹配。

2. ViewDoesNotExist

• 原因 ：urls.py 引用的视图函数 / 类不存在，或导入错误。

3. Method Not Allowed（405）

• 原因 ：视图只支持 GET，却发送了 POST 请求；未重写对应请求方法（如类视图没写 post()）。

4. TemplateDoesNotExist

• 原因 ：模板文件名写错；DIRS 配置错误；应用未注册 INSTALLED_APPS。

---

三、模型 / 数据库错误（最频繁）

1. OperationalError

• 原因 ：数据库连接失败；未执行 migrate；表不存在；账号密码错误。

2. DoesNotExist

• 原因 ：Model.objects.get() 查询不到匹配数据。

• 解决 ：用 filter().first() 或 try-except 捕获。

3. MultipleObjectsReturned

• 原因 ：get() 查询到多条结果，必须唯一。

4. IntegrityError

• 原因：唯一约束冲突；非空字段为空；外键关联失败；重复数据。

5. RelatedObjectDoesNotExist

• 原因：访问不存在的一对一 / 外键关联对象。

6. FieldError

• 原因：查询字段名写错；模型无此字段；跨表查询语法错误。

7. Migration 相关错误

• Migration name collision：迁移文件重名

• Circular dependency：迁移循环依赖

• Table already exists：表已存在

---

四、模板语法错误

1. TemplateSyntaxError

• 原因 ：标签未闭合（{% for %} 没写 {% endfor %}）；变量语法错误；过滤器写错。

2. VariableDoesNotExist

• 原因：模板使用了视图未传递的变量。

3. Invalid block tag

• 原因：自定义标签未加载；标签名写错。

---

五、表单 / 用户认证错误

1. ValidationError

• 原因：表单验证失败（字段格式、长度、唯一性不满足）。

2. PermissionDenied

• 原因：用户无操作权限（如删除、修改他人数据）。

3. AuthenticationFailed

• 原因：用户名 / 密码错误；账号被禁用。

---

六、配置 / 环境错误

1. ImproperlyConfigured

• 原因 ：settings.py 配置错误（密钥、应用未注册、中间件顺序错）。

2. ModuleNotFoundError / ImportError

• 原因：依赖未安装；导入路径错误；虚拟环境未激活。

3. DisallowedHost

• 原因 ：ALLOWED_HOSTS 未配置当前域名 / IP。

4. Staticfiles.DoesNotExist

• 原因：静态文件配置错误，找不到静态资源。

Django项目的页面转跳

转发

return render（request，“login.html）``

重定向

return redirect("/index")

Django项目整合数据库

Django -----------ORM------------pymysql----- MySQL

ORM(对象关系映射)

ORM（对象关系映射，Object-Relational Mapping）是一种编程技术，用于在面向对象编程语言与关系型数据库之间建立映射关系，使开发者能以操作对象的方式操作数据库，而无需直接编写SQL语句。根据当前（2026年）权威公开资料，ORM的主要优势如下：

‌核心优势‌

•提升开发效率•：通过将数据库表映射为类、行映射为对象、字段映射为属性，开发者可直接使用面向对象语法进行增删改查，避免手写重复SQL代码 。
•增强代码可读性与可维护性•：ORM查询使用语言原生语法（如Python），逻辑更直观，便于团队协作和后期维护 。
•数据库无关性•：多数ORM框架（如Django ORM、SQLAlchemy、Hibernate）支持多种数据库（MySQL、PostgreSQL、SQLite等），切换数据库时无需重写大量SQL 。
•自动防止SQL注入•：ORM通常自动处理参数化查询和输入转义，有效提升应用安全性 。
•简化复杂操作•：支持关联查询（如一对多、多对多）、事务管理、自动建表与数据迁移等功能，降低业务逻辑实现难度 。
•提高代码复用性•：模型定义一次，可在多个模块复用，减少冗余代码 。••

‌适用场景建议‌

•中小型项目或快速开发•：ORM能显著缩短开发周期，推荐优先使用 。
•大型高并发系统•：若对性能要求极高或需频繁编写复杂原生SQL，可考虑结合原生SQL或轻量级ORM（如MyBatis、jOOQ）

ORM整合过程

第一步：检查Django项目中是否有app文件夹

如果没有，那么可以通过命令行创建新的app文件夹

01：python manage.py startapp 文件夹名称

02：在settings.py文件的INSTALLED_APPS中配置新的app文件夹

第二步：在项目的核心settings.py文件中配置数据库基本信息

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.mysql",
        "NAME": "fire01",  # 数据库名称
        "HOST": "127.0.0.1",  # 数据库IP
        "PORT": "3306",  # 数据库端口
        "USER": "root",  # 数据库用户名
        "PASSWORD": "root"   # 数据库密码
    }
}

第三步：在项目中配置pymysql，在于settings.py 同一条件下找到init.py文件

import pymysql
pymysql.install_as_MySQLdb()

第四部 ：配置数据库映射信息（类信息），在models.py中配置

# 管理员类
class Admins(models.Model):
    id = models.AutoField(primary_key=True) 
    username = models.CharField(max_length=30)
    password = models.CharField(max_length=30)
    status = models.IntegerField(default=0)  # 0 超级管理员  1 普通管理员

第五步：将上述映射类信息转换为数据表，一旦模型model发生变化，需要再次执行以下命令

python manage.py makemigrations
​
python manage.py migrate

第六步 设置view.py 文件中的业务逻辑

def login2(request):
    # 接收前台页面的用户名 密码
    username = request.POST.get("username")
    password = request.POST.get("password")
​
    if Admins.objects.filter(username=username,password=password):
        return redirect("/index")
    return render(request, "login.html")

Django版本-银发守护（项目驱动）

项目启动：前期调研、社会话题、银发经济...... 团队组建.....

需求分析：所有的需求，1.0 2.0 3.0

静态页面设计：已完成（AI生成、现成的网页模板下载.......）

数据库设计：

后端功能开发：将页面导入项目环境..........

项目功能开发

老人列表

老人新增

.....

项目技术拓展

01图片上传

思考的问题：

图片的上传方式 file文件属性

图片上传后的保存位置： 当前项目、其他项目、云端

数据库中的图片存储方式： 图片路径

图片上传步骤：

第一步：设置文件框与post提交方式与提交类型

<form id="elderForm" class="form-container" action="/elderadd/" method="post" enctype="multipart/form-data">
    <input type="file" id="name" name="photo" class="form-input"  required>
</form>

02异步交互Ajax

一、AJAX 是什么（一句话讲清）

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

• 它不是新语言，而是一套技术组合 ：JS + 浏览器内置的 XMLHttpRequest（XHR） （或现代的 fetch）+ DOM + 数据格式（现在基本用 JSON，很少用 XML）。

• 核心作用：不刷新整个页面，在后台和服务器交换数据，只更新页面局部。

传统同步 vs AJAX 异步

• 传统：点按钮 / 提交表单 → 整页变白、重载 → 服务器返回完整新 HTML → 体验卡顿、带宽浪费。

• AJAX：JS 悄悄发请求 → 后台处理 → 只返回数据（JSON）→ JS 改 DOM、局部刷新 → 页面不刷新、用户无感知。

---

二、AJAX 的优点（为什么要用）

1. 无刷新、体验顺滑

   只更新需要变的区域，不白屏、不打断用户操作（如搜建议、表单实时校验）。

2. 异步不阻塞

   发请求后，浏览器继续干别的（点按钮、滚动），不用等服务器回来才动。

3. 省带宽、省流量

   只传纯数据（JSON），不传整页 HTML，体积小、速度快、服务器压力小。

4. 前后端分离、好维护

   前端只管展示，后端只管出数据；分工清晰、易迭代。

5. 状态不丢失

   页面不刷新，滚动位置、已填表单内容都还在。

---

三、什么时候用 AJAX（常见场景）

只要满足：不想整页刷新、只想局部更新、要后台拿数据，就用 AJAX。

1. 表单实时验证（高频）

• 注册时：用户名是否已存在、手机号格式、密码强度 → 输完就查，不用点提交才报错。

• 登录时：验证码实时校验。

2. 搜索自动联想（最经典）

• 百度 / 淘宝搜索框：输一个字就出建议列表 → 异步请求后端关键词库。

3. 无刷新分页 / 无限滚动

• 商品列表、朋友圈动态、评论区：拉到底自动加载下一页，不刷新页面。

4. 局部数据更新

• 购物车：点 "加入购物车"→ 数量数字局部变，不刷新。

• 点赞 / 收藏：点一下，图标和数字马上变。

• 仪表盘：股票、订单数、在线人数定时刷新。

5. 单页应用（SPA）

• 整个网站只有一个 HTML 页面，切换菜单只换内容区（如后台管理系统）。

6. 按需加载

• 树形菜单：只点一级，再加载下一级；不一次性全加载。

---

四、什么时候不用 AJAX（简单说）

• 需要整页跳转（如从首页跳到详情页）。

• 页面首次加载（必须先返回完整 HTML）。

• 要SEO 友好（纯 AJAX 内容搜索引擎难抓取，需服务端渲染 SSR）。

---

五、Django 里怎么用（极简示例）

1. 前端（jQuery 版，最常用）

html

<input type="text" id="username" placeholder="用户名">
<div id="tip"></div>
​
<script src="/static/jquery.min.js"></script>
<script>
$('#username').blur(function(){ // 失去焦点时触发
  let uname = $(this).val();
  $.ajax({
    url: '/check-username/',  // Django 路由
    type: 'POST',
    data: {username: uname, csrfmiddlewaretoken: '{{ csrf_token }}'},
    success: function(res){
      if(res.exists){
        $('#tip').text('已存在').css('color','red');
      }else{
        $('#tip').text('可用').css('color','green');
      }
    }
  });
});
</script>

2. Django 视图（返回 JSON）

python运行

# views.py
from django.http import JsonResponse
from .models import User
​
def check_username(request):
    if request.method == 'POST':
        uname = request.POST.get('username')
        exists = User.objects.filter(username=uname).exists()
        return JsonResponse({'exists': exists})

3. 路由

python运行

# urls.py
path('check-username/', views.check_username, name='check-username'),

03MVT设计模式

一、MVT 是什么

MVT 是 Django 专属的分层架构设计模式 ，由 Model、View、Template 三部分组成，是 MVC 模式在 Django 里的变体，核心目的：代码解耦、分工明确、易维护。

---

二、三大组成部分详解

1. Model（模型）

• 职责

  ：负责

  数据层

  ，对接数据库

  1. 定义数据表结构（字段、类型、约束、表关系）

  2. 提供增删改查（ORM）操作，封装数据逻辑

  3. 不参与页面展示、不处理请求逻辑

• 对应文件 ：app 下的 models.py

• 类比：数据库管家，只管存数据、取数据

2. View（视图）

• 职责

  ：负责

  逻辑控制层

  ，整个架构的

  中枢

  1. 接收浏览器发来的请求（GET/POST/AJAX）

  2. 调用 Model 读写数据

  3. 传递数据给模板，或直接返回响应（JSON / 文本）

  4. 处理业务逻辑、权限判断、参数校验

• 对应文件 ：app 下的 views.py

• 类比：总指挥，接收指令、调度数据、分配任务

3. Template（模板）

• 职责

  ：负责

  展示层

  ，专门渲染页面

  1. 编写 HTML 结构，搭配 Django 模板语法

  2. 接收 View 传来的数据，动态渲染页面

  3. 只做页面展示，不写复杂业务逻辑、不操作数据库

• 对应目录 ：项目 / APP 下的 templates 文件夹

• 类比：页面美工，只负责把内容展示给用户

---

三、完整执行流程（请求流转顺序）

1. 用户在浏览器发起请求 → 匹配 urls.py 路由

2. 路由分发请求 → 交给对应 View（视图）

3. View 需要数据 → 调用 Model（模型） 操作数据库

4. Model 完成数据查询 / 修改 → 将结果返回给 View

5. View 把数据封装 → 传递给 Template（模板）

6. Template 渲染完整 HTML → 最终返回给浏览器展示

一句话流程：路由 → View → Model → View → Template → 页面

四、MVT 的优点（结合你之前学的 AJAX）

1. 分层解数据、逻辑、页面完全分离，改页面不用动数据库，改业务不用改 HTML。

2. 复用性强

   一个 Model 可以被多个 View 调用；一套模板可以复用在多个页面。

3. 便于团队协作

   后端写 Model/View，前端写 Template，互不干扰。

4. 适配 AJAX 异步交互

   AJAX 请求到达 View 后，可直接通过

   JsonResponse 返回 JSON 数据，不用走 Template，完美支持前后端异步通信。

04URL路由匹配

一、路由是什么？

一句话：用户访问的网址，对应到哪个视图函数。

就像：门牌号 → 找到对应房间。

---

二、最基础写法（必掌握）

1. 项目主路由 urls.py

from django.contrib import admin
# 必须引入 include
from django.urls import path, include
​
urlpatterns = [
    path('admin/', admin.site.urls),
    
    # 访问 http://127.0.0.1:8000/book/  交给 book 应用处理
    path('book/', include('book.urls')),
]

---

2. 应用路由 app/urls.py

from django.urls import path
from . import views  # 引入当前目录的视图
​
urlpatterns = [
    # 路径      视图函数      路由名称
    path('', views.index, name='index'),  # 首页
    path('add/', views.add_book, name='add_book'),
]

---

三、路由匹配规则（重点）

1. 完全匹配

path('about/', views.about)

只有访问 about/ 才会匹配。

---

2. 带参数匹配（最常用）

（1）字符串参数

path('book/<str:name>/', views.book_detail)

匹配：book/python/、book/django/

（2）数字参数（id）

path('book/<int:id>/', views.book_detail)

匹配：book/1/、book/100/

（3）slug 参数（文章标题）

path('post/<slug:slug>/', views.post_detail)

（4）路径参数

path('path/<path:subpath>/', views.path_view)

---

四、视图怎么接收参数？

# urls.py
path('book/<int:id>/', views.book_detail)
​
# views.py
def book_detail(request, id):  # 必须写 id
    book = Book.objects.get(id=id)
    return render(...)

---

五、路由命名（反向解析）

给路由起名字，模板、视图里可以直接调用，不怕改路径。

path('add/', views.add, name='add_book')

模板里用：

html预览

<a href="{% url 'add_book' %}">添加书籍</a>

视图里用：

from django.urls import reverse
return redirect(reverse('add_book'))

---

六、带参数的反向解析

python

path('book/<int:id>/', views.detail, name='book_detail')

模板：

{% url 'book_detail' id=1 %}

视图：

reverse('book_detail', args=[1])

---

七、路由匹配顺序（重要）

Django 从上往下匹配，匹配到第一个就停止！

urlpatterns = [
    path('book/add/', ...),  # 先写精确
    path('book/<int:id>/', ...),  # 后写参数
]

---

八、最常用总结（背会就够用）

1. path('路径', 视图, name='名称')

2. `` 传数字

3. `` 传字符串

4. 路由从上往下匹配

5. name 用于反向解析

6. 主路由用 include 包含应用路由

05类视图与函数视图

对比项	FBV 函数视图	CBV 类视图
写法	函数 def	类 class，继承 Django 内置视图类
请求区分	手动判断 request.method	自动分发：get() / post() 等方法
代码复用	靠函数调用、装饰器复用	靠继承、重写复用，更优雅
适用场景	简单逻辑、少量接口、快速开发	通用逻辑、增删改查、权限控制、多请求方式
学习难度	简单直观	需了解类、继承、内置父类

06模型层的ORM操作

<01>测试ORM的运行

方式一：构造MVT设计模式

方式二：在python控制台直接测试

python manage.py shell   # 进入 Django 控制台
​
from 应用名.views import 视图名  # 导入
​
响应 = 视图函数(请求对象)   # 直接测试
    

方式三：在终端配置运行代码

import os
if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djangoProject_orm.settings")
    import django
    django.setup()
​
    from app.models import *
    persons = Person.objects.all()
    print(persons)

如果需要在控制台输出sql语句，可以在settings.py文件中做SQL的日志配置

# 控制台显示sql语句
LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'handlers': {
         'console':{
         'level':'DEBUG',
         'class':'logging.StreamHandler',
     },
     },
​
     'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
     }
 }

方式四：在Django中自带的管理系统中测试

第一步：创建管理员账户

python manage.py createsuperuser

第二步：将模型注入到管理终端

from django.contrib import admin
​
# Register your models here.
​
from app.models import *
admin.site.register(Person)

第三步：打开浏览器，输入http://localhost:8000/admin

07页面模板层模板语法

一、变量输出（显示数据）

1. 基本变量

{{ 变量名 }}

示例：

<h1>{{ title }}</h1>
<p>{{ content }}</p>

2. 对象。属性

{{ book.name }}
{{ book.price }}

3. 列表。下标

{{ list.0 }}
{{ list.1 }}

---

二、标签语法（逻辑控制）

1. if 判断（最常用）

{% if 条件 %}
    显示内容
{% elif 条件2 %}
    其他内容
{% else %}
    否则内容
{% endif %}

示例：

{% if age >= 18 %}
    成年人
{% else %}
    未成年人
{% endif %}

2. for 循环（遍历列表）

{% for 变量 in 列表 %}
    {{ 变量 }}
{% endfor %}

示例：

{% for book in book_list %}
    <li>{{ book.title }}</li>
{% endfor %}

3. for 内置变量

{{ forloop.counter }}     从 1 开始计数
{{ forloop.first }}       是否是第一个
{{ forloop.last }}        是否是最后一个

4. 注释

{# 这是注释 #}

5. 静态文件加载

{% load static %}
<img src="{% static 'images/logo.png' %}">

6. URL 反向解析html

{% url '路由名' %}
{% url 'book_detail' id=1 %}

1. 模板继承（超级重要）

父模板 base.html

{% block content %}
{% endblock %}

子模板：

{% extends 'base.html' %}
​
{% block content %}
    这里写子页面内容
{% endblock %}

---

三、过滤器（修改变量显示）

1. 长度

{{ list|length }}
​

2. 日期格式化

{{ create_time|date:"Y-m-d H:i:s" }}

3. 转大

{{ name|upper }}

4. 转小写

{{ name|lower }}

5. 切片

{{ str|slice:"0:5" }}

6. 默认值

{{ age|default:"未知" }}

---

三大部分总结（必须背）

1. 变量 ：{``{ 变量 }} 显示数据

2. 标签 ：{% 标签 %} 做逻辑（if、for、block、url）

3. 过滤器 ：{``{ 变量|过滤器 }} 修改变量显示

---

最简单记忆口诀

双大括号显示值， 百分号做逻辑， 竖线后面是过滤。

08Session与Cookie

一、基础概念

1. Cookie（饼干）

• 定义 ：客户端（浏览器） 存储的小型文本数据，由服务器下发，保存在用户本地。

• 特点

  1. 数据存在浏览器，不安全，可被篡改、查看

  2. 大小有限（一般 4KB），数量也有限制

  3. 跟随请求自动携带：每次访问同域名，浏览器自动带上 Cookie

  4. 可设置过期时间：会话 Cookie（关闭浏览器失效）、持久 Cookie

2. Session（会话）

• 定义 ：服务端 存储用户会话数据，依靠 Cookie 传递唯一标识 sessionid 实现。

• 特点

  1. 数据存在服务器，相对安全

  2. 存储大小无严格限制

  3. 核心依赖：浏览器通过 Cookie 携带 sessionid，服务器根据 ID 找到对应会话数据

  4. 单用户一次访问网站的全过程，称为一次会话

二、工作流程（核心）

1. 用户第一次访问网站，服务器创建 Session ，生成唯一 sessionid

2. 服务器把 sessionid 以 Cookie 形式发给浏览器

3. 浏览器保存该 Cookie，后续所有请求自动带上 sessionid

4. 服务器收到请求，根据 sessionid 查找服务端 Session 数据，识别用户

5. 用户关闭浏览器 / 会话过期，sessionid 失效，会话结束

一句话：Session 存数据，Cookie 存钥匙（sessionid）

三、Cookie 用法（Django）

1. 设置 Cookie（视图中）

from django.http import HttpResponse
​
def set_cookie(request):
    res = HttpResponse("Cookie 设置成功")
    # set_cookie(键, 值, 过期秒数)，不设expires=会话Cookie
    res.set_cookie("username", "zhangsan", max_age=3600) 
    return res

2. 获取 Cookie

def get_cookie(request):
    # 从请求对象取cookie
    username = request.COOKIES.get("username", "游客")
    return HttpResponse(f"当前用户：{username}")

3. 删除 Cookie

def del_cookie(request):
    res = HttpResponse("Cookie 已删除")
    res.delete_cookie("username")
    return res

---

四、Session 用法（Django）

Django 默认开启 Session 中间件，无需额外配置。

1. 写入 Session

def set_session(request):
    # 直接赋值，数据存在服务端
    request.session["username"] = "lisi"
    request.session["age"] = 20
    return HttpResponse("Session 写入成功")

2. 读取 Session

def get_session(request):
    username = request.session.get("username", "未登录")
    age = request.session.get("age", 0)
    return HttpResponse(f"用户：{username}，年龄：{age}")

3. 删除 Session

# 1. 删除单个键
del request.session["username"]
​
# 2. 清空当前用户所有会话（退出登录常用）
request.session.flush()
​
# 3. 清除会话数据，但保留sessionid
request.session.clear()

4. 检查 Session 是否存在

if "username" in request.session:
    print("已登录")

---

五、Cookie 与 Session 核心区别

表格

对比项	Cookie	Session
存储位置	浏览器（客户端）	服务器
安全性	低，可查看、篡改	高，数据不在前端暴露
存储大小	最大约 4KB，限制多	基本无大小限制
依赖关系	独立使用，也可配合 Session	依赖 Cookie 传递 sessionid
有效期	可自定义过期时间	默认浏览器关闭失效，可配置超时
压力	占用客户端资源	占用服务器内存 / 数据库

---

六、常见使用场景

Cookie 适用

• 记住用户名、网站偏好设置、简单标记

• 非敏感、小型数据存储

Session 适用

• 用户登录状态保持（最主流）

• 保存用户隐私、权限、临时业务数据

• 购物车临时数据、验证码校验

---

七、补充要点（面试 / 考点）

1. 禁用 Cookie 还能用 Session 吗？

   不能。Django 默认靠 Cookie 传 sessionid；浏览器禁用 Cookie，会话无法识别。

2. 会话过期配置

   Django 默认会话超时：两周，可在 settings.py 修改

   # 会话超时秒数
   SESSION_COOKIE_AGE = 3600  

3. CSRF 与 Cookie/Session

   Django 登录、AJAX POST 请求，同时依赖 Session + CSRF Cookie 做安全校验。

4. 会话 Cookie vs 持久 Cookie

   • 不设置 max_age：浏览器关闭立即失效（会话 Cookie）

   • 设置 max_age：指定时间后失效，重启浏览器仍存在（持久 Cookie）

---

速记口诀

Cookie 存前端，小数据不安全； Session 存服务，登录全靠它； Session 找 Cookie，拿着钥匙认用户。

09中间件

第一步：创建类、继承中间件，重写相关方法

class MyMiddleware01(MiddlewareMixin):
​
    def process_request(self, request):
        print("中间件01---process_request")
​
    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("中间件01---process_view")
​
    def process_template_response(self,request,response):
        print("中间件01---process_template_response")
​
    def process_exception(self, request, exception):
        print("中间件01---process_exception")
        
    def process_response(self, request, response):
        print("中间件01---process_response")

第二步：在项目中配置中间件

MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
    "django.middleware.clickjacking.XFrameOptionsMiddleware",
    "app.MyMiddleware01.MyMiddleware01"
]

第三步：测试中间件

from django.http import HttpResponse
from django.utils.deprecation import MiddlewareMixin
​
​
class MyMiddleware01(MiddlewareMixin):
    """
        执行时间：在视图函数之前执行
        执行顺序：与settings.py文件中的注册顺序一致
        参数：与视图函数中的参数是同一个对象
        返回值：没有返回值，执行下一步
    """
    def process_request(self, request):
        print("中间件01---process_request")
​
    """
        执行时间：在视图函数之前执行
        执行顺序：与settings.py文件中的注册顺序一致
        参数：
            request:与视图函数中的参数是同一个对象
            callback: 要执行的视图函数本身
            callback_args: 函数中的位置参数
            callback_kwargs：函数中的关键字参数
            
        返回值：没有返回值，执行下一步
    """
    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("中间件01---process_view")
    #
    """
        执行条件：视图函数中的response需要调用render函数
        执行时间：在视图函数之后执行
        执行顺序：与settings.py文件中的注册顺序相反
        参数：与视图函数中的参数是同一个对象
        返回值：必须返回response
    """
    def process_template_response(self,request,response):
        print("中间件01---process_template_response")
        return response
    #
    """
        执行时间：在视图函数之后执行
        执行顺序：与settings.py文件中的注册顺序相反
        参数：
            request:与视图函数中的参数是同一个对象
            exception:异常对象信息
        返回值：没有返回值，执行下一步
    """
    def process_exception(self, request, exception):
        print("中间件01---process_exception")
    #
​
    """
        执行时间：在视图函数之后执行
        执行顺序：与settings.py文件中的注册顺序 相反
        参数：与视图函数中的参数是同一个对象
        返回值：必须返回response
    """
    def process_response(self, request, response):
        print("中间件01---process_response")
        return response

项目中存在的问题：

01.路由太多（函数视图）

02.无法实现前后端分离开发

03.耦合度太高

04.Django框架太重