Flask的session

除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥

• 设置：session['username'] ＝ 'xxx'

• 删除：session.pop('username', None)

 

1、内置session实现原理

# - Flask中的session处理机制（内置：将session保存在加密cookie中实现）
    # - 请求刚到来：获取随机字符串，存在则去“数据库”中获取原来的个人数据
    # 否则创建一个空容器。 --> 内存：对象（随机字符串，{放置数据的容器}）
        # 1. obj = 创建SecureCookieSessionInterface()
        # 2. obj = open_session(self.request) = SecureCookieSession()
        # self.session = SecureCookieSession()对象。
        # self.session = self.app.open_session(self.request)
    # - 视图：操作内存中 对象（随机字符串，{放置数据的容器}）
    # - 响应：内存对象（随机字符串，{放置数据的容器}）
            # - 将数据保存到“数据库”
            # - 把随机字符串写在用户cookie中。

总的来说就是

执行到push方法时，内部会调用open_session

请求到来时执行open_session，这个方法如果是第一次来，就会生成一个空字典，视图中可以对session进行操作；若带着cookie来，那么就会

根据随机字符串把对应容器中的数据获取到

执行到full_dispatch_request方法中的finalize_request方法中的process_response方法中，执行完所有的被after_request装饰的函数后会执行save_session方法

请求结束时执行save_session方法，若session已经不存在，也就是在视图中我们就已经把它删掉了，那么就给浏览器返回响应，响应对象中要执行delete_cookie把cookie信息删掉，若session还存在说明在视图中只是获取值或者修改只，那么就把随即字符串作为key，把容器的数据序列化作为value，写到浏览器的cookie中，flask默认是把session的数据放到cookie中的

注意：只要session被设置值，内部的modified参数就会变成True，代表session被修改过

2、自定义session

补充：

生成随机字符串的方法：from  uuid  import  uuid4   str( uuid4( ) )  这样就得到了一个随机字符串

 

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

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)

 

 

3、第三方组件

一般我们不用自定义session，因为有人已经帮我们写好了

from flask import Flask, session
from flask_session import RedisSessionInterface

app = Flask(__name__)
app.secret_key = 'suijksdfsd'

# 方式一
from redis import Redis

conn = Redis()
app.session_interface = RedisSessionInterface(conn, key_prefix='__', use_signer=False)

# 方式二
from redis import Redis
from flask.ext.session import Session

app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='192.168.0.94', port='6379')
Session(app)


@app.route('/')
def index():
    session['xxx'] = 123
    return 'Index'


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