python Django Session，CSRF，Model操作，Form验证，中间件，缓存，信号
Django Session，CSRF，Model操作，Form验证，中间件，缓存，信号
- Session
- CSRF
- Model 操作
- Form 验证
- 中间件
- 缓存
- 信号
1,Session
基于cookie做用户验证时：敏感信息不适合放在cookie中
a,Session 原理
cookie是保存在在用户浏览器端的键值对
Session是保存在服务器端的键值对
原理：
1，生成随机字符串
2，写到用户浏览器cookie
3，保存到session中
4，在随机字符串对应的字典中设置相关内容
b,Cookie 和 Session 对比
c,Session 配置（缺少cache）
d,实例：实现两周自动登录（下方使用实例）
-request.session.set_expiry(60*10)
-SESSION_SAVE_EVERY_REQUEST = True
PS:
cookie 中不设置超时时间，则表示关闭浏览器自动清除
session依赖于cookie
服务器 session
request.session.get()
request.session[x] =x
request.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'] = user
request.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
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
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'] = 123
request.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/T
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. 使用
同上
缓存+数据库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 原理
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. Meta
d. SQL操作：
- 基本增删改查
- 进阶操作
- 正反查询
- 其他操作
e. 验证（弱）
Django 的 Model 操作
4,Form 验证（Model Form）
完成：
验证用户请求
生成HTML（保留上一次数据）
自定义：
类
字段（校验）
插件（生成HTML）
初始化操作：
实例：
views.py
######################## Form #####################
from django import forms
from django.forms import widgets
from django.forms import fields
class 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 models
def 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_data
models.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
<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 CsrfViewMiddleware
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',
'Middle.m1.Row1',
'Middle.m2.Row2',
'Middle.m3.Row3',
]views.py
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
class 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 response
class 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 response
class 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 response
def 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】）
}
}
# 自定义key
def default_key_func(key, key_prefix, version):
"""
Default function to generate keys.
Constructs the key used by all other methods. By default it prepends
the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
function 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_func
else:
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 createcachetableMemcache缓存（python-memcached模块）
#此缓存使用python-memcached模块连接memcache
CACHES = {
'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模块连接memcache
CACHES = {
'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_connection
conn = get_redis_connection("default")5 种配置
某一块 细节配置
views.py
from django.views.decorators.cache import cache_page
@cache_page(10)
def cache(request):
import time
ctime = 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 FetchFromCacheMiddleware
from django.middleware.cache import UpdateCacheMiddleware
MIDDLEWARE = [
'django.middleware.cache.UpdateCacheMiddleware',
'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',
'Middle.m1.Row1',
'Middle.m2.Row2',
'Middle.m3.Row3',
'django.middleware.cache import FetchFromCacheMiddleware',
]3 种应用
全局
视图函数
模板
7，信号
Django中提供了“信号调度”，用于在框架执行操作时解耦。
通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。
Django内置信号
Model signals
pre_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 signals
pre_migrate # 执行migrate命令前，自动触发
post_migrate # 执行migrate命令后，自动触发
Request/response signals
request_started # 请求到来前，自动触发
request_finished # 请求结束后，自动触发
got_request_exception # 请求异常后，自动触发
Test signals
setting_changed # 使用test测试修改配置文件时，自动触发
template_rendered # 使用test测试渲染模板时，自动触发
Database Wrappers
connection_created # 创建数据库连接时，自动触发对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：
from django.core.signals import request_finished
from django.core.signals import request_started
from django.core.signals import got_request_exception
from django.db.models.signals import class_prepared
from django.db.models.signals import pre_init, post_init
from django.db.models.signals import pre_save, post_save
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate
from django.test.signals import setting_changed
from django.test.signals import template_rendered
from django.db.backends.signals import connection_created
def callback(sender, **kwargs):
print("xxoo_callback")
print(sender,kwargs)
xxoo.connect(callback)
# xxoo指上述导入的内容
from django.core.signals import request_finished
from django.dispatch import receiver
@receiver(request_finished)
def my_callback(sender, **kwargs):
print("Request finished!")自定义信号
定义信号
import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])
注册信号
def callback(sender, **kwargs):
print("callback")
print(sender,kwargs)
pizza_done.connect(callback)
触发信号
from 路径 import pizza_done
pizza_done.send(sender='seven',toppings=123, size=456)
实例：
views.py
from django.core.signals import request_finished
from django.core.signals import request_started
from django.core.signals import got_request_exception
from django.db.models.signals import class_prepared
from django.db.models.signals import pre_init, post_init
from django.db.models.signals import pre_save, post_save
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate
from django.test.signals import setting_changed
from django.test.signals import template_rendered
from django.db.backends.signals import connection_created
def f1(sender, **kwargs):
print("xxoo_callback")
# print(sender,kwargs)
pre_save.connect(f1)
import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])
def callback(sender, **kwargs):
print("callback")
print(sender,kwargs)
pizza_done.connect(callback)