WechatIMG582.jpeg
这篇文章主要介绍两种方式实现批量操作，
一种是使用 Django restframework提供的装饰器action，可以更具实际情况扩展默认的增删改查操作，扩展性很好；另外一种是使用第三方模块 djangorestframework-bulk，这个模块简化了我们对于 对象本身增删改查的批量化操作，各有优缺点。实际工作中选择合适的就好。
本次分享中使用到的model模型
from django.db import models
class User(models.Model):
name = models.CharField(max_length=32, unique=True, verbose_name='用户名')
def __str__(self):
return self.name
# Student 是后来添加的，`User` 在使用restframework-bulk 模块的时候存在问题
# 注意这里两个模型存在的差异性，你发现差在哪里了吗？
class Student(models.Model):
name = models.CharField(max_length=32)
def __str__(self):
return self.name
注意这里两个模型存在的差异性，你发现差在哪里了吗？
1、使用action装饰器自定义批量方法
为了分享方便，这里把serializers、viewset等都放到了一个文件(selfaction.py)中去
from django.shortcuts import get_object_or_404
from app.models import Student, User
from rest_framework.serializers import ModelSerializer
from rest_framework.viewsets import ModelViewSet
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework import status
# serializers
class UserModelSerializer(ModelSerializer):
class Meta:
model = User
fields = '__all__'
# viewset
class UserModelViewSet(ModelViewSet):
serializer_class = UserModelSerializer
queryset = User.objects.all()
# 通过 many=True 改造原有的API, 使其支持批量创建
# 核心就是如果过来的数据是list，则使用many=True
def get_serializer(self, *args, **kwargs):
serializer_class = self.get_serializer_class()
kwargs.setdefault('context', self.get_serializer_context())
if isinstance(self.request.data, list):
return serializer_class(many=True, *args, **kwargs)
else:
return serializer_class(*args, **kwargs)
# 使用action自定义方法
# detail 是针对记录是单条还是多条，这里是自定义批量操作，所以肯定是多条数据，detail=False
# 自定义批量删除， 方法名就是url的一部分，比如这里的 /v1/user/multi_delete/?ids=1,2,3
@action(methods=['delete'], detail=False)
def multi_delete(self, request, *args, **kwargs):
ids = request.query_params.get('ids', None)
if not ids:
return Response(status=status.HTTP_404_NOT_FOUND)
for id in ids.split(','):
get_object_or_404(User, id=int(id)).delete()
return Response(status=status.HTTP_204_NO_CONTENT)
# 自定义批量更新操作，
# 更新涉及到 全部 和 局部 更新，所以这里的methods要支持 put(全部)和 patch(局部)
@action(methods=['put', 'PATCH'], detail=False)
def multi_update(self, request, *args, **kwargs):
print("args: ", args, " kwargs: ", kwargs)
partial = kwargs.pop('partial', None)
print("partial: ", partial)
# 报错更新后的结果给前端
instances = []
if isinstance(self.request.data, list):
for item in request.data:
print(item)
instance = get_object_or_404(User, id=int(item['id']))
# partial 允许局部更新
serializer = super().get_serializer(instance, data=item, partial=partial)
serializer.is_valid(raise_exception=True)
serializer.save()
instances.append(serializer.data)
else:
pass
return Response(instances)
分析说明：
1、通过action装饰器可以实现自定义接口，可以扩展当前默认的增删改查操作
2、action的methods是该方法可执行的http method， detail参数是确定方法是针对单条数据还是多条数据
3、实际验证过发现partial = kwargs.pop('partial', None)不起作用，因为不管是PUT还是PATCH方法，该参数都是None，所以这里对于 partial的来源和用法有待进一步研究
args: () kwargs: {}
partial: None
4、使用DRF的Response返回的时候要求是JSON serializable，网上有些教程直接把get_object_or_404的结果instance追加到一个列表进行返回会报如下错误：
TypeError: Object of type User is not JSON serializable
所以追加到结果列表的时候使用 instances.append(serializer.data)
请求的接口验证
1、常规增删改查这里就赘述，可以参考文末整理的 《数据接口验证》
2、批量新增还是使用 /api/v1/users/接口，只不过body体是 List 格式，
3、批量更新（put/patch） 接口/api/v1/users/multi_update/
4、批量删除（） 接口/api/v1/users/multi_delete/?ids=1,2,3,4这里的ids可以根据实际自定义
2、djangorestframework-bulk
以下配置可以放到一个文件或者放到几个独立的问题都可以
serializers.py
# serializers.py
from rest_framework.serializers import ModelSerializer
from rest_framework.filters import SearchFilter
from rest_framework_bulk import BulkListSerializer, BulkSerializerMixin, BulkModelViewSet
from app.models import User
from app.models import Student
class UserSerializer(BulkSerializerMixin, ModelSerializer):
class Meta:
model = User
fields = '__all__'
list_serializer_class = BulkListSerializer
# filter_backends = (SearchFilter, )
class StudentSerializer(BulkSerializerMixin, ModelSerializer):
class Meta:
model = Student
fields = '__all__'
list_serializer_class = BulkListSerializer
filter_backends = (SearchFilter, )
filters.py
# fitlers.py
from django_filters.rest_framework.filterset import FilterSet
from django_filters import filters
from app.models import User
from app.models import Student
class UserFilterSet(FilterSet):
class Meta:
model = User
fields = {
'id': ['in'],
'name': ['icontains'],
}
class StudentFilterSet(FilterSet):
class Meta:
model = Student
fields = {
'id': ['in'],
'name': ['icontains'],
}
views.py
# views.py
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework_bulk import BulkModelViewSet
from app.models import User, Student
from app.serializers import UserSerializer, StudentSerializer
from app.filters import UserFilterSet, StudentFilterSet
# Create your views here.
class UserViewSet(BulkModelViewSet):
serializer_class = UserSerializer
queryset = User.objects.all()
print(queryset)
filter_backends = (DjangoFilterBackend, )
filter_class = UserFilterSet
def allow_bulk_destroy(self, qs, filtered):
print("here: qs-> ", qs, "\n filtered-> ", filtered)
return qs is not filtered
class StudentViewSet(BulkModelViewSet):
serializer_class = StudentSerializer
queryset = Student.objects.all()
filter_backends = (DjangoFilterBackend, )
filter_class = StudentFilterSet
def allow_bulk_destroy(self, qs, filtered):
print("here: qs-> ", qs, "\n filtered-> ", filtered)
return qs is not filtered
urls.py
from rest_framework_bulk.routes import BulkRouter
from app.views import UserViewSet
from app.views import StudentViewSet
from django.urls import path, include
router = BulkRouter()
router.register('users', UserViewSet)
router.register('students', StudentViewSet)
urlpatterns = [
path('', include(router.urls)),
]
数据接口验证
下表整理了常规接口和批量操作的接口汇总，大家可以按照这个实际进行测试
| 方法 | api接口 | 参数 | 说明 |
|---|---|---|---|
| GET | http://127.0.0.1:8001/api/students/ | 获取列表 | |
| GET | http://127.0.0.1:8001/api/students/1/ | 获取单个记录 | |
| GET | http://127.0.0.1:8001/api/students/ | ?id__in=2,3&name__icontains= | 自定义过滤查询 |
| POST | http://127.0.0.1:8001/api/students/ | { 'name': 'Stu-01'} | 新增单条记录 |
| POST | http://127.0.0.1:8001/api/students/ | [{ 'name': 'Stu-02'},{ 'name': 'Stu-03'}] | 批量新增 |
| PUT/PATCH | http://127.0.0.1:8001/api/students/ | { 'id': 1, 'name': 'Stu-01-ch'} | 单个更新 |
| PUT/PATCH | http://127.0.0.1:8001/api/students/ | [{ 'id': 2, 'name': 'Stu-02-ch'},{ 'id': 3, 'name': 'Stu-03-ch'}] | 批量更新 |
| DELETE | http://127.0.0.1:8001/api/students/1/ | 单个删除 | |
| DELETE | http://127.0.0.1:8001/api/students/ | ?id__in=2,3 | 批量删除 |
知识点说明：
1、使用 restframework-bulk批量删除时，是通过 allow_bulk_destroy这样的hook来判断要删除的结果是否是经过过滤的 qs is not filtered；
1.1、所以必须定义过滤才可以，不然执行delete会不会删除
class StudentViewSet(BulkModelViewSet):
serializer_class = StudentSerializer
queryset = Student.objects.all()
# 注意注释这两个就不会删除，接口直接报 400 错误
# filter_backends = (DjangoFilterBackend, )
# filter_class = StudentFilterSet
def allow_bulk_destroy(self, qs, filtered):
print("here: qs-> ", qs, "\n filtered-> ", filtered)
return qs is not filtered
1.2、allow_bulk_destroy返回True 代表删除，返回 False 代表不删除，如果一旦没有上面的过滤限制，然后这个函数又直接返回True， 那就悲剧了.... 这个model的所有数据都被删除了...
class StudentViewSet(BulkModelViewSet):
serializer_class = StudentSerializer
queryset = Student.objects.all()
# 注意注释这两个就不会删除，接口直接报 400 错误
# filter_backends = (DjangoFilterBackend, )
# filter_class = StudentFilterSet
def allow_bulk_destroy(self, qs, filtered):
# print("here: qs-> ", qs, "\n filtered-> ", filtered)
# return qs is not filtered
# 直接返回True 是灾难的
return True
2、还记得刚开始的User模型么，除了批量更新之外所有的操作都是没有问题，为什么单独 批量更新就问题呢？ 报错如下，提示没有pk属性，但是实际上该表是有id作为主键的, id对应的就是 pk
djang-bulk-01.png
django-bulk-02.png
明明和Student的代码一模一样。
一模一样吗？ 当然存在差异，就是User模型中的name字段多了个 unique=True
去掉这个属性之后，再次执行批量更新操作没有任何问题。 但是最终未能找到问题的根源是什么？ 大家有知道原因的，欢迎指导~
Refer:
1、https://zhuanlan.zhihu.com/p/369898862
感兴趣的可以搜索微信公众号 全栈运维，或者添加QQ 1209755822 备注技术交流