Django——session，csrf，中间件，信号，缓存

session

使用session前一定要先python manage.py makemigration+python manage.py migrate

基于cookie做用户验证的时候，敏感的信息不适合放在cookie中，所以引出session

a.session原理

• cookie是保存在用户浏览器端的键值对
• session是保存在服务器端的键值对，session是基于cookie做的

session相当于内存中的一个大字典

session = {
	随机字符串1 : {'username':'alex1','pwd':'123',...}
	随机字符串2 : {'username':'alex2','pwd':'1234',...}
	...
}

1.生成随机字符串
2.写到用户浏览器的cookie中
3.保存到session中
4.在对应字典中设置相关内容（私密信息）

实际上Django就是做的以上的操作

设置session

获取session

 1 def login(request):
 2     if request.method == 'GET':
 3         return render(request,'login.html')
 4 
 5     elif request.method == 'POST':
 6         u = request.POST.get('user')
 7         p = request.POST.get('pwd')
 8         if u == 'root' and p == '123':
 9             request.session['username'] = u
10             request.session['is_login'] = True
11             if request.POST.get('rmb',None) == '1':
12                 print(123)
13                 request.session.set_expiry(2)
14 
15             return redirect('/index/')
16         else:
17             return redirect("/login/")
18 
19 def index(request):
20     if request.session['is_login']:
21         return HttpResponse('OK')
22     else:
23         return HttpResponse('滚')

设置+获取session

b.session的使用

# 获取Session中数据
request.session['k1']
request.session.get('k1',None) ***

# 设置Session中数据
request.session['k1'] = 123
request.session.setdefault('k1',123) # 存在则不设置

# 删除Session中数据
del request.session['k1']	#只删除k1内的
request.session.clear()		#清除session中所有的数据 

# 所有 键、值、键值对
request.session.keys()
request.session.values()
request.session.items()
request.session.iterkeys()	#返回一个迭代器，不可以print，数据量大的时候for循环效率高
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失效策略。

示例

 1 views.py
 2 
 3 def login(request):
 4     if request.method == 'GET':
 5         return render(request,'login.html')
 6 
 7     elif request.method == 'POST':
 8         u = request.POST.get('user')
 9         p = request.POST.get('pwd')
10         if u == 'root' and p == '123':
11             request.session['username'] = u
12             request.session['is_login'] = True
13             if request.POST.get('rmb',None) == '1':
14                 print(123)
15                 request.session.set_expiry(2)   #将服务器和浏览器的超时时间都设置成2s
16 
17             return redirect('/index/')
18         else:
19             return redirect("/login/")
20 
21 def index(request):
22     if request.session.get('is_login',None):
23         return HttpResponse('OK')
24     else:
25         return HttpResponse('滚')
26 
27 
28 login.html
29 
30 
31 "en">
32 
33     "UTF-8">
34     
35 
36 
37     
"/login/" method="post">
38         "text" name="user" />
39         "text" name="pwd" />
40         "checkbox" name="rmb" value="1"/>2s免登陆
41         "submit" value="提交" />
42         'btn1' type="button" value="ajax" />
43     
44 
45 
46 

View Code

c.配置(settings)文件中设置默认操作（通用配置）:

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（默认不是https传输）

SESSION_COOKIE_HTTPONLY = True               
# 是否Session的cookie只支持http传输（默认是http传输）

SESSION_COOKIE_AGE = 1209600                 
# Session的cookie失效日期（默认超时时间是两周）

SESSION_EXPIRE_AT_BROWSER_CLOSE = False      
# 是否关闭浏览器使得Session过期（如果为True就是不帮我们写超时时间）（默认）

SESSION_SAVE_EVERY_REQUEST = False           
# 是否每次请求都保存Session，默认修改之后才保存（默认设置10s，10s就退出，改为True就按最后一次操作时间计时）

 d.引擎的配置

a.数据库Session（默认）
	SESSION_ENGINESESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）
	# Django默认是将Session数据存储在数据库中，即：django_session 表中。

b.缓存Session
	SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
    SESSION_CACHE_ALIAS = 'default'     # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

	配置memcache：
	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】）
        }
    }
	
c.文件Session
	SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
    SESSION_FILE_PATH = None        # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir

d.缓存+数据库Session
	SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎
 
e.加密cookie Session（我觉得和盐加密cookie没啥区别）
	SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎

CSRF

a.简介

　　django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

全局：
　　中间件 django.middleware.csrf.CsrfViewMiddleware

局部：
	from django.views.decorators.csrf import csrf_exempt,csrf_protect

	@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
	@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

b.form表单提交 / ajax提交

 1 login.html
 2 
 3 
 4 "en">
 5 
 6     "UTF-8">
 7     
 8 
 9 
10     
"/login/" method="post">
11         {% csrf_token %}
12         "text" name="user" />
13         "text" name="pwd" />
14         "checkbox" name="rmb" value="1"/>2s免登陆
15         "submit" value="提交" />
16         'btn1' type="button" value="ajax" />
17     
18 
19     
20     
21     
42 
43 
44 
45 views
46 
47 def login(request):
48     if request.method == 'GET':
49         return render(request,'login.html')
50 
51     elif request.method == 'POST':
52         u = request.POST.get('user')
53         p = request.POST.get('pwd')
54         if u == 'root' and p == '123':
55             request.session['username'] = u
56             request.session['is_login'] = True
57             if request.POST.get('rmb',None) == '1':
58                 print(123)
59                 request.session.set_expiry(2)   #将服务器和浏览器的超时时间都设置成2s
60 
61             return redirect('/index/')
62         else:
63             return redirect("/login/")
64 
65 def index(request):
66     if request.session.get('is_login',None):
67         return HttpResponse('OK')
68     else:
69         return HttpResponse('滚')

View Code

中间件（请求的生命周期加上中间件）

django 中的中间件（middleware），在django中，中间件其实就是一个类，在请求到来和结束后，django会根据自己的规则在合适的时机执行中间件中相应的方法。

在django项目的settings模块中，有一个 MIDDLEWARE_CLASSES 变量，其中每一个元素就是一个中间件，如下图。

与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)　　

以上方法的返回值可以是None和HttpResonse对象，如果是None，则继续按照django定义的规则向下执行，如果是HttpResonse对象，则直接将该对象返回给用户。

就不继续向下执行了

 

拦截请求只需要return HttpResponse

自定义中间件

1、创建中间件类

2、注册中间件（加入配置文件）

>>运行输出结果，证明了上图的走的路径

 1 from django.utils.deprecation import MiddlewareMixin
 2 
 3 
 4 class Row1(MiddlewareMixin):
 5     def process_request(self,request):
 6         print('a')
 7 
 8     def process_view(self, request, view_func, view_func_args, view_func_kwargs):
 9         print('b')
10 
11     def process_response(self, request, response):
12         print('c')
13         return response
14 
15 class Row2(MiddlewareMixin):
16     def process_request(self,request):
17         print('1')
18 
19     def process_view(self, request, view_func, view_func_args, view_func_kwargs):
20         print('2')
21 
22     def process_response(self, request, response):
23         print('3')
24         return response
25 
26 
27 class Row3(MiddlewareMixin):
28     def process_request(self,request):
29         print('aa')
30 
31     def process_view(self, request, view_func, view_func_args, view_func_kwargs):
32         print('bb')
33 
34     def process_response(self, request, response):
35         print('cc')
36         return response

View Code

process_exception用法

1、执行完所有 request 方法 

2、执行 所有 process_view方法

3、如果视图函数出错，执行process_exception（最终response，process_exception的return值）

如果process_exception 方法有了 返回值 就不再执行 其他中间件的 process_exception，直接执行response方法响应 

4.执行所有response方法

5.最后返回process_exception的返回值　

process_template_response用法

1、默认不执行

2、只有在视图函数的返回对象中有render方法才会执行！

3、并把对象的render方法的返回值返回给用户（注意不返回视图函数的return的结果了，而是返回视图函数 return值（对象）的render方法）

中间件应用场景

由于中间件工作在 视图函数执行前、执行后（像不像所有视图函数的装饰器！）适合所有的请求/一部分请求做批量处理

1、做IP限制

放在 中间件类的列表中，阻止某些IP访问了；

2、URL访问过滤

如果用户访问的是login视图（放过）

如果访问其他视图（需要检测是不是有session已经有了放行，没有返回login），这样就省得在 多个视图函数上写装饰器了！

3、缓存（还记得CDN吗?）

客户端请求来了，中间件去缓存看看有没有数据，有直接返回给用户，没有再去逻辑层 执行视图函数

缓存

a.开发调试

# 此为开始调试用，实际内部不做任何操作
    # 配置：
        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，也就是默认一次剔除100）
                },
                '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)	#上面的值传来组成-> key= :1:函数名

    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

b.内存

# 此缓存将内容保存至内存的变量中
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                'LOCATION': 'unique-snowflake',
            }
        }

    # 注：其他配置同开发调试版本

 c.文件

# 此缓存将内容保存至文件
    # 配置：

        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                'LOCATION': '/var/tmp/django_cache',
            }
        }
    # 注：其他配置同开发调试版本

d.数据库

# 此缓存将内容保存至数据库

    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                'LOCATION': 'my_cache_table', # 数据库表
            }
        }

    # 注：执行创建表命令 python manage.py createcachetable

e、Memcache缓存（python-memcached模块）以后回来看

# 此缓存使用python-memcached模块连接memcache

    CACHES = {    #连接memcache
        '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',
            ]
        }
    }
    CACHES = {    #连接集群，分比重
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': [
                ('172.19.26.240:11211',10),
                ('172.19.26.242:11211',11),
            ]
        }
    }

f、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',
            ]
        }
    }

缓存的应用

a. 全站使用
使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

    MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',
        # 其他中间件...
        'django.middleware.cache.FetchFromCacheMiddleware',
    ]

    CACHE_MIDDLEWARE_ALIAS = ""		#多长时间刷新一下
    CACHE_MIDDLEWARE_SECONDS = ""
    CACHE_MIDDLEWARE_KEY_PREFIX = ""
	
b.单独视图缓存
方式一：在函数上加装饰器
    from django.views.decorators.cache import cache_page

    @cache_page(60 * 15)
    def my_view(request):
        ...

方式二：缓存一个url
    from django.views.decorators.cache import cache_page

    urlpatterns = [
        url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
    ]

c、局部视图使用
1、引入TemplateTag

        {% load cache %}

2、使用缓存

    {% cache 5000 缓存key %}
        缓存内容
    {% endcache %}	

如果三个都有的话，最外层的生效（想想请求生命周期就知道了）

信号 

Django提供一种信号机制，一些动作发生时，会触发信号，然后监听了这个信号的函数就会被执行。比如，实现数据库每写入一条数据，写一条日志。要实现这个需求，可以通过全局的中间件来做，但是利用Django的信号机制会更灵活。中间件只作用在请求进来和响应出去时，而信号的散布范围更广。

1、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          # 创建数据库连接时，自动触发

2、信号的使用

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指上述导入的内容

    pre_init.connect(callback)    #在__init__触发前触发我们注入的函数

然后要将该文件引入到与工程同名的目录下的__init__文件引入该函数

3、自定义信号

a. 定义信号

import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])　　#[]里面是触发要传的2个参数
#信号的名字

b. 注册信号

def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
 
pizza_done.connect(callback)
c. 触发信号

from 路径 import pizza_done
 
pizza_done.send(sender='seven',toppings=123, size=456)
由于内置信号的触发者已经集成到Django中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。

转载于:https://www.cnblogs.com/x54256/p/7819564.html