Flask中的session ,自定義實現 session機制, 和 flask-session組件

session 是基於cookie實現， 保存在服務端的鍵值對（形式為 {隨機字符串：‘xxxxxx’}）, 同時在瀏覽器中的cookie中也對應一相同的隨機字符串，用來再次請求的 時候驗證；

    注意 ：Flask中的session是存在瀏覽器中  默認key是session(加密的cookie)， 也可以像Django一樣基於上述的方式實現保存在數據庫

1 flask中 session的基本概念

flask 有一個 session 對象。它允許你在不同請求間存儲特定用戶的信息。它是在 Cookies 的基礎上實現的，並且對 Cookies 進行密鑰簽名要使用會話，你需要設置一個密鑰

    同 reqeust 一樣 session 基於上下文管理

本質是字典,具有字典的操作方法

    設置：session['username'] ＝ 'xxx'
    刪除：session.pop('username', None)

大概流程：

第一次請求進來 會把session所有的值都放入內存，對session的增刪改查的操作都是在內存中進行的；

    class SecureCookieSessionInterface(SessionInterface):

        open_session --> 打開，獲取 app.session_cookie_name獲取加密的session(沒有的話會創建)
                                      然后進行解密

        save_session  --> 對操作完的sesison進行加密 保存

session的超時時間如何配置：

    app.config['SESSION_COOKIE_NAME'] = ''

    'SESSION_COOKIE_NAME':                  'session',    # 默認
    'SESSION_COOKIE_DOMAIN':                None,
    'SESSION_COOKIE_PATH':                  None,
    'SESSION_COOKIE_HTTPONLY':              True,
    'SESSION_COOKIE_SECURE':                False,
    'SESSION_REFRESH_EACH_REQUEST':         True,
    'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),

2 flask中 session的流程詳解

剛進來創建 request_context 對象(request，初始化session(最開始為空))-->>

當接收到用戶請求之后，會調用 Flask對象的 session_interface對象的open_session方法，以此來獲取一個session對象。-->>

數據返回給用戶，並且把內容中的session重新保存-->>

3 自定義session

根據內置session原理可以進行session的定制：

    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)

    使用時，需要先新進行配置：
    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()

4 flask-session組件

flask內置session使用簽名cookie保存

flask-session 組件則將支持session保存到多個地方：

redis：
memcached
filesystem
mongodb
sqlalchmey：拿數據存到數據庫表里面


安裝

pip3 install flask-session

redis存儲方式

import redis
from flask import Flask, session
from flask_session import Session

app = Flask(__name__)
app.debug = True
app.secret_key = 'xxxx'

app.config['SESSION_TYPE'] = 'redis'  # session類型為redis
app.config['SESSION_PERMANENT'] = False  # 如果設置為True，則關閉瀏覽器session就失效。
app.config['SESSION_USE_SIGNER'] = False  # 是否對發送到瀏覽器上session的cookie值進行加密
app.config['SESSION_KEY_PREFIX'] = 'session:'  # 保存到session中的值的前綴
app.config['SESSION_REDIS'] = redis.Redis(host='127.0.0.1', port='6379', password='123123')  # 用於連接redis的配置

Session(app)


@app.route('/index')
def index():
    session['k1'] = 'v1'
    return 'xx'


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

memcached

import redis
from flask import Flask, session
from flask_session import Session
import memcache

app = Flask(__name__)
app.debug = True
app.secret_key = 'xxxx'


app.config['SESSION_TYPE'] = 'memcached' 
app.config['SESSION_PERMANENT'] = True # 如果設置為True，則關閉瀏覽器session就失效。
app.config['SESSION_USE_SIGNER'] = False # 是否對發送到瀏覽器上session的cookie值進行加密
app.config['SESSION_KEY_PREFIX'] = 'session:' # 保存到session中的值的前綴
app.config['SESSION_MEMCACHED'] = memcache.Client(['10.211.55.4:12000'])


Session(app)


@app.route('/index')
def index():
    session['k1'] = 'v1'
    return 'xx'


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

filesystem

import redis
from flask import Flask, session
from flask_session import Session

app = Flask(__name__)
app.debug = True
app.secret_key = 'xxxx'

app.config['SESSION_TYPE'] = 'filesystem'  
app.config[
    'SESSION_FILE_DIR'] = '/Users/wupeiqi/PycharmProjects/grocery/96.Flask新課程/組件/2.flask-session'  # session類型為redis
app.config['SESSION_FILE_THRESHOLD'] = 500  # 存儲session的個數如果大於這個值時，就要開始進行刪除了
app.config['SESSION_FILE_MODE'] = 384  # 文件權限類型

app.config['SESSION_PERMANENT'] = True  # 如果設置為True，則關閉瀏覽器session就失效。
app.config['SESSION_USE_SIGNER'] = False  # 是否對發送到瀏覽器上session的cookie值進行加密
app.config['SESSION_KEY_PREFIX'] = 'session:'  # 保存到session中的值的前綴

Session(app)


@app.route('/index')
def index():
    session['k1'] = 'v1'
    session['k2'] = 'v1'
    return 'xx'


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

mongodb

from flask import Flask, session
from flask_session import Session
import pymongo

app = Flask(__name__)
app.debug = True
app.secret_key = 'xxxx'

app.config['SESSION_TYPE'] = 'mongodb'  

app.config['SESSION_MONGODB'] = pymongo.MongoClient()
app.config['SESSION_MONGODB_DB'] = 'mongo的db名稱（數據庫名稱）'
app.config['SESSION_MONGODB_COLLECT'] = 'mongo的collect名稱（表名稱）'

app.config['SESSION_PERMANENT'] = True  # 如果設置為True，則關閉瀏覽器session就失效。
app.config['SESSION_USE_SIGNER'] = False  # 是否對發送到瀏覽器上session的cookie值進行加密
app.config['SESSION_KEY_PREFIX'] = 'session:'  # 保存到session中的值的前綴

Session(app)


@app.route('/index')
def index():
    session['k1'] = 'v1'
    session['k2'] = 'v1'
    return 'xx'


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

sqlalchemy

import redis
from flask import Flask, session
from flask_session import Session as FSession
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.debug = True
app.secret_key = 'xxxx'

# 設置數據庫鏈接
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:123@127.0.0.1:3306/fssa?charset=utf8'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True

# 實例化SQLAlchemy
db = SQLAlchemy(app)

app.config['SESSION_TYPE'] = 'sqlalchemy'  # session類型為sqlalchemy
app.config['SESSION_SQLALCHEMY'] = db # SQLAlchemy對象
app.config['SESSION_SQLALCHEMY_TABLE'] = 'session' # session要保存的表名稱
app.config['SESSION_PERMANENT'] = True  # 如果設置為True，則關閉瀏覽器session就失效。
app.config['SESSION_USE_SIGNER'] = False  # 是否對發送到瀏覽器上session的cookie值進行加密
app.config['SESSION_KEY_PREFIX'] = 'session:'  # 保存到session中的值的前綴
FSession(app)


@app.route('/index')
def index():

    session['k1'] = 'v1'
    session['k2'] = 'v1'

    return 'xx'


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

    應用程序比較小，用原生的加密ccokie 保存session(內置)
    應用程序比較大，可以用redis（flask-session）