Django Session，CSRF，Model操作，Form验证，中间件，缓存，信号
SessionCSRFModel 操作Form 验证中间件缓存信号1,Session
基于cookie做用户验证时：敏感信息不适合放在cookie中
a,Session 原理
cookie是保存在在用户浏览器端的键值对Session是保存在服务器端的键值对原理：1，生成随机字符串2，写到用户浏览器cookie3，保存到session中4，在随机字符串对应的字典中设置相关内容
b,Cookie 和 Session 对比
c,Session 配置（缺少cache）
d,实例：实现两周自动登录（下方使用实例）
-request.session.set_expiry(60*10)-SESSION_SAVE_EVERY_REQUEST = True
PS:
cookie 中不设置超时时间，则表示关闭浏览器自动清除session依赖于cookie服务器 sessionrequest.session.get()request.session[x] =xrequest.session.clear()
e,数据库session
Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。
使用实例：
缓存+免密登录 views.py
from django.shortcuts import render,redirect,HttpResponse# Create your views here.def login(request):if request.method == 'GET':return render(request,'login.html')elif request.method == 'POST':user = request.POST.get('user')pwd = request.POST.get('pwd')if user=='root' and pwd=='123':#session设置值#生成随机字符串#写到用户浏览器cookie#保存到session中#在随机字符串对应的字典中设置相关内容request.session['username'] = userrequest.session['is_login'] = True#设置 10s 免登陆（超时时间）if request.POST.get('rmb',None) == '1':request.session.set_expiry(10)return redirect('/index/')else:return render(request,'login.html')def index(request):#session 中获取值# if request.session['is_login']:if request.session.get('is_login',None):# return HttpResponse(request.session['username'])return render(request,'index.html',{'username':request.session['username']})else:return HttpResponse('gun')#注销def logout(request):request.session.clear()return redirect('/login/')
免密登录 login.html
<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>Title</title></head><body><form action="/login/" method="post"><input type="text" name="user"><input type="text" name="pwd"><input type="checkbox" name="rmb" value="1">10s免登陆<input type="submit" value="提交"><input type="button" id="btn1" value="按钮1"><input type="button" id="btn2" value="按钮2"></form><script src="/static/jquery-3.4.1.js"></script><script src="/static/jquery-cookie.js"></script><script>$(function () {$.ajaxSetup({beforeSend:function (xhr,settings) {xhr:setRequestHeader('X-CSRFtoken',$.cookie('csrftoken'));}});$('#btn1').click(function () {$.ajax({url:'/login/',type:'POST',data:{'user':'root','pwd':'123'},{#header:{'X-CSRFtoken':$.cookie('csrftoken')},#}success:function (arg) {}})});})</script></body></html>
数据库session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎（默认）SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径（默认）SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名（默认）SESSION_COOKIE_SECURE = False # 是否Https传输cookie（默认）SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输（默认）SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）（默认）SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期（默认）SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存（默认）
b. 使用
def index(request):# 获取、设置、删除Session中数据request.session['k1']request.session.get('k1',None)request.session['k1'] = 123request.session.setdefault('k1',123) # 存在则不设置del request.session['k1']# 所有 键、值、键值对request.session.keys()request.session.values()request.session.items()request.session.iterkeys()request.session.itervalues()request.session.iteritems()# 用户session的随机字符串request.session.session_key# 将所有Session失效日期小于当前日期的数据删除request.session.clear_expired()# 检查 用户session的随机字符串 在数据库中是否request.session.exists("session_key")# 删除当前用户的所有Session数据request.session.delete("session_key")request.session.set_expiry(value)* 如果value是个整数，session会在些秒数后失效。* 如果value是个datatime或timedelta，session就会在这个时间后失效。* 如果value是0,用户关闭浏览器session就会失效。* 如果value是None,session会依赖全局session失效策略。
缓存session
配置和使用同上
文件session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎SESSION_FILE_PATH = None# 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()# 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/TSESSION_COOKIE_NAME ＝ "sessionid"# Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名SESSION_COOKIE_SECURE = False # 是否Https传输cookieSESSION_COOKIE_HTTPONLY = True# 是否Session的cookie只支持http传输SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期SESSION_SAVE_EVERY_REQUEST = False# 是否每次请求都保存Session，默认修改之后才保存
b. 使用
同上
缓存+数据库session
数据库用于做持久化，缓存用于提高效率
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎
b. 使用
同上
加密session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎
b. 使用
同上
2,CSRF
django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。
a,CSRF 原理
<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title></title></head><body><form action="/fm/" method="POST">{% csrf_token %} --------CSRF 网站身份识别头<p>{{ obj.user.label }} {{ obj.user }} {{ obj.errors.user.0 }}</p><p>{{ obj.pwd }} {{ obj.errors.pwd.0 }}</p><p>{{ obj.email }}{{ obj.errors.email.0 }}</p><p>{{ obj.f }}{{ obj.errors.f.0 }}</p>{{ obj.city1 }}{{ obj.city2 }}<input type="submit" value="提交" /></form></body></html>
b,无CSRF时存在隐患
c,Form 提交
d,Ajax提交（CSRF)
CSRF 请求头 X-CSRFToken
关于CSRF （灵活设置 CSRF）
django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。全局：中间件 django.middleware.csrf.CsrfViewMiddleware局部：@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。注：from django.views.decorators.csrf import csrf_exempt,csrf_protect
3,Model 操作
a. 字段类型 + 参数b. 连表字段 + 参数c. Metad. SQL操作：- 基本增删改查- 进阶操作- 正反查询- 其他操作e. 验证（弱）
Django 的 Model 操作
4,Form 验证（Model Form）
完成：验证用户请求生成HTML（保留上一次数据）自定义：类字段（校验）插件（生成HTML）初始化操作：
实例：
views.py
######################## Form #####################from django import formsfrom django.forms import widgetsfrom django.forms import fieldsclass FM(forms.Form):# 字段本身只做验证user = fields.CharField(error_messages={'required': '用户名不能为空.'},widget=widgets.Textarea(attrs={'class': 'c1'}),label="用户名",)pwd = fields.CharField(max_length=12,min_length=6,error_messages={'required': '密码不能为空.', 'min_length': '密码长度不能小于6', "max_length": '密码长度不能大于12'},widget=widgets.PasswordInput(attrs={'class': 'c2'}))email = fields.EmailField(error_messages={'required': '邮箱不能为空.','invalid':"邮箱格式错误"})f = fields.FileField()# p = fields.FilePathField(path='app01')city1 = fields.ChoiceField(choices=[(0,'上海'),(1,'广州'),(2,'东莞')])city2 = fields.MultipleChoiceField(choices=[(0,'上海'),(1,'广州'),(2,'东莞')])from app01 import modelsdef fm(request):if request.method == "GET":# 从数据库中吧数据获取到dic = {"user": 'r1','pwd': '123123','email': 'sdfsd','city1': 1,'city2': [1,2]}obj = FM(initial=dic)return render(request,'fm.html',{'obj': obj})elif request.method == "POST":# 获取用户所有数据# 每条数据请求的验证# 成功：获取所有的正确的信息# 失败：显示错误信息obj = FM(request.POST)r1 = obj.is_valid()if r1:# obj.cleaned_datamodels.UserInf.objects.create(**obj.cleaned_data)else:# ErrorDict# print(obj.errors.as_json())# print(obj.errors['user'][0])return render(request,'fm.html', {'obj': obj})return render(request,'fm.html')
fm.html
<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title></title></head><body><form action="/fm/" method="POST">{% csrf_token %}<p>{{ obj.user.label }} {{ obj.user }} {{ obj.errors.user.0 }}</p><p>{{ obj.pwd }} {{ obj.errors.pwd.0 }}</p><p>{{ obj.email }}{{ obj.errors.email.0 }}</p><p>{{ obj.f }}{{ obj.errors.f.0 }}</p>{{ obj.city1 }}{{ obj.city2 }}<input type="submit" value="提交" /></form></body></html>
参考网页
5，中间件
django 中的中间件（middleware），在django中，中间件其实就是一个类，在请求到来和结束后，django会根据自己的规则在合适的时机执行中间件中相应的方法。在django项目的settings模块中，有一个 MIDDLEWARE_CLASSES 变量，其中每一个元素就是一个中间件，适合对所有请求 统一操作某些事件
-settings.py
from django.middleware.csrf import CsrfViewMiddlewareMIDDLEWARE = ['django.middleware.security.SecurityMiddleware','django.contrib.sessions.middleware.SessionMiddleware','monMiddleware','django.middleware.csrf.CsrfViewMiddleware','django.contrib.auth.middleware.AuthenticationMiddleware','django.contrib.messages.middleware.MessageMiddleware','django.middleware.clickjacking.XFrameOptionsMiddleware','Middle.m1.Row1','Middle.m2.Row2','Middle.m3.Row3',]
views.py
from django.utils.deprecation import MiddlewareMixinfrom django.shortcuts import HttpResponseclass Row1(MiddlewareMixin):def process_request(self,request):print('bao1')def process_view(self,request,view_func,view_func_args,view_func_kwargs):print("bao7")def process_response(self,request,response):print('bao6')return responseclass Row2(MiddlewareMixin):def process_request(self,request):print('bao2')def process_view(self,request,view_func,view_func_args,view_func_kwargs):print("bao8")def process_response(self,request,response):print('baoba5')return responseclass Row3(MiddlewareMixin):def process_request(self,request):print('bao3')def process_view(self,request,view_func,view_func_args,view_func_kwargs):print("bao9")def process_response(self,request,response):print('baobao4')return responsedef process_exception(self,request,exception):if isinstance(exception,ValueError):return HttpResponse("出现异常")def process_template_response(self,request,response):#如果 view中的函数返回的对象中具有，render方法，就会触发这个函数print("-------------")return response
与mange.py在同一目录下的文件夹 wupeiqi/middleware下的auth.py文件中的Authentication类中间件中可以定义四个方法，分别是：
process_request(self,request)process_view(self, request, callback, callback_args, callback_kwargs)process_template_response(self,request,response)process_exception(self, request, exception)process_response(self, request, response)
参考网页
6，缓存
由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。
Django中提供了6种缓存方式：
开发调试
# 此为开始调试用，实际内部不做任何操作# 配置：CACHES = {'default': {'BACKEND': 'django.core.cache.backends.dummy.DummyCache',# 引擎'TIMEOUT': 300, # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）'OPTIONS':{'MAX_ENTRIES': 300, # 最大缓存个数（默认300）'CULL_FREQUENCY': 3, # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）},'KEY_PREFIX': '',# 缓存key的前缀（默认空）'VERSION': 1, # 缓存key的版本（默认1）'KEY_FUNCTION' 函数名 # 生成key的函数（默认函数会生成为：【前缀:版本:key】）}}# 自定义keydef default_key_func(key, key_prefix, version):"""Default function to generate keys.Constructs the key used by all other methods. By default it prependsthe `key_prefix'. KEY_FUNCTION can be used to specify an alternatefunction with custom key making behavior."""return '%s:%s:%s' % (key_prefix, version, key)def get_key_func(key_func):"""Function to decide which key function to use.Defaults to ``default_key_func``."""if key_func is not None:if callable(key_func):return key_funcelse:return import_string(key_func)return default_key_func
内存
# 此缓存将内容保存至内存的变量中# 配置：CACHES = {'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache','LOCATION': 'unique-snowflake',}}# 注：其他配置同开发调试版本
文件
# 此缓存将内容保存至文件# 配置：CACHES = {'default': {'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache','LOCATION': '/var/tmp/django_cache',}}# 注：其他配置同开发调试版本
数据库
# 此缓存将内容保存至数据库# 配置：CACHES = {'default': {'BACKEND': 'django.core.cache.backends.db.DatabaseCache','LOCATION': 'my_cache_table', # 数据库表}}# 注：执行创建表命令 python manage.py createcachetable
Memcache缓存（python-memcached模块）
#此缓存使用python-memcached模块连接memcacheCACHES = {'default': {'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache','LOCATION': '127.0.0.1:11211',}}CACHES = {'default': {'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache','LOCATION': 'unix:/tmp/memcached.sock',}} CACHES = {'default': {'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache','LOCATION': ['172.19.26.240:11211','172.19.26.242:11211',]}}
Memcache缓存（pylibmc模块）
#此缓存使用pylibmc模块连接memcacheCACHES = {'default': {'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache','LOCATION': '127.0.0.1:11211',}}CACHES = {'default': {'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache','LOCATION': '/tmp/memcached.sock',}} CACHES = {'default': {'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache','LOCATION': ['172.19.26.240:11211','172.19.26.242:11211',]}}
Redis 缓存 （依赖：pip3 install django-redis）
CACHES = {"default": {"BACKEND": "django_redis.cache.RedisCache","LOCATION": "redis://127.0.0.1:6379","OPTIONS": {"CLIENT_CLASS": "django_redis.client.DefaultClient","CONNECTION_POOL_KWARGS": {"max_connections": 100}# "PASSWORD": "密码",}}}按 Ctrl+C 复制代码from django_redis import get_redis_connectionconn = get_redis_connection("default")
5 种配置
某一块 细节配置
views.py
from django.views.decorators.cache import cache_page@cache_page(10)def cache(request):import timectime = time.time()return render(request,'cache.html',{'ctime':ctime})
cache.html
{% load cache %}<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>cache</title></head><body><h1>{{ctime }}</h1><h1>{{ctime }}</h1>{% cache 10 c1 %}<h1>{{ctime }}</h1>{% endcache %}</body></html>
全网站配置
from django.middleware.csrf import CsrfViewMiddleware#全网站 缓存配置from django.middleware.cache import FetchFromCacheMiddlewarefrom django.middleware.cache import UpdateCacheMiddlewareMIDDLEWARE = ['django.middleware.cache.UpdateCacheMiddleware','django.middleware.security.SecurityMiddleware','django.contrib.sessions.middleware.SessionMiddleware','monMiddleware','django.middleware.csrf.CsrfViewMiddleware','django.contrib.auth.middleware.AuthenticationMiddleware','django.contrib.messages.middleware.MessageMiddleware','django.middleware.clickjacking.XFrameOptionsMiddleware','Middle.m1.Row1','Middle.m2.Row2','Middle.m3.Row3','django.middleware.cache import FetchFromCacheMiddleware',]
3 种应用
全局视图函数模板
7，信号
Django中提供了“信号调度”，用于在框架执行操作时解耦。通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。
Django内置信号
Model signalspre_init# django的modal执行其构造方法前，自动触发post_init # django的modal执行其构造方法后，自动触发pre_save# django的modal对象保存前，自动触发post_save # django的modal对象保存后，自动触发pre_delete # django的modal对象删除前，自动触发post_delete # django的modal对象删除后，自动触发m2m_changed # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发class_prepared # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发Management signalspre_migrate # 执行migrate命令前，自动触发post_migrate# 执行migrate命令后，自动触发Request/response signalsrequest_started # 请求到来前，自动触发request_finished # 请求结束后，自动触发got_request_exception # 请求异常后，自动触发Test signalssetting_changed # 使用test测试修改配置文件时，自动触发template_rendered # 使用test测试渲染模板时，自动触发Database Wrappersconnection_created# 创建数据库连接时，自动触发
对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：
from django.core.signals import request_finishedfrom django.core.signals import request_startedfrom django.core.signals import got_request_exceptionfrom django.db.models.signals import class_preparedfrom django.db.models.signals import pre_init, post_initfrom django.db.models.signals import pre_save, post_savefrom django.db.models.signals import pre_delete, post_deletefrom django.db.models.signals import m2m_changedfrom django.db.models.signals import pre_migrate, post_migratefrom django.test.signals import setting_changedfrom django.test.signals import template_renderedfrom django.db.backends.signals import connection_createddef callback(sender, **kwargs):print("xxoo_callback")print(sender,kwargs)xxoo.connect(callback)# xxoo指上述导入的内容
from django.core.signals import request_finishedfrom django.dispatch import receiver@receiver(request_finished)def my_callback(sender, **kwargs):print("Request finished!")
自定义信号
定义信号import django.dispatchpizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])注册信号def callback(sender, **kwargs):print("callback")print(sender,kwargs)pizza_done.connect(callback)触发信号from 路径 import pizza_donepizza_done.send(sender='seven',toppings=123, size=456)
实例：
views.py
from django.core.signals import request_finishedfrom django.core.signals import request_startedfrom django.core.signals import got_request_exceptionfrom django.db.models.signals import class_preparedfrom django.db.models.signals import pre_init, post_initfrom django.db.models.signals import pre_save, post_savefrom django.db.models.signals import pre_delete, post_deletefrom django.db.models.signals import m2m_changedfrom django.db.models.signals import pre_migrate, post_migratefrom django.test.signals import setting_changedfrom django.test.signals import template_renderedfrom django.db.backends.signals import connection_createddef f1(sender, **kwargs):print("xxoo_callback")# print(sender,kwargs)pre_save.connect(f1)import django.dispatchpizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])def callback(sender, **kwargs):print("callback")print(sender,kwargs)pizza_done.connect(callback)
