第1步：Flask Request 的执行流程
启动先执行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)调用了wsgi方法，执行初步的请求，wsgi把要处理的信息交给__call__方法去执行wsgi_app()，通过app.request_context方法，把请求的相关信息传给RequestContext()，并返回，得到ctx对象，其中封装了request,session
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)
def request_context(self, environ):
return RequestContext(self, environ)
def __call__(self, environ, start_response):
return self.wsgi_app(environ, start_response)
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 = Nonectx = self.request_context(environ)
ctx.push()ctx是一个RequestContext对象，这个对象里面封装了两个主要的属性，一个是self.request = Request实例的对象，Request对象里面封装了请求进来的所有数据；另外一个是self.session = None。
第1.1步：到_app_ctx_stack这个栈中取最后一个数据，如果未取到或者取到的不是当前的app，就调用app.app_context()方法，就是新实例一个上下文app_ctx对象，再执行app_ctx.push()方法 （在这再次强调，因为app_ctx是AppContext对象，就要先去AppContext类中找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() # 将封装好的request/session放在一个空间中
#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.)
class AppContext(object):
def push(self):
_app_ctx_stack.push(self) #把新创建的app_ctx上下文app对象添加到了_app_ctx_stack这个栈中
appcontext_pushed.send(self.app) #在这里遇到了第一个信号，请求app上下文push时执行
第1.2步：LocalStack类，帮助操作local __storage__字典，把ctx对象添加到local中，（对local维护的__storage__字典进行操作，视图系统的读取也要通过其完成）
# LocalStack 帮助管理Local 中 __storage__
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
'''
__storage__ ={
线程/进程唯一标识:{stack:[ctx,]}
}
'''第1.3步：执行Local 对象，维护字典__storage__ = {}
# Local 创建 __storage__
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__', {})
#如果用self的方式设置属性，就会触发self的__setattr__方法，就会无限的循环
object.__setattr__(self, '__ident_func__', get_ident)
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}
'''
__storage__ ={}
'''第1.4步：给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()那么第1步做了什么？
1.把app_ctx上下文对象添加到了_app_ctx_stack这个栈中
2.把 ctx 请求对象添加到Local类的列表中
3.执行open_session方法，把session加载到内第2步：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)第2.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()第2.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第2.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)第2.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第2.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第2.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)第2.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()第3步：
class Flask(_PackageBoundObject):
def handle_exception(self, e):
got_request_exception.send(self, exception=e) #信号 - 请求执行出现异常时执行第4步： 执行了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)第4.1步： 执行 app.do_teardown_request方法
class Flask(_PackageBoundObject):
def do_teardown_request(self, exc=_sentinel):
# 信号 - 请求执行完毕后自动执行（无论成功与否）
request_tearing_down.send(self, exc=exc)第4.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)第4.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)