Flask学习-Flask app接受第一个HTTP请求

1、__call__()

在Flask app启动后，一旦uwsgi收到来自web server的请求，就会调用后端app，其实此时就是调用app的__call__（environ，start_response）.

flask.py:

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

　　

2、wsgi_app()

当http请求从server发送过来的时候，他会启动__call__功能，这时候就启动了最关键的wsgi_app（environ，start_response）函数。

fask.py:

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）进行正式回应

　　

2.1 环境变量入栈

经过with上下文管理，生成request请求对象和请求上下文环境，并入栈。

执行以下代码块：

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

　　

2.1.1 调用_RequestContext（）类

首先 会执行__enter__（）函数，执行_request_ctx_stack的push方法，把环境变量进行入栈操做。

注意：_request_ctx_stack = LocalStack()

#请求上下文初始化
class _RequestContext(object):
   
    def __init__(self, app, environ):
        self.app = app
        self.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 = name
        self.mode = mode

    def __enter__(self):
        print "Hi enter here!!"
        self.filehander = open(self.name,self.mode)
        return self.filehander

    def __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()

　　

这一步最主要的是LocalStack类。

class LocalStack(object):

    """This class works similar to a :class:`Local` but keeps a stack
    of objects instead.  This is best explained with an example::
LocalStack相似于Local类，可是它保持了一个栈功能。它可以将对象入栈、出栈，以下：

        >>> ls = LocalStack()
        >>> ls.push(42)
        >>> ls.top
        42
        >>> ls.push(23)
        >>> ls.top
        23
        >>> ls.pop()
        23
        >>> ls.top
        42

    They can be force released by using a :class:`LocalManager` or with
    the :func:`release_local` function but the correct way is to pop the
    item from the stack after using.  When the stack is empty it will
    no 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 to
    the topmost item on the stack.
经过调用调用无参数的stack，返回一个proxy。

　　

从LocalStack的说明能够得知这几个事情：

一、LocalStack是一个相似Local的类，可是它具有栈的功能，可以让对象入栈、出栈以及销毁对象。

二、能够经过LocalManager类进行强制释放对象。

由引伸出两个类：Local类和Localmanager类

Local类用于添加、存储、或删除上下文变量。

LocalManager类：因为Local对象不能管理本身，因此经过LocalManager类用来管理Local对象。

 

咱们再回到wsgi_app函数中的2.2步骤：

2.2  preprocess_request

preprocess_request()方法，主要是进行flask的hook钩子, before_request功能的实现，也就是在真正发生请求以前，有些准备工做须要提早作。好比，链接数据库。

代码以下：

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

　　

它会执行preprocess_request列表里面的每一个函数。执行完成后，他会进入到dispatch_request方法。

2.3 dispatch_request

'''
分发请求
一、获取endpoint和values，即请求url和参数
二、调用视图函数view_functions[endpoint](**values)
三、处理异常错误
'''		
    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 e
            return handler(e)
        except Exception, e:
            handler = self.error_handlers.get(500)
            if self.debug or handler is None:
                raise
            return handler(e)

　　

进入dispatch_request()后，先执行match_request()，match_request()定义以下：

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

　　

注意：函数里面的url_adapter。

self.url_adapter = app.url_map.bind_to_environ(environ),其实他使一个Map()对象，Map（）对象位于werkzeug.routing模块，用于处理routeing。

从函数能够看出，它会返回一个元组（endpoint,view_args）

endpoint:是一个url

view_args:是url的参数

例如：

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

　　

match_request（）执行完成后，此时已经获取到了url和url里面包含的参数的信息。接着进入视图函数的执行：view_functions（）

 在Flask app启动一节咱们知道，view_functions()是一个字典，相似view_functions = {'hello_world':hello_world}，当咱们执行

self.view_functions[endpoint](**values)

就至关于执行了hello_wold(**values),即自行了视图函数。也就是咱们最开始app里面的hello_world视图函数：

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

　　

这时就会返回'Hello  World！‘若是有异常，则返回异常内容。

 至此，就完成了dispatch_request（），请求分发工做。这时，咱们再次回到wsgi_app中的2.4步：response = self.make_response(rv)

2.4 make_response

def make_response(self, rv):
    """Converts the return value from a view function to a real
    response 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 the
                            string as body
    :class:`unicode`        a response object is created with the
                            string encoded to utf-8 as body
    :class:`tuple`          the response object is created with the
                            contents of the tuple as arguments
    a WSGI function         the function is called as WSGI application
                            and buffered as response object
    ======================= ===========================================

    :param rv: the return value from the view function
    """
    if isinstance(rv, self.response_class):
        return rv
    if 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)

　　

经过make_response函数，将刚才取得的 rv 生成响应，从新赋值response

2.5 process_response

再经过process_response功能主要是处理一个after_request的功能，好比你在请求后，要把数据库链接关闭等动做，和上面提到的before_request对应和相似。

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

　　

以后再进行request_finished.send的处理，也是和socket处理有关，暂时不详细深刻。以后返回新的response对象。

这里特别须要注意的是，make_response函数是一个很是重要的函数，他的做用是返回一个response_class的实例对象，也就是能够接受environ和start_reponse两个参数的对象

 

当全部清理工做完成后，就会进入response(environ, start_response)函数，进行正式回应。

2.6 response(environ, start_response)

　最后进入response()函数，说response函数以前，咱们先来看看response函数的由来：

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

　　

2.6.1 response=make_response()

而make_response的返回值为：return self.response_class.force_type(rv, request.environ)

其中的response_class = Response，而Response最终来自werkzeug.

werkzeug import Response as ResponseBase

@classmethod
    def force_type(cls, response, environ=None):
"""Enforce that the WSGI response is a response object of the current
        type.  Werkzeug will use the :class:`BaseResponse` internally in many
        situations like the exceptions.  If you call :meth:`get_response` on an
        exception you will get back a regular :class:`BaseResponse` object, even
        if you are using a custom subclass.

        This method can enforce a given response type, and it will also
        convert arbitrary WSGI callables into response objects if an environ
        is 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 object
            response = MyResponseClass.force_type(response, environ)

        This is especially useful if you want to post-process responses in
        the main dispatcher and use functionality provided by your subclass.

        Keep in mind that this will modify response objects in place if
        possible!

　　

从上面能够知道，force_type（）是一个类方法，强制使当前对象成为一个WSGI的reponse对象。

 

 2.6.2  response = self.process_response(response)

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

　　

process_response()执行了2个操做：

一、保存会话

二、执行请求后的函数列表中每个函数，并返回response对象

 

最后response函数会加上environ, start_response的参数并返回给uwsgi（web服务器），再由uwsgi返回给nginx，nignx返回给浏览器，最终咱们看到的内容显示出来。

 至此，一个HTTP从请求到响应的流程就完毕了.

 

3、总结

总的来讲，一个流程的关键步骤能够简单归结以下：

 

 最后附上flask 0.1版本的注释源码：

# -*- 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, escape

try:
    import pkg_resources
    pkg_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 = None
        self.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 = app
        self.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 = name
        self.mode = mode

    def __enter__(self):
        print "Hi enter here!!"
        self.filehander = open(self.name,self.mode)
        return self.filehander

    def __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.flashes
    if 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.top
    return 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 = Request
    response_class = Response
    static_path = '/static'
    secret_key = None
    session_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 = False
        self.package_name = package_name
        self.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 development
    environments or simple server setups. Usage is quite simple::

        import os
        from werkzeug.wsgi import SharedDataMiddleware

        app = 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 templates
    in 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 multiple
    locations are wanted a list of them which is then looked up in the
    given 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 file
    system could look like this::

        from jinja2 import BaseLoader, TemplateNotFound
        from os.path import join, exists, getmtime

        class MyLoader(BaseLoader):

            def __init__(self, path):
                self.path = path

            def 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.top
        for func in self.template_context_processors:
            context.update(func())

'''
总体APP启动入口，启动后进行以下几个步骤：
一、判断是否有设置DEBUG
二、运行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_simple
        if '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 Client
        return 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_key
        if 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'] = endpoint
        options.setdefault('methods', ('GET',))
        self.url_map.add(Rule(rule, **options))


'''
@app.route('/test')
def test():
	pass
	
route是一个装饰器，它干了2个事情：
一、添加url到map里
二、添加函数名到视图函数{'test':test}
'''
    def route(self, rule, **options):
        
        def decorator(f):
            self.add_url_rule(rule, f.__name__, **options)
            self.view_functions[f.__name__] = f
            return f
        return decorator

'''
A decorator that is used to register a function give a given
        error code.  Example::

            @app.errorhandler(404)
            def page_not_found():
                return 'This page does not exist', 404

        You can also register a function as error handler without using
        the :meth:`errorhandler` decorator.  The following example is
        equivalent to the one above::

            def page_not_found():
                return 'This page does not exist', 404
            app.error_handlers[404] = page_not_found
			
			error_handlers = {page_not_found:404}

'''	
    def errorhandler(self, code):
       
        def decorator(f):
            self.error_handlers[code] = f
            return f
        return 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 f

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

    def 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 = rv
        return rv
		
'''
分发请求
一、获取endpoint和values，即请求url和参数
二、调用视图函数view_functions[endpoint](**values)
三、处理异常错误
'''		
    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 e
            return handler(e)
        except Exception, e:
            handler = self.error_handlers.get(500)
            if self.debug or handler is None:
                raise
            return handler(e)
'''
from werkzeug.wrappers import BaseResponse as Response

        def 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 rv
        if 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 rv

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

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