Python开发从入门到精通：Web框架Django高级应用实战

一、学习目标与重点

这次我们要深入Django的高级玩法——从中间件、信号到缓存、表单验证和权限管理，再到一个完整的博客系统实战。目标很明确：不只是会用Django，而是能写出高效、可维护的Web应用。

⚠️ 学习重点：中间件、信号、缓存、表单验证、权限管理、Django高级功能、Web应用实战。

33.1 Django高级功能概述

33.1.1 什么是Django高级功能

所谓高级功能，是指Django框架中那些能让复杂Web开发事半功倍的“杀手锏”——中间件、信号、缓存、表单验证、权限管理等等。它们不是玩具，而是生产环境里的必备工具。

33.1.2 高级功能的应用场景

• 中间件：处理HTTP请求和响应，比如身份验证、日志记录、请求预处理。
• 信号：让应用的不同组件之间能够“通知”和“监听”，解耦通信。
• 缓存：减少数据库查询，让页面响应速度飞起来。
• 表单验证：确保用户提交的数据是干净的。
• 权限管理：精确控制谁能访问什么资源。

33.2 中间件

33.2.1 什么是中间件

中间件是Django框架的一个核心组件，它在HTTP请求抵达视图函数之前、或者在响应返回客户端之前，执行一些特定的操作。你可以把它看作一道“关卡”，每个请求和响应都会经过它。

33.2.2 自定义中间件

# myapp/middleware.py
from django.http import HttpResponse
class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        # 请求到达视图函数之前执行的操作
        print("请求到达视图函数之前")
        response = self.get_response(request)
        # 响应返回客户端之前执行的操作
        print("响应返回客户端之前")
        return response

33.2.3 注册中间件

# myproject/settings.py
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',
    'myapp.middleware.SimpleMiddleware',
]

33.3 信号

33.3.1 什么是信号

信号是Django里的一种“事件通知”机制。当某个行为发生（比如保存模型、删除数据），信号会广播一条消息，而其他组件可以订阅并做出响应。这就好比一个广播电台，谁都可以收听。

33.3.2 内置信号

Django自带了不少实用的信号，比如：

• django.db.models.signals.pre_sa ve：在保存模型之前发送。
• django.db.models.signals.post_sa ve：在保存模型之后发送。
• django.db.models.signals.pre_delete：在删除模型之前发送。
• django.db.models.signals.post_delete：在删除模型之后发送。

33.3.3 自定义信号

# myapp/signals.py
import django.dispatch
# 定义信号
my_signal = django.dispatch.Signal()

33.3.4 发送信号

# myapp/views.py
from myapp.signals import my_signal
def my_view(request):
    # 发送信号
    my_signal.send(sender=my_view, message="Hello, World!")
    return HttpResponse("信号已发送")

33.3.5 接收信号

# myapp/receivers.py
from django.dispatch import receiver
from myapp.signals import my_signal
@receiver(my_signal)
def my_receiver(sender, **kwargs):
    print("收到信号")
    print("发送者：", sender)
    print("参数：", kwargs)

33.3.6 注册信号

# myapp/apps.py
from django.apps import AppConfig
class MyAppConfig(AppConfig):
    name = 'myapp'
    def ready(self):
        import myapp.receivers

33.4 缓存

33.4.1 什么是缓存

缓存是一种简单粗暴但效果极好的性能优化手段：把那些经常被访问的数据存到内存里，下次请求直接拿来用，省去数据库查询和重复计算。Django支持多种缓存后端，比如Memcached、Redis，可以根据项目需要灵活选择。

33.4.2 配置缓存

# myproject/settings.py
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

33.4.3 使用缓存

# myapp/views.py
from django.core.cache import cache
from django.http import HttpResponse
def my_view(request):
    # 从缓存中获取数据
    data = cache.get('my_data')
    if data is None:
        # 缓存未命中，从数据库中获取数据
        data = "Hello, World!"
        # 将数据存入缓存，有效期为60秒
        cache.set('my_data', data, 60)
    return HttpResponse(data)

33.5 表单验证

33.5.1 自定义表单验证

# myapp/forms.py
from django import forms
class MyForm(forms.Form):
    name = forms.CharField(label='姓名', max_length=100)
    email = forms.EmailField(label='邮箱')
    def clean_name(self):
        name = self.cleaned_data['name']
        if len(name) < 2:
            raise forms.ValidationError('姓名长度不能少于2个字符')
        return name
    def clean_email(self):
        email = self.cleaned_data['email']
        if not email.endswith('@example.com'):
            raise forms.ValidationError('邮箱必须以@example.com结尾')
        return email

33.5.2 使用表单验证

# myapp/views.py
from myapp.forms import MyForm
from django.shortcuts import render, redirect
def my_view(request):
    if request.method == 'POST':
        form = MyForm(request.POST)
        if form.is_valid():
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            return redirect('success')
    else:
        form = MyForm()
    return render(request, 'myapp/my_form.html', {'form': form})

33.6 权限管理

33.6.1 自定义权限

# myapp/models.py
from django.db import models
from django.contrib.auth.models import Permission
class MyModel(models.Model):
    name = models.CharField(max_length=100)
    class Meta:
        permissions = [
            ('can_view', 'Can view my model'),
            ('can_edit', 'Can edit my model'),
            ('can_delete', 'Can delete my model'),
        ]

33.6.2 分配权限

# myapp/admin.py
from django.contrib import admin
from myapp.models import MyModel
@admin.register(MyModel)
class MyModelAdmin(admin.ModelAdmin):
    list_display = ['name']

33.6.3 检查权限

# myapp/views.py
from myapp.models import MyModel
from django.contrib.auth.decorators import permission_required
from django.shortcuts import render
@permission_required('myapp.can_view')
def my_view(request):
    data = MyModel.objects.all()
    return render(request, 'myapp/my_view.html', {'data': data})

33.7 实战案例：博客系统

33.7.1 需求分析

终于到了实战部分。我们要搭建一个博客系统，核心功能包括：

• 文章的CRUD操作（增删改查）。
• 文章分类管理。
• 评论管理。
• 权限管理（谁可以操作什么）。

33.7.2 代码实现

33.7.2.1 数据模型

# myapp/models.py
from django.db import models
from django.contrib.auth.models import User
class Category(models.Model):
    name = models.CharField(max_length=100)
    def __str__(self):
        return self.name
class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    def __str__(self):
        return self.title
class Comment(models.Model):
    article = models.ForeignKey(Article, on_delete=models.CASCADE)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    def __str__(self):
        return f"{self.author.username} - {self.article.title}"

33.7.2.2 序列化器

# myapp/serializers.py
from rest_framework import serializers
from myapp.models import Category, Article, Comment
class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = "__all__"
class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = "__all__"
class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Comment
        fields = "__all__"

33.7.2.3 视图函数

# myapp/views.py
from rest_framework import viewsets, permissions
from rest_framework.authentication import TokenAuthentication
from myapp.models import Category, Article, Comment
from myapp.serializers import CategorySerializer, ArticleSerializer, CommentSerializer
class CategoryViewSet(viewsets.ModelViewSet):
    queryset = Category.objects.all()
    serializer_class = CategorySerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]
class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]
class CommentViewSet(viewsets.ModelViewSet):
    queryset = Comment.objects.all()
    serializer_class = CommentSerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]

33.7.2.4 路由配置

# myapp/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from myapp.views import CategoryViewSet, ArticleViewSet, CommentViewSet
router = DefaultRouter()
router.register(r"categories", CategoryViewSet)
router.register(r"articles", ArticleViewSet)
router.register(r"comments", CommentViewSet)
urlpatterns = [
    path("", include(router.urls)),
]

33.7.2.5 项目路由配置

# myproject/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/", include("myapp.urls")),
]

33.7.3 实施过程

1. 安装Django和Django REST framework。
2. 创建项目和应用。
3. 定义数据模型。
4. 编写序列化器。
5. 编写视图函数。
6. 配置路由。
7. 运行应用。

33.7.4 最终效果

通过这个博客系统，我们实现了所有预设功能：

• 文章的CRUD操作。
• 文章分类管理。
• 评论管理。
• 权限管理（基于Token认证和权限控制）。

总结

本文从中间件、信号、缓存、表单验证到权限管理，逐一拆解了Django的高级技巧，最后通过一个完整的博客系统把它们串联起来。想要真正掌握这些知识，最好的办法就是打开编辑器，把代码敲一遍，遇到问题再回来翻翻——别指望一次性记住所有细节，动手才是王道。