Web框架本質

時間  2019-12-08
標籤 web 框架 本質 欄目 HTML 简体版
原文   原文鏈接

咱們能夠這樣理解：全部的Web應用本質上就是一個socket服務端，而用戶的瀏覽器就是一個socket客戶端。 這樣咱們就能夠本身實現Web框架了。html

socket服務端 

  1. import socket  
  2.   
  3. sk = socket.socket()  
  4. sk.bind(("127.0.0.1", 80))  
  5. sk.listen()  
  6.   
  7.   
  8. while True:  
  9.     conn, addr = sk.accept()  
  10.     data = conn.recv(8096)  
  11.     conn.send(b"OK")  
  12.     conn.close()  

能夠說Web服務本質上都是在這十幾行代碼基礎上擴展出來的。這段代碼就是它們的祖宗。python

用戶在瀏覽器中輸入網址，瀏覽器會向服務端發送數據，那瀏覽器會發送什麼數據？怎麼發？這個誰來定？ 你這個網站是這個規定，他那個網站按照他那個規定，那互聯網還能玩麼？mysql

因此，必須有一個統一的規則，讓你們發送消息、接收消息的時候都有個格式依據，不能隨便寫。web

這個規則就是HTTP協議，之後瀏覽器發送請求信息也好，服務器回覆響應信息也罷，都要按照這個規則來。sql

HTTP協議主要規定了客戶端和服務器之間的通訊格式，那HTTP協議是怎麼規定消息格式的呢？數據庫

讓咱們首先打印下咱們在服務端接收到的消息是什麼。django

  1. import socket    
  2.     
  3. sk = socket.socket()    
  4. sk.bind(("127.0.0.1", 80))    
  5. sk.listen()    
  6.     
  7.     
  8. while True:    
  9.     conn, addr = sk.accept()    
  10.     data = conn.recv(8096)    
  11.     print(data)  # 將瀏覽器發來的消息打印出來    
  12.     conn.send(b"OK")    
  13.     conn.close()    

輸出：瀏覽器

b'GET / HTTP/1.1\r\nHost: 127.0.0.1:8080\r\nConnection: keep-alive\r\nCache-Control: max-age=0\r\nUpgrade-Insecure-Requests: 1\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3355.4 Safari/537.36\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8\r\nAccept-Encoding: gzip, deflate, br\r\nAccept-Language: zh-CN,zh;q=0.9\r\nCookie: csrftoken=CtHePYARJOKNx5oNVwxIteOJXpNyJ29L4bW4506YoVqFaIFFaHm0EWDZqKmw6Jm8\r\n\r\n'

咱們將\r\n替換成換行看得更清晰點：服務器

  1. GET / HTTP/1.1  
  2. Host: 127.0.0.1:8080  
  3. Connection: keep-alive  
  4. Cache-Control: max-age=0  
  5. Upgrade-Insecure-Requests: 1  
  6. User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3355.4 Safari/537.36  
  7. Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8  
  8. Accept-Encoding: gzip, deflate, br  
  9. Accept-Language: zh-CN,zh;q=0.9  
  10. Cookie: csrftoken=CtHePYARJOKNx5oNVwxIteOJXpNyJ29L4bW4506YoVqFaIFFaHm0EWDZqKmw6Jm8  
  11.   
  12.   

而後咱們再看一下咱們訪問博客園官網時瀏覽器收到的響應信息是什麼。session

響應相關信息能夠在瀏覽器調試窗口的Network標籤頁中看到。

點擊view source以後顯示以下圖：

咱們發現收發的消息須要按照必定的格式來，這裏就須要瞭解一下HTTP協議了。

HTTP協議介紹

HTTP協議對收發消息的格式要求

每一個HTTP請求和響應都遵循相同的格式，一個HTTP包含Header和Body兩部分，其中Body是可選的。

HTTP響應的Header中有一個 Content-Type代表響應的內容格式。它的值如text/html; charset=utf-8。

text/html則表示是網頁，charset=utf-8則表示編碼爲utf-8。

HTTP GET請求的格式：

HTTP響應的格式：

 自定義web框架

通過上面的學習，那咱們基於socket服務端的十幾行代碼寫一個咱們本身的web框架。咱們先不處理瀏覽器發送的請求，先讓瀏覽器能顯示咱們web框架返回的信息，那咱們就要按照HTTP協議的格式來發送響應。

  1. import socket    
  2.     
  3. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    
  4. sock.bind(('127.0.0.1', 8000))    
  5. sock.listen()    
  6.     
  7. while True:    
  8.     conn, addr = sock.accept()    
  9.     data = conn.recv(8096)    
  10.     # 給回覆的消息加上響應狀態行    
  11.     conn.send(b"HTTP/1.1 200 OK\r\n\r\n")    
  12.     conn.send(b"OK")    
  13.     conn.close()    

咱們經過十幾行代碼簡單地演示了web 框架的本質。

接下來就讓咱們繼續完善咱們的自定義web框架吧！

根據不一樣的路徑返回不一樣的內容

這樣就結束了嗎？ 如何讓咱們的Web服務根據用戶請求的URL不一樣而返回不一樣的內容呢？ 

小事一樁，咱們能夠從請求相關數據裏面拿到請求URL的路徑，而後拿路徑作一個判斷...

  1. """ 
  2. 根據URL中不一樣的路徑返回不一樣的內容 
  3. """  
  4.   
  5. import socket  
  6.   
  7. sk = socket.socket()  
  8. sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口  
  9. sk.listen()  # 監聽  
  10.   
  11. while True:  
  12.     # 等待鏈接  
  13.     conn, add = sk.accept()  
  14.     data = conn.recv(8096)  # 接收客戶端發來的消息  
  15.     # 從data中取到路徑  
  16.     data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串  
  17.     # 按\r\n分割  
  18.     data1 = data.split("\r\n")[0]  
  19.     url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑  
  20.     conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行  
  21.     # 根據不一樣的路徑返回不一樣內容  
  22.     if url == "/index/":  
  23.         response = b"index"  
  24.     elif url == "/home/":  
  25.         response = b"home"  
  26.     else:  
  27.         response = b"404 not found!"  
  28.   
  29.     conn.send(response)  
  30.     conn.close()  

根據不一樣的路徑返回不一樣的內容--函數版

上面的代碼解決了不一樣URL路徑返回不一樣內容的需求。

咱們返回的內容是簡單的幾個字符，那若是我能夠將返回的結果封裝成一個函數呢？

  1. """ 
  2. 根據URL中不一樣的路徑返回不一樣的內容--函數版 
  3. """  
  4.   
  5. import socket  
  6.   
  7. sk = socket.socket()  
  8. sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口  
  9. sk.listen()  # 監聽  
  10.   
  11.   
  12. # 將返回不一樣的內容部分封裝成函數  
  13. def func(url):  
  14.     s = "這是{}頁面！".format(url)  
  15.     return bytes(s, encoding="utf8")  
  16.   
  17.   
  18. while True:  
  19.     # 等待鏈接  
  20.     conn, add = sk.accept()  
  21.     data = conn.recv(8096)  # 接收客戶端發來的消息  
  22.     # 從data中取到路徑  
  23.     data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串  
  24.     # 按\r\n分割  
  25.     data1 = data.split("\r\n")[0]  
  26.     url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑  
  27.     conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行  
  28.     # 根據不一樣的路徑返回不一樣內容，response是具體的響應體  
  29.     if url == "/index/":  
  30.         response = func(url)  
  31.     elif url == "/home/":  
  32.         response = func(url)  
  33.     else:  
  34.         response = b"404 not found!"  
  35.   
  36.     conn.send(response)  
  37.     conn.close()  

根據不一樣的路徑返回不一樣的內容--函數進階版

看起來上面的代碼寫了一個函數，那確定能夠寫多個函數，不一樣的路徑對應執行不一樣的函數拿到結果，可是咱們要一個個判斷路徑，是否是很麻煩？咱們有簡單的辦法來解決。

  1. """ 
  2. 根據URL中不一樣的路徑返回不一樣的內容--函數進階版 
  3. """  
  4.   
  5. import socket  
  6.   
  7. sk = socket.socket()  
  8. sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口  
  9. sk.listen()  # 監聽  
  10.   
  11.   
  12. # 將返回不一樣的內容部分封裝成不一樣的函數  
  13. def index(url):  
  14.     s = "這是{}頁面XX！".format(url)  
  15.     return bytes(s, encoding="utf8")  
  16.   
  17.   
  18. def home(url):  
  19.     s = "這是{}頁面。。！".format(url)  
  20.     return bytes(s, encoding="utf8")  
  21.   
  22.   
  23. # 定義一個url和實際要執行的函數的對應關係  
  24. list1 = [  
  25.     ("/index/", index),  
  26.     ("/home/", home),  
  27. ]  
  28.   
  29. while True:  
  30.     # 等待鏈接  
  31.     conn, add = sk.accept()  
  32.     data = conn.recv(8096)  # 接收客戶端發來的消息  
  33.     # 從data中取到路徑  
  34.     data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串  
  35.     # 按\r\n分割  
  36.     data1 = data.split("\r\n")[0]  
  37.     url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑  
  38.     conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行  
  39.     # 根據不一樣的路徑返回不一樣內容  
  40.     func = None  # 定義一個保存將要執行的函數名的變量  
  41.     for item in list1:  
  42.         if item[0] == url:  
  43.             func = item[1]  
  44.             break  
  45.     if func:  
  46.         response = func(url)  
  47.     else:  
  48.         response = b"404 not found!"  
  49.   
  50.     # 返回具體的響應消息  
  51.     conn.send(response)  
  52.     conn.close()  

返回具體的HTML文件

完美解決了不一樣URL返回不一樣內容的問題。 可是我不想僅僅返回幾個字符串，我想給瀏覽器返回完整的HTML內容，這又該怎麼辦呢？

沒問題，不論是什麼內容，最後都是轉換成字節數據發送出去的。 咱們能夠打開HTML文件，讀取出它內部的二進制數據，而後再發送給瀏覽器。

  1. """ 
  2. 根據URL中不一樣的路徑返回不一樣的內容--函數進階版 
  3. 返回獨立的HTML頁面 
  4. """  
  5.   
  6. import socket  
  7.   
  8. sk = socket.socket()  
  9. sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口  
  10. sk.listen()  # 監聽  
  11.   
  12.   
  13. # 將返回不一樣的內容部分封裝成不一樣的函數  
  14. def index(url):  
  15.     # 讀取index.html頁面的內容  
  16.     with open("index.html", "r", encoding="utf8") as f:  
  17.         s = f.read()  
  18.     # 返回字節數據  
  19.     return bytes(s, encoding="utf8")  
  20.   
  21.   
  22. def home(url):  
  23.     with open("home.html", "r", encoding="utf8") as f:  
  24.         s = f.read()  
  25.     return bytes(s, encoding="utf8")  
  26.   
  27.   
  28. # 定義一個url和實際要執行的函數的對應關係  
  29. list1 = [  
  30.     ("/index/", index),  
  31.     ("/home/", home),  
  32. ]  
  33.   
  34. while True:  
  35.     # 等待鏈接  
  36.     conn, add = sk.accept()  
  37.     data = conn.recv(8096)  # 接收客戶端發來的消息  
  38.     # 從data中取到路徑  
  39.     data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串  
  40.     # 按\r\n分割  
  41.     data1 = data.split("\r\n")[0]  
  42.     url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑  
  43.     conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行  
  44.     # 根據不一樣的路徑返回不一樣內容  
  45.     func = None  # 定義一個保存將要執行的函數名的變量  
  46.     for item in list1:  
  47.         if item[0] == url:  
  48.             func = item[1]  
  49.             break  
  50.     if func:  
  51.         response = func(url)  
  52.     else:  
  53.         response = b"404 not found!"  
  54.   
  55.     # 返回具體的響應消息  
  56.     conn.send(response)  
  57.     conn.close()  
  index.html
  home.html

讓網頁動態起來

這網頁可以顯示出來了，可是都是靜態的啊。頁面的內容都不會變化的，我想要的是動態網站。

沒問題，我也有辦法解決。我選擇使用字符串替換來實現這個需求。（這裏使用時間戳來模擬動態的數據）

  1. """ 
  2. 根據URL中不一樣的路徑返回不一樣的內容--函數進階版 
  3. 返回獨立的HTML頁面 
  4. """  
  5.   
  6. import socket  
  7.   
  8. sk = socket.socket()  
  9. sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口  
  10. sk.listen()  # 監聽  
  11.   
  12.   
  13. # 將返回不一樣的內容部分封裝成不一樣的函數  
  14. def index(url):  
  15.     # 讀取index.html頁面的內容  
  16.     with open("index.html", "r", encoding="utf8") as f:  
  17.         s = f.read()  
  18.     # 返回字節數據  
  19.     return bytes(s, encoding="utf8")  
  20.   
  21.   
  22. def home(url):  
  23.     with open("home.html", "r", encoding="utf8") as f:  
  24.         s = f.read()  
  25.     return bytes(s, encoding="utf8")  
  26.   
  27.   
  28. def timer(url):  
  29.     import time  
  30.     with open("time.html", "r", encoding="utf8") as f:  
  31.         s = f.read()  
  32.         s = s.replace('@@time@@', time.strftime("%Y-%m-%d %H:%M:%S"))  
  33.     return bytes(s, encoding="utf8")  
  34.   
  35.   
  36. # 定義一個url和實際要執行的函數的對應關係  
  37. list1 = [  
  38.     ("/index/", index),  
  39.     ("/home/", home),  
  40.     ("/time/", timer),  
  41. ]  
  42.   
  43. while True:  
  44.     # 等待鏈接  
  45.     conn, add = sk.accept()  
  46.     data = conn.recv(8096)  # 接收客戶端發來的消息  
  47.     # 從data中取到路徑  
  48.     data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串  
  49.     # 按\r\n分割  
  50.     data1 = data.split("\r\n")[0]  
  51.     url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑  
  52.     conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行  
  53.     # 根據不一樣的路徑返回不一樣內容  
  54.     func = None  # 定義一個保存將要執行的函數名的變量  
  55.     for item in list1:  
  56.         if item[0] == url:  
  57.             func = item[1]  
  58.             break  
  59.     if func:  
  60.         response = func(url)  
  61.     else:  
  62.         response = b"404 not found!"  
  63.   
  64.     # 返回具體的響應消息  
  65.     conn.send(response)  
  66.     conn.close()  

服務器程序和應用程序

對於真實開發中的python web程序來講，通常會分爲兩部分：服務器程序和應用程序。

服務器程序負責對socket服務端進行封裝，並在請求到來時，對請求的各類數據進行整理。

應用程序則負責具體的邏輯處理。爲了方便應用程序的開發，就出現了衆多的Web框架，例如：Django、Flask、web.py 等。不一樣的框架有不一樣的開發方式，可是不管如何，開發出的應用程序都要和服務器程序配合，才能爲用戶提供服務。

 

這樣，服務器程序就須要爲不一樣的框架提供不一樣的支持。這樣混亂的局面不管對於服務器仍是框架，都是很差的。對服務器來講，須要支持各類不一樣框架，對框架來講，只有支持它的服務器才能被開發出的應用使用。

這時候，標準化就變得尤其重要。咱們能夠設立一個標準，只要服務器程序支持這個標準，框架也支持這個標準，那麼他們就能夠配合使用。一旦標準肯定，雙方各自實現。這樣，服務器能夠支持更多支持標準的框架，框架也可使用更多支持標準的服務器。

WSGI（Web Server Gateway Interface）就是一種規範，它定義了使用Python編寫的web應用程序與web服務器程序之間的接口格式，實現web應用程序與web服務器程序間的解耦。

經常使用的WSGI服務器有uwsgi、Gunicorn。而Python標準庫提供的獨立WSGI服務器叫wsgiref，Django開發環境用的就是這個模塊來作服務器。

 

從這繼續...

wsgiref

咱們利用wsgiref模塊來替換咱們本身寫的web框架的socket server部分：

  1. """  
  2. 根據URL中不一樣的路徑返回不一樣的內容--函數進階版  
  3. 返回HTML頁面  
  4. 讓網頁動態起來  
  5. wsgiref模塊版  
  6. """   
  7.      
  8. from wsgiref.simple_server import make_server   
  9.      
  10.      
  11. # 將返回不一樣的內容部分封裝成函數   
  12. def index(url):   
  13.     # 讀取index.html頁面的內容   
  14.     with open("index.html", "r", encoding="utf8") as f:   
  15.         s = f.read()   
  16.     # 返回字節數據   
  17.     return bytes(s, encoding="utf8")   
  18.      
  19.      
  20. def home(url):   
  21.     with open("home.html", "r", encoding="utf8") as f:   
  22.         s = f.read()   
  23.     return bytes(s, encoding="utf8")   
  24.      
  25.      
  26. def timer(url):   
  27.     import time   
  28.     with open("time.html", "r", encoding="utf8") as f:   
  29.         s = f.read()   
  30.         s = s.replace('@@time@@', time.strftime("%Y-%m-%d %H:%M:%S"))   
  31.     return bytes(s, encoding="utf8")   
  32.      
  33.      
  34. # 定義一個url和實際要執行的函數的對應關係   
  35. list1 = [   
  36.     ("/index/", index),   
  37.     ("/home/", home),   
  38.     ("/time/", timer),   
  39. ]   
  40.      
  41.      
  42. def run_server(environ, start_response):   
  43.     start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ])  # 設置HTTP響應的狀態碼和頭信息   
  44.     url = environ['PATH_INFO']  # 取到用戶輸入的url   
  45.     func = None   
  46.     for i in list1:   
  47.         if i[0] == url:   
  48.             func = i[1]   
  49.             break   
  50.     if func:   
  51.         response = func(url)   
  52.     else:   
  53.         response = b"404 not found!"   
  54.     return [response, ]   
  55.      
  56.      
  57. if __name__ == '__main__':   
  58.     httpd = make_server('127.0.0.1', 8090, run_server)   
  59.     print("我在8090等你哦...")   
  60.     httpd.serve_forever()  

jinja2

上面的代碼實現了一個簡單的動態，我徹底能夠從數據庫中查詢數據，而後去替換我html中的對應內容，而後再發送給瀏覽器完成渲染。 這個過程就至關於HTML模板渲染數據。 本質上就是HTML內容中利用一些特殊的符號來替換要展現的數據。 我這裏用的特殊符號是我定義的，其實模板渲染有個現成的工具： jinja2

下載jinja2:

pip install jinja2
  index2.html文件

使用jinja2渲染index2.html文件：

  1. from wsgiref.simple_server import make_server  
  2. from jinja2 import Template  
  3.   
  4.   
  5. def index(url):  
  6.     # 讀取HTML文件內容  
  7.     with open("index2.html", "r", encoding="utf8") as f:  
  8.         data = f.read()  
  9.         template = Template(data)   # 生成模板文件  
  10.         ret = template.render({'name': 'alex', 'hobby_list': ['抽菸', '喝酒', '燙頭']})   # 把數據填充到模板中  
  11.     return bytes(ret, encoding="utf8")  
  12.   
  13.   
  14. def home(url):  
  15.     with open("home.html", "r", encoding="utf8") as f:  
  16.         s = f.read()  
  17.     return bytes(s, encoding="utf8")  
  18.   
  19.   
  20. # 定義一個url和實際要執行的函數的對應關係  
  21. list1 = [  
  22.     ("/index/", index),  
  23.     ("/home/", home),  
  24. ]  
  25.   
  26.   
  27. def run_server(environ, start_response):  
  28.     start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ])  # 設置HTTP響應的狀態碼和頭信息  
  29.     url = environ['PATH_INFO']  # 取到用戶輸入的url  
  30.     func = None  
  31.     for i in list1:  
  32.         if i[0] == url:  
  33.             func = i[1]  
  34.             break  
  35.     if func:  
  36.         response = func(url)  
  37.     else:  
  38.         response = b"404 not found!"  
  39.     return [response, ]  
  40.   
  41.   
  42. if __name__ == '__main__':  
  43.     httpd = make_server('127.0.0.1', 8090, run_server)  
  44.     print("我在8090等你哦...")  
  45.     httpd.serve_forever()  

如今的數據是咱們本身手寫的，那可不能夠從數據庫中查詢數據，來填充頁面呢？

使用pymysql鏈接數據庫：

複製代碼 
conn = pymysql.connect(host="127.0.0.1", port=3306, user="root", passwd="xxx", db="xxx", charset="utf8")
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select name, age, department_id from userinfo")
user_list = cursor.fetchall()
cursor.close()
conn.close()
複製代碼

建立一個測試的user表：

CREATE TABLE user(
  id int auto_increment PRIMARY KEY,
  name CHAR(10) NOT NULL,
  hobby CHAR(20) NOT NULL
)engine=innodb DEFAULT charset=UTF8;

模板的原理就是字符串替換，咱們只要在HTML頁面中遵循jinja2的語法規則寫上，其內部就會按照指定的語法進行相應的替換，從而達到動態的返回內容。

Django

Django官網下載頁面

安裝（安裝最新LTS版）：

pip3 install django==1.11.15

建立一個django項目：

下面的命令建立了一個名爲"mysite"的Django 項目：

django-admin startproject mysite

目錄介紹：

複製代碼 
mysite/
├── manage.py  # 管理文件
└── mysite  # 項目目錄
    ├── __init__.py
    ├── settings.py  # 配置
    ├── urls.py  # 路由 --> URL和函數的對應關係
    └── wsgi.py  # runserver命令就使用wsgiref模塊作簡單的web server
複製代碼

運行Django項目：

python manage.py runserver 127.0.0.1:8000

模板文件配置：

複製代碼 
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, "template")],  # template文件夾位置
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]
複製代碼

靜態文件配置：

STATIC_URL = '/static/'  # HTML中使用的靜態文件夾前綴
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "static"),  # 靜態文件存放位置
]

看不明白？有圖有真相：

剛開始學習時可在配置文件中暫時禁用csrf中間件，方便表單提交測試。

複製代碼 
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
複製代碼

Django基礎必備三件套：

from django.shortcuts import HttpResponse, render, redirect

HttpResponse

內部傳入一個字符串參數，返回給瀏覽器。

例如：

def index(request):
    # 業務邏輯代碼
    return HttpResponse("OK")

render

除request參數外還接受一個待渲染的模板文件和一個保存具體數據的字典參數。

將數據填充進模板文件，最後把結果返回給瀏覽器。（相似於咱們上面用到的jinja2）

例如：

def index(request):
    # 業務邏輯代碼
    return render(request, "index.html", {"name": "alex", "hobby": ["燙頭", "泡吧"]})

redirect

接受一個URL參數，表示跳轉到指定的URL。

例如：

def index(request):
    # 業務邏輯代碼
    return redirect("/home/")

重定向是怎麼回事？

啓動Django報錯：

Django 啓動時報錯 UnicodeEncodeError ...

報這個錯誤一般是由於計算機名爲中文，改爲英文的計算機名重啓下電腦就能夠了。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程