跳至主要内容

5 篇文章 含有標籤「RESTful」

檢視所有標籤

Django Middleware 入門教學筆記

· 閱讀時間約 4 分鐘
kdchang

前言

在 Web 應用程式中,每一次的 HTTP 請求與回應都會經過一連串的處理流程。在 Django 框架中,這些處理流程的攔截點與操作邏輯就是透過「Middleware(中介軟體)」來實現。

Middleware 是 Django 請求與回應處理流程中一個極為關鍵的機制,允許開發者在請求進入 View 前或回應送出前進行特定操作,例如:身份驗證、日誌紀錄、權限控制、跨域處理、錯誤攔截、壓縮回應等。

掌握 Middleware 的基本原理與撰寫方式,將有助於你更靈活地控制整個應用程式的行為與安全性。


重點摘要

  • Middleware 是介於「請求 → View → 回應」流程中,可插入自訂邏輯的中介處理元件。

  • 每個 Middleware 類別皆需實作特定的方法,如 __call__()process_request()process_response()

  • Middleware 可用於:日誌、認證、CORS、壓縮、IP 限制、防止 CSRF 等。

  • 所有 Middleware 的執行順序依 settings.pyMIDDLEWARE 設定順序為準。

  • Middleware 執行順序為:

    • 請求階段(request):從上往下
    • 回應階段(response):從下往上

Middleware 執行流程簡述

以下是 Django 處理請求的標準流程:

Request

Middleware(request)→ View 處理 → Middleware(response)

Response

舉例來說,假設你有三個 Middleware:

MIDDLEWARE = [
'myproject.middleware.FirstMiddleware',
'myproject.middleware.SecondMiddleware',
'myproject.middleware.ThirdMiddleware',
]

執行順序會是:

  • 請求階段:First → Second → Third → View
  • 回應階段:Third → Second → First → Client

Middleware 的基本結構與方法

從 Django 1.10 起,Middleware 使用「新式 Middleware」架構,基於 __call__() 方法設計。基本範例如下:

# middleware.py
class SimpleMiddleware:
def __init__(self, get_response):
self.get_response = get_response
# 這裡是初始化,只在伺服器啟動時執行一次

def __call__(self, request):
# 處理請求邏輯(View 前)
print("Before view")

response = self.get_response(request)

# 處理回應邏輯(View 後)
print("After view")

return response

實際範例一:請求時間計算 Middleware

此範例會計算 View 執行所花費的時間,並加入到 HTTP 回應標頭中。

# middleware.py
import time

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

def __call__(self, request):
start_time = time.time()
response = self.get_response(request)
duration = time.time() - start_time
response["X-Process-Time"] = f"{duration:.4f}s"
return response

settings.py 中啟用:

MIDDLEWARE = [
# 其他內建 middleware...
'myapp.middleware.TimerMiddleware',
]

當你訪問任意頁面時,HTTP 回應標頭中會出現類似:

X-Process-Time: 0.0321s

實際範例二:只允許特定 IP 的 Middleware

你可以建立一個 Middleware,用來限制只有某些 IP 位址可以訪問網站。

# middleware.py
from django.http import HttpResponseForbidden

class IPWhitelistMiddleware:
ALLOWED_IPS = ["127.0.0.1", "192.168.1.100"]

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

def __call__(self, request):
ip = request.META.get("REMOTE_ADDR")
if ip not in self.ALLOWED_IPS:
return HttpResponseForbidden("Access denied.")
return self.get_response(request)

這可以用來防止內部 API 被外部訪問。


常見用途與建議實作

用途建議工具或方式
請求/回應紀錄實作 logging Middleware
使用者權限控管自訂 Middleware 或使用 Django Authentication
防止過多請求與 Redis 結合實作 Rate Limiting Middleware
跨域(CORS)處理使用 django-cors-headers 套件
錯誤攔截與通知捕捉例外並結合外部通知工具(如 Sentry)

注意事項與開發建議

  1. Middleware 應保持單一職責:一個 Middleware 做一件事,方便測試與維護。
  2. 避免過度耦合 View 或 Model:Middleware 應專注於請求與回應處理,不應過度介入業務邏輯。
  3. 注意 Middleware 順序:Django 會依照 MIDDLEWARE 陣列順序執行,不當排序可能導致無效或錯誤。
  4. 善用內建 Middleware:如 SecurityMiddleware, CommonMiddleware, AuthenticationMiddleware,無須重造輪子。
  5. 除錯技巧:可在 Middleware 中使用 print()logging 或加入 HTTP 標頭協助觀察執行情況。

總結

Middleware 是 Django 框架中攔截與處理請求/回應流程的核心機制之一。學會撰寫與使用 Middleware,能讓你更有效地實現各種橫向功能(如安全、效能、紀錄等),並保持應用架構的乾淨與可維護性。

透過本教學筆記,你應該已理解:

  • Middleware 的基本概念與執行流程
  • 如何撰寫一個簡單的 Middleware 類別
  • 幾種常見的 Middleware 實用場景與範例

進一步建議可以閱讀 Django 官方文件中的 Middleware 章節,並觀察第三方套件的 Middleware 是如何實作的,將更有助於理解其威力與應用彈性。

Django 中的 n+1 問題入門教學筆記

· 閱讀時間約 4 分鐘
kdchang

前言

Django 作為一個功能完整的 Python Web 框架,其 ORM(Object-Relational Mapping)能讓開發者以物件導向方式操作資料庫。然而,這樣的便利也容易隱藏一些效能陷阱,其中最常見也最容易忽略的就是 n+1 查詢問題(n+1 query problem)

n+1 問題會導致程式在執行查詢時產生大量多餘的 SQL 語句,影響效能並拖慢頁面載入速度,特別是在處理關聯資料時(如 ForeignKey 或 ManyToManyField)。本篇筆記將帶你認識 n+1 問題在 Django 中的成因、辨識方法與解法。


重點摘要

  • n+1 問題定義:查詢一個主物件(n 筆),卻對每筆物件再執行一次額外查詢,總共造成 n+1 次查詢。

  • 常見發生情境:在模板或程式中存取 ForeignKey 或 ManyToManyField 時,未預先載入(eager loading)相關資料。

  • 效能影響:每個物件觸發一次額外 SQL,當資料量增加時,查詢數可能達到數百次以上。

  • 解法

    • 使用 select_related() 預先載入「多對一」與「一對一」的關聯。
    • 使用 prefetch_related() 預先載入「一對多」與「多對多」的關聯。
  • 如何偵測 n+1 問題

    • 開啟 django.db.backends 日誌觀察查詢數量與內容。
    • 使用 Django Debug Toolbar 查看 SQL 查詢次數與細節。

實際範例:部落格文章與作者

假設有以下兩個模型:

# models.py
class Author(models.Model):
name = models.CharField(max_length=100)

class Post(models.Model):
title = models.CharField(max_length=200)
content = models.TextField()
author = models.ForeignKey(Author, on_delete=models.CASCADE)

n+1 問題範例

# views.py
def post_list(request):
posts = Post.objects.all()
return render(request, "blog/post_list.html", {"posts": posts})
{# post_list.html #}
<ul>
{% for post in posts %}
<li>{{ post.title }} - {{ post.author.name }}</li>
{% endfor %}
</ul>

這段程式會發生 n+1 問題:

  • 第一次查詢取得所有文章 SELECT * FROM post
  • 每篇文章查詢一次作者 SELECT * FROM author WHERE id = ?

如果有 100 篇文章,總共會執行 101 次查詢。


# views.py(改進)
def post_list(request):
posts = Post.objects.select_related("author").all()
return render(request, "blog/post_list.html", {"posts": posts})

select_related 會使用 SQL JOIN 一次把作者資料一起載入。查詢數減少為 1 次:

SELECT post.*, author.*
FROM post
JOIN author ON post.author_id = author.id;

這種方式適合用於 ForeignKey(多對一)與 OneToOneField 關聯。


若改為一對多或多對多關係,例如:

class Tag(models.Model):
name = models.CharField(max_length=30)

class Post(models.Model):
title = models.CharField(max_length=200)
tags = models.ManyToManyField(Tag)

如果在模板中使用:

{% for post in posts %}
{{ post.title }}:
{% for tag in post.tags.all %}
{{ tag.name }}
{% endfor %}
{% endfor %}

這樣會產生 n+1 查詢問題(每個 post 查一次 tag)。解法:

posts = Post.objects.prefetch_related("tags").all()

prefetch_related() 會先查出所有關聯,再用 Python 記憶體關聯對應資料,不用 JOIN。

SELECT * FROM post;
SELECT * FROM post_tags WHERE post_id IN (...);
SELECT * FROM tag WHERE id IN (...);

特性select_relatedprefetch_related
關係類型一對一、外鍵(ForeignKey)一對多、多對多
查詢方式使用 JOIN 一次查出分別查詢後用 Python 關聯
查詢數量一次查詢即可完成最少兩次查詢
效能適用情境關聯資料不多且關係單純關聯資料多或複雜嵌套

如何偵測與除錯 n+1 問題

  1. 開啟 SQL 日誌: 在 settings.py 中設定:

    LOGGING = {
    "version": 1,
    "handlers": {
    "console": {
    "class": "logging.StreamHandler",
    },
    },
    "loggers": {
    "django.db.backends": {
    "handlers": ["console"],
    "level": "DEBUG",
    },
    },
    }
  2. 使用 Django Debug Toolbar: 安裝與設定後可視覺化查詢次數與內容。

  3. 查看 QuerySet 查詢次數: 使用 len(connection.queries) 或中間件分析每個 request 的查詢數。


總結

n+1 問題是 Django ORM 中最常見的效能陷阱之一,但只要了解其原理與解法,透過 select_related()prefetch_related() 搭配得當,幾乎可以完全避免這個問題。

掌握以下原則即可:

  • 遇到 ForeignKey 或 OneToOne 時用 select_related()
  • 遇到 ManyToMany 或反向 ForeignKey 時用 prefetch_related()
  • 避免在模板中直接使用 .related_set.all() 未預先載入資料
  • 對列表頁或頻繁查詢頁進行效能測試與 SQL 分析

良好的 ORM 使用習慣能大幅提升系統穩定性與使用者體驗,是每位 Django 開發者必備的基礎功。

GraphQL 入門教學筆記(ESM 模組版)| 學習筆記

· 閱讀時間約 4 分鐘
kdchang

前言

在傳統的 REST API 中,前端往往需要根據不同的需求,呼叫多個端點取得資料,有時還會遇到資料過多(Over-fetching)或不足(Under-fetching)的問題。為了解決這些痛點,Facebook 在 2015 年開源了 GraphQL,一種靈活且高效率的查詢語言。

GraphQL 讓前端可以明確指定想要的資料欄位,伺服器僅回傳需要的資料,改善資料浪費與重複請求的問題。此語言既可以查詢(Query)、也可以修改資料(Mutation),更支援訂閱(Subscription)即時變化,成為 REST 的強大替代方案。

本文將以 ESM(ECMAScript Module)模組格式,搭配現代 Node.js 環境與 Apollo Server,手把手實作一個簡易 GraphQL API。


重點摘要

  • GraphQL 是什麼? 一種用於 API 的查詢語言(Query Language),由 Facebook 開發。它不是資料庫,而是用來建立伺服器與用戶端之間通訊的一種規格。

  • 特色與優點

    • 客戶端可以精確指定所需資料
    • 單一端點處理所有請求
    • 減少 over-fetching / under-fetching 問題
    • 強型別系統(Schema 定義清楚 API 結構)
    • 自帶文件化功能(如 Apollo Studio / GraphQL Playground)
  • 核心概念

    • Schema:定義資料型別與查詢結構
    • Query:讀取資料
    • Mutation:修改資料(新增、刪除、更新)
    • Resolver:實際執行資料存取邏輯的函式
    • Type:定義資料欄位與型別,例如 type Book { title: String }
  • GraphQL vs REST

    特性RESTGraphQL
    資料請求多個端點單一端點
    回傳資料固定欄位,可能過多或不足客戶端可自訂所需欄位
    文件維護手動撰寫 Swagger/OpenAPI自動產生於 Playground / Studio
    資料關聯查詢多次 HTTP 請求一次查詢可取得巢狀關聯資料

實作範例(Node.js + Apollo Server + ESM)

一、專案初始化

建立資料夾並初始化:

mkdir graphql-esm-demo
cd graphql-esm-demo
npm init -y
npm install @apollo/server graphql

修改 package.json 啟用 ESM 模組:

{
"type": "module"
}

二、撰寫 GraphQL API(server.js)

建立 server.js

// server.js
import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';

// 模擬資料
const books = [
{ title: 'GraphQL 教學指南', author: 'Alice' },
{ title: '現代 JavaScript', author: 'Bob' },
];

// 定義 Schema
const typeDefs = `
type Book {
title: String
author: String
}

type Query {
books: [Book]
}
`;

// 定義 Resolver
const resolvers = {
Query: {
books: () => books,
},
};

// 建立 Apollo Server 實例
const server = new ApolloServer({ typeDefs, resolvers });

// 啟動伺服器
const { url } = await startStandaloneServer(server, {
listen: { port: 4000 },
});

console.log(`🚀 Server ready at ${url}`);

三、啟動伺服器並測試

執行伺服器:

node server.js

啟動後會顯示伺服器位置(通常是 http://localhost:4000 Apollo Studio,或使用 Postman / Altair / curl 測試。


四、查詢範例(GraphQL Playground 中輸入)

query {
books {
title
author
}
}

我們也可以僅查詢某個欄位,例如:

query {
books {
title
}
}

這正是 GraphQL 的威力所在:我們只拿我們需要的資料。


延伸功能與建議學習方向

  • Mutation 實作(新增、刪除資料) 可以加入 Mutation 類型與 resolver,實作 POST/PUT 功能。

  • 資料來源整合 Resolver 可以整合 REST API、資料庫、第三方服務等來源。

  • 驗證與權限 可透過 Context 傳入使用者驗證資訊,進行資料存取控管。

  • 使用工具

    • Apollo Studio:視覺化介面與測試工具
    • GraphQL Codegen:產生型別定義與前端 Hooks
    • Relay / urql / Apollo Client:前端整合工具

總結

GraphQL 提供比 REST 更彈性與效率的 API 設計方式,尤其適合需要頻繁前後端協作或資料結構變化頻繁的專案。透過本篇教學,我們已經學會如何使用 Apollo Server 以 ESM 模組撰寫簡單的 GraphQL API,並實際查詢資料。

未來我們可以嘗試進一步加入 Mutation、串接資料庫(如 MongoDB、PostgreSQL)、前端 Apollo Client 等,打造一個全端的 GraphQL 應用。

concurrently.js 入門教學筆記 | 學習筆記

· 閱讀時間約 4 分鐘
kdchang

前言

在前端與全端開發中,我們經常需要同時執行多個指令,例如一邊啟動前端開發伺服器,一邊啟動後端 API 伺服器,或一邊監看 Sass 編譯,一邊執行 TypeScript 編譯。在這樣的情境下,concurrently 是一個非常實用的工具,它能讓我們在同一個命令列同時執行多個命令。

本篇筆記將介紹 concurrently 是什麼、如何安裝、基本用法,以及實際應用範例。


什麼是 concurrently?

concurrently 是一個 Node.js 套件,可以在一個命令中同時執行多個命令行指令,而且會把各個執行的結果分別以不同顏色標示,方便辨認。它常用來取代 npm-run-allgulp 等工具中針對「平行執行任務」的需求。

官方說明:“Run multiple commands concurrently.”

例如你想同時執行一個 React 專案的前端開發伺服器與後端 API 伺服器:

npm run start-frontend & npm run start-backend

在不同系統或 shell 可能有兼容性問題,用 concurrently 則會簡單許多。


1️⃣ 安裝 concurrently

首先,你需要在專案中安裝 concurrently

npm install concurrently --save-dev

或者使用 yarn:

yarn add concurrently --dev

安裝完成後,你可以在 package.jsonscripts 區塊中使用它。


2️⃣ 基本用法

最基本的用法如下:

npx concurrently "command1" "command2"

例如,同時執行 npm run servernpm run client

npx concurrently "npm run server" "npm run client"

執行時會在終端顯示兩個任務的 log,並自動用不同顏色標示來源。


3️⃣ 在 package.json 中使用

通常我們會把 concurrently 寫在 package.json 裡的 scripts 區塊:

{
"scripts": {
"server": "node server.js",
"client": "react-scripts start",
"dev": "concurrently \"npm run server\" \"npm run client\""
}
}

執行 npm run dev,就會同時執行 server.js(後端)與 react-scripts start(前端)。

這樣只需要一個指令就能同時啟動兩個服務,對開發非常方便。


4️⃣ 實際範例:React + Express 同時啟動

假設你有一個專案結構如下:

my-app/
client/
(React 專案)
server/
(Express 後端)

server/package.json

{
"name": "server",
"version": "1.0.0",
"scripts": {
"start": "node index.js"
}
}

client/package.json

{
"name": "client",
"version": "1.0.0",
"scripts": {
"start": "react-scripts start"
}
}

在專案根目錄的 package.json 中加入:

{
"name": "my-app",
"version": "1.0.0",
"scripts": {
"start": "concurrently \"npm start --prefix server\" \"npm start --prefix client\""
},
"devDependencies": {
"concurrently": "^8.0.0"
}
}
  • --prefix 是讓 npm 到指定資料夾執行
  • npm start --prefix server 會到 server/ 資料夾執行 npm start
  • npm start --prefix client 會到 client/ 資料夾執行 npm start

此時執行:

npm start

就會同時啟動 React 前端與 Express 後端,而且都會在終端中顯示 log,方便觀察開發情況。


5️⃣ 進階用法

✅ 自訂 prefix 與顏色

可以自訂 log 標籤與顏色,方便辨識哪一個 log 來自哪個指令:

npx concurrently --names "BACK,FRONT" --prefix-colors "bgBlue.bold,bgMagenta.bold" "npm run server" "npm run client"

效果:

[BACK] server running on port 5000
[FRONT] webpack compiled successfully

✅ 自動終止所有執行中的任務

當一個任務失敗時,讓其他任務也自動停止:

npx concurrently --kill-others "npm run server" "npm run client"

當其中一個 command 錯誤,另一個也會被 kill,避免殘留無用的背景 process。


6️⃣ 常見用途

concurrently 常見的使用情境有:

  • 同時啟動多個 Node.js 服務
  • 一邊監看 Sass/LESS 編譯,一邊執行 webpack
  • 同時跑 test 與 build
  • 同時監看前端與後端程式碼

如果你用 create-react-appNext.jsViteExpressNestJS 這些框架開發全端應用,concurrently 非常適合整合開發流程。


7️⃣ 與其他工具比較

concurrently 的特色在於:

  • 簡單語法(不需要額外配置檔)
  • 支援 Windows、Linux、Mac
  • 輕量、僅做平行執行,不強制任務流程
  • log 輸出自帶標籤與顏色
  • 可搭配 npm script 或 npx 單獨執行

如果需要「先後順序執行多個任務」,則可以搭配 npm-run-all


總結

concurrently 是一個適合在開發環境中同時執行多個命令的小工具,對需要前後端同時啟動、前端多個編譯工作並行的開發者非常實用。

它用法簡單、安裝快速、跨平台,推薦將它納入專案開發腳本中,以提升開發效率。

希望這篇筆記能幫助你了解 concurrently 的用途與基本操作!

Django RESTful API 入門教學筆記 | 學習筆記

· 閱讀時間約 3 分鐘
kdchang

隨著 Web 與行動應用的發展,API(應用程式介面)已成為前後端溝通的橋樑。RESTful API 是目前最常見的 API 設計風格之一,而 Django REST Framework(簡稱 DRF)則是基於 Django 的強大工具,讓開發 RESTful API 變得更簡單。

本篇筆記將帶我們從零開始,快速建立一個 Django RESTful API 專案,實作一個基本的「文章系統」。


1. 安裝 Django 與 Django REST Framework

首先,建立一個虛擬環境並安裝必要套件:

python -m venv venv
source venv/bin/activate # Windows 用戶請使用 venv\Scripts\activate
pip install django djangorestframework

接著,建立 Django 專案:

django-admin startproject myapi
cd myapi

建立一個 app 來處理文章功能:

python manage.py startapp articles

2. 設定專案

myapi/settings.py 中,將 rest_frameworkarticles 加入 INSTALLED_APPS

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework',
'articles',
]

3. 建立模型

打開 articles/models.py,定義一個 Article 模型:

from django.db import models

class Article(models.Model):
title = models.CharField(max_length=100)
content = models.TextField()
created_at = models.DateTimeField(auto_now_add=True)

def __str__(self):
return self.title

然後執行遷移:

python manage.py makemigrations
python manage.py migrate

4. 建立序列化器(Serializer)

articles 資料夾中建立 serializers.py

from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
class Meta:
model = Article
fields = '__all__'

這樣就完成了資料庫模型與 JSON 之間的轉換設定。


5. 建立 API View

articles/views.py 中加入以下程式:

from rest_framework import generics
from .models import Article
from .serializers import ArticleSerializer

class ArticleListCreateView(generics.ListCreateAPIView):
queryset = Article.objects.all()
serializer_class = ArticleSerializer

class ArticleDetailView(generics.RetrieveUpdateDestroyAPIView):
queryset = Article.objects.all()
serializer_class = ArticleSerializer

我們使用了 DRF 的「通用類別視圖」,大幅減少手寫程式碼。


6. 設定 URL

articles 資料夾中建立 urls.py

from django.urls import path
from .views import ArticleListCreateView, ArticleDetailView

urlpatterns = [
path('articles/', ArticleListCreateView.as_view(), name='article-list-create'),
path('articles/<int:pk>/', ArticleDetailView.as_view(), name='article-detail'),
]

接著將 articles/urls.py 加入主專案的 myapi/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('articles.urls')),
]

現在 API 路由已經設定完成。


7. 測試 API

啟動開發伺服器:

python manage.py runserver

打開瀏覽器,造訪 http://127.0.0.1:8000/api/articles/,我們會看到 DRF 提供的漂亮瀏覽介面,可以直接用網頁表單測試 API。

我們也可以用工具如 Postman 或 curl 測試:

建立新文章

curl -X POST -H "Content-Type: application/json" \
-d '{"title": "第一篇文章", "content": "這是一篇測試文章"}' \
http://127.0.0.1:8000/api/articles/

取得文章列表

curl http://127.0.0.1:8000/api/articles/

取得單篇文章

curl http://127.0.0.1:8000/api/articles/1/

更新文章

curl -X PUT -H "Content-Type: application/json" \
-d '{"title": "更新後標題", "content": "更新後內容"}' \
http://127.0.0.1:8000/api/articles/1/

刪除文章

curl -X DELETE http://127.0.0.1:8000/api/articles/1/

8. 總結

透過這篇筆記,我們完成了:

  • 安裝 Django 與 DRF
  • 定義模型與序列化器
  • 使用泛型類別視圖實作 CRUD API
  • 設定 URL 路由
  • 使用瀏覽器或命令列工具測試 API

Django REST Framework 提供了許多自動化與簡化開發的工具,讓我們能快速建立出符合 REST 標準的 API。當然,隨著需求增加,我們也可以進一步學習自定義權限、驗證、過濾與分頁等功能。