flask-session
Flask中的session处理机制
- 请求刚到来，获取随机字符串，存在则去“数据库”中获取原来的个人数据，否则创建一个空的容器-->内存：对象（随机字符串 ，存放数据容器）
- 视图：操作 内存中的对象（随机字符串 ，存放数据容器）
- 响应：把内存对象数据保存到数据库中，并把随机字符串更新到用户的cookie中
之前我们对flask源码进行分析过，在RequestContext中不仅封装了request的数据，还是封装了session，只不过此时为none
不过在执行ctx.push()方法中，执行到_request_ctx_stack.push(self)，也是LocalStack对象把RequestContext对象放到local中...之后，还有这么一段代码
self.session = self.app.open_session(self.request)
if self.session is None:
self.session = self.app.make_null_session()
似乎上面这个过程就对ctx里session进行重新赋值，那这个session到底是一个什么对象呢？
上面self.app就是flask对象，在open_session返回这么一玩意
self.session_interface.open_session(self, request)
这self.session_interface又是个什么鬼？是SecureCookieSessionInterface()对象，并调用它里面的open_session方法，还是传入了request的，还在这个方法中，最终执行了return self.session_class(data)，其实就是一个SecureCookieSession对象，而在SecureCookieSession这个类的一个父类是继承了字典，所以SecureCookieSession对象是一个特殊的字典，RequestContext对象封装的session也就是一个特殊的字典
class CallbackDict(UpdateDictMixin, dict):
再次回到open_session的源码中
def open_session(self, app, request):
#s就相当于加密规则，里面有涉及到secret_key
s = self.get_signing_serializer(app)
if s is None:
return None
#去用户请求的cookie中获取原来给你的随机字符串
#去cookie中获取key为session的值
val = request.cookies.get(app.session_cookie_name)
if not val:
#如果没有，就创建一个特殊的空字典
return self.session_class()
max_age = total_seconds(app.permanent_session_lifetime)
try:
#把从cookie里获取的session值反序列化回字典
data = s.loads(val, max_age=max_age)
return self.session_class(data)
except BadSignature:
return self.session_class()
最后我们会发现在ctx.push()里，请求刚进来时，会给封装在RequestContext对象下的session创建一个特殊的空字典
请求处理中，比如进行session['xxx'] = 123操作，会执行session的__setitem__方法，注意这个session是全局导入的，所以它是LocalProxy对象，流程又是这么熟悉，执行偏函数，获取session对象（这里就是特殊空字典），self._get_current_object()就是这个特殊的空字典，也是SecureCookieSession对象
self._get_current_object()[key] = value
[key] = value这代码又会执行SecureCookieSession里的__setitem__方法，它本身没有实现该方法，所以它调用父类字典中的方法
响应时，在response = self.full_dispatch_request()中，最后会执行self.finalize_request(rv)，并在这里面执行的response = self.process_response(response)，返回response前还执行了如下代码
if not self.session_interface.is_null_session(ctx.session):
#ctx.session为那个特殊字典，执行视图后，里面现在是有值的 self.save_session(ctx.session, response)
save_session中，执行了self.session_interface.save_session，而这个session_interface就是SecureCookieSessionInterface对象，执行它里面save_session方法
def save_session(self, app, session, response):
#这里self是配置文件对象，这些get操作是从配置文件读取session的相关的一些配置
domain = self.get_cookie_domain(app)
path = self.get_cookie_path(app)
if not session:
if session.modified:
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)
#把特殊字典转成字典，并进行序列化
val = self.get_signing_serializer(app).dumps(dict(session))
#写入到相应的cookie中，但是这里没有涉及写入"数据库"相关的操作
response.set_cookie(app.session_cookie_name, val,
expires=expires, httponly=httponly,
domain=domain, path=path, secure=secure)
so，flask内置的session，是将session保存在加密的cookie中实现
但是放在cookie会有两个方面的考虑：长度和安全，所以还需要了解第三方session
安装 pip3 install Flask-Session,这个 组件里支持了session的各种存储方法：Redis，Memcached，文件，数据库(mongodb,sqlalchemy)
上面源码分析过，在self.session_interface.save_session中，self.session_interface就是SecureCookieSessionInterface()，在它里面直接是把序列化后的session写入到cookie中，没有进行服务端的存储，而我们希望就是把session随机字符串写入cookie中，其他的值存储到我们指定的地方去，所以我们需要把SecureCookieSessionInterface这个类替换成第三方session提供的类
from flask import Flask,session
app = Flask(__name__)
app.secret_key = 'suijksdfsd'
# 指定session_interface 类
from redis import Redis
from flask_session import RedisSessionInterface
conn = Redis() #ip 端口连接
#permanent为true时，关闭浏览器，cookie就失效
app.session_interface = RedisSessionInterface(conn,key_prefix='__',use_signer=False,permanent=True)
@app.route('/')
def index():
session['xxx'] = 123
return 'Index'
if __name__ == '__main__':
app.run()
从源码执行情况看，指定为RedisSessionInterface后，它会执行RedisSessionInterface的open_session和save_session方法
def open_session(self, app, request):
#去cookie中获取键为session的值
sid = request.cookies.get(app.session_cookie_name)
if not sid: #刚开始没有的时候，生成一个随机字符串
sid = self._generate_sid()
#session_class = RedisSession，RedisSession也是一个特殊字典
return self.session_class(sid=sid, permanent=self.permanent)
if self.use_signer: #签名加密
signer = self._get_signer(app)
if signer is None:
return None
try:
sid_as_bytes = signer.unsign(sid)
sid = sid_as_bytes.decode()
except BadSignature:
sid = self._generate_sid()
return self.session_class(sid=sid, permanent=self.permanent)
if not PY2 and not isinstance(sid, text_type):
sid = sid.decode('utf-8', 'strict')
#到redis里获取 前缀+随机字符串 的值
val = self.redis.get(self.key_prefix + sid)
if val is not None:
try:
#有值就进行反序列化，得到字典
data = self.serializer.loads(val)
#生成redis特殊字典，返回
return self.session_class(data, sid=sid)
except:
return self.session_class(sid=sid, permanent=self.permanent)
return self.session_class(sid=sid, permanent=self.permanent)
在close_session中，其他似曾相识的地方就不看，就看不同的吧
httponly = self.get_cookie_httponly(app)
secure = self.get_cookie_secure(app)
expires = self.get_expiration_time(app, session)
#字典化后，在进行序列化
val = self.serializer.dumps(dict(session))
#把序列化后的字符串写入redis，并设置超时时间
self.redis.setex(name=self.key_prefix + session.sid, value=val,
time=total_seconds(app.permanent_session_lifetime))
if self.use_signer:
session_id = self._get_signer(app).sign(want_bytes(session.sid))
else:
session_id = session.sid
#最终只是把随机字符串写入到cookie中
response.set_cookie(app.session_cookie_name, session_id,
expires=expires, httponly=httponly,
domain=domain, path=path, secure=secure)
除了上述直接指定session_interface类的方式外，还可以通过配置文件的方式进行指定
# 通过配置的方式进行
from redis import Redis
from flask_session import Session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='192.168.0.94',port='6379')
Session(app)
我可以看在Session(app)做了一件什么事，实例化对象，执行__init__方法
def __init__(self, app=None):
self.app = app
if app is not None:
self.init_app(app)
在这里面执行了init_app方法，对session_interface开始操作
app.session_interface = self._get_interface(app)
我们大概都能猜到在get_interface(app)里根据配置来为session_interface执行类
if config['SESSION_TYPE'] == 'redis':
session_interface = RedisSessionInterface(
config['SESSION_REDIS'], config['SESSION_KEY_PREFIX'],
config['SESSION_USE_SIGNER'], config['SESSION_PERMANENT'])
elif config['SESSION_TYPE'] == 'memcached':
session_interface = MemcachedSessionInterface(
config['SESSION_MEMCACHED'], config['SESSION_KEY_PREFIX'],
config['SESSION_USE_SIGNER'], config['SESSION_PERMANENT'])
最后返回session_interface对象给app.session_interface，过程和第一方式一样的，只不过就多做了一层封装
