摘要：在實際創建一個運行的時，一個參數都不需要我們傳，無論是還是回調函數都由服務器，也就是負責。如上所述，兩個參數，回調函數傳入和最后返回一個字符串，也就是服務器返回給客戶端的核心數據。

https://jasonlvhit.github.io/...

簡單來看，wsgi是web組件的接口規范，在wsgi規范里，wsgi把web組件分成三個部分，wsgi server，wsgi middleware，wsgi application

更多的時候，我們關心的只是wsgi application， wsgi application就是一個Python中的callable對象（函數，或定義了__call__方法的類等）, 接受兩個參數，environ和start_response，參數只是一個名字而已，environ指的是環境變量，start_response是一個回調函數。在實際創建一個運行的app時，一個參數都不需要我們傳，無論是environ還是回調函數都由服務器，也就是wsgi server負責。

environ 包括 服務器環境變量，客戶端環境變量，和請求中的數據method，path等等。environ是怎么生成的呢？

wsgi server主要分為兩部分，server和handler。server監聽端口，handler處理請求。server接受到一個request，解析客戶端environ，bind一個handler，handler解析請求，將請求信息放入environ，最后服務器端環境變量也放入environ中。這就是environ的全部了。

start_response

在wsgiref中，回調函數start_response的源碼是下面這樣的：

def start_response(self, status, headers,exc_info=None):

    """"start_response()" callable as specified by PEP 333"""

    if exc_info:
        try:
            if self.headers_sent:
                # Re-raise original exception if headers sent
                raise exc_info[0], exc_info[1], exc_info[2]
        finally:
            exc_info = None        # avoid dangling circular ref
    elif self.headers is not None:
        raise AssertionError("Headers already set!")

    assert type(status) is StringType,"Status must be a string"
    assert len(status)>=4,"Status must be at least 4 characters"
    assert int(status[:3]),"Status message must begin w/3-digit code"
    assert status[3]==" ", "Status message must have a space after code"
    if __debug__:
        for name,val in headers:
            assert type(name) is StringType,"Header names must be strings"
            assert type(val) is StringType,"Header values must be strings"
            assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed"
    self.status = status
    self.headers = self.headers_class(headers)
    return self.write

函數接受兩個參數，status，也就是HTTP狀態碼，和headers，請求頭。函數驗證這兩個信息，并將其塞入服務器。最后調用write方法，write方法的功能是“to buffer data for send to client”，也就是把信息再塞回客戶端。

說到這，我們就可以看看一個在PEP3333中給出的簡單的wsgi app了。

HELLO_WORLD = b"Hello world!n"

def simple_app(environ, start_response):
    """Simplest possible application object"""
    status = "200 OK"
    response_headers = [("Content-type", "text/plain")]
    start_response(status, response_headers)
    return [HELLO_WORLD]

如上所述，兩個參數，environ, start_response, 回調函數start_response傳入status和headers,最后返回一個字符串，也就是服務器返回給客戶端的核心數據。

同樣，我們說過，一個wsgi application是一個callable對象，只要他是callable（實現__call__方法)的就可以。在PEP3333中也給出了一個簡單的類形式的app：

class AppClass:

def __call__(self, environ, start_response):
    status = "200 OK"
    response_headers = [("Content-type", "text/plain")]
    start_response(status, response_headers)
return [HELLO_WORLD]

到這，其實wsgi的結構很清晰了，最后，還差一個wsgi middleware。

middleware

按照PEP3333的說法，wsgi server是server端的東西，wsgi app是應用端的東西，并不是說middleware是中間的東西，middleware是一個兩頭兼顧的東西。

我們可以把app看成一個蛋糕，middleware則是這塊蛋糕的包裝。web服務中，例如session，route，auth等等，都是用middleware實現的。

例如一個PEP3333中的這個轉換piglatin的wsgi middleware:

from piglatin import piglatin

class LatinIter:

"""Transform iterated output to piglatin, if it"s okay to do so

Note that the "okayness" can change until the application yields
its first non-empty bytestring, so "transform_ok" has to be a mutable
truth value.
"""

def __init__(self, result, transform_ok):
    if hasattr(result, "close"):
        self.close = result.close
    self._next = iter(result).__next__
    self.transform_ok = transform_ok

def __iter__(self):
    return self

def __next__(self):
    if self.transform_ok:
        return piglatin(self._next())   # call must be byte-safe on Py3
    else:
        return self._next()

class Latinator:

# by default, don"t transform output
transform = False

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

def __call__(self, environ, start_response):

    transform_ok = []

    def start_latin(status, response_headers, exc_info=None):

        # Reset ok flag, in case this is a repeat call
        del transform_ok[:]

        for name, value in response_headers:
            if name.lower() == "content-type" and value == "text/plain":
                transform_ok.append(True)
                # Strip content-length if present, else it"ll be wrong
                response_headers = [(name, value)
                    for name, value in response_headers
                        if name.lower() != "content-length"
                ]
                break

        write = start_response(status, response_headers, exc_info)

        if transform_ok:
            def write_latin(data):
                write(piglatin(data))   # call must be byte-safe on Py3
            return write_latin
        else:
            return write

    return LatinIter(self.application(environ, start_latin), transform_ok)

middleware與函數裝飾器很像。

最后，一個應用的middleware不止一層，middleware可能像下面一樣工作：

def configure(app):
   return ErrorHandlerMiddleware(
           SessionMiddleware(
            IdentificationMiddleware(
             AuthenticationMiddleware(
              UrlParserMiddleware(app))))))

最后我們來看webframework，現在回想一下包括Django，Flask等框架，我們可以察覺出Python的web框架并不是特別的難以搭建。在4年前，第一個版本的Flask，只有短短600行代碼，并且其中充斥著大量的注釋（文檔）。

一般來說，一個python的webframework需要一個wsgi工具集（werkzeug, webob(pylons))，一個模板渲染引擎（mako，jinja2）和一個ORM數據庫工具集（sqlalchemy），還有其他的包括dispatcher，mail，json等支持，這樣我們可以膠合一個自己的框架。