执行app.run()方法:
def run(self, host=None, port=None, debug=None, **options): from werkzeug.serving import run_simple if host is None: host = ‘127.0.0.1‘ if port is None: server_name = self.config[‘SERVER_NAME‘] if server_name and ‘:‘ in server_name: port = int(server_name.rsplit(‘:‘, 1)[1]) else: port = 5000 if debug is not None: self.debug = bool(debug) options.setdefault(‘use_reloader‘, self.debug) options.setdefault(‘use_debugger‘, self.debug) try: #执行,self=app---->执行Flask类的__call__方法 run_simple(host, port, self, **options) finally: self._got_first_request = False
执行Flask.__call__方法：
#包含请求相关的所有信息 def __call__(self, environ, start_response): """Shortcut for :attr:`wsgi_app`.""" return self.wsgi_app(environ, start_response)
执行wsgi_app()方法:
def wsgi_app(self, environ, start_response): #获取请求数据,并进行封装和加工, ctx = self.request_context(environ) #将RequestContext(request,session)封装在Local中 ‘‘‘ {‘唯一标识‘:{‘stack‘:[RequestContext(request,session),]} } ‘‘‘ ctx.push() error = None try: try: #调用视图函数 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 ctx.auto_pop(error)
执行RequestContext.__init__()和push()方法:
__init__():获取request
def __init__(self, app, environ, request=None): self.app = app if request is None: #实际是一个Request对象,将request信息封装到Request(environ)中，并赋值给RequestContext对象中
request = app.request_class(environ) self.request = request self.url_adapter = app.create_url_adapter(self.request) self.flashes = None self.session = None
push()方法：将RequestContext对象添加到Local中，获取/创建session
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() #将当前requestContext对象放到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=SecureCookieSession()
#SecureCookieSession()实际上是一个字典
self.session = self.app.open_session(self.request) if self.session is None:
#用户第一次进来session={}执行，返回NullSession self.session = self.app.make_null_session()
当请求进来时:执行open_session()方法:
class SecureCookieSessionInterface(SessionInterface): def open_session(self, app, request): s = self.get_signing_serializer(app) if s is None: return None #去cookie中获取session作为key,所对应的值(包含了当前用户所有的session数据) val = request.cookies.get(app.session_cookie_name) #没有 if not val: #返回SecureCookieSession return self.session_class() max_age = total_seconds(app.permanent_session_lifetime) try: #val存在的话 #解密 将加密的字符串解密程字典 data = s.loads(val, max_age=max_age) return self.session_class(data) except BadSignature: return self.session_class()
这是我们已经将RequestContext(request,session)的对象放到Local中，并且request和session的初始值也获取到了，
上面方法就是为了执行下面两句:
ctx = self.request_context(environ)
ctx.push()
执行上面的语句后我们在wagi_app()方法中继续向下执行,
触发视图函数
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 """ #执行@before_first_request所装饰的所有函数 self.try_trigger_before_first_request_functions() try: request_started.send(self) #执行@before_request装饰的所有函数 看是否有返回值 rv = self.preprocess_request() if rv is None: rv = self.dispatch_request() except Exception as e: rv = self.handle_user_exception(e) #执行@after_request所装饰的所有函数 return self.finalize_request(rv)
执行finalize_request()方法:
def finalize_request(self, rv, from_error_handler=False): """Given the return value from a view function this finalizes the request by converting it into a response and invoking the postprocessing functions. This is invoked for both normal request dispatching as well as error handlers. Because this means that it might be called as a result of a failure a special safe mode is available which can be enabled with the `from_error_handler` flag. If enabled, failures in response processing will be logged and otherwise ignored. :internal: """ response = self.make_response(rv) try: #执行@after_request所装饰的所有函数 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
执行process_response()方法
def process_response(self, response): """Can be overridden in order to modify the response object before it‘s sent to the WSGI server. By default this will call all the :meth:`after_request` decorated functions. .. versionchanged:: 0.5 As of Flask 0.5 the functions registered for after request execution are called in reverse order of registration. :param response: a :attr:`response_class` object. :return: a new response object or the same, has to be an instance of :attr:`response_class`. """ 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])) 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
具体是怎么保存session的呢?
看save_session()方法
session.py中
def save_session(self, app, session, response): domain = self.get_cookie_domain(app) path = self.get_cookie_path(app) # Delete case. If there is no session we bail early. # If the session was modified to be empty we remove the # whole cookie. if not session: if session.modified: response.delete_cookie(app.session_cookie_name, domain=domain, path=path) return # Modification case. There are upsides and downsides to # emitting a set-cookie header each request. The behavior # is controlled by the :meth:`should_set_cookie` method # which performs a quick check to figure out if the cookie # should be set or not. This is controlled by the # SESSION_REFRESH_EACH_REQUEST config flag as well as # the permanent flag on the session itself. if not self.should_set_cookie(app, session): return httponly = self.get_cookie_httponly(app) secure = self.get_cookie_secure(app) expires = self.get_expiration_time(app, session)
#加密操作 val = self.get_signing_serializer(app).dumps(dict(session))
#将session保存在cookie中 response.set_cookie(app.session_cookie_name, val, expires=expires, httponly=httponly, domain=domain, path=path, secure=secure)
globals.py
def _lookup_req_object(name): # top实际是一个RequestContext对象 ‘‘‘ { ‘唯一标识‘:{‘stack‘:[RequestContext(request,session),]} } ‘‘‘ top = _request_ctx_stack.top if top is None: raise RuntimeError(_request_ctx_err_msg) #得到session:RequestContext(request,session).session #得到request:RequestContext(request,session).request 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‘))