flask源码(3)__上下文栈实现

╰半橙微兮° 2022-05-28 07:28 173阅读 0赞

## 前景 ##

昨天看了WSGI在app.py中的分发request给视图函数，今天来看看栈实现

## 上下文 ##

上下文这个名字是一个比较生涩的词，初学的我表示一脸懵逼，用网上的一段话来说

> 每一段程序都有很多外部变量。只有像Add这种简单的函数才是没有外部变量的。一旦你的一段程序有了外部变量，这段程序就不完整，不能独立运行。你为了使他们运行，就要给所有的外部变量一个一个写一些值进去。这些值的集合就叫上下文。 – vzch

自己通俗一下理解就是，一段程序需要从别的地方获取变量的值，这些变量是外部变量，不是自身的。

比如，在 flask 中，视图函数需要知道它执行情况的请求信息（请求的 url，参数，方法等）以及应用信息（应用中初始化的数据库等），才能够正确运行。

最直观地做法是把这些信息封装成一个对象，作为参数传递给视图函数。但是这样的话，所有的视图函数都需要添加对应的参数，即使该函数内部并没有使用到它。

## 上下文栈 ##

上下文都定义在globals.py里面

def _lookup_req_object(name):
        # 请求上下文的栈顶对象
        top = _request_ctx_stack.top
        if top is None:
            raise RuntimeError(_request_ctx_err_msg)
        # 返回栈顶对象的属性name
        return getattr(top, name)
    
    
    def _lookup_app_object(name):
        top = _app_ctx_stack.top
        if top is None:
            raise RuntimeError(_app_ctx_err_msg)
        return getattr(top, name)
    
    
    def _find_app():
        # 获取应用上下文的对象
        top = _app_ctx_stack.top
        if top is None:
            raise RuntimeError(_app_ctx_err_msg)
        return top.app
    
    
    # context locals
    _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'))

我们可以看到主要是两个上下文,request\_ctx 和 app,由app\_ctx引申出来了g和current\_app，由request\_ctx引申出来了 request和session，每次会调用\_lookup\_req\_object来获取栈顶的数据，我们去开课LocalStack

def release_local(local):
        """释放当前上下文的内容 Example:: >>> loc = Local() >>> loc.foo = 42 >>> release_local(loc) >>> hasattr(loc, 'foo') False 用这个函数能够释放Local类和LocalStack类的对象. """
        local.__release_local__()

## Local()基础类 ##

class Local(object):
        # 规定了类的两个属性
        __slots__ = ('__storage__', '__ident_func__')
    
        def __init__(self):
            # 数据保存在__storage__中，线程id保存在__ident_func__中
            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)

基础类Local一共有两个属性**storage**和**ident\_func**，**storage**存储线程状态，\{id: \{name: value\}\},**ident\_func**是根据不同情况的获取线程（或者协程）id的函数.提供了属性的访问、设置和删除，最牛逼就在于这个嵌套的二层字典，每一个线程id就是**ident\_func**函数标识，对应了一系列的\{name:value\}键值对，等于就是将全局变量都隔离开了，你的是你的全局变量，我的是我的全局变量，几者之间没有关系。**getattr**也只是直接获取你自己的全局变量中的内容。太妙了！

## LocalStack ##

class LocalStack(object):
    
        """和Local类差不多，但是维护了一个对象集合的栈. This is best explained with an example:: >>> ls = LocalStack() >>> ls.push(42) >>> ls.top 42 >>> ls.push(23) >>> ls.top 23 >>> ls.pop() 23 >>> ls.top 42 它们能够被LocalManager类中的release_local方法强制清除，但是正确的方法是在它们被使用之后pop从栈中弹出，当栈空的时候，将不再和当前上下文绑定在一起了 不带参数的调用它，能够返回一个解析栈顶top的代理 """
    
        def __init__(self):
            self._local = Local()
    
        def __release_local__(self):
            self._local.__release_local__()
        # 获取ident_func属性
        def _get__ident_func__(self):
            return self._local.__ident_func__
        # 设置ident_func线程id的函数
        def _set__ident_func__(self, value):
            object.__setattr__(self._local, '__ident_func__', value)
        __ident_func__ = property(_get__ident_func__, _set__ident_func__)
        del _get__ident_func__, _set__ident_func__
    
        def __call__(self):
            def _lookup():
                rv = self.top
                if rv is None:
                    raise RuntimeError('object unbound')
                return rv
            return LocalProxy(_lookup)
    
        def push(self, obj):
            """Pushes a new item to the stack"""
            rv = getattr(self._local, 'stack', None)
            if rv is None:
                self._local.stack = rv = []
            rv.append(obj)
            return rv
    
        def pop(self):
            """Removes the topmost item from the stack, will return the old value or `None` if the stack was already empty. """
            stack = getattr(self._local, 'stack', None)
            if stack is None:
                return None
            elif len(stack) == 1:
                release_local(self._local)
                return stack[-1]
            else:
                return stack.pop()
    
        @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

初始化的时候自身对象的属性\_local指代Local类的对象。提供了三种方法，push,pop,top。可以看到栈的相关内容保存在self.\_local.stack中一个键为’stack’值为列表的字典中。每一次的压入push就是在列表里面添加,pop就是移除列表中的最后一项，top返回列表的最后一项

## LocalProxy ##

这是一个代理类，是Local对象的代理，负责把对自己的所有操作转发给内部的Local对象。细节部分就不看了，我也看不懂QAQ，这里提出了两个问题。

1、为什么不直接用Local而用LocalStack？  
**答案**：  
　　因为Local和LocalStack都实现了不同的线程隔离，但是flask为了能够允许多request，多app。所以用栈（列表）实现了。  
　　  
2、为什么要用代理而不直接用LocalStack的对象，  
**答案**：  
　　代理其实也是为了动态这个意思。current\_app = LocalProxy(\_find\_app)是为了每次使用current\_app的时候都会调用find\_app然后对得到的结果进行操作，如果直接使用current\_app = \_find\_app()之后，current就不会产生变化了，总的来说就是一句话：因为上下文保存的数据是保存在栈里的，并且会动态发生变化。如果不是动态地去访问，会造成数据访问异常。

## 总结 ##

附上一张自己写的总结图片，虽然说看了这么多，最终留下的只有一个大概，就是这张图了，这样也好，有一个初步的印象。多花些时间罢了  
![这里写图片描述][70]

[70]: /images/20220528/b273d102baa34474a134d5e5b3f532e1.png