【引自selfboot的博客】在 從零開始搭建論壇(一)：Web服務器與Web框架 中我們弄清楚了Web 服務器、Web 應用程序、Web框架的概念。對于 Python 來說，越來越多的 Web 框架面世，在給我們更多選擇機會的同時，也限制了我們對于 Web Server 的選擇。同樣是有著很多 Web 框架的Java，因為有著 servlet API 的存在，任何Java Web框架寫的應用程序都可以運行在任意一個 Web Server 上。

Python 社區(qū)當然也需要這樣一套 API，來適配Web服務器和應用程序，這套 API 就是 WSGI(Python Web Server Gateway Interface)，在 PEP 3333 里有詳細的說明。簡單來說，WSGI是連接Web服務器和Web應用程序的橋梁，一方面從Web server 拿到原始 HTTP 數(shù)據(jù)，處理成統(tǒng)一格式后交給 Web 應用程序，另一方面從應用程序/框架這邊進行業(yè)務邏輯處理，生成響應內(nèi)容后交給服務器。

Web服務器和框架通過 WSGI 來進行耦合的詳細過程如下圖所示：

 WSGI Server 適配

具體解釋如下：

• 應用程序(網(wǎng)絡框架)提供一個命名為application的可調(diào)用對象(WSGI協(xié)議并沒有指定如何實現(xiàn)這個對象)。
• 服務器每次從HTTP客戶端接收請求之后，調(diào)用可調(diào)用對象application，調(diào)用時傳遞一個名叫environ的字典作為參數(shù)，以及一個名為start_response的可調(diào)用對象。
• 框架/應用生成HTTP狀態(tài)碼以及HTTP響應報頭，然后將二者傳遞至start_response，等待服務器保存。此外，框架/應用還將返回響應的正文。
• 服務器將狀態(tài)碼、響應報頭和響應正文組合成HTTP響應，并返回給客戶端(這一步并不屬于WSGI協(xié)議)。

下面分別從服務器端和應用程序端來看看 WSGI 是如何做適配的。

服務器端

我們知道客戶端(通常是瀏覽器)發(fā)出的每個HTTP請求由請求行、消息報頭、請求正文三部分組成，里面包含了本次請求的相關細節(jié)內(nèi)容。比如：

• Method：指出在由Request-URI標識的資源上所執(zhí)行的方法，包括GET，POST 等
• User-Agent：允許客戶端將它的操作系統(tǒng)、瀏覽器和其它屬性告訴服務器;

服務器從客戶端接收HTTP請求之后，WSGI 接口必須要對這些請求字段進行統(tǒng)一化處理，方便傳給應用服務器接口(其實就是給框架)。Web服務器具體傳遞哪些數(shù)據(jù)給應用程序，早在CGI(Common Gateway Interface，通用網(wǎng)關接口)里就有詳細規(guī)定，這些數(shù)據(jù)被叫做 CGI 環(huán)境變量。WSGI 沿用了 CGI 環(huán)境變量的內(nèi)容，要求 Web 服務器必須創(chuàng)建一個字典用來保存這些環(huán)境變量(一般將其命名為 environ)。除了 CGI 定義的變量，environ 還必須保存一些WSGI定義的變量，此外還可以保存一些客戶端系統(tǒng)的環(huán)境變量，可以參考environ Variables 來看看具體有哪些變量。

接著 WSGI 接口必須將 environ 交給應用程序去處理，這里 WSGI 規(guī)定應用程序提供一個可調(diào)用對象 application，然后服務器去調(diào)用 application，獲得返回值為HTTP響應正文。服務器在調(diào)用 application 的時候，需要提供兩個變量，一個是前面提到的變量字典environ，另一個是可調(diào)用對象 start_response，它產(chǎn)生狀態(tài)碼和響應頭，這樣我們就得到了一個完整的HTTP響應。Web 服務器將響應返回給客戶端，一次完整的HTTP請求-響應過程就完成了。

wsgiref 分析

Python 中內(nèi)置了一個實現(xiàn)了WSGI接口的 Web 服務器，在模塊wsgiref中，它是用純Python編寫的WSGI服務器的參考實現(xiàn)，我們一起來簡單分析一下它的實現(xiàn)。首先假設我們用下面代碼啟動一個 Web 服務器：

# Instantiate the server 
httpd = make_server( 
    'localhost',    # The host name 
    8051,           # A port number where to wait for the request 
    application     # The application object name, in this case a function 
) 
# Wait for a single request, serve it and quit 
httpd.handle_request()  

然后我們以Web服務器接收一個請求、生成 environ，然后調(diào)用 application 來處理請求這條主線來分析源碼的調(diào)用過程，簡化如下圖所示：

 WSGI Server 調(diào)用流程

這里主要有三個類，WSGIServer，WSGIRequestHandler，ServerHandle。WSGIServer 是Web服務器類，可以提供server_address(IP:Port)和 WSGIRequestHandler 類來進行初始化獲得一個server對象。該對象監(jiān)聽響應的端口，收到HTTP請求后通過 finish_request 創(chuàng)建一個RequestHandler 類的實例，在該實例的初始化過程中會生成一個 Handle 類實例，然后調(diào)用其 run(application) 函數(shù)，在該函數(shù)里面再調(diào)用應用程序提供的 application對象來生成響應。

這三個類的繼承關系如下圖所示：

 WSGI 類繼承關系圖

其中 TCPServer 使用 socket 來完成 TCP 通信，HTTPServer 則是用來做 HTTP 層面的處理。同樣的，StreamRequestHandler 來處理 stream socket，BaseHTTPRequestHandler 則是用來處理 HTTP 層面的內(nèi)容，這部分和 WSGI 接口關系不大，更多的是 Web 服務器的具體實現(xiàn)，可以忽略。

微服務器實例

如果上面的 wsgiref 過于復雜的話，下面一起來實現(xiàn)一個微小的 Web 服務器，便于我們理解 Web 服務器端 WSGI 接口的實現(xiàn)。代碼摘自 自己動手開發(fā)網(wǎng)絡服務器(二)，放在 gist 上，主要結構如下：

class WSGIServer(object): 
    # 套接字參數(shù) 
    address_family, socket_type = socket.AF_INET, socket.SOCK_STREAM 
    request_queue_size = 1 
    def __init__(self, server_address): 
        # TCP 服務端初始化：創(chuàng)建套接字，綁定地址，監(jiān)聽端口 
        # 獲取服務器地址，端口 
    def set_app(self, application): 
        # 獲取框架提供的 application 
        self.application = application 
    def serve_forever(self): 
        # 處理 TCP 連接：獲取請求內(nèi)容，調(diào)用處理函數(shù) 
    def handle_request(self): 
        # 解析 HTTP 請求，獲取 environ，處理請求內(nèi)容，返回HTTP響應結果 
        env = self.get_environ() 
        result = self.application(env, self.start_response) 
        self.finish_response(result) 
    def parse_request(self, text): 
        # 解析 HTTP 請求 
         
    def get_environ(self): 
        # 分析 environ 參數(shù)，這里只是示例，實際情況有很多參數(shù)。 
        env['wsgi.url_scheme']   = 'http' 
        ... 
        env['REQUEST_METHOD']    =  self.request_method    # GET 
        ... 
        return env 
    def start_response(self, status, response_headers, exc_info=None): 
        # 添加響應頭，狀態(tài)碼 
        self.headers_set = [status, response_headers + server_headers] 
    def finish_response(self, result): 
        # 返回 HTTP 響應信息 
SERVER_ADDRESS = (HOST, PORT) = '', 8888 
# 創(chuàng)建一個服務器實例 
def make_server(server_address, application): 
    server = WSGIServer(server_address) 
    server.set_app(application) 
    return server  

目前支持 WSGI 的成熟Web服務器有很多，Gunicorn是相當不錯的一個。它脫胎于ruby社區(qū)的Unicorn，成功移植到python上，成為一個WSGI HTTP Server。有以下優(yōu)點：

• 容易配置
• 可以自動管理多個worker進程
• 選擇不同的后臺擴展接口(sync, gevent, tornado等)

應用程序端(框架)

和服務器端相比，應用程序端(也可以認為框架)要做的事情就簡單很多，它只需要提供一個可調(diào)用對象(一般習慣將其命名為application)，這個對象接收服務器端傳遞的兩個參數(shù) environ 和 start_response。這里的可調(diào)用對象不僅可以是函數(shù)，還可以是類(下面第二個示例)或者擁有 __call__ 方法的實例，總之只要可以接受前面說的兩個參數(shù)，并且返回值可以被服務器進行迭代即可。

Application 具體要做的就是根據(jù) environ 里面提供的關于 HTTP 請求的信息，進行一定的業(yè)務處理，返回一個可迭代對象，服務器端通過迭代這個對象，來獲得 HTTP 響應的正文。如果沒有響應正文，那么可以返回None。

同時，application 還會調(diào)用服務器提供的 start_response，產(chǎn)生HTTP響應的狀態(tài)碼和響應頭，原型如下：

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

Application 需要提供 status：一個字符串，表示HTTP響應狀態(tài)字符串，還有 response_headers: 一個列表，包含有如下形式的元組：(header_name, header_value)，用來表示HTTP響應的headers。同時 exc_info 是可選的，用于出錯時，server需要返回給瀏覽器的信息。

到這里為止，我們就可以實現(xiàn)一個簡單的 application 了，如下所示：

def simple_app(environ, start_response): 
    """Simplest possible application function""" 
    HELLO_WORLD = "Hello world!\n" 
    status = '200 OK' 
    response_headers = [('Content-type', 'text/plain')] 
    start_response(status, response_headers) 
    return [HELLO_WORLD]  

或者用類實現(xiàn)如下。

class AppClass: 
    """Produce the same output, but using a class""" 
    def __init__(self, environ, start_response): 
        self.environ = environ 
        self.start = start_response 
    def __iter__(self): 
        ... 
        HELLO_WORLD = "Hello world!\n" 
        yield HELLO_WORLD  

注意這里 AppClass 類本身就是 application，用 environ 和 start_response 調(diào)用(實例化)它返回一個實例對象，這個實例對象本身是可迭代的，符合 WSGI 對 application 的要求。

如果想使用 AppClass 類的對象作為 application，那么必須給類添加一個 __call__ 方法，接受 environ 和 start_response 為參數(shù)，返回可迭代對象，如下所示：

class AppClass: 
    """Produce the same output, but using an object""" 
    def __call__(self, environ, start_response):  

這部分涉及到python的一些高級特性，比如 yield 和 magic method，可以參考我總結的python語言要點來理解。

Flask 中的 WSGI

flask 是一個輕量級的Python Web框架，符合 WSGI 的規(guī)范要求。它的最初版本只有 600 多行，相對便于理解。下面我們來看下它最初版本中關于 WSGI 接口的部分。

def wsgi_app(self, environ, start_response): 
    """The actual WSGI application. 
    This is not implemented in `__call__` so that middlewares can be applied: 
        app.wsgi_app = MyMiddleware(app.wsgi_app) 
    """ 
    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 __call__(self, environ, start_response): 
    """Shortcut for :attr:`wsgi_app`""" 
    return self.wsgi_app(environ, start_response)  

這里的 wsgi_app 實現(xiàn)了我們說的 application 功能，rv 是 對請求的封裝，response 是框架用來處理業(yè)務邏輯的具體函數(shù)。這里對 flask 源碼不做過多解釋，感興趣的可以去github下載，然后check 到最初版本去查看。

中間件

前面 flask 代碼 wsgi_app 函數(shù)的注釋中提到不直接在 __call__ 中實現(xiàn) application 部分，是為了可以使用中間件。 那么為什么要使用中間件，中間件又是什么呢?

回顧前面的 application/server 端接口，對于一個 HTTP 請求，server 端總是會調(diào)用一個 application 來進行處理，并返回 application 處理后的結果。這足夠應付一般的場景了，不過并不完善，考慮下面的幾種應用場景：

• 對于不同的請求(比如不同的 URL)，server 需要調(diào)用不同的 application，那么如何選擇調(diào)用哪個呢;
• 為了做負載均衡或者是遠程處理，需要使用網(wǎng)絡上其他主機上運行的 application 來做處理;
• 需要對 application 返回的內(nèi)容做一定處理后才能作為 HTTP 響應;

上面這些場景有一個共同點就是，有一些必需的操作不管放在服務端還是應用(框架)端都不合適。對應用端來說，這些操作應該由服務器端來做，對服務器端來說，這些操作應該由應用端來做。為了處理這種情況，引入了中間件。

中間件就像是應用端和服務端的橋梁，來溝通兩邊。對服務器端來說，中間件表現(xiàn)的像是應用端，對應用端來說，它表現(xiàn)的像是服務器端。如下圖所示：

 中間件

中間件的實現(xiàn)

flask 框架在 Flask 類的初始化代碼中就使用了中間件：

self.wsgi_app = SharedDataMiddleware(self.wsgi_app, { self.static_path: target })  

這里的作用和 python 中的裝飾器一樣，就是在執(zhí)行 self.wsgi_app 前后執(zhí)行 SharedDataMiddleware 中的一些內(nèi)容。中間件做的事，很類似python中裝飾器做的事情。SharedDataMiddleware 中間件是 werkzeug 庫提供的，用來支持站點托管靜態(tài)內(nèi)容。此外，還有DispatcherMiddleware 中間件，用來支持根據(jù)不同的請求，調(diào)用不同的 application，這樣就可以解決前面場景 1, 2 中的問題了。

下面來看看 DispatcherMiddleware 的實現(xiàn)：

class DispatcherMiddleware(object): 
    """Allows one to mount middlewares or applications in a WSGI application. 
    This is useful if you want to combine multiple WSGI applications:: 
        app = DispatcherMiddleware(app, { 
            '/app2':        app2, 
            '/app3':        app3 
        }) 
    """ 
    def __init__(self, app, mounts=None): 
        self.app = app 
        self.mounts = mounts or {} 
    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)  

初始化中間件時需要提供一個 mounts 字典，用來指定不同 URL 路徑到 application 的映射關系。這樣對于一個請求，中間件檢查其路徑，然后選擇合適的 application 進行處理。

關于 WSGI 的原理部分基本結束，下一篇我會介紹下對 flask 框架的理解。