flask请求流程

启动先执行manage.py 中的    app.run()

class Flask(_PackageBoundObject):　　 def run(self, host=None, port=None, debug=None, **options):
    　　from werkzeug.serving import run_simple
    　　try:
        　　#run_simple 是werkzeug 提供的方法，会执行第三个参数 self()
        　　run_simple(host, port, self, **options)

执行app()，对象()表示调用对象的__call__方法

class Flask(_PackageBoundObject):　　 def __call__(self, environ, start_response):
        return self.wsgi_app(environ, start_response)

又调用了app.wsgi_app方法

class Flask(_PackageBoundObject):　　 def wsgi_app(self, environ, start_response):
        #1.　　　　　ctx = self.request_context(environ)　　　　       #self.request_context
        #2.
        ctx.push()　　 　　try:
            try:　　　　　　　　　 #3.执行视图函数
                response = self.full_dispatch_request()
            except Exception as e:
                error = e　　　　　　　　　 #4.
                response = self.handle_exception(e)
            except:
                error = sys.exc_info()[1]
                raise
            return response(environ, start_response)
        finally:　　　　　　　#5.
            ctx.auto_pop(error)

第1步：执行app.request_context方法，把请求的相关信息传进去了

class Flask(_PackageBoundObject):　　 def request_context(self, environ):
        return RequestContext(self, environ)

返回了一个RequestContext类的实例对象

class RequestContext(object):　　 def __init__(self, app, environ, request=None):
        self.app = app
        if request is None:
            request = app.request_class(environ) 　　　　　　  #app.request_class = Request
        self.request = request
        self.session = None

在init构造方法中注意app又调用了request_class方法，这时候我们所实例化的app中默认参数request_class中有一个Request的类，

那么第1步我们知道：

ctx是一个RequestContext对象，这个对象里面封装了两个主要的属性，一个是self.request = Request实例的对象，Request对象里面封装了请求进来的所有数据；另外一个是self.session = None就可以了

第2步：执行ctx.push()方法

因为ctx是RequestContext类的对象，那我们就要去RequestContext类中找push方法

class RequestContext(object):　　 def push(self):
　　　　 #2.1.
        app_ctx = _app_ctx_stack.top
        if app_ctx is None or app_ctx.app != self.app:
            app_ctx = self.app.app_context()　　　　　　　　　　　　# self.app.app_context = app.app_context = AppContext(app)
            app_ctx.push()　　　　　#2.2.　　　　  _request_ctx_stack.push(self)　　　　　　　　#_request_ctx_stack = LocalStack()　　　　 #2.3.        self.session = self.app.open_session(self.request)

        #判断没有 secret_key时：        if self.session is None:            self.session = self.app.make_null_session()            #raise RuntimeError(‘The session is unavailable because no secret ‘‘key was set.)

第2.1步：到_app_ctx_stack这个栈中取最后一个数据，如果未取到或者取到的不是当前的app，就调用app.app_context()方法，就是新实例一个上下文app_ctx对象，再执行app_ctx.push()方法     （在这再次强调，因为app_ctx是AppContext对象，就要先去AppContext类中找push方法），

class AppContext(object):　　 def push(self):
        _app_ctx_stack.push(self)     #把新创建的app_ctx上下文app对象添加到了_app_ctx_stack这个栈中
        appcontext_pushed.send(self.app)   #在这里遇到了第一个信号，请求app上下文push时执行

第2.2步：LocalStack类的对象调用push方法

class LocalStack(object):　　 def push(self, obj):
        rv = getattr(self._local, ‘stack‘, None)       #self._local = Local()　　　　      #第一次的时候rv肯定是None
        if rv is None:
            self._local.stack = rv = []      #Local对象 .stack = rv = [] 就执行了对象的 __setattr__方法
        rv.append(obj)                       #把 ctx对象添加到Local类的列表中
        return rv

try:
    from greenlet import getcurrent as get_ident
except ImportError:
    try:
        from thread import get_ident
    except ImportError:
        from _thread import get_ident

class Local(object):        def __init__(self):        object.__setattr__(self, ‘__storage__‘, {})             #这里为什么用object.__setattr__  而不是直接用self.__storage__={}        object.__setattr__(self, ‘__ident_func__‘, get_ident)   #如果用self的方式设置属性，就会触发self的__setattr__方法，就会无限的循环　　
    def __setattr__(self, name, value):
        ident = self.__ident_func__()
        storage = self.__storage__
        try:
            storage[ident][name] = value    # {"唯一标识1"：{"stack":[]}，"唯一标识2"：{"stack":[]}}   和本地线程类似
        except KeyError:
            storage[ident] = {name: value}

第2.3步：给ctx.session赋值，执行app.open_session(ctx.request)

class Flask(_PackageBoundObject):　　 def open_session(self, request):
        return self.session_interface.open_session(self, request)　　　　　#return SecureCookieSessionInterface().open_session(app, request)　　　　　#所以就要去SecureCookieSessionInterface类找open_session方法

class SecureCookieSessionInterface(SessionInterface):　　 def open_session(self, app, request):
        # 查看 是否有secret_key
        s = self.get_signing_serializer(app)
        if s is None:
            return None
        val = request.cookies.get(app.session_cookie_name)
        # 请求第一次来的时候取不到值
        if not val:
            return self.session_class()
            #返回了一个 类似字典
        max_age = total_seconds(app.permanent_session_lifetime)
        try:
            data = s.loads(val, max_age=max_age)  #loads 作用是： 反序列化+解析乱码
            return self.session_class(data)       ##返回了一个 类似字典对象，对象里面有data
        except BadSignature:
            return self.session_class()

那么第2步我们知道：

1.把app_ctx上下文对象添加到了_app_ctx_stack这个栈中2.把 ctx请求对象添加到Local类的列表中3.执行open_session方法，把session加载到内

第3步：app.full_dispatch_request()   执行视图函数

class Flask(_PackageBoundObject):    def full_dispatch_request(self):        #3.1         self.try_trigger_before_first_request_functions()        try:            request_started.send(self)     # 信号 - 请求到来前执行            # 3.2             rv = self.preprocess_request()            if rv is None:                # 3.3 如果所有的中间件都通过了， 执行视图函数                rv = self.dispatch_request()　　　　 #3.4         return self.finalize_request(rv)

第3.1步：找到所有的 执行一次的 伪中间件 执行

class Flask(_PackageBoundObject):
    def try_trigger_before_first_request_functions(self):

        with self._before_request_lock:
            for func in self.before_first_request_funcs:
                func()

第3.2步：找到所有的 伪中间件的执行

class Flask(_PackageBoundObject):
    def preprocess_request(self):

        funcs = self.before_request_funcs.get(None, ())
        for func in funcs:
            rv = func()
            if rv is not None:
                return rv

第3.3步：

class Flask(_PackageBoundObject):
    def dispatch_request(self):
        #获取请求的ctx对象中的request数据
        req = _request_ctx_stack.top.request
        #获取请求的url
        rule = req.url_rule
        #执行视图函数
        return self.view_functions[rule.endpoint](**req.view_args)

第3.4步：

class Flask(_PackageBoundObject):
    def finalize_request(self, rv, from_error_handler=False):
        response = self.make_response(rv)   #通过make_response方法后就可以对返回值进行设置响应头等数据了
        try:　　　　　　　#3.4.1
            response = self.process_response(response)
            request_finished.send(self, response=response)  #信号 -  请求结束后执行
        return response

第3.4.1步：

class Flask(_PackageBoundObject):
    def process_response(self, response):
        ctx = _request_ctx_stack.top
        #找到所有的 after_request 伪中间件执行
        funcs = ctx._after_request_functions
        for handler in funcs:
            response = handler(response)
        # 3.4.1.1 如果有session就执行self.save_session方法
        if not self.session_interface.is_null_session(ctx.session):　　　　　# self.session_interface = SecureCookieSessionInterface() 　　　　　　  #3.4.1.2　　　　 　　 self.save_session(ctx.session, response) return response

第3.4.1.1步： 到SecureCookieSessionInterface类中找is_null_session方法，发现没有，就去它基类SessionInterface中找

class SessionInterface(object):
    def is_null_session(self, obj):
        #判断ctx.session 是不是 self.null_session_class = NullSession 类或者它派生类的对象
        return isinstance(obj, self.null_session_class)

第3.4.1.2步：执行了SecureCookieSessionInterface类的save_session方法

class Flask(_PackageBoundObject):
    def save_session(self, session, response):
        return self.session_interface.save_session(self, session, response)
        # return SecureCookieSessionInterface().save_session(self, session, response)
class SecureCookieSessionInterface(SessionInterface):
    def save_session(self, app, session, response):
        #给响应设置cookie
        response.set_cookie(app.session_cookie_name, val,
                            expires=expires, httponly=httponly,
                            domain=domain, path=path, secure=secure)

补充：自定义session

 自定义类似django的session

第4步：

class Flask(_PackageBoundObject):
    def handle_exception(self, e):
        got_request_exception.send(self, exception=e)    #信号 - 请求执行出现异常时执行

第5步： 执行了RequestContext 的 pop 方法

class RequestContext(object):
    def auto_pop(self, exc):
        else:
            self.pop(exc)

class RequestContext(object):
    def pop(self, exc=_sentinel):　　　　 try:        　　if not self._implicit_app_ctx_stack:　　　　　　　　  #5.1            　　self.app.do_teardown_request(exc)
        finally:　　　　　　  # 请求结束时  request上下文的栈中就把请求pop掉
            rv = _request_ctx_stack.pop()        　　 if app_ctx is not None:　　　　　　　　　　#5.2        　　 　　 app_ctx.pop(exc)

第5.1步： 执行  app.do_teardown_request方法

class Flask(_PackageBoundObject):
    def do_teardown_request(self, exc=_sentinel):
　　　　 # 信号 - 请求执行完毕后自动执行（无论成功与否）
        request_tearing_down.send(self, exc=exc)

第5.2步：

class AppContext(object):
    def pop(self, exc=_sentinel):        try:            if self._refcnt <= 0:　　　　　　　　　 #5.2.1                self.app.do_teardown_appcontext(exc)　　　　 # 信号 - 请求上下文pop时执行
        appcontext_popped.send(self.app)

第5.2.1步：

class Flask(_PackageBoundObject):
    def do_teardown_appcontext(self, exc=_sentinel):
        # 信号 - 请求上下文执行完毕后自动执行（无论成功与否）
        appcontext_tearing_down.send(self, exc=exc)

补充：

多app应用

from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
from flask import Flask, current_app

app1 = Flask(‘app01‘)

app2 = Flask(‘app02‘)

@app1.route(‘/index‘)
def index():
    return "app01"

@app2.route(‘/index2‘)
def index2():
    return "app2"

dm = DispatcherMiddleware(app1, {
    ‘/sec‘: app2,
})

if __name__ == "__main__":
    app2.__call__
    run_simple(‘localhost‘, 5000, dm)

调用__call__方法的时候，如果有‘/’的话分割，mounts之前传过的url，如果在的话，就break，不在的话分割完拼接路径

    def __call__(self, environ, start_response):
        script = environ.get(‘PATH_INFO‘, ‘‘)
        path_info = ‘‘
        while ‘/‘ in script:
            if script in self.mounts:
                app = self.mounts[script]
                break
            script, last_item = script.rsplit(‘/‘, 1)
            path_info = ‘/%s%s‘ % (last_item, path_info)
        else:
            app = self.mounts.get(script, self.app)
        original_script_name = environ.get(‘SCRIPT_NAME‘, ‘‘)
        environ[‘SCRIPT_NAME‘] = original_script_name + script
        environ[‘PATH_INFO‘] = path_info
        return app(environ, start_response)

原文地址：https://www.cnblogs.com/journey-mk5/p/10257451.html

时间： 2024-10-06 16:26:52

flask请求流程的相关文章

Flask快速入门(11) — 请求流程

目录 full_dispatch_request() flask项目整个请求流程其实就是执行:wsgi_app()方法中调用的full_dispatch_request(),包括请求扩展和真正的视图函数 full_dispatch_request() def full_dispatch_request(self): # 执行before_first_request函数 self.try_trigger_before_first_request_functions() try: # 发送请求开始信

DRF之REST规范介绍及View请求流程分析

编程是数据结构和算法的结合,而在Web类型的App中,我们对于数据的操作请求是通过url来承载的,本文详细介绍了REST规范和CBV规范和CBV请求流程. 编程即数据结构和算法的结合.简单的程序可能不需要跟用户交互数据,但是现代的应用程序几乎都需要跟用户进行交互,不分应用程序类型,不管是CS型还是BS型的程序都是如此,而Python最擅长的Web App即BS型的程序,就是通过url和http来跟用户进行数据交互的,通过url和http请求,用户可以操作服务器端的程序,主要操作分为:增.删.改.

flask请求和应用上下文

关于WSGI WSGI(全称Web Server Gateway Interface),是为 Python 语言定义的Web服务器和Web应用程序之间的一种简单而通用的接口,它封装了接受HTTP请求.解析HTTP请求.发送HTTP,响应等等的这些底层的代码和操作,使开发者可以高效的编写Web应用. 一个简单的使用WSGI的App例子: def application(environ, start_response): start_response('200 OK', [('Content-Typ

flask启动流程02

flask请求到达流程 1.0 app启动后,浏览器发送请求触发app.__call__()方法 #1. 执行__call__方法, def __call__(self, environ, start_response): """The WSGI server calls the Flask application object as the WSGI application. This calls :meth:`wsgi_app` which can be wrapped

OkHttp面试之--OkHttp的整个异步请求流程

通过上一节,我们已经了解了如何使用OkHttp发送异步请求,下载网络图片信息并显示到ImageView控件上,从这一节开始我们就来开始研究一下其内部的实现流程和原理.因为整个流程相对而言还是比较复杂,因此对于流程的分析我划分成以下几个章节去介绍 流程概述 拦截器的原理 HttpEngine中sendRequest的流程分析 HttpEngine中readResponse的流程分析 这一节我们先来看一下整个流程的概述,先上一张时序图 以上图片来自http://www.jianshu.com/p/d

.NET MVC请求流程

ASP.NET MVC 请求流程:Controller MvcHandler Action Action参数赋值

zookeeper源码分析之五服务端(集群leader)处理请求流程

leader的实现类为LeaderZooKeeperServer,它间接继承自标准ZookeeperServer.它规定了请求到达leader时需要经历的路径: PrepRequestProcessor -> ProposalRequestProcessor ->CommitProcessor -> Leader.ToBeAppliedRequestProcessor ->FinalRequestProcessor 具体情况可以参看代码: @Override protected v

Action请求流程分析

Strut2流程分析-----从请求到Action方法() 首先请求会调用strutsPrepareAndExcuteFliter----(这个就是我们在web.xml文件中所配置的那个拦截器吧,所有Action请求都要过这个拦截器)的doFilter()方法 然后会调用StrutsActionProxy类的excute()方法,生成一个代理类(ActionProxy) ActionProxy 是 Action 的一个代理类,也就是说Action的调用是通过 ActionProxy 实现的,就是

WebX学习二——URL请求流程分析

URL请求流程分析 1.在index页面中设置了 得到如下链接 当这个get请求发出的时候,流程是这样的: 首先,它被webx中配置的Filter捕获: 进入源码分析发现:该请求进入了WebxFrameworkFilter的doFilter方法: @Override protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOExcept