1.执行Flask的实例对象.run()方法
from flask import Flask,request,session app = Flask(__name__) app.secret_key ='sdfsdfsdf' if __name__ == '__main__':
app.__call__
app.run()
2.经过对IP与端口的处理，然后执行 from werkzeug.serving import run_simple中的 run_simple(host, port, self, **options)方法
def run(self, host=None, port=None, debug=None, **options):
from werkzeug.serving import run_simple
#查看是否有ip
if host is None:
host = '127.0.0.1'
if port is None:
# 读取settings文件
server_name = self.config['SERVER_NAME']
# print(server_name)#127.0.0.1:80
if server_name and ':' in server_name:
port = int(server_name.rsplit(':', 1)[1])
# print(port)#80
else:
port = 5000
if debug is not None:
self.debug = bool(debug)
print(self.debug)
options.setdefault('use_reloader', self.debug)
options.setdefault('use_debugger', self.debug)
try:
run_simple(host, port, self, **options)
finally:
# reset the first request information if the development server
# reset normally. This makes it possible to restart the server
# without reloader and that stuff from an interactive shell.
self._got_first_request = False
def run_simple(hostname, port, application, use_reloader=False,
use_debugger=False, use_evalex=True,
extra_files=None, reloader_interval=1,
reloader_type='auto', threaded=False,
processes=1, request_handler=None, static_files=None,
passthrough_errors=False, ssl_context=None):
"""Start a WSGI application. Optional features include a reloader,
multithreading and fork support. This function has a command-line interface too:: python -m werkzeug.serving --help .. versionadded:: 0.5
`static_files` was added to simplify serving of static files as well
as `passthrough_errors`. .. versionadded:: 0.6
support for SSL was added. .. versionadded:: 0.8
Added support for automatically loading a SSL context from certificate
file and private key. .. versionadded:: 0.9
Added command-line interface. .. versionadded:: 0.10
Improved the reloader and added support for changing the backend
through the `reloader_type` parameter. See :ref:`reloader`
for more information. :param hostname: The host for the application. eg: ``'localhost'``
:param port: The port for the server. eg: ``8080``
:param application: the WSGI application to execute
:param use_reloader: should the server automatically restart the python
process if modules were changed?
:param use_debugger: should the werkzeug debugging system be used?
:param use_evalex: should the exception evaluation feature be enabled?
:param extra_files: a list of files the reloader should watch
additionally to the modules. For example configuration
files.
:param reloader_interval: the interval for the reloader in seconds.
:param reloader_type: the type of reloader to use. The default is
auto detection. Valid values are ``'stat'`` and
``'watchdog'``. See :ref:`reloader` for more
information.
:param threaded: should the process handle each request in a separate
thread?
:param processes: if greater than 1 then handle each request in a new process
up to this maximum number of concurrent processes.
:param request_handler: optional parameter that can be used to replace
the default one. You can use this to replace it
with a different
:class:`~BaseHTTPServer.BaseHTTPRequestHandler`
subclass.
:param static_files: a list or dict of paths for static files. This works
exactly like :class:`SharedDataMiddleware`, it's actually
just wrapping the application in that middleware before
serving.
:param passthrough_errors: set this to `True` to disable the error catching.
This means that the server will die on errors but
it can be useful to hook debuggers in (pdb etc.)
:param ssl_context: an SSL context for the connection. Either an
:class:`ssl.SSLContext`, a tuple in the form
``(cert_file, pkey_file)``, the string ``'adhoc'`` if
the server should automatically create one, or ``None``
to disable SSL (which is the default).
"""
3.execute(app) 中 application_iter = app(environ, start_response)即call方法
def execute(app):
application_iter = app(environ, start_response)
try:
for data in application_iter:
write(data)
if not headers_sent:
write(b'')
finally:
if hasattr(application_iter, 'close'):
application_iter.close()
application_iter = None
4.call方法中返回 return self.wsgi_app(environ, start_response)
def __call__(self, environ, start_response):
"""Shortcut for :attr:`wsgi_app`."""
print(environ,start_response) return self.wsgi_app(environ, start_response)
5.首先，处理的是request和session，将请求添加到Local中，即 ctx = self.request_context(environ)
def wsgi_app(self, environ, start_response):
#处理request，将请求添加到local中
ctx = self.request_context(environ)
# 处理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)
5.1.返回的是 return RequestContext(self, environ) 即类的一个实例
def request_context(self, environ):
return RequestContext(self, environ)
5.2.执行 ctx.push()方法 保存
def push(self):
"""Binds the request context to the current context.""" top = _request_ctx_stack.top
if top is not None and top.preserved:
top.pop(top._preserved_exc) # Before we push the request context we have to ensure that there
# is an application 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) self.session = self.app.open_session(self.request)
if self.session is None:
self.session = self.app.make_null_session()
6.执行视图函数 response = self.full_dispatch_request()方法
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
"""
self.try_trigger_before_first_request_functions()
try:
request_started.send(self)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request()
except Exception as e:
rv = self.handle_user_exception(e)
return self.finalize_request(rv)
6.1：执行 self.try_trigger_before_first_request_functions()即装饰器@before_first_request装饰所有函数
6.2：执行 rv = self.preprocess_request()方法 即@before_request装饰所有函数
6.3：return self.finalize_request(rv)方法 即@after_request装饰所有函数
response = self.process_response(response)方法
# 执行after_request 装饰所有的函数 response = handler(response)
最后处理session self.save_session(ctx.session, response)
7.return response(environ, start_response) 将处理完的内容返回给用户浏览器