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

2024-08-21 01:04
文章标签 自定义 认证 开发 django api 架构 用户 后端 匿名 rest 节流

本文主要是介绍Django后端架构开发：从匿名用户API节流到REST自定义认证，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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

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

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

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

实现步骤：

  1. 创建中间件：

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

    # middlewares.py
import time
from django.core.cache import cache
from django.http import JsonResponseclass ThrottleMiddleware:"""匿名用户节流中间件"""def __init__(self, get_response):self.get_response = get_responsedef __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 ipdef allow_request(self, ip):"""检查是否允许请求"""cache_key = f'throttle_{ip}'requests = cache.get(cache_key, 0)if requests >= 100:  # 设定阈值，例如每小时100次请求return Falsecache.set(cache_key, requests + 1, timeout=3600)return True

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

  2. 在 settings.py 中注册中间件：

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

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

  3. 测试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 Responseclass 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 类，我们可以轻松实现自定义的认证逻辑。

实现步骤：

  1. 创建自定义认证类：

    假设我们需要通过自定义的 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 MyTokenclass CustomTokenAuthentication(BaseAuthentication):"""自定义Token认证类"""def authenticate(self, request):token = request.headers.get('Authorization')if not token:return Nonetry: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 异常。

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

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

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

  3. 测试自定义认证：

    通过发送带有 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的权限控制。

实现步骤：

  1. 创建自定义权限类：

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

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

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

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

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

    # views.py
from rest_framework.viewsets import ModelViewSet
from .models import MyModel
from .serializers import MyModelSerializer
from .permissions import IsAdminUserOrReadOnlyclass MyModelViewSet(ModelViewSet):"""示例视图集，应用自定义权限控制"""queryset = MyModel.objects.all()serializer_class = MyModelSerializerpermission_classes = [IsAdminUserOrReadOnly]

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

  3. 测试权限管理：

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

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

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

# permissions.py
class TokenLevelPermission(BasePermission):"""基于Token等级的权限控制"""def has_permission(self, request, view):token = request.headers.get('Authorization')if not token:return Falseuser_level = self.get_user_level(token)if request.method == 'POST' and user_level < 2:return Falseif request.method in ['PUT', 'DELETE'] and user_level < 3:return Falsereturn Truedef 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中实现并处理这些请求。

实现步骤：

  1. 模型定义：

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

    # models.py
from django.db import modelsclass 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

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

  2. 序列化与反序列化：

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

    # serializers.py
from rest_framework import serializers
from .models import Articleclass ArticleSerializer(serializers.ModelSerializer):"""文章序列化器"""class Meta:model = Articlefields = '__all__'

    这个序列化器使用了Django REST Framework提供的 ModelSerializer，可以自动处理模型的序列化和反序列化。

  3. 视图实现：

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

    # 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 ArticleSerializerclass 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请求则用于删除文章。

  4. URL配置：

    最后，我们需要将视图与URL路由绑定，以便客户端可以通过HTTP请求访问这些API。

    # urls.py
from django.urls import path
from .views import ArticleDetailViewurlpatterns = [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 ArticleCreateViewurlpatterns = [path('articles/', ArticleCreateView.as_view(), name='article-create'),
]

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

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

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

实现步骤：

  1. 序列化器的基础用法：

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

    # serializers.py
from rest_framework import serializers
from .models import Articleclass ArticleSerializer(serializers.ModelSerializer):"""文章序列化器"""class Meta:model = Articlefields = ['title', 'author', 'content', 'created_at']

    这个序列化器可以将 Article 模型实例转换为字典格式，或者将传入的数据反序列化为 Article 实例。

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

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

    # views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Article
from .serializers import ArticleSerializerclass 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请求的反序列化操作。

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

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

    # serializers.py
class ArticleSerializer(serializers.ModelSerializer):"""文章序列化器，带有自定义验证与方法"""class Meta:model = Articlefields = '__all__'def validate_title(self, value):"""验证文章标题的长度"""if len(value) < 5:raise serializers.ValidationError("标题长度必须大于5个字符")return valuedef create(self, validated_data):"""自定义创建方法"""return Article.objects.create(**validated_data)

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

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

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

# serializers.py
class CommentSerializer(serializers.ModelSerializer):"""评论序列化器"""class Meta:model = Commentfields = ['author', 'content', 'created_at']class ArticleSerializer(serializers.ModelSerializer):"""文章序列化器，包含嵌套的评论序列化器"""comments = CommentSerializer(many=True, read_only=True)class Meta:model = Articlefields = ['title', 'author', 'content', 'created_at', 'comments']

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

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

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

实现步骤：

  1. 理解格式后缀的作用：

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

    例如：

    • GET /articles/1.json 会返回JSON格式的数据
    • GET /articles/1.html 会返回HTML格式的数据

  2. 配置格式后缀：

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

    # urls.py
from django.urls import path
from .views import ArticleDetailView
from rest_framework.urlpatterns import format_suffix_patternsurlpatterns = [path('articles/<int:pk>/', ArticleDetailView.as_view(), name='article-detail'),
]# 添加格式后缀支持
urlpatterns = format_suffix_patterns(urlpatterns)

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

  3. 自定义格式支持：

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

    # views.py
from rest_framework.renderers import BaseRendererclass 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的开发。

实现步骤：

  1. 视图包装器的基础用法：

    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数据。

  2. 多请求方法处理：

    使用 @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。

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

    视图包装器还可以与权限和认证机制结合使用。例如，我们可以通过 @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 PageNumberPaginationclass 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。

实现步骤：

  1. 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 获取了当前登录的用户。

  2. 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 对象返回了序列化的文章数据，并根据请求的结果返回了不同的状态码。

  3. 自定义响应格式：

    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 MiddlewareMixinclass 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的功能。

这篇关于Django后端架构开发：从匿名用户API节流到REST自定义认证的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1091676。

相关文章

TP-Link PDDNS服将于务6月30日正式停运:用户需转向第三方DDNS服务

TP-Link PDDNS服将于务6月30日正式停运:用户需转向第三方DDNS服务

《TP-LinkPDDNS服将于务6月30日正式停运:用户需转向第三方DDNS服务》近期，路由器制造巨头普联（TP-Link）在用户群体中引发了一系列重要变动,上个月，公司发出了一则通知，明确要求所... 路由器厂商普联（TP-Link）上个月发布公告要求所有用户必须完成实名认证后才能继续使用普联提供的 D
阅读更多...
Deepseek R1模型本地化部署+API接口调用详细教程(释放AI生产力)

Deepseek R1模型本地化部署+API接口调用详细教程(释放AI生产力)

《DeepseekR1模型本地化部署+API接口调用详细教程(释放AI生产力)》本文介绍了本地部署DeepSeekR1模型和通过API调用将其集成到VSCode中的过程,作者详细步骤展示了如何下载和... 目录前言一、deepseek R1模型与chatGPT o1系列模型对比二、本地部署步骤1.安装oll
阅读更多...
浅析如何使用Swagger生成带权限控制的API文档

浅析如何使用Swagger生成带权限控制的API文档

《浅析如何使用Swagger生成带权限控制的API文档》当涉及到权限控制时,如何生成既安全又详细的API文档就成了一个关键问题,所以这篇文章小编就来和大家好好聊聊如何用Swagger来生成带有... 目录准备工作配置 Swagger权限控制给 API 加上权限注解查看文档注意事项在咱们的开发工作里，API
阅读更多...
一分钟带你上手Python调用DeepSeek的API

一分钟带你上手Python调用DeepSeek的API

《一分钟带你上手Python调用DeepSeek的API》最近DeepSeek非常火,作为一枚对前言技术非常关注的程序员来说,自然都想对接DeepSeek的API来体验一把,下面小编就来为大家介绍一下... 目录前言免费体验API-Key申请首次调用API基本概念最小单元推理模型智能体自定义界面总结前言最
阅读更多...
JAVA调用Deepseek的api完成基本对话简单代码示例

JAVA调用Deepseek的api完成基本对话简单代码示例

《JAVA调用Deepseek的api完成基本对话简单代码示例》：本文主要介绍JAVA调用Deepseek的api完成基本对话的相关资料,文中详细讲解了如何获取DeepSeekAPI密钥、添加H... 获取API密钥首先，从DeepSeek平台获取API密钥，用于身份验证。添加HTTP客户端依赖使用Jav
阅读更多...
java如何通过Kerberos认证方式连接hive

java如何通过Kerberos认证方式连接hive

《java如何通过Kerberos认证方式连接hive》该文主要介绍了如何在数据源管理功能中适配不同数据源（如MySQL、PostgreSQL和Hive）,特别是如何在SpringBoot3框架下通过... 目录Java实现Kerberos认证主要方法依赖示例续期连接hive遇到的问题分析解决方式扩展思考总
阅读更多...
MySQL 缓存机制与架构解析(最新推荐)

MySQL 缓存机制与架构解析(最新推荐)

《MySQL缓存机制与架构解析(最新推荐)》本文详细介绍了MySQL的缓存机制和整体架构,包括一级缓存（InnoDBBufferPool）和二级缓存（QueryCache）,文章还探讨了SQL... 目录一、mysql缓存机制概述二、MySQL整体架构三、SQL查询执行全流程四、MySQL 8.0为何移除查
阅读更多...
基于Python开发PPTX压缩工具

基于Python开发PPTX压缩工具

《基于Python开发PPTX压缩工具》在日常办公中,PPT文件往往因为图片过大而导致文件体积过大,不便于传输和存储,所以本文将使用Python开发一个PPTX压缩工具,需要的可以了解下... 目录引言全部代码环境准备代码结构代码实现运行结果引言在日常办公中，PPT文件往往因为图片过大而导致文件体积过大，
阅读更多...
C#使用DeepSeek API实现自然语言处理,文本分类和情感分析

C#使用DeepSeek API实现自然语言处理,文本分类和情感分析

《C#使用DeepSeekAPI实现自然语言处理,文本分类和情感分析》在C#中使用DeepSeekAPI可以实现多种功能,例如自然语言处理、文本分类、情感分析等,本文主要为大家介绍了具体实现步骤,... 目录准备工作文本生成文本分类问答系统代码生成翻译功能文本摘要文本校对图像描述生成总结在C#中使用Deep
阅读更多...
CSS自定义浏览器滚动条样式完整代码

CSS自定义浏览器滚动条样式完整代码

《CSS自定义浏览器滚动条样式完整代码》：本文主要介绍了如何使用CSS自定义浏览器滚动条的样式，包括隐藏滚动条的角落、设置滚动条的基本样式、轨道样式和滑块样式，并提供了完整的CSS代码示例，通过这些技巧，你可以为你的网站添加个性化的滚动条样式，从而提升用户体验，详细内容请阅读本文，希望能对你有所帮助...
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2