18 Cookies与Session

目录

• 1、Cookie
  • 1.1 Cookie的由来
  • 1.2 什么是Cookie
  • 1.3 Cookie的原理
  • 1.4 查看Cookie
• 2、Django 中操做Cookies
  • 2.1 如何在浏览器中设置Cookie
  • 2.2 如何获取浏览器的Cookie
  • 2.3 如何删除Cookie
  • 2.4 Cookie 案例
• 3、Session
  • 3.1 Session的由来
• 4、Django中操做session
  • 4.1 如何在服务端设置session
  • 4.2 如何设置session的过时时间
  • 4.3 如何在服务端获取浏览器携带的session
  • 4.4 删除session的两种方式
  • 4.5 session的其余参数
  • 4.6 session 案例
  • 4.7 session流程解析
  • 4.8 Django 中的session 配置
• 5、CBV加装饰器
  • 5.1 CBV加装饰器案例
  • 5.2 CBV加装饰器的方法

1、Cookie

1.1 Cookie的由来

咱们知道HTTP协议的四大特性中有一特性：无状态

无状态：服务器没法保存客户端浏览器的任何信息，没法记住每次访问服务器的客户端浏览器是谁。也就是说客户端浏览器每次对服务器的访问请求都是独立的，它的知心话状况和结果与前面任何依次的请求和以后的全部请求都是没有直接关系的。它不会受前面的请求响应状况直接影响，也不会直接影响后面的请求响应状况。

对服务器来讲：客户端浏览器每次的访问请求都是新的请求，服务端无论该浏览器是否以前已经访问过我，你只要访问我，我就给你响应

状态：能够理解为客户端和服务器在某次会话中产生的数据，那无状态的就是这些数据不会被保留。会话中产生的数据又是咱们须要保存的，也就是说要“保持状态”。所以Cookie就是在这样一个场景下诞生。

1.2 什么是Cookie

Cookie：具体指的就是一小段信息，他是服务器发送出来存处在浏览器上的一组键值对，当该浏览器下次访问服务器时，浏览器会自动携带这些记录在浏览器上的键值对，用于服务器从访问的浏览器身上提取有用的信息

注意：Cookies既然时浏览器访问服务器时，服务器发送给个人，那我浏览器固然也拒绝保存服务器给我发送的这组信息（键值对）

1.3 Cookie的原理

Cookie工做的原理：在客户端浏览器访问服务器时，有服务器产生的一部分信息，这个信息就是一个键值对（Cookie），浏览器接收服务端发送的信息（Cookie）键值对后，保存在浏览器本身身上；当浏览器再次访问该服务器时，浏览器会自动带上（Cookie）键值对，这样服务器就能经过获取浏览器请求携带的参数（Cookie键值对）的内容来判断这个是“哪个浏览器”了。

1.4 查看Cookie

这里咱们先去访问本身的博客园，使用后谷歌浏览器，F12 打开开发者工具，在Network那一栏中有的谷歌浏览器会显示Cookie，这里咱们用Application，就能够看到在当前浏览器访问博客园的服务器时，浏览器本身自己记录的Cookie（键值对）

2、Django 中操做Cookies

此处再次提出咱们的Django响应数据的三种方式：

return HttpResponse() # 直接返回字符串渲染页面
return render()# 返回html页面
return redirect()# 重定向

上述：还记得，上面的三种方式实际上是一个个的类把，当类加（）的时候，实例化一个对象出来,因此我写成下面这样的方式再响应返回数据也能够把

obj1 = Httprespose()
return obj

obj2 = render()
return obj

obj3 = redirect()
return obj

# 向上面的方式，经过这三个类先实例化一个对象，而后再返回这个对象
# 那咱们是否是又能联想到，既然是对象，我是否是就能够对这个对象赋值属性或者是方法啊

2.1 如何在浏览器中设置Cookie

obj = redirect('/login')
obj.set_cookie(key,value) # 由于浏览器是以键值对的方式去存储cookie的


##############参数
key 键
value 值
max_age=None cookie的有效时间，秒为单位

2.2 如何获取浏览器的Cookie

obj = redirect('/home') # 先生成一个跳转到home页面的对象
request.COOKIES.get(key): # ()里面的参数是服务端给浏览器返回的键值对的key

2.3 如何删除Cookie

obj = redirect("/login/")
obj.delete_cookie(key)
return obj

2.4 Cookie 案例

咱们这里以一个登陆案例为例：

有四个页面：登陆用户、主页面home 、index.页面，退出登陆页面logout

需求，当用户未登陆时，不能访问home、index、logout三个页面；当用户登陆成功之后，浏览器在本地保存服务器给本身发送的Cookie值，并能够去访问home页面、index页面、logout页面、logout页面是当用户登陆成功之后，清除用户浏览器保存在本地的Cookie值的

# 登陆装饰器
from functools import wraps
def login_auth(func):
    @wraps(func)

    # 这里把每个被装饰功能函数的request接收
    def inner(request,*args,**kwargs):
        # 经过request.COOKIES.get('name') 去哪这个浏览器本地有没有Cookie值
        if request.COOKIES.get('name'):
            res = func(request,*args, **kwargs)
            return res
        else:
            '''
            这里补充两个知识点：
            1. request.path_info 只拿该url，不拿get请求携带的参数
            2. request.get_full_path() url的全路径，包括url
            '''
            # 若是浏览器中本地没有保存cookie值，那就把当前url的路径拿到，
            last_page = request.path_info
            # 拿到路径后经过get请求携带参数的方式重定向到登陆页面
            return redirect('/login/?next=%s' %last_page)
    return inner

# login视图函数
def login(request):
    # 判断login登陆页面是否为POST请求
    if request.method == 'POST':
        # 拿到用户的登陆用户名，密码
        username = request.POST.get('username')
        password = request.POST.get('password')
        # 这里我就拿固定的值去校验，这里以后写项目的时候能够从数据库中拿值作检验
        if username == 'cecilia' and password == '123':
            # 若是用户名，密码都校验正确之后，在拿到经过装饰器装饰的页面的url
            # 这里再装饰器的时候，就已是经过get请求携带参数的形式跳转到login登陆页面的
            next_url = request.GET.get('next') # 因此这里是登陆以前的页面的url
            obj = redirect(next_url) # 将redirect直接赋给一个对象
            if next_url == '/logout/': # 判断这个上一次的url是否是退出登陆的url，
                # 若是是的话，实例化一个跳转到本身页面的对象
                obj = redirect('/logout')

            # 若是不是，就登陆以后设置cookie值obj.set_cookie('name','cecilia')
            obj.set_cookie('name','cecilia')
            return obj

    return render(request,'login.html')

@login_auth
# 首页
def home(request):
    return HttpResponse('我是主页，home主页！')


@login_auth
# index页
def index(request):
    return HttpResponse('我是index页面')



# 清除cookie
@login_auth
# 退出登陆
def logout(request):
    obj = redirect('/login/')
    # 清除浏览器本地的cookie
    obj.delete_cookie('name')
    return obj

# login.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="" method="post">
    <p>用户名:<input type="text" name="username"></p>
    <p>密码:<input type="text" name="password"></p>
    <p><input type="submit"></p>
</form>
</body>
</html>

3、Session

3.1 Session的由来

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

问题来了，基于HTTP协议的无状态特征，服务器根本就不知道访问者是“谁”。那么上述的Cookie就起到桥接的做用。

咱们能够给每一个客户端的Cookie分配一个惟一的id，这样用户在访问时，经过Cookie，服务器就知道来的人是“谁”。而后咱们再根据不一样的Cookie的id，在服务器上保存一段时间的私密资料，如“帐号密码”等等。

总结而言：Cookie弥补了HTTP无状态的不足，让服务器知道来的人是“谁”；可是Cookie以文本的形式保存在本地，自身安全性较差；因此咱们就经过Cookie识别不一样的用户，对应的在Session里保存私密的信息以及超过4096字节的文本。

另外，上述所说的Cookie和Session实际上是共通性的东西，不限于语言和框架。

4、Django中操做session

4.1 如何在服务端设置session

request.session[key]=value

在服务端设置session的时候，会发生下面这几件事情：

1. 在浏览器请求服务端的时候，django内部自动生成了随机加密字符串

2. 在django_session表中存入数据

   提示1：在服务端添加session值以前，必需要先将django须要用到的表用数据库的迁移命令迁移

   提示2：这个django_session表中有三个字段

   session_key : key
   session_data:value
   exprie_date:session的过时时间，django默认的是14天

3. 将产生的随机字符串返回给浏览器，让浏览器在本地也保存一份

4.2 如何设置session的过时时间

# 设置session以后，
request.session.set_expiry(value)
    * 若是value是个整数，session会在些秒数后失效。
    * 若是value是个datatime或timedelta，session就会在这个时间后失效。
    * 若是value是0,用户关闭浏览器session就会失效。
    * 若是value是None,session会依赖全局session失效策略。14天

4.3 如何在服务端获取浏览器携带的session

request.session.get(key)

在获取浏览器的session时，会发生下面几件事情：

1. 浏览器发送cookie到django以后，django会自动获取cookie值
2. django拿着获取到的随机字符串去django中进行校验，，看是否有对应的数据
3. 若是校验成功了，就将随机字符串所对应的数据，取出给request.session，对不上就返回None

4.4 删除session的两种方式

# 第一种：
request.session.delete() # 只会删除在服务端的session，就是把django_session表中对应的记录给删了

# 第二种：
request.session.flush() # 服务器和浏览器保存的都删掉

4.5 session的其余参数

# 获取、设置、删除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的key
request.session.session_key

# 将全部Session失效日期小于当前日期的数据删除
request.session.clear_expired()

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

4.6 session 案例

咱们这里以一个登陆案例为例：

有四个页面：登陆用户、主页面s_home 、s_index.页面，删除session页面del_session

需求，当用户未登陆时，不能访问s_home、s_index、del_session三个页面；当用户登陆成功之后，浏览器在本地保存服务器给本身发送的Cookie值，并能够去访问home页面、s_index页面、del_session页面、del_session页面是当用户登陆成功之后，删除在服务端的session值的

# 登陆装饰器
def s_login_auth(func):
    @wraps(func)
    def inner(request,*args,**kwargs):
        # 获取当前被装饰的函数的url
        last_page = request.get_full_path()
        if request.session.get('name'):
            res = func(request,*args,**kwargs)
            return res
        else:
            # 若是客户端没有session，那带着本身的url到登陆页面
            return redirect('/s_login/?next=%s'%last_page)
    return inner

# 登陆视图函数
def s_login(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        # 查看用户输入的用户名和密码是否正确
        if username == 'cecilia' and password == '123':
            # 正确之后，登陆成功，在复渠段记录session值
            request.session['name'] = username
            # 获取从装饰器传过来的上一个页面的url
            last_page = request.GET.get('next')
            # 判断上一个页面的url是否存在
            if last_page:
                # 存在则直接重定向上一个页面，此时是已经保存session值的
                return redirect(last_page)
            else:
                # 不存在，就默认回到首页
                return redirect('/s_home')

    return render(request, 'login.html')

@s_login_auth
# 首页
def s_home(request):
    return HttpResponse('我是主页，是home页面')

@s_login_auth
# s_index页面
def s_index(request):
    return HttpResponse('我是index页面')


@s_login_auth
# 删除session页面，此处就默认是删除服务端的session
def del_session(request):
    request.session.delete()
    # request.session.flush() 将服务端和浏览器的session值全都删掉
    return HttpResponse('删除session')

4.7 session流程解析

4.8 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，默认修改以后才保存（默认）

5、CBV加装饰器

5.1 CBV加装饰器案例

就以上面的设置服务端的session为例，咱们用CBV来写s_login的get请求和post请求的功能

咱们要给CBV加装饰器的话，首先要导入from django.utils.decorators import method_decorator

# 装饰器
from functools import wraps
def s_login_auth(func):
    @wraps(func)
    def inner(request,*args,**kwargs):
        last_page = request.get_full_path()
        if request.session.get('name'):
            res = func(request,*args,**kwargs)
            return res
        else:
            return redirect('/c_login/?next=%s'%last_page)
    return inner



# CBV实现登陆页面
from django.views import View 
class LoginView(View):
    # get请求时
    def get(self, request):
        return render(request, 'login.html')
    
    # post请求时
    def post(self, request):
        username = request.POST.get('username')
        password = request.POST.get('password')

        if username == 'cecilia' and password == '123':
            request.session['name'] = username
            last_page = request.GET.get('next')
            if last_page:
                return redirect(last_page)
            else:
                return redirect('/c_home')
        else:
            return redirect('/c_login')


##############################################################开始加装饰器
# 首先导入下面的
from django.utils.decorators import method_decorator

# home页面
@method_decorator(s_login_auth,name='get') # 给这个类的get的方法加装饰器
class HomeView(View):
    def dispatch(self, request, *args, **kwargs):
        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        return HttpResponse('我是主页，是home页面')


# index页面
@method_decorator(s_login_auth,name='get')# 给这个类的get的方法加装饰器
class IndexView(View):
    def dispatch(self, request, *args, **kwargs):
        return super(IndexView, self).dispatch(request, *args, **kwargs)
    def get(self, request):
        return HttpResponse('我是index页面')



# 删除session页面
@method_decorator(s_login_auth,name='get')# 给这个类的get的方法加装饰器
class DelView(View):
    def dispatch(self, request, *args, **kwargs):
        return super(DelView, self).dispatch(request, *args, **kwargs)
    def get(self, request):
        request.session.flush()# 删除服务端和浏览器的session
        return redirect('/c_login')

5.2 CBV加装饰器的方法

1. 直接加载CBV视图类上：但method_decorator必须传 name 关键字参数

注意： 这个装饰器要@method_decorator(装饰器的名字，name=’被装饰的方法‘)

# 首先导入下面的
from django.utils.decorators import method_decorator

# home页面
@method_decorator(s_login_auth,name='get') 
# 给这个类的get方法加装饰器，get方法会使用装饰器，而post方法则不会
class HomeView(View):
    def dispatch(self, request, *args, **kwargs):
        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        return HttpResponse('我是主页，是home页面')
    
    def post(self,request):
        pass

2. 加在dispatc和方法上

注意:这个装饰器要@method_decorator(装饰器的名字)，而且这个CBV里的get和post方法就都使用了装饰器

由于CBV中首先执行的就是dispatch方法，因此这么写至关于给get和post方法都加上了登陆校验。

from django.utils.decorators import method_decorator

# home页面
class HomeView(View):
    @method_decorator(s_login_auth)
    def dispatch(self, request, *args, **kwargs):
        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        return HttpResponse('我是主页，是home页面')
    
    def post(self,request):
        pass

3. 直接加上视图的get或post方法上

from django.utils.decorators import method_decorator

# home页面
class HomeView(View):
    def dispatch(self, request, *args, **kwargs):
        return super(HomeView, self).dispatch(request, *args, **kwargs)
    
    @method_decorator(s_login_auth)
    def get(self, request):
        return HttpResponse('我是主页，是home页面')
    
    @method_decorator(s_login_auth)
    def post(self,request):
        pass