flask之自己的session和三方的flask-session组件

1.flask对session的处理机制

 　1.1、 flask的session处理机制（内置，将session保存到加密的cookie中去实现）
    　　- 请求来的时候，获取随机字符串，（这些都放在内存）
       　　 存在，到数据库（或者文件，某个地方）中获取个人数据
       　　 不存在，创建，创建对象（随机字符串，{存放用户的数据的容器}）
    　　- 视图：操作内存中的对象（随机字符串，{用户的数据}）
    　　- 响应：内存中的对象（随机字符串，{用户的数据}）
      　　  将数据保存到数据库
        　　随机字符串写在用户的cookie中

　　1.2、源码分析、

　　　　a.请求进来执行app的__call__()方法，然后执行wsgi_app()方法　

def wsgi_app(self, environ, start_response):
    # 1、在request_context这里，实例化RequestContext()对象，environ是请求的相关所有数据
    # 封装了request，session，app等
    ctx = self.request_context(environ)

    # 2、执行RequestContext()对象的push
    ctx.push()
    # push内部创建了app_ctx：AppContext(self)对象，
    # push操作之后，session就有值了，请求第一次进来，此时的session=特殊的空字典

    error = None
    # try的内部其实是在做视图函数的处理
    try:
        try:
            response = self.full_dispatch_request() # 这里找视图函数并执行
        except Exception as e:
            error = e
            response = self.handle_exception(e) # 当在处理视图的时候出错执行这个函数
        except:
            error = sys.exc_info()[1]
            raise
        # 给用户返回信息
        return response(environ, start_response)
    finally:
        if self.should_ignore_error(error):
            error = None
        # 请求结束：执行RequestContext()对象的auto_pop函数
        ctx.auto_pop(error)

　　　　a-1. 执行 ctx.push() 

def push(self):
   
    # app_ctx是LocalStack类的对象。请求一开始进来，app_ctx为空
    app_ctx = _app_ctx_stack.top
    if app_ctx is None or app_ctx.app != self.app:
        # 第一次进来的时候app没有值，这里是实例化AppContext类对象的操作
        # app_ctx.g     相当于字典，可以存放before_request的时候传的值，一次使用
        app_ctx = self.app.app_context()
        # 执行AppContext类对象的push方法
        app_ctx.push()
        self._implicit_app_ctx_stack.append(app_ctx)
    else:
        self._implicit_app_ctx_stack.append(None)

    if hasattr(sys, 'exc_clear'):
        sys.exc_clear()

    # _request_ctx_stack就是对LocalStark的对象，执行LocalStark的push
    _request_ctx_stack.push(self)

    # 获取session信息，
    # 请求一开始进来给session赋值，执行当前app的open_session方法，
    # self.session实际就是SecureCookieSession()对象
    # 由于session此次的赋值是在ctx的push里面赋值，但是Local类中封装了ctx，所以这里的session被赋值，Local中的session也会变化
    self.session = self.app.open_session(self.request)
    if self.session is None:
        self.session = self.app.make_null_session()

　　　　a-1-1、执行 self.app.open_session(self.request) 

def open_session(self, request):
    # self.session_interface = SecureCookieSessionInterface()
    # 执行SecureCookieSessionInterface()的open_session方法
    return self.session_interface.open_session(self, request)

　　　　a-1-2、执行SecureCookieSessionInterface()的open_session方法

def open_session(self, app, request):
    # s获取一个加密规则
    s = self.get_signing_serializer(app)
    if s is None:
        return None

    # 去用户请求的cookie中获取原来返回给用户的随机字符串
    # 即key为session的值
    val = request.cookies.get(app.session_cookie_name)

    if not val:
        # 请求第一次进来的时候val没有值，返回一个特殊的空字典
        # session_class = SecureCookieSession
        # SecureCookieSession继承了一个继承了字典的类，相当于给session创建了一个特殊的字典
        return self.session_class()

    max_age = total_seconds(app.permanent_session_lifetime)

    try:
        # 把用户浏览器中的cookie的key为session的值解密成字典(dict)
        data = s.loads(val, max_age=max_age)
        # 再把这个字典转换成特殊的字典，也放到了Local中的ctx中
        return self.session_class(data)

    except BadSignature:
        return self.session_class()

　　　　b.在视图函数中执行 session['xxx'] = 123

# session['xxx']=123 ---> 执行LocalProxy()的__setitem__()方法
session = LocalProxy(partial(_lookup_req_object, 'session'))

　　　　b-1.执行LocalProxy()的__setitem__()方法

def __setitem__(self, key, value):
    # 1.obj = self._get_current_object()：执行偏函数，拿到对应的session对象，即一个特殊的空字典
    # 2.obj[key] = value   执行SecureCookieSession类的__setitem__()方法，把数据放到了特殊的空字典中
    self._get_current_object()[key] = value

　　　　c.请求离开的时候 wsgi_app()--->full_dispatch_request()--->finalize_request()--->process_response() 

def process_response(self, response):
    ctx = _request_ctx_stack.top
    bp = ctx.request.blueprint
    funcs = ctx._after_request_functions
    if bp is not None and bp in self.after_request_funcs:
        funcs = chain(funcs, reversed(self.after_request_funcs[bp]))
    if None in self.after_request_funcs:
        funcs = chain(funcs, reversed(self.after_request_funcs[None]))
    for handler in funcs:
        response = handler(response)
    if not self.session_interface.is_null_session(ctx.session):
        # ctx.session就是之前创建的特殊的自典，response就是返回值
        self.save_session(ctx.session, response)
    return response

　　　　c-1.执行 save_session 

def save_session(self, session, response):
    # session_interface = SecureCookieSessionInterface
    # 执行SecureCookieSessionInterface()的save_session()
    return self.session_interface.save_session(self, session, response)

　　　　c-2.执行SecureCookieSessionInterface()的save_session()

def save_session(self, app, session, response):
    domain = self.get_cookie_domain(app)
    path = self.get_cookie_path(app)

    if not session:
        # session没有值
        if session.modified:
            # 只要修改session，modified就变化，session是空的并且修改过，表示删除了session
            # 删除cookie
            response.delete_cookie(app.session_cookie_name,
                                   domain=domain, path=path)
        return

    if not self.should_set_cookie(app, session):
        return

    httponly = self.get_cookie_httponly(app)
    secure = self.get_cookie_secure(app)
    expires = self.get_expiration_time(app, session)

    # dict(session) ---> 转换成自典
    # get_signing_serializer ---> 序列化
    # val ---> 加密之后的值
    val = self.get_signing_serializer(app).dumps(dict(session))

    # 将数据加密之后，写到cookie中，flask中默认把session中的数据写到cookie中
    response.set_cookie(app.session_cookie_name, val,
                        expires=expires, httponly=httponly,
                        domain=domain, path=path, secure=secure)

2.自定义

3.flask组件