python Django Session，CSRF，Model操作，Form验证，中间件，缓存，信号_小言_互联网的博客

python Django Session，CSRF，Model操作，Form验证，中间件，缓存，信号

2019-09-25 14:38 410人阅读评论(0)

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

<!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'] = 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 原理

<!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. 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

<!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 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 createcachetable

Memcache缓存（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)

转载：https://blog.csdn.net/qq_42124842/article/details/101286705

查看评论

小言_互联网的博客

小言_互联网的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章

python Django Session，CSRF，Model操作，Form验证，中间件，缓存，信号

Django Session，CSRF，Model操作，Form验证，中间件，缓存，信号

* 以上用户言论只代表其个人观点，不代表本网站的观点或立场