django-session源码流程分析

一,

session一直在中间件中,所以当程序开始进入wsgi模块时,随后就会执行session中间件.

 

第一步::    'django.contrib.sessions.middleware.SessionMiddleware',

    
   class SessionMiddleware(MiddlewareMixin):
    def __init__(self, get_response=None):
        self.get_response = get_response
        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,
                    path=settings.SESSION_COOKIE_PATH,
                    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:
                            raise SuspiciousOperation(
                                "The request's session was deleted before the "
                                "request completed. The user may have logged "
                                "out in a concurrent request, for example."
                            )
                        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

 

1,  a,在中间件执行时,首先进入sessionmiddleware的__init__构造函数

    def __init__(self, get_response=None):
        self.get_response = get_response   #开始等于None
        engine = import_module(settings.SESSION_ENGINE)   #　　
        self.SessionStore = engine.SessionStore 

b,settings.SESSION_ENGINE是在globle_settings(settings里面没有的东西都在globle_settings)中

SESSION_ENGINE = 'django.contrib.sessions.backends.db'

 

c.  engine = import_module(settings.SESSION_ENGINE)
也就是相同与

from django.contrib.sessions.backends import db

def import_module(name, package=None):
    """Import a module.
    pass

里面是从路径中导入一个模块  具体的代码实现由点复杂,略过

 

engine = import_module(settings.SESSION_ENGINE) 也就是导入db模块并复制给engine

d, 执行self.SessionStore = engine.SessionStore  把db模块里面的SessionStore导入并付给
self.SessionStore

class SessionStore(SessionBase):
    """
    Implements database session store.
    """
    def __init__(self, session_key=None):
        super(SessionStore, self).__init__(session_key)

    @classmethod
    def get_model_class(cls):
        # Avoids a circular import and allows importing SessionStore when
        # django.contrib.sessions is not in INSTALLED_APPS.
        from django.contrib.sessions.models import Session
        return Session

    @cached_property
    def model(self):
        return self.get_model_class()

    def load(self):
        try:
            s = self.model.objects.get(
                session_key=self.session_key,
                expire_date__gt=timezone.now()
            )
            return self.decode(s.session_data)
        except (self.model.DoesNotExist, SuspiciousOperation) as e:
            if isinstance(e, SuspiciousOperation):
                logger = logging.getLogger('django.security.%s' % e.__class__.__name__)
                logger.warning(force_text(e))
            self._session_key = None
            return {}

    def exists(self, session_key):
        return self.model.objects.filter(session_key=session_key).exists()

    def create(self):
        while True:
            self._session_key = self._get_new_session_key()
            try:
                # Save immediately to ensure we have a unique entry in the
                # database.
                self.save(must_create=True)
            except CreateError:
                # Key wasn't unique. Try again.
                continue
            self.modified = True
            return

    def create_model_instance(self, data):
        """
        Return a new instance of the session model object, which represents the
        current session state. Intended to be used for saving the session data
        to the database.
        """
        return self.model(
            session_key=self._get_or_create_session_key(),
            session_data=self.encode(data),
            expire_date=self.get_expiry_date(),
        )

    def save(self, must_create=False):
        """
        Saves the current session data to the database. If 'must_create' is
        True, a database error will be raised if the saving operation doesn't
        create a *new* entry (as opposed to possibly updating an existing
        entry).
        """
        if self.session_key is None:
            return self.create()
        data = self._get_session(no_load=must_create)
        obj = self.create_model_instance(data)
        using = router.db_for_write(self.model, instance=obj)
        try:
            with transaction.atomic(using=using):
                obj.save(force_insert=must_create, force_update=not must_create, using=using)
        except IntegrityError:
            if must_create:
                raise CreateError
            raise
        except DatabaseError:
            if not must_create:
                raise UpdateError
            raise

    def delete(self, session_key=None):
        if session_key is None:
            if self.session_key is None:
                return
            session_key = self.session_key
        try:
            self.model.objects.get(session_key=session_key).delete()
        except self.model.DoesNotExist:
            pass

    @classmethod
    def clear_expired(cls):
        cls.get_model_class().objects.filter(expire_date__lt=timezone.now()).delete()

 

  第一步总结:init里面,就是把SessionStore类赋值给self.SessionStore.以便后面调用.

第二步:请求到来的时候,开始走request中间件.

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

 

a, 在GET里面 settings.SESSION_COOKIE_NAME的数据还是在globle_settings里

SESSION_COOKIE_NAME = 'sessionid'   

 

b.  session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME)中从COOKOES找
sessionid这个key,如果有就返回没有则返回空,   
当你开始第一次进入页面时,self.COOKIES一定是空的.

self.COOKIES = {}

 

c,  request.session = self.SessionStore(session_key) 也就是__init__里面返回的self.SessionStore

并且把从session_key穿进去.

class SessionStore(SessionBase):
    """
    Implements database session store.
    """
    def __init__(self, session_key=None):
        super(SessionStore, self).__init__(session_key)

这里执行父类的__init__构造方法.

 

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

    __not_given = object()

    def __init__(self, session_key=None):
        self._session_key = session_key  
        self.accessed = False    #开始等于False,后面如果调用session时,会变成True
        self.modified = False　　#同上
        self.serializer = import_string(settings.SESSION_SERIALIZER)

SESSION_SERIALIZER = 'django.contrib.sessions.serializers.JSONSerializer'

 

d.当用户通过request.session赋值时,会调用父类的的__setitem__方法,而request.session就是
SessionStore,所以找他的__getitem__方法,他没有救找SessionStore的方法.

class SessionBase(object):
  def __setitem__(self, key, value):
        self._session[key] = value   #这里既然找不到self._session都找不到,那么嗨有一种情况就_session是类的静态属性.
        self.modified = True

 

e. 这里 _session = property(_get_session)是类的静态属性,运行_get_session

 

    def _get_session(self, no_load=False):
        """
        Lazily loads session from storage (unless "no_load" is True, when only
        an empty dict is stored) and stores it in the current instance.
        """
        self.accessed = True   #这里把__init__中的accessed变成True
        try:
            return self._session_cache    #这里从类中找 _session_cache,因为没找到,所以报错,执行下面的except
        except AttributeError:    
            if self.session_key is None or no_load:    #开始第一次进来的session_key是空的,所以运行
                self._session_cache = {}                #这里给seslf._session_cache={},以便后面保存.
            else:
                self._session_cache = self.load()
        return self._session_cache                      #第一次把空字典返回

 

最后把Basesession类中的self.modified 变成 True,并且在字典里面加上键值对,表示完成工作

process_request总结:这里主要执行BaseSession中的__setitem__方法,把键值对存放到self_session中.

 

第三步,开始执行process_response