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

def wsgi_app(self, environ, start_response):with self.request_context(environ):  #2.1,把环境变量入栈rv = self.preprocess_request()   #2.2，请求前的处理操作，主要执行一些函数，主要是准备工作。if rv is None:   #请求前如果没有需要做的事情，就会进入到请求分发rv = self.dispatch_request()  #2.3 进行请求分发response = self.make_response(rv)  #2.4 返回一个response_class的实例对象，也就是可以接受environ和start_reponse两个参数的对象response = self.process_response(response)  #2.5 进行请求后的处理操作，只要是执行一些函数，和preprocesses_request()类似，主要是清理工作。return response(environ, start_response)   #2.6 对web server（uwsgi）进行正式回应

   def request_context(self, environ):return _RequestContext(self, environ) #调用_RequestContext（）类

#请求上下文初始化
class _RequestContext(object):def __init__(self, app, environ):self.app = appself.url_adapter = app.url_map.bind_to_environ(environ)self.request = app.request_class(environ)self.session = app.open_session(self.request)self.g = _RequestGlobals()self.flashes = None
'''
调用with的时候就会执行
'''def __enter__(self):_request_ctx_stack.push(self)'''with进行上下文管理的例子：
with离开后就会执行自定义上下文管理
class Diycontextor:def __init__(self,name,mode):self.name = nameself.mode = modedef __enter__(self):print "Hi enter here!!"self.filehander = open(self.name,self.mode)return self.filehanderdef __exit__(self,*para):print "Hi exit here"self.filehander.close()with Diycontextor('py_ana.py','r') as f:for i in f:print i
'''def __exit__(self, exc_type, exc_value, tb):if tb is None or not self.app.debug:_request_ctx_stack.pop()

class LocalStack(object):"""This class works similar to a :class:`Local` but keeps a stackof objects instead.  This is best explained with an example::LocalStack类似于Local类，但是它保持了一个栈功能。它能够将对象入栈、出栈，如下：>>> ls = LocalStack()>>> ls.push(42)>>> ls.top42>>> ls.push(23)>>> ls.top23>>> ls.pop()23>>> ls.top42They can be force released by using a :class:`LocalManager` or withthe :func:`release_local` function but the correct way is to pop theitem from the stack after using.  When the stack is empty it willno longer be bound to the current context (and as such released).入栈的对象可以通过LocalManage类进行强制释放，或者通过函数release_local函数。但是，正确的姿势是通过pop函数把他们出栈。当栈为空时，它不再弹出上下文对象，这样就完全释放了。By calling the stack without arguments it returns a proxy that resolves tothe topmost item on the stack.通过调用调用无参数的stack，返回一个proxy。

   def preprocess_request(self):for func in self.before_request_funcs:rv = func()if rv is not None:return rv

'''
分发请求
1、获取endpoint和values，即请求url和参数
2、调用视图函数view_functions[endpoint](**values)
3、处理异常错误
'''      def dispatch_request(self):try:endpoint, values = self.match_request()return self.view_functions[endpoint](**values)except HTTPException, e:handler = self.error_handlers.get(e.code)if handler is None:return ereturn handler(e)except Exception, e:handler = self.error_handlers.get(500)if self.debug or handler is None:raisereturn handler(e)

    def match_request(self):rv = _request_ctx_stack.top.url_adapter.match()request.endpoint, request.view_args = rvreturn rv

>>> m = Map([...     Rule('/', endpoint='index'),...     Rule('/downloads/', endpoint='downloads/index'),...     Rule('/downloads/<int:id>', endpoint='downloads/show')... ])>>> urls = m.bind("example.com", "/")>>> urls.match("/", "GET")('index', {})>>> urls.match("/downloads/42")('downloads/show', {'id': 42})

@app.route('/hello')
def hello_world():return 'Hello World!'

def make_response(self, rv):"""Converts the return value from a view function to a realresponse object that is an instance of :attr:`response_class`.The following types are allowd for `rv`:======================= ===========================================:attr:`response_class`  the object is returned unchanged:class:`str`            a response object is created with thestring as body:class:`unicode`        a response object is created with thestring encoded to utf-8 as body:class:`tuple`          the response object is created with thecontents of the tuple as argumentsa WSGI function         the function is called as WSGI applicationand buffered as response object======================= ===========================================:param rv: the return value from the view function"""if isinstance(rv, self.response_class):return rvif isinstance(rv, basestring):return self.response_class(rv)if isinstance(rv, tuple):return self.response_class(*rv)return self.response_class.force_type(rv, request.environ)

def after_request(self, f):self.after_request_funcs.append(f)return f

response = self.make_response(rv)
response = self.process_response(response)

@classmethoddef force_type(cls, response, environ=None):
"""Enforce that the WSGI response is a response object of the currenttype.  Werkzeug will use the :class:`BaseResponse` internally in manysituations like the exceptions.  If you call :meth:`get_response` on anexception you will get back a regular :class:`BaseResponse` object, evenif you are using a custom subclass.This method can enforce a given response type, and it will alsoconvert arbitrary WSGI callables into response objects if an environis provided::# convert a Werkzeug response object into an instance of the# MyResponseClass subclass.response = MyResponseClass.force_type(response)# convert any WSGI application into a response objectresponse = MyResponseClass.force_type(response, environ)This is especially useful if you want to post-process responses inthe main dispatcher and use functionality provided by your subclass.Keep in mind that this will modify response objects in place ifpossible!

def process_response(self, response):session = _request_ctx_stack.top.sessionif session is not None:self.save_session(session, response)for handler in self.after_request_funcs:response = handler(response)return response

# -*- coding: utf-8 -*-
from __future__ import with_statement
import os
import sys
from threading import local
from jinja2 import Environment, PackageLoader, FileSystemLoader
from werkzeug import Request as RequestBase, Response as ResponseBase, \LocalStack, LocalProxy, create_environ, cached_property, \SharedDataMiddleware
from werkzeug.routing import Map, Rule
from werkzeug.exceptions import HTTPException, InternalServerError
from werkzeug.contrib.securecookie import SecureCookie
from werkzeug import abort, redirect
from jinja2 import Markup, escapetry:import pkg_resourcespkg_resources.resource_stream
except (ImportError, AttributeError):pkg_resources = None#Request继承werkzeug的Request类
class Request(RequestBase):def __init__(self, environ):RequestBase.__init__(self, environ)self.endpoint = Noneself.view_args = None#Response继承werkzeug的Response类
class Response(ResponseBase):default_mimetype = 'text/html'#请求的全局变量类
class _RequestGlobals(object):pass#请求上下文初始化
class _RequestContext(object):def __init__(self, app, environ):self.app = appself.url_adapter = app.url_map.bind_to_environ(environ)self.request = app.request_class(environ)self.session = app.open_session(self.request)self.g = _RequestGlobals()self.flashes = None
'''
调用with的时候就会执行
'''def __enter__(self):_request_ctx_stack.push(self)'''
with离开后就会执行
自定义上下文管理
class Diycontextor:def __init__(self,name,mode):self.name = nameself.mode = modedef __enter__(self):print "Hi enter here!!"self.filehander = open(self.name,self.mode)return self.filehanderdef __exit__(self,*para):print "Hi exit here"self.filehander.close()with Diycontextor('py_ana.py','r') as f:for i in f:print i
'''def __exit__(self, exc_type, exc_value, tb):if tb is None or not self.app.debug:_request_ctx_stack.pop()'''self.url_adapter = app.url_map.bind_to_environ(environ)>>> m = Map([...     Rule('/', endpoint='index'),...     Rule('/downloads/', endpoint='downloads/index'),...     Rule('/downloads/<int:id>', endpoint='downloads/show')... ])>>> urls = m.bind("example.com", "/")>>> urls.build("index", {})'/'>>> urls.build("downloads/show", {'id': 42})'/downloads/42'>>> urls.build("downloads/show", {'id': 42}, force_external=True)'http://example.com/downloads/42'
'''
def url_for(endpoint, **values):return _request_ctx_stack.top.url_adapter.build(endpoint, values)'''
flash实现，通过get_flashed_messages获取消息
'''
def flash(message):session['_flashes'] = (session.get('_flashes', [])) + [message]def get_flashed_messages():flashes = _request_ctx_stack.top.flashesif flashes is None:_request_ctx_stack.top.flashes = flashes = \session.pop('_flashes', [])return flashes'''
实现render_template功能，模板名和{content}
'''
def render_template(template_name, **context):current_app.update_template_context(context)return current_app.jinja_env.get_template(template_name).render(context)'''
实现render_template_string功能，模板名和{content}
'''
def render_template_string(source, **context):current_app.update_template_context(context)return current_app.jinja_env.from_string(source).render(context)def _default_template_ctx_processor():reqctx = _request_ctx_stack.topreturn dict(request=reqctx.request,session=reqctx.session,g=reqctx.g)def _get_package_path(name):try:return os.path.abspath(os.path.dirname(sys.modules[name].__file__))except (KeyError, AttributeError):return os.getcwd()'''
Flask类
'''
class Flask(object):'''
全局变量
'''request_class = Requestresponse_class = Responsestatic_path = '/static'secret_key = Nonesession_cookie_name = 'session'jinja_options = dict(autoescape=True,extensions=['jinja2.ext.autoescape', 'jinja2.ext.with_'])'''
当前模块名
app=Flask(__name__)'''def __init__(self, package_name):self.debug = Falseself.package_name = package_nameself.root_path = _get_package_path(self.package_name)self.view_functions = {}self.error_handlers = {}self.before_request_funcs = []self.after_request_funcs = []self.template_context_processors = [_default_template_ctx_processor]self.url_map = Map()"""
A WSGI middleware that provides static content for developmentenvironments or simple server setups. Usage is quite simple::import osfrom werkzeug.wsgi import SharedDataMiddlewareapp = SharedDataMiddleware(app, {'/shared': os.path.join(os.path.dirname(__file__), 'shared')})
"""if self.static_path is not None:self.url_map.add(Rule(self.static_path + '/<filename>',build_only=True, endpoint='static'))if pkg_resources is not None:target = (self.package_name, 'static')else:target = os.path.join(self.root_path, 'static')self.wsgi_app = SharedDataMiddleware(self.wsgi_app, {self.static_path: target})       self.jinja_env = Environment(loader=self.create_jinja_loader(),**self.jinja_options)self.jinja_env.globals.update(url_for=url_for,get_flashed_messages=get_flashed_messages)'''
FileSystemLoader(BaseLoader)
Loads templates from the file system.  This loader can find templatesin folders on the file system and is the preferred way to load them.The loader takes the path to the templates as string, or if multiplelocations are wanted a list of them which is then looked up in thegiven order::>>> loader = FileSystemLoader('/path/to/templates')>>> loader = FileSystemLoader(['/path/to/templates', '/other/path'])A very basic example for a loader that looks up templates on the filesystem could look like this::from jinja2 import BaseLoader, TemplateNotFoundfrom os.path import join, exists, getmtimeclass MyLoader(BaseLoader):def __init__(self, path):self.path = pathdef get_source(self, environment, template):path = join(self.path, template)if not exists(path):raise TemplateNotFound(template)mtime = getmtime(path)with file(path) as f:source = f.read().decode('utf-8')return source, path, lambda: mtime == getmtime(path)PackageLoader(BaseLoader)If the package path is not given, ``'templates'`` is assumed.默认值为templates
'''def create_jinja_loader(self):if pkg_resources is None:return FileSystemLoader(os.path.join(self.root_path, 'templates'))return PackageLoader(self.package_name)'''
template_context_processors=[dict(request=reqctx.request,session=reqctx.session,g=reqctx.g]
'''def update_template_context(self, context):reqctx = _request_ctx_stack.topfor func in self.template_context_processors:context.update(func())'''
整体APP启动入口，启动后进行如下几个步骤：
1、判断是否有设置DEBUG
2、运行rum_simple()
app = Flask(__name__)
if __name__ == '__main__():app.run()app.run() run_simple(host, port, self, **options) Start a WSGI application. Optional features include a reloader,multithreading and fork support.    '''def run(self, host='localhost', port=5000, **options):from werkzeug import run_simpleif 'debug' in options:self.debug = options.pop('debug')options.setdefault('use_reloader', self.debug)options.setdefault('use_debugger', self.debug)return run_simple(host, port, self, **options)def test_client(self):from werkzeug import Clientreturn Client(self, self.response_class, use_cookies=True)def open_resource(self, resource):if pkg_resources is None:return open(os.path.join(self.root_path, resource), 'rb')return pkg_resources.resource_stream(self.package_name, resource)def open_session(self, request):key = self.secret_keyif key is not None:return SecureCookie.load_cookie(request, self.session_cookie_name,secret_key=key)def save_session(self, session, response):if session is not None:session.save_cookie(response, self.session_cookie_name)def add_url_rule(self, rule, endpoint, **options):options['endpoint'] = endpointoptions.setdefault('methods', ('GET',))self.url_map.add(Rule(rule, **options))'''
@app.route('/test')
def test():passroute是一个装饰器，它干了2个事情：
1、添加url到map里
2、添加函数名到视图函数{'test':test}
'''def route(self, rule, **options):def decorator(f):self.add_url_rule(rule, f.__name__, **options)self.view_functions[f.__name__] = freturn freturn decorator'''
A decorator that is used to register a function give a givenerror code.  Example::@app.errorhandler(404)def page_not_found():return 'This page does not exist', 404You can also register a function as error handler without usingthe :meth:`errorhandler` decorator.  The following example isequivalent to the one above::def page_not_found():return 'This page does not exist', 404app.error_handlers[404] = page_not_founderror_handlers = {page_not_found:404}''' def errorhandler(self, code):def decorator(f):self.error_handlers[code] = freturn freturn decorator
'''
请求开始前做准备工作，比如数据库连接，用户验证
@app.before_request
def before_request():  #可在此处检查jwt等auth_key是否合法，  #abort(401)  #然后根据endpoint，检查此api是否有权限，需要自行处理  #print(["endpoint",connexion.request.url_rule.endpoint])  #abort(401)  #也可做ip检查，以阻挡受限制的ip等
'''def before_request(self, f):self.before_request_funcs.append(f)return fdef after_request(self, f):self.after_request_funcs.append(f)return fdef context_processor(self, f):self.template_context_processors.append(f)return f
'''Here is a small example for matching:>>> m = Map([...     Rule('/', endpoint='index'),...     Rule('/downloads/', endpoint='downloads/index'),...     Rule('/downloads/<int:id>', endpoint='downloads/show')... ])>>> urls = m.bind("example.com", "/")>>> urls.match("/", "GET")('index', {})>>> urls.match("/downloads/42")('downloads/show', {'id': 42})
'''def match_request(self):rv = _request_ctx_stack.top.url_adapter.match()request.endpoint, request.view_args = rvreturn rv'''
分发请求
1、获取endpoint和values，即请求url和参数
2、调用视图函数view_functions[endpoint](**values)
3、处理异常错误
'''      def dispatch_request(self):try:endpoint, values = self.match_request()return self.view_functions[endpoint](**values)except HTTPException, e:handler = self.error_handlers.get(e.code)if handler is None:return ereturn handler(e)except Exception, e:handler = self.error_handlers.get(500)if self.debug or handler is None:raisereturn handler(e)
'''
from werkzeug.wrappers import BaseResponse as Responsedef index():return Response('Index page')def application(environ, start_response):path = environ.get('PATH_INFO') or '/'if path == '/':response = index()else:response = Response('Not Found', status=404)return response(environ, start_response)
'''def make_response(self, rv):if isinstance(rv, self.response_class):return rvif isinstance(rv, basestring):return self.response_class(rv)if isinstance(rv, tuple):return self.response_class(*rv)return self.response_class.force_type(rv, request.environ)def preprocess_request(self):for func in self.before_request_funcs:rv = func()if rv is not None:return rvdef process_response(self, response):session = _request_ctx_stack.top.sessionif session is not None:self.save_session(session, response)for handler in self.after_request_funcs:response = handler(response)return responsedef wsgi_app(self, environ, start_response):with self.request_context(environ):rv = self.preprocess_request()if rv is None:rv = self.dispatch_request()response = self.make_response(rv)response = self.process_response(response)return response(environ, start_response)def request_context(self, environ):return _RequestContext(self, environ)def test_request_context(self, *args, **kwargs):return self.request_context(create_environ(*args, **kwargs))
'''
app=Flask(__name__)call(self, environ, start_response) wsgi_app(self, environ, start_response) wsgi_app是flask核心:'''def __call__(self, environ, start_response):return self.wsgi_app(environ, start_response)# context locals
_request_ctx_stack = LocalStack()
current_app = LocalProxy(lambda: _request_ctx_stack.top.app)
request = LocalProxy(lambda: _request_ctx_stack.top.request)
session = LocalProxy(lambda: _request_ctx_stack.top.session)
g = LocalProxy(lambda: _request_ctx_stack.top.g)