Django cookie与session简介_django cookie和session

1. cookie 简介

Cookie 并不是它的原意“甜饼”的意思, 而是一个保存在客户机中的简单的文本文件, 这个文件与特定的 Web 文档关联在一起, 保存了该客户机访问这个Web 文档时的信息, 当客户机再次访问这个 Web 文档时这些信息可供该文档使用。

由于HTTP协议是无状态的。也就是每次请求都是独立的，它的执行情况和结果与前面的请求和之后的请求都无直接关系，
它不会受前面的请求响应情况直接影响，也不会直接影响后面的请求响应情况。简单来说我们每次使用网站时都需要账号
和密码来验证身份，为了不重复输入账号密码，产生了cookie，其实cookie具体指的是一段小信息，它是服务器发送出
来存储在浏览器上的一组组键值对，下次访问服务器时浏览器会自动携带这些键值对，以便服务器提取有用信息。
1
2
3
4

cookie的工作原理如上图所示
1

查看cookie

查看cookie需要使用开发者工具快捷键F12即可打开

2. Django 操作 cookie

获取 cookie

request.COOKIES['key']
request.COOKIES.get('key')
这俩个方法可以获取指定键名的cookie
1
2
3

request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)

default: 默认值
salt: 	 加密盐
max_age: 后台控制过期时间，默认是秒数
expires: 专门针对IE浏览器设置超时时间
1
2
3
4
5
6

设置 cookie

# 获取HttpResponse对象
# rep = HttpResponse(...)
rep ＝ render(request, ...)
# 设置 cookie
rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密盐', max_age=None, ...)

1
2
3
4
5
6
7

参数

key, 	  	   键
value='', 	   值
max_age=None,  超时时间
expires=None,  超时时间(IE requires expires, so set it if hasn't been already.)
path='/', 	   Cookie生效的路径，/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问
domain=None,   Cookie生效的域名
secure=False,  https传输
httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）
1
2
3
4
5
6
7
8
9
10

删除 cookie

# 获取HttpResponse对象
# rep = HttpResponse(...)
rep ＝ render(request, ...)
# 删除 cookie
rep.delete_cookie(key)

此方法会删除用户浏览器上之前设置的cookie值
1
2
3
4
5
6
7

cookie 登录验证

通过操作cookie可以验证用户是否登录，并且判断其原本的页面，登录之后自动跳转回原页面。

装饰器

def outer(func):
    def inner(request, *args, **kwargs):
    	# 获取到当前路径
        path = request.get_full_path()
        # 判断有没有登录
        if request.COOKIES.get('login'):
            res = func(request, *args, **kwargs)
            return res
        else:
        	# 没有登录跳转到登录界面，并将上级页面路径添加到登录界面路径
            return redirect(f'/login/?next={path}')
    return inner
    
1
2
3
4
5
6
7
8
9
10
11
12
13

视图函数

# 创建Form组件
class Myfroms(forms.Form):
    name = forms.CharField(max_length=32)
    pwd = forms.CharField(min_length=3)

    # 创建全局钩子函数
    def clean(self):
        # 获取指定字段的值
        name = self.cleaned_data.get('name')
        password = self.cleaned_data.get('pwd')
        # 获取用户对象
        is_exist = models.Users.objects.filter(name=name).first()
        # 比对该用户是否存在
        if not is_exist:
            # 若不存在添加提示信息，格式为add_error('字段名', '提示信息')
            self.add_error('name', '用户名不存在')
        # 比对密码
        if is_exist.pwd != int(password):
        	# 若密码不正确，添加提示信息
            self.add_error('pwd', '密码错误')
        # 在最后要将勾出来的值返回出去
        return self.cleaned_data


# 登录视图函数
class Login(View):
    def get(self, request):
    	# 将form组件类实例化并传递到前端
        form_obj = Myfroms()
        res = render(request, 'login.html', locals())
        return res

    def post(self, request):
    	# 将用户输入数据传到form类中
        form_obj = Myfroms(request.POST)
        # 数据不合法时返回的页面
        res = render(request, 'login.html', locals())
        # 判断数据是否全部合法
        if form_obj.is_valid():
        	# 获取GET请求中的next值，也就是装饰器中的上级路径
            path = request.GET.get('next')
            if path:
            	# 若有上级页面，则登录成功后跳转上级页面
                res = redirect(path)
                return self.cleaned_data
            else:
                res = redirect('/')
            # 添加 cookie ，保存登录状态
            res.set_cookie('login', request.POST.get('name'))
        return res


# 退出登录视图函数
class Exit(View):
    @method_decorator(is_login.outer)
    def get(self, request):
        res = redirect('/login/')
        # 删除cookie
        res.delete_cookie('login')
        return res


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

HTMl 部分

<form action="" method="post" novalidate>
	{% for foo in form_obj %}
	    <p>
	    <label>
	        {{ foo.label }}
	        {{ foo }}
	        <span style="color: red">{{ foo.errors.0 }}</span>
	    </label>
	    </p>
	{% endfor %}
    <input type="submit" class="btn btn-info btn-block" value="下一步">
</form>
1
2
3
4
5
6
7
8
9
10
11
12

CBV 装饰器

由于登录功能校验会在很多地方使用到，我们可以使用装饰器的形式来应用，例如上面示例。需要注意的是在CBV的情况下不能直接添加装饰器，需要额外导入装饰器模块。

导入语句： from django.utils.decorators import method_decorator
1

添加方式

1. 直接在类中的某个方法上添加

		class MyLoginView(views.View):
			# login_auth 是自己创建的装饰器
		    @method_decorator(login_auth)
		    def get(self, request):
		        return HttpResponse("from CBV get view")

1
2
3
4
5
6
7
8

2. 直接在类名上添加并指定
		
		# 需要用 name参数来指定装饰的方法名
		@method_decorator(login_auth, name='get')
		class MyLoginView(views.View):
		    def get(self, request):
		        return HttpResponse("from CBV get view")

1
2
3
4
5
6
7
8

3. 重写 dispatch 方法并添加作用于类中所有的方法

		class MyLoginView(views.View):
			# 对重写的 dispatch 方法使用自定义装饰器
		    @method_decorator(login_auth)
		    def dispatch(self, request, *args, **kwargs):
		    	# 继承父类方法
		        return super().dispatch(request,*args,**kwargs)

1
2
3
4
5
6
7
8
9

3. session 简介

cookie虽然在一定程度上解决了“保持状态”的需求，但是由于Cookie本身最大支持4096字节，以及Cookie本身保存在客户端，可能被拦截或窃取，因此就需要有一种新的东西，它能支持更多的字节，并且他保存在服务器，有较高的安全性。这就是Session。

它的作用就相当于是一个桥梁，给每个客户端的Cookie分配一个唯一的id，这样用户在访问时，通过Cookie，服务器就知道
来的人是“谁”。然后我们再根据不同的Cookie的id，在服务器上保存一段时间的私密资料，如“账号密码”等等
1
2

Session和Cookie的区别

1、数据存储位置：cookie 数据存放在客户的浏览器上，session 数据放在服务器上。

2、安全性：cookie不是很安全，别人可以分析存放在本地的cookie并进行cookie欺骗，考虑到安全应当使用session。

3、服务器性能：session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性
能方面，应当使用cookie。

4、数据大小：单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

5、信息重要程度：可以考虑将用户信息等重要信息存放为session，其他信息如果需要保留，可以放在cookie中。
1
2
3
4
5
6
7
8
9
10

Django 操作 session

1. 获取、设置、删除Session中数据

		request.session['k1'] 					# 没有值会报错				
		request.session.get('k1',None)			# 可以获取多组
		request.session['k1'] = 123				# 可以设置多组
		request.session.setdefault('k1',123) 	# 存在则不设置
		del request.session['k1']


2. 所有 键、值、键值对

		request.session.keys()
		request.session.values()
		request.session.items()
		request.session.iterkeys()
		request.session.itervalues()
		request.session.iteritems()

4. 会话session的key
		
		request.session.session_key

5. 将所有Session失效日期小于当前日期的数据删除
		
		request.session.clear_expired()

6. 检查会话session的key在数据库中是否存在
		
		request.session.exists("session_key")

7. 删除当前会话的所有Session数据
		
		request.session.delete()	# 只删客户端
　　
8. 删除当前的会话数据并删除会话的Cookie。
		
		request.session.flush() 	# 服务端、客户端都删
	    这用于确保前面的会话数据不可以再次被用户的浏览器访问
	    例如，django.contrib.auth.logout() 函数中就会调用它。

9. 设置会话Session和Cookie的超时时间
		
		'django默认的session失效时间是14天'
		request.session.set_expiry(value)
	    * 如果value是个整数，session会在些秒数后失效。
	    * 如果value是个datatime或timedelta，session就会在这个时间后失效。
	    * 如果value是0,用户关闭浏览器session就会失效。
	    * 如果value是None,session会依赖全局session失效策略。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

服务端保存用户相关状态信息，返回给客户端随机字符串
针对保存 django 需要一张表来处理需要使用其自带的 'django_session' 表
ps:django数据库迁移命令会产生一堆默认的表，其中就有一张django_session表
1
2
3

session 登录验证

# form 组件
class Myfroms(forms.Form):
    name = forms.CharField(max_length=32)
    pwd = forms.CharField(min_length=3)

    # 创建全局钩子函数
    def clean(self):
        # 获取指定字段的值
        name = self.cleaned_data.get('name')
        password = self.cleaned_data.get('pwd')
        # 获取用户对象
        is_exist = models.Users.objects.filter(name=name).first()
        # 比对该用户是否存在
        if not is_exist:
            # 若存在添加错误信息，格式为 add_error('字段名', '错误信息')
            self.add_error('name', '用户名不存在')
            return self.cleaned_data
        if is_exist.pwd != int(password):
            self.add_error('pwd', '密码错误')
            # 在最后要将勾出来的值返回出去
            return self.cleaned_data


# 登录视图函数
class Login(View):
    def get(self, request):
        form_obj = Myfroms()
        res = render(request, 'login.html', locals())
        return res

    def post(self, request):
        form_obj = Myfroms(request.POST)
        res = render(request, 'login.html', locals())
        if form_obj.is_valid():
            path = request.GET.get('next')
            if path:
                res = redirect(path)
            else:
                res = redirect('/')
            # res.set_cookie('login', request.POST.get('name'))
            # 添加 session 值
            request.session['login'] = request.POST.get('name')
        return res


class Exit(View):
    @method_decorator(is_login.outer)
    def get(self, request):
        res = redirect('/login/')
        # res.delete_cookie('login')
        # 删除 session 值
        del request.session['login']
        return res


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

4. Django 中的 Session 配置

1. 数据库Session
SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）

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

3. 文件Session
SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir() 

4. 缓存+数据库
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎

5. 加密Cookie Session
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎

其他公用设置项：
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，默认修改之后才保存（默认）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26