DRF 快速入门：构建你的第一个 Web API

引言：Web API 的重要性与 DRF 的魅力

在当今互联互通的世界里，Web API (应用程序编程接口) 无处不在。它们是不同软件系统之间相互交流的桥梁，使得移动应用可以获取服务器数据，前端网页可以与后端交互，甚至不同的服务之间可以进行数据交换。如果你想构建一个能够被多种客户端（如 Web 浏览器、移动 App、桌面应用、甚至其他服务）访问的后端服务，那么构建 Web API 是必不可少的技能。

Python 语言以其简洁优雅和强大的生态系统在后端开发领域占据重要地位。而 Django 作为一个成熟、高效的 Web 框架，为快速开发提供了坚实基础。然而，Django 本身主要专注于传统的 Web 应用（渲染 HTML 页面）。要构建现代的 Web API，我们需要一个专门的工具来处理数据序列化、请求解析、身份认证、权限控制等 API 特有的需求。

这时，Django REST Framework (DRF) 应运而生。DRF 是一个强大而灵活的工具包，用于快速构建高质量的 Web API。它建立在 Django 的基础之上，充分利用了 Django 的 ORM (对象关系映射)、URL 路由等核心特性，同时提供了丰富的功能来简化 API 开发，例如：

数据序列化 (Serialization): 轻松地将 Django 模型数据转换为 JSON 或 XML 等格式，以及将接收到的数据反序列化回 Python 对象进行验证和保存。
视图 (Views): 提供多种视图类，从基础的 APIView 到强大的 ModelViewSet，大幅简化了 API 逻辑的编写。
URL 路由 (URL Routing): 提供灵活的路由机制，特别是 DefaultRouter 可以自动为 ViewSet 生成多种 URL 模式。
身份认证与权限控制 (Authentication & Permissions): 提供多种内置的认证和权限类，方便你保护你的 API 资源。
请求解析 (Request Parsing): 自动解析客户端发送的不同格式的数据。
响应渲染 (Response Rendering): 灵活控制返回数据的格式。
内置的可浏览 API (Browsable API): 一个非常实用的特性，使得在浏览器中测试和与 API 交互变得异常简单。
完善的文档： 优秀的官方文档和活跃的社区支持。

使用 DRF，你可以专注于业务逻辑，而将许多繁琐的 API 开发细节交给框架处理，从而极大地提高了开发效率。

本文将带你从零开始，使用 DRF 构建你的第一个 Web API。我们将创建一个简单的博客 API，实现对博客文章的创建、读取、更新和删除 (CRUD) 功能。通过这个例子，你将掌握 DRF 的基本用法，为后续深入学习打下基础。

准备工作：环境搭建

在开始之前，请确保你的系统已经安装了 Python 和 pip 包管理器。我们将在一个虚拟环境中进行开发，这是一个良好的实践，可以避免项目之间的依赖冲突。

创建并激活虚拟环境：

“`bash

对于 macOS/Linux

python3 -m venv venv
source venv/bin/activate

对于 Windows

python -m venv venv
venv\Scripts\activate
“`

激活后，你的终端提示符前面会显示 (venv)，表示你正在虚拟环境中。
安装 Django 和 Django REST Framework：

bash pip install Django djangorestframework

这将安装最新版本的 Django 和 DRF。

第一步：创建 Django 项目和应用

我们将创建一个名为 myapi 的 Django 项目，并在其中创建一个名为 blog 的应用来存放我们的 API 逻辑。

创建 Django 项目：

在虚拟环境激活的状态下，运行：

bash django-admin startproject myapi .

注意末尾的点 . 表示在当前目录下创建项目文件（settings.py, urls.py, wsgi.py, asgi.py, manage.py）。
创建 Django 应用：

进入项目目录（如果你不在的话），运行：

bash python manage.py startapp blog

这会在项目目录下创建一个 blog 子目录，包含应用所需的基本文件。
配置项目：注册应用和 DRF

打开 myapi/settings.py 文件，找到 INSTALLED_APPS 列表，添加 blog 应用和 rest_framework：

“`python

myapi/settings.py

INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
```
# 新增的应用和 DRF
'blog',
'rest_framework', # 注册 DRF
```
]

… 其他配置

“`

保存文件。这样，Django 就知道我们的项目中有一个 blog 应用，并且启用了 DRF。

第二步：定义数据模型 (Model)

我们的博客 API 需要处理博客文章数据。我们将创建一个简单的 Post 模型来代表一篇文章。

创建模型：

打开 blog/models.py 文件，编写 Post 模型代码：

“`python

blog/models.py

from django.db import models

class Post(models.Model):
title = models.CharField(max_length=100, verbose_name=”标题”)
content = models.TextField(verbose_name=”内容”)
created_at = models.DateTimeField(auto_now_add=True, verbose_name=”创建时间”)
```
class Meta:
    ordering = ['-created_at'] # 按创建时间倒序排列

def __str__(self):
    return self.title
```
“`

这个模型非常简单，包含标题、内容和创建时间三个字段。auto_now_add=True 会在创建对象时自动设置当前时间。Meta 类用于指定模型的元信息，这里我们指定了默认的排序方式。__str__ 方法定义了模型的字符串表示，方便在 Django Admin 或调试时查看。
进行数据库迁移：

模型定义好后，需要将其同步到数据库。运行迁移命令：

bash python manage.py makemigrations blog python manage.py migrate

makemigrations blog 会检测 blog 应用中模型的变更并生成对应的迁移文件。migrate 命令则会将所有未应用的迁移应用到数据库中，包括 Django 自身的认证、会话等模型，以及我们刚刚创建的 Post 模型。

现在，你的数据库中已经有了 Post 表。

第三步：创建序列化器 (Serializer)

在 API 中，数据通常以 JSON 或 XML 格式传输。Django 模型是 Python 对象，不能直接发送。DRF 的序列化器 (Serializer) 的作用就是将 Django 模型对象转换为可传输的格式（如字典，然后可以被渲染为 JSON），反之亦然（将接收到的数据转换为 Python 对象，进行验证，然后保存到数据库）。

创建序列化器文件：

在 blog 应用目录下创建一个新文件 serializers.py。
编写序列化器：

打开 blog/serializers.py，编写 PostSerializer：

“`python

blog/serializers.py

from rest_framework import serializers
from .models import Post

class PostSerializer(serializers.ModelSerializer):
class Meta:
model = Post
fields = ‘all‘ # 或者指定需要序列化的字段，如: [‘id’, ‘title’, ‘content’, ‘created_at’]
# read_only_fields = [‘created_at’] # 如果希望某个字段只读，客户端不能修改
“`

serializers.ModelSerializer 是 DRF 提供的一个快捷方式，可以自动根据指定的模型生成序列化器字段。
- 我们指定 model = Post，告诉序列化器基于 Post 模型。
- fields = '__all__' 表示序列化器将包含模型中的所有字段 (id, title, content, created_at)。你也可以使用列表指定特定的字段，例如 fields = ['id', 'title', 'created_at'] 如果你不想暴露内容字段。对于这个例子，我们序列化所有字段。
- 默认情况下，ModelSerializer 会为模型的主键字段（通常是 id）生成一个只读字段。
这个简单的 PostSerializer 已经具备了将 Post 对象序列化为字典和将字典反序列化并验证数据的功能。

第四步：创建视图 (View)

视图是 API 的核心，负责处理客户端的请求、调用序列化器进行数据转换和验证、与模型交互（查询、创建、更新、删除数据），并最终返回响应。

DRF 提供了多种类型的视图：

APIView: 最基础的视图类，继承自 Django 的 View。你可以为不同的 HTTP 方法 (GET, POST, PUT, DELETE 等) 定义对应的方法（get(), post(), put(), delete()）。这提供了最大的灵活性，但需要手动处理很多细节（如请求解析、响应渲染、认证、权限等）。
Mixin 类: DRF 提供了一组 Mixin 类（如 ListModelMixin, CreateModelMixin, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin），它们提供了处理特定操作（如列表、创建、详情、更新、删除）的通用逻辑。
GenericAPIView: 继承自 APIView，集成了 Mixin 的功能，可以指定 queryset 和 serializer_class。通常与一个或多个 Mixin 类结合使用，可以快速构建常见的 API 视图。
具体视图类 (Concrete Views): 继承自 GenericAPIView 并混合了特定的 Mixin 类，提供更简洁的写法，如 ListCreateAPIView (列表和创建)、RetrieveUpdateDestroyAPIView (详情、更新和删除)。
ViewSet: 一组相关的视图逻辑的集合（如列表、详情、创建、更新、删除等操作），可以绑定到同一个 URL 前缀下。与 Routers 结合使用可以大大简化 URL 配置。

对于我们的快速入门，我们将使用最常用的 具体视图类 (Concrete Views)，因为它们代码量最少，能快速实现 CRUD 功能。

编写视图逻辑：

打开 blog/views.py 文件，编写视图代码：

“`python

blog/views.py

导入 DRF 的具体视图类

from rest_framework import generics

导入模型和序列化器

from .models import Post
from .serializers import PostSerializer

视图1: 处理 /api/posts/ 请求 (获取所有文章列表和创建新文章)

class PostListCreateView(generics.ListCreateAPIView):
# queryset: 指定视图要操作的数据集
queryset = Post.objects.all()
# serializer_class: 指定视图使用的序列化器
serializer_class = PostSerializer
```
# ListCreateAPIView 自动提供了 get() 方法来处理列表请求，
# 和 post() 方法来处理创建请求。
# 这些方法内部会使用上面指定的 queryset 和 serializer_class。
```
视图2: 处理 /api/posts// 请求 (获取单篇文章详情, 更新文章, 删除文章)

class PostDetailView(generics.RetrieveUpdateDestroyAPIView):
# queryset: 指定视图要操作的数据集 (用于查找单篇文章)
queryset = Post.objects.all()
# serializer_class: 指定视图使用的序列化器
serializer_class = PostSerializer
# lookup_field = ‘pk’ # 默认就是 ‘pk’，可以不写，表示通过主键查找对象
```
# RetrieveUpdateDestroyAPIView 自动提供了 get() 方法处理详情请求,
# put()/patch() 方法处理更新请求,
# delete() 方法处理删除请求。
# 这些方法内部会使用上面指定的 queryset 和 serializer_class，
# 并通过 URL 中的 pk 参数来查找具体的对象。
```
“`
- PostListCreateView 继承自 generics.ListCreateAPIView。这个类结合了 ListModelMixin 和 CreateModelMixin 的功能。
  - 当收到 GET 请求时，它会返回 queryset 中的所有对象列表，并使用 serializer_class 进行序列化。
  - 当收到 POST 请求时，它会使用 serializer_class 反序列化请求数据，验证通过后创建新的 Post 对象并保存到数据库。
- PostDetailView 继承自 generics.RetrieveUpdateDestroyAPIView。这个类结合了 RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin 的功能。
  - 当收到 GET 请求（带有一个主键参数，例如 /api/posts/1/）时，它会根据主键从 queryset 中取出对应的对象，并使用 serializer_class 进行序列化，返回详情。
  - 当收到 PUT 或 PATCH 请求时，它会根据主键取出对象，使用 serializer_class 反序列化请求数据，验证通过后更新该对象并保存到数据库。
  - 当收到 DELETE 请求时，它会根据主键取出对象并将其从数据库中删除。
通过简单地设置 queryset 和 serializer_class，我们就利用 DRF 的通用视图快速实现了 CRUD 的核心逻辑，而无需手动编写大量的请求解析、序列化、数据库操作和响应生成代码。这就是 DRF 强大之处的体现。

第五步：配置 URL 路由

现在我们有了视图，需要将它们映射到特定的 URL 上，以便客户端可以通过这些 URL 访问我们的 API。

在应用中配置 URL：

在 blog 应用目录下创建一个新文件 urls.py。

打开 blog/urls.py，编写 URL 配置：

“`python

blog/urls.py

from django.urls import path
from .views import PostListCreateView, PostDetailView

urlpatterns = [
# URL: /api/posts/
# 映射到 PostListCreateView，处理 GET (列表) 和 POST (创建) 请求
path(‘posts/’, PostListCreateView.as_view(), name=’post-list-create’),
```
# URL: /api/posts/<pk>/
# <pk> 是一个路径参数，匹配整数主键
# 映射到 PostDetailView，处理 GET (详情), PUT/PATCH (更新), DELETE (删除) 请求
path('posts/<int:pk>/', PostDetailView.as_view(), name='post-detail'),
```
]
“`
- path('posts/', ...) 将 /posts/ 路径映射到 PostListCreateView。我们使用 .as_view() 方法将视图类转换为可调用的视图函数。
- path('posts/<int:pk>/', ...) 将 /posts/ 后跟一个整数路径参数 (<int:pk>) 的路径映射到 PostDetailView。<int:pk> 会将 URL 中的整数部分捕获并作为关键字参数 pk 传递给视图。RetrieveUpdateDestroyAPIView 会使用这个 pk 参数来查找对应的对象。
- name 参数是 URL 的名称，在 Django 内部有用，例如反向解析 URL。
在项目级别包含应用的 URL：

打开项目目录下的 myapi/urls.py 文件，包含 blog 应用的 URL 配置：

“`python

myapi/urls.py

from django.contrib import admin
from django.urls import path, include # 导入 include

urlpatterns = [
path(‘admin/’, admin.site.urls),
# 将 blog 应用的 urls 包含进来，并给它们一个前缀 ‘api/’
path(‘api/’, include(‘blog.urls’)),
]
“`
- include('blog.urls') 将 blog 应用的 urls.py 中的所有 URL 配置包含进来。
- path('api/', ...) 给 blog 应用的所有 URL 前面添加一个 /api/ 的前缀。所以 /posts/ 在项目层面就变成了 /api/posts/，/posts/<int:pk>/ 变成了 /api/posts/<int:pk>/。
现在，我们的 URL 路由已经配置完成。客户端可以通过 http://127.0.0.1:8000/api/posts/ 访问文章列表和创建接口，通过 http://127.0.0.1:8000/api/posts/<pk>/ 访问单篇文章的详情、更新和删除接口。

第六步：运行服务器并测试 API

所有的代码都已就绪，是时候运行开发服务器并测试我们的 API 了。

启动开发服务器：

确保你在项目根目录下，并且虚拟环境是激活的，然后运行：

bash python manage.py runserver

服务器默认会在 http://127.0.0.1:8000/ 监听。
使用 DRF 可浏览 API 进行测试：

打开你的 Web 浏览器，访问 http://127.0.0.1:8000/api/posts/。

如果一切顺利，你将看到一个由 DRF 自动生成的可浏览 API 页面！这是一个非常方便的工具，你可以直接在浏览器中查看 API 的响应数据，以及通过表单提交 POST 请求来创建新的文章。
- 查看列表 (GET): 默认进入 /api/posts/ 页面就是发送 GET 请求。如果当前没有文章，你会看到一个空的列表。
- 创建文章 (POST): 在 /api/posts/ 页面底部，你会看到一个带有表单的区域（如果请求方法是 POST）。填写 “标题” 和 “内容”，点击 POST 按钮。如果创建成功，页面会刷新并显示新创建的文章详情，同时在列表页面也能看到新添加的文章。
- 查看详情 (GET ): 在列表页面，点击某篇文章的标题（实际上是链接到 /api/posts/<pk>/）。你会进入该文章的详情页面，只显示该篇文章的数据。
- 更新文章 (PUT/PATCH ): 在详情页面底部，你会看到一个表单。修改标题或内容，选择 PUT 或 PATCH 方法，点击按钮提交。PATCH 允许你只更新部分字段，而 PUT 通常需要提交所有字段。更新成功后，页面会显示更新后的文章详情。
- 删除文章 (DELETE ): 在详情页面，选择 DELETE 方法，点击按钮提交。该文章将被删除，页面会显示一个空响应（通常是 204 No Content）。
通过这个可浏览 API，你可以直观地测试我们构建的 CRUD 接口是否工作正常。
使用 curl 或 Postman/Insomnia 等工具测试 (可选)：

除了可浏览 API，你也可以使用命令行工具 curl 或图形界面工具 Postman/Insomnia 等来测试你的 API。
- 获取列表 (GET):
  bash curl http://127.0.0.1:8000/api/posts/
- 创建文章 (POST):
  bash curl -X POST -H "Content-Type: application/json" -d '{"title": "我的第一篇API文章", "content": "这是通过API创建的内容。"}' http://127.0.0.1:8000/api/posts/
- 获取详情 (GET): (假设ID为1)
  bash curl http://127.0.0.1:8000/api/posts/1/
- 更新文章 (PUT): (假设ID为1)
  bash curl -X PUT -H "Content-Type: application/json" -d '{"title": "更新后的文章标题", "content": "内容也被更新了。"}' http://127.0.0.1:8000/api/posts/1/
- 删除文章 (DELETE): (假设ID为1)
  bash curl -X DELETE http://127.0.0.1:8000/api/posts/1/
使用这些工具可以更真实地模拟客户端的请求。

第七步：深入理解 DRF 的核心概念（进阶思考）

虽然我们已经成功构建了第一个 API，但理解其背后的原理将帮助你更好地使用 DRF。

Serializer 的更多功能

ModelSerializer 只是序列化器的一种。DRF 还提供了 Serializer 基类，可以让你完全自定义字段和验证逻辑，适用于不需要直接映射到模型的情况，或者需要更复杂的序列化/反序列化需求。

此外，序列化器还支持嵌套、关系字段（如 PrimaryKeyRelatedField, HyperlinkedRelatedField, SerializerMethodField 用于自定义字段等），以及更详细的验证规则（通过 validators 属性或自定义 validate_<field_name> 方法，甚至 validate 方法进行对象级别的验证）。

Views 的不同选择

我们使用了具体的通用视图类 (ListCreateAPIView, RetrieveUpdateDestroyAPIView)，它们非常方便。了解一下其他视图类型也很有用：

APIView: 如果你的 API 逻辑非常特殊，不符合 CRUD 的通用模式，或者你需要对请求/响应进行非常底层的控制，那么 APIView 是最灵活的选择。你需要手动处理请求数据 (request.data)、调用序列化器、返回 Response 对象。
GenericAPIView + Mixin: 这是介于 APIView 和具体视图类之间的选择。你可以选择性地混入你需要的 Mixin（例如，只需要列表和详情，就混入 ListModelMixin 和 RetrieveModelMixin）。这比具体视图类更灵活，比 APIView 更简洁。
ViewSet: 当你的 API 资源具有典型的 CRUD 操作时，ViewSet 是最高效的选择。一个 ViewSet 类可以定义 list(), retrieve(), create(), update(), partial_update(), destroy() 等方法，对应不同的 API 操作。与 routers.DefaultRouter 结合使用时，Router 可以自动生成 /posts/ (GET list, POST create) 和 /posts/<pk>/ (GET retrieve, PUT update, PATCH partial_update, DELETE destroy) 等 URL 模式，大大减少 URL 配置代码。

示例：使用 ModelViewSet 和 Router 实现同样功能

你可以将我们之前的两个视图 (PostListCreateView 和 PostDetailView) 合并成一个 ViewSet：

“`python

blog/views.py (使用 ViewSet)

from rest_framework import viewsets # 导入 viewsets
from .models import Post
from .serializers import PostSerializer

class PostViewSet(viewsets.ModelViewSet):
# ModelViewSet 提供了所有 CRUD 操作的实现
# 它会自动查找 pk 参数，执行 list, retrieve, create, update, destroy 等操作
queryset = Post.objects.all()
serializer_class = PostSerializer

# 无需再写额外的 get(), post(), retrieve() 等方法，ModelViewSet 都提供了

“`

然后修改 blog/urls.py 使用 Router：

“`python

blog/urls.py (使用 Router)

from django.urls import path, include
from rest_framework.routers import DefaultRouter # 导入 DefaultRouter
from .views import PostViewSet # 导入 ViewSet

创建一个 Router 实例

router = DefaultRouter()

注册 ViewSet 到 Router，指定 URL 前缀 (posts) 和 ViewSet 类

router.register(r’posts’, PostViewSet) # r’posts’ 是 URL 前缀

Router 会自动生成 URL 模式，例如 /posts/ 和 /posts/{pk}/

urlpatterns = [
# 将 Router 生成的 URL 模式包含进来
path(”, include(router.urls)),
# 额外添加一个可选的用于登录认证的 URL，在 DRF 可浏览 API 右上角使用
# path(‘api-auth/’, include(‘rest_framework.urls’, namespace=’rest_framework’))
]
“`

然后在项目 urls.py 中照常包含 blog.urls：path('api/', include('blog.urls'))。

使用 ViewSet 和 Router 是构建 RESTful API 的常见且高效的方式，尤其适用于资源具有标准 CRUD 操作的情况。在更复杂的场景下，你可能需要回到 GenericAPIView + Mixins 或者 APIView 来实现定制逻辑。

认证 (Authentication) 与权限 (Permissions)

在实际的 API 中，通常需要验证用户身份 (Authentication) 并确定用户是否有权执行请求的操作 (Permissions)。DRF 提供了一套灵活的认证和权限系统。

你可以在 settings.py 中设置全局的认证和权限策略：

“`python

myapi/settings.py

REST_FRAMEWORK = {
‘DEFAULT_AUTHENTICATION_CLASSES’: [
‘rest_framework.authentication.SessionAuthentication’,
‘rest_framework.authentication.BasicAuthentication’,
# ‘rest_framework.authentication.TokenAuthentication’, # 如果使用 Token 认证
],
‘DEFAULT_PERMISSION_CLASSES’: [
‘rest_framework.permissions.IsAuthenticatedOrReadOnly’, # 登录用户才能修改，未登录用户只能读
# ‘rest_framework.permissions.IsAdminUser’, # 只有管理员用户
# ‘rest_framework.permissions.AllowAny’, # 允许任何人 (默认)
],
# … 其他 DRF 设置
}
“`

或者在单个视图中指定：

“`python

blog/views.py (在视图中指定认证和权限)

from rest_framework.permissions import IsAuthenticatedOrReadOnly
from rest_framework.authentication import TokenAuthentication

class PostListCreateView(generics.ListCreateAPIView):
queryset = Post.objects.all()
serializer_class = PostSerializer
authentication_classes = [TokenAuthentication] # 指定此视图使用 Token 认证
permission_classes = [IsAuthenticatedOrReadOnly] # 指定此视图使用 IsAuthenticatedOrReadOnly 权限
“`

这使得你可以精细地控制不同 API 端点的访问权限。

分页 (Pagination) 和过滤 (Filtering)

对于返回大量数据的列表 API (如 /api/posts/)，一次性返回所有数据可能效率低下。DRF 提供了分页功能，只返回一部分数据。

可以在 settings.py 中设置全局分页样式：

“`python

myapi/settings.py

REST_FRAMEWORK = {
# … 其他设置
‘DEFAULT_PAGINATION_CLASS’: ‘rest_framework.pagination.PageNumberPagination’,
‘PAGE_SIZE’: 10, # 每页10条数据
}
“`

或者在视图中指定：

“`python

blog/views.py (在视图中指定分页)

from rest_framework.pagination import PageNumberPagination

class PostPagination(PageNumberPagination):
page_size = 10
page_size_query_param = ‘page_size’ # 允许客户端通过 ?page_size= 来控制每页数量
max_page_size = 100 # 限制客户端设置的最大每页数量

class PostListCreateView(generics.ListCreateAPIView):
queryset = Post.objects.all()
serializer_class = PostSerializer
pagination_class = PostPagination # 指定此视图使用自定义分页类
“`

DRF 还提供了过滤功能，允许客户端通过 URL 参数来过滤返回的数据集。例如，只获取某个用户发布的文章。这通常需要结合 django-filter 等第三方库。

文档生成

为 API 提供文档非常重要。DRF 可以与 drf-yasg 或 django-rest-swagger 等第三方库集成，自动生成 Swagger/OpenAPI 格式的 API 文档，非常方便。

总结与下一步

恭喜你！你已经成功构建了你的第一个使用 Django REST Framework 的 Web API。通过这个简单的博客文章 CRUD 示例，你学习了 DRF 的核心概念：

Serializers: 如何将 Django 模型转换为可传输格式，以及验证输入数据。
Views: 如何使用通用视图类快速实现常见的 API 逻辑。
URLs: 如何配置 URL 路由来映射视图。
Browsable API: 如何使用 DRF 内置的可浏览 API 进行便捷的测试。

你还初步了解了 ViewSets 和 Routers 这种更简洁的 API 构建方式，以及认证、权限、分页、过滤等重要的高级概念。

这仅仅是 DRF 强大功能的冰山一角。要构建更健壮、更安全的 API，你需要进一步学习：

ViewSets 和 Routers: 熟练掌握如何使用 ModelViewSet 和 DefaultRouter 来简化代码。
认证和权限: 实现不同类型的认证（如 Token 认证、JWT 认证）和更细粒度的权限控制。
分页和过滤: 为大型数据集的列表接口添加分页和过滤功能。
自定义 Serializer 和 Fields: 学习如何处理更复杂的数据结构和关系。
验证: 深入理解 DRF 的验证机制，包括字段级别和对象级别的验证。
测试: 为你的 API 编写自动化测试。
异常处理: 定制 API 的错误响应。
限流 (Throttling): 限制用户或 IP 的访问频率，防止滥用。
跨域资源共享 (CORS): 如果你的前端应用与后端 API 不在同一个域名下，需要配置 CORS。

DRF 官方文档是最好的学习资源，它详细介绍了所有功能和用法。现在你已经有了入门的基础，可以开始探索更多高级主题，构建更复杂的 Web API 了！

希望这篇详细的文章对你快速掌握 DRF 有所帮助。祝你在 API 开发的道路上越走越远！

DRF 快速入门：构建你的第一个 Web API – wiki基地

DRF 快速入门：构建你的第一个 Web API

引言：Web API 的重要性与 DRF 的魅力

准备工作：环境搭建

对于 macOS/Linux

对于 Windows

第一步：创建 Django 项目和应用

myapi/settings.py

… 其他配置

第二步：定义数据模型 (Model)

blog/models.py

第三步：创建序列化器 (Serializer)

blog/serializers.py

第四步：创建视图 (View)

blog/views.py

导入 DRF 的具体视图类

导入模型和序列化器

视图1: 处理 /api/posts/ 请求 (获取所有文章列表和创建新文章)

视图2: 处理 /api/posts// 请求 (获取单篇文章详情, 更新文章, 删除文章)

第五步：配置 URL 路由

blog/urls.py

myapi/urls.py

第六步：运行服务器并测试 API

第七步：深入理解 DRF 的核心概念（进阶思考）

Serializer 的更多功能

Views 的不同选择

blog/views.py (使用 ViewSet)

blog/urls.py (使用 Router)

创建一个 Router 实例

注册 ViewSet 到 Router，指定 URL 前缀 (posts) 和 ViewSet 类

Router 会自动生成 URL 模式，例如 /posts/ 和 /posts/{pk}/

认证 (Authentication) 与权限 (Permissions)

myapi/settings.py

blog/views.py (在视图中指定认证和权限)

分页 (Pagination) 和过滤 (Filtering)

myapi/settings.py

blog/views.py (在视图中指定分页)

文档生成

总结与下一步

发表评论取消回复

DRF 快速入门：构建你的第一个 Web API

引言：Web API 的重要性与 DRF 的魅力

准备工作：环境搭建

对于 macOS/Linux

对于 Windows

第一步：创建 Django 项目和应用

myapi/settings.py

… 其他配置

第二步：定义数据模型 (Model)

blog/models.py

第三步：创建序列化器 (Serializer)

blog/serializers.py

第四步：创建视图 (View)

blog/views.py

导入 DRF 的具体视图类

导入模型和序列化器

视图1: 处理 /api/posts/ 请求 (获取所有文章列表 和 创建新文章)

视图2: 处理 /api/posts// 请求 (获取单篇文章详情, 更新文章, 删除文章)

第五步：配置 URL 路由

blog/urls.py

myapi/urls.py

第六步：运行服务器并测试 API

第七步：深入理解 DRF 的核心概念（进阶思考）

Serializer 的更多功能

Views 的不同选择

blog/views.py (使用 ViewSet)

blog/urls.py (使用 Router)

创建一个 Router 实例

注册 ViewSet 到 Router，指定 URL 前缀 (posts) 和 ViewSet 类

Router 会自动生成 URL 模式，例如 /posts/ 和 /posts/{pk}/

认证 (Authentication) 与权限 (Permissions)

myapi/settings.py

blog/views.py (在视图中指定认证和权限)

分页 (Pagination) 和过滤 (Filtering)

myapi/settings.py

blog/views.py (在视图中指定分页)

文档生成

总结与下一步

发表评论 取消回复

视图1: 处理 /api/posts/ 请求 (获取所有文章列表和创建新文章)

发表评论取消回复