# Django 约定和最佳实践 ## 目的该技能提供全面的 Django 最佳实践和约定，以确保高质量、安全且高性能的 Django 应用程序。它可作为代码审查期间的参考指南，以验证是否遵守 Django 标准和社区最佳实践。 **何时使用此技能：** * 对Django项目进行代码审查 * 设计 Django 应用程序和模型 * 编写 Django 视图、序列化器和表单 * 评估 Django 安全性和性能 * 重构 Django 代码库 * 向团队成员教授 Django 最佳实践该技能旨在供“uncle-duke-python”代理在 Django 代码审查期间参考。 ## 上下文 Django 是一个高级 Python Web 框架，鼓励快速开发和简洁、务实的设计。该技能记录了行业标准 Django 实践，强调： * **约定优于配置** ：遵循 Django 的可预测性约定 * **不要重复自己（DRY）** ：最大限度地减少代码重复 * **显式优于隐式**：清晰、可读的代码 * **默认安全** ：利用 Django 的内置安全功能 * **数据库效率**：优化查询并避免常见的性能陷阱 * **可维护性** ：编写易于理解和修改的代码 ## 先决条件 **所需知识：** * Python基础知识和最佳实践 * 了解Web开发概念（HTTP、REST、MVC/MTV） * 基本了解Django的MTV（模型-模板-视图）架构 * SQL和数据库概念 **所需工具：** * Django 3.2+（推荐 LTS） * Python 3.8+ * 数据库（推荐使用 PostgreSQL 用于生产） **预期项目结构：** 我的项目/ ├── 管理.py ├── myproject/ # 项目配置 │ ├── __init__.py │ ├── settings/ # 按环境分割设置 │ │ ├── __init__.py │ │ ├── 基础.py │ │ ├── 开发.py │ │ ├── 生产.py │ │ └── 测试.py │ ├── urls.py │ ├── wsgi.py │ └── asgi.py ├── apps/ # Django 应用程序 │ ├── 用户/ │ │ ├── __init__.py │ │ ├── 模型.py │ │ ├──views.py │ │ ├── 序列化器.py │ │ ├── urls.py │ │ ├── admin.py │ │ ├── apps.py │ │ ├── 管理者.py │ │ ├── 测试/ │ │ │ ├── test_models.py │ │ │ ├── test_views.py │ │ │ └── test_serializers.py │ │ └── 迁徙/ │ └── 核心/ ├── 静态/ ├── 媒体/ ├── 模板/ ├── 要求/ │ ├── 基础.txt │ ├── 开发.txt │ ├── 制作.txt │ └── 测试.txt └── 自述文件.md ** ** ## 说明 ### 任务 1：Django 项目结构最佳实践 #### 1.1 项目布局 **规则：** 组织 Django 项目时，项目配置和应用程序之间应明确分开。 ✅ **良好的项目结构：** 我的项目/ ├── 管理.py ├── myproject/ # 项目设置和配置 │ ├── 设置/ │ │ ├── base.py # 共享设置 │ │ ├──development.py # 开发特定设置 │ │ ├── production.py # 生产设置 │ │ └── test.py # 测试设置 │ ├── urls.py # 根URL配置 │ ├── wsgi.py │ └── asgi.py ├── apps/ # 所有 Django 应用 │ ├── 用户/ │ ├── 博客/ │ └── core/ # 共享实用程序 ├── static/ # 静态文件 ├── media/ # 用户上传的文件 ├── templates/ # 共享模板 ├──requirements/ # 分割需求 └── docs/ # 文档 ❌ **不好：** 我的项目/ ├── 管理.py ├── settings.py # 所有设置在一个文件中 ├── users.py # 应用程序未正确组织 ├── 博客.py └── utils.py # 混合关注点 **为什么：** 清晰的结构提高了可维护性，使设置管理更容易，并遵循 Django 社区标准。 #### 1.2 应用程序组织 **规则：** 每个应用程序都应专注于单个域概念。 ✅ **良好的应用程序结构：** 用户/ ├── __init__.py ├── models.py # 用户相关模型 ├──views.py # 用户浏览量 ├── serializers.py # DRF 序列化器 ├── urls.py # 应用程序特定的 URL ├── admin.py # 管理员配置 ├── apps.py # 应用配置 ├── manager.py # 自定义模型管理器 ├── forms.py # 表单 ├── signals.py # 信号处理程序 ├── requests.py # 自定义权限 ├── utils.py # 应用程序特定的实用程序 ├── 测试/ │ ├── __init__.py │ ├── test_models.py │ ├── test_views.py │ └──factorys.py # 测试工厂 └── 迁徙/ **应用程序命名约定：** * 对于包含模型的应用程序使用复数名词（用户、帖子、评论） * 对实用程序应用程序使用单数名词（core、common、utils） * 保持应用程序名称简短且具有描述性 * 使用下划线表示多字名称（user_profiles） #### 1.3 设置组织 **规则：** 按环境拆分设置以确保安全性和灵活性。 ✅ **良好的设置结构：** **`设置/base.py`：** """在所有环境中共享的基本设置。""" 导入操作系统从 pathlib 导入路径 BASE_DIR = 路径(__file__).resolve().parent.parent.parent # 安全警告：对生产中使用的密钥保密！ # 这应该在特定于环境的设置中被覆盖 SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'dev-only-secret-key') # 应用程序定义已安装的应用程序 = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', # 第三方应用程序 '休息框架', 'django_filters', # 本地应用程序 '应用程序.用户', '应用程序.博客', '应用程序核心', ] 中间件 = [ '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', ] ROOT_URLCONF = 'myproject.urls' # 国际化 LANGUAGE_CODE = 'en-us' 时区 = 'UTC' USE_I18N = 真 USE_TZ = True # 始终使用时区感知的日期时间 # 静态文件 STATIC_URL = '/静态/' STATIC_ROOT = BASE_DIR / '静态文件' # 媒体文件 MEDIA_URL = '/媒体/' MEDIA_ROOT = BASE_DIR / '媒体' # 默认主键字段类型 DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField' **`设置/development.py`：** """特定于开发的设置。""" 从 .base 导入 * 调试=真 ALLOWED_HOSTS = ['localhost', '127.0.0.1'] # 数据库数据库= { “默认”：{ '引擎': 'django.db.backends.postgresql', '名称'：'myproject_dev'， '用户'：'我的项目用户'， '密码': 'dev_password', '主机'：'本地主机'， “端口”：“5432”， } } # 特定于开发的应用程序已安装的应用程序 += [ '调试工具栏', 'django_extensions', ] 中间件 += [ 'debug_toolbar.middleware.DebugToolbarMiddleware', ] # Django 调试工具栏 INTERNAL_IPS = ['127.0.0.1'] # 用于开发的电子邮件后端 EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' **`设置/生产.py`：** """生产设置。""" 导入操作系统从 .base 导入 * 调试=假 # 安全警告：将此更新为您的域 ALLOWED_HOSTS = os.environ.get('ALLOWED_HOSTS', '').split(',') # 对敏感数据使用环境变量 SECRET_KEY = os.environ['DJANGO_SECRET_KEY'] 数据库= { “默认”：{ '引擎': 'django.db.backends.postgresql', 'NAME': os.environ['DB_NAME'], '用户': os.environ['DB_USER'], '密码': os.environ['DB_PASSWORD'], 'HOST': os.environ['DB_HOST'], 'PORT': os.environ.get('DB_PORT', '5432'), 'CONN_MAX_AGE': 600, # 连接池 } } # 安全设置 SECURE_SSL_REDIRECT = 真 SESSION_COOKIE_SECURE = True CSRF_COOKIE_SECURE = True SECURE_BROWSER_XSS_FILTER = True SECURE_CONTENT_TYPE_NOSNIFF = True X_FRAME_OPTIONS = '拒绝' SECURE_HSTS_SECONDS = 31536000 SECURE_HSTS_INCLUDE_SUBDOMAINS = True SECURE_HSTS_PRELOAD = True # 日志记录记录 = { “版本”：1， “disable_existing_loggers”：错误， '处理程序'：{ “文件”：{ '级别'：'错误'， 'class': 'logging.FileHandler', '文件名': '/var/log/myproject/django.log', }, }, '记录器'：{ 'django': { '处理程序'：['文件']， '级别'：'错误'， “传播”：确实， }, }, } #### 1.4 URL 配置模式 **规则：** 使用 RESTful URL 模式并将 include() 用于特定于应用程序的 URL。 ✅ **好：** **`myproject/urls.py`:** """根 URL 配置。""" 从 django.contrib 导入 admin from django.urls 导入路径，包括从 django.conf 导入设置从 django.conf.urls.static 导入静态 url 模式 = [ 路径('admin/', admin.site.urls), 路径('api/v1/users/', include('apps.users.urls')), 路径('api/v1/blog/', include('apps.blog.urls')), 路径('api/v1/', include('apps.core.urls')), ] # 在开发中提供媒体文件如果设置.DEBUG: urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT) **`apps/users/urls.py`:** """用户应用 URL 配置。""" from django.urls 导入路径，包括从rest_framework.routers导入DefaultRouter 从 .导入视图 app_name = 'users' # URL 命名空间路由器=默认路由器() router.register(r'',views.UserViewSet,basename='user') url 模式 = [ 路径（''，包括（router.urls）），路径('me/',views.CurrentUserView.as_view(),name='当前用户'), 路径('登录/',views.LoginView.as_view(),name='登录'), 路径（'注销/'，views.LogoutView.as_view（），name ='注销'）， ] **URL 命名最佳实践：** * 使用小写字母和连字符：`/api/user-profiles/` * 对您的 API 进行版本控制：`/api/v1/`、`/api/v2/` * 对资源使用复数名词：`/users/`、`/posts/` * 谨慎使用嵌套路由：`/user/123/posts/`（考虑使用`/posts/?user=123`） * 始终命名您的 URL 以进行反向查找 ** ** ### 任务 2：建模最佳实践 #### 2.1 模型设计模式 **规则：** 模型应该有重点、有良好的文档记录，并遵循 Django 约定。 ✅ **良好的模型设计：** “”“用户模型。”“” 从 django.contrib.auth.models 导入 AbstractUser 从 django.db 导入模型从 django.utils.translation 导入 gettext_lazy as _ 从 django.core.validators 导入 MinValueValidator、MaxValueValidator 用户类（抽象用户）： """扩展 Django 的 AbstractUser 的自定义用户模型。为用户配置文件添加附加字段并实施与用户帐户相关的业务逻辑。 ”“” 类 UserRole(models.TextChoices): """用户角色选择。""" ADMIN = '管理员', _('管理员') 主持人 = 'MOD', _('主持人') USER = '用户', _('普通用户') # 附加字段 email = models.EmailField(_('电子邮件地址'), unique=True) 角色 = models.CharField( _('角色'), 最大长度=10，选择=UserRole.choices，默认=UserRole.USER, ） bio = models.TextField(_('传记'), 空白=True, max_length=500) birth_date = models.DateField(_('出生日期'), null=True, Blank=True) 头像 = models.ImageField( _('头像'), upload_to='头像/%Y/%m/%d/', 空=真，空白=真，） email_verified = models.BooleanField(_('电子邮件已验证'), 默认=False) created_at = models.DateTimeField(_('创建于'), auto_now_add=True) Updated_at = models.DateTimeField(_('更新时间'), auto_now=True) 类元：详细名称 = _('用户') verbose_name_plural = _('用户') 排序 = ['-created_at'] 索引 = [ models.Index(fields=['email']), models.Index(fields=['-created_at']), ] def __str__(自身): """用户的字符串表示形式。""" return f"{self.username} ({self.get_role_display()})" def get_full_name(self): """如果未设置，则返回用户的全名或用户名。""" 完整名称 = super().get_full_name() 如果全名则返回全名，否则返回 self.username @属性 def is_admin(自我): """检查用户是否具有管理员角色。""" 返回 self.role == self.UserRole.ADMIN def verify_email(自我): """将用户的电子邮件标记为已验证。""" self.email_verified = True self.save(update_fields=['email_verified', 'updated_at']) 类 Post(models.Model): “”“博客帖子模型。”“” 类 PostStatus(models.TextChoices): """发布状态选择。""" 草稿 = '草稿', _('草稿') 已发布 = '已发布', _('已发布') 已存档 = '已存档', _('已存档') 标题 = models.CharField(_('标题'), max_length=200) slug = models.SlugField(_('slug'), max_length=200, unique=True) 作者 = models.ForeignKey( 用户， on_delete=models.CASCADE, related_name='帖子', related_query_name='帖子', verbose_name=_('作者'), ）内容 = models.TextField(_('内容')) 状态 = models.CharField( _('状态'), 最大长度=20，选择=PostStatus.choices, 默认=PostStatus.DRAFT， db_index=真，）特色 = models.BooleanField(_('特色'), 默认=False) view_count = models.PositiveIntegerField(_('观看次数'), 默认=0) Publication_at = models.DateTimeField(_('发布于'), null=True, Blank=True) created_at = models.DateTimeField(_('创建于'), auto_now_add=True) Updated_at = models.DateTimeField(_('更新时间'), auto_now=True) # 使用自定义管理器对象 = PostManager() 类元：详细名称 = _('帖子') verbose_name_plural = _('帖子') 排序 = ['-published_at', '-created_at'] 索引 = [ models.Index(fields=['status', '-published_at']), models.Index(fields=['author', '-created_at']), ] 约束= [ 模型.CheckConstraint( 检查=models.Q(view_count__gte=0), name='post_view_count_non_negative', ), ] def __str__(自身): """帖子的字符串表示形式。""" 返回自我标题 def save(self, *args, **kwargs): """当状态更改为已发布时覆盖保存以设置published_at。""" 如果 self.status == self.PostStatus.PUBLISHED 而不是 self.published_at：从 django.utils 导入时区 self.published_at = timezone.now() super().save(*args, **kwargs) defincrement_view_count(self): """有效增加帖子浏览次数。""" self.__class__.objects.filter(pk=self.pk).update( view_count=models.F('view_count') + 1 ） # 从数据库中刷新 self.refresh_from_db(fields=['view_count']) **关键模型设计原则：** 1. 对于 i18n，使用带有 gettext_lazy 的详细字段名称 2.为复杂字段添加`help_text` 3. 使用 TextChoices/IntegerChoices 作为选择字段 4. 在大多数模型上包含时间戳（created_at、updated_at） 5. 对ForeignKey使用适当的`on_delete` 6. 在关系上设置 `lated_name` 和 `lated_query_name` 7.为经常查询的字段添加数据库索引 8. 使用约束来确保数据完整性 9. 覆盖`__str__()`以获得有意义的表示 10. 记录模型和复杂方法 #### 2.2 字段选择和命名 **规则：** 使用 TextChoices/IntegerChoices 进行字段选择，遵循命名约定。 ✅ **好：** 类订单（模型.模型）： """客户订单型号。""" 类 OrderStatus(models.TextChoices): """使用 TextChoices 进行订单状态选择。""" PENDING = 'PENDING', _('待付款') 已付费 = '已付费', _('已付费') 处理 = '处理中', _('处理中') 已发货 = '已发货', _('已发货') 已交付 = '已交付', _('已交付') 取消 = '取消', _('取消') 已退款 = '已退款', _('已退款') 类 PaymentMethod(models.TextChoices): """付款方式选择。""" CREDIT_CARD = 'CC', _('信用卡') DEBIT_CARD = 'DC', _('借记卡') PAYPAL = 'PP', _('PayPal') BANK_TRANSFER = 'BT', _('银行转账') # 字段命名遵循snake_case order_number = models.CharField(max_length=50, unique=True) 客户 = models.ForeignKey(User, on_delete=models.PROTECT) 状态 = models.CharField( 最大长度=20，选择=OrderStatus.choices, 默认=OrderStatus.PENDING，） payment_method = models.CharField( 最大长度=2，选择=PaymentMethod.choices, 空=真，空白=真，）总金额 = models.DecimalField( 最大位数=10，小数位数=2，验证器=[MinValueValidator(0)], ）送货地址 = models.TextField() 创建的_at = models.DateTimeField(auto_now_add=True) update_at = models.DateTimeField(auto_now=True) def __str__(自身): return f"订单 {self.order_number} - {self.get_status_display()}" ❌ **不好：** 类订单（模型.模型）： “”“坏例子 - 避免这个。”“” # 不好：元组选择而不是 TextChoices 状态选择 = ( （1，“待处理”），（2，“付费”），（3，“已发货”），） # 不好：使用没有明确含义的整数状态 = models.IntegerField(choices=STATUS_CHOICES) # 不好：用camelCase代替snake_case orderNumber = models.CharField(max_length=50) # 不好：字段名称模糊 amt = models.DecimalField(max_digits=10,decimal_places=2) addr = models.TextField() **字段命名约定：** * 使用snake_case作为字段名称 * 明确且具有描述性（避免缩写） * 谨慎使用`_id`后缀（Django自动将其添加到ForeignKey） * 使用读起来像问题的布尔字段名称：`is_active`、`has_paid`、`email_verified` * 使用带有“_at”或“_date”后缀的日期/时间字段名称：“created_at”、“birth_date” #### 2.3 元类选项 **规则：** 使用 Meta 类来配置模型行为和数据库选项。 ✅ **良好的元类：** 类文章（模型.模型）： """具有全面Meta配置的文章模型。""" 标题 = models.CharField(max_length=200) slug = models.SlugField(unique=True) 作者 = models.ForeignKey(User, on_delete=models.CASCADE) 类别 = models.ForeignKey('类别', on_delete=models.SET_NULL, null=True) Publication_at = models.DateTimeField(null=True, 空白=True) 创建的_at = models.DateTimeField(auto_now_add=True) 类元： # 管理员的详细名称 verbose_name = _('文章') verbose_name_plural = _('文章') # 默认排序排序 = ['-published_at', '-created_at'] # 获取最新信息 get_latest_by = '发布时间' # 数据库表名称（可选，Django 自动生成） db_table = '博客文章' # 用于查询优化的索引索引 = [ models.Index(fields=['slug']), models.Index(fields=['author', '-published_at']), models.Index(fields=['类别', '-published_at']), models.Index(fields=['-published_at'], name='recent_articles_idx'), ] # 唯一的共同约束约束= [ 模型.UniqueConstraint( 字段=['作者', 'slug'], 名称='unique_author_slug', ), 模型.CheckConstraint( check=models.Q(published_at__isnull=True) | 检查=models.Q(published_at__isnull=True) | models.Q(published_at__gte=models.F('created_at')), name='published_after_created', ), ] # 权限权限=[ ('can_publish', '可以发布文章'), ('can_feature', '可以精选文章'), ] **常见元选项：** * `verbose_name` / `verbose_name_plural`：管理员显示名称 * `ordering`: 默认查询顺序 * `indexes`：用于性能的数据库索引 * `constraints`：UniqueConstraint、CheckConstraint 保证数据完整性 * `permissions`: 自定义权限 * `db_table`: 自定义表名（谨慎使用） * `get_latest_by`：用于latest()的字段 * `abstract`: 用于抽象基础模型 * `managed`: Django是否管理数据库生命周期 #### 2.4 管理器和查询集 **规则：** 使用自定义管理器实现可重用查询逻辑，使用查询集实现可链接查询。 ✅ **良好的自定义管理器和查询集：** **`apps/blog/managers.py`:** """博客应用程序的自定义管理器和查询集。""" 从 django.db 导入模型从 django.utils 导入时区类 PostQuerySet(models.QuerySet): """具有可重用查询方法的 Post 模型的自定义查询集。""" def 已发布（自己）： """仅返回已发布的帖子。""" 返回 self.filter( 状态= self.model.PostStatus.PUBLISHED， published_at__lte=timezone.now(), ） def 草稿（自己）： """返回草稿帖子。""" 返回 self.filter(status=self.model.PostStatus.DRAFT) def by_author(自我, 作者): """返回特定作者的帖子。""" 返回 self.filter(作者=作者) def 特色（自我）： """返回精选帖子。""" 返回 self.filter(featured=True) def 最近（自身，天数=30）： """返回最近 N 天的帖子。""" cutoff_date = timezone.now() - timezone.timedelta(days=days) 返回 self.filter(published_at__gte=cutoff_date) def with_author_info(self): """通过选择相关作者优化查询。""" 返回 self.select_lated('作者') def with_comments_count(self): """用评论数进行注释。""" 返回自我注释（ comments_count=models.Count('comments',distinct=True) ） def流行（自我，min_views = 100）： """返回高于查看阈值的热门帖子。""" return self.filter(view_count__gte=min_views).order_by('-view_count') 类 PostManager(models.Manager): """Post 模型的自定义管理器。""" def get_queryset(self): """返回自定义查询集。""" 返回 PostQuerySet(self.model, using=self._db) # 为方便起见，代理 QuerySet 方法 def 已发布（自己）： """返回已发布的帖子。""" 返回 self.get_queryset().published() def 草稿（自己）： """返回草稿帖子。""" 返回 self.get_queryset().drafts() def by_author(自我, 作者): """按作者返回帖子。""" 返回 self.get_queryset().by_author(作者) def 特色（自我）： """返回精选帖子。""" 返回 self.get_queryset().featured() def 最近（自身，天数=30）： """返回最近的帖子。""" 返回 self.get_queryset().recent(days) 类 PublishedPostManager(models.Manager): """默认情况下仅返回已发布帖子的管理器。""" def get_queryset(self): """仅返回已发布的帖子。""" 返回 super().get_queryset().filter( 状态='已发布', published_at__lte=timezone.now(), ） **models.py 中的用法：** 从 .managers 导入 PostManager、PublishedPostManager 类 Post(models.Model): # ...字段... # 默认管理器对象 = PostManager() # 仅针对已发布帖子的附加管理员已发布 = PublishedPostManager() 类元： base_manager_name = 'objects' # 用于相关查询 **在视图中的用法：** # 可链接的 QuerySet 方法 centre_featured_posts = Post.objects.published().featured().recent(days=7) # 多项优化热门帖子 = ( 后置对象 .published() .with_author_info() .with_comments_count() .popular(min_views=500) ） # 使用替代管理器 all_published = Post.published.all() **经理最佳实践：** 1. 将查询逻辑放入 QuerySet 中以实现可链接性 2. 创建返回 QuerySet 的管理器方法 3. 使用描述性方法名称 4. 记录每个方法的作用 5. 不要将业务逻辑放在管理器中（使用模型或服务） 6. 在管理器方法中使用 select_lated() 和 prefetch_lated() #### 2.5 模型方法与信号 **规则：** 将模型方法用于特定于对象的逻辑，将信号用于横切关注点。 ✅ **好 - 使用模型方法：** 类订单（模型.模型）： """方法中具有业务逻辑的订单模型。""" 总金额 = models.DecimalField(max_digits=10,decimal_places=2) discount_amount = models.DecimalField(max_digits=10，decimal_places=2，默认=0) tax_amount = models.DecimalField(max_digits=10，decimal_places=2，默认=0) defcalculate_total(self): """计算订单总额，包括税费和折扣。""" 小计 = self.total_amount - self.discount_amount 返回小计 + self.tax_amount def apply_discount(self, 折扣代码): """在订单中应用折扣代码。""" 从 .services 导入 DiscountService 折扣 = DiscountService.validate_and_get_discount(discount_code, self) self.discount_amount = 折扣.amount self.save(update_fields=['折扣金额']) 退货折扣 def mark_as_paid(自我): """将订单标记为已付款并触发履行。""" self.status = self.OrderStatus.PAID self.paid_at = timezone.now() self.save(update_fields=['状态', 'paid_at']) # 触发履行信号从.signals导入order_paid order_paid.send(sender=self.__class__, order=self) ✅ **好 - 使用信号来解决跨领域问题：** **`apps/orders/signals.py`:** """订单相关信号。""" 从 django.db.models.signals 导入 post_save、pre_delete 从 django.dispatch 导入接收器，信号 from .models import 订单 # 自定义信号 order_paid = Signal() # 提供 'order' 参数 @receiver(post_save, 发送者=订单) def send_order_confirmation_email（发件人，实例，创建，**kwargs）： """创建订单时发送确认电子邮件。""" 如果创建：从.tasks导入send_order_confirmation_email_task send_order_confirmation_email_task.delay(instance.id) @receiver(order_paid) def start_order_fulfillment（发件人，订单，**kwargs）： """订单付款后开始履行流程。""" 从.tasks导入start_fulfillment_task start_fulfillment_task.delay(order.id) @receiver(pre_delete, 发送者=订单) def log_order_deletion（发件人，实例，**kwargs）： """删除订单时记录日志以进行审计跟踪。""" 导入日志记录记录器=logging.getLogger(__name__) 记录器.警告( f"订单 {instance.order_number} 已被系统删除", extra={'order_id': 实例.id} ） **在apps.py中连接信号：** 从 django.apps 导入 AppConfig 类 OrdersConfig(AppConfig): default_auto_field = 'django.db.models.BigAutoField' 名称 = '应用程序.订单' def 准备好（自己）： """应用程序准备就绪时导入信号。""" 导入 apps.orders.signals # noqa **何时使用每个：** **模型方法：** * 特定于对象的业务逻辑 * 根据模型数据计算 * 状态转换 * 数据验证 * 简单的相关对象查询 **信号：** * 发送通知（电子邮件、短信、网络钩子） * 更新缓存 * 创建审计日志 * 触发后台任务 * 跨应用程序通信 * 更新非规范化数据 ❌ **不好 - 信号中的业务逻辑：** @receiver(post_save, 发送者=订单) def update_order_total（发件人，实例，**kwargs）： “”“不要这样做 - 业务逻辑应该在模型方法中。”“” 实例.total = 实例.calculate_subtotal() + 实例.tax instance.save() # 导致无限循环！ #### 2.6 相关名称和 related_query_name **规则：** 始终为反向关系设置显式的 related_name。 ✅ **好：** 用户类（模型.模型）：用户名 = models.CharField(max_length=150) 类 Post(models.Model): 作者 = models.ForeignKey( 用户， on_delete=models.CASCADE, related_name='posts', # user.posts.all() related_query_name='post', # User.objects.filter(post__title='...') ）标题 = models.CharField(max_length=200) 类注释（模型.模型）：帖子 = models.ForeignKey( 邮政， on_delete=models.CASCADE, related_name='评论', related_query_name='评论', ）作者 = models.ForeignKey( 用户， on_delete=models.CASCADE, related_name='评论', related_query_name='评论', ）内容 = models.TextField() # 用法： user = User.objects.get(用户名='john') user_posts = user.posts.all() # 使用 related_name user_comments = user.comments.all() # 查询过滤使用 related_query_name users_with_python_posts = User.objects.filter(post__title__contains='Python') posts_with_comments = Post.objects.filter(comment__isnull=False) ❌ **不好：** 类 Post(models.Model): # 不好：没有 related_name，Django 生成 'post_set' 作者 = models.ForeignKey(User, on_delete=models.CASCADE) # 不清楚的用法： user_posts = user.post_set.all() # 什么是 post_set？ **相关名称最佳实践：** * 使用复数形式表示一对多：`lated_name='posts'` * 使用单数表示一对一：`lated_name='profile'` * 使用 `lated_query_name` 进行清晰的查询过滤 * 如果不需要，可以使用 `lated_name='+'` 禁用反向关系 * 使用“app_label”避免应用程序之间的名称冲突 #### 2.7 数据库索引策略 **规则：** 为查询、过滤、排序等常用字段添加索引。 ✅ **良好的索引：** 类文章（模型.模型）： """具有战略索引的文章模型。""" 标题 = models.CharField(max_length=200) slug = models.SlugField(unique=True) # unique自动创建索引 author = models.ForeignKey(User, on_delete=models.CASCADE) # FK 创建索引类别 = models.ForeignKey(类别, on_delete=models.SET_NULL, null=True) 状态 = models.CharField(max_length=20, 选择=StatusChoices.choices) 特色 = models.BooleanField(默认=False) Publication_at = models.DateTimeField(null=True, 空白=True) view_count = models.PositiveIntegerField(默认=0) 创建的_at = models.DateTimeField(auto_now_add=True) 类元：索引 = [ # 按状态和排序过滤的索引 models.Index(fields=['status', '-published_at'], name='status_pub_idx'), # 作者文章索引 models.Index(fields=['author', '-created_at'], name='author_articles_idx'), # 分类浏览索引 models.Index(fields=['category', '-published_at'], name='cat_pub_idx'), # 专题文章索引模型.索引( 字段=['-published_at'], 条件=模型.Q(特色=真), name='featured_idx', # 部分索引 (PostgreSQL) ), # 复杂查询的复合索引模型.索引( fields=['状态', '精选', '-view_count'], name='popular_published_idx', ), ] # 文本搜索索引 (PostgreSQL) # 用于全文搜索功能 # 注意：需要来自 django.contrib.postgres.indexes 的 GinIndex **何时添加索引：** * 外键（Django 中自动） * `WHERE` 子句中的字段 * “ORDER BY”子句中的字段 * “JOIN”条件中的字段 * 唯一字段（自动） * `filter()`、`exclude()`、`get()` 中使用的字段 **何时不添加索引：** * 小表（< 10,000 行） * 经常变化的字段 * 基数较低的字段（很少有像布尔值这样的唯一值） * 太多索引会减慢写入速度 **指数分析：** # 检查查询是否使用索引从 django.db 导入连接从 django.test.utils 导入 CaptureQueriesContext 使用 CaptureQueriesContext(connection) 作为查询：文章 = 文章.objects.filter( 状态='已发布', 特色=真实 ).order_by('-view_count')[:10] list(articles) # 强制评估对于查询中的查询：打印（查询['sql']） # 检查数据库中的 EXPLAIN 输出 #### 2.8 迁移最佳实践 **规则：** 创建有针对性的、可审查的迁移并单独处理数据迁移。 ✅ **良好的迁移实践：** **1\.小而集中的迁移：** # 为不同的更改创建单独的迁移 python manage.py makemigrations --name add_email_verified_field python manage.py makemigrations --name add_user_role_choices **2\.数据迁移示例：** # 生成的迁移文件：0003_populate_user_roles.py 从 django.db 导入迁移 def populate_user_roles（应用程序，schema_editor）： """根据 is_staff 和 is_superuser 填充用户角色。""" 用户 = apps.get_model('用户', '用户') # 针对大数据集批量更新 User.objects.filter(is_superuser=True).update(role='ADMIN') User.objects.filter(is_staff=True, is_superuser=False).update(role='MOD') User.objects.filter(is_staff=False, is_superuser=False).update(role='USER') defverse_populate_user_roles（应用程序，schema_editor）： “”“反向操作。”“” 用户 = apps.get_model('用户', '用户') User.objects.all().update(role='USER') 类迁移（迁移.迁移）：依赖关系 = [ ('用户', '0002_user_role'), ] 操作=[ 迁移.RunPython( 填充_用户_角色， verse_code=reverse_populate_user_roles, ), ] **3\.安全架构更改：** # 安全：添加可为空的字段类迁移（迁移.迁移）：操作=[ 迁移.AddField( model_name='用户', 名称='电话号码', 字段=models.CharField(max_length=20, null=True, 空白=True), ), ] # 安全：添加默认字段类迁移（迁移.迁移）：操作=[ 迁移.AddField( model_name='帖子', name='view_count', 字段=models.PositiveIntegerField（默认=0）， ), ] **4\.用于删除字段的多步骤迁移：** # 第 1 步：使字段可为空（部署）字段=models.CharField（max_length=100，null=True，空白=True） # 步骤 2：从代码中删除，创建迁移（部署） # 第 3 步：删除列（部署） **迁移最佳实践：** 1. 在提交之前检查生成的迁移 2. 使用描述性迁移名称（`--name`） 3. 切勿在生产中编辑应用的迁移 4.使用`RunPython`进行反向操作的数据迁移 5. 测试类似生产数据的迁移 6. 在 CI 中使用 `--check` 来检测丢失的迁移 7. 当旧的迁移堆积时将其压扁 8. 通过数据迁移中的批处理处理大型数据集 9. 在单独的迁移中添加索引（可能会很慢） 10.使用数据库事务（Django中默认） ** ** ### 任务 3：视图和 URL 最佳实践 #### 3.1 基于类的视图 (CBV) 与基于函数的视图 (FBV) **规则：** 使用 CBV 进行 CRUD 操作，使用 FBV 进行简单或独特的逻辑。 ✅ **好 - 使用 CBV 进行标准 CRUD：** """使用基于类的视图的博客视图。""" 从 django.views.generic 导入 ListView、DetailView、CreateView、UpdateView、DeleteView 从 django.contrib.auth.mixins 导入 LoginRequiredMixin、UserPassesTestMixin 从 django.urls 导入reverse_lazy 从 .models 导入帖子从 .forms 导入 PostForm 类 PostListView(ListView): """列出所有已发布的帖子。""" 型号 = 帖子 template_name = '博客/post_list.html' context_object_name = '帖子' 分页依据 = 20 def get_queryset(self): """仅返回带有作者信息的已发布帖子。""" 返回 Post.objects.published().with_author_info() def get_context_data(self, **kwargs): """添加附加上下文数据。""" 上下文 = super().get_context_data(**kwargs) context['featured_posts'] = Post.objects.featured()[:5] 返回上下文类 PostDetailView(DetailView): """显示单个帖子。""" 型号 = 帖子 template_name = '博客/post_detail.html' context_object_name = '帖子' def get_object(self, queryset=None): """获取帖子并增加观看次数。""" post = super().get_object(queryset) post.increment_view_count() 返回帖子类 PostCreateView(LoginRequiredMixin, CreateView): """创建新帖子。""" 型号 = 帖子表单类 = PostForm template_name = '博客/post_form.html' success_url = reverse_lazy('博客:帖子列表') def form_valid(自我, 形式): """将作者设置为当前用户。""" form.instance.author = self.request.user 返回 super().form_valid(form) 类 PostUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView): “”“更新现有帖子。”“” 型号 = 帖子表单类 = PostForm template_name = '博客/post_form.html' def test_func(自身): """检查用户是作者还是管理员。""" post = self.get_object() 返回 self.request.user == post.author 或 self.request.user.is_staff def get_success_url(self): """重定向到帖子详细信息。""" 返回 self.object.get_absolute_url() 类 PostDeleteView（LoginRequiredMixin，UserPassesTestMixin，DeleteView）： “”“删除帖子。”“” 型号 = 帖子 template_name = '博客/post_confirm_delete.html' success_url = reverse_lazy('博客:帖子列表') def test_func(自身): """检查用户是作者还是管理员。""" post = self.get_object() 返回 self.request.user == post.author 或 self.request.user.is_staff ✅ **好 - 使用 FBV 实现独特的逻辑：** """博客视图使用基于函数的视图来实现自定义逻辑。""" 从 django.shortcuts 导入渲染、get_object_or_404、重定向从 django.contrib.auth.decorators 导入 login_required 从 django.http 导入 JsonResponse 从 django.views.decorators.http 导入 require_POST 从 .models 导入帖子 @login_required @require_POST deftoggle_post_featured(请求, pk): “”“切换帖子特色状态（独特的逻辑，适合FBV）。”“” 帖子 = get_object_or_404(帖子, pk=pk) # 检查权限如果不是request.user.is_staff：返回 JsonResponse({'error': '权限被拒绝'}, status=403) # 切换特色状态 post.featured = 不是 post.featured post.save(update_fields=['特色']) 返回 JsonResponse({ “成功”：确实， '精选'：post.featured， }) def search_posts（请求）： """搜索帖子（自定义搜索逻辑，适合 FBV）。""" 查询 = request.GET.get('q', '') 类别 = request.GET.get('类别', '') posts = Post.objects.published() 如果查询：帖子 = posts.filter( models.Q(title__icontains=query) | models.Q(content__icontains=query) ）如果类别： posts = posts.filter(category__slug=category) 上下文={ “帖子”：帖子， '查询'：查询， '类别'：类别， } 返回渲染（请求，'blog/search_results.html'，上下文） **何时使用每个：** **在以下情况下使用 CBV：** * 标准CRUD操作 * 需要继承和mixins * 使用表单 * 需要跨视图的一致结构 **在以下情况下使用 FBV：** * 简单的逻辑 * 独特的业务逻辑，不符合CBV模式 * 具有自定义逻辑的API端点 * 复杂的多步骤流程 * 函数更清晰易读 #### 3.2 通用视图 **规则：** 使用 Django 的通用视图来表示常见模式。 ✅ **好 - 使用通用视图：** 从 django.views.generic 导入（列表视图、详细信息视图、创建视图、更新视图、删除视图、模板视图、重定向视图、表单视图）类 HomePageView(TemplateView): """使用 TemplateView 的主页。""" 模板名称 = 'home.html' def get_context_data(self, **kwargs): 上下文 = super().get_context_data(**kwargs) context['recent_posts'] = Post.objects.published().recent()[:5] context['featured_posts'] = Post.objects.featured()[:3] 返回上下文类 ContactFormView(FormView): """使用 FormView 的联系表单。""" 模板名称 = 'contact.html' form_class = 联系表格 success_url = reverse_lazy('联系成功') def form_valid(自我, 形式): """当表单有效时发送电子邮件。""" 表单.send_email() 返回 super().form_valid(form) 类 RedirectToLatestPostView(RedirectView): """重定向到最新发布的帖子。""" 永久 = 假 def get_redirect_url(self, *args, **kwargs): latest_post = Post.objects.published().latest('published_at') 返回latest_post.get_absolute_url() **常见的通用视图：** * `TemplateView`: 渲染模板 * `ListView`: 列表对象 * `DetailView`: 显示单个对象 * `CreateView`: 创建带有表单的对象 * `UpdateView`: 用表单更新对象 * `DeleteView`: 删除对象 * `FormView`：显示并处理表单 * `RedirectView`: 重定向到 URL #### 3.3 查看权限和Mixins **规则：** 使用 mixin 来实现可重用的视图行为和权限。 ✅ **好 - 使用 Mixin：** 从 django.contrib.auth.mixins 导入（ LoginRequiredMixin, PermissionRequiredMixin, 用户通过测试混合，）从 django.views.generic 导入 ListView、UpdateView 类 AuthorRequiredMixin(UserPassesTestMixin): """Mixin 要求用户成为对象作者。""" def test_func(自身): """检查用户是否是对象作者。""" obj = self.get_object() 返回 obj.author == self.request.user 类 AdminOrAuthorMixin(UserPassesTestMixin): """混合要求用户是管理员或作者。""" def test_func(自身): """检查用户是否是管理员或作者。""" obj = self.get_object() 返回（ self.request.user.is_staff 或 obj.author == self.request.user ）类 MyPostsView(LoginRequiredMixin, ListView): """列出当前用户的帖子（需要登录）。""" 型号 = 帖子 template_name = '博客/my_posts.html' def get_queryset(self): 返回 Post.objects.filter(author=self.request.user) 类 PostPublishView(PermissionRequiredMixin, UpdateView): """发布帖子（需要许可）。""" 型号 = 帖子字段 = ['状态'] Permission_required = 'blog.can_publish' def form_valid(自我, 形式): form.instance.status = '已发布' 返回 super().form_valid(form) 类 PostEditView(AdminOrAuthorMixin, UpdateView): """编辑帖子（需要作者或管理员）。""" 型号 = 帖子表单类 = PostForm template_name = '博客/post_edit.html' **常见的混入：** * `LoginRequiredMixin`: 需要身份验证 * `PermissionRequiredMixin`: 需要特定权限 * `UserPassesTestMixin`: 自定义测试函数 * `UserOwnerMixin`：对象所有权的自定义 mixin **混合订单事宜：** # 正确顺序：从左到右类 MyView(LoginRequiredMixin, PermissionRequiredMixin, UpdateView): # Mixins从左到右处理通过 # 错误：视图类应该放在最后 class MyView(UpdateView, LoginRequiredMixin): # 不要这样做通过 #### 3.4 处理视图中的表单 **规则：** 使用 Django 表单进行验证，使用 form_valid() 进行自定义处理。 ✅ **良好的表格处理：** 从 django.views.generic.edit 导入 CreateView、UpdateView 从 .forms 导入 PostForm、CommentForm 类 PostCreateView(LoginRequiredMixin, CreateView): """使用表单创建帖子。""" 型号 = 帖子表单类 = PostForm template_name = '博客/post_form.html' def get_form_kwargs(self): """将用户传递给表单。""" kwargs = super().get_form_kwargs() kwargs['用户'] = self.request.user 返回夸格斯 def form_valid(自我, 形式): """处理有效的表格。""" form.instance.author = self.request.user 响应 = super().form_valid(form) # 发送通知从.tasks导入send_post_created_notification send_post_created_notification.delay(self.object.id) messages.success(self.request, '帖子创建成功！') 返回响应 def form_invalid(自我, 形式): """处理无效表单。""" messages.error(self.request, '请更正下面的错误。') 返回 super().form_invalid(form) def get_success_url(self): """重定向到帖子详细信息。""" 返回 self.object.get_absolute_url() 类 CommentCreateView(LoginRequiredMixin, CreateView): """使用 AJAX 支持创建评论。""" 型号=评论 form_class = 评论表单 template_name = '博客/comment_form.html' def form_valid(自我, 形式): """处理有效的评论表。""" form.instance.author = self.request.user form.instance.post_id = self.kwargs['post_pk'] 响应 = super().form_valid(form) # AJAX 请求返回 JSON if self.request.headers.get('X-Requested-With') == 'XMLHttpRequest': 返回 JsonResponse({ “成功”：确实， 'comment_id': self.object.id, '作者': self.object.author.用户名, '内容'：self.object.content， }) 返回响应 ** ** ### 任务 4：Django REST Framework (DRF) 最佳实践 #### 4.1 序列化器模式 **规则：** 对模型使用 ModelSerializer，根据需要添加验证和自定义字段。 ✅ **良好的序列化器设计：** **`apps/blog/serializers.py`:** """博客应用程序序列化器。""" 从rest_framework导入序列化器从 django.contrib.auth 导入 get_user_model 从 .models 导入帖子、评论、类别用户 = get_user_model() 类 UserSerializer(serializers.ModelSerializer): """具有有限字段的用户序列化程序。""" full_name = serializers.CharField(source='get_full_name', read_only=True) post_count = serializers.IntegerField(source='posts.count', read_only=True) 类元：模型=用户 fields = ['id', '用户名', '电子邮件', '全名', '帖子计数', '加入日期'] read_only_fields = ['加入日期'] 类 CategorySerializer(serializers.ModelSerializer): """类别序列化器。""" post_count = serializers.IntegerField(source='posts.count', read_only=True) 类元：型号=类别 fields = ['id', 'name', 'slug', 'description', 'post_count'] read_only_fields = ['slug'] 类 CommentSerializer(serializers.ModelSerializer): """带有嵌套作者的注释序列化器。""" 作者 = UserSerializer(read_only=True) author_id = serializers.IntegerField(write_only=True, required=False) 类元：型号=评论字段 = [ 'id', '帖子', '作者', 'author_id', '内容', “创建时间”、“更新时间” ] read_only_fields = ['创建时间', '更新时间'] def validate_content（自身，值）： """验证评论内容。""" 如果 len(值) < 10: 引发序列化器。ValidationError( “评论长度必须至少 10 个字符。” ）返回值类 PostListSerializer(serializers.ModelSerializer): """列表视图的后序列化程序（最小字段）。""" 作者 = UserSerializer(read_only=True) 类别 = CategorySerializer(read_only=True) comment_count = serializers.IntegerField(read_only=True) 摘录=serializers.SerializerMethodField() 类元：型号 = 帖子字段 = [ 'id', '标题', 'slug', '作者', '类别', '摘录'、'状态'、'精选'、'view_count'、 'comment_count', 'published_at', 'created_at' ] def get_excerpt(self, obj): """返回内容的前 200 个字符。""" 返回 obj.content[:200] + '...' if len(obj.content) > 200 else obj.content 类 PostDetailSerializer(serializers.ModelSerializer): """详细视图的后序列化程序（完整字段）。""" 作者 = UserSerializer(read_only=True) 类别 = CategorySerializer(read_only=True) 评论= CommentSerializer（许多= True，read_only = True） comment_count = serializers.IntegerField(source='comments.count', read_only=True) # 只写字段 author_id = serializers.IntegerField(write_only=True, required=False) Category_id = serializers.IntegerField(write_only=True, required=False) 类元：型号 = 帖子字段 = [ 'id', '标题', 'slug', '作者', 'author_id', '类别'，'category_id'，'内容'，'状态'， '精选', 'view_count', '评论', 'comment_count', “发布时间”、“创建时间”、“更新时间” ] read_only_fields = ['slug', 'view_count', 'created_at', 'updated_at'] def 验证（自身，属性）： """验证发布数据。""" # 如果未提供，则根据请求设置作者如果“author_id”不在属性中： attrs['author_id'] = self.context['request'].user.id # 验证发布的帖子有类别如果 attrs.get('status') == 'PUBLISHED' 而不是 attrs.get('category_id')：引发序列化器。ValidationError({ 'category': '发布的帖子必须有一个类别。' }) 返回属性 def create(self, validated_data): """创建帖子并设置published_at（如果已发布）。""" 如果 valid_data.get('status') == '已发布': 从 django.utils 导入时区 valid_data['published_at'] = timezone.now() 返回 super().create(validated_data) 类 PostWriteSerializer(serializers.ModelSerializer): """用于创建/更新的后序列化程序（与读取分开）。""" 类元：型号 = 帖子字段 = [ '标题', 'slug', '类别', '内容', “状态”、“特色” ] def validate_slug(自身, 值): """验证 slug 的唯一性。""" # 更新时排除当前实例 queryset = Post.objects.filter(slug=值) 如果是 self.instance: 查询集 = 查询集.排除(pk=self.instance.pk) 如果 queryset.exists(): raise serializers.ValidationError("带有此 slug 的帖子已经存在。") 返回值 **序列化器最佳实践：** 1. 当字段差异很大时，使用单独的序列化器进行列表/详细信息/写入 2. 对计算字段使用 `SerializerMethodField` 3.使用“source”参数来引用模型方法/属性 4.为计算字段设置`read_only=True` 5. 对密码/敏感输入字段使用 write_only=True 6. 单字段在 `validate_()` 中验证，多字段在 `validate()` 中验证 7. 将业务逻辑保留在模型/服务中，而不是序列化器中 8. 在读取中对相关对象使用嵌套序列化器，在写入中对 ID 使用嵌套序列化器 #### 4.2 ViewSet 与 APIView **规则：** 将 ViewSets 用于标准 CRUD API，将 APIView 用于自定义端点。 ✅ **好 - 使用 ViewSets：** """使用 ViewSets 的博客 API 视图。""" 从rest_framework导入视图集、过滤器、状态从rest_framework.decorators导入操作从rest_framework.response导入响应从rest_framework.permissions导入IsAuthenticatedOrReadOnly 从 django_filters.rest_framework 导入 DjangoFilterBackend 从 .models 导入帖子、评论从 .serializers 导入 ( PostListSerializer、PostDetailSerializer、 PostWriteSerializer、CommentSerializer ）从 .permissions 导入 IsAuthorOrReadOnly 类 PostViewSet(viewsets.ModelViewSet): """具有 CRUD 操作的 Post 模型的 ViewSet。""" 权限类 = [IsAuthenticatedOrReadOnly, IsAuthorOrReadOnly] filter_backends = [DjangoFilterBackend, 过滤器.SearchFilter, 过滤器.OrderingFilter] filterset_fields = ['状态', '类别', '特色'] search_fields = ['标题','内容'] ordering_fields = ['created_at', 'published_at', 'view_count'] 排序 = ['-published_at'] def get_queryset(self): """根据操作返回适当的查询集。""" 查询集 = Post.objects.all() 如果 self.action == '列表': # 优化列表查询 queryset = queryset.select_lated('作者', '类别') 查询集 = 查询集.注释( comment_count=models.Count('评论') ） # 按非员工用户的发布状态过滤如果不是 self.request.user.is_staff： queryset = queryset.filter(status='已发布') elif self.action == '检索': # 优化明细查询 queryset = queryset.select_lated('作者', '类别') queryset = queryset.prefetch_lated('comments__author') 返回查询集 def get_serializer_class(self): """根据操作返回适当的序列化程序。""" 如果 self.action == '列表': 返回 PostListSerializer ['create', 'update', 'partial_update'] 中的 elif self.action: 返回 PostWriteSerializer 返回 PostDetailSerializer def Perform_create(self, 序列化器): """创建帖子时设置作者。""" 序列化器.save（作者= self.request.user） @action(详细信息=True, 方法=['post']) def 发布（自我，请求，pk =无）： """发布帖子的自定义操作。""" post = self.get_object() 如果 post.status == '已发布': 返回响应（ {'detail': '帖子已经发布。'}, 状态=status.HTTP_400_BAD_REQUEST ） post.status = '已发布' 从 django.utils 导入时区 post.published_at = timezone.now() 保存后（）序列化器 = self.get_serializer(post) 返回响应（序列化器.数据） @action(详细信息=True, 方法=['get']) def 评论（自我、请求、pk=无）： """获取帖子的评论。""" post = self.get_object() 评论 = post.comments.select_lated('作者') 页面 = self.paginate_queryset(评论) 如果页面不是“无”：序列化器= CommentSerializer（页，许多= True）返回 self.get_pagination_response(serializer.data) 序列化器= CommentSerializer（评论，很多= True）返回响应（序列化器.数据） @action(detail=False, 方法=['get']) def 特色（自我，请求）： """获取特色帖子。""" queryset = self.get_queryset().filter(featured=True)[:10] 序列化器 = self.get_serializer(queryset, Many=True) 返回响应（序列化器.数据）类 CommentViewSet(viewsets.ModelViewSet): """评论模型的视图集。""" queryset = Comment.objects.select_lated('作者', '帖子') 序列化器类 = CommentSerializer 权限类 = [IsAuthenticatedOrReadOnly, IsAuthorOrReadOnly] def Perform_create(self, 序列化器): """创建评论时设置作者。""" 序列化器.save（作者= self.request.user） ✅ **好 - 使用 APIView 进行自定义逻辑：** """使用 APIView 自定义 API 视图。""" 从rest_framework.views导入APIView 从rest_framework.response导入响应从rest_framework导入状态从 django.db.models 导入计数、平均值从 .models 导入帖子类 PostStatisticsAPIView(APIView): """用于帖子统计的自定义端点。""" def get(自身, 请求): """返回帖子统计信息。""" stats = Post.objects.aggregate( 总帖子数=计数('id'), Total_views=models.Sum('view_count'), avg_views=平均('view_count'), published_posts=Count('id',filter=models.Q(status='已发布')), ）返回响应（统计）类 BulkPublishAPIView(APIView): """批量发布帖子。""" 权限类 = [IsAdminUser] def post（自我，请求）： """发布多个帖子。""" post_ids = request.data.get('post_ids', []) 如果不是 post_ids：返回响应（ {'detail': '未提供帖子 ID。'}, 状态=status.HTTP_400_BAD_REQUEST ）从 django.utils 导入时区 Updated_count = Post.objects.filter（ id__in=post_ids, 状态='草稿' ).更新( 状态='已发布', published_at=时区.now() ）返回响应（{ 'detail': f'已发布 {updated_count} 条帖子。', “计数”：updated_count }) **何时使用每个：** **在以下情况下使用视图集：** * 标准CRUD操作 * 使用单一模型 * 需要生成路由器URL * 想要一致的API结构 **在以下情况下使用 APIView：** * 自定义业务逻辑 * 一个端点多个模型 * 非CRUD操作 * 复杂的请求/响应处理 #### 4.3 权限类别 **规则：** 使用 DRF 权限类进行访问控制。 ✅ **良好的自定义权限：** **`apps/blog/permissions.py`:** """博客应用程序的自定义权限类。""" 从rest_framework导入权限类 IsAuthorOrReadOnly(permissions.BasePermission): """仅允许作者编辑其对象的权限。""" def has_object_permission(self, request, view, obj): """检查对象级权限。""" # 任何请求的读取权限如果request.method在permissions.SAFE_METHODS中：返回真 # 只有作者有写权限返回 obj.author == request.user 类 IsAdminOrAuthor(permissions.BasePermission): """管理员或作者的权限。""" def has_object_permission(self, request, view, obj): """检查用户是否是管理员或作者。""" 返回 request.user.is_staff 或 obj.author == request.user 类 CanPublishPost(permissions.BasePermission): """发布帖子的权限。""" message = “您无权发布帖子。” def has_permission（自身，请求，视图）： """检查用户是否有发布权限。""" 返回 request.user.has_perm('blog.can_publish') 类 IsEmailVerified(permissions.BasePermission): """需要验证电子邮件的权限。""" message =“必须验证电子邮件才能执行此操作。” def has_permission（自身，请求，视图）： """检查用户的电子邮件是否已验证。""" 返回 request.user.is_authenticated 和 request.user.email_verified **使用视图中的权限：** 类 PostViewSet(viewsets.ModelViewSet): """发布具有多个权限类别的 ViewSet。""" def get_permissions(自我): """根据操作返回适当的权限。""" if self.action in ['create', 'update', 'partial_update', 'destroy']: 权限类 = [IsAuthenticated、IsEmailVerified、IsAuthorOrReadOnly] elif self.action == '发布': Permission_classes = [IsAuthenticated, CanPublishPost] 其他：权限类 = [AllowAny] 返回[permission()以获得permission_classes中的权限] **常见权限类别：** * `AllowAny`: 允许所有（默认） * `IsAuthenticated`: 需要身份验证 * `IsAdminUser`: 需要员工身份 * `IsAuthenticatedOrReadOnly`：读取所有内容，写入经过身份验证的内容 * `DjangoModelPermissions`: 使用Django模型权限 * `DjangoObjectPermissions`: 对象级权限 #### 4.4 身份验证模式 **规则：** 对 API 使用基于令牌的身份验证，对 Web 使用会话。 ✅ **良好的身份验证设置：** **`设置/base.py`：** 休息框架 = { 'DEFAULT_AUTHENTICATION_CLASSES'：[ 'rest_framework.authentication.TokenAuthentication', 'rest_framework.authentication.SessionAuthentication', ], 'DEFAULT_PERMISSION_CLASSES'：[ 'rest_framework.permissions.IsAuthenticatedOrReadOnly', ], 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination', “页面大小”：20， 'DEFAULT_FILTER_BACKENDS'：[ 'django_filters.rest_framework.DjangoFilterBackend', 'rest_framework.filters.SearchFilter', 'rest_framework.filters.OrderingFilter', ], } **JWT 身份验证（使用 djangorestframework-simplejwt）：** # 设置/base.py 从日期时间导入时间增量已安装的应用程序 += [ 'rest_framework_simplejwt', ] 休息框架 = { 'DEFAULT_AUTHENTICATION_CLASSES'：[ 'rest_framework_simplejwt.authentication.JWTAuthentication', ], } 简单_JWT = { 'ACCESS_TOKEN_LIFETIME': timedelta(分钟=60), 'REFRESH_TOKEN_LIFETIME': timedelta(天=7), 'ROTATE_REFRESH_TOKENS'：正确， 'BLACKLIST_AFTER_ROTATION'：正确， 'UPDATE_LAST_LOGIN'：正确， '算法': 'HS256', 'SIGNING_KEY'：SECRET_KEY， 'AUTH_HEADER_TYPES': ('承载',), } **身份验证视图：** 从rest_framework_simplejwt.views导入（ Token获取PairView，令牌刷新视图，） url 模式 = [ 路径('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'), 路径('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'), ] #### 4.5 分页最佳实践 **规则：** 始终对列表端点进行分页，提供分页控件。 ✅ **良好的分页：** **`apps/core/pagination.py`:** """自定义分页类。""" 从rest_framework.pagination导入PageNumberPagination，CursorPagination 从rest_framework.response导入响应类 StandardResultsSetPagination(PageNumberPagination): """带有页码的标准分页。""" 页面大小 = 20 page_size_query_param = 'page_size' 最大页面大小 = 100 def get_pagination_response(自身，数据)： """自定义分页响应。""" 返回响应（{ 'count': self.page.paginator.count, '下一个': self.get_next_link(), '上一个': self.get_previous_link(), 'page_size': self.page_size, 'total_pages': self.page.paginator.num_pages, 'current_page': self.page.number, “结果”：数据， }) 类 LargeResultsSetPagination(PageNumberPagination): """大型数据集的分页。""" 页面大小 = 100 page_size_query_param = 'page_size' 最大页面大小 = 1000 类 PostCursorPagination(CursorPagination): """帖子的光标分页（更适合无限滚动）。""" 页面大小 = 20 排序 = '-created_at' 光标查询参数 = '光标' **在视图集中使用：** 类 PostViewSet(viewsets.ModelViewSet): """发布带有分页的 ViewSet。""" pagination_class = StandardResultsSetPagination # 覆盖特定操作 def get_pagination_response(自身，数据)： """将自定义元数据添加到分页响应中。""" 响应 = super().get_pagination_response(数据) 响应.data['元'] = { 'total_featured': Post.objects.filter(featured=True).count(), } 返回响应 #### 4.6 过滤和搜索 **规则：** 使用 django-filter 进行复杂过滤，使用 DRF 过滤器进行搜索/排序。 ✅ **良好的过滤设置：** **`apps/blog/filters.py`:** """博客应用程序的自定义过滤器。""" 从 django_filters 导入rest_framework 作为过滤器从 .models 导入帖子类 PostFilter(filters.FilterSet): """Post 模型的自定义过滤器。""" title =filters.CharFilter(lookup_expr='icontains') 作者用户名=filters.CharFilter(field_name='author__username',lookup_expr='iexact') 类别=过滤器.CharFilter(field_name='category__slug') published_after=filters.DateTimeFilter(field_name='published_at',lookup_expr='gte') published_before=filters.DateTimeFilter(field_name='published_at',lookup_expr='lte') min_views =filters.NumberFilter(field_name='view_count',lookup_expr='gte') 特色=过滤器.BooleanFilter() 状态=过滤器.ChoiceFilter(choices=Post.PostStatus.choices) 类元：型号 = 帖子 fields = ['标题', '作者用户名', '类别', '特色', '状态'] 类 PostViewSet(viewsets.ModelViewSet): """通过过滤发布 ViewSet。""" 查询集 = Post.objects.all() 序列化器类 = PostSerializer 过滤器集_类 = 后置过滤器过滤器后端 = [ DjangoFilter后端，过滤器.SearchFilter, 过滤器.OrderingFilter, ] search_fields = ['标题', '内容', '作者__用户名'] ordering_fields = ['created_at', 'published_at', 'view_count', 'title'] 排序 = ['-published_at'] **用途：** # 过滤器示例： GET /api/posts/?category=django&featured=true GET /api/posts/?published_after=2024-01-01&min_views=100 GET /api/posts/?search=django&ordering=-view_count GET /api/posts/?author_username=john #### 4.7 API 版本控制 **规则：** 从一开始就对 API 进行版本控制，使用 URL 路径版本控制。 ✅ **良好的 API 版本控制：** **`设置/base.py`：** 休息框架 = { 'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning', 'DEFAULT_VERSION': 'v1', 'ALLOWED_VERSIONS': ['v1', 'v2'], 'VERSION_PARAM': '版本', } **`urls.py`:** from django.urls 导入路径，包括 url 模式 = [ 路径('api/v1/', include('apps.api.v1.urls')), 路径('api/v2/', include('apps.api.v2.urls')), ] **特定于版本的序列化器：** # 应用程序/api/v1/serializers.py 类 PostSerializerV1(serializers.ModelSerializer): 类元：型号 = 帖子 fields = ['id', '标题', '内容', '作者'] # 应用程序/api/v2/serializers.py 类 PostSerializerV2(serializers.ModelSerializer): # V2添加新字段类元：型号 = 帖子 fields = ['id', '标题', '内容', '作者', 'slug', '类别'] ** ** ### 任务 5：表单和模型表单最佳实践 #### 5.1 表单字段验证 **规则：** 使用 clean_() 方法验证字段，使用 clean() 跨字段验证。 ✅ **良好的表单验证：** **`apps/users/forms.py`:** """带有验证的用户表单。""" 从 django 导入表单从 django.contrib.auth 导入 get_user_model 从 django.contrib.auth.forms 导入 UserCreationForm 从 django.core.exceptions 导入 ValidationError 进口再用户 = get_user_model() 类用户注册表单（用户创建表单）： """具有自定义验证的用户注册表单。""" 电子邮件=表单.EmailField( 必需=真， help_text='输入有效的电子邮件地址。', ）同意条款 = forms.BooleanField( 必需=真， label='我同意条款和条件', ）类元：模型=用户 fields = ['用户名', '电子邮件', '密码1', '密码2', '同意条款'] def clean_username(自己): """验证用户名。""" 用户名 = self.cleaned_data.get('用户名') # 检查长度如果 len(用户名) < 3: raise ValidationError('用户名必须至少为 3 个字符。') # 检查格式（仅限字母数字和下划线）如果不是 re.match(r'^[a-zA-Z0-9_]+$', 用户名): 引发验证错误（ “用户名只能包含字母、数字和下划线。” ） # 检查唯一性 if User.objects.filter(username__iexact=username).exists(): raise ValidationError('该用户名已被占用。') 返回用户名.lower() def clean_email(自我): """验证电子邮件。""" 电子邮件 = self.cleaned_data.get('电子邮件') # 检查唯一性如果 User.objects.filter(email__iexact=email).exists(): raise ValidationError('此电子邮件已被注册。') # 检查域（例如：阻止某些域）域 = email.split('@')[1] blocked_domains = ['tempmail.com', 'throtaway.email'] 如果域位于blocked_domains中： raise ValidationError('不允许来自此域的电子邮件。') 返回 email.lower() def 清洁（自我）： “”“跨领域验证。”“” clean_data = super().clean() 密码1 = clean_data.get('密码1') 密码2 = clean_data.get('密码2') 用户名 = clean_data.get('用户名') # 检查密码不包含用户名如果password1和username以及username.lower()在password1.lower()中： raise ValidationError('密码不能包含您的用户名。') 返回已清理的数据 def 保存（自我，提交=True）： """通过附加处理保存用户。""" 用户 = super().save(commit=False) user.email = self.cleaned_data['email'] 如果提交：用户.save() # 发送验证邮件从.tasks导入send_verification_email send_verification_email.delay(用户.id) 返回用户类 PostForm(forms.ModelForm): """发布表单并进行验证。""" 类元：型号 = 帖子 fields = ['标题', 'slug', '类别', '内容', '状态', '特色'] 小部件= { '内容': forms.Textarea(attrs={'rows': 10}), 'slug': forms.TextInput(attrs={'placeholder': '自动生成的标题'}), } def __init__(self, *args, **kwargs): """使用自定义行为初始化表单。""" self.user = kwargs.pop('用户', None) super().__init__(*args, **kwargs) # 在创建时使 slug 可选（从标题自动生成）如果不是 self.instance.pk： self.fields['slug'].required = False # 根据用户限制类别选择如果 self.user 而不是 self.user.is_staff： self.fields['category'].queryset = Category.objects.filter(public=True) def clean_slug(自身): """验证并自动生成段。""" slug = self.cleaned_data.get('slug') 标题 = self.cleaned_data.get('标题') # 如果没有提供则自动生成slug 如果没有标题和标题：从 django.utils.text 导入 slugify slug = slugify(标题) # 检查唯一性（不包括当前实例） queryset = Post.objects.filter(slug=slug) 如果 self.instance.pk: 查询集 = 查询集.排除(pk=self.instance.pk) 如果 queryset.exists(): raise ValidationError('带有此 slug 的帖子已经存在。') 返回弹头 def clean_content(自我): """验证内容。""" 内容 = self.cleaned_data.get('内容') # 最小长度如果 len(内容) < 100: raise ValidationError('帖子内容必须至少为 100 个字符。') 返回内容 def 清洁（自我）： “”“跨领域验证。”“” clean_data = super().clean() 状态 = clean_data.get('状态') 类别 = clean_data.get('类别') # 发布的帖子必须有类别如果状态==“已发布”而不是类别：引发验证错误({ 'category': '发布的帖子必须有一个类别。' }) 返回已清理的数据 #### 5.2 模型表单的使用 **规则：** 对于数据库支持的表单使用 ModelForm，对于非模型表单使用 Form。 ✅ **良好的模型形式：** 类 CommentForm(forms.ModelForm): """注释模型的 ModelForm。""" 类元：型号=评论字段 = ['内容'] 小部件= { '内容': forms.Textarea(attrs={ “行”：4， 'placeholder': '在这里写下您的评论...', 'class': '表单控制', }), } 标签={ '内容': '您的评论', } 帮助文本 = { 'content': '保持尊重和建设性。', } def __init__(self, *args, **kwargs): “”“初始化表单。”“” self.post = kwargs.pop('post', None) self.user = kwargs.pop('用户', None) super().__init__(*args, **kwargs) def 保存（自我，提交=True）： """保存帖子和用户的评论。""" 评论 = super().save(commit=False) 如果是自我发布：评论.post = self.post 如果是 self.user: 评论.作者 = self.用户如果提交：评论.保存() 返回评论 ✅ **良好的形态（非模特）：** 类 ContactForm(forms.Form): """联系表格不受模型支持。""" 名称 = forms.CharField( 最大长度=100， widget=forms.TextInput(attrs={'placeholder': '你的名字'}), ）电子邮件=表单.EmailField( widget=forms.EmailInput(attrs={'placeholder': 'your@email.com'}), ）主题 = forms.CharField( 最大长度=200， widget=forms.TextInput(attrs={'placeholder': '主题'}), ）消息 = forms.CharField( widget=forms.Textarea(attrs={'rows': 6, 'placeholder': '您的消息...'}), ） def send_email(自己): """发送联系电子邮件。""" 从 django.core.mail 导入 send_mail 发送邮件（ subject=f"联系表格：{self.cleaned_data['subject']}", 消息=self.cleaned_data['消息'], from_email=self.cleaned_data['电子邮件'], 收件人列表=['contact@example.com'], ） #### 5.3 表单集 **规则：** 使用表单集处理多个表单。 ✅ **良好的表单集用法：** 从 django.forms 导入 modelformset_factory，inlineformset_factory # ModelFormSet 用于编辑多个对象 PostFormSet = modelformset_factory( 邮政， fields=['标题', '状态', '特色'], extra=0, # 没有多余的空表格 can_delete=真，） # 相关对象的 InlineFormSet CommentFormSet = inlineformset_factory( 邮政，评论，字段=['内容'], 额外=1， can_delete=真，） # 在视图中： def edit_post_with_comments(请求, pk): """编辑帖子及其评论。""" 帖子 = get_object_or_404(帖子, pk=pk) 如果 request.method == 'POST': post_form = PostForm(请求.POST, 实例=post) comment_formset = CommentFormSet(request.POST, 实例=post) 如果 post_form.is_valid() 和 comment_formset.is_valid(): post_form.save() comment_formset.save() 返回重定向（'post-detail'，pk = post.pk）其他： post_form = PostForm(实例=post) comment_formset = CommentFormSet(实例=帖子) 返回渲染（请求，'post_edit.html'，{ '形式'：post_form， '表单集'：comment_formset， }) ** ** ### 任务 6：安全最佳实践 #### 6.1 CSRF 保护 **规则：** 始终使用 CSRF 保护，切勿在生产中禁用它。 ✅ **良好的 CSRF 用法：** <表单方法=“帖子”> {% csrf_token %} {{ 表单.as_p }} # 在 AJAX 请求中从 django.middleware.csrf 导入 get_token def my_view（请求）： """为 AJAX 提供 CSRF 令牌的视图。""" 返回 JsonResponse({ 'csrfToken'：get_token（请求）， }) // 在 JavaScript 中 fetch('/api/端点/', { 方法：'POST'，标题：{ '内容类型'：'应用程序/json'， 'X-CSRFToken': getCookie('csrftoken'), }, 正文：JSON.stringify（数据）， }); ❌ **不好 - 永远不要这样做：** 从 django.views.decorators.csrf 导入 csrf_exempt @csrf_exempt # 不要在生产中这样做 def my_view（请求）：通过 #### 6.2 SQL注入预防 **规则：** 始终使用 Django ORM 或参数化查询，切勿使用字符串连接。 ✅ **好 - 免受 SQL 注入：** # 使用ORM（自动转义）用户 = User.objects.filter(用户名=user_input) # 使用 ORM Q 对象从 django.db.models 导入 Q 用户 = User.objects.filter( Q(用户名__icontains=search_term) | Q(email__icontains=search_term) ） # 如果必须使用原始 SQL，请使用参数化从 django.db 导入连接使用 connection.cursor() 作为光标：光标.执行( “从用户中选择*，其中用户名 = %s”， [user_input] # 参数化 - SAFE ） ❌ **糟糕 - SQL 注入漏洞：** # 不要这样做 - 容易受到 SQL 注入查询= f“从用户中选择*，其中用户名='{user_input}'” 光标.执行（查询） # 不要这样做 User.objects.raw(f"SELECT * FROM users WHERE username = '{user_input}'") #### 6.3 XSS 预防 **规则：** 使用 Django 的自动转义，仅在必要时标记安全。 ✅ **好 - XSS 保护：**

从 django.utils.html 导入转义，format_html # 转义用户输入安全文本 = 转义（用户输入） # 使用 format_html 构建 HTML html = 格式_html( '链接', user_url # 自动转义） ❌ **坏 - XSS 漏洞：**

# 不要这样做 html = f'

{user_input}

' # 未转义 #### 6.4 SECRET_KEY 和敏感设置 **规则：** 永远不要对秘密进行硬编码，使用环境变量。 ✅ **好：** # 设置/生产.py 导入操作系统 SECRET_KEY = os.environ['DJANGO_SECRET_KEY'] DATABASE_PASSWORD = os.environ['DB_PASSWORD'] AWS_SECRET_ACCESS_KEY = os.environ['AWS_SECRET_KEY'] # 使用 python 解耦从解耦导入配置 SECRET_KEY = 配置（'SECRET_KEY'） DEBUG = config('DEBUG', 默认=False, 强制转换=bool) ❌ **不好：** # 不要这样做 SECRET_KEY = 'my-secret-key-123' # 硬编码的秘密 DATABASE_PASSWORD = 'password123' # 在源代码中 #### 6.5 调试设置 **规则：** 切勿在生产中设置 DEBUG=True。 ✅ **好：** # 设置/生产.py 调试=假 ALLOWED_HOSTS = ['yourdomain.com', 'www.yourdomain.com'] # 自定义错误页面 ADMINS = [('管理员', 'admin@yourdomain.com')] 经理=管理员 #### 6.6 安全中间件 **规则：** 在生产中启用所有安全中间件。 ✅ **良好的生产安全：** # 设置/生产.py # 安全中间件中间件 = [ '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', ] # HTTPS 设置 SECURE_SSL_REDIRECT = 真 SESSION_COOKIE_SECURE = True CSRF_COOKIE_SECURE = True # HSTS 设置 SECURE_HSTS_SECONDS = 31536000 # 1 年 SECURE_HSTS_INCLUDE_SUBDOMAINS = True SECURE_HSTS_PRELOAD = True # 其他安全设置 SECURE_BROWSER_XSS_FILTER = True SECURE_CONTENT_TYPE_NOSNIFF = True X_FRAME_OPTIONS = '拒绝' # 密码验证 AUTH_PASSWORD_VALIDATORS = [ {'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'}, {'NAME'：'django.contrib.auth.password_validation.MinimumLengthValidator'，'选项'：{'min_length'：12}}， {'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'}, {'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'}, ] ** ** ### 任务 7：性能优化 #### 7.1 N+1 Query Prevention **规则：** 使用 select_lated() 和 prefetch_lated() 来避免 N+1 查询。 ✅ **好 - 优化查询：** # N+1 Problem Example (BAD): posts = Post.objects.all() 对于帖子中的帖子： print(post.author.username) # 触发每个帖子的查询！ # 解决方案 1：ForeignKey/OneToOne 的 select_lated posts = Post.objects.select_lated('作者', '类别').all() 对于帖子中的帖子： print(post.author.username) # 没有额外的查询！ # 解决方案 2：ManyToMany/Reverse FK 的 prefetch_lated posts = Post.objects.prefetch_lated('comments').all() 对于帖子中的帖子： print(post.comments.count()) # 没有额外的查询！ # 带过滤的复杂预取从 django.db.models 导入预取帖子 = Post.objects.prefetch_lated( 预取（ '评论', queryset=Comment.objects.select_lated('author').filter(approved=True), to_attr='批准的评论' ） ).all() 对于帖子中的帖子： for comment in post.approved_comments: print(comment.author.username) # 总共 3 次查询！ **何时使用每个：** * `select_lated()`: 对于ForeignKey 和 OneToOneField (SQL JOIN) * `prefetch_lated()`：对于ManyToManyField和反向ForeignKey（单独查询+Python join） #### 7.2 使用 only() 和 defer() 进行查询优化 **规则：** 使用 only() 获取特定字段，defer() 排除字段。 ✅ **好：** # Only fetch needed fields users = User.objects.only('id', '用户名', '电子邮件') # 推迟大字段 posts = Post.objects.defer('content') # 不加载内容字段 # Combine with select_related 帖子 = ( 后置对象 .select_related('author') .only('id', '标题', '作者__用户名', 'created_at') ） #### 7.3 Database Query Analysis **规则：** 监控和分析查询，使用 django-debug-toolbar。 ✅ **Good - Query Analysis:** # In development, use django-debug-toolbar INSTALLED_APPS += ['debug_toolbar'] 中间件 += ['debug_toolbar.middleware.DebugToolbarMiddleware'] # Log queries in development 记录 = { “版本”：1， '处理程序'：{ '控制台'：{ 'class': 'logging.StreamHandler', }, }, '记录器'：{ 'django.db.backends': { '处理程序'：['控制台']， '级别'：'调试'， }, }, } # Check query count in tests from django.test.utils import override_settings 从 django.db 导入连接从 django.test.utils 导入 CaptureQueriesContext 使用 CaptureQueriesContext(connection) 作为查询： # 这里是你的代码列表(Post.objects.all()) print(f"Number of queries: {len(queries)}") 对于查询中的查询：打印（查询['sql']） #### 7.4 Caching Strategies **Rule:** Cache expensive queries and computations. ✅ **良好的缓存：** # Cache decorator for views 从 django.views.decorators.cache 导入cache_page @cache_page(60 * 15) # 缓存15分钟 def post_list（请求）： posts = Post.objects.published().with_author_info() return render(request, 'posts.html', {'posts': posts}) # 低级缓存API 从 django.core.cache 导入缓存 def get_popular_posts(): """Get popular posts with caching.""" cache_key = 'popular_posts' posts = cache.get(cache_key) 如果 posts 为 None： posts = list(Post.objects.popular()[:10]) cache.set(cache_key, posts, 60 * 60) # Cache for 1 hour 返回帖子 # Cache expensive computations from django.utils.functional import cached_property 类 Post(models.Model): # ...字段... @cached_property def word_count(自身): """Calculate word count (cached on instance).""" return len(self.content.split()) # Template fragment caching {%加载缓存%} {% cache 500 sidebar request.user.username %} {% 结束缓存%} **缓存设置：** # Redis cache (recommended for production) 缓存 = { “默认”：{ '后端': 'django.core.cache.backends.redis.RedisCache', '位置': 'redis://127.0.0.1:6379/1', “选项”：{ 'CLIENT_CLASS': 'django_redis.client.DefaultClient', }, 'KEY_PREFIX': 'myproject', 'TIMEOUT': 300, # 5 minutes default } } # Memcached 缓存缓存 = { “默认”：{ 'BACKEND': 'django.core.cache.backends.memcached.PyMemcacheCache', 'LOCATION': '127.0.0.1:11211', } } #### 7.5 Database Connection Pooling **Rule:** Use connection pooling in production for better performance. ✅ **好：** # 设置/生产.py 数据库= { “默认”：{ '引擎': 'django.db.backends.postgresql', 'NAME': os.environ['DB_NAME'], '用户': os.environ['DB_USER'], '密码': os.environ['DB_PASSWORD'], 'HOST': os.environ['DB_HOST'], 'PORT': os.environ.get('DB_PORT', '5432'), 'CONN_MAX_AGE': 600, # Connection pooling (10 minutes) “选项”：{ '连接超时'：10， }, } } ** ** ### Task 8: Testing Django Applications **Rule:** Write comprehensive tests for models, views, and APIs. ✅ **Good Django Tests:** **`apps/blog/tests/test_models.py`:** """博客模型测试。""" 从 django.test 导入测试用例从 django.contrib.auth 导入 get_user_model 从 apps.blog.models 导入帖子、类别用户 = get_user_model() 类 PostModelTest（测试用例）： “”“后模型测试。”“” def 设置（自身）： """设置测试数据。""" self.user = User.objects.create_user( 用户名='测试用户', 电子邮件='test@example.com', 密码='testpass123', ） self.category = Category.objects.create( 名称='姜戈', slug='django', ） def test_create_post(自我): """测试创建帖子。""" post = Post.objects.create( title='测试帖', slug='测试帖子', 作者=self.user, 类别=自我类别， content='测试内容', ） self.assertEqual(post.title, '测试帖子') self.assertEqual(post.author, self.user) self.assertEqual(str(post), '测试帖子') def test_published_posts_manager(自我): """测试发布帖子管理器。""" # 创建发布的帖子发布 = Post.objects.create( title='发表的帖子', slug='发布的帖子', 作者=self.user, 内容='内容', 状态='已发布', ） # 创建草稿帖子草稿= Post.objects.create( title='帖子草稿', slug='草稿帖子', 作者=self.user, 内容='内容', 状态='草稿', ） # 测试经理 published_posts = Post.objects.published() self.assertIn（已发布，已发布的帖子） self.assertNotIn（草稿，published_posts） **`apps/blog/tests/test_views.py`:** """测试博客浏览量。""" 从 django.test 导入测试用例，客户端从 django.urls 反向导入从 apps.blog.models 导入帖子类 PostListViewTest(测试用例): """测试帖子列表视图。""" def 设置（自身）： """设置测试客户端和数据。""" self.client = 客户端() self.user = User.objects.create_user( 用户名='测试用户', 密码='testpass123', ） def test_post_list_view(自身): """测试帖子列表视图返回 200。""" 响应 = self.client.get(reverse('博客:帖子列表')) self.assertEqual(响应.status_code, 200) self.assertTemplateUsed（响应，'blog/post_list.html'） def test_post_create_requires_login(self): """测试创建帖子是否需要登录。""" 响应 = self.client.get(reverse('blog:post-create')) self.assertEqual(response.status_code, 302) # 重定向到登录 self.assertIn('/登录/',response.url) **`apps/blog/tests/test_api.py`:** """博客 API 测试。""" 从rest_framework.test导入APITestCase 从rest_framework导入状态从 django.urls 反向导入类 PostAPITest(APITestCase): """Post API 端点测试。""" def 设置（自身）： """设置测试数据。""" self.user = User.objects.create_user( 用户名='测试用户', 电子邮件='test@example.com', 密码='testpass123', ） def test_list_posts(自我): """测试列表帖子。""" url = 反向('api:post-list') 响应 = self.client.get(url) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_create_post_requires_authentication（自我）： """测试创建帖子是否需要身份验证。""" url = 反向('api:post-list') data = {'title': '测试帖子', 'content': '测试内容'} 响应 = self.client.post(url, 数据) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_create_post_authenticated（自我）： """通过身份验证后测试创建帖子。""" self.client.force_authenticate(用户=self.user) url = 反向('api:post-list') 数据 = { 'title': '测试帖', 'content': '测试内容' * 20, # 满足最小长度 '状态'：'草稿'， } 响应 = self.client.post(url, 数据, format='json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(Post.objects.count(), 1) self.assertEqual(Post.objects.first().author, self.user) ** ** ### 任务 9：常见 Django 反模式 #### 9.1 反模式：使用filter().first()代替get() ❌ **不好：** # 不要这样做 - 意图不太明确 user = User.objects.filter(id=user_id).first() 如果用户为“无”： # 未找到句柄通过 ✅ **好：** # 使用 get() 并处理DoesNotExist 从 django.core.exceptions 导入 ObjectDoesNotExist 尝试： user = User.objects.get(id=user_id) 除了 User.DoesNotExist： # 未找到句柄通过 # 或者在视图中使用 get_object_or_404 来自 django.shortcuts.get_object_or_404 用户 = get_object_or_404(用户, id=user_id) #### 9.2 反模式：不使用 select_lated/prefetch_lated ❌ **不好 - N+1 查询：** # 这会生成 N+1 个查询（1 个针对帖子 + 1 个针对作者的帖子） posts = Post.objects.all() 对于帖子中的帖子： print(f"{post.title} 作者：{post.author.username}") ✅ **好：** # 这会生成 1 个查询 (JOIN) posts = Post.objects.select_lated('author').all() 对于帖子中的帖子： print(f"{post.title} 作者：{post.author.username}") #### 9.3 反模式：当 ORM 起作用时使用原始 SQL ❌ **不好：** # 不要使用原始 SQL 进行简单查询从 django.db 导入连接光标 = 连接.cursor() cursor.execute("SELECT * FROM users WHERE username = %s", [username]) 用户 = 游标.fetchone() ✅ **好：** # 使用 ORM user = User.objects.get(用户名=用户名) **当原始 SQL 合适时：** * ORM无法高效表达的复杂查询 * 数据库特定功能（窗口函数、CTE） * 需要完全控制的性能关键查询 #### 9.4 反模式：不使用事务 ❌ **不好：** # 多次保存，无需交易 def Transfer_money(from_account, to_account, amount): from_account.balance -= 金额 from_account.save() to_account.balance += 金额 to_account.save() # 如果失败，则第一次保存成功！ ✅ **好：** 从 django.db 导入事务 @transaction.atomic def Transfer_money(from_account, to_account, amount): “”“自动转账。”“” from_account.balance -= 金额 from_account.save() to_account.balance += 金额 to_account.save() # 两次保存都成功或者都失败 # 或者使用上下文管理器 def Transfer_money(from_account, to_account, amount): “”“自动转账。”“” 使用 transaction.atomic()： from_account.balance -= 金额 from_account.save() to_account.balance += 金额 to_account.save() #### 9.5 反模式：在代码中存储秘密 ❌ **不好：** SECRET_KEY = 'django-不安全-硬编码密钥' AWS_SECRET_KEY = 'AKIAIOSFODNN7EXAMPLE' DATABASE_PASSWORD = '我的密码123' ✅ **好：** 导入操作系统从解耦导入配置 SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY') AWS_SECRET_KEY = config('AWS_SECRET_KEY') DATABASE_PASSWORD = config('DB_PASSWORD') #### 9.6 反模式：不使用迁移 ❌ **不好：** # 手动创建数据库表 # 直接编辑数据库模式 # 不提交迁移文件 ✅ **好：** # 始终为模型更改创建迁移 python 管理.py makemigrations python 管理.py 迁移 # 将迁移文件提交到版本控制 git add apps/*/migrations/*.py git commit -m“添加用户配置文件模型” #### 9.7 反模式：循环导入 ❌ **不好：** # 应用程序/用户/models.py from apps.blog.models import Post # 循环导入！用户类（模型.模型）： favorite_post = models.ForeignKey(Post, ...) # 应用程序/博客/models.py from apps.users.models import User # 循环导入！类 Post(models.Model): 作者 = models.ForeignKey(User, ...) ✅ **好：** # 应用程序/用户/models.py 从 django.db 导入模型用户类（模型.模型）：最喜欢的帖子 = models.ForeignKey( 'blog.Post', # 字符串引用 on_delete=models.SET_NULL, 空=真，） # 应用程序/博客/models.py 从 django.conf 导入设置类 Post(models.Model): 作者 = models.ForeignKey( settings.AUTH_USER_MODEL, # 引用用户模型 on_delete=models.CASCADE, ） ** ** ## 最佳实践总结 ### Django 项目清单 * 项目结构遵循Django约定 * 按环境划分的设置（基础、开发、产品、测试） * 环境变量中的SECRET_KEY和敏感数据 * 生产环境中 DEBUG=False * 在生产中启用所有安全中间件 * ALLOWED_HOSTS 配置正确 * 启用数据库连接池（CONN_MAX_AGE） * 正确配置静态/媒体文件 ### 建模最佳实践 * 模型使用 gettext_lazy 的详细字段名称 * 用于选择字段的 TextChoices/IntegerChoices * 在ForeignKey/ManyToMany 上显式关联名称 * 适当的 on_delete 处理程序 * 频繁查询字段的数据库索引 * 模型上的时间戳（created_at、updated_at） * 可重用查询逻辑的自定义管理器 * 业务逻辑的模型方法 * 跨领域关注点的信号 ### 查看最佳实践 * 用于标准 CRUD 的 CBV，用于自定义逻辑的 FBV * Mixins 用于可重用视图行为 * 适当的权限检查（LoginRequired 等） * select_相关/预取相关以避免N+1 * 列表视图上的分页 * 表单中的表单验证，而不是视图中的表单验证 ### DRF 最佳实践 * 用于列表/详细信息/写入的单独序列化器 * 访问控制的权限等级 * 配置令牌/JWT 身份验证 * 在列表端点上启用分页 * 配置过滤和搜索 * 实施 API 版本控制 * 正确的错误处理和响应 ### 安全检查表 * 启用CSRF保护 * 使用 Django ORM（不是原始 SQL 连接） * 在模板中启用自动转义 * 环境变量中的 SECRET_KEY * 生产环境中 DEBUG=False * 启用安全中间件 * 强制执行 HTTPS (SECURE_SSL_REDIRECT) * 配置密码验证器 ### 绩效检查表 * 适当使用 select_lated/prefetch_lated * 频繁查询字段的数据库索引 * 查询优化（仅/在适当时推迟） * 实施缓存策略 * 配置数据库连接池 * django-debug-toolbar 在开发中安装 * 查询监控到位 ### 测试清单 * 所有型号的测试 * 测试所有视图/API 端点 * 表单和验证测试 * 权限测试 * 测试覆盖率 > 80% * 关键路径的集成测试 ** ** ## 模板 ### 模板 1：Django 模型位于：`templates/django_model_template.py` 请参阅：`templates/django_model_template.py` ### 模板 2：Django REST Framework 视图集位于：`templates/drf_viewset_template.py` 请参阅：`templates/drf_viewset_template.py` ### 模板 3：Django 表单位于：`templates/django_form_template.py` 请参阅：`templates/django_form_template.py` ** ** ## 相关技能 * **python-testing-standards** ：Python 测试最佳实践（Django 测试参考） * **python-type-hints-guide** : Python 类型提示（适用于 Django） * **uncle-duke-python** ：使用此技能的Python代码审查代理 ** ** ## 参考文献 ### 官方文档 * [Django 文档]() * [Django REST 框架文档]() * [Django 最佳实践]() ### 安全 * [Django 安全]() * [OWASP Django 安全]() ### 性能 * [Django 数据库优化]() * [Django 缓存]() ### 书籍和指南 * 两勺 Django（最佳实践书籍） * Django API（Django REST 框架） * 高性能Django ** ** **版本：** 1.0 **最后更新：** 2025-12-24 **维护者：** 开发团队

Django约定

包含技能