[[170310]]

在***部分中，我提出了一個問題：“如何在你剛剛搭建起來的 Web 服務器上適配 Django, Flask 或 Pyramid 應用，而不用單獨對 Web 服務器做做出改動以適應各種不同的 Web 框架呢?”我們可以從這一篇中找到答案。

曾幾何時，你所選擇的 Python Web 框架會限制你所可選擇的 Web 服務器，反之亦然。如果某個框架及服務器設計用來協同工作的，那么一切正常：

但你可能正面對著(或者曾經面對過)嘗試將一對無法適配的框架和服務器搭配在一起的問題：

基本上，你需要選擇那些能夠一起工作的框架和服務器，而不能選擇你想用的那些。

所以，你該如何確保在不對 Web 服務器或框架的代碼做任何更改的情況下，讓你的 Web 服務器和多個不同的 Web 框架一同工作呢?這個問題的答案，就是 Python Web 服務器網關接口(Web Server Gateway Interface )(縮寫為 WSGI，念做“wizgy”)。

WSGI 允許開發者互不干擾地選擇 Web 框架及 Web 服務器的類型。現在，你可以真正將 Web 服務器及框架任意搭配，然后選出你最中意的那對組合。比如，你可以使用 Django，Flask 或者 Pyramid，與 Gunicorn，Nginx/uWSGI 或 Waitress 進行結合。感謝 WSGI 同時對服務器與框架的支持，我們可以真正隨意選擇它們的搭配了。

所以，WSGI 就是我在***部分中提出，又在本文開頭重復了一遍的那個問題的答案。你的 Web 服務器必須實現 WSGI 接口的服務器部分，而現代的 Python Web 框架均已實現了 WSGI 接口的框架部分，這使得你可以直接在 Web 服務器中使用任意框架，而不需要更改任何服務器代碼，以對特定的 Web 框架實現兼容。

現在，你已經知道 Web 服務器及 Web 框架對 WSGI 的支持使得你可以選擇最合適的一對來使用，而且它也有利于服務器和框架的開發者，這樣他們只需專注于其擅長的部分來進行開發，而不需要觸及另一部分的代碼。其它語言也擁有類似的接口，比如：Java 擁有 Servlet API，而 Ruby 擁有 Rack。

這些理論都不錯，但是我打賭你在說：“Show me the code!” 那好，我們來看看下面這個很小的 WSGI 服務器實現：

### 使用 Python 2.7.9，在 Linux 及 Mac OS X 下測試通過 
import socket 
import StringIO 
import sys 
class WSGIServer(object): 
    address_family = socket.AF_INET 
    socket_type = socket.SOCK_STREAM 
    request_queue_size = 1 
    def __init__(self, server_address): 
        ### 創建一個監聽的套接字 
        self.listen_socket = listen_socket = socket.socket( 
            self.address_family, 
            self.socket_type 
        ) 
        ### 允許復用同一地址 
        listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 
        ### 綁定地址 
        listen_socket.bind(server_address) 
        ### 激活套接字 
        listen_socket.listen(self.request_queue_size) 
        ### 獲取主機的名稱及端口 
        host, port = self.listen_socket.getsockname()[:2] 
        self.server_name = socket.getfqdn(host) 
        self.server_port = port 
        ### 返回由 Web 框架/應用設定的響應頭部字段 
        self.headers_set = [] 
    def set_app(self, application): 
        self.application = application 
    def serve_forever(self): 
        listen_socket = self.listen_socket 
        while True: 
            ### 獲取新的客戶端連接 
            self.client_connection, client_address = listen_socket.accept() 
            ### 處理一條請求后關閉連接，然后循環等待另一個連接建立 
            self.handle_one_request() 
    def handle_one_request(self): 
        self.request_data = request_data = self.client_connection.recv(1024) 
        ### 以 'curl -v' 的風格輸出格式化請求數據 
        print(''.join( 
            '< {line}\n'.format(line=line) 
            for line in request_data.splitlines() 
        )) 
        self.parse_request(request_data) 
        ### 根據請求數據構建環境變量字典 
        env = self.get_environ() 
        ### 此時需要調用 Web 應用來獲取結果， 
        ### 取回的結果將成為 HTTP 響應體 
        result = self.application(env, self.start_response) 
        ### 構造一個響應，回送至客戶端 
        self.finish_response(result) 
    def parse_request(self, text): 
        request_line = text.splitlines()[0] 
        request_line = request_line.rstrip('\r\n') 
        ### 將請求行分成幾個部分 
        (self.request_method,  # GET 
         self.path,            # /hello 
         self.request_version  # HTTP/1.1 
         ) = request_line.split() 
    def get_environ(self): 
        env = {} 
        ### 以下代碼段沒有遵循 PEP8 規則，但這樣排版，是為了通過強調 
        ### 所需變量及它們的值，來達到其展示目的。 
        ### 
        ### WSGI 必需變量 
        env['wsgi.version']      = (1, 0) 
        env['wsgi.url_scheme']   = 'http' 
        env['wsgi.input']        = StringIO.StringIO(self.request_data) 
        env['wsgi.errors']       = sys.stderr 
        env['wsgi.multithread']  = False 
        env['wsgi.multiprocess'] = False 
        env['wsgi.run_once']     = False 
        ### CGI 必需變量 
        env['REQUEST_METHOD']    = self.request_method    # GET 
        env['PATH_INFO']         = self.path              # /hello 
        env['SERVER_NAME']       = self.server_name       # localhost 
        env['SERVER_PORT']       = str(self.server_port)  # 8888 
        return env 
    def start_response(self, status, response_headers, exc_info=None): 
        ### 添加必要的服務器頭部字段 
        server_headers = [ 
            ('Date', 'Tue, 31 Mar 2015 12:54:48 GMT'), 
            ('Server', 'WSGIServer 0.2'), 
        ] 
        self.headers_set = [status, response_headers + server_headers] 
        ### 為了遵循 WSGI 協議，start_response 函數必須返回一個 'write' 
        ### 可調用對象（返回值.write 可以作為函數調用）。為了簡便，我們 
        ### 在這里無視這個細節。 
        ### return self.finish_response 
    def finish_response(self, result): 
        try: 
            status, response_headers = self.headers_set 
            response = 'HTTP/1.1 {status}\r\n'.format(status=status) 
            for header in response_headers: 
                response += '{0}: {1}\r\n'.format(*header) 
            response += '\r\n' 
            for data in result: 
                response += data 
            ### 以 'curl -v' 的風格輸出格式化請求數據 
            print(''.join( 
                '> {line}\n'.format(line=line) 
                for line in response.splitlines() 
            )) 
            self.client_connection.sendall(response) 
        finally: 
            self.client_connection.close() 
SERVER_ADDRESS = (HOST, PORT) = '', 8888 
def make_server(server_address, application): 
    server = WSGIServer(server_address) 
    server.set_app(application) 
    return server 
if __name__ == '__main__': 
    if len(sys.argv) < 2: 
        sys.exit('Provide a WSGI application object as module:callable') 
    app_path = sys.argv[1] 
    module, application = app_path.split(':') 
    module = __import__(module) 
    application = getattr(module, application) 
    httpd = make_server(SERVER_ADDRESS, application) 
    print('WSGIServer: Serving HTTP on port {port} ...\n'.format(port=PORT)) 
    httpd.serve_forever() 

當然，這段代碼要比***部分的服務器代碼長不少，但它仍然很短(只有不到 150 行)，你可以輕松理解它，而不需要深究細節。上面的服務器代碼還可以做更多——它可以用來運行一些你喜歡的框架寫出的 Web 應用，可以是 Pyramid，Flask，Django 或其它 Python WSGI 框架。

不相信嗎?自己來試試看吧。把以上的代碼保存為 webserver2.py，或直接從 Github 上下載它。如果你打算不加任何參數而直接運行它，它會抱怨一句，然后退出。

$ python webserver2.py 
Provide a WSGI application object as module:callable 

它想做的其實是為你的 Web 應用服務，而這才是重頭戲。為了運行這個服務器，你唯一需要的就是安裝好 Python。不過，如果你希望運行 Pyramid，Flask 或 Django 應用，你還需要先安裝那些框架。那我們把這三個都裝上吧。我推薦的安裝方式是通過 virtualenv 安裝。按照以下幾步來做，你就可以創建并激活一個虛擬環境，并在其中安裝以上三個 Web 框架。

$ [sudo] pip install virtualenv 
$ mkdir ~/envs 
$ virtualenv ~/envs/lsbaws/ 
$ cd ~/envs/lsbaws/ 
$ ls 
bin  include  lib 
$ source bin/activate 
(lsbaws) $ pip install pyramid 
(lsbaws) $ pip install flask 
(lsbaws) $ pip install django 

現在，你需要創建一個 Web 應用。我們先從 Pyramid 開始吧。把以下代碼保存為 pyramidapp.py，并與剛剛的 webserver2.py 放置在同一目錄，或直接從 Github 下載該文件：

from pyramid.config import Configurator 
from pyramid.response import Response 
def hello_world(request): 
    return Response( 
        'Hello world from Pyramid!\n', 
        content_type='text/plain', 
    ) 
config = Configurator() 
config.add_route('hello', '/hello') 
config.add_view(hello_world, route_name='hello') 
app = config.make_wsgi_app() 

現在，你可以用你自己的 Web 服務器來運行你的 Pyramid 應用了：

(lsbaws) $ python webserver2.py pyramidapp:app 
WSGIServer: Serving HTTP on port 8888 ... 

你剛剛讓你的服務器去加載 Python 模塊 pyramidapp 中的可執行對象 app。現在你的服務器可以接收請求，并將它們轉發到你的 Pyramid 應用中了。在瀏覽器中輸入 http://localhost:8888/hello ，敲一下回車，然后看看結果：

你也可以使用命令行工具 curl 來測試服務器：

$ curl -v http://localhost:8888/hello 
... 

看看服務器和 curl 向標準輸出流打印的內容吧。

現在來試試 Flask。運行步驟跟上面的一樣

from flask import Flask 
from flask import Response 
flask_app = Flask('flaskapp') 
@flask_app.route('/hello') 
def hello_world(): 
    return Response( 
        'Hello world from Flask!\n', 
        mimetype='text/plain' 
    ) 
app = flask_app.wsgi_app 

將以上代碼保存為 flaskapp.py，或者直接從 Github 下載，然后輸入以下命令運行服務器：

(lsbaws) $ python webserver2.py flaskapp:app 
WSGIServer: Serving HTTP on port 8888 ... 

現在在瀏覽器中輸入 http://localhost:8888/hello ，敲一下回車：

同樣，嘗試一下 curl，然后你會看到服務器返回了一條 Flask 應用生成的信息：

$ curl -v http://localhost:8888/hello 
... 

這個服務器能處理 Django 應用嗎?試試看吧!不過這個任務可能有點復雜，所以我建議你將整個倉庫克隆下來，然后使用 Github 倉庫中的 djangoapp.py 來完成這個實驗。這里的源代碼主要是將 Django 的 helloworld 工程(已使用 Django 的 django-admin.py startproject 命令創建完畢)添加到了當前的 Python 路徑中，然后導入了這個工程的 WSGI 應用。(LCTT 譯注：除了這里展示的代碼，還需要一個配合的 helloworld 工程才能工作，代碼可以參見 Github 倉庫。)

import sys 
sys.path.insert(0, './helloworld') 
from helloworld import wsgi 
app = wsgi.application 

將以上代碼保存為 djangoapp.py，然后用你的 Web 服務器運行這個 Django 應用：

(lsbaws) $ python webserver2.py djangoapp:app 
WSGIServer: Serving HTTP on port 8888 ... 

輸入以下鏈接，敲回車：

你這次也可以在命令行中測試——你之前應該已經做過兩次了——來確認 Django 應用處理了你的請求：

$ curl -v http://localhost:8888/hello 
... 

你試過了嗎?你確定這個服務器可以與那三個框架搭配工作嗎?如果沒試，請去試一下。閱讀固然重要，但這個系列的內容是重新搭建，這意味著你需要親自動手干點活。去試一下吧。別擔心，我等著你呢。不開玩笑，你真的需要試一下，親自嘗試每一步，并確保它像預期的那樣工作。

好，你已經體驗到了 WSGI 的威力：它可以使 Web 服務器及 Web 框架隨意搭配。WSGI 在 Python Web 服務器及框架之間提供了一個微型接口。它非常簡單，而且在服務器和框架端均可以輕易實現。下面的代碼片段展示了 WSGI 接口的服務器及框架端實現：

def run_application(application): 
    """服務器端代碼。""" 
    ### Web 應用/框架在這里存儲 HTTP 狀態碼以及 HTTP 響應頭部， 
    ### 服務器會將這些信息傳遞給客戶端 
    headers_set = [] 
    ### 用于存儲 WSGI/CGI 環境變量的字典 
    environ = {} 
    def start_response(status, response_headers, exc_info=None): 
        headers_set[:] = [status, response_headers] 
    ### 服務器喚醒可執行變量“application”，獲得響應頭部 
    result = application(environ, start_response) 
    ### 服務器組裝一個 HTTP 響應，將其傳送至客戶端 
    … 
def app(environ, start_response): 
    """一個空的 WSGI 應用""" 
    start_response('200 OK', [('Content-Type', 'text/plain')]) 
    return ['Hello world!'] 
run_application(app) 

這是它的工作原理：

1. Web 框架提供一個可調用對象 application (WSGI 規范沒有規定它的實現方式)。
2. Web 服務器每次收到來自客戶端的 HTTP 請求后，會喚醒可調用對象 applition。它會向該對象傳遞一個包含 WSGI/CGI 變量的環境變量字典 environ，以及一個可調用對象 start_response。
3. Web 框架或應用生成 HTTP 狀態碼和 HTTP 響應頭部，然后將它傳給 start_response 函數，服務器會將其存儲起來。同時，Web 框架或應用也會返回 HTTP 響應正文。
4. 服務器將狀態碼、響應頭部及響應正文組裝成一個 HTTP 響應，然后將其傳送至客戶端(這一步并不在 WSGI 規范中，但從邏輯上講，這一步應該包含在工作流程之中。所以為了明確這個過程，我把它寫了出來)

這是這個接口規范的圖形化表達：

到現在為止，你已經看過了用 Pyramid、Flask 和 Django 寫出的 Web 應用的代碼，你也看到了一個 Web 服務器如何用代碼來實現另一半(服務器端的) WSGI 規范。你甚至還看到了我們如何在不使用任何框架的情況下，使用一段代碼來實現一個最簡單的 WSGI Web 應用。

其實，當你使用上面的框架編寫一個 Web 應用時，你只是在較高的層面工作，而不需要直接與 WSGI 打交道。但是我知道你一定也對 WSGI 接口的框架部分感興趣，因為你在看這篇文章呀。所以，我們不用 Pyramid、Flask 或 Django，而是自己動手來創造一個最樸素的 WSGI Web 應用(或 Web 框架)，然后將它和你的服務器一起運行：

def app(environ, start_response): 
    """一個最簡單的 WSGI 應用。 
    這是你自己的 Web 框架的起點 ^_^ 
    """ 
    status = '200 OK' 
    response_headers = [('Content-Type', 'text/plain')] 
    start_response(status, response_headers) 
    return ['Hello world from a simple WSGI application!\n'] 

同樣，將上面的代碼保存為 wsgiapp.py 或直接從 Github 上下載該文件，然后在 Web 服務器上運行這個應用，像這樣：

(lsbaws) $ python webserver2.py wsgiapp:app 
WSGIServer: Serving HTTP on port 8888 ... 

在瀏覽器中輸入下面的地址，然后按下回車。這是你應該看到的結果：

你剛剛在學習如何創建一個 Web 服務器的過程中自己編寫了一個最樸素的 WSGI Web 框架!棒極了!

現在，我們再回來看看服務器傳給客戶端的那些東西。這是在使用 HTTP 客戶端調用你的 Pyramid 應用時，服務器生成的 HTTP 響應內容：

這個響應和你在本系列***部分中看到的 HTTP 響應有一部分共同點，但它還多出來了一些內容。比如說，它擁有四個你曾經沒見過的 HTTP 頭部：Content-Type, Content-Length, Date 以及 Server。這些頭部內容基本上在每個 Web 服務器返回的響應中都會出現。不過，它們都不是被嚴格要求出現的。這些 HTTP 請求/響應頭部字段的目的在于它可以向你傳遞一些關于 HTTP 請求/響應的額外信息。

既然你對 WSGI 接口了解的更深了一些，那我再來展示一下上面那個 HTTP 響應中的各個部分的信息來源：

我現在還沒有對上面那個 environ 字典做任何解釋，不過基本上這個字典必須包含那些被 WSGI 規范事先定義好的 WSGI 及 CGI 變量值。服務器在解析 HTTP 請求時，會從請求中獲取這些變量的值。這是 environ 字典應該有的樣子：

Web 框架會利用以上字典中包含的信息，通過字典中的請求路徑、請求動作等等來決定使用哪個視圖來處理響應、在哪里讀取請求正文、在哪里輸出錯誤信息(如果有的話)。

現在，你已經創造了屬于你自己的 WSGI Web 服務器，你也使用不同 Web 框架做了幾個 Web 應用。而且，你在這個過程中也自己創造出了一個樸素的 Web 應用及框架。這個過程真是累人。現在我們來回顧一下，你的 WSGI Web 服務器在服務請求時，需要針對 WSGI 應用做些什么：

• 首先，服務器開始工作，然后會加載一個可調用對象 application，這個對象由你的 Web 框架或應用提供
• 然后，服務器讀取一個請求
• 然后，服務器會解析這個請求
• 然后，服務器會使用請求數據來構建一個 environ 字典
• 然后，它會用 environ 字典及一個可調用對象 start_response 作為參數，來調用 application，并獲取響應體內容。
• 然后，服務器會使用 application 返回的響應體，和 start_response 函數設置的狀態碼及響應頭部內容，來構建一個 HTTP 響應。
• 最終，服務器將 HTTP 響應回送給客戶端。

這基本上是服務器要做的全部內容了。你現在有了一個可以正常工作的 WSGI 服務器，它可以為使用任何遵循 WSGI 規范的 Web 框架(如 Django、Flask、Pyramid，還有你剛剛自己寫的那個框架)構建出的 Web 應用服務。最棒的部分在于，它可以在不用更改任何服務器代碼的情況下，與多個不同的 Web 框架一起工作。真不錯。

在結束之前，你可以想想這個問題：“你該如何讓你的服務器在同一時間處理多個請求呢?”

敬請期待，我會在第三部分向你展示一種解決這個問題的方法。干杯!

順便，我在撰寫一本名為《搭個 Web 服務器：從頭開始》的書。這本書講解了如何從頭開始編寫一個基本的 Web 服務器，里面包含本文中沒有的更多細節。訂閱郵件列表，你就可以獲取到這本書的***進展，以及發布日期。