def wsgi_app(self, environ, start_response):
        ctx = self.request_context(environ)
        ctx.push()
        error = None
        try:
            try:
                response = self.full_dispatch_request()
            except Exception as e:
                error = e
                response = self.make_response(self.handle_exception(e))
            return response(environ, start_response)
        finally:
            if self.should_ignore_error(error):
                error = None
            ctx.auto_pop(error)

class RequestContext(object):

    def __init__(self, app, environ, request=None):
        self.app = app
        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
    
        # 暂时先忽略
        self._implicit_app_ctx_stack = []
        self.preserved = False
        self._preserved_exc = None
        self._after_request_functions = []

        self.match_request()
        
    ＃其它函数

    ＃ with语句协议
    def __enter__(self):
        self.push()
        return self
    def __exit__(self, exc_type, exc_value, tb):
        # do not pop the request stack if we are in debug mode and an
        # exception happened.  This will allow the debugger to still
        # access the request object in the interactive shell.  Furthermore
        # the context can be force kept alive for the test client.
        # See flask.testing for how this works.
        self.auto_pop(exc_value)

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

在init函数我们可以看到有这些东西将被保存到RequestContext中：

• app
• request
• url_adapter
• flashes
• session

其中request = app.request_class(environ)中的request_class是Flask类的一个class variable. 默认情况下，request_class = Request, 在wrappers.py 我们查看Request类:

class Request(RequestBase):

   url_rule = None
   view_args = None
   routing_exception = None
   _is_old_module = False

   @property
   def max_content_length(self):
      ...
   @property
   def endpoint(self):
      ...
   @property
   def module(self):
      ...
   @property
   def blueprint(self):
      ...
   @property
   def json(self):
      ...
   @property
   def is_json(self):
      ...
   def get_json(self, force=False, silent=False, cache=True):
      ...
   def on_json_loading_failed(self, e):
      ...

Request继承自werkzeug的Request类(示例)，通过传入environ进行初始化，获得url_rule, view_args, endpoint等信息(示例)。

init函数最后会调用match_request():

    def match_request(self):
        """Can be overridden by a subclass to hook into the matching
        of the request.
        """
        try:
            url_rule, self.request.view_args = \
                self.url_adapter.match(return_rule=True)
            self.request.url_rule = url_rule
        except HTTPException as e:
            self.request.routing_exception = e

match_request函数配置了路由信息，可参考werkzeug路由示例。
下面我们做实验看看request里面到底有些啥，
至此，ctx = self.request_context(environ) 执行完毕。ctx为一个RequestContext对象。
接下来ctx.psuh():

    def push(self):
        """Binds the request context to the current context."""

        # 这3行代码跟调试异常有关，暂时忽略。
        top = _request_ctx_stack.top
        if top is not None and top.preserved:
            top.pop(top._preserved_exc)

        # 在push Request Context之前先保证push App Context。
        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)

        # 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()

首先获取app_ctx, app_ctx = self.app.app_context():

    def app_context(self):
        return AppContext(self)

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

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

    def push(self):
        """Binds the app context to the current context."""
        self._refcnt += 1
        if hasattr(sys, 'exc_clear'):
            sys.exc_clear()
        _app_ctx_stack.push(self)
        appcontext_pushed.send(self.app)

与Request Context相比 AppContext含有的内容只有：

• app
• url_adapter
• g

相比RequestContext中的url_adapter，AppContext中提供给app.create_url_adapter的参数是None，那么AppContext只需要server name信息就足够了。

    def create_url_adapter(self, request):
        if request is not None:
            return self.url_map.bind_to_environ(request.environ,
                server_name=self.config['SERVER_NAME'])
        # We need at the very least the server name to be set for this
        # to work.
        if self.config['SERVER_NAME'] is not None:
            return self.url_map.bind(
                self.config['SERVER_NAME'],
                script_name=self.config['APPLICATION_ROOT'] or '/',
                url_scheme=self.config['PREFERRED_URL_SCHEME'])

对于g变量，app_ctx_globals_class = _AppCtxGlobals，即g变量是_AppCtxGlobals的一个实例：

class _AppCtxGlobals(object):
    """A plain object."""

    def get(self, name, default=None):
        return self.__dict__.get(name, default)

    def pop(self, name, default=_sentinel):
        if default is _sentinel:
            return self.__dict__.pop(name)
        else:
            return self.__dict__.pop(name, default)

    def setdefault(self, name, default=None):
        return self.__dict__.setdefault(name, default)

    def __contains__(self, item):
        return item in self.__dict__

    def __iter__(self):
        return iter(self.__dict__)

    def __repr__(self):
        top = _app_ctx_stack.top
        if top is not None:
            return '<flask.g of %r>' % top.app.name
        return object.__repr__(self)

换句话说，g就是一个普通的对象，具体用法可参考flask.g.
app_ctx = self.app.app_context()执行完毕，执行app_ctx.push()，app context可以推送多次，但是一个基本的refcount足以来跟踪它们。_app_ctx_stack.push(self), 在globals.py中，我们看到：

# 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_stack,还是_app_ctx_stack都是werkzeug中的LocalStack 实例，而current_app, request, session, g都是LocalProxy实例，关于LocalStack和LocalProxy的用法可参见另一篇文章。与AppContext相关的是_app_ctx_stack, current_app, g.

def _lookup_req_object(name):
    top = _request_ctx_stack.top
    if top is None:
        raise RuntimeError(_request_ctx_err_msg)
    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

由于current_app是个代理对象，当我们对current_app进行操作时，实际上是对_find_app函数中返回的top.app进行操作的，即 _app_ctx_stack.top.app, 也即是AppContext().app（一个Flask类实例）进行操作。同样 ，对g进行操作，会转交给getattr(_app_ctx_stack.top, 'g')也即是_AppCtxGlobals类的实例。至此AppContext push完毕。
回到push RequestContext过程中，_request_ctx_stack.push(self)，过程同上，request, session是与RequestContext相关的变量。
因此，当我们写from flask import current_app, request, session, g时，这些变量看似是全局变量，实际上则是LocalProxy类实例。最后push()函数中还有几行与session有关的代码，暂时忽略。