深入學習和理解Django檢視層：處理請求與響應

Amd794發表於2024-05-04
Django

title: 深入學習和理解Django檢視層：處理請求與響應
date: 2024/5/4 17:47:55
updated: 2024/5/4 17:47:55
categories:

  • 後端開發

tags:

  • Django
  • 請求處理
  • 響應生成
  • 模板渲染
  • 表單處理
  • 中介軟體
  • 異常處理

image

第一章：Django框架概述

1.1 什麼是Django？

Django是一個高階的Python Web框架，它鼓勵快速開發和乾淨、實用的設計。它由Wall Street Journal的程式設計師在2005年開發，用於他們的新聞網站。自那時起，Django已經成為全球範圍內廣泛使用的Web框架之一。

Django的核心理念是“快速開發”和“穩健的防禦”，它透過以下特點實現這一點：

  • 快速開發：Django提供了一套豐富的功能，如內建的admin介面、模板引擎和資料庫遷移系統，這些功能可以幫助開發者快速構建複雜的應用程式。
  • 穩健的防禦：Django內建了許多安全功能，如防止常見Web攻擊（如XSS、CSRF、SQL隱碼攻擊等）的防護措施，以及嚴格的使用者許可權管理系統。

1.2 Django的核心元件

Django框架由多個緊密整合的元件組成，這些元件協同工作，提供了一個完整的Web應用程式開發環境。以下是Django的核心元件及其作用：

  • 模型（Models） ：模型是Django框架的基石，它們代表資料庫中的表。透過定義模型，Django自動建立資料庫結構，並提供了運算元據庫的介面。
  • 檢視（Views） ：檢視是Django處理HTTP請求的邏輯部分。它們接收來自路由器的請求，處理請求，並返回響應。檢視負責業務邏輯，並與模型互動以獲取資料。
  • 模板（Templates） ：模板是用於生成HTML頁面的文字檔案。它們允許開發者將資料（由檢視提供）插入到HTML中，從而建立動態的Web內容。Django提供了一個強大的模板語言，用於在模板中處理資料和邏輯。
  • 路由器（URL Router） ：路由器將URL路徑對映到Django檢視上。它定義了應用程式的結構，並處理使用者的URL請求，將其傳遞給相應的檢視進行處理。

這些元件共同工作，形成了一個強大的體系結構，使Django成為構建複雜Web應用程式的理想選擇。在下一章中，我們將深入探討Django的檢視層，瞭解它是如何處理請求和生成響應的。

第二章：Django檢視層基礎

2.1 檢視函式的定義和作用

在Django中，檢視函式是處理Web應用程式邏輯的關鍵部分。檢視函式負責接收HTTP請求物件，並返回HTTP響應物件。檢視函式通常定義在views.py檔案中，可以透過URL路由器對映到特定的URL路徑上。

檢視函式的定義通常如下所示：

from django.http import HttpResponse

def my_view(request):
    # 處理請求邏輯
    return HttpResponse("Hello, World!")

在上面的例子中，my_view是一個簡單的檢視函式，它接收一個request引數，代表HTTP請求物件。在函式內部，可以根據請求物件的內容進行邏輯處理，然後透過HttpResponse物件返回一個HTTP響應。

檢視函式的作用包括但不限於：

  • 處理使用者請求：接收使用者的HTTP請求，從請求中獲取資料並進行處理。
  • 生成響應：根據請求處理的結果生成HTTP響應，可以是HTML頁面、JSON資料等。
  • 業務邏輯處理：執行特定的業務邏輯，如資料查詢、計算等。
  • 路由對映：將URL請求對映到對應的檢視函式上。

2.2 類檢視的概念和用法

除了使用函式來定義檢視外，Django還提供了類檢視的概念。類檢視是基於類的檢視，透過繼承Django提供的類檢視基類，可以更方便地組織檢視邏輯。

使用類檢視的示例：

from django.views import View
from django.http import HttpResponse

class MyView(View):
    def get(self, request):
        # 處理GET請求邏輯
        return HttpResponse("Hello, World!")

在上面的例子中，MyView是一個簡單的類檢視，繼承自View類。類檢視中，我們可以透過定義類方法來處理不同型別的HTTP請求，如get()方法用於處理GET請求，post()方法用於處理POST請求等。

類檢視的優點包括：

  • 程式碼複用：可以透過繼承和重寫類方法來實現程式碼複用。
  • 可讀性：類檢視將相關的請求處理邏輯組織在一個類中，提高了程式碼的可讀性和可維護性。
  • 內建功能：Django提供了許多內建的類檢視，如ListView、DetailView等，用於快速構建常見的檢視功能。

類檢視和函式檢視在功能上是等效的，開發者可以根據個人喜好和專案需求選擇使用哪種方式來編寫檢視。

第三章：處理請求

3.1 請求物件的屬性和方法

在Django中，請求物件（HttpRequest）是一個包含了HTTP請求資訊的物件，可以透過檢視函式中的request引數來訪問。請求物件包含了許多屬性和方法，常用的包括：

  • request.method：獲取請求的HTTP方法，如GET、POST等。
  • request.GET：包含GET請求引數的字典。
  • request.POST：包含POST請求引數的字典。
  • request.FILES：包含檔案上傳的資料。
  • request.path：獲取請求的路徑部分。
  • request.META：包含請求的後設資料，如請求頭資訊。
  • request.COOKIES：包含請求中的cookie資料。
  • request.session：包含與當前會話相關的資料。
  • request.user：表示當前登入使用者的物件。

除了上述屬性外，請求物件還包含其他一些方法和屬性，用於獲取請求的資訊、處理請求資料等。

3.2 請求處理流程

在Django中，請求處理的流程如下：

  1. 中介軟體處理：當請求到達Django應用時，會先經過中介軟體的處理。中介軟體可以對請求進行預處理、後處理或者攔截請求。常見的中介軟體包括身份驗證、日誌記錄、跨域處理等。
  2. URL路由匹配：Django會根據專案中定義的URL路由規則，將請求的URL路徑對映到對應的檢視函式或類檢視上。URL路由器會根據URL配置檔案（如urls.py）中的規則進行匹配。
  3. 檢視函式呼叫：匹配到對應的檢視函式後，Django會呼叫該檢視函式來處理請求。檢視函式接收請求物件作為引數，根據請求的方法（GET、POST等）和引數進行邏輯處理，最終生成HTTP響應物件。
  4. HTTP響應返回：檢視函式生成HTTP響應物件後，Django會將該響應返回給客戶端，完成請求-響應迴圈。

整個請求處理流程中，中介軟體起到了預處理和後處理的作用，URL路由器負責將請求分發到對應的檢視函式，檢視函式則處理具體的業務邏輯並生成響應。這樣的分層設計使得Django應用具有良好的可擴充套件性和可維護性。

第四章：生成響應

4.1 響應物件的屬性和方法

在Django中，響應物件（HttpResponse）用於表示HTTP響應，包含了伺服器返回給客戶端的資訊。常用的響應物件屬性和方法包括：

  • response.status_code：獲取響應的HTTP狀態碼，如200、404等。
  • response.content：獲取響應的內容，通常是位元組流或字串。
  • response.charset：獲取響應內容的字符集。
  • response.headers：獲取響應的頭部資訊。
  • response.set_cookie()：設定cookie資訊。
  • response.delete_cookie()：刪除cookie資訊。
  • response.write()：向響應內容中寫入資料。
  • response.flush()：重新整理響應內容。

除了上述屬性和方法外，響應物件還包含其他一些方法，用於設定響應的內容、狀態碼、頭部資訊等。

4.2 響應處理流程

在Django中，響應處理的流程如下：

  1. 檢視函式生成響應：在檢視函式中，透過構造HttpResponse物件或其子類（如JsonResponse）來生成HTTP響應。檢視函式可以設定響應的內容、狀態碼、頭部資訊等。
  2. 響應傳遞：生成的響應物件會被Django傳遞給中介軟體，中介軟體可以對響應進行處理或者新增額外的資訊。
  3. 響應返回給客戶端：最終，Django會將響應物件返回給客戶端，客戶端根據響應的內容和狀態碼進行處理。常見的響應狀態碼包括200（OK）、404（Not Found）、500（Internal Server Error）等。

檢視函式根據業務邏輯生成響應物件，並透過該物件返回給客戶端，完成了請求-響應迴圈。響應處理流程中，檢視函式起到了生成響應的作用，而中介軟體則可以對響應進行進一步處理或者新增額外的資訊。這樣的設計使得Django應用能夠靈活地處理各種請求，並返回相應的響應給客戶端。

第五章：模板渲染

5.1 模板語言基礎

Django模板語言（Django Template Language）是一種用於在HTML模板中插入動態內容的語言。其基礎語法包括：

  • 變數：使用{{ variable }}語法表示變數，可以在模板中輸出變數的值。
  • 標籤：使用{% tag %}語法表示標籤，用於控制模板的邏輯，如for迴圈、if條件判斷等。
  • 過濾器：可以在變數輸出時使用過濾器，如{{ variable|filter }}，用於對變數進行格式化或處理。

示例：

<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>Hello, {{ user }}!</h1>
    
    <ul>
        {% for item in items %}
            <li>{{ item|upper }}</li>
        {% endfor %}
    </ul>
</body>
</html>

在上面的示例中，{{ title }}、{{ user }}是變數，{% for %}是標籤，|upper是過濾器。

5.2 模板渲染流程

模板渲染是將動態資料填充到模板中，生成最終的HTML頁面的過程。在Django中，模板渲染的流程如下：

  1. 檢視函式準備資料：在檢視函式中，準備需要傳遞給模板的資料，可以是單個變數、字典、列表等。
  2. 構造上下文：將資料封裝在上下文（Context）物件中，傳遞給模板引擎。
  3. 載入模板：模板引擎根據檢視函式指定的模板路徑，載入對應的模板檔案。
  4. 渲染模板：模板引擎將上下文中的資料填充到模板中，生成最終的HTML頁面。
  5. 返回響應：最終，檢視函式將渲染好的HTML頁面封裝在HttpResponse物件中返回給客戶端。

整個模板渲染流程中，檢視函式起到了準備資料和指定模板的作用，模板引擎負責將資料填充到模板中並生成HTML頁面，最終將HTML頁面返回給客戶端。這樣的設計使得前端頁面與後端資料邏輯分離，提高了程式碼的可維護性和可複用性。

第六章：表單處理

6.1 表單定義和驗證

在Django中，定義表單類是透過繼承forms.Form或forms.ModelForm來實現的。表單類定義了表單的欄位以及相應的驗證規則。

表單類定義示例：

from django import forms

class MyForm(forms.Form):
    name = forms.CharField(label='Name', max_length=100)
    email = forms.EmailField(label='Email')
    message = forms.CharField(label='Message', widget=forms.Textarea)

表單驗證過程：

  1. 在檢視函式中例項化表單類：form = MyForm(request.POST)
  2. 呼叫表單的is_valid()方法進行表單資料驗證。
  3. 如果表單資料有效，可以透過form.cleaned_data獲取經過清洗後的資料。
  4. 如果表單資料無效，可以透過form.errors獲取錯誤資訊，將錯誤資訊傳遞給模板以便顯示給使用者。

6.2 表單渲染和處理

表單渲染：

  1. 在模板中使用{{ form.as_p }}、{{ form.as_ul }}或{{ form.as_table }}來渲染表單欄位。
  2. 可以透過{{ form.field_name }}來渲染單個欄位，以及{{ form.field_name.errors }}來顯示欄位的錯誤資訊。

表單處理：

  1. 在GET請求時，渲染空白表單供使用者填寫。
  2. 在POST請求時，根據使用者提交的資料例項化表單物件。
  3. 呼叫表單的is_valid()方法進行驗證，如果表單資料有效，處理資料；如果無效，返回帶有錯誤資訊的表單給使用者重新填寫。
  4. 在處理資料時，可以透過form.cleaned_data獲取經過清洗後的資料，進行進一步處理。

示例檢視函式：

from django.shortcuts import render
from .forms import MyForm

def my_view(request):
    if request.method == 'POST':
        form = MyForm(request.POST)
        if form.is_valid():
            # 處理有效的表單資料
            return render(request, 'success.html')
    else:
        form = MyForm()
    
    return render(request, 'my_template.html', {'form': form})

在上面的示例中，MyForm是自定義的表單類，my_view是處理表單的檢視函式，根據請求的方法渲染空白表單或處理使用者提交的表單資料。

第七章：上下文處理

7.1 上下文物件的概念

在Django中，上下文（Context）是將資料從檢視傳遞給模板的一種方式。它是一個字典，其中鍵是模板中的變數名，值是這些變數的值。檢視函式透過render()或render_to_response()方法將上下文傳遞給模板，模板則使用這些資料進行渲染。

在檢視中，通常使用context引數或return render(request, 'template.html', {'key': 'value', ...})這樣的方式來設定上下文：

def my_view(request):
    data = {'name': 'John', 'age': 30}
    return render(request, 'template.html', context=data)

7.2 上下文處理器的定義和用法

Django的上下文處理器（Context Processors）是用於在檢視無需顯式設定上下文時自動新增或修改上下文的。它們是註冊在Django設定中的函式，處理函式會在每次檢視執行時被呼叫，可以修改傳遞給模板的預設上下文。

要定義一個上下文處理器，首先在settings.py中新增到TEMPLATES的OPTIONS部分的context_processors列表：

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'yourapp.context_processors.custom_processor',
            ],
        },
    },
]

然後，定義一個處理函式，例如：

from django.conf import settings
from django.template import Context, RequestContext

def custom_processor(request):
    # 在這裡新增或修改要新增到上下文的鍵值對
    if settings.DEBUG:
        context = {'is_debug': True}
    else:
        context = {}
    
    # 如果需要使用RequestContext，確保新增到模板
    return RequestContext(request, context)

這個處理器會在每次請求時自動新增is_debug鍵到上下文，如果DEBUG設定為True。如果不需要RequestContext，則直接返回context字典。

第八章：中介軟體

8.1 中介軟體的概念和作用

中介軟體（Middleware）是Django框架中一種外掛式的機制，用於在處理檢視函式前後對請求和響應進行預處理和後處理。中介軟體可以在請求到達檢視函式之前對請求進行處理，也可以在檢視函式處理完響應後對響應進行處理。

中介軟體的作用包括但不限於：

  • 在處理請求前進行身份驗證、許可權檢查等操作。
  • 在處理響應前對資料進行處理，如壓縮、加密等。
  • 記錄請求日誌、效能監控等。
  • 在異常處理中對錯誤進行處理或重定向。

8.2 中介軟體的實現和應用

要編寫和註冊中介軟體，首先需要建立一箇中介軟體類，實現process_request（處理請求前）、process_view（處理檢視前）、process_response（處理響應後）等方法中的一個或多個。

class CustomMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # 在處理請求前的邏輯
        response = self.get_response(request)
        # 在處理響應後的邏輯
        return response

然後，在settings.py中的MIDDLEWARE設定中註冊中介軟體類：

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'yourapp.middleware.CustomMiddleware',
]

中介軟體在請求-響應處理中的應用場景包括：

  • 認證和授權：在請求到達檢視前進行使用者身份驗證和許可權檢查。
  • 日誌記錄：記錄請求資訊、響應時間等用於監控和分析。
  • 異常處理：捕獲異常並返回自定義錯誤頁面或資訊。
  • 快取控制：在響應中新增快取控制頭。
  • 響應處理：對響應進行處理，如新增額外的資料或修改響應內容。
  • 安全控制：在請求到達前進行安全檢查，如跨站請求偽造（CSRF）保護等。

第九章：異常處理

9.1 異常的分類和處理

在Django中，異常通常分為兩類：系統異常（由Django框架丟擲）和自定義異常（由開發者定義）。系統異常是由Django框架在執行過程中遇到的錯誤，例如Http404和PermissionDenied。自定義異常通常用於表示應用的業務邏輯錯誤。

捕獲和處理異常

在Django中，異常處理通常透過檢視函式中的try-except塊來完成。系統異常可以透過Django的異常處理機制自動捕獲和處理，而自定義異常需要開發者自己捕獲並處理。

from django.http import HttpResponse
from django.views.generic import View

class MyView(View):
    def get(self, request, *args, **kwargs):
        try:
            # 檢視邏輯
            pass
        except SystemExit as e:
            # 系統退出異常處理
            return HttpResponse("SystemExit: " + str(e))
        except Exception as e:
            # 其他異常處理
            return HttpResponse("Exception: " + str(e))

設定異常處理器

Django預設提供了一個異常處理器django.views.exception.handler，它會在檢視函式中發生異常時被呼叫。開發者可以透過設定settings.py中的EXCEPTION_HANDLER來自定義異常處理器。

# settings.py

EXCEPTION_HANDLER = 'yourapp.utils.custom_exception_handler'

在yourapp/utils.py中定義自定義異常處理器：

# utils.py

from django.http import HttpResponse
from django.views.exception import handler

def custom_exception_handler(exc, context):
    # 獲取預設的異常處理器結果
    response = handler(exc, context)
    
    # 自定義處理邏輯
    if response is not None:
        response.content = "Custom Exception Content"
    
    return response

9.2 自定義異常處理

自定義異常處理可以讓開發者根據特定的業務需求來處理異常。在Django中，自定義異常通常繼承自django.core.exceptions.AppException或直接繼承自Exception。

# yourapp/exceptions.py

class CustomException(Exception):
    pass

在檢視函式中使用自定義異常：

# views.py

from django.http import HttpResponse
from .exceptions import CustomException
from django.views.generic import View

class MyView(View):
    def get(self, request, *args, **kwargs):
        raise CustomException("This is a custom exception")

在異常處理器中捕獲並處理自定義異常：

# utils.py

from django.http import HttpResponse
from django.views.exception import handler
from .exceptions import CustomException

def custom_exception_handler(exc, context):
    if isinstance(exc, CustomException):
        # 自定義異常處理邏輯
        return HttpResponse("Custom Exception Handled")
    
    response = handler(exc, context)
    return response

透過這種方式，開發者可以更好地控制異常的處理流程，提高應用的穩定性和使用者體驗。

附錄A：Django最佳實踐

AD: 一個覆蓋廣泛主題工具的高效線上平臺(amd794.com)

  1. 程式碼規範：

    • 命名約定：遵循PEP8（Python編碼風格指南），如模型類名以CamelCase命名，函式名以snake_case命名。
    • 分模組：將程式碼劃分為邏輯清晰的模組，如views.py, models.py, forms.py等。
    • Django模板：使用模板繼承和模板標籤提高複用性和可維護性。

AD: 漫畫首頁

  1. 效能最佳化：

    • 查詢最佳化：使用select_related和prefetch_related減少資料庫查詢次數。
    • 快取：使用django.core.cache或第三方快取庫（如Memcached或Redis）。
    • 分頁：對於大量資料，使用分頁功能，限制每頁顯示的資料量。
    • 靜態檔案處理：將靜態檔案（如CSS, JS, 圖片）託管在CDN或使用collectstatic命令。

AD: 專業的搜尋引擎

  1. 安全防範：

    • CSRF保護：確保啟用了CSRF保護，使用{% csrf_token %}標籤。
    • 密碼安全：使用get_password_hash和check_password處理使用者密碼。
    • 輸入驗證：對使用者輸入進行驗證，使用Django的ModelForm和forms模組。
    • XSS和SQL隱碼攻擊防護：使用safe和escape模板過濾器，以及django.middleware.csrf.CsrfViewMiddleware。

  2. 可維護性：

    • 文件：為程式碼編寫清晰的註釋，使用django.contrib.comments或自定義評論系統。
    • 程式碼審查：定期進行程式碼審查，遵循DRY（Don't Repeat Yourself）原則。
    • 錯誤處理：使用try/except處理可能的錯誤，提供有用的錯誤訊息。

  3. 部署：

    • 設定環境變數：使用環境變數管理配置，如DJANGO_SETTINGS_MODULE。
    • 使用部署工具：如Gunicorn, uWSGI, Nginx等。
    • 日誌記錄：啟用詳細的日誌記錄，使用logging模組。

  4. 持續整合/持續部署（CI/CD） ：使用工具如Jenkins, Travis CI或GitHub Actions自動化構建和部署過程。

遵循這些最佳實踐可以幫助你開發出更加健壯、高效和安全的Django應用。

相關文章