- 初识cookie

        a.cookie是保留在浏览器端的键值对

        b.服务端可以向客户端写cookie

        c.客户端每次发送请求，会携带cookie一起发送过去，而且cookie是存放在消息头cookie字段

        应用：

            a. 投票

            b. 用户登录

        深入cookie

                -- 登录页面处理：

                    obj = redirect('/classes/')

                    obj.set_cookies('crsf','lzp', max-age=, expires=value)

                    return obj

                -- classes页面

                    cookies = request.COOKIES

                    if not cookies:  # 这里只是简单判断是否有cookie，并没有判断cookie是否正确

                        redirect('/login/')

-- 设置cookie

            obj.set_cookies(key, value, max-age=None, expires=None, path='/', ...)

        - 参数

            a. key

            b. value

            c. max-age=None

                 # mag-age=10表示当超过10s,浏览器会自动清除该cookie

            d. expires=None

                 # expires也是cookie的保存时间，不过是日期类型，而不是整数

                 # expires 和 max-age只要一个就好,推荐max-age(因为设置expires，最后还是转换成max-age)

            e. path='/’

                #表示只有访问path路径的时候才能拿到cookies

                #当path='/'表示所有路径（url)都可以拿到cookies

            f. domain=None,默认是当前域名

            h. secure=False,

                secure=True，https传输

            i. httponly=False 只能http传输

        - set_cookie后会在响应头里面增加一个Set-cookie字段，这个字段的值是一个字典

            key为set_cookie里面的kye,value为set_cookie里面的value

                obj.set_cookie('ticket3', '')

            之前的key,value也会保存在浏览器中

                obj.set_cookie('ticket4', '')

        - 下次访问的时候，会将浏览器保存的cookie存放在消息头Cookie上

            Cookie:ticket3=; ticket4=

    -- 签名设置cookie(加盐）

        a. 设置签名cookie:

            # obj.set_signed_cookie('tt1','',salt='ddddd')

            得到一个cookie: 'tt': '33:1e8HKP:CiklYZU3LtBdztFrCWB7PfEvBbM'

        b. 获取签名

            request.get_signed_cookie('tt1',salt='ddddd')

-- 装饰器，实现登录验证

        # views

            def login(request):

                if request.method == "GET":

                    return render(request, "login.html")

                else:

                    username = request.POST.get('username')

                    pwd = request.POST.get('password')

                    remember = request.POST.get('remember')

                    # username:root,pwd:;remember:on

                    if username == 'root' and pwd == '':

                        # 设置一个cookie，返回给客户端，然后这个cookie会随着请求一起

                        obj = redirect('/classes/')

                        obj.set_cookie('ticket', 'lzp')

                        return obj

                    else:

                        return redirect('/login/')

        # 装饰器（登录状态验证）

            def auth(func):

                def wrapper(request):

                    ticket = request.COOKIES.get('ticket')

                    print(ticket)

                    if not ticket:

                        return redirect('/login/')

                    else:

                        return func(request)

                return wrapper

        # 使用装饰器登录验证（不能直接方法/classes/ 必须先登录才能访问/classes/

            @auth

            def classes(request):

                # 先要判断用户是否成功，通过cookie, cookie是一个字典, ticket是自己设置的一个key

                # ticket = request.COOKIES.get('ticket')

                # print(ticket)

                # if not ticket:

                #     return redirect('/login/')

                # pymysql操作数据库

                print('ddddd')

                conn = pymysql.connect(host='127.0.0.1', port=, user='root', passwd='', db='django_student', charset='utf8')

                cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

                cursor.execute("select id,title from class")

                class_list = cursor.fetchall()

                cursor.close()

                conn.close()

                return render(request, "classes.html", {"class_list": class_list})

    - session定义

         cookie:

            保存在客户端的键值对， 依赖cookie，用来保持会话，记住登录状态；敏感信息不会直接给用户

         session：

            保存在服务端的数据(本质上是键值对)

         session原理：

            每一个用户登录成功后，服务端生成一个属于该用户的随机字符串，

            并把这个随机字符串作为字典的Key，

            往这个key添加该用户的敏感信息； 并将该随机字符串作为response_cookies 中sessionid返回给客户端。

            客户发送下一个请求的时候，携带该随机字符串，服务端在字典找到该随机字符串，就会记得该用户的登录状态。

            好处：敏感信息没有给客户端； 依赖cookie,保持会话

- session使用

        获取：

            request.session.get('k1',None)

            request.session['k1']

        设置：

            request.session['k1'] = ''

            request.session.setdefault('k1','') # 存在则不设置

        删除：

            del request.session['k1']

        获取当前用户所有键值对

            request.session.keys()

            request.session.values()

            request.session.items()

        获取当前用户随机字符串：

            request.session.session_key

        删除当前用户的session

            request.session.delete(request.session.session_key)

        检查用户的随机字符串是否在数据库中

            request.session.exist(request.session.session_key)

        将数据库中所有的session，有效时间（django_session中的expire_date字段）小于当前时间的数据删除

            request.session.clear_expired()

            # 客户端中cookie中sessionid默认是保存两周

            # django_session中expire_date默认也是两周

        设置session超时时间（同时设置客户端session和服务端session)

            request.session.set_expiry(value)

                # 如果value是个整数，session会在些秒数后失效。

                # 如果value是个datatime或timedelta，session就会在这个时间后失效。

                # 如果value是0,用户关闭浏览器session就会失效。

                # 如果value是None,session会依赖全局session失效策略。

- 配置session(session默认是保存数据库表django_session)

         数据库session

            Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_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 =                              # Session的cookie失效日期（2周）（默认）

                SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）

                SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）

         缓存session

            a. 设置settings.py

                SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎

                SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

         文件session

            a. 设置settings.py

                    SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎

                    SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()

    - 基于session的登录验证

        a. views

            def login(request):

                if request.method == 'GET':

                    return render(request, 'app02_login.html')

                else:

                    username = request.POST.get('username')

                    pwd = request.POST.get('pwd')

                    models.User.objects.filter()

                    obj = models.User.objects.filter(name=username,password=pwd).first()

                    if obj:

                        #1 生成随机字符串

                        #2 返回随机字符串给客户端(通过cookie)

                        #3 服务端保存该随机字符串（）

                        #4 服务端保存形式：

                        # {

                        #     '随机字符串'：{'username': 'root', 'email': 'root1234@qq.com'}

                        # }django是保存在数据库表django_session中

                        request.session['username'] = obj.name

                        request.session['email'] = obj.email

                        return redirect('/app02/index.html')

                        # 客户端得到session（随机字符串）后，后面的请求都会携带在cookie中sessionid中

                    else:

                        return render(request, 'app02_login.html', {'msg': '用户名或密码错误'})

            def index(request):

                # 获取cookie中的sessionid（即随机字符串）

                # 在数据库表django_session查找是否有随机字符串

                # 如果在数据库表中，判断username该列是否有值（如果有值代表登录成功）

                v = request.session.get('username')

                if v:

                    return HttpResponse('登录成功:%s'% v)

                else:

                    redirect('/app02/login.html')

        b. 模板

            <body>

                <h3>用户登录</h3>

                <form action="/app02/login.html" method="POST">

                    {% csrf_token %}

                    <p><input type="text" placeholder="username" name="username"></p>

                    <p><input type="password" placeholder="password" name="pwd"></p>

                    <p><input type="submit" value="login"></p>

                    <p style="color:red">{{ msg }}</p>

                </form>

            </body>

    - session 和cookie 比较

        同： cookie和session都是用来记住登录状态

        异：

            cookie是将用户的唯一标识是保存在客户端中，不安全；

            cookie有添加一个签名，将唯一标识进行加密；但是可以破解，仍然不是很安全

            session:只给客户端发送一个字符串，并不包含任何标识用户的内容

            在服务端内存保存一个键值对，

                {'随机字符串': {'name': '于浩'}}

            当客户端发送下一个请求，并携带随机字符串，服务端获取字符串，并在内存中判断

            唯一标识来判断用户是否已经登录了