Django后端架构开发：从匿名用户API节流到REST自定义认证

Switch616

于 2024-08-20 22:15:17 发布

阅读量666

点赞数 14

分类专栏： Python Web 文章标签： django 架构 python 中间件数据库后端

本文链接：https://blog.csdn.net/weixin_52392194/article/details/141369764

版权

Python Web 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

🎯Django后端架构开发：从匿名用户API节流到REST自定义认证

在现代Web应用中，后端架构的开发至关重要。无论是用户的认证与权限管理，还是API的节流与数据序列化，都需要一个高效且安全的实现方案。本文将带领大家深入探讨Python Django后端架构开发的关键要素，涵盖匿名用户配置、REST自定义认证、权限机制、模型搭建以及请求和响应的处理。通过实战代码和详细解析，帮助您掌握构建高效、可扩展的Django后端架构的核心技能。

🔒匿名用户配置与API节流：保护资源与提升性能

在一个多用户的Web应用中，API请求的控制非常重要。特别是对于匿名用户，需要采取合理的节流策略，防止资源滥用。Django提供了丰富的中间件和装饰器，能够帮助我们轻松实现API的节流机制。我们将结合Django REST Framework (DRF) 来实现这一功能。

实现步骤：

创建中间件：

我们首先需要创建一个中间件，用于检查匿名用户的请求频率。这个中间件会记录每个匿名用户的IP地址，并限制其在一定时间内的请求次数。

# middlewares.py
import time
from django.core.cache import cache
from django.http import JsonResponse

class ThrottleMiddleware:
    """
    匿名用户节流中间件
    """
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if not request.user.is_authenticated:
            ip = self.get_client_ip(request)
            if not self.allow_request(ip):
                return JsonResponse({'error': '请求过于频繁，请稍后再试。'}, status=429)
        return self.get_response(request)

    def get_client_ip(self, request):
        """
        获取用户IP地址
        """
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0]
        else:
            ip = request.META.get('REMOTE_ADDR')
        return ip

    def allow_request(self, ip):
        """
        检查是否允许请求
        """
        cache_key = f'throttle_{ip}'
        requests = cache.get(cache_key, 0)
        if requests >= 100:  # 设定阈值，例如每小时100次请求
            return False
        cache.set(cache_key, requests + 1, timeout=3600)
        return True

以上代码创建了一个简单的节流中间件，针对每个匿名用户（通过IP地址识别），记录他们的请求次数。如果在一个小时内请求次数超过100次，则拒绝服务并返回429状态码。

在 settings.py 中注册中间件：

# settings.py
MIDDLEWARE = [
    # 其他中间件
    'yourapp.middlewares.ThrottleMiddleware',
]

将中间件添加到Django项目的设置中，使其生效。

测试API节流：

现在我们可以测试API的节流功能了。通过发送多个请求，可以观察到在超过请求阈值后，系统会返回相应的错误消息。

拓展：为特定API实现更细粒度的节流

如果我们需要对特定的API进行更加细致的节流控制，可以使用Django REST Framework 提供的 throttling 功能。

# views.py
from rest_framework.throttling import AnonRateThrottle
from rest_framework.views import APIView
from rest_framework.response import Response

class CustomThrottle(AnonRateThrottle):
    """
    自定义节流类
    """
    rate = '10/minute'  # 每分钟10次请求

class MyAPIView(APIView):
    """
    示例视图，应用自定义节流策略
    """
    throttle_classes = [CustomThrottle]

    def get(self, request):
        return Response({"message": "API 请求成功！"})

在这个示例中，我们创建了一个自定义的节流类，并将其应用于一个API视图中。该API视图限制匿名用户每分钟只能发起10次请求，超过限制则会返回节流错误。这种方式更为灵活，可以根据不同的需求对不同的API进行节流控制。

🛡️REST自定义认证：重写认证流程提升安全性

在实际项目中，默认的认证机制可能无法满足复杂的业务需求。我们需要根据项目需求自定义认证流程，以实现更高的安全性和灵活性。通过Django REST Framework的 BaseAuthentication 类，我们可以轻松实现自定义的认证逻辑。

实现步骤：

创建自定义认证类：

假设我们需要通过自定义的 Token 认证用户，而不是使用默认的 Session 或 Basic Auth。我们可以通过继承 BaseAuthentication 来实现这个需求。

# authentication.py
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from django.contrib.auth.models import User
from .models import MyToken

class CustomTokenAuthentication(BaseAuthentication):
    """
    自定义Token认证类
    """
    def authenticate(self, request):
        token = request.headers.get('Authorization')
        if not token:
            return None

        try:
            my_token = MyToken.objects.get(token=token)
        except MyToken.DoesNotExist:
            raise AuthenticationFailed('无效的Token')

        user = User.objects.get(id=my_token.user_id)
        return (user, None)

在这个例子中，我们定义了一个自定义的 Token 认证类。该类通过从请求头中获取 Authorization 字段的值，验证 Token 的合法性。如果 Token 无效，则抛出 AuthenticationFailed 异常。

在 settings.py 中注册自定义认证类：

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'yourapp.authentication.CustomTokenAuthentication',
    ],
}

将自定义的认证类添加到Django REST Framework的设置中，使其成为默认的认证方式。

测试自定义认证：

通过发送带有 Token 的请求，可以验证自定义认证类的功能。无论是GET请求还是POST请求，系统都会首先通过自定义认证类验证用户的身份，确保每个请求的安全性。

拓展：双重认证机制

有时我们可能需要在项目中实现双重认证（例如，Token + Session），以满足更高的安全需求。此时，可以在 settings.py 中配置多个认证类：

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'yourapp.authentication.CustomTokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
}

在这个配置中，系统会依次尝试使用每个认证类进行用户验证，直到成功为止。如果所有认证类都无法验证用户，则返回认证失败。这种方式可以大大提升系统的安全性和灵活性。

🔗REST 权限管理与Token认证：精细化控制用户访问

在Web应用中，不同用户角色对资源的访问权限通常不同。通过Django REST Framework，我们可以实现精细化的权限管理。这里我们将探讨如何结合Token认证，实现REST API的权限控制。

实现步骤：

创建自定义权限类：

Django REST Framework 提供了灵活的权限控制机制。我们可以通过继承 BasePermission 类，创建自定义的权限类。

# permissions.py
from rest_framework.permissions import BasePermission

class IsAdminUserOrReadOnly(BasePermission):
    """
    自定义权限类：仅管理员可写，其他用户只读
    """
    def has_permission(self, request, view):
        if request.method in ['GET', 'HEAD', 'OPTIONS']:
            return True
        return request.user.is_authenticated and request.user.is_staff

这个自定义权限类 IsAdminUserOrReadOnly 的作用是：所有用户都可以进行读操作（GET、HEAD、OPTIONS），但是只有管理员用户可以进行写操作（POST、PUT、DELETE）。

在视图中应用自定义权限：

我们可以将自定义的权限类应用到具体的视图或视图集上，以控制对该视图的访问权限。

# views.py
from rest_framework.viewsets import ModelViewSet
from .models import MyModel
from .serializers import MyModelSerializer
from .permissions import IsAdminUserOrReadOnly

class MyModelViewSet(ModelViewSet):
    """
    示例视图集，应用自定义权限控制
    """
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer
    permission_classes = [IsAdminUserOrReadOnly]

在这个示例中，我们将 IsAdminUserOrReadOnly 权限类应用到了 MyModelViewSet 视图集中。这样一来，只有管理员用户可以对该视图进行写操作，而其他用户只能进行读操作。

测试权限管理：

通过模拟不同用户角色的请求，可以测试自定义权限类的效果。管理员用户应具有完全的访问权限，而普通用户只能进行读操作。

拓展：基于Token的多级权限控制

如果我们需要实现基于Token的多级权限控制，可以结合自定义认证和权限类，实现更加复杂的权限管理策略。

# permissions.py
class TokenLevelPermission(BasePermission):
    """
    基于Token等级的权限控制
    """
    def has_permission(self, request, view):
        token = request.headers.get('Authorization')
        if not token:
            return False

        user_level = self.get_user_level(token)
        if request.method == 'POST' and user_level < 2:
            return False
        if request.method in ['PUT', 'DELETE'] and user_level < 3:
            return False
        return True

    def get_user_level(self, token):
        """
        获取用户Token对应的权限等级
        """
        # 这里假设Token中包含用户权限等级信息
        return int(token.split('-')[-1])  # 示例实现，实际逻辑可能不同

通过这个 TokenLevelPermission 类，我们可以根据Token中的权限等级信息，精细控制不同用户对资源的访问权限。例如，权限等级为1的用户只能进行GET操作，权限等级为2的用户可以进行POST操作，而只有权限等级为3的用户才可以进行PUT和DELETE操作。

这种方式在大规模应用中非常有用，可以为不同级别的用户提供不同的服务，并确保敏感资源的安全性。

💼项目实践：GET、POST、PUT、DELETE请求的全面解析

在实际项目开发中，RESTful API 的核心就是GET、POST、PUT和DELETE请求。理解并正确使用这些请求方法，是开发健壮API的基础。接下来，我们将通过一个具体的案例，展示如何在Django中实现并处理这些请求。

实现步骤：

模型定义：

假设我们正在开发一个简单的博客系统，其中包含文章（Article）模型。我们需要实现文章的增删改查操作，对应的即是GET、POST、PUT和DELETE请求。

# models.py
from django.db import models

class Article(models.Model):
    """
    文章模型
    """
    title = models.CharField(max_length=200, verbose_name="标题")
    content = models.TextField(verbose_name="内容")
    author = models.CharField(max_length=50, verbose_name="作者")
    created_at = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    updated_at = models.DateTimeField(auto_now=True, verbose_name="更新时间")

    def __str__(self):
        return self.title

这个模型定义了文章的基本字段，包括标题、内容、作者、创建时间和更新时间。

序列化与反序列化：

接下来，我们需要创建一个序列化器，用于将 Article 模型实例转换为JSON格式，以及将JSON数据反序列化为 Article 实例。
```
# serializers.py
from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    """
    文章序列化器
    """
    class Meta:
        model = Article
        fields = '__all__'
```
这个序列化器使用了Django REST Framework提供的 ModelSerializer，可以自动处理模型的序列化和反序列化。

视图实现：

我们需要为文章的增删改查操作创建对应的视图，并将其与请求方法相对应。

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import Article
from .serializers import ArticleSerializer

class ArticleDetailView(APIView):
    """
    文章详情视图，处理GET、PUT、DELETE请求
    """

    def get(self, request, pk):
        article = Article.objects.get(pk=pk)
        serializer = ArticleSerializer(article)
        return Response(serializer.data)

    def put(self, request, pk):
        article = Article.objects.get(pk=pk)
        serializer = ArticleSerializer(article, 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):
        article = Article.objects.get(pk=pk)
        article.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

在这个视图中，我们处理了GET、PUT和DELETE请求。GET请求用于获取文章详情，PUT请求用于更新文章，而DELETE请求则用于删除文章。

URL配置：

最后，我们需要将视图与URL路由绑定，以便客户端可以通过HTTP请求访问这些API。
```
# urls.py
from django.urls import path
from .views import ArticleDetailView

urlpatterns = [
    path('articles/<int:pk>/', ArticleDetailView.as_view(), name='article-detail'),
]
```
这样，我们就完成了基本的RESTful API的实现，可以通过 /articles/<pk>/ 路径访问文章详情。

拓展：添加POST请求以创建新文章

为了完整实现博客系统的增删改查操作，我们还需要为创建新文章的POST请求添加视图和路由。

# views.py
class ArticleCreateView(APIView):
    """
    文章创建视图，处理POST请求
    """

    def post(self, request):
        serializer = ArticleSerializer(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)

# urls.py
from .views import ArticleCreateView

urlpatterns = [
    path('articles/', ArticleCreateView.as_view(), name='article-create'),
]

现在，我们可以通过POST请求 /articles/ 路径创建新文章，从而完成整个增删改查操作的实现。

🔄REST框架的序列化与反序列化：数据与模型的桥梁

在Web应用中，数据的传输与处理是不可避免的。而序列化与反序列化正是实现数据与模型之间转换的关键步骤。Django REST Framework提供了强大的序列化功能，帮助我们轻松处理数据转换。

实现步骤：

序列化器的基础用法：

序列化器的主要作用是将模型实例转换为字典或JSON格式，便于数据的传输。而反序列化则是将传入的数据转换为模型实例，便于数据的保存和处理。
```
# serializers.py
from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    """
    文章序列化器
    """
    class Meta:
        model = Article
        fields = ['title', 'author', 'content', 'created_at']
```
这个序列化器可以将 Article 模型实例转换为字典格式，或者将传入的数据反序列化为 Article 实例。

序列化与反序列化的使用：

在视图中，我们可以通过 ArticleSerializer 进行序列化与反序列化操作。

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Article
from .serializers import ArticleSerializer

class ArticleView(APIView):
    """
    文章视图，处理GET和POST请求
    """

    def get(self, request):
        articles = Article.objects.all()
        serializer = ArticleSerializer(articles, many=True)
        return Response(serializer.data)

    def post(self, request):
        serializer = ArticleSerializer(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)

在这个视图中，我们使用了序列化器进行GET请求的序列化操作，以及POST请求的反序列化操作。

序列化器的验证与自定义方法：

除了基本的序列化与反序列化功能外，Django REST Framework 还提供了验证与自定义方法，帮助我们实现更加复杂的数据处理逻辑。

# serializers.py
class ArticleSerializer(serializers.ModelSerializer):
    """
    文章序列化器，带有自定义验证与方法
    """
    class Meta:
        model = Article
        fields = '__all__'

    def validate_title(self, value):
        """
        验证文章标题的长度
        """
        if len(value) < 5:
            raise serializers.ValidationError("标题长度必须大于5个字符")
        return value

    def create(self, validated_data):
        """
        自定义创建方法
        """
        return Article.objects.create(**validated_data)

在这个序列化器中，我们添加了一个 validate_title 方法，用于验证文章标题的长度。同时，我们还重写了 create 方法，实现自定义的创建逻辑。

拓展：嵌套序列化器的使用

在复杂的数据结构中，可能会涉及到嵌套关系。例如，文章可能包含多个评论（Comment）。我们可以使用嵌套序列化器来处理这种情况。

# serializers.py
class CommentSerializer(serializers.ModelSerializer):
    """
    评论序列化器
    """
    class Meta:
        model = Comment
        fields = ['author', 'content', 'created_at']

class ArticleSerializer(serializers.ModelSerializer):
    """
    文章序列化器，包含嵌套的评论序列化器
    """
    comments = CommentSerializer(many=True, read_only=True)

    class Meta:
        model = Article
        fields = ['title', 'author', 'content', 'created_at', 'comments']

通过这种方式，我们可以在序列化文章时，自动包含其关联的评论数据，实现复杂数据结构的序列化与反序列化操作。

📚Django REST Framework的请求与响应：深入理解格式后缀

在Django REST Framework中，处理请求与响应时，格式后缀是一个非常实用的功能。它允许我们根据URL中的后缀来自动决定响应的数据格式，极大地方便了API的开发与使用。

实现步骤：

理解格式后缀的作用：

格式后缀（format suffix）是Django REST Framework提供的一种机制，允许客户端通过在URL中指定后缀来请求特定格式的数据。默认支持的格式包括JSON和HTML，但我们也可以自定义其他格式。

例如：
- GET /articles/1.json 会返回JSON格式的数据
- GET /articles/1.html 会返回HTML格式的数据

配置格式后缀：

在项目的URL配置中，我们可以通过 format_suffix_patterns 函数来启用格式后缀功能。

# urls.py
from django.urls import path
from .views import ArticleDetailView
from rest_framework.urlpatterns import format_suffix_patterns

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

# 添加格式后缀支持
urlpatterns = format_suffix_patterns(urlpatterns)

这样，我们就为 ArticleDetailView 视图启用了格式后缀支持，客户端可以通过添加 .json 或 .html 等后缀来请求不同格式的响应。

自定义格式支持：

除了默认的JSON和HTML格式外，我们还可以自定义响应的格式。例如，支持返回CSV格式的数据。

# views.py
from rest_framework.renderers import BaseRenderer

class CSVRenderer(BaseRenderer):
    """
    自定义CSV格式渲染器
    """
    media_type = 'text/csv'
    format = 'csv'

    def render(self, data, media_type=None, renderer_context=None):
        """
        将数据渲染为CSV格式
        """
        # 简单实现，仅供示例
        header = ','.join(data[0].keys()) + '\n'
        rows = [','.join(map(str, row.values())) for row in data]
        return header + '\n'.join(rows)

class ArticleListView(APIView):
    """
    文章列表视图，支持CSV格式响应
    """
    renderer_classes = [CSVRenderer]

    def get(self, request, format=None):
        articles = Article.objects.all()
        serializer = ArticleSerializer(articles, many=True)
        return Response(serializer.data)

在这个示例中，我们定义了一个自定义的 CSVRenderer，并将其应用到 ArticleListView 视图中。这样，当客户端请求 .csv 格式时，API将返回CSV格式的数据。

拓展：根据用户偏好自动选择格式

有时，我们希望根据用户的偏好自动选择响应格式。Django REST Framework提供了内容协商（Content Negotiation）机制，可以帮助我们实现这一功能。

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_CONTENT_NEGOTIATION_CLASS': 'rest_framework.negotiation.DefaultContentNegotiation',
    'DEFAULT_RENDERER_CLASSES': (
        'rest_framework.renderers.JSONRenderer',
        'rest_framework.renderers.TemplateHTMLRenderer',
        'path.to.CSVRenderer',
    ),
}

通过在配置中添加 DEFAULT_CONTENT_NEGOTIATION_CLASS 和 DEFAULT_RENDERER_CLASSES，我们可以控制REST框架如何选择合适的渲染器。这样，API就可以根据用户的请求头或URL后缀，自动选择最适合的响应格式。

🔗Django REST Framework请求和响应：视图包装器与实践案例

Django REST Framework提供了视图包装器（View Decorators）来简化视图的开发。使用视图包装器，可以更方便地处理请求和响应，减少样板代码的重复。接下来，我们将通过一个实际案例，展示如何使用视图包装器来简化REST API的开发。

实现步骤：

视图包装器的基础用法：

Django REST Framework提供了多个视图包装器，最常用的是 @api_view。这个包装器可以将一个简单的函数视图转换为RESTful API视图，处理GET、POST等请求方法。

# views.py
from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import Article
from .serializers import ArticleSerializer

@api_view(['GET'])
def article_list(request):
    """
    文章列表视图，处理GET请求
    """
    articles = Article.objects.all()
    serializer = ArticleSerializer(articles, many=True)
    return Response(serializer.data)

在这个示例中，我们使用 @api_view 包装了一个简单的函数视图，使其能够处理GET请求，并返回文章列表的JSON数据。

多请求方法处理：

使用 @api_view，我们还可以同时处理多个请求方法。例如，处理文章列表的GET请求和创建新文章的POST请求。

@api_view(['GET', 'POST'])
def article_list(request):
    """
    文章列表视图，处理GET和POST请求
    """
    if request.method == 'GET':
        articles = Article.objects.all()
        serializer = ArticleSerializer(articles, many=True)
        return Response(serializer.data)

    elif request.method == 'POST':
        serializer = ArticleSerializer(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)

在这个视图中，我们根据请求方法的不同，分别处理GET和POST请求，实现了一个简单的增查操作API。

使用视图包装器处理权限与认证：

视图包装器还可以与权限和认证机制结合使用。例如，我们可以通过 @permission_classes 和 @authentication_classes 装饰器，为视图添加权限和认证控制。

from rest_framework.permissions import IsAuthenticated
from rest_framework.authentication import TokenAuthentication

@api_view(['GET'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def article_detail(request, pk):
    """
    文章详情视图，处理GET请求，仅限认证用户访问
    """
    try:
        article = Article.objects.get(pk=pk)
    except Article.DoesNotExist:
        return Response(status=status.HTTP_404_NOT_FOUND)

    serializer = ArticleSerializer(article)
    return Response(serializer.data)

在这个示例中，我们使用 @authentication_classes 指定了Token认证机制，并通过 @permission_classes 限制了访问权限，确保只有经过认证的用户才能访问文章详情。

拓展：视图包装器与分页结合

在处理大量数据时，分页功能是非常有用的。我们可以将视图包装器与分页功能结合使用，为API提供高效的数据传输。

# views.py
from rest_framework.pagination import PageNumberPagination

class ArticlePagination(PageNumberPagination):
    """
    自定义文章分页器
    """
    page_size = 10  # 每页显示10篇文章

@api_view(['GET'])
def paginated_article_list(request):
    """
    带分页功能的文章列表视图
    """
    articles = Article.objects.all()
    paginator = ArticlePagination()
    page = paginator.paginate_queryset(articles, request)
    serializer = ArticleSerializer(page, many=True)
    return paginator.get_paginated_response(serializer.data)

通过这个视图，我们可以在返回文章列表时自动进行分页，从而提高API的性能和用户体验。

🧰**Django REST Framework的请求与响应：Request和Response对象的灵活运

用**

在Django REST Framework中，Request 和 Response 对象是处理请求和生成响应的核心组件。通过深入理解和灵活运用这些对象，我们可以更加高效地开发RESTful API。

实现步骤：

Request 对象的使用：

Request 对象是Django REST Framework对Django原生 HttpRequest 的扩展，提供了更丰富的功能。我们可以通过 request 参数访问到 Request 对象，进而获取请求数据、头信息等。

@api_view(['POST'])
def create_article(request):
    """
    创建新文章的视图，处理POST请求
    """
    title = request.data.get('title')
    content = request.data.get('content')
    author = request.user  # 获取当前登录用户

    # 创建新文章
    article = Article.objects.create(title=title, content=content, author=author)
    return Response({'message': '文章创建成功', 'article_id': article.id}, status=status.HTTP_201_CREATED)

在这个示例中，我们使用 request.data 获取了POST请求中的数据，并通过 request.user 获取了当前登录的用户。

Response 对象的使用：

Response 对象是Django REST Framework对Django原生 HttpResponse 的扩展，提供了更简洁的API来生成不同格式的响应数据。

@api_view(['GET'])
def article_detail(request, pk):
    """
    文章详情视图，处理GET请求
    """
    try:
        article = Article.objects.get(pk=pk)
    except Article.DoesNotExist:
        return Response({'error': '文章不存在'}, status=status.HTTP_404_NOT_FOUND)

    serializer = ArticleSerializer(article)
    return Response(serializer.data)

在这个示例中，我们使用 Response 对象返回了序列化的文章数据，并根据请求的结果返回了不同的状态码。

自定义响应格式：

Django REST Framework支持多种响应格式，包括JSON、HTML、XML等。我们可以通过 Response 对象的 content_type 参数来自定义响应的格式。
```
@api_view(['GET'])
def custom_response(request):
    """
    自定义响应格式的视图
    """
    data = {'message': 'Hello, World!'}
    return Response(data, content_type='application/xml')
```
在这个示例中，我们通过指定 content_type 为 application/xml，返回了XML格式的响应数据。

拓展：请求和响应的中间件

在一些复杂的应用场景中，我们可能需要在请求和响应处理的不同阶段执行额外的逻辑。此时，Django中间件可以帮助我们实现这一功能。

# middlewares.py
from django.utils.deprecation import MiddlewareMixin

class CustomMiddleware(MiddlewareMixin):
    """
    自定义中间件，用于处理请求和响应
    """
    def process_request(self, request):
        # 在请求处理之前执行
        print(f"请求路径: {request.path}")

    def process_response(self, request, response):
        # 在响应处理之前执行
        response['X-Custom-Header'] = 'My Custom Header'
        return response

通过自定义中间件，我们可以在请求和响应的不同阶段插入自定义逻辑，进一步增强Django REST Framework的功能。

Switch616

关注

14
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
Django后端架构开发：从匿名用户API节流到REST自定义认证

在现代Web应用中，后端架构的开发至关重要。无论是用户的认证与权限管理，还是API的节流与数据序列化，都需要一个高效且安全的实现方案。本文将带领大家深入探讨Python Django后端架构开发的关键要素，涵盖匿名用户配置、REST自定义认证、权限机制、模型搭建以及请求和响应的处理。通过实战代码和详细解析，帮助您掌握构建高效、可扩展的Django后端架构的核心技能。
复制链接

扫一扫