python框架之Flask(4)-上下文管理

知识储备

偏函数

• 作用

  偏函数，帮助开发者自动传递参数。

• 使用

  import functools
  
  def index(a1, a2):
      return a1 + a2
  
  # 原来的调用方式
  # ret = index(1,23)
  # print(ret)
  
  # 偏函数，帮助开发者自动传递参数
  new_index = functools.partial(index, 666)
  ret = new_index(1)
  ret = new_index(1)
  print(ret)

  例：

super

class Base(object):

    def func(self):
        super(Base, self).func()
        print('Base.func')

class Bar(object):
    def func(self):
        print('Bar.func')

class Foo(Base, Bar):
    pass

# 示例一
obj = Foo()  # Bar.func
obj.func()  # Base.func
print(Foo.__mro__)  # (<class '__main__.Foo'>, <class '__main__.Base'>, <class '__main__.Bar'>, <class 'object'>)

# 示例二
obj = Base()
obj.func()  # AttributeError: 'super' object has no attribute 'func'

例：

super 在我们心里可能都默认它是用来执行父类方法，但在 python 中，这句话只在单继承时成立。看输出结果，其实 super 的执行顺序是根据执行对象 __mro__ 属性的结果顺序来的。

面向对象的特殊方法

class Foo(object):
    def __init__(self):
        # 执行这行时会报错： AttributeError: 'Foo' object has no attribute 'storage'
        # 因为 self.storage 的赋值就是由 __setattr__ 方法完成的，而在 __setattr__ 方法中直接使用 self.storage ，并没有赋值操作，肯定会因为没有这个属性报错
        # self.storage = {}
        object.__setattr__(self, 'storage', {})

    def __setattr__(self, key, value):
        print(key, value, self.storage)

obj = Foo()
obj.v = 123
# v 123 {}

例：

基于列表实现栈

class Stack(object):

    def __init__(self):
        self.data = []

    def push(self, val):
        self.data.append(val)

    def pop(self):
        return self.data.pop()

    def top(self):
        return self.data[-1]

_stack = Stack()

_stack.push('v1')
_stack.push('v2')

print(_stack.pop())
print(_stack.pop())

例：

threading.local

• 作用

  为每个线程创建一个独立的空间，使得线程对自己空间中的数据进行操作（数据隔离）。

• 示例

  看如下示例：

  import threading
  import time
  
  v = 0
  
  def task(i):
      global v;
      v = i
      time.sleep(1)
      print(v)
  
  for i in range(10):
      t = threading.Thread(target=task, args=(i,))
      t.start()
  
  '''
  9
  9
  9
  9
  9
  9
  9
  9
  9
  9
  '''

  例：

  当通过多线程对同一份数据进行修改时，会出现如上覆盖的现象。以往我们解决这种问题一般时通过加锁，而 threading.local 其实也可以为我们解决这种问题，如下：

  import threading
  import time
  from threading import local
  
  obj = local()
  
  def task(i):
      obj.v = i
      time.sleep(1)
      print(obj.v)
  
  for i in range(10):
      t = threading.Thread(target=task, args=(i,))
      t.start()
  
  '''
  0
  5
  3
  1
  6
  2
  4
  9
  7
  8
  '''

  例：

  可以看到并没有发生值覆盖的问题。

• 原理

  修改上述第一个示例如下：

  import threading
  import time
  
  dic = {}
  
  def task(i):
      # 获取当前线程的唯一标记
      ident = threading.get_ident()
  
      if ident in dic:
          dic[ident]['v'] = i
      else:
          dic[ident] = {'v': i}
      time.sleep(1)
      print(dic[ident]['v'])
  
  for i in range(10):
      t = threading.Thread(target=task, args=(i,))
      t.start()
  
  '''
  0
  1
  3
  5
  2
  4
  9
  8
  6
  7
  '''

  例：第一版

  其实原理很简单，一个字典，通过获取正执行线程的唯一标记作为键，通过这个键就能够区分开线程隔离保存数据。

  同理，按上述原理，我们也可以将其改为根据协程隔离数据：

  import threading
  import greenlet
  import time
  
  dic = {}
  
  def task(i):
      # 获取当前协程的唯一标记
      ident = greenlet.getcurrent()
      if ident in dic:
          dic[ident]['v'] = i
      else:
          dic[ident] = {'v': i}
      time.sleep(1)
      print(dic[ident]['v'])
  
  for i in range(10):
      t = threading.Thread(target=task, args=(i,))
      t.start()
  
  '''
  0
  1
  3
  5
  2
  4
  9
  8
  6
  7
  '''

  例：第二版

  还可以将其进行对象的封装，使其的使用更接近于 threading.local ，如下：

  import time
  import threading
  
  try:
      import greenlet
  
      get_ident = greenlet.getcurrent
  except Exception as e:
      get_ident = threading.get_ident
  
  class Local(object):
      dic = {}
  
      def __getattr__(self, item):
          ident = get_ident()
          if ident in self.dic:
              return self.dic[ident].get(item)
          return None
  
      def __setattr__(self, key, value):
          ident = get_ident()
          if ident in self.dic:
              self.dic[ident][key] = value
          else:
              self.dic[ident] = {key: value}
  
  obj = Local()
  
  def task(i):
      obj.v = i
      time.sleep(1)
      print(obj.v)
  
  for i in range(10):
      t = threading.Thread(target=task, args=(i,))
      t.start()
  
  '''
  5
  3
  1
  6
  4
  2
  0
  9
  7
  8
  '''

  例：终极版

localstack

import functools

try:
    from greenlet import getcurrent as get_ident
except:
    from threading import get_ident

class Local(object):
    __slots__ = ('__storage__', '__ident_func__')

    def __init__(self):
        object.__setattr__(self, '__storage__', {})
        object.__setattr__(self, '__ident_func__', get_ident)

    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)

class LocalStack(object):
    def __init__(self):
        self._local = Local()

    def push(self, value):
        rv = getattr(self._local, 'stack', None)
        if rv is None:
            self._local.stack = rv = []
        rv.append(value)
        return rv

    def pop(self):
        stack = getattr(self._local, 'stack', None)
        if stack is None:
            return None
        elif len(stack) == 1:
            return stack[-1]
        else:
            return stack.pop()

    def top(self):
        try:
            return self._local.stack[-1]
        except (AttributeError, IndexError):
            return None

stack = LocalStack()
stack.push('aaa')
print(stack.pop())

例：

以上综合应用

通过以上知识来模拟 Flask 中 session 和 request 的存储。

import functools

try:
    from greenlet import getcurrent as get_ident
except:
    from threading import get_ident

class Local(object):
    __slots__ = ('__storage__', '__ident_func__')

    def __init__(self):
        object.__setattr__(self, '__storage__', {})
        object.__setattr__(self, '__ident_func__', get_ident)

    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)

class LocalStack(object):
    def __init__(self):
        self._local = Local()

    def push(self, value):
        rv = getattr(self._local, 'stack', None)
        if rv is None:
            self._local.stack = rv = []
        rv.append(value)
        return rv

    def pop(self):
        stack = getattr(self._local, 'stack', None)
        if stack is None:
            return None
        elif len(stack) == 1:
            return stack[-1]
        else:
            return stack.pop()

    def top(self):
        try:
            return self._local.stack[-1]
        except (AttributeError, IndexError):
            return None

class RequestContext(object):
    def __init__(self):
        self.request = 'request'
        self.session = 'session'

_request_ctx_stack = LocalStack()

_request_ctx_stack.push(RequestContext())

def _lookup_req_object(arg):
    ctx = _request_ctx_stack.top()
    return getattr(ctx, arg)

request = functools.partial(_lookup_req_object, 'request')
session = functools.partial(_lookup_req_object, 'session')

print(request())
print(session())

例：

上下文管理

request上下文

之前说Session原理时，在执行 flask.app.Flask.wsgi_app 方法时其中有一个 ctx 变量，如下：

 def wsgi_app(self, environ, start_response):
     '''
     获取environ并对其进行封装
     从environ中获取名为session的cookie，解密并反序列化
     放入请求上下文
     '''
     ctx = self.request_context(environ)
     error = None
     try:
         try:
             ctx.push()
             '''
             执行视图函数
             '''
             response = self.full_dispatch_request()
         except Exception as e:
             error = e
             response = self.handle_exception(e)
         except:
             error = sys.exc_info()[1]
             raise
         return response(environ, start_response)
     finally:
         if self.should_ignore_error(error):
             error = None
         '''
         获取session，解密并序列化，写入cookie
         清空请求上下文
         '''
         ctx.auto_pop(error)

flask.app.Flask.wsgi_app

一个网站程序是可能有多个用户也就是多个线程同时访问的，之所以上面会提 threading.local 知识，正是因为 ctx 就是以这种方式保存的。看 ctx.push 方法：

 def push(self):
     top = _request_ctx_stack.top
     if top is not None and top.preserved:
         top.pop(top._preserved_exc)

     app_ctx = _app_ctx_stack.top
     if app_ctx is None or app_ctx.app != self.app:
         app_ctx = self.app.app_context()
         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()

     _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)

flask.ctx.RequestContext.push

直接看 17 行： _request_ctx_stack.push(self) ，这里这个 self 指的就是当前保存了 request 和 session 信息的 ctx 对象。再进到这个 push 方法：

 def push(self, obj):
     rv = getattr(self._local, 'stack', None)
     if rv is None:
         self._local.stack = rv = []
     rv.append(obj)
     return rv

werkzeug.local.LocalStack.push

可以看到，从 self._local 中取一个名为 'stack' 的属性，如果为空，则创建一个空列表，并将 obj （这里也就是传入进来的 ctx ）加入列表。再看一下这个 self._local ：

 class Local(object):
     __slots__ = ('__storage__', '__ident_func__')

     def __init__(self):
         object.__setattr__(self, '__storage__', {})
         object.__setattr__(self, '__ident_func__', get_ident)

     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)

werkzeug.local.Local

查看发现这个 self._local 就是之前提到的 threading.local 中第三个版本。到这里一切明了，Flask 也是通过这种方式来完成线程之间的数据隔离，而 _request_ctx_stack 就是维护在 werkzeug.local.Local 对象中一个键为 'stack' 的列表，Flask 将 request 和 session 信息通过 flask.ctx.RequestContext 进行封装，再将其维护在这个列表中，这就是 Flask 的请求上下文管理。

app上下文

再回到 flask.ctx.RequestContext.push 中，回头看 8、9 行，查看 self.app.app_context 方法：

 def app_context(self):
     return AppContext(self)

flask.app.Flask.app_context

可以看到它返回一个 AppContext 实例，再看到 AppContext ：

 class AppContext(object):
     def __init__(self, app):
         self.app = app
         self.url_adapter = app.create_url_adapter(None)
         self.g = app.app_ctx_globals_class()

         self._refcnt = 0

     def push(self):
         self._refcnt += 1
         if hasattr(sys, 'exc_clear'):
             sys.exc_clear()
         _app_ctx_stack.push(self)
         appcontext_pushed.send(self.app)

     def pop(self, exc=_sentinel):
         try:
             self._refcnt -= 1
             if self._refcnt <= 0:
                 if exc is _sentinel:
                     exc = sys.exc_info()[1]
                 self.app.do_teardown_appcontext(exc)
         finally:
             rv = _app_ctx_stack.pop()
         assert rv is self, 'Popped wrong app context.  (%r instead of %r)' \
             % (rv, self)
         appcontext_popped.send(self.app)

     def __enter__(self):
         self.push()
         return self

     def __exit__(self, exc_type, exc_value, tb):
         self.pop(exc_value)

         if BROKEN_PYPY_CTXMGR_EXIT and exc_type is not None:
             reraise(exc_type, exc_value, tb)

flask.ctx.AppContext

AppContext 对象中封装了 app 和一个 g 属性，最后把它赋值给 flask.ctx.RequestContext.push 中第 8 行的 app_ctx 变量，在第 9 行又执行了这个变量的 push 方法：

 def push(self):
     self._refcnt += 1
     if hasattr(sys, 'exc_clear'):
         sys.exc_clear()
     _app_ctx_stack.push(self)
     appcontext_pushed.send(self.app)

flask.ctx.AppContext.push

再执行第 5 行的 _app_ctx_stack.push(self) 方法，查看 _app_ctx_stack ：

 _request_ctx_stack = LocalStack()
 _app_ctx_stack = LocalStack()
 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'))

flask.globals

可以看到， _app_ctx_stack 和请求上下文中 _request_ctx_stack 一样，也是一个 LocalStack 对象，它的 push 方法也就对应上面的 werkzeug.local.LocalStack.push 块。所以这里也就是将封装了 app 和 g 的 flask.ctx.AppContext 实例 app_ctx 放入到 werkzeug.local.Local 管理的字典中。

LocalProxy

上面所说的都是上下文的存放原理，而我们实际使用时只需要在视图函数中导入响应对象即可。比如取 request.method ：

from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def index():
    method = request.method
    return 'index'

而这里使用的 request 正是上面 flask.globals 中的：

request = LocalProxy(partial(_lookup_req_object, 'request'))

可以看到给 LocalProxy 类传入一个偏函数以实例化， request.method 实际上就是找 LocalProxy 类中的 method ，查看 LocalProxy 类：

 @implements_bool
 class LocalProxy(object):
     __slots__ = ('__local', '__dict__', '__name__', '__wrapped__')

     def __init__(self, local, name=None):
         object.__setattr__(self, '_LocalProxy__local', local)
         object.__setattr__(self, '__name__', name)
         if callable(local) and not hasattr(local, '__release_local__'):
             object.__setattr__(self, '__wrapped__', local)

     def _get_current_object(self):
         if not hasattr(self.__local, '__release_local__'):
             return self.__local()
         try:
             return getattr(self.__local, self.__name__)
         except AttributeError:
             raise RuntimeError('no object bound to %s' % self.__name__)

     @property
     def __dict__(self):
         try:
             return self._get_current_object().__dict__
         except RuntimeError:
             raise AttributeError('__dict__')

     def __repr__(self):
         try:
             obj = self._get_current_object()
         except RuntimeError:
             return '<%s unbound>' % self.__class__.__name__
         return repr(obj)

     def __bool__(self):
         try:
             return bool(self._get_current_object())
         except RuntimeError:
             return False

     def __unicode__(self):
         try:
             return unicode(self._get_current_object())  # noqa
         except RuntimeError:
             return repr(self)

     def __dir__(self):
         try:
             return dir(self._get_current_object())
         except RuntimeError:
             return []

     def __getattr__(self, name):
         if name == '__members__':
             return dir(self._get_current_object())
         return getattr(self._get_current_object(), name)

     def __setitem__(self, key, value):
         self._get_current_object()[key] = value

     def __delitem__(self, key):
         del self._get_current_object()[key]

     if PY2:
         __getslice__ = lambda x, i, j: x._get_current_object()[i:j]

         def __setslice__(self, i, j, seq):
             self._get_current_object()[i:j] = seq

         def __delslice__(self, i, j):
             del self._get_current_object()[i:j]

     __setattr__ = lambda x, n, v: setattr(x._get_current_object(), n, v)
     __delattr__ = lambda x, n: delattr(x._get_current_object(), n)
     __str__ = lambda x: str(x._get_current_object())
     __lt__ = lambda x, o: x._get_current_object() < o
     __le__ = lambda x, o: x._get_current_object() <= o
     __eq__ = lambda x, o: x._get_current_object() == o
     __ne__ = lambda x, o: x._get_current_object() != o
     __gt__ = lambda x, o: x._get_current_object() > o
     __ge__ = lambda x, o: x._get_current_object() >= o
     __cmp__ = lambda x, o: cmp(x._get_current_object(), o)  # noqa
     __hash__ = lambda x: hash(x._get_current_object())
     __call__ = lambda x, *a, **kw: x._get_current_object()(*a, **kw)
     __len__ = lambda x: len(x._get_current_object())
     __getitem__ = lambda x, i: x._get_current_object()[i]
     __iter__ = lambda x: iter(x._get_current_object())
     __contains__ = lambda x, i: i in x._get_current_object()
     __add__ = lambda x, o: x._get_current_object() + o
     __sub__ = lambda x, o: x._get_current_object() - o
     __mul__ = lambda x, o: x._get_current_object() * o
     __floordiv__ = lambda x, o: x._get_current_object() // o
     __mod__ = lambda x, o: x._get_current_object() % o
     __divmod__ = lambda x, o: x._get_current_object().__divmod__(o)
     __pow__ = lambda x, o: x._get_current_object() ** o
     __lshift__ = lambda x, o: x._get_current_object() << o
     __rshift__ = lambda x, o: x._get_current_object() >> o
     __and__ = lambda x, o: x._get_current_object() & o
     __xor__ = lambda x, o: x._get_current_object() ^ o
     __or__ = lambda x, o: x._get_current_object() | o
     __div__ = lambda x, o: x._get_current_object().__div__(o)
     __truediv__ = lambda x, o: x._get_current_object().__truediv__(o)
     __neg__ = lambda x: -(x._get_current_object())
     __pos__ = lambda x: +(x._get_current_object())
     __abs__ = lambda x: abs(x._get_current_object())
     __invert__ = lambda x: ~(x._get_current_object())
     __complex__ = lambda x: complex(x._get_current_object())
     __int__ = lambda x: int(x._get_current_object())
     __long__ = lambda x: long(x._get_current_object())  # noqa
     __float__ = lambda x: float(x._get_current_object())
     __oct__ = lambda x: oct(x._get_current_object())
     __hex__ = lambda x: hex(x._get_current_object())
     __index__ = lambda x: x._get_current_object().__index__()
     __coerce__ = lambda x, o: x._get_current_object().__coerce__(x, o)
     __enter__ = lambda x: x._get_current_object().__enter__()
     __exit__ = lambda x, *a, **kw: x._get_current_object().__exit__(*a, **kw)
     __radd__ = lambda x, o: o + x._get_current_object()
     __rsub__ = lambda x, o: o - x._get_current_object()
     __rmul__ = lambda x, o: o * x._get_current_object()
     __rdiv__ = lambda x, o: o / x._get_current_object()
     if PY2:
         __rtruediv__ = lambda x, o: x._get_current_object().__rtruediv__(o)
     else:
         __rtruediv__ = __rdiv__
     __rfloordiv__ = lambda x, o: o // x._get_current_object()
     __rmod__ = lambda x, o: o % x._get_current_object()
     __rdivmod__ = lambda x, o: x._get_current_object().__rdivmod__(o)
     __copy__ = lambda x: copy.copy(x._get_current_object())
     __deepcopy__ = lambda x, memo: copy.deepcopy(x._get_current_object(), memo)

werkzeug.local.LocalProxy

可以看到这个类中并没有 method 属性，所以此时会执行 54 行也就是它的 __getattr__ 方法，它的返回值 self._get_current_object 中名为 name 变量值对应的属性，而此时这个 name 就等于 'method' ，我们此时就要看看 self._get_current_object 返回的是什么了。看 11-17 行，它的返回值是 self.__local() 的执行结果，而 self.__local 实际上就是上面传入的偏函数 partial(_lookup_req_object, 'request') ，查看这个偏函数：

 def _lookup_req_object(name):

     top = _request_ctx_stack.top
     if top is None:
         raise RuntimeError(_request_ctx_err_msg)
     return getattr(top, name)

flask.globals._lookup_req_object

此时执行这个偏函数， name 的值就为 'request' ，而 _request_ctx_stack.top 的返回值正是我们之前在 flask.app.Flask.wsgi_app 中看到的存入了封装了 request 和 session 的 ctx 变量，再从中取到名为 request 的属性返回，即 werkzeug.local.LocalProxy 中 54 行 self._get_current_object() 拿到的就是这个 request ，从中再取名为 method 的属性返回给视图函数，使用 session 的流程也是如此。取 app 上下文中内容也是如此，只不过它使用的上下文栈是 _app_ctx_stack 。

流程图

aaarticlea/png;base64,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" alt="" width="1365" height="937" />