自学Python第二十二天- Django框架(三) AJAX、文件上传、POST 请求类型之间的转换、多APP开发、iframe、验证码、分页器、类视图、中间件、信号、日志、缓存、celery异步
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_exempt
def 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 serve
from django.urls import path, re_path
from 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方式提交数据。
- multipart/form-data
另一种常见的 POST数据提交的方式。我们使用表单上传文件时，必须让 form的 enctyped 等于这个值。
- application/json
application/json 就是传说中的 json 格式，实际上，现在越来越多的人把它作为请求头，用来告诉服务端消息主体是序列化后的 JSON字符串。由于 JSON规范的流行，除了低版本 IE之外的各大浏览器都原生支持 JSON.stringify，服务端语言也都有处理 JSON的函数。
- text/xml
它是一种使用 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: 'www.test.com/'
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 HttpResponse
from django.views.decorators.clickjacking import xframe_options_exempt@xframe_options_exempt
def 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 HttpResponse
from django.views.decorators.clickjacking import xframe_options_deny
from django.views.decorators.clickjacking import xframe_options_sameorigin@xframe_options_deny
def view_one(request):return HttpResponse("不能在 iframe 中使用")@xframe_options_sameorigin
def 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 %}><</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 %}>></a></p></body>
</html>
类视图(CBV)
django 提供了很多视图处理类，来代替视图处理函数(类似于 tornado)。
- View
- TemplateView
- RedirectView
- ListView
- EditView
- FormView
- DetailView
- DeleteView
一个简单的 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 MiddlewareMixin
from 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
| 信号 | 说明 |
|---|---|
| pre_init | model 对象执行其构造方法前，自动触发 |
| post_init | model 对象执行其构造方法后，自动触发 |
| pre_save | model 对象保存前，自动触发 |
| post_save | model 对象保存后，自动触发 |
| pre_delete | model 对象删除前，自动触发 |
| post_delete | model 对象删除后，自动触发 |
| m2m_changed | model 对象使用 ManyToMany 字段操作数据库的第三张表(add/remove) |
| class_prepared | 程序启动时，检测到已注册的model类，对于每一个类，自动触发 |
| pre_migrate | 执行migrate命令前，自动触发 |
| post_migrate | 执行migrate命令后，自动触发 |
- 请求响应和配置文件 django.core.signals
| 信号 | 说明 |
|---|---|
| request_started | 请求来到前，自动触发 |
| request_finished | 请求结束后，自动触发 |
| got_request_exception | 请求异常时，自动触发 |
| setting_changed | 配置文件改变时，自动触发 |
- 模板渲染 django.test.signals
| 信号 | 说明 |
|---|---|
| template_rendered | 模板执行渲染时，自动触发 |
- 数据库 django.db.backends.signals
| 信号 | 说明 |
|---|---|
| connection_created | 创建数据库连接时，自动触发 |
信号的使用
一般信号写在应用 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_save
from 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、timeout
cache.set_many(dict, timeout) # 传入字典，一次设置多个缓存
cache.get(key, default=None, version=None) # 获取缓存 key 的 value
cache.get_many(keys, version=None) # keys 是列表，返回字典，返回多个缓存
cache.delete(key, version=None) # 显性删除 key 和其 value
cache.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_cache
from django_redis import get_redis_connectionr = get_redis_connection('redis')
connection_pool = r.connection_pool
自学Python第二十二天- Django框架(三) AJAX、文件上传、POST 请求类型之间的转换、多APP开发、iframe、验证码、分页器、类视图、中间件、信号、日志、缓存、celery异步相关推荐
- 自学Python第二十二天- Django框架(一)创建项目、APP、快速上手、请求和响应流程、模板、数据库操作
Django 框架是一个基于 python 的重量级的 web 开发框架,现今很多大公司大项目都是使用 Django 框架.采用了 MVC(model view controller) 的框架模式,p ...
- 关于jQuery在Asp.Net Mvc 框架下Ajax文件上传的实现
1. 实现传统的网络文件上传解决方案 首先,我先实现一个传统的网络文件上传方案,建立一个web页面,我还需要一个<form>和两个<input>元素就能解决问题,如在Index ...
- django中的Ajax文件上传
主要介绍两个 1.ajax文件上传 2.写路由器 3.创建对应的函数 4.file_put.html代码 <!DOCTYPE html> <html lang="en&qu ...
- iframe ajax上传,ajax--iframe模拟ajax文件上传效果
js无权读取本地的文件,so不能上传文件但是 有这几种方法 1 iframe伪装 jquery-uploaded-file 2 swf插件 (这个不讲,是一个单独的软件 3 html5 iframe模 ...
- 原生态的ajax如何上传文件,原生ajax和iframe框架实现图片文件上传的两种方式
大家应该可以举出几种常用的异步文件上传功能的实现方式,使用频率较多的有原生ajax和iframe框架,实现图片文件上传,下面就为大家分享图片文件上传的两种方式:原生ajax和iframe框架,供大家参 ...
- ORM中的事务和锁、Ajax异步请求和局部刷新、Ajax文件上传、日期时间类型的Json、多表查询图书系统
一.ORM中的事务和锁 事务 事务要确保原子性 """ 事务ACID原子性:不可分隔的最小单位一致性:跟原子性是相辅相成隔离性:事务之间相互不干扰持久性:事务一旦确认永久 ...
- ajax文件上传data,ajax文件上传-FormData()
HTML: JS: $("input[type='button']").on('click', upfile); /** * [upfile 文件上传] * @return {[O ...
- 使用ajax提交form表单，包括ajax文件上传 转http://www.cnblogs.com/zhuxiaojie/p/4783939.html...
使用ajax提交form表单,包括ajax文件上传 前言 使用ajax请求数据,很多人都会,比如说: $.post(path,{data:data},function(data){... },&quo ...
- SSM框架使用Layui文件上传插件实现多文件上传（多文件列表）
SSM框架使用Layui文件上传插件实现多文件上传(多文件列表) pom.xml文件的配置 想要实现SSM框架实现多文件上传,必要的jar包必须要在pom.xml文件中引入.如下: <!--co ...
最新文章
- android x86 按键精灵,界面版按键精灵的使用【包含内置浏览器、打开程序的方法】...
- 基于Linux（LAMP）平台搭建MYsql数据库(二)
- 在Centos7安装mysql
- 中国毛纺织行业竞争分析与发展前景展望报告2022-2028年
- 多种方法巧妙优化数据库
- 【2016年第5期】位置大数据在车辆保险风险管理中的应用
- 我的小白同事接触白鹭引擎4天，成功做了一款足球小游戏
- VMware vSphere Hypervisor 6 (ESXi) 免费许可证使用限制
- LeetCode 分割整数数组，分割为两部分的和相等
- PostgreSQL下载与安装
- kubeadm工作原理-kubeadm init原理分析-kubeadm join原理分析
- python是动态语言图片_利用python图片生成，需10几行代码，生成的动态表情包（小黄鸭）...
- React之Ref如何去使用？
- 安全性剖析：对比 LayerZero、Wormhole 等跨链桥优劣
- 前端开发[html+css]的实用网站分享（一）
- android 手动连接wifi,android手动连接wifi的过程
- NFC·（近距离无线通讯技术）
- 有你的小镇漫画下载[濑尾公治]
- 百度网盘分享创建免密码输入链接
- 百度地图API之GPS坐标转换