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

from flask import Flask,request,session
app = Flask(__name__)
app.secret_key = 'sdfsdfsd'
from flask.sessions import SessionInterface,SessionMixin
import uuid
import json
from flask.sessions import SessionInterface
from flask.sessions import SessionMixin
from itsdangerous import Signer, BadSignature, want_bytes

class MySession(dict, SessionMixin):
    def __init__(self, initial=None, sid=None):
        self.sid = sid
        self.initial = initial
        super(MySession, self).__init__(initial or ())

    def __setitem__(self, key, value):
        super(MySession, self).__setitem__(key, value)

    def __getitem__(self, item):
        return super(MySession, self).__getitem__(item)

    def __delitem__(self, key):
        super(MySession, self).__delitem__(key)


class MySessionInterface(SessionInterface):
    session_class = MySession
    container = {
        # 'asdfasdfasdfas':{'k1':'v1','k2':'v2'}
        # 'asdfasdfasdfas':"{'k1':'v1','k2':'v2'}"
    }

    def __init__(self):
        pass
        # import redis
        # self.redis = redis.Redis()

    def _generate_sid(self):
        return str(uuid.uuid4())

    def _get_signer(self, app):
        if not app.secret_key:
            return None
        return Signer(app.secret_key, salt='flask-session',
                      key_derivation='hmac')

    def open_session(self, app, request):
        """
        程序剛啟動時執行，需要返回一個session對象
        """
        sid = request.cookies.get(app.session_cookie_name)
        if not sid:
            # 生成隨機字符串，並將隨機字符串添加到 session對象中
            sid = self._generate_sid()
            return self.session_class(sid=sid)

        signer = self._get_signer(app)
        try:
            sid_as_bytes = signer.unsign(sid)
            sid = sid_as_bytes.decode()
        except BadSignature:
            sid = self._generate_sid()
            return self.session_class(sid=sid)

        # session保存在redis中
        # val = self.redis.get(sid)
        # session保存在內存中
        val = self.container.get(sid)

        if val is not None:
            try:
                data = json.loads(val)
                return self.session_class(data, sid=sid)
            except:
                return self.session_class(sid=sid)
        return self.session_class(sid=sid)

    def save_session(self, app, session, response):
        """
        程序結束前執行，可以保存session中所有的值
        如：
            保存到resit
            寫入到用戶cookie
        """
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        httponly = self.get_cookie_httponly(app)
        secure = self.get_cookie_secure(app)
        expires = self.get_expiration_time(app, session)

        val = json.dumps(dict(session))

        # session保存在redis中
        # self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime)
        # session保存在內存中
        self.container.setdefault(session.sid, val)

        session_id = self._get_signer(app).sign(want_bytes(session.sid))

        response.set_cookie(app.session_cookie_name, session_id,
                            expires=expires, httponly=httponly,
                            domain=domain, path=path, secure=secure)



app.session_interface = MySessionInterface()
# app.session_interface = Foo()
# app.session_interface
# app.make_null_session()
@app.route('/index')
def index():
    print('網站的所有session',MySessionInterface.container)
    print(session)
    session['k1'] = 'v1'
    session['k2'] = 'v2'
    del session['k1']

    # 在內存中操作字典....
    # session['k1'] = 'v1'
    # session['k2'] = 'v2'
    # del session['k1']

    return "xx"

if __name__ == '__main__':
    app.__call__
    app.run()

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