一、上下文管理理论基础
1.线程数据隔离
多线程访问一个数据：当内存中存在一个数据，多个线程都可以对其进行修改，如果要保证数据的一致性，则需要对其进行加锁。
多线程操作自己的数据：当需要每个线程都只能操作自己的数据，而该数据需要放置到一个全局的空间（例如全局变量）。则需要对其进行数据隔离，即线程只能访问自己存储的数据。
在threading模块中，我们可以使用threading.local来实现线程之间的数据隔离：
import threading import time # 定义一个threading.local对象 obj = threading.local def run(index): # 写入xxx=index obj.xxx = index # 10个线程 for i in range(10): t = threading.Thread(target=run, agrs=(i,)) t.start()
虽然每个线程都对obj写入了一个名为"xxx"的变量，值为自己的index。但是threading.local对象为各个线程做了数据隔离。
他的原理是，为每一个线程都开辟一块内存空间，实际上就是利用一个字典，将线程的唯一表示作为键key，线程存入的值放到该键对应的value中。如下所示：
# threading.local使用一个字典来保存各个线程的数据 { 1233: {'xxx': 0}, # 第0个线程的tid为1233，存入的值放在对应的字典中 1234: {'xxx': 1}, 1235: {'xxx': 2}, 1236: {'xxx': 3}, 1237: {'xxx': 4}, 1238: {'xxx': 5}, 1239: {'xxx': 6}, 1240: {'xxx': 7}, 1241: {'xxx': 8}, 1242: {'xxx': 9}, }
2.用字典实现一个threading.local类
import threading class Local(object): DIC = {} # DIC字典用于存放各线程的数据，通过key来隔离 # 从DIC中线程tid对应的字典中获取值 def __getattr__(self, item): tid = threading.get_ident() if tid in self.DIC: return self.DIC[tid].get(item) else: return None # 设置一个值，类似obj.xxx = 1 def __setattr__(self, key, value): # 获取该线程的tid tid = threading.get_ident() # 如果DIC中存在键为tid的数据 if tid in self.DIC: self.DIC[tid][key] = value else: self.DIC[tid] = {key: value} # 创建一个Local对象 obj = Local() def run(index): # 使用Local对象保存各线程的数据 obj.xxx = index # 开启10个线程 for i in range(10): t = threading.Thread(target=run, args=(i,)) t.start() # 打印最后的值 print( obj.DIC) # {2852: {'xxx': 0}, 13520: {'xxx': 1}, 10756: {'xxx': 2}, 7488: {'xxx': 3}, 8484: {'xxx': 4}, 13924: {'xxx': 5}, 10668: {'xxx': 6}, 10252: {'xxx': 7}, 11348: {'xxx': 8}, 10736: {'xxx': 9}}
3.将Local支持协程
我们实现的Local类，达到了和threading.local一样的效果，可以隔离线程的数据。但是我们如果使用的是协程，则需要对其进行扩展。
import threading try: import greenlet # 使用协程时，将协程获取唯一标识的方法赋值给get_ident get_ident = greenlet.getcurrent print("使用协程") except Exception as e: print("使用线程") # 没有使用协程时，将线程获取唯一标识的方法赋值给get_ident get_ident = threading.get_ident class Local(object): DIC = {} # DIC字典用于存放各线程的数据，通过key来隔离 # 从DIC中线程tid对应的字典中获取值 def __getattr__(self, item): tid = get_ident() if tid in self.DIC: return self.DIC[tid].get(item) else: return None # 设置一个值，类似obj.xxx = 1 def __setattr__(self, key, value): # 获取该线程的tid tid = get_ident() # 如果DIC中存在键为tid的数据 if tid in self.DIC: self.DIC[tid][key] = value else: self.DIC[tid] = {key: value} # 创建一个Local对象 obj = Local() def run(index): # 使用Local对象保存各线程的数据 obj.xxx = index # 开启10个线程 for i in range(10): t = threading.Thread(target=run, args=(i,)) t.start() # 打印最后的值 print(obj.DIC)
要扩展支持协程，其实很简单，就是让唯一标识从线程的唯一标识替换为协程的唯一标识。
4.线程、协程数据隔离和Flask的关系
虽然threading.local和Flask没有直接的关系，但是Flask中实现了一套利用此原理的数据隔离机制。类似我们第3.节中实现的支持线程和协程的版本。
在Flask中，请求相关的数据和session等数据都是通过上下文管理的。我们可以将上下文看成一个全局的数据存放点。而我们需要对其数据进行隔离，因为Flask有可能底层会使用多线程、协程等方式来运行。
多个线程或协程会同时接受来自用户的请求，而如果不进行数据隔离，则可能数据会相互覆盖，从而导致数据错误。
二、阅读Flask上下文源码所需的一些小知识点
1.偏函数
偏函数就是利用functools.partial帮我们为某个函数传入一些固定的参数：
import functools # 原本的函数 def add(a, b): return a + b # 使用functools.partial将add函数变为偏函数 new_func = functools.partial(add, 100) # 调用偏函数，只需要传递剩下的参数 res = new_func(1) print(res) # 打印结果为101
2.类的继承关系
类的继承关系可以参考：https://www.cnblogs.com/leokale-zz/p/8472560.html 中的第7节《多继承》和第8节《新式类和经典类的区别》。
我们调用父类方法，通常有两种方式：
class Foo(Base_1, Base_2): def func(self): # 方式一，使用super调用 super(Foo,self).func() # 如果在类内部调用父类方法，可以省略super的参数。即super().func() # 方式二，直接使用父类名调用 Base_1.func(self)
第二种方式很直接，指定父类名调用，如果父类没有对应的方法，则会报错。
而第一种方式super是安装继承顺序来逐级查找被调用的方法的。
例如以下代码：
class Base_1(object): def func(self): print("Base_1.func") class Base_2(object): def func(self): print("Base_2.func") class Foo(Base_1, Base_2): def func(self): # 方式一，使用super调用 super(Foo, self).func() # 打印 Base_1.func # 方式二，直接使用父类名调用 Base_2.func(self) # 打印 Base_2.func if __name__ == '__main__': f = Foo() f.func()
Foo类继承于Base_1和Base_2类，而Base_1和Base_2类继承自object。
我们执行f.func()，可以得到打印结果super执行了Base_1的func方法。
而当我们将Base_1的func方法去掉后（只有Base_2才有func方法）：
class Base_1(object): pass class Base_2(object): def func(self): print("Base_2.func") class Foo(Base_1, Base_2): def func(self): # 方式一，使用super调用 super(Foo, self).func() # 打印 Base_2.func # 方式二，直接使用父类名调用 Base_2.func(self) # 打印 Base_2.func if __name__ == '__main__': f = Foo() f.func()
此时，super找到了Base_2的func方法。
所以，super可以执行父类的方法，但不一定会执行父类的方法。当Base_1和Base_2都没有func方法时，super还回去object类中查找func方法，结果是找不到，则报错。
我们总结一下super的查找顺序：
总结：super不是找父类，而是从左往右在多个父类中查找，如果找到了，则直接调用（前提是方法名和参数都一致，如果参数不一致，也要报错），不往后面继续查找，如果直到object都还没找到，则报错。
3.__getattr__、__setattr__以及__delattr__
在python的类中，有两个很重要的特殊方法__getattr__(self,item)和__setattr__(self,key,value)：
class Foo(object): def __getattr__(self, item): print(item) def __setattr__(self, key, value): print(key, value)
这两个方法是在使用该类对象进行"."操作的时候会被调用。例如：
if __name__ == '__main__': obj = Foo() obj.name = 'Alex' # __setattr__被调用，打印name Alex obj.age # __getattr__被调用，打印age
注意，我们平时在使用对象的"."操作时，一般不会定义这两个方法。所以默认情况下，都会找到object类的__setattr__和__getattr__来执行，而object类的这两个方法默认的功能就是设置属性和获取属性的值。
如果我们在自己定义的类中重写了这两个方法，那么就可以自己设置"."操作的行为。
考虑以下特殊场景：（构造函数的属性初始化也会触发__setattr__方法）
class Foo(object): def __init__(self): self.storage = {} def __getattr__(self, item): print(item) def __setattr__(self, key, value): print(key, value) if __name__ == '__main__': obj = Foo() obj.name = 'Alex'
在该类的构造方法中，我们初始化了一个对象属性storage。那么按照我们前面所叙述的__setattr__的触发机制。这里应该打印以下信息：
storage {}
name Alex
即，构造函数中的self.storage = {}也会触发__setattr__方法。因为self代表Foo的对象obj（由__new__(Foo)产生），然后使用"."操作设置了storage。
__delattr__：
del obj.name
__delattr__也一样，使用del删除指定的属性，但只能使用"."操作。
注意：__setattr__、__getattr__、__delattr__应该和__setitem__、__getitem__、__delitem__区分。__xxxitem__是使用字典形式操作，例如obj['name'] = Alex，del obj['name']。
具体可以参考：[Python自学] day-7 (静态方法、类方法、属性方法、类的其他、类的来源、反射、异常处理、socket) 中《类的其他内容-7节》
4.基于列表实现栈
python中使用列表实现栈结构，很简单：
class Stack(object): def __init__(self): self._list = [] def push(self, x): self._list.append(x) def pop(self): return self._list.pop() def top(self): if self._list: return self._list[-1] else: return None if __name__ == '__main__': s = Stack() s.push('Alex') # 从栈顶压入"Alex" s.push('Leo') # 从栈顶压入"Leo" print(s.pop()) # 从栈顶弹出"Leo" print(s.pop()) # 从栈顶弹出"Alex" print(s.top()) # s中已经没有数据，打印None
三、源码中的Local类（数据隔离）
在前面的第一章《上下文管理理论基础》中的第3节，我们实现了一个Local类，用于线程、协程的数据隔离。
Flask中其实也是这种实现方式，我们来看看源码是怎么样的：
try: # 使用使用协程，则使用getcurrent作为唯一标识符获取方法 from greenlet import getcurrent as get_ident except ImportError: # 如果使用线程，则使用get_ident作为唯一标识符获取方法 try: from thread import get_ident except ImportError: from _thread import get_ident class Local(object): # 用于限定向外暴露的属性 __slots__ = ("__storage__", "__ident_func__") # 构造函数，由于我们要在这个类中重写object的__setattr__方法，所以构造函数初始化属性直接调用object原始的__setattr__方法 # __storage__私有属性用于存放每个线程或协程的数据 # __ident_func__私有属性用于存放获取唯一标识符的方法（线程为get_ident，协程为getcurrent） def __init__(self): object.__setattr__(self, "__storage__", {}) object.__setattr__(self, "__ident_func__", get_ident) # 返回__storage__的迭代器 def __iter__(self): return iter(self.__storage__.items()) # def __call__(self, proxy): # """Create a proxy for a name.""" # return LocalProxy(self, proxy) # 释放整个线程或协程对应的数据 def __release_local__(self): self.__storage__.pop(self.__ident_func__(), None) # 获取数据（对应各自线程或协程） def __getattr__(self, name): try: return self.__storage__[self.__ident_func__()][name] except KeyError: raise AttributeError(name) # 设置数据（对应各自线程或协程） def __setattr__(self, name, value): ident = self.__ident_func__() storage = self.__storage__ try: storage[ident][name] = value except KeyError: storage[ident] = {name: value} # 删除线程或协程自己的数据 def __delattr__(self, name): try: del self.__storage__[self.__ident_func__()][name] except KeyError: raise AttributeError(name)
注释掉的部分，我们不用关心。特别注意标黄的部分。
我们可以发现，Flask源码中的Local类，和我们自己实现的Local类几乎相同。我们判断字典中是否存在键使用的是if else，而源码中使用的是异常捕获（可以学习借鉴）。
四、源码中的LocalStack类（利用Local实现数据隔离的栈结构）
在Local类中，我们可以使用obj.attr的方式来往字典中存放值（线程或协程隔离的）。那么，我们可以在该字典中维持一个栈：
if __name__ == '__main__': obj = Local() obj.stack = [] obj.stack.append('Alex') obj.stack.append('Leo') print(obj.stack.pop()) print(obj.stack.pop())
虽然这样可以操作字典中的stack，但不是很方便。在Flask源码中实现了一个代理类LocalStack来操作字典中的stack。源码如下：
# 操作stack结构的代理类 class LocalStack(object): # 构造函数，创建一个Local实例（里面有一个字典__storage__） def __init__(self): self._local = Local() # 释放一个线程对应的数据 def __release_local__(self): self._local.__release_local__() # 获取线程或协程唯一标识符的方法 @property def __ident_func__(self): return self._local.__ident_func__ # 设置获取唯一标识符的方法 @__ident_func__.setter def __ident_func__(self, value): object.__setattr__(self._local, "__ident_func__", value) # def __call__(self): # def _lookup(): # rv = self.top # if rv is None: # raise RuntimeError("object unbound") # return rv # # return LocalProxy(_lookup) # 往字典中的stack键对应的栈中放数据（对应调用线程） def push(self, obj): rv = getattr(self._local, "stack", None) # 如果没有stack栈 if rv is None: # 设置一个空栈，rv和self._local.stack都指向该空列表 self._local.stack = rv = [] # 往栈中放数据 rv.append(obj) return rv # 从栈顶弹出数据 def pop(self): stack = getattr(self._local, "stack", None) # 如果栈不存在，返回None if stack is None: return None elif len(stack) == 1: # 如果栈中只有一个数据，则释放该线程或协程对应的栈 release_local(self._local) # 这里等价于self._local.__release_local__() # 将栈的唯一一个数据返回 return stack[-1] else: return stack.pop() # 获取栈顶元素，如果没有则返回None @property def top(self): """The topmost item on the stack. If the stack is empty, `None` is returned. """ try: return self._local.stack[-1] except (AttributeError, IndexError): return None
同样的，不用关心注释掉的部分。
我们可以看到LocalStack类在构造函数中初始化了一个Local对象，在该对象中的字典里，每个线程或协程都对应一个空间。而这个空间里只有一个元素，就是一个栈"stack"。
而LocalStack所提供的操作，例如push、pop、top等都是针对这个栈的。
所以LocalStack提供了一个线程或协程隔离的栈结构存储空间。
五、源码中对request和session的存储
在第4章中，我们了解了Flask源码对LocalStack的实现，知道其利用LocalStack对线程或协程进行数据隔离，并在其中使用栈结构来保存数据。
那么，我们看看LocalStack是如何存储和读取用户的上下文的。
1.模拟RequestContext
参考[Python自学] Flask框架 (3) (路由、CBV、自定义正则动态路由、请求处理流程、蓝图)中的请求处理流程章节，我们知道，当用户请求到达后，Flask将用户的请求信息和session都封装到了一个RequestContext类的对象中（叫做ctx变量）。
假设简单实现一个RequestContext类，模拟源码中的RequestContext类：
# 模拟一个RequestContext类，其中包含用户请求和session class RequestContext(object): def __init__(self): self.request = 'my request' self.session = 'my session'
2.仿照源码实现ctx的存储和读取
# 模拟一个RequestContext类，其中包含用户请求和session class RequestContext(object): def __init__(self): self.request = 'my request' self.session = 'my session' if __name__ == '__main__': # 创建保存上下文实例的栈（支持数据隔离） _request_ctx_stack = LocalStack() # 当用户请求到达时，request和session被封装到RequestContext中 # 将封装好的RequestContext对象保存到栈中 _request_ctx_stack.push(RequestContext()) # 根据参数，取栈中上下文里的request或session def _lookup_req_object(arg): ctx = _request_ctx_stack.top return getattr(ctx, arg) import functools # 通过functools.partial将其封装成两个偏函数，方便使用（源码中的request和session还包了一层LocalProxy类，可以看后面LocalProxy的章节） request = functools.partial(_lookup_req_object, 'request') session = functools.partial(_lookup_req_object, 'session') # 通过request和sesison获取上下文中的数据 print(request()) print(session())
3.源码中ctx存储的过程
1）请求到达时，服务器调用Flask的__call__方法，然后在其中调用wsgi_app方法：
def __call__(self, environ, start_response): return self.wsgi_app(environ, start_response)
2）在wsgi_app方法中实例化ctx，
def wsgi_app(self, environ, start_response): # 实例化RequestContext，在其中封装Request对象，并将session初始化为空 ctx = self.request_context(environ) error = None try: try: # 调用ctx的push方法 ctx.push() ... ...
3）ctx.push()中，将自己压入栈
def push(self): ... ... # 将自己（ctx对象）压入栈_request_ctx_stack _request_ctx_stack.push(self) ... ...
4）_request_ctx_stack是LocalStack的实例，该实例全局定义的
# globals.py # context locals _request_ctx_stack = LocalStack()
4.ctx存储过程图
5.session的存储过程
总体来说，由于session和request都被封装在ctx对象中（RequestContext类的对象）。所以存储的过程是一样的。
但是session和request的不同点在于，数据获取的时机不同。
对于request：我们在wsgi_app()函数中，创建ctx对象的时候，就将environ作为参数传递进去，environ被封装成Request对象，然后放在ctx对象中。
对于session：wsgi_app()函数创建好ctx的时候，session只是被初始化为空，我们看RequestContext的构造函数源码：
class RequestContext(object): def __init__(self, app, environ, request=None, session=None): self.app = app if request is None: request = app.request_class(environ) self.request = request self.url_adapter = None try: self.url_adapter = app.create_url_adapter(self.request) except HTTPException as e: self.request.routing_exception = e self.flashes = None self.session = session ... ...
在ctx.push()中，ctx被压入到栈之后，对session进行了赋值：
def push(self): ... ... _request_ctx_stack.push(self) ... ... if self.session is None: session_interface = self.app.session_interface self.session = session_interface.open_session(self.app, self.request) if self.session is None: self.session = session_interface.make_null_session(self.app) ...
源码中的app.session_interface实际上是 SecureCookieSessionInterface类，session_interface是其一个对象，然后调用其中的open_session来对session进行赋值。
通过open_session源码，可以大致了解session的赋值过程：
def open_session(self, app, request): s = self.get_signing_serializer(app) if s is None: return None # 从cookie中获取名为session的数据（默认名为session） val = request.cookies.get(app.session_cookie_name) # 如果没有session，则session为空的SecureCookieSession对象 if not val: return self.session_class() max_age = total_seconds(app.permanent_session_lifetime) try: # 对拿到的数据做反序列化 data = s.loads(val, max_age=max_age) return self.session_class(data) except BadSignature: return self.session_class()
六、源码中的LocalProxy
1.LocalProxy类工作流程
在第五章的2.仿照源码实现ctx的存储和读取 中可以看到，我们使用functools.partial制造了两个偏函数，用于从ctx中获取request和session。如下代码：
request = functools.partial(_lookup_req_object, 'request') session = functools.partial(_lookup_req_object, 'session') # 通过request和sesison获取上下文中的数据 print(request()) print(session())
这是我们仿造源码实现的功能。真正的源码还对偏函数进行了一层封装，即使用LocalProxy类，
current_app = LocalProxy(_find_app) request = LocalProxy(partial(_lookup_req_object, "request")) session = LocalProxy(partial(_lookup_req_object, "session")) g = LocalProxy(partial(_lookup_app_object, "g"))
其中的current_app和g我们将在后面的章节中讨论。
LocalPorxy的源码如下：
class LocalProxy(object): # 构造函数，将request或session偏函数传入，即local参数 def __init__(self, local, name=None): # 将其保存到self.__local中 object.__setattr__(self, "_LocalProxy__local", local) ... def _get_current_object(self): # 返回self.__local()，即返回request或session对象 if not hasattr(self.__local, "__release_local__"): return self.__local() ... # 当我们使用request.xxx的时候就会从request对象中帮我们取值 def __getattr__(self, name): if name == "__members__": return dir(self._get_current_object()) return getattr(self._get_current_object(), name) # 当我们使用request['xxx']取值时，帮我们从request对象中取值 __getitem__ = lambda x, i: x._get_current_object()[i] ... ...
从源码中，我们可以看到，self.__local（self._LocalProxy__local）就是request和session的偏函数，所以self.__local()得到的就是request和session对象。
LocalProxy类中实现了__getattr__、__setattr__、__getitem__、__setitem__等方法，用于帮我们从request和session中取值。
所以，综上所述，LocalProxy就是帮我们从Request和Session对象中取值的中间代理，只是为了让我们取值更加方便。
2.修改后的ctx存储过程图
图中多了LocalProxy部分和偏函数部分。
在偏函数中，通过_lookup_req_object获取request和session对应的对象（ctx=_request_ctx_stack.top()）。
在LocalProxy中通过__getattr__等特殊方法来获取request和session对象中的值。
七、flask-session组件
在第五章对session工作流程的解析中，我们知道从加密cookie中获取session，以及将session写到加密cookie中。都是使用的一个叫做SecureCookieSessionInterface的类。
那么，我们如果想将session存储到redis数据库中，则只需要使用其他的类来替换SecureCookieSessionInterface类即可。
1.安装flask-session
pip install flask-session
2.导入flask-session
from flask_session import Session
以前的老版本可能是：
from flask.ext.session import Session
3.使用flask-session
# 在Flask的全局配置中指定使用redis来保存session app.config['SESSION_TYPE'] = 'redis' # 然后将app对象传递给Session，在里面原本的app.session_interface = SecureCookieSessionInterface()会被替换为RedisSessionInterface() Session(app)
我们解析以下Session类的源码：
import os # 导入Session支持的各种Interface，例如redis、memcache、文件系统、MongoDB、SQL from .sessions import NullSessionInterface, RedisSessionInterface, MemcachedSessionInterface, FileSystemSessionInterface, MongoDBSessionInterface, SqlAlchemySessionInterface class Session(object): # 构造函数，app对象被传入 def __init__(self, app=None): self.app = app # 如果app不为空 if app is not None: self.init_app(app) # 调用init_app(app) def init_app(self, app): # 在这里替换app.session_interface=SecureCookieSessionInterface() app.session_interface = self._get_interface(app) # 在这个方法中，根据我们指定的SESSION_TYPE来返回对应的Interface类 def _get_interface(self, app): # 从全局配置复制一份 config = app.config.copy() # 注意，这里都是使用的setdefault，即配置不存在才设置 config.setdefault('SESSION_TYPE', 'null') config.setdefault('SESSION_PERMANENT', True) config.setdefault('SESSION_USE_SIGNER', False) config.setdefault('SESSION_KEY_PREFIX', 'session:') config.setdefault('SESSION_REDIS', None) config.setdefault('SESSION_MEMCACHED', None) config.setdefault('SESSION_FILE_DIR', os.path.join(os.getcwd(), 'flask_session')) config.setdefault('SESSION_FILE_THRESHOLD', 500) config.setdefault('SESSION_FILE_MODE', 384) config.setdefault('SESSION_MONGODB', None) config.setdefault('SESSION_MONGODB_DB', 'flask_session') config.setdefault('SESSION_MONGODB_COLLECT', 'sessions') config.setdefault('SESSION_SQLALCHEMY', None) config.setdefault('SESSION_SQLALCHEMY_TABLE', 'sessions') # 如果我们在全局配置中设置了SESSION_TYPE为redis，则返回RedisSessionInterface类 if config['SESSION_TYPE'] == 'redis': session_interface = RedisSessionInterface( config['SESSION_REDIS'], config['SESSION_KEY_PREFIX'], config['SESSION_USE_SIGNER'], config['SESSION_PERMANENT']) # 如果指定使用Memcached，则返回MemcachedSessioninterface类 elif config['SESSION_TYPE'] == 'memcached': session_interface = MemcachedSessionInterface( config['SESSION_MEMCACHED'], config['SESSION_KEY_PREFIX'], config['SESSION_USE_SIGNER'], config['SESSION_PERMANENT']) # 如果指定文件系统，则返回FileSystemSessionInterface类 elif config['SESSION_TYPE'] == 'filesystem': session_interface = FileSystemSessionInterface( config['SESSION_FILE_DIR'], config['SESSION_FILE_THRESHOLD'], config['SESSION_FILE_MODE'], config['SESSION_KEY_PREFIX'], config['SESSION_USE_SIGNER'], config['SESSION_PERMANENT']) # Mongodb，返回MongoDBSessionInterface类 elif config['SESSION_TYPE'] == 'mongodb': session_interface = MongoDBSessionInterface( config['SESSION_MONGODB'], config['SESSION_MONGODB_DB'], config['SESSION_MONGODB_COLLECT'], config['SESSION_KEY_PREFIX'], config['SESSION_USE_SIGNER'], config['SESSION_PERMANENT']) # SqlAlchemy，返回SqlAlchemySessionInterface类 elif config['SESSION_TYPE'] == 'sqlalchemy': session_interface = SqlAlchemySessionInterface( app, config['SESSION_SQLALCHEMY'], config['SESSION_SQLALCHEMY_TABLE'], config['SESSION_KEY_PREFIX'], config['SESSION_USE_SIGNER'], config['SESSION_PERMANENT']) else: # 如果都不符合，则返回NullSessionInterface类 session_interface = NullSessionInterface() return session_interface
我们可以看到，最核心的过程就是根据全局配置中指定的SESSION_TYPE类返回对应的Interface类，来代替默认的加密cookie。
4.redis的配置
如果我们在全局配置中指定了使用redis，那么肯定需要给Flask指定redis的IP、端口等信息。
我们首先观察RedisSessionInterface类构造函数的源码：
def __init__(self, redis, key_prefix, use_signer=False, permanent=True): if redis is None: from redis import Redis redis = Redis() self.redis = redis self.key_prefix = key_prefix self.use_signer = use_signer self.permanent = permanent
可以看到，RedisSessionInterface接收4个参数，第一个参数是redis实例，第二个参数是session存到redis中名字的前缀。第三个参数是否使用加密盐（对sessionid进行加密），第四个参数
此时，我们再看Session类源码中，使用RedisSessionInterface的时候传入的四个参数对应的全局配置项：
if config['SESSION_TYPE'] == 'redis': session_interface = RedisSessionInterface( config['SESSION_REDIS'], config['SESSION_KEY_PREFIX'], config['SESSION_USE_SIGNER'], config['SESSION_PERMANENT'])
从上述代码可以看出全局配置项SESSION_REDIS应该配置一个redis实例，SESSION_KEY_PREFIX应该配置一个前缀字符串。
所以，我们应该这样配置使用redis：
from flask import Flask from flask_session import Session import redis
app = Flask(__name__) app.config['SESSION_TYPE'] = 'redis' app.config['SESSION_REDIS'] = redis.Redis(host='111.111.111.111',port=6379,password='123456') Session(app) if __name__ == '__main__': app.run()
5.如何从redis中读取session
我们查看RedisSessionInterface类中的open_session方法源码：
def open_session(self, app, request): # 先从cookie中去拿session的id sid = request.cookies.get(app.session_cookie_name) # 如果sid为空（例如第一次请求） if not sid: # 生成一个sid，格式是uuid4 sid = self._generate_sid() # 返回一个空的session return self.session_class(sid=sid, permanent=self.permanent) # 是否使用加密盐 if self.use_signer: # 获取app中设置的加密盐字符串 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') # 根据获取到的sid加上前缀，从redis中获取session的值 val = self.redis.get(self.key_prefix + sid) # 如果值不为空，则发反序列化，然后返回RedisSession对象（其中包含session数据和sid） if val is not None: try: data = self.serializer.loads(val) 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)
如果是第一次请求，则cookie没有带sessionid，所以会新建一个随机字符串（uuid4）作为sessionid，并且创建一个空的session对象。
如果是第二次请求，则cookie中带着sessionid，则从cookie中获取该sessionid。如果使用了加密盐，则使用盐解密。然后得到解密后的sid，加上我们指定的前缀字符串作为key，从redis中获取对应的session数据。如果获取到数据，则反序列化，并将其封装成session对象返回。
6.如何将session保存到redis
当用户请求处理过程中，对session进行了修改（例如保存了一个值在session中）。请求处理完毕后，在返回响应之前，会在RedisSessionInterface类中的save_session方法中将修改后的session保存到redis中，并且将sessionid设置到cookie中。
我们看一下save_session方法的源码：
def save_session(self, app, session, response): domain = self.get_cookie_domain(app) path = self.get_cookie_path(app) # 删除session if not session: if session.modified: self.redis.delete(self.key_prefix + session.sid) response.delete_cookie(app.session_cookie_name, domain=domain, path=path) return 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中的session加上默认超时时间（31天） 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 # 将session的id写到响应的cookie中 response.set_cookie(app.session_cookie_name, session_id, expires=expires, httponly=httponly, domain=domain, path=path, secure=secure)
当参数中session为空时，执行删除session操作，从redis中删除对应session数据，主要用于当用户退出登录时。
当session不为空时，首先序列化session字典（对象.__dict__转换为字典）。然后将其存入redis，并且设置超时时间为默认的31天（可在全局配置中修改）。
如果使用了加密盐，则对sid进行加密，然后设置到response的cookie中，返回给用户。
八、app和g上下文
在前面的章节，我们了解了request+session形成的上下文管理流程。流程中使用了一个Local、一个LocalStack、两个LocalProxy，其中Local用于维护一个线程或协程隔离的字典，用于存放按线程或协程唯一标识符作为键的数据。
然后，LocalStack用于在Local的字典中维护一个栈结构，每个线程或协程对应一个栈，而用户的请求和session组成的ctx（上下文实例）就存放在这个栈中。我们通过LocalStack将请求对应的ctx压入和弹出，并且通过LocalProxy来方便的获取ctx中包含的Request和Session对象中的值。
LocalProxy为Flask用户提供的方便的request和session操作接口。
1.app和g的上下文
除了我们已经了解的request+session上下文，Flask中还有一组上下文管理流程，他们也使用一个Local、一个LocalStack以及两个LocalProxy。该上下文用于管理Flask的对象app以及g。
我们首先看以下全局对象的源码(globals.py)：
# context locals # request+session的LocalStack，其中维护了一个Local对象 _request_ctx_stack = LocalStack() # app和g的LocalStack，其中也维护了一个Local对象 _app_ctx_stack = LocalStack() # app使用的LocalProxy current_app = LocalProxy(_find_app) request = LocalProxy(partial(_lookup_req_object, "request")) session = LocalProxy(partial(_lookup_req_object, "session")) # g使用的LocalProxy g = LocalProxy(partial(_lookup_app_object, "g"))
2.app和g上下文流程
app和g的上下文存储流程和request、session的存储流程相似。
request和session的上下文是在app.wsgi_app方法中创建的，然后调用了ctx.push将其压入对应的LocalStack。
但是app和g的上下文是在ctx.push方法中创建的，而且先于ctx压入LocalStack之前被压入自己对应的LocalStack。
源码：
def push(self): ... ... # 这里先从app上下文管理的LocalStack中去获取app_ctx app_ctx = _app_ctx_stack.top # 如果获取的app_ctx为空或者其中的app不是当前app if app_ctx is None or app_ctx.app != self.app: # 则新创建一个AppContext对象。app_ctx = AppContext()对象 app_ctx = self.app.app_context() # _app_ctx_stack.push(self) 将self，即app_ctx放入_app_ctx_stack（LocalStack） app_ctx.push() self._implicit_app_ctx_stack.append(app_ctx) else: self._implicit_app_ctx_stack.append(None) if hasattr(sys, "exc_clear"): sys.exc_clear() # 然后将ctx放入_request_ctx_stack（另一个LocalStack) _request_ctx_stack.push(self) ... ...
源码中，蓝色部分是ctx压入request、session对应的LocalStack。
黄色部分是app_ctx压入app、g对应的LocalStack。
3.使用app和g
如何使用保存在LocalStack中的app和g，这和使用request以及session是一样的，直接导入使用即可（他们是在globals.py中定义的全局变量）。
# 直接导入并使用 from flask import Flask,current_app,g
其中current_app就是app，current_app和g都对应一个LocalProxy对象。但是使用的话，像操作app本身一样操作即可。
4.g是什么
由于g和session的处理流程很相似，我们可以对他们进行对比：
1）session中的值是每次请求到才从加密cookie或redis中获取的。而g并不获取值。
2）响应返回的时候，session中的值被重新写入cookie或redis，然后session被销毁。当然g也会被销毁。
3）session是线程隔离的。g也是线程隔离的。
我们可以得出结论。g和session实际上的生命周期是一样的，都是一个请求的生命周期。
g和全局变量的对比：
1）普通的全局变量时在程序启动时就定义的，可以在任何时候任何地方直接使用。
2）g保存在全局变量Local对象中，但是其被线程唯一标识符所隔离，并且根据请求--->响应的周期进行创建和销毁。
所以得出结论，g只是针对某个请求的生命周期中的全局变量。在这个请求的生命周期内，可以在不同的地方存入和取出值。
5.g有什么用
当在一个请求的生命周期中，我们可以用g作为存放公共变量的地方。
例如使用g可以仿造出一个session：
@lg.before_request def before(): print('before') g.session = {} g.session['name'] = 'Leo' # 使用蓝图来调用装饰器（而不是使用app） @lg.route('/login', methods=['GET', 'POST']) def login(): if request.method == 'GET': print(g.session.get('name')) return "login"
因为before函数和login函数都在一个请求生命周期。但是对于每个请求，g中的内容是不一样的。
##