Django官方文档

django 使用 AJAX

django 项目中也可以使用 ajax 技术

前端

前端和其他 web 框架一样，需要注意的是，django 接收 POST 请求时，需要 csrf_token 进行验证，而在 ajax 中获取 csrf_token 比较麻烦。所以通常会在后端免除 csrf_token 验证。

绑定事件方式

{% extends 'layout.html' %}{% block content %}<div class="container"><h1>任务管理</h1><input type="button" class="btn btn-primary" value="点击" onclick="clickMe();"/></div>{% endblock %}{% block js %}<script type="text/javascript">function clickMe() {$.ajax({url: "/test/ajax/",type: "get",data: {type:'add',n1:123,n2:456},success: function (res) {console.log(res);}})}</script>{% endblock %}

以 jQuery 方式

{% extends 'layout.html' %}{% block content %}<div class="container"><h1>任务管理</h1><input type="button" class="btn btn-primary" value="点击" id="btn1" /></div>{% endblock %}{% block js %}<script type="text/javascript">$(function (){// 页面框架加载完成后代码自动执行bindBtn1Event(); // 绑定事件})function bindBtn1Event(){$("#btn1").click(function (){// 绑定到 btn1 的 click 事件的函数$.ajax({url: "/task/ajax/",type: "POST",data: $("#addForm").serialize(),dataType:'JSON',success: function (res) {console.log(res);// console.log(res.res_add)// console.log(res['res_add'])}})})}</script>{% endblock %}

后端

后端部分只要将响应请求 url 绑定视图函数，则可以在视图函数中进行处理

def task_ajax(request):"""测试ajax"""return HttpResponse('成功')

从请求体中获取数据

对于 request.POST 在使用中有一些限制：

只能用于 POST 请求，对于 PUT、DELETE 等非 POST 请求不能使用只能用于表单数据，即content-type为application/x-www-form-urlencoded类型的请求

对于其他数据，必须从请求体中获取。因为request.body中的数据是字节型，所以需要先解析。

import jsondef data_form_body(request):req_dict = json.loads(request.body)category = req_dict.get('category)

返回 json 数据

可以使用 json 的 dumps 方法将字典转为 json 并返回

import jsondef task_ajax(request):res_dict = {'res':'ok', 'data':{'k1': 'v1', 'k2': 'v2'}}res_dict = json.dumps(res_dict)return HttpResponse(res_dict)

也可以直接使用 JsonResponse 返回数据

from django.http import JsonResponsedef task_ajax(request):res_dict = {'res':'ok', 'data':{'k1': 'v1', 'k2': 'v2'}}return JsonResponse(res_dict)

禁用 csrf 校验检查

前端发送 post 请求时如果不加载 csrf_token，则后端需要禁用 csrf 校验检查

from django.views.decorators.csrf import csrf_exempt@csrf_exemptdef task_ajax(request):return HttpResponse('成功')

或在注册路由时注明

from django.views.decorators.csrf import csrf_exempturlpatterns = [path('goods/', csrf_exempt(views.goods), name='goods'),]

或在settings.py 的中间件中取消 csrf 中间件(不推荐)。

Ajax 结合 ModelForm

Ajax 结合 ModelForm 在前端实际上几乎没有改变，要注意的也就是按钮绑定 Ajax 函数和不用 csrf_token。

在后端，ModelForm 其实接收到的数据也是 form 的字典格式，包含校验、保存等处理方式没有变化，只是在返回值时有了变化。

处理重定位信息

因为 Ajax 是接收处理数据，所以后端返回重定位信息是无法跳转的。如果希望跳转，则需要返回一个 json ，ajax 收到了这个特定的 json 数据后使用 js 进行页面跳转。

处理表单错误信息

另外返回 ModelForm 错误信息时，form.字段.errors获取的是一个字典，可以整理成 json 格式返回给 ajax 处理。

<!-- novalidate 可以禁止浏览器自身的有效性检测 --><form id="addForm" novalidate><div class="clearfix">{% for field in form %}<!-- field.label 是从数据表定义中的 verbose_name 取的 --><div class="col-xs-6"><div class="form-group"><label>{{ field.label }}</label>{{ field }}<!-- 因为不会使用 ModelForm 返回错误信息，所以不再这样写 --><!-- <span style="color: red">{{ field.errors.0 }}</span> --><span style="color: red"></span></div></div>{% endfor %}<div class="col-xs-12"><button type="button" id="btnAdd" class="btn btn-primary">添加</button></div></div></form><script type="text/javascript">$(function () {// 页面框架加载完成后代码自动执行bindBtnAddEvent();})function bindBtnAddEvent() {$("#btnAdd").click(function () {$(".error-msg").empty(); // 清空上一次的错误信息$.ajax({url: "/task/add/",type: "POST",data: $("#addForm").serialize(),dataType: 'JSON',success: function (res) {if(res.status){alert("添加成功！");}else{console.log(res);$.each(res.error,function (name,data){// 循环每一个错误，获取键值// 拼接 id_ 和 name，获取对应文本框的 id// 查找文本框元素的下一个元素(span)，使其文本(text)为错误信息$("#id_" + name).next().text(data[0]);})}}})})}</script>

文件上传

简单的文件上传

前端会将文件以 post 请求发送至后端，后端可以使用 request.FILES 来接收。需要注意的是 form 需要 enctype 属性。

<form method="post" enctype="multipart/form-data">{% csrf_token %}<input type="text" name="filename"><input type="file" name="file"><input type="submit" value="提交"></form>

file_obj = request.FILES.get('file') # 获取上传文件的对象filename = request.POST.get('filename', file_obj.name)# 获取设置的文件名，如果没有则为原文件名。with open(filename, mode='wb') as f:for chunk in file_obj.chunks(): # 将上传文件分块读取f.write(chunk)f.flush()# 文件写入完成，冲刷缓冲区

ajax 上传文件

ajax 上传文件和发送 json 的不同在于，发送的数据是一个 FormData 对象，创建这个对象时可以将表单 form 的 dom 对象传入。

$("#upload").click(function () {var formData = new FormData($('#uploadForm')[0]);// 或使用 FormDate 对象添加文件对象的方式// var formData = new FormData();// formDate.append('file', this.file[0]);//这里的 this 指向上传文件的 input 标签的dom对象// formDate.append('key', value);// 可以添加其他的数据$.ajax({type: 'post',url: "https://****:****/fileUpload", //上传文件的请求路径必须是绝对路劲data: formData,cache: false,processData: false,contentType: false,}).success(function (data) {console.log(data);alert("上传成功"+data);filename=data;}).error(function () {alert("上传失败");});});

后端接收时，注意接收字段是前端定义的 name ,文件从 requests.FILES 里获取

uid = requests.POST.get('uid')# 获取数据file = requests.FILES.get('file')# 获取文件# files = requests.FILES.getlist('files')# 获取多个文件

使用 Form 组件上传文件

使用 Form 时可以定义文件字段 FileField ，定义后就能够上传文件了。

class UpForm(forms.Form):name = forms.CharField(label='姓名')age = forms.IntegerField(label='年龄')img = forms.FileField(label='头像')def upload_form(request):form = UpForm(data=request.POST, files=request.FILES)if form.is_valid():print(form.cleaned_data)# 文件在 form.cleaned_data 的相应字段(img)内img = form.cleaned_data.get('img')file_path = os.path.join('app01', 'static', 'img', img.name)# 拼接文件路径with open(file_path,'wb') as f:# 写入文件for chunk in img.chunks():f.write(chunk)else:return render(request, 'upload.html', {'form': form})

<form method="post" enctype="multipart/form-data" novalidate>...</form>

文件上传至上传目录 media

通常使用的静态资源都在 static 文件夹内，如果想要用户上传文件到一个特定文件夹，例如项目根目录下的 media 文件夹，则需要在 urls.py 中进行设置启用。首先引入一些资源，再在 urls.py 文件的 urlpatterns 字段添加：

from django.views.static import servefrom django.urls import path, re_pathfrom django.conf import settingsre_path(r'^media/(?P<path>.*)$', serve, {'document_root': settings.MEDIA_ROOT}, name='media'),

然后在 settings.py 中进行配置：

import osMEDIA_ROOT = os.path.join(BASE_DIR, 'media')# 项目根目录下的 media 目录MEDIA_URL = '/media/'

此时上传文件保存的路径可以写为

media_file_path = os.path.join('media', image_obj.name)

这样将用户上传的文件放在 media 目录下，也可以通过/media/文件名的 url 来访问，例如 http://127.0.0.1:8000/media/001.png

使用 ModelForm 组件上传文件

ModelForm 组件可以自动上传文件，并存储保存路径到数据库，不用再写相应保存的代码，且能够自动进行重名处理。只是需要设置了上传保存目录。

需注意的是，保存到数据库中的文件路径也是 media 下的相对路径，并且不包含 media ，使用时候注意添加 media。

# models.pyclass City(models.Model):"""城市"""name = models.CharField(verbose_name='名称', max_length=32)count = models.IntegerField(verbose_name='人口')# 本质上数据库存储的是文件路径，也是CharField，可以自动保存数据# upload_to 指的就是上传文件到哪个目录，是 media 目录下的相对路径img = models.FileField(verbose_name='logo', max_length=128, upload_to='city/')

# views.pyclass UpModelForm(forms.ModelForm)class Meta:model = models.Cityfields = '__all__'def upload_modal_form(request):form = UpModelForm(data=request.POST, files=request.FIELS）if form.is_valid():# 保存文件，保存 form 字段信息和文件路径并写入数据库form.save()return HttpResponse('成功')

POST 请求类型之间的转换

POST 和 GET 请求是最常用的两种请求方式。一般简单的请求使用 GET，如果需要附加大量参数、数据，都会选择 POST。之后也有将POST的功能进行具体区分，则出现了 PUT、DELETE、OPTIONS 等请求类型。

常见的四种编码方式

HTTP 协议规定POST 提交的数据必须放在消息主体（entity-body）中，但协议并没有规定数据必须使用什么编码方式。常见的四种编码方式有：

application/x-www-form-urlencoded

最常见的 POST提交数据的方式。浏览器的原生 form表单，如果不设置 enctype属性，那么最终就会以application/x-www-form-urlencoded方式提交数据。

另一种常见的 POST数据提交的方式。我们使用表单上传文件时，必须让 form的 enctyped 等于这个值。

application/json 就是传说中的 json 格式，实际上，现在越来越多的人把它作为请求头，用来告诉服务端消息主体是序列化后的 JSON字符串。由于 JSON规范的流行，除了低版本 IE之外的各大浏览器都原生支持 JSON.stringify，服务端语言也都有处理 JSON的函数。

它是一种使用 HTTP作为传输协议，XML 作为编码方式的远程调用规范。

python中读取各类型请求中的数据

转换分为读取和发送，实际上发送的 response 包类型基本都能被浏览器正常识别（根据请求头中的 content-type）。经常使用的有：text/javascript、text/html、application/json 和一些例如 image/png 之类的媒体类响应报文了。

这里使用的环境就是在 django 中。

需注意的是，如果后端返回的响应使用 json 格式，则需要使用json.dumps()将其序列化。

application/x-www-form-urlencoded

这种 form 格式虽然发送的是POST请求，但实际上是将数据体作为类似于GET请求的方式发送的，而不是对象或序列化字符。

url: '/'body: "id=1&name=zhangsan&age=23"

只是前端发送工具的不同会经过相应处理，例如 jquery 可以直接将 json 对象处理后发送，fetch 不进行处理。

django 可以直接使用request.POST.get()方法获取，获取的 POST 数据以字典形式保存，但是字典内部不可以进行嵌套字典。

如果前端发送的是嵌套的对象，django 会将嵌套的对象进行转换，例如：

// 前端发送的数据{status:true,person:{name:'张三',age:18,sex:'male'}}

# django 会将数据解析成这样，类型为字典{'status':'true','person[name]':'张三','person[age]':'18','person[sex]':'male'}

如果前端进行了序列化，则后端可以反序列化获得相应的数据。方式同 json 数据的序列化与反序列化。

multipart/form-data

前端需要注意的是，multipart/form-data 类型前端是要发送一个FormData对象的，直接发送字符串文本、json对象等都无法正常处理。可以将数据对象(包括字符串或json对象)添加到FormData对象中发送。使用jquery发送时，需要设置content-type=false，这样会自动添加请求头为content-type:multipart/form-data; boundary=----WebKitFormBoundaryyr7L6TwhhOAIoEyn。同时需要设置processData=false，不处理转换数据。

这种格式可以直接使用request.POST.get()方法获取各参数的值，类型是字符串类型。

因为 request.POST 是一个QueryDict对象，不能直接反序列化，所以其第一级属性必须直接获取，例如get()方法。此方法获取到的都是字符串，哪怕字符串内容是字典类型(前端发送的数据对象)。

如果浏览器将一个数据对象(类似于json的对象)作为FormData对象的一个属性值这种方式传送过来，获取的则是字符串类型的：[object Object]。这时需要前端将其(数据对象)序列化，例如使用 js 里的JSON.stringify()方法。后端收到这个值类型是字符串，内容是字典数据。

后端接收到后，获取的值是序列化后的字符串，可以使用json.loads()来将其转为字典格式。

上传文件也需要通过这种格式，可以使用requests.FILES.get('file')来获取。

application/json

前端发送 json 时，注意要使用JSON.stringify()将发送的 json 对象序列化，后端才能正常获取。

将请求体使用json.loads()反序列化得到字典类型。

if request.method == 'POST' and request.content_type == 'application/json':dic = json.loads(request.body)param1 = dic.get('param1')# 如果不知道字典中是否有 param1 参数，可以使用字典的 get 方法，否则会报错param2 = dic.get('param2')

多 app 开发

django 多人协作开发时，每人开发不同的 app 也可能会遇到一些问题：对于相同名称的模板或静态资源的使用问题。因为 django 搜索静态资源和模板是安装 app 注册的顺序，在各 app 目录下查找模板或静态资源文件。如果有相同名称的模板或静态资源文件，后注册的 app 就会使用先注册 app 的同名文件了。

所以对于模板文件来说，在各自 app 下的 templates 文件夹下建立 app 名称的文件夹，再建立模板文件，使得各模板文件引用时会加入各自 app 的名称，这样就不会出现引用路径相同的问题了。

对于静态资源文件，因为涉及公共静态资源，所以需要注册静态资源路径。

# settings.pySTATIC_URL = '/static/'STATICFILES_DIRS = [os.path.join(BASE_DIR, "static"),# 主静态文件目录os.path.join(BASE_DIR, "main", "static"),# main app 静态文件目录os.path.join(BASE_DIR, "login", "static"),# login app 静态文件目录]

然后可以在每个APP下的static下建立以APP名相同的文件夹，比如在 login/static/login/ 放入样式JS CSS等

调用时使用 static 结构，加上 app 名称

{% static 'main/img/firefox-logo-small.jpg' %}{% static 'login/img/name.png' %}

另外对于静态文件的打包整合可以参考这篇文章：

解决django多个app下的静态文件无法访问问题

使用 iframe

django 使用 iframe 时，可能浏览器会出现错误，根据提示信息发现是因为X-Frame-Options=deny导致的。

Refused to display xxx in a frame because it set 'X-Frame-Options' to 'deny'.

官方文档中关于点击劫持保护

点击劫持保护

The X-Frame-Options HTTP 响应头是用来给浏览器 指示允许一个页面 可否在<frame>,<iframe>,<embed>或者<object>中展现的标记。站点可以通过确保网站没有被嵌入到别人的站点里面，从而避免点击劫持（clickjacking）攻击。它有三个值：

DENY ：表示该页面不允许在 frame 中展示，即便是在相同域名的页面中嵌套也不允许SAMEORIGIN ：表示该页面可以在相同域名页面的 frame 中展示ALLOW-FROM uri ：表示该页面可以在指定来源的 frame 中展示

根据上述 X-Frame-Options的三个值描述，只要修改django的X-Frame-Options为SAMEORIGIN ，那么相同域名页面就可以使用frame中展示。

启用 X-Frame

在 settings.py 中的中间件中，启用了django.middleware.clickjacking.XFrameOptionsMiddleware中间件即开启了 X-Frame，django 是默认开启的。

MIDDLEWARE = [...'django.middleware.clickjacking.XFrameOptionsMiddleware',...]

允许同域名使用 iframe

默认情况下，中间件将为每个出站的HttpResponse将X-Frame-Options头设置为DENY。如果希望设置为其他值，可以在 settings.py 中的X_FRAME_OPTIONS设置：

X_FRAME_OPTIONS = 'SAMEORIGIN'

指定视图不使用 X-Frame

如果在使用此中间件的情况下，希望个别视图不使用 X-Frame ,则可以使用装饰器xframe_options_exempt

from django.http import HttpResponsefrom django.views.decorators.clickjacking import xframe_options_exempt@xframe_options_exemptdef ok_to_load_in_a_frame(request):return HttpResponse("此页面可以使用 iframe 加载")

注意：如果要提交表单或访问框架或 iframe 中的会话 cookie，则可能需要修改CSRF_COOKIE_SAMESITE或SESSION_COOKIE_SAMESITE设置。

指定视图使用 X-Frame

在指定视图中使用 X-Frame，也可以使用装饰器

from django.http import HttpResponsefrom django.views.decorators.clickjacking import xframe_options_denyfrom django.views.decorators.clickjacking import xframe_options_sameorigin@xframe_options_denydef view_one(request):return HttpResponse("不能在 iframe 中使用")@xframe_options_sameorigindef view_two(request):return HttpResponse("可以在同域的 iframe 中使用")

验证码

为了防止爬虫程序或其他非人为操作，会使用验证码进行检查，一般常用的验证码方式有：

图片验证码滑动验证码短信验证码邮箱验证码

pillow 库

pillow 库是 python 的一个比较简单方便的图形工具库

pip install pillow

需注意的是，使用 pillow 时，是引入 PIL 库

pillow 有三个主要的类，分别是 Image、ImageDraw 和 ImageFont 类。

画布 Image 类

Image 类可以创建画布，所有的绘制图形都会在画布上进行。创建画布时需指定画布大小、颜色等信息。

画笔 ImageDraw 类

ImageDraw 类用来在画布上进行绘制图案，使用时需指定画笔的颜色、绘制方式(具体的图形或绘制路径)、绘画起始坐标、结束坐标等信息。

字体 ImageFont 类

ImageFont 类可以将文本绘制为图像，使用时需要指定字体、大小、文本内容等信息

绘制流程

绘制流程一般为创建画布、绘制文本到画布上、绘制干扰图像到画布上。

from PIL import Image, ImageDraw, ImageFontdef new_code_img(request):# 创建画布bg = (220, 220, 180)# 画布背景色，RGBimg = Image.new('RGB', (120, 30), bg)# 创建画布，使用RGB模式，画布大小为120*30，指定背景色# 在画布上创建画笔对象draw = ImageDraw.Draw(img, 'RGB')# 指定画布，创建画笔对象，使用RGB模式# 随机生成4位字符chars = ''while len(chars) < 4:flag = random.randint(0, 2)char = chr(random.randrange(48, 57) if flag == 0 else random.randrange(65, 90) if flag == 1 else random.randrange(97, 122))if len(chars) == 0 or chars.count(char) == 0:chars += char# 保存验证字符到 sessionrequest.session['code'] = chars# 创建字体font = ImageFont.truetype(font='static/font/Fangz.ttf',size=25)# 绘制内容for char in chars:# 指定字体颜色font_color = (random.randrange(255), random.randrange(255), random.randrange(255))# 字符坐标xy = (15 + chars.index(char) * 25, random.randint(0, 5))# 绘制字符draw.text(xy, char,font=font,fill=font_color)# 画干扰点for i in range(50):# 干扰点坐标xy = (random.randrange(120), random.randrange(30))# 干扰点颜色p_color = (random.randrange(255), random.randrange(255), random.randrange(255))# 绘制干扰点draw.point(xy, p_color)# 删除画笔和字体，释放资源del drawdel font# 生成图片对象，返回响应import io# 创建缓冲对象buf = io.BytesIO()# 保存图片到缓冲区img.save(buf, 'png')# 从缓冲区获取图片，添加到响应对象中，并返回return HttpResponse(content=buf.getvalue(), content_type='image/png')

前端使用验证码

在前端可以使用 img 标签来获取验证码图片，并添加点击重新获取事件

<img src='/new_code_img/' onclick='this.src="/new/code_img/?t="+new Date()*1'>

添加参数是为了确保每次请求时路径不一样，获取的都是新的验证码图片。

分页器 Paginator

django 提供了一个很方便的数据分页工具: 分页器 Paginator，用于数据模型的分页。使用时(通常在视图处理函数中)将查询到的数据模型传入即可。使用分页器可以十分方便的获取当前页号、上页下页页号、是否有上下页等信息。

from django.core.paginator import Paginatordef order_list(request):# 获取查询关键字kw = request.GET.get('kw', '')# 获取展示页码page = request.GET.get('p', 1)# 获取查询数据orders = Order.objects.filter(Q(title__icontains=kw)).all()# 创建分页器，参数1是数据模型对象，参数2是每页显示记录数量paginator = Paginator(orders, 5)# 获取分页后的数据，即第几页内的数据pager = paginator.page(page)return render(request, 'list.html', locals())

前端使用 pager.object_list 获取数据，还可以使用 paginator.page_range 获取全部页码，还有一些其他分页信息也能方便的获得。

<html lang="en"><head><meta charset="UTF-8"><title>商品列表</title><style>.page {text-decoration: none;cursor: pointer;padding: 5px;margin: 5px;}.active {background-color: lightblue;}</style></head><body><form method="GET"><input type="text" name='kw' placeholder="商品名称"><button>搜索</button></form><h3>订单查询结果</h3><table border="1" cellspacing="0" cellpadding="2" width="100%"><thead><th>ID </th><th>名称</th><th>单价</th><th>支付状态</th></thead><tbody>{% for order in pager.object_list %}<tr><td>{{ order.id }}</td><td>{{ order.title }}</td><td>{{ order.price }}</td><td>{{ order.pay_status }}</td></tr>{% empty %}<tr><td colspan="">没有查到数据</td></tr>{% endfor %}</tbody></table><p style="text-align: center;"><a {% if pager.has_previous %} href="?p={{ pager.previous_page_number }}&kw={{ kw }}" {% endif %}>&lt;</a>{% for p in paginator.page_range %}{% if p == pager.number %}<a class="page active">{{ p }}</a>{% else %}<a class="page" href="?p={{ p }}&kw={{ kw }}">{{ p }}</a>{% endif %}{% endfor %}<a {% if pager.has_next %} href="?p={{ pager.next_page_number }}&kw={{ kw }}" {% endif %}>&gt;</a></p></body></html>

类视图(CBV)

django 提供了很多视图处理类，来代替视图处理函数(类似于 tornado)。

ViewTemplateViewRedirectViewListViewEditViewFormViewDetailViewDeleteView

一个简单的 View 例子：

from django.views import Viewclass GoodsView(View):# 处理 get 请求def get(self, request):pass# 处理 post 请求def post(self, request):pass

需注意的是，注册路由时注册路由处理类并使用其 as_view() 方法

urlpatterns = [path('goods/', views.GoodsView.as_view(), name='goods')]

具体的使用方法可以参考官方文档

官方文档-内置的基于类的视图

django 的中间件

中间件基于 AOP(面向切面编程)的设计思想，目的是扩展业务，即在不修改原业务的基础上，添加新的功能，有些类似于装饰器。

django 收到一个请求后，会经过一系列的中间件后达到视图函数，经过视图函数处理后，再经过这些中间件后将数据返回给用户浏览器。

中间件处理请求的方法是 process_request，处理响应的方法是 process_response。处理顺序为：接收到请求交给 process_request ，然后交给 url 分发器，之后是 process_view，然后交给视图处理函数，接下来是 process_template_response（不常用），然后是处理数据模型、通过视图渲染模板，再下来是 process_response ，最后将响应发回给浏览器。如果从请求到响应的过程中出现错误，则交给 process_exception 处理，然后返回错误信息到浏览器。

如果请求在通过中间件时， process_request 没有返回值(或返回值为 None)，则会继续交给下一步处理；如果有返回值(返回值是 HttpResponse、render、redirect)，则会禁止请求往下进行，而将返回值交给本类的 process_response 方法返回请求，直接返回给客户端，所以可以将一些放在视图函数之前或之后的行为写在中间件中。

中间件的处理顺序按照在 settings.py 中注册的顺序，请求是顺序处理，响应是逆序处理。

使用中间件

django 使用的中间件可以在 settings.py 中的 MIDDLEWARE 字段定义。此字段是一个字符串列表，每一个字符串就是引用的中间件类所在。

自定义中间件

所有自定义的中间件(类)需继承django.utils.deprecation.MiddlewareMixin类。并且要在 settings.py 中添加注册

from django.utils.deprecation import MiddlewareMixinfrom django.shortcuts import redirectclass AuthMiddleware(MiddlewareMixin):"""访问验证中间件"""def process_request(self, request):# 如果请求访问 login 页面则不进行检测if request.path_info == '/login/':# request.path_info 能获取请求URLreturn# 1. 读取当前访问用户的 session 信息，如果能读到，说明已经登录过username = request.sesssion.get('username')if username:return# 2. 如果没有登录过，else:return redirect('/login/')def process_view(self, request):passdef process_template_response(self, request, response):passdef process_response(self, request, response):return response

信号机制

django 提供了信号调度机制，用于监听框架中执行某些操作，实现业务与模型或视图之间解耦。django 中某些动作发生的时候，系统会根据信号定义的函数执行相应的操作。

发送信号有点像是调用函数并传参，只是在发送信号时并不知道需要调用什么函数，所以设立了信号机制。只在有需要时才创建接收信号的函数或方法。

常用的内置信号

django 内置了一些信号：

模型和迁移 django.db.models.signals请求响应和配置文件 django.core.signals模板渲染 django.test.signals数据库 django.db.backends.signals

信号的使用

一般信号写在应用 app 的 __init__.py 文件中。信号函数的参数定义是固定的，例如 sender 表示信息发送对象。django 默认将信号处理程序存储为弱引用，这意味着如果处理程序是一个本地函数，可能会被垃圾回收，所以需要添加weak=False。

from dango.db.models.signals import post_savedef post_save_func(sender, **kwargs):# 输出相关信息print('保存信息：', sender, kwargs)# 连接信号和处理函数post_save.connect(post_save_func, weak=False)

也可以使用装饰器的方式

from django.db.models.signals import post_savefrom django.dispatch import receiver@receiver(post_save, weak=False)def post_save_func(sender, **kwargs):# 输出相关信息print('保存信息：', sender, kwargs)

信息的传递

django 信号处理函数主要参数有两个，sender 是信号发送者，kwargs 是个字典，存储了传递的基本信息。例如 instance 为引起信号的实例对象，signal 为传递的信号对象等。

自定义信号

除了 django 预设的信号外，我们也可以自定义一些信号

定义信号

定义信号就是

from django import dispatch# providing_args 发送信息的参数列表action = dispatch.Signal(providing_args=['name', 'age'])

注册信号

注册信号就是将信号发给接收函数

@receiver(action)def post_action(sender, **kwargs):print(sender, kwargs)

发送信号

在行为发生时(函数、方法执行中)发送信号。发送的数据除了 sender 外，在定义信号时就定义好了。

action.send(sender='sender', name='Joe', age=18)

日志 Logging

django 的日志由版本号(version)、格式化(formatters)、处理器(handlers)、记录器(loggers)、过滤器(filters)五部分组成。django 的日志记录器默认存在"django.server"和"django.request"两个。

配置日志需要在 settings.py 中声明 LOGGING，它是一个字典。

LOGGING = {'version': 1,# 版本号'disable_existing_logger': False,# 是否禁用已经存在的记录器'formatters': {# 声明 格式化输出'simple': {# 声明格式化的名称，后面在记录器中会使用'format': "%(asctime)s %(module)s.%(funcName)s: %(message)s",# 输出格式'datefmt': '%Y-%m-%d %H:%M:%S'# 时间格式}},'handlers': {# 声明处理器，如文件输出、控制台输出、发送邮件等'inf': {'class': 'logging.handlers.TimedRotatingFileHandler',# 处理器类'filename': f'{BASE_DIR}/out.log',# 输出文件名'when': 'WO',# 每周一切割日志'backupCount': 5,# 备份数量'formatter': 'simple',# 使用的格式'level': 'DEBUG' if DEBUG else 'INFO',# 处理级别},'err': {'class': 'logging.handlers.TimedRotatingFileHandler',# 处理器类'filename': f'{BASE_DIR}/err.log',# 输出文件名'when': 'D',# 每天切割日志'backupCount': 5,# 备份数量'formatter': 'verbose',# 使用的格式'level': 'WARNING',},'out': {'class': 'logging.StreamHandler',# 处理器类'formatter': 'simple',# 使用的格式'level': 'INFO',},'file': {'class': 'logging.FileHandler',# 处理器类'formatter': 'simple',# 使用的格式'level': 'WARNING','filename': f'{BASE_DIR}/warn.log','when': 'D',# 每天切割日志'backupCount': 7,# 备份数量}},'loggers': {# 日志记录器'inf': {'handlers': ['inf'],# 使用的处理器，一个记录器能使用多个处理器'level': 'DEBUG',# 记录级别'propagate': True,# 是否传播},'err': {'handlers': ['err'],'level': 'DEBUG','propagate': True,},'django': {'handlers': ['out', 'file'],# 使用的处理器，一个记录器能使用多个处理器'level': 'INFO',# 记录级别'propagate': True,# 是否传播}}}

配置好后可以使用，一般会在中间件里，例如对请求进行日志记录

import loggingclass LoggingMiddleware(MiddlewareMixin):def process_request(self, request):ip = request.META.get('REMOTE_ADDR')path = request.get_raw_uri()msg = "%s 访问 %s" %(ip, path)# 获取日志记录器 django,并记录 INFO 级消息logging.getLogger('django').info(msg)

缓存

django 有多种缓存方案，可以将渲染好的页面、session 等数据存放在缓存中等待调用。缓存也有很多选择，本地、文件服务器、redis 服务器、数据库服务器等。详细的可以查看官方文档。

官方文档-缓存框架

配置缓存

自定义缓存需要在 settings.py 中进行配置，例如

文件缓存：

CACHES = {'default': {# 缓存方案名称'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',# 缓存方案(使用哪种缓存技术)'LOCATION': 'c:/foo/bar',# 数据存储地点名称'TIMEOUT': 300,# 超时时间,单位是秒'OPTIONS': {# 其他的一些选项'MAX_ENTRIES': 300,# 最大的实体数},}}

内存缓存：

CACHES = {'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache','LOCATION': 'unique-snowflake',}}

原生缓存

原生缓存用来保存一些临时性的数据，有点像 session，但是是不依赖、不区分客户端的。timeout 时间单位是秒。

from django.core.cache import cachecache.add(key, value, timeout=DEFAULT_TIMEOUT, version=None)# 添加缓存，如果 key 已存在则放弃cache.set(key, value, timeout=DEFAULT_TIMEOUT, version=None)# 设置缓存 key、value、timeoutcache.set_many(dict, timeout)# 传入字典，一次设置多个缓存cache.get(key, default=None, version=None)# 获取缓存 key 的 valuecache.get_many(keys, version=None)# keys 是列表，返回字典，返回多个缓存cache.delete(key, version=None)# 显性删除 key 和其 valuecache.clear()# 清空所有缓存

更多详细的使用方式可以查看官方文档

官方文档-缓存框架-底层缓存API

缓存方案

cache 缓存默认使用default方案，如果希望使用其他方案名称，或需要操作其他方案名称中的缓存数据可以这样指定缓存方案：

from django.core.cache import cachescache = caches['other_cache']# 指定缓存方案

然后就可以正常操作 cache 了。

缓存视图

使用缓存保存渲染好的视图结果，可以使用装饰器 @cache_page ，它将自动缓存视图的响应。

from django.views.decorators.cache import cache_page@cache_page(timeout=60,cache='default',key_prefix=None)# cache为settings.py中设置的缓存方案def index(request):pass

使用 redis 缓存

redis 的特性决定了它是一个高速缓存的分布式数据库，所以大多数的框架缓存都会使用 redis。django 使用 redis 可以使用其插件django-redis，然后在 settings.py 的 CACHES 中进行设置

pip install django-redis

CACHES = {'redis': {# 缓存方案名称'BACKEND': 'django_redis.cache.RedisCache',# 缓存方案'LOCATION': 'redis://127.0.0.1:6379/1',# redis 的主机地址、端口和数据库编号'OPTIONS': {# 其他的一些选项'CLIENT_CLASS': 'django_redis.client.DefaultClient',# 连接客户端'PASSWORD': 'mysecret',# 口令'SOCKET_CONNECT_TIMEOUT': 5,# 连接超时时间，单位秒'SOCKET_TIMEOUT': 5,# 读写超时时间，单位秒'CONNECTION_POOL_KWARGS': {'max_connections': 10,}# 连接池参数},}}

django-redis 的连接池

当配置好缓存信息后，可以在代码中使用连接池

from django.core.cache import get_cachefrom django_redis import get_redis_connectionr = get_redis_connection('redis')connection_pool = r.connection_pool

自学Python第二十二天- Django框架(三) AJAX 文件上传 POST 请求类型之间的转换 多APP开发 iframe 验证码 分页器 类视图 中间件 信号 日志 缓存 celery异步