Flask中内置session处理机制源码剖析2(自定义session)

1、自定义session思路

• 请求刚到来：

               创建特殊的字典，并添加到Local中：

               调用关系：

                self.session = session_interface.open_session(self.app, self.request)

               由于默认app中的 session_interface = SecureCookieSessionInterface()，等价于：

               self.session = SecureCookieSessionInterface().open_session(self.app, self.request)

               若自定义了一个MySessionInterFace类，则可执行：

               self.session = MySessionInterFace().open_session(self.app, self.request)

• 调用：

                 session->LocalProxy-->偏函数--->LocalStack ---->Local

• 请求终止：

              由于默认app中的 session_interface = SecureCookieSessionInterface()，等价于：

               self.session = SecureCookieSessionInterface().save_session(self, ctx.session, response)

               若自定义了一个MySessionInterFace类，则可执行：

               self.session = MySessionInterFace().save_session(self, ctx.session, response)

2、自定义session简单示例,可将session存入数据库等进行扩展

from flask import Flask,session

app = Flask(__name__)
app.secret_key = "secret_key"
import json
class MySessionInterFace(object):
    def open_session(self, request):
        return {}
    def save_session(self,session,response):
        response.set_cookie("session_ddgd",json.dumps(session))
    def is_null_session(self):
        return False

app.session_interface = MySessionInterFace

@app.route('/')
def index():
    # 特殊空字典
    # 在local的ctx中找到session
    # 在空字典中写值
    session['xxx'] = 123
    return "index"



if __name__ == '__main__':
    #一旦请求进来就会执行app.__call__
    app.__call__
    app.session_interface
    app.run()

3、自定义session完整示例

pip3 install Flask-Session
        
        run.py
            from flask import Flask
            from flask import session
            from pro_flask.utils.session import MySessionInterface
            app = Flask(__name__)

            app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
            app.session_interface = MySessionInterface()

            @app.route('/login.html', methods=['GET', "POST"])
            def login():
                print(session)
                session['user1'] = 'alex'
                session['user2'] = 'alex'
                del session['user2']

                return "内容"

            if __name__ == '__main__':
                app.run()

        session.py
            #!/usr/bin/env python
            # -*- coding:utf-8 -*-
            import uuid
            import json
            from flask.sessions import SessionInterface
            from flask.sessions import SessionMixin
            from itsdangerous import Signer, BadSignature, want_bytes


            class MySession(dict, SessionMixin):
                def __init__(self, initial=None, sid=None):
                    self.sid = sid
                    self.initial = initial
                    super(MySession, self).__init__(initial or ())


                def __setitem__(self, key, value):
                    super(MySession, self).__setitem__(key, value)

                def __getitem__(self, item):
                    return super(MySession, self).__getitem__(item)

                def __delitem__(self, key):
                    super(MySession, self).__delitem__(key)



            class MySessionInterface(SessionInterface):
                session_class = MySession
                container = {}

                def __init__(self):
                    import redis
                    self.redis = redis.Redis()

                def _generate_sid(self):
                    return str(uuid.uuid4())

                def _get_signer(self, app):
                    if not app.secret_key:
                        return None
                    return Signer(app.secret_key, salt='flask-session',
                                  key_derivation='hmac')

                def open_session(self, app, request):
                    """
                    程序刚启动时执行，需要返回一个session对象
                    """
                    sid = request.cookies.get(app.session_cookie_name)
                    if not sid:
                        sid = self._generate_sid()
                        return self.session_class(sid=sid)

                    signer = self._get_signer(app)
                    try:
                        sid_as_bytes = signer.unsign(sid)
                        sid = sid_as_bytes.decode()
                    except BadSignature:
                        sid = self._generate_sid()
                        return self.session_class(sid=sid)

                    # session保存在redis中
                    # val = self.redis.get(sid)
                    # session保存在内存中
                    val = self.container.get(sid)

                    if val is not None:
                        try:
                            data = json.loads(val)
                            return self.session_class(data, sid=sid)
                        except:
                            return self.session_class(sid=sid)
                    return self.session_class(sid=sid)

                def save_session(self, app, session, response):
                    """
                    程序结束前执行，可以保存session中所有的值
                    如：
                        保存到resit
                        写入到用户cookie
                    """
                    domain = self.get_cookie_domain(app)
                    path = self.get_cookie_path(app)
                    httponly = self.get_cookie_httponly(app)
                    secure = self.get_cookie_secure(app)
                    expires = self.get_expiration_time(app, session)

                    val = json.dumps(dict(session))

                    # session保存在redis中
                    # self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime)
                    # session保存在内存中
                    self.container.setdefault(session.sid, val)

                    session_id = self._get_signer(app).sign(want_bytes(session.sid))

                    response.set_cookie(app.session_cookie_name, session_id,
                                        expires=expires, httponly=httponly,
                                        domain=domain, path=path, secure=secure)