Flask系列之源碼分析(二)

應用技術點

• python之__setattr__
• python之threading.local
• python之偏函數

flask源碼上下文管理

一、綜述過程

將請求對象壓入棧

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

二、將請求對象壓入棧

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

            # 九、結束
            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)

 三、從棧中將請求對象調取出來

 --request  --->_lookup_req_object

　　--session --->_lookup_req_object

　　--current_app--->_find_app

　　--g--->_lookup_app_object

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

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__'):
            # "local" is a callable that is not an instance of Local or
            # LocalManager: mark it as a wrapped function.
            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__)

2.以上四個對象經過localProxy（採用threading.local）,調用

　　--_lookup_app_object

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

　　--_find_app

def _find_app():
    top = _app_ctx_stack.top
    if top is None:
        raise RuntimeError(_app_ctx_err_msg)
    return top.app

　　--_lookup_app

def _lookup_app_object(name):
    top = _app_ctx_stack.top
    if top is None:
        raise RuntimeError(_app_ctx_err_msg)
    return getattr(top, name)

3.以上三個方法調用

　　_lookup_req_object ----> _implicit_app_ctx_stack

　　_find_app和_lookup_app  ----> _request_ctx_stack

4.上下文出棧流程

session的保存方式：

wsgi_app()-->full_dispatch_request-->self.dispatch_request()
wsgi_app()

def wsgi_app(self, environ, start_response):
            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

            # 九、結束
            ctx.auto_pop(error)

full_dispatch_request

# Flask類   
 def full_dispatch_request(self):
        """Dispatches the request and on top of that performs request
        pre and postprocessing as well as HTTP exception catching and
        error handling.

        .. versionadded:: 0.7
        """ self.try_trigger_before_first_request_functions() try: request_started.send(self) rv = self.preprocess_request() if rv is None: # 觸發執行視圖函數，使用session rv = self.dispatch_request() except Exception as e: rv = self.handle_user_exception(e) return self.finalize_request(rv)

finalize_request(self, rv, from_error_handler=False):

# Flask類
def finalize_request(self, rv, from_error_handler=False):
        response = self.make_response(rv)
        try:
            '''八、'''
            response = self.process_response(response)
            request_finished.send(self, response=response)
        except Exception:
            if not from_error_handler:
                raise
            self.logger.exception('Request finalizing failed with an '
                                  'error while handling an error')
        return response           

 　self.process_response(response)

# Flask類
def process_response(self, response):
        ctx = _request_ctx_stack.top
        bp = ctx.request.blueprint
        funcs = ctx._after_request_functions
        if bp is not None and bp in self.after_request_funcs:
            funcs = chain(funcs, reversed(self.after_request_funcs[bp]))
        if None in self.after_request_funcs:
            funcs = chain(funcs, reversed(self.after_request_funcs[None]))
        # 執行 after_request裝飾器
        for handler in funcs:
            response = handler(response)
        # 將內存中的session持久化到：數據庫、....
        if not self.session_interface.is_null_session(ctx.session):
            self.save_session(ctx.session, response)
        return response

　　self.save_session(ctx.session, response)

 
# Flask類
def save_session(self, session, response):
        return self.session_interface.save_session(self, session, response)

上下文的出棧方式：

wsgi_app()-->ctx.auto_pop(error)-->

auto_pop

# RequestContext類
    def auto_pop(self, exc):
        if self.request.environ.get('flask._preserve_context') or \
           (exc is not None and self.app.preserve_context_on_exception):
            self.preserved = True
            self._preserved_exc = exc
        else:
            self.pop(exc)

self.pop(exc)

#RequestContext類
def pop(self, exc=_sentinel):
    app_ctx = self._implicit_app_ctx_stack.pop()

        try:
            clear_request = False
            if not self._implicit_app_ctx_stack:
                self.preserved = False
                self._preserved_exc = None
                if exc is _sentinel:
                    exc = sys.exc_info()[1]
                self.app.do_teardown_request(exc)

                # If this interpreter supports clearing the exception information
                # we do that now.  This will only go into effect on Python 2.x,
                # on 3.x it disappears automatically at the end of the exception
                # stack.
                if hasattr(sys, 'exc_clear'):
                    sys.exc_clear()

                request_close = getattr(self.request, 'close', None)
                if request_close is not None:
                    request_close()
                clear_request = True
        finally:
            rv = _request_ctx_stack.pop()

            # get rid of circular dependencies at the end of the request
            # so that we don't require the GC to be active.
            if clear_request:
                rv.request.environ['werkzeug.request'] = None

            # Get rid of the app as well if necessary.
            if app_ctx is not None:
                app_ctx.pop(exc)

            assert rv is self, 'Popped wrong request context.  ' \
                '(%r instead of %r)' % (rv, self)

rv = _request_ctx_stack.pop()

# LocalStack類
 def pop(self):
        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()

app_ctx.pop(exc)

#AppContext類

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)
　　# 信號執行8 appcontext_popped
　　appcontext_popped.send(self.app)

完成