将 flask 中的 session 存储到 SQLite 数据库中

使用 flask 构建服务器后端时，常需要在浏览器端存储 cookie 用于识别不同用户，根据不同的 cookie 判断出当前请求访问的用户。而在服务器端 flask 提供了易用的 session 代理，通过 from flask import session，可以引入 session 并将其作为特定用户信息的字典来用。

要使用 session 代理，首先要给 flask 实例设置 secret_key，然后就可以在请求上下文中使用 session（如在特定的路由中）：

from flask import Flask, session, render_template

app = Flask( __name__ )

app.secret_key = hashlib.sha1( 'abcdefg'.encode() ).hexdigest()

# app.config[ 'SECRET_KEY' ] = hashlib.sha1( 'abcdefg'.encode() ).hexdigest()  # same with previous one statement

@app.route( '/', methods = [ 'GET' ])

def index():

    session[ 'user' ] = 'test'

    return render_template( 'index.html' )

由于 flask 默认的 session 实现方式是 SecureCookieSessionInterface，它将 session 中的数据以加密方式存储在客户端的 cookie 中，因此在使用 session 前，需要首先设置 secret_key，这样才能避免客户端中的 cookie 泄漏信息。

将 session 信息存储在数据库中

尽管 flask 默认的 session 数据是加密之后存储在客户端的 cookie 中，但如果 session 要存储大量敏感的信息，还是将其存储在服务端较好。flask 已经提供了 SessionInterface 接口，要自己实现 session 的存储方式，需要实现该接口并将 flask 实例 app 的 session_interface 指向其实现类的实例。此外还要实现自定义的 Session 类，在自定义的 SessionInterface 实现类中使用自定义的 Session 类。

自定义 Session 类

自定义的 Session 类实现起来很简单，因为它的工作方式与 dict 很类似，可以直接将其继承 dict，这里使用 werkzeug 中提供的 CallbackDict，另外还需要继承的父类是 SessionMixin，以便在 flask 中使用该 Session。由于要使用的是 sqlite 存储方式，这里我将类命名为 DbSession：

# file: dbsessions.py

from flask.sessions import SessionMixin, SessionInterface

from werkzeug import CallbackDict

class DbSession( CallbackDict, SessionMixin ):

    def __init__( self, initial = None, sid = None, new = False ):

        def on_update( self ):

            self.modified = True

        CallbackDict.__init__( self, initial, on_update )

        self.sid = sid

        self.new = new

        self.modified = False

在 Server-side sessions with SQLite 这篇示例中，由于实现的其实现的 SqliteSession 继承的是 MutableMapping，并且没有使用 flask-sqlalchemy，因此需要有 __getitem__、 __setitem__ 等实现数据库的操作，并且需要定义查询的 SQL 语句。而我们使用 flask-sqlalchemy 处理底层的数据库事务，因此 Session 实现类较为简单。

定义 Session 数据模型

为了将 session 数据存储在 sqlite 数据库中，我们还需要定义它的 Model，flask-sqlalchemy 已经为我们处理好了底层繁琐的代码，在应用中直接使用 flask-sqlalchemy 提供的数据库实例即可。

使用 flask-sqlalchemy：

# file: myglobal.py

from flask import Flask

from flask_sqlalchemy import SQLAlchemy

app = Flask( __name__ )

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.db'

app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True

db = SQLAlchemy( app )

# file: dbsessions.py

from .myglobal import db

from datetime import datetime, timedelta

class Sessions( db.Model ):

    __tablename__ = 'sessions'

    sid = db.Column( db.String( 255 ), primary_key = True )

    expired = db.Column( db.DateTime )

    session = db.Column( db.Text ) # it refers session content

    def __init__( self, **kwargs ):

        super( Sessions, self ).__init__( **kwargs )

        if 'sid' in kwargs:

            self.sid = kwargs[ 'sid' ]

        if 'expired' in kwargs:

            self.expired = kwargs[ 'expired' ]

        if 'session' in kwargs:

            self.session = kwargs[ 'session' ]

    def __repr__( self ):

        return '<Session %s>' % self.session

这里的 sid 字段为用于识别用户身份的标识，expired 字段用于设定过期时间，session 字段是实际存储的 session 内容，由于 session 的数据结构与 dict 一样，因此可以考虑使用 json 格式序列化到数据库中。

顺便提一下，如果在程序中使用 session，并要以 json 格式序列化 session，那么 session 中最好不要用到 Datetime 类，否则在运行过程中会提示 Datetime 无法被 JSON 序列化 之类的错误，使用时间戳替代即可：

# in flask app context

session[ 'login' ] = datetime.now()  # 当用 JSON 格式序列化 session 时，会提示 Datetime 对象无法序列化

session[ 'login' ] = datetime.now().timestamp() # 正常

实现 SessionInterface 接口

接下来要实现 flask 中提供的 SessionInterface 接口，较前面两部分内容相对复杂，但是其实原理也很简单。这里需要在实现类中完成 sid 的分配和客户端 cookie 的读写，sid 分配需要尽可能随机，可以直接使用 python 中的 uuid 模块。序列化 session 时使用 JSON 格式，因此需要引入 json 模块（也可以使用 pickle 模块进行序列化）。

SessionInterface 的两个主要接口方法是 open_session 和 save_session：

# file: dbsessions.py

from uuid import uuid4

import json

class DatabaseSessionInterface( SessionInterface ):

    session_class = DbSession

    serializer = json  # or pickle

    def __init__( self, db = db, prefix = 'session:' ):

        self.db = db

        self.prefix = prefix

    def generate_sid( self ):

        return str( uuid4() )

    def get_expiration_time( self, app, session = None ):

        """

        可以直接使用父类的默认超时时间方法，为了自定义默认超时时间进行重写

        """

        if session.permanent:

            return datetime.now() + app.permanent_session_lifetime

        return datetime.now() + timedelta( minutes = 10 )

    def open_session( self, app, request ):

        sid = request.cookies.get( app.session_cookie_name )  # 尝试从请求中获取存储的 cookie（与 session 相关的 cookie）

        if not sid:

            # 没有从 cookie 中找到相关 sid，说明客户端是第一次访问，需要构造 sid

            sid = self.generate_sid()

            # create new Session Model instance

            dbrecord = Sessions( sid = sid )

            sc = self.session_class( sid = sid, new = True )

            return sc

        # if client have a session_cookie, take relative one from database

        dbrecord = Sessions.query.filter_by( sid = sid ).first()

        if dbrecord is None:

            return self.session_class( sid = sid ) # in case of wrong sid in session_cookie

        else:

            return self.session_class( self.serializer.loads( dbrecord.session ), sid = sid )

    def save_session( self, app, session, response ):

        domain = self.get_cookie_domain( app )

        dbrecord = Sessions.query.filter_by( sid = session.sid ).first()

        if not session:

            # 内容为空并且被修改过，说明 session 已经被删除

            if session.modified:

                db.session.delete( dbrecord )

                db.session.commit()

                response.delete_cookie( app.session_cookie_name, domain = domain )

            return

        if dbrecord is None:

            dbrecord = Sessions( sid = session.sid )

            db.session.add( dbrecord )

        # update database record

        dbrecord.session = self.serializer.dumps( session )

        sexp = self.get_expiration_time( app, session )

        dbrecord.expired = sexp

        db.session.commit()

        response.set_cookie( app.session_cookie_name, session.sid, expires = sexp, httponly = True, domain = domain )

实现了 open_session 和 save_session 方法的实现类就可以在 flask 应用中使用了：

app.session_interface = DatabaseSessionInterface()

这里有必要说一下处理 session 的流程：

若客户端第一次请求服务器（服务器使用了 session，但服务器上没有相应的 session），首先调用 open_session 方法，返回一个新创建的 DbSession 对象。在 open_session 方法中最终一定需要返回一个字典结构的对象，我们这里也就是 DbSession 实例。
接下来 flask 会将 open_session 方法中返回的 DbSession 对象的 sid 写入到客户端的 cookie 响应中，并将该对象作为 session 参数调用 save_session 方法。根据 session 中的内容（当 session 中的内容为空时，not session 为 True）和属性执行删除或更新 session 的操作
客户端存储了有 sid 的 cookie 后，后续请求到来时，在 open_session 方法将会返回在数据库中存储的 session 条目。这样就达到了识别用户的目的。

总结

总的来说实现自定义的 session 存储方式并不困难，在参考了 stackoverflow 上相关问题的解答和一些示例后再根据自己的需求进行实现和改进。其实 Server-side sessions with SQLite 这篇示例已经很接近于我的需求了，但是我的具体代码中和该示例有所区别。

比如，示例中为每个 session 创建一个单独的 sqlite 数据库文件，而我的代码中将 session 作为表的一行。另外，示例中会话结束时就会删除对应的数据库文件，而我修改了默认的超时时间方法，因此需要在会话结束后并超时时删除对应的数据库条目，但是目前的代码中并没有相应的实现。不过基本上来说已经达到了最初的目的。

envrionments or requirements

python3.6
flask
flask-sqlalchemy

References