django中的cookies和session机制

Posted 2021-12-30 znn041622

0.概述

（1）为什么要有cookies和session

　　在网站中，http请求是无状态的。也就是说即使第一次和服务器连接后并且登录成功后，第二次请求服务器依然不能知道当前请求是哪个用户。而在现实网站中，那淘宝网来举例，用户将商品加入购物车和用户付款是不同的请求，但这个这连个请求需要是同一个用户，而这样的使用场景很多。总结来说，cookies和session一种用户识别用户身份的解决方案。

（2）cookies

　　第一次登录后服务器返回一些数据（cookie）给浏览器，然后浏览器保存在本地，当该用户发送第二次请求的时候，就会自动的把上次请求存储的 cookie 数据自动的携带给服务器，服务器通过浏览器携带的数据就能判断当前用户是哪个了。 cookie 存储的数据量有限，不同的浏览器有不同的存储大小，但一般不超过4KB。因此使用 cookie 只能存储一些小量的数据。

（3）session

　　session和cookie的作用有点类似，都是为了存储用户相关的信息。不同的是， cookie 是存储在本地浏览器， session 是一个思路、一个概念、一个服务器存储授权信息的解决方案，不同的服务器，不同的框架，不同的语言有不同的实现。虽然实现不一样，但是他们的目的都是服务器为了方便存储数据的。 session 的出现，是为了解决 cookie 存储数据不安全的问题的。

（4）cookies与session对比

1.存储位置。cookies存储在服务端，session存储在服务端。
2.安全性。session因为存储在服务端，安全性更高。
3.存储容量。cookies一般不能超过4kb，而session没有限制。

1.操作cookies

cookies本质上是返回值给浏览器，而在Django上是通过调用response对象的方法来实现cookies的操作

（1）设置cookies

通过set_cookies方法来实现的。具体参数如下：

1.  key  ：这个 cookie  的 key  。
2.  value  ：这个 cookie  的 value  。
3.  max_age  ：最长的生命周期。单位是秒。
4.  expires  ：过期时间。跟 max_age  是类似的，只不过这个参数需要传递一个具体的日期，比如 datetime  或者是符合日期格式的字符串。如果同时设置了 expires  和 max_age  ，那么将
　　　会使用 expires  的值作为过期时间。
5.  path  ：对域名下哪个路径有效。默认是对域名下所有路径都有效。
6.  domain  ：针对哪个域名有效。默认是针对主域名下都有效，如果只要针对某个子域名才有效，那么可以设置这个属性.
7.  secure  ：是否是安全的，如果设置为 True  ，那么只能在 https  协议下才可用。
8.  httponly  ：默认是 False  。如果为 True  ，那么在客户端不能通过 javascript  进行操作。

（2）删除cookie：

　　通过 delete_cookie方法即可删除 cookie 。实际上删除 cookie 就是将指定的 cookie 的值设置为空的字符串，然后使用将他的过期时间设置为 0 ，也就是浏览器关闭后就过期。

（3）获取cookie：

　　获取浏览器发送过来的 cookie  信息。可以通过 request.COOKIES（最终对象是一个字典类型，可以通过遍历来获取所需要的数据）。

2.操作sessions

（1）session存储方案介绍

存储在服务端：通过 cookie  存储一个 sessionid  ，然后具体的数据则是保存在 session  中。如果用户已经登录，则服务器会在 cookie  中保存一个 sessionid，
下次再次请求的时候，会把该 sessionid  携带上来，服务器根据 sessionid  在 session  库中获取用户的 session  数据。就能知道该用户到底是谁，以及之前保存的一些状态信息。
这种专业术语叫做 server side session 。Django  把 session  信息默认存储到数据库中，当然也可以存储到其他地方，比如缓存中，文件系统中等。
存储在服务器的数据会更加的安全，不容易被窃取。但存储在服务器也有一定的弊端，就是会占用服务器的资源，但现在服务器已经发展至今，一些 session  信息还是绰绰有余的。


存储在浏览器：将 session  数据加密，然后存储在 cookie  中。这种专业术语叫做 client side session。flask框架默认采用的就是这种方式，但是也可以替换成其他形式。

（2）sessionss操作流程：

　　django  中的 session  默认情况下是存储在服务器的数据库中的，通过 request.session  即可操作。常用方法如下：

1.  get  ：用来从 session  中获取指定值。
2.  pop  ：从 session  中删除一个值。
3.  keys  ：从 session  中获取所有的键。
4.  items  ：从 session  中获取所有的值。
5.  clear  ：清除当前这个用户的 session  数据。
6.  flush  ：删除 session  并且删除在浏览器中存储的 session_id  ，一般在注销的时候用得比较多。
7.  set_expiry(value)  ：设置过期时间。
    整形：代表秒数，表示多少秒后过期。
    0  ：代表只要浏览器关闭， session  就会过期。
    None  ：会使用全局的 session  配置。在 settings.py  中可以设置 SESSION_COOKIE_AGE  来配置全局的过期时间。默认是 1209600  秒，也就是2周的时间。
8.  clear_expired：清除过期的session。 Django并不会清除过期的session，需要定期手动的清理，或者是在终端，使用命令行 python manage.py clearsessions来清除过期
　　的 session  。

（3）session存储机制修改

　　默认情况下， session 数据是存储到数据库中的。当然也可以将 session 数据存储到其他地方。可以通过设置 SESSION_ENGINE 来更改 session 的存储位置，这个可以配置为以下几种方案：

1.  django.contrib.sessions.backends.db  ：使用数据库。默认就是这种方案。
2.  django.contrib.sessions.backends.file  ：使用文件来存储session。
3.  django.contrib.sessions.backends.cache  ：使用缓存来存储session。想要将数据存储到缓存中，前提是你必须要在 settings.py 中配置好 CACHES ，
　　并且是需要使用 Memcached  ，而不能使用纯内存作为缓存。
4.  django.contrib.sessions.backends.cached_db  ：在存储数据的时候，会将数据先存到缓存中，再存到数据库中。这样就可以保证万一缓存系统出现问题，session数据也不会丢失。在
　　获取数据的时候，会先从缓存中获取，如果缓存中没有，那么就会从数据库中获取。
5.  django.contrib.sessions.backends.signed_cookies  ：将 session  信息加密后存储到浏览器的 cookie  中。这种方式要注意安全，
　　建议设置SESSION_COOKIE_HTTPONLY=True  ，那么在浏览器中不能通过 js  来操作 session  数据，并且还需要对 settings.py  中的 SECRET_KEY  进行保密，
　　因为一旦别人知道这个 SECRET_KEY  ，那么就可以进行解密。另外还有就是在 cookie  中，存储的数据不能超过 4k  。

3.总结

一个好的程序员不应该只是知道不要重复造轮子，但是应该知道轮子是如何造的，了解一个功能背后的原理，能够设计出适合自己的轮子，这才是优秀的程序员。所谓举一反三，从设计者的角度来思考。要知道代码只是结局问题的一种表达方式，你可以有自己的表达方式。

3.1django中cookies实现原理

（1）cookies的设置流程：

1.客户端发起一个请求连接（如HTTP GET）。
2.服务器在http响应头上加上Set-Cookie，里面存放字符串的键值对。
3.客户端随后的http请求头加上Cookie首部，它包含了之前服务器响应中设置cookie的信息。

（2）利用Python实现cookies设置，代码如下：

from BaseHTTPServer import HTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
import Cookie

class MyRequestHandler(SimpleHTTPRequestHandler):
    def do_GET(self):
        content = "Path is: %s" % self.path
        self.send_response(200)
        self.send_header(‘Content-type‘, ‘text/html‘)
        self.send_header(‘Content-length‘, str(len(content)))

        cookie = Cookie.SimpleCookie()
        cookie[‘id‘] = ‘some_value_42‘

        self.wfile.write(cookie.output())
        self.wfile.write(‘\r\n‘)

        self.end_headers()
        self.wfile.write(content)

server = HTTPServer((‘‘, 59900), MyRequestHandler)
server.serve_forever()

（3）Django通过一系列的包装使得封装Cookie的操作变得更加简单，仅仅使用set_cookies就可以操作，那么它在其中是怎么实现cookie的读取的呢，下面来窥探原理。

def _get_cookies(self):
    if not hasattr(self, ‘_cookies‘):
        self._cookies = http.parse_cookie(self.environ.get(‘HTTP_COOKIE‘, ‘‘))
    return self._cookies

可以看出，获取cookie的操作用了Lazy initialization（延迟加载）的技术，因为如果客户端不需要用到cookie，这个过程只会浪费不必要的操作。

再来看parse_cookie的实现：

def parse_cookie(cookie):
    if cookie == ‘‘:
        return 
    if not isinstance(cookie, Cookie.BaseCookie):
        try:
            c = SimpleCookie()
            c.load(cookie, ignore_parse_errors=True)
        except Cookie.CookieError:
            # 无效cookie
            return 
    else:
        c = cookie
    cookiedict = 
    for key in c.keys():
        cookiedict[key] = c.get(key).value
    return cookiedict

它负责解析Cookie并把结果集成到一个dict（字典）对象中，并返回字典。而设置cookie的操作则会被WSGIHandler执行。

3.2session原理分析

（1）Django中的session实现

class SessionBase(object):
    """
    Base class for all Session classes.
    """
    TEST_COOKIE_NAME = ‘testcookie‘
    TEST_COOKIE_VALUE = ‘worked‘

    def __init__(self, session_key=None):
        self._session_key = session_key
        self.accessed = False
        self.modified = False
        self.serializer = import_string(settings.SESSION_SERIALIZER)

其实django中的session就是一个模拟dict的对象，并实现了一系列的hash和序列化方法，默认持久化在数据库中（有时候也可能由于为了提高性能，用redis之类的内存数据库来缓存session）。

（2）session的操作机制

session操作是通过request.session再加上系列的方法实现的，那么其背后的原理本质上是什么呢？

其实是用了Django的中间件部分，可以参考后续博客内容：django的中间件和上下文处理器。这里先简单介绍，中间件可以在请求到来之前和响应返回的时候做一些处理。

我们看传统的django视图模式一般是这样的：http请求->view->http响应，而加入中间件框架后，则变为：http请求->中间件处理->app->中间件处理->http响应。而在django中这两个处理分别对应process_request和process_response函数，这两个钩子函数将会在特定的时候被触发。

下面结合session中间件具体分析：

class SessionMiddleware(object):
    def __init__(self):
        engine = import_module(settings.SESSION_ENGINE)
        self.SessionStore = engine.SessionStore

    def process_request(self, request):
        session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME)
        request.session = self.SessionStore(session_key)

    def process_response(self, request, response):
        """
        If request.session was modified, or if the configuration is to save the
        session every time, save the changes and set a session cookie or delete
        the session cookie if the session has been emptied.
        """
        try:
            accessed = request.session.accessed
            modified = request.session.modified
            empty = request.session.is_empty()
        except AttributeError:
            pass
        else:
            # First check if we need to delete this cookie.
            # The session should be deleted only if the session is entirely empty
            if settings.SESSION_COOKIE_NAME in request.COOKIES and empty:
                response.delete_cookie(settings.SESSION_COOKIE_NAME,
                    domain=settings.SESSION_COOKIE_DOMAIN)
            else:
                if accessed:
                    patch_vary_headers(response, (‘Cookie‘,))
                if (modified or settings.SESSION_SAVE_EVERY_REQUEST) and not empty:
                    if request.session.get_expire_at_browser_close():
                        max_age = None
                        expires = None
                    else:
                        max_age = request.session.get_expiry_age()
                        expires_time = time.time() + max_age
                        expires = cookie_date(expires_time)
                    # Save the session data and refresh the client cookie.
                    # Skip session save for 500 responses, refs #3881.
                    if response.status_code != 500:
                        try:
                            request.session.save()
                        except UpdateError:
                            # The user is now logged out; redirecting to same
                            # page will result in a redirect to the login page
                            # if required.
                            return redirect(request.path)
                        response.set_cookie(settings.SESSION_COOKIE_NAME,
                                request.session.session_key, max_age=max_age,
                                expires=expires, domain=settings.SESSION_COOKIE_DOMAIN,
                                path=settings.SESSION_COOKIE_PATH,
                                secure=settings.SESSION_COOKIE_SECURE or None,
                                httponly=settings.SESSION_COOKIE_HTTPONLY or None)
        return response

在请求到来后，SessionMiddleware的process_request在请求取出session_key，并把一个新的session对象赋给request.session，而在返回响应时，process_response则判断session是否被修改或过期，来更新session的信息。

（3）dajngo认证中的session

其实request.user的实现也借助到了session。当用户通过login（request，user）登陆的时候，会默认在数据库中保存session数据。

跟上面提到的Session中间件相似，用户验证也有一个中间件：AuthenticationMiddleware，在process_request中，通过request.class.user = LazyUser()在request设置了一个全局的可缓存的用户对象。

class LazyUser(object):
    def __get__(self, request, obj_type=None):
        if not hasattr(request, ‘_cached_user‘):
            from django.contrib.auth import get_user
            request._cached_user = get_user(request)
        return request._cached_user

class AuthenticationMiddleware(object):
    def process_request(self, request):
        request.__class__.user = LazyUser()
        return None

在get_user里，会在检查session中是否存放了当前用户对应的user_id，如果有，则通过id在model查找相应的用户返回，否则返回一个匿名的用户对象(AnonymousUser)。

def get_user(request):
    from django.contrib.auth.models import AnonymousUser
    try:
        user_id = request.session[SESSION_KEY]
        backend_path = request.session[BACKEND_SESSION_KEY]
        backend = load_backend(backend_path)
        user = backend.get_user(user_id) or AnonymousUser()
    except KeyError:
        user = AnonymousUser()
    return user

 

参考博客：django 中 session 的实现机制