Flask系列之源码分析(二)

应用技术点

flask源码上下文管理

1、综述过程

将请求对象压入栈

1.请求进入

__call__ ---> wsgi_app ---> ctx = self.request_context(environ)

初始化请求对象

2.通过ctx.puth()建立2个请求堆栈（采用threading.local）

　　--app_ctx(app,g)

　　--ctx(request,session)

3._implicit_app_ctx_stack初始化

4._request_ctx_stack初始化

从栈中将请求对象调取出来

1.经过层层建立到达视图函数

　　--request

　　--session

　　--current_app

　　--g

2.以上四个对象通过localProxy（采用threading.local）,调用

　　--_lookup_app_object

　　--_find_app

　　--_lookup_app

3.以上三个方法调用

　　_lookup_req_object ----> _implicit_app_ctx_stack

　　_find_app和_lookup_app ----> _request_ctx_stack

2、将请求对象压入栈

1.请求进入

__call__ ---> wsgi_app ---> ctx = self.request_context(environ)

初始化请求对象

wsgi_app源码

# Flask 类
 def wsgi_app(self, environ, start_response):

        ctx = self.request_context(environ)
        ctx.push()

        error = None
        try:
            try:
                # 4 执行视图函数
                response = self.full_dispatch_request()
            except Exception as e:
                # 异常处理试图报错，包含信号2345报错执行，got_request_exception信号
                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

            # 9、结束
            ctx.auto_pop(error)

self.request_context(environ)

# Flask类
def request_context(self, environ):
       return RequestContext(self, environ)

RequestContext(self, environ)

# RequestContest类
 def __init__(self, app, environ, request=None):
        self.app = app
　　　　 # 初始化request请求对象
        if request is None:
            request = app.request_class(environ)

        self.request = request

        self.url_adapter = app.create_url_adapter(self.request)
        self.flashes = None

        self.session = None

2.通过ctx.puth()建立2个请求堆栈（采用threading.local）

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

        # Before we push the request context we have to ensure that there
        # is an application context.
        app_ctx = _app_ctx_stack.top
        if app_ctx is None or app_ctx.app != self.app:
            # app_ctx = AppContext(self.app) --> _implictit_app_ctx_stack(app,g)
            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()

        '''
        请求相关数据，加到local中
        '''
        _request_ctx_stack.push(self)


        # Open the session at the moment that the request context is
        # available. This allows a custom open_session method to use the
        # request context (e.g. code that access database information
        # stored on `g` instead of the appcontext).

        self.session = self.app.open_session(self.request)
        if self.session is None:
            self.session = self.app.make_null_session()

3._implicit_app_ctx_stack 调用

--app_ctx(app,g) --> self._implicit_app_ctx_stack.append(app_ctx)堆栈

top = _request_ctx_stack.top

_request_ctx_stack = LocalStack()

class LocalStack(object):

    def __init__(self):
        self._local = Local()

    def __release_local__(self):
        self._local.__release_local__()

    def _get__ident_func__(self): return self._local.__ident_func__ 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

app_ctx = self.app.app_context()

# Flask类
def app_context(self):
    return AppContext(self)

AppContext(self)

# AppContext类，初始化
def __init__(self, app):
        self.app = app  # 等于Flask对象
        self.url_adapter = app.create_url_adapter(None)
        self.g = app.app_ctx_globals_class() # Flask系统全局变量 

        # Like request context, app contexts can be pushed multiple times
        # but there a basic "refcount" is enough to track them.
        self._refcnt = 0

4._request_ctx_stack调用

--_request_ctx_stack.push(self) (请求相关)（堆栈）

    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

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)

3、从栈中将请求对象调取出来