Django REST Framework 介绍 – wiki基地

作者： /

拥抱现代 Web API：深度解析 Django REST Framework (DRF)

在当今高度互联的世界中，构建高效、可扩展的 Web API 变得越来越重要。无论是为移动应用提供后端服务、构建单页应用（SPA）的后端、为第三方集成开放数据接口，还是仅仅为了解耦前后端开发，RESTful API 都已成为主流选择。对于 Django 开发者而言，构建强大的 API 最流行和最高效的工具莫过于 Django REST Framework (DRF)。

DRF 是一个强大且灵活的工具包，用于构建 Web API。它构建在 Django 之上，充分利用了 Django 强大的 ORM、URL 路由、认证系统等功能，同时又提供了构建 API 所需的一系列高级抽象和便利功能。本文将深入探讨 DRF 的核心概念、关键组件以及如何利用它来快速、高效地构建高质量的 API。

为什么需要 Django REST Framework？

在理解 DRF 是什么之前，我们先思考一下，如果没有像 DRF 这样的框架，构建一个 Web API 需要做些什么？

想象一下，你需要在 Django 中为一个模型（比如 Product）创建一套 API，支持创建、读取、更新、删除（CRUD）操作。你需要：

  1. 数据序列化与反序列化： 将 Django 模型实例（Python 对象）转换成 JSON 或 XML 等格式，以便通过 HTTP 响应发送给客户端。反之，将客户端发送的 JSON 或 XML 数据转换回 Python 对象，用于创建或更新数据库记录。这涉及到手动处理各种数据类型、验证输入数据格式、处理关联对象等，过程繁琐且容易出错。
  2. 请求与响应处理： 解析 HTTP 请求头、请求体，根据不同的 HTTP 方法（GET, POST, PUT, DELETE）执行相应的逻辑。构建 HTTP 响应，设置正确的 Content-Type、状态码等。
  3. 视图逻辑： 编写处理不同请求的视图函数或类视图。对于 CRUD 操作，这意味着至少要写四个不同的视图（列表、详情、创建、更新/删除）。
  4. URL 路由： 将这些视图函数映射到特定的 URL 路径上。
  5. 认证与权限： 确定请求是由哪个用户发出的（认证），以及该用户是否有权执行请求的操作（权限）。这需要手动检查用户的身份、判断其角色或权限等级。
  6. 其他高级功能： 如果需要分页（处理大量数据）、过滤（根据条件查询数据）、版本控制（API 演进）、限流（防止滥用）等功能，你需要自己编写额外的逻辑。
  7. 文档： 如何让 API 的使用者知道如何调用你的 API？你需要手动编写 API 文档，并且在 API 变化时及时更新。

手动实现所有这些功能不仅耗时耗力，而且容易引入 Bug，难以维护。DRF 的出现，正是为了解决这些痛点。它提供了一套成熟的、经过良好设计的抽象和工具，让开发者能够专注于业务逻辑，而将大部分通用的 API 构建任务交给框架来完成。

Django REST Framework 是什么？

Django REST Framework 是一个基于 Django 的强大且灵活的工具集，用于构建 Web API。它的核心目标是使得构建 RESTful API 变得简单、快速且高效。

DRF 并不是一个全新的 Web 框架，它是一个构建在 Django 之上的应用程序。这意味着你可以充分利用你已有的 Django 知识和生态系统，如 Django ORM、forms、authentication、admin site 等。同时，DRF 为构建 API 引入了一系列新的概念和组件，如 Serializers、Views、ViewSets、Routers、Parsers、Renderers、Authentications、Permissions、Throttling 等。

DRF 的主要特性包括：

  • 强大的序列化器 (Serializers)： 轻松实现 Python 对象与各种数据格式（如 JSON、XML）之间的相互转换，支持数据验证。
  • 灵活的视图 (Views & ViewSets)： 提供了多种编写 API 视图的方式，从简单的函数视图到功能丰富的类视图和视图集，极大地减少了重复代码。
  • 自动化的 URL 路由 (Routers)： 为视图集自动生成 URL 模式，进一步简化了开发流程。
  • 内置的认证与权限系统： 提供了多种认证方式和灵活的权限控制机制，保障 API 安全。
  • 可配置的解析器与渲染器： 支持多种请求数据格式（Parser）和响应数据格式（Renderer），方便处理不同客户端需求。
  • 可浏览的 API (Browsable API)： 这是一个非常实用的特性，允许你在浏览器中直接查看和交互你的 API，极大地提高了开发和测试效率。
  • 丰富的高级特性： 内置了分页、过滤、限流、版本控制等 API 开发中常用的功能。
  • 优秀的文档和活跃的社区： DRF 拥有全面、清晰的官方文档和庞大的用户群体，遇到问题很容易找到帮助。

DRF 的核心组件详解

让我们逐一深入了解 DRF 的核心组件：

1. Serializers (序列化器)

序列化器是 DRF 中最重要的概念之一，它承担着数据转换和验证的职责。

  • 作用：

    • 序列化 (Serialization)： 将 Django QuerySet 或模型实例等复杂的 Python 数据类型转换为可以轻松通过网络传输的原生数据类型（如字典、列表），然后由渲染器转换为特定格式（如 JSON）。
    • 反序列化 (Deserialization)： 将接收到的原生数据类型（如请求体中的字典）转换为复杂的 Python 数据类型，通常是用于创建或更新模型实例。在此过程中，序列化器还会进行数据验证。

  • 工作方式：

    • 你可以定义一个序列化器类，指定需要序列化哪些字段，以及这些字段的数据类型和约束。
    • 实例化序列化器时，你可以传入要序列化的对象 (instance) 或要反序列化的数据 (data)。
    • 调用 serializer.data 获取序列化后的数据。
    • 调用 serializer.is_valid(raise_exception=True) 进行数据验证。
    • 调用 serializer.save() 持久化（创建或更新）数据到数据库（通常在使用 ModelSerializer 时）。

  • 主要类型：

    • rest_framework.serializers.Serializer: 基础序列化器类，你需要手动定义所有字段。适用于非模型数据或需要精细控制字段的场景。
    • rest_framework.serializers.ModelSerializer: 这是最常用的序列化器类，它会自动根据 Django 模型生成字段，并提供了 .create() 和 .update() 方法用于方便地保存模型实例。极大地减少了重复代码。

  • 数据验证： Serializer 提供了一套强大的数据验证机制。你可以在字段上定义验证器（如 validators=[UniqueValidator(...)]），也可以在序列化器类中定义 validate_<field_name> 方法或 validate 方法进行字段级或对象级的自定义验证。

  • 示例：

“`python

models.py

from django.db import models

class Product(models.Model):
name = models.CharField(max_length=100)
price = models.DecimalField(max_digits=10, decimal_places=2)
description = models.TextField(blank=True, null=True)
in_stock = models.BooleanField(default=True)

def __str__(self):
    return self.name

serializers.py

from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
class Meta:
model = Product
fields = [‘id’, ‘name’, ‘price’, ‘description’, ‘in_stock’]
# 或者使用 ‘all‘ 包含所有字段
# fields = ‘all‘

使用示例 (在视图或 shell 中)

product = Product.objects.first()
serializer = ProductSerializer(product)
print(serializer.data) # {‘id’: 1, ‘name’: ‘Example Product’, …}

data = {‘name’: ‘New Product’, ‘price’: 19.99}
serializer = ProductSerializer(data=data)
if serializer.is_valid():
product = serializer.save() # 创建新的 Product 实例
print(product)
else:
print(serializer.errors) # {‘price’: [‘This field is required.’]}
“`

ModelSerializer 极大地简化了与 Django 模型相关的序列化任务，是 DRF 开发中的首选。

2. Views (视图)

DRF 提供了多种编写 API 视图的方式，它们层层抽象，提供了不同的便利程度。

  • @api_view 装饰器： 用于将标准的 Django 函数视图转换为 DRF 的 API 视图。它提供了 DRF 的 Request 和 Response 对象，并允许你指定支持的 HTTP 方法、解析器和渲染器等。适用于简单的、不需要太多定制逻辑的 API 端点。

“`python

views.py

from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import Product
from .serializers import ProductSerializer

@api_view([‘GET’, ‘POST’])
def product_list(request):
“””
列出所有产品或创建一个新产品。
“””
if request.method == ‘GET’:
products = Product.objects.all()
serializer = ProductSerializer(products, many=True)
return Response(serializer.data)

elif request.method == 'POST':
    serializer = ProductSerializer(data=request.data)
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=201)
    return Response(serializer.errors, status=400)

“`

  • APIView 类视图： 这是 DRF 类视图的基础。它类似于 Django 的 View，但提供了 DRF 特有的功能，如处理 Request/Response、认证、权限、限流、解析器、渲染器等。你可以通过定义 get(), post(), put(), delete() 等方法来处理不同的 HTTP 请求。

“`python

views.py

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import Product
from .serializers import ProductSerializer
from django.http import Http404

class ProductList(APIView):
“””
列出所有产品或创建一个新产品。
“””
def get(self, request, format=None):
products = Product.objects.all()
serializer = ProductSerializer(products, many=True)
return Response(serializer.data)

def post(self, request, format=None):
    serializer = ProductSerializer(data=request.data)
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

class ProductDetail(APIView):
“””
检索、更新或删除一个产品实例。
“””
def get_object(self, pk):
try:
return Product.objects.get(pk=pk)
except Product.DoesNotExist:
raise Http404

def get(self, request, pk, format=None):
    product = self.get_object(pk)
    serializer = ProductSerializer(product)
    return Response(serializer.data)

def put(self, request, pk, format=None):
    product = self.get_object(pk)
    serializer = ProductSerializer(product, data=request.data)
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

def delete(self, request, pk, format=None):
    product = self.get_object(pk)
    product.delete()
    return Response(status=status.HTTP_204_NO_CONTENT)

“`

  • GenericAPIView 和 Mixins： GenericAPIView 是 APIView 的子类，它增加了一些常用的行为，如获取对象（get_object）、获取 QuerySet（get_queryset）、获取序列化器（get_serializer）等，这些方法可以被 Mixins 使用。Mixins 是一组预定义的行为类，可以与 GenericAPIView 结合使用，快速构建常见的 API 端点，例如：

    • ListModelMixin: 用于处理列表查询 (GET)。
    • CreateModelMixin: 用于处理创建 (POST)。
    • RetrieveModelMixin: 用于处理详情查询 (GET)。
    • UpdateModelMixin: 用于处理更新 (PUT/PATCH)。
    • DestroyModelMixin: 用于处理删除 (DELETE)。

    通过组合 GenericAPIView 和这些 Mixins，可以非常简洁地实现常见的 API 功能。

“`python

views.py

from rest_framework import generics
from .models import Product
from .serializers import ProductSerializer

class ProductListCreate(generics.ListCreateAPIView):
queryset = Product.objects.all()
serializer_class = ProductSerializer
# 相当于结合了 ListModelMixin 和 CreateModelMixin

class ProductRetrieveUpdateDestroy(generics.RetrieveUpdateDestroyAPIView):
queryset = Product.objects.all()
serializer_class = ProductSerializer
# 相当于结合了 RetrieveModelMixin, UpdateModelMixin 和 DestroyModelMixin
``ListCreateAPIView和RetrieveUpdateDestroyAPIView等是 DRF 提供的一些常用组合类，它们继承自GenericAPIView` 并混合了相应的 Mixins，让代码更加简洁。

  • ViewSets (视图集)： 这是 DRF 提供的一种更高级的抽象，进一步减少了视图的编写。一个 ViewSet 将一组相关联的视图逻辑（如列表、详情、创建、更新、删除）合并到一个类中。它不提供像 get(), post() 等方法，而是提供 list(), retrieve(), create(), update(), partial_update(), destroy() 等方法。ViewSets 通常与 Routers 配合使用，由 Router 根据请求的 HTTP 方法和路径自动映射到 ViewSet 中相应的方法。

    • rest_framework.viewsets.ViewSet: 基本 ViewSet，你需要手动实现所有方法。
    • rest_framework.viewsets.GenericViewSet: 继承自 GenericAPIView 和 ViewSet，可以结合 Mixins 使用。
    • rest_framework.viewsets.ModelViewSet: 继承自 GenericViewSet 并混合了 ListModelMixin, RetrieveModelMixin, CreateModelMixin, UpdateModelMixin, DestroyModelMixin。这是最强大的 ViewSet，通常用于为模型提供完整的 CRUD API，一行代码即可实现一个模型的全套 API。

  • 示例 (使用 ModelViewSet):

“`python

views.py

from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer

class ProductViewSet(viewsets.ModelViewSet):
“””
提供产品的列出、创建、检索、更新和删除操作。
“””
queryset = Product.objects.all()
serializer_class = ProductSerializer
``
可以看到，使用ModelViewSet极大地减少了代码量，只需指定queryset和serializer_class` 即可获得一个模型的完整 CRUD API。

3. Routers (路由)

Router 负责为 ViewSet 自动生成 URL 模式。如果使用 APIView 或 GenericAPIView，你仍然需要像 Django 中一样手动定义 URL 模式。但对于 ViewSet，Router 可以根据 ViewSet 定义的方法自动生成对应的 URL。

  • 主要类型：

    • rest_framework.routers.DefaultRouter: 提供完整的路由功能，包括生成列表、详情、创建、更新、删除等 URL，并自动生成可浏览 API 的根视图。
    • rest_framework.routers.SimpleRouter: 提供基本的路由功能，不包含可浏览 API 的根视图。

  • 工作方式：

    • 实例化一个 Router。
    • 使用 router.register() 方法注册 ViewSet，通常需要提供 URL 前缀、Viewset 类和可选的 basename。
    • 将 Router 的 URL 模式包含在你的主 URL 配置中。

  • 示例：

“`python

urls.py (在你的 Django app 或 project 的 urls.py 文件中)

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import ProductViewSet

创建一个 Router 实例

router = DefaultRouter()

注册 ViewSet

第一个参数是 URL 前缀 (如 /products/)

第二个参数是 ViewSet 类

basename 是可选的，用于生成 URL 名称，如果 queryset 有 .model 属性，可以省略

router.register(r’products’, ProductViewSet)

urlpatterns 通常包含 app 的 API URL

urlpatterns = [
# 将 router 生成的 URL 模式包含进来
path(”, include(router.urls)),

# 你也可以在这里定义非 ViewSet 的 URL
# path('some-custom-endpoint/', SomeAPIView.as_view()),

]
``
通过router.register(r’products’, ProductViewSet)，DefaultRouter会自动为ProductViewSet生成如下 URL：
*/products/(GET): 对应ProductViewSet.list()*/products/(POST): 对应ProductViewSet.create()*/products/{pk}/(GET): 对应ProductViewSet.retrieve()*/products/{pk}/(PUT): 对应ProductViewSet.update()*/products/{pk}/(PATCH): 对应ProductViewSet.partial_update()*/products/{pk}/(DELETE): 对应ProductViewSet.destroy()`
这极大地减少了手动编写 URLconf 的工作量。

4. Authentication (认证)

认证是确定发出请求的客户端是谁的过程。DRF 提供了一套灵活的认证系统。

  • 工作方式：

    • 认证类通过检查请求中的凭证（如 Session ID、Token、用户名/密码）来识别用户。
    • 如果认证成功，请求对象 (request.user 和 request.auth) 将被填充上用户实例和认证凭证。
    • 如果认证失败，request.user 通常是 AnonymousUser，request.auth 是 None。
    • 认证类不会阻止请求，它们只是识别用户。权限类才会决定是否允许请求继续。

  • 常用的认证类：

    • rest_framework.authentication.SessionAuthentication: 基于 Django Session 的认证，常用于与浏览器结合的单页应用或传统的服务端渲染应用。
    • rest_framework.authentication.TokenAuthentication: 基于 Token 的认证，客户端在请求头中携带一个 Token（通常在 Authorization: Token <token> 格式），服务端验证 Token 的有效性来识别用户。常用于移动应用或第三方服务。
    • rest_framework.authentication.BasicAuthentication: 基于 HTTP Basic Auth 的认证，客户端使用用户名和密码进行认证。通常用于简单的集成或调试。
    • rest_framework_simplejwt.authentication.JWTAuthentication: 基于 JSON Web Token (JWT) 的认证（需要安装第三方库 djangorestframework-simplejwt）。JWT 是一种无状态的认证方式，服务器不需要保存 Session 或 Token 的状态。

  • 如何应用：

    • 全局设置： 在 settings.py 中通过 REST_FRAMEWORK 设置 DEFAULT_AUTHENTICATION_CLASSES。
    • 视图/视图集级别： 在视图或 ViewSet 类中通过 authentication_classes 属性指定。
    • 函数视图级别： 使用 @authentication_classes([...]) 装饰器。

  • 示例：

“`python

settings.py

REST_FRAMEWORK = {
‘DEFAULT_AUTHENTICATION_CLASSES’: [
‘rest_framework.authentication.TokenAuthentication’,
‘rest_framework.authentication.SessionAuthentication’, # 方便 Browsable API 调试
],
# … other settings
}

views.py

from rest_framework import viewsets
from rest_framework.permissions import IsAuthenticated
from .models import Product
from .serializers import ProductSerializer

class ProductViewSet(viewsets.ModelViewSet):
queryset = Product.objects.all()
serializer_class = ProductSerializer
# 指定该 ViewSet 需要认证用户才能访问
# authentication_classes = [TokenAuthentication] # 如果只允许 Token 认证
permission_classes = [IsAuthenticated] # 要求用户必须通过认证
“`

5. Permissions (权限)

权限是确定经过认证的客户端是否有权访问特定资源或执行特定操作的过程。

  • 工作方式：

    • 权限类在认证之后执行。
    • 它们检查请求的 request.user 和 request.method，并根据权限规则返回 True 或 False。
    • 如果任何一个权限类返回 False，DRF 会拒绝请求，并返回相应的错误响应（通常是 403 Forbidden）。

  • 常用的权限类：

    • rest_framework.permissions.AllowAny: 允许任何请求，无论是否认证。这是默认行为。
    • rest_framework.permissions.IsAuthenticated: 只允许经过认证的用户访问。
    • rest_framework.permissions.IsAdminUser: 只允许 Django 的管理员用户访问。
    • rest_framework.permissions.IsAuthenticatedOrReadOnly: 允许未认证用户执行安全方法（GET, HEAD, OPTIONS），只允许认证用户执行非安全方法（POST, PUT, PATCH, DELETE）。这是非常常用的权限设置。
    • rest_framework.permissions.DjangoModelPermissions: 基于 Django 模型权限的权限，如 add_product, change_product, delete_product, view_product。
    • rest_framework.permissions.DjangoObjectPermissions: 基于 Django 对象权限的权限（需要与第三方库如 django-guardian 配合使用）。
    • 自定义权限： 你可以继承 rest_framework.permissions.BasePermission 并重写 has_permission(self, request, view) 和/或 has_object_permission(self, request, view, obj) 方法来创建自己的权限逻辑。

  • 如何应用：

    • 全局设置： 在 settings.py 中通过 REST_FRAMEWORK 设置 DEFAULT_PERMISSION_CLASSES。
    • 视图/视图集级别： 在视图或 ViewSet 类中通过 permission_classes 属性指定。
    • 函数视图级别： 使用 @permission_classes([...]) 装饰器。

  • 示例：

“`python

settings.py

REST_FRAMEWORK = {
‘DEFAULT_PERMISSION_CLASSES’: [
‘rest_framework.permissions.IsAuthenticated’, # 默认所有 API 都需要认证
],
# … other settings
}

views.py

from rest_framework import viewsets
from rest_framework.permissions import IsAuthenticatedOrReadOnly # 导入
from .models import Product
from .serializers import ProductSerializer

class ProductViewSet(viewsets.ModelViewSet):
queryset = Product.objects.all()
serializer_class = ProductSerializer
# 覆盖全局设置，允许未认证用户查看，但只有认证用户可以修改/删除
permission_classes = [IsAuthenticatedOrReadOnly]
“`

认证和权限是 API 安全的基石，DRF 提供了丰富且灵活的机制来满足不同的安全需求。

6. Parsers 和 Renderers (解析器和渲染器)

  • Parsers (解析器)： 负责解析进入请求的请求体数据。DRF 根据请求的 Content-Type 头来选择合适的解析器。
    • JSONParser: 解析 JSON 数据。
    • FormParser: 解析 HTML 表单数据。
    • MultiPartParser: 解析多部分表单数据（用于文件上传）。
  • Renderers (渲染器)： 负责将序列化后的数据渲染成特定的响应格式。DRF 根据请求的 Accept 头和 URL 后缀来选择合适的渲染器。
    • JSONRenderer: 将数据渲染成 JSON 格式。
    • BrowsableAPIRenderer: 渲染出 DRF 的可浏览 API 页面。
    • HTMLFormRenderer: 渲染出 HTML 表单，用于可浏览 API 的 POST/PUT/PATCH 请求。
    • XMLRenderer: 将数据渲染成 XML 格式。

你可以通过 parser_classes 和 renderer_classes 属性在视图或 ViewSet 中指定使用的解析器和渲染器，也可以在 settings.py 中进行全局配置。

7. Browsable API (可浏览 API)

这是 DRF 最受欢迎的特性之一。当你在浏览器中访问使用 DRF 构建的 API 端点时，如果使用了 BrowsableAPIRenderer (这是默认的，通常与 JSONRenderer 一起配置)，DRF 会渲染出一个漂亮的 HTML 页面，展示 API 的详细信息、允许你发送请求并查看响应。这极大地简化了 API 的开发、调试和测试过程。

要启用可浏览 API，确保 rest_framework.renderers.BrowsableAPIRenderer 包含在你的渲染器列表中，并且在你的 URLconf 中包含了 DRF 的登录/注销 URL，以便在可浏览 API 中进行认证操作（通常通过在主 urls.py 中包含 path('api-auth/', include('rest_framework.urls')) 来实现）。

8. Pagination (分页)

当数据集很大时，一次性返回所有数据是不现实的。分页机制允许你限制响应中返回的数据数量，并提供链接指向下一页、上一页等。

  • 常用的分页类：

    • rest_framework.pagination.PageNumberPagination: 基于页码的分页，客户端通过查询参数 page 指定页码，page_size 指定每页数量。
    • rest_framework.pagination.LimitOffsetPagination: 基于偏移量的分页，客户端通过查询参数 limit (数量) 和 offset (偏移量) 指定。
    • rest_framework.pagination.CursorPagination: 基于游标的分页，更适合大型数据集和频繁添加/删除数据的场景，性能通常更好。

  • 如何应用：

    • 全局设置： 在 settings.py 中通过 REST_FRAMEWORK 设置 DEFAULT_PAGINATION_CLASS 和 PAGE_SIZE。
    • 视图/视图集级别： 在 GenericAPIView 或 ViewSet 中通过 pagination_class 属性指定。

9. Filtering (过滤)

允许客户端通过查询参数来过滤数据集。DRF 本身提供了简单的过滤功能，但通常结合第三方库 django-filter 来提供更强大的过滤能力。

  • 使用 django-filter：
    • 安装 django-filter 并将其添加到 INSTALLED_APPS。
    • 在视图或 ViewSet 中通过 filter_backends 属性指定过滤后端，如 rest_framework.filters.SearchFilter, rest_framework.filters.OrderingFilter 或 django_filters.rest_framework.DjangoFilterBackend。
    • 对于 DjangoFilterBackend，还需要通过 filterset_fields 或 filterset_class 指定允许过滤的字段或自定义的 FilterSet 类。

10. Versioning (版本控制)

随着 API 的演进，你可能需要发布新版本以支持新功能或进行不兼容的变更。版本控制允许你在不影响现有客户端的情况下提供新版本的 API。

  • 常用的版本控制方案：

    • URLPathVersioning: 版本号包含在 URL 路径中，如 /v1/products/, /v2/products/。
    • NamespaceVersioning: 使用 URL 命名空间区分版本。
    • QueryParameterVersioning: 版本号作为查询参数，如 /products/?version=v1。
    • HostNameVersioning: 版本号包含在主机名中，如 v1.api.example.com。

  • 如何应用：

    • 在 settings.py 中通过 REST_FRAMEWORK 设置 DEFAULT_VERSIONING_CLASS 和其他相关配置。
    • 在 URLconf 中根据版本控制方案进行相应的配置。

11. Throttling (限流)

限流用于控制客户端或用户在一定时间内可以发出的请求数量，以防止 API 被滥用或过载。

  • 常用的限流类：

    • rest_framework.throttling.AnonRateThrottle: 限制未认证用户的请求速率，使用 IP 地址进行识别。
    • rest_framework.throttling.UserRateThrottle: 限制认证用户的请求速率，使用用户 ID 进行识别。
    • rest_framework.throttling.ScopedRateThrottle: 基于视图作用域进行限流，可以在 settings.py 中为不同的视图或 ViewSet 设置不同的限流规则。

  • 如何应用：

    • 全局设置： 在 settings.py 中通过 REST_FRAMEWORK 设置 DEFAULT_THROTTLE_CLASSES 和 DEFAULT_THROTTLE_RATES。
    • 视图/视图集级别： 在视图或 ViewSet 中通过 throttle_classes 属性指定。

安装与基本配置

开始使用 DRF 非常简单：

  1. 安装：
    bash
    pip install djangorestframework
  2. 添加到 INSTALLED_APPS： 在你的 Django 项目的 settings.py 文件中，将 'rest_framework' 添加到 INSTALLED_APPS 列表中。
    python
    # settings.py
    INSTALLED_APPS = [
    # ... other apps
    'rest_framework',
    # 'rest_framework.authtoken', # 如果使用 Token 认证，需要添加此项并运行 migrate
    # 'django_filters', # 如果使用 django-filter
    ]

  3. 添加 DRF 认证 URL (可选，但推荐用于 Browsable API)： 在你的主 urls.py 文件中包含 DRF 的认证 URL。
    “`python
    # urls.py (project level)
    from django.contrib import admin
    from django.urls import path, include

    urlpatterns = [
    path(‘admin/’, admin.site.urls),
    path(‘api-auth/’, include(‘rest_framework.urls’)), # 添加这一行
    # … your app’s API urls
    path(‘api/’, include(‘your_app.urls’)), # 示例：包含你的应用的 API URL
    ]
    4. **运行数据库迁移 (如果使用了 `authtoken` 或其他需要模型的特性)：**bash
    python manage.py migrate
    “`

现在你就可以在你的 Django 应用中创建 serializers.py, views.py, urls.py 并开始构建 API 了。

总结

Django REST Framework 是 Django 生态系统中构建 Web API 的事实标准。它提供了一套全面、高效且设计良好的工具和抽象，极大地简化了 API 开发的复杂度。从强大的序列化器、灵活的视图选项、自动化的路由，到内置的认证、权限、分页、过滤、限流等功能，DRF 覆盖了 API 开发的方方面面。特别是其独有的可浏览 API 特性，为开发和调试带来了极大的便利。

通过学习和掌握 DRF 的核心概念和组件，Django 开发者能够以更快的速度、更高的效率构建出健壮、安全、可扩展的 Web API，从而更好地支持现代 Web 应用、移动应用以及各种系统集成需求。无论你是刚开始接触 API 开发，还是希望提升现有 API 的质量和开发效率，Django REST Framework 都是一个值得深入学习和使用的优秀框架。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部