深度解析Django REST Framework 批量操作
更新時間：2021年05月12日 09:34:13 作者：大江東流
這篇文章主要介紹了深度解析Django REST Framework批量操作，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
我們都知道Django rest framework這個庫，默認(rèn)只支持批量查看，不支持批量更新（局部或整體）和批量刪除。
下面我們來討論這個問題，看看如何實現(xiàn)批量更新和刪除操作。
DRF基本情況
我們以下面的代碼作為例子：
models：
from django.db import models
# Create your models here.
class Classroom(models.Model):
location = models.CharField(max_length=128)
def __str__(self):
return self.location
class Student(models.Model):
name = models.CharField(max_length=32)
classroom = models.ForeignKey(Classroom, on_delete=models.CASCADE)
def __str__(self):
return self.name
serializers:
from .models import Classroom, Student
from rest_framework.serializers import ModelSerializer
class StudentSerializer(ModelSerializer):
class Meta:
model = Student
fields = "__all__"
class ClassroomSerializer(ModelSerializer):
class Meta:
model = Classroom
fields = "__all__"
views:
from rest_framework.viewsets import ModelViewSet
from .serializers import StudentSerializer, ClassroomSerializer
from .models import Student, Classroom
class StudentViewSet(ModelViewSet):
serializer_class = StudentSerializer
queryset = Student.objects.all()
class ClassroomViewSet(ModelViewSet):
serializer_class = ClassroomSerializer
queryset = Classroom.objects.all()
myapp/urls:
from rest_framework.routers import DefaultRouter from .views import StudentViewSet, ClassroomViewSet router = DefaultRouter() router.register(r'students', StudentViewSet) router.register(r'classrooms', ClassroomViewSet) urlpatterns = router.urls
根urls：
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('myapp.urls')),
]
這是一個相當(dāng)簡單而又經(jīng)典的場景。其中的Classroom模型不是重點，只是為了豐富元素，展示一般場景。
創(chuàng)建數(shù)據(jù)：
- 通過post方法訪問127.0.0.1:8000/classrooms/創(chuàng)建一些教室數(shù)據(jù)。
- 通過post方法訪問127.0.0.1:8000/students/創(chuàng)建一些學(xué)生數(shù)據(jù)。
可以很清楚地看到DRF默認(rèn)：
- 通過GET
/students/查看所有的學(xué)生 - 通過GET
/students/1/查看id為1的學(xué)生 - 通過POST
/students/攜帶一個數(shù)據(jù)字典，創(chuàng)建單個學(xué)生 - 通過PUT
/students/1/整體更新id為1的學(xué)生信息 - 通過PATCH
/students/1/局部更新id為1的學(xué)生信息 - 通過DELETE
/students/1/刪除id為1的學(xué)生
沒有批量更新和刪除的接口。
并且當(dāng)我們嘗試向/students/，POST一個攜帶了多個數(shù)據(jù)字典的列表對象時，比如下面的數(shù)據(jù)：
[
{
"name": "alex",
"classroom": 1
},
{
"name": "mary",
"classroom": 2
},
{
"name": "kk",
"classroom": 3
}
]
反饋給我們的如下圖所示：
錯誤提示：非法的數(shù)據(jù)，期望一個字典，但你提供了一個列表。
至于嘗試向更新和刪除接口提供多個對象的id，同樣無法操作。
可見在DRF中，默認(rèn)情況下，只能批量查看，不能批量創(chuàng)建、修改和刪除。
自定義批量操作
現(xiàn)實中，難免有批量的創(chuàng)建、修改和刪除需求。那怎么辦呢？只能自己寫代碼實現(xiàn)了。
下面是初學(xué)者隨便寫的代碼，未考慮數(shù)據(jù)合法性、安全性、可擴(kuò)展性等等，僅僅是最基礎(chǔ)的實現(xiàn)了功能而已：
批量創(chuàng)建
class StudentViewSet(ModelViewSet):
serializer_class = StudentSerializer
queryset = Student.objects.all()
# 通過many=True直接改造原有的API，使其可以批量創(chuàng)建
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)
DRF本身提供了一個ListSerializer，這個類是實現(xiàn)批量創(chuàng)建的核心關(guān)鍵。
當(dāng)我們在實例化一個序列化器的時候，有一個關(guān)鍵字參數(shù)many，如果將它設(shè)置為True，就表示我們要進(jìn)行批量操作，DRF在后臺會自動使用ListSerializer來替代默認(rèn)的Serializer。
所以，實現(xiàn)批量創(chuàng)建的核心就是如何將many參數(shù)添加進(jìn)去。
這里，我們重寫了get_serializer方法，通過if isinstance(self.request.data, list):語句，分析前端發(fā)送過來的數(shù)據(jù)到底是個字典還是個列表。如果是個字典，表示這是創(chuàng)建單個對象，如果是個列表，表示是創(chuàng)建批量對象。
讓我們測試一下。首先，依然可以正常地創(chuàng)建單個對象。
然后如下面的方式，通過POST 往/students/發(fā)送一個列表：
這里有個坑，可能會碰到AttributeError: 'ListSerializer' object has no attribute 'fields'錯誤。
這是響應(yīng)數(shù)據(jù)格式的問題。沒關(guān)系。刷新頁面即可。
也可以在POSTMAN中進(jìn)行測試，就不會出現(xiàn)這個問題。
批量刪除
先上代碼：
from rest_framework.viewsets import ModelViewSet
from .serializers import StudentSerializer, ClassroomSerializer
from .models import Student, Classroom
from rest_framework import status
from rest_framework.response import Response
from django.shortcuts import get_object_or_404
from rest_framework.decorators import action
class StudentViewSet(ModelViewSet):
serializer_class = StudentSerializer
queryset = Student.objects.all()
# 通過many=True直接改造原有的API，使其可以批量創(chuàng)建
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)
# 新增一個批量刪除的API。刪除單個對象，依然建議使用原API
# 通過DELETE訪問訪問url domain.com/students/multiple_delete/?pks=4,5
@action(methods=['delete'], detail=False)
def multiple_delete(self, request, *args, **kwargs):
# 獲取要刪除的對象們的主鍵值
pks = request.query_params.get('pks', None)
if not pks:
return Response(status=status.HTTP_404_NOT_FOUND)
for pk in pks.split(','):
get_object_or_404(Student, id=int(pk)).delete()
return Response(status=status.HTTP_204_NO_CONTENT)
要注意，原DRF是通過DELETE/students/1/刪除id為1的學(xué)生。
那么如果我想批量刪除id為1,3,5的三個數(shù)據(jù)怎么辦？
反正肯定是不能往/students/1/這樣的url發(fā)送請求的。
那么是構(gòu)造一條這樣的url嗎？/students/1,3,5/?或者/students/?pk=1,3,5
還是往/students/發(fā)送json數(shù)據(jù)[1,3,5]?
這里，我采用/students/multiple_delete/?pks=1,3,5的形式。
這樣，它創(chuàng)建了一條新的接口，既避開了/students/這個接口，也能通過url發(fā)送參數(shù)。
由于我們的視圖繼承的是ModelViewSet，所以需要通過action裝飾器，增加一個同名的multiple_delete()方法。
為了防止id和Python內(nèi)置的id函數(shù)沖突。我們這里使用pks作為url的參數(shù)名。
通過一個for循環(huán)，分割逗號獲取批量主鍵值。
通過主鍵值去數(shù)據(jù)庫中查找對象，然后刪除。（這里只是實現(xiàn)功能，未處理異常）
下面，最好在POSTMAN中測試一下：
注意請求是DELETE /students/multiple_delete/?pks=4,5
再訪問/students/,可以看到相關(guān)數(shù)據(jù)確實被刪除了。
批量更新
代碼如下：
from rest_framework.viewsets import ModelViewSet
from .serializers import StudentSerializer, ClassroomSerializer
from .models import Student, Classroom
from rest_framework import status
from rest_framework.response import Response
from django.shortcuts import get_object_or_404
from rest_framework.decorators import action
class StudentViewSet(ModelViewSet):
serializer_class = StudentSerializer
queryset = Student.objects.all()
# 通過many=True直接改造原有的API，使其可以批量創(chuàng)建
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)
# 新增一個批量刪除的API。刪除單個對象，依然建議使用原API
# 通過DELETE訪問訪問url domain.com/students/multiple_delete/?pks=4,5
@action(methods=['delete'], detail=False)
def multiple_delete(self, request, *args, **kwargs):
pks = request.query_params.get('pks', None)
if not pks:
return Response(status=status.HTTP_404_NOT_FOUND)
for pk in pks.split(','):
get_object_or_404(Student, id=int(pk)).delete()
return Response(status=status.HTTP_204_NO_CONTENT)
# 新增一個批量修改的API。更新單個對象，依然建議使用原API
# 通過PUT方法訪問url domain.com/students/multiple_update/
# 發(fā)送json格式的數(shù)據(jù)，數(shù)據(jù)是個列表，列表中的每一項是個字典，每個字典是一個實例
@action(methods=['put'], detail=False)
def multiple_update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', False)
instances = [] # 這個變量是用于保存修改過后的對象，返回給前端
for item in request.data: # 遍歷列表中的每個對象字典
instance = get_object_or_404(Student, id=int(item['id'])) # 通過ORM查找實例
# 構(gòu)造序列化對象，注意partial=True表示允許局部更新
# 由于我們前面重寫了get_serializer方法，進(jìn)行了many=True的判斷。
# 但此處不需要many=True的判斷，所以必須調(diào)用父類的get_serializer方法
serializer = super().get_serializer(instance, data=item, partial=partial)
serializer.is_valid(raise_exception=True)
serializer.save()
instances.append(serializer.data) # 將數(shù)據(jù)添加到列表中
return Response(instances)
更新和刪除不同的地方在于，它在提供主鍵值的同時，還需要提供新的字段值。
所以，這里我們將主鍵值放在json數(shù)據(jù)中，而不是作為url的參數(shù)。
請仔細(xì)閱讀上面的代碼注釋。
這里有個小技巧，其實可以根據(jù)HTTP的PUT和PATCH的不同，靈活設(shè)定partial參數(shù)的值。
另外，要注意的對get_serializer()方法的處理。
下面測試一下。在POSTMAN中通過PUT方法，訪問/students/multiple_update/，并攜帶如下的json數(shù)據(jù)：
[
{
"id":2,
"name":"tom",
"classroom":3
},
{
"id":3,
"name":"jack",
"classroom":2
}
]
上面是整體更新，局部更新也是可以的。
djangorestframework-bulk
前面，我們通過蹩腳的代碼，實現(xiàn)了最基礎(chǔ)的批量增刪改查。
但問題太多，不夠優(yōu)雅清晰、異常未處理、邊界未考慮等等，實在是太爛。
事實上，有這么個djangorestframework-bulk庫，已經(jīng)高水平地實現(xiàn)了我們的需求。
這個庫非常簡單，核心的其實只有3個模塊，核心代碼也就300行左右，非常短小精干，建議精讀它的源碼，肯定會有收獲。
官網(wǎng)：https://pypi.org/project/djangorestframework-bulk/
github：https://github.com/miki725/django-rest-framework-bulk
最后更新：2015年4月
最后版本：0.2.1
它有兩個序列化器的版本：drf2\drf3。我們用drf3。
依賴
- Python > = 2.7
- 的Django > = 1.3
- Django REST framework > = 3.0.0
安裝
使用pip：
$ pip install djangorestframework-bulk
范例
視圖
我們注釋掉前面章節(jié)中的代碼，編寫下面的代碼，使用bulk庫來實現(xiàn)批量操作。
bulk中的views（和mixins）非常類似drf原生的generic views(和mixins)
from rest_framework.serializers import ModelSerializer
from .models import Student
from rest_framework_bulk import (
BulkListSerializer,
BulkSerializerMixin,
BulkModelViewSet
)
from rest_framework.filters import SearchFilter
# 序列化器。暫時寫在視圖模塊里
# 必須先繼承BulkSerializerMixin，由它將只讀字段id的值寫回到validated_data中，才能實現(xiàn)更新操作。
class StudentSerializer(BulkSerializerMixin, ModelSerializer):
class Meta(object):
model = Student
fields = '__all__'
# 在Meta類下面的list_serializer_class選項用來修改當(dāng)`many=True`時使用的類。
# 默認(rèn)情況下，DRF使用的是ListSerializer。
# 但是ListSerializer沒有實現(xiàn)自己的批量update方法。
# 在DRF3中如果需要批量更新對象，則需定義此屬性，并編寫ListSerializer的子類
# 所以bulk庫提供了一個BulkListSerializer類
# 它直接繼承了ListSerializer，并重寫了update方法。
list_serializer_class = BulkListSerializer
# 這條可以不寫。但實際上，批量刪除需要搭配過濾操作
filter_backends = (SearchFilter,)
# 視圖集
class StudentView(BulkModelViewSet):
queryset = Student.objects.all()
serializer_class = StudentSerializer
def allow_bulk_destroy(self, qs, filtered):
# 這里作為例子，簡單粗暴地直接允許批量刪除
return True
然后我們將自動獲得下面的功能：
# 批量查詢
GET http://127.0.0.1/students/
# 創(chuàng)建單個對象
POST http://127.0.0.1/students/
body {"field":"value","field2":"value2"} 發(fā)送字典格式的json數(shù)據(jù)
# 創(chuàng)建多個對象
POST http://127.0.0.1/students/
body [{"field":"value","field2":"value2"}] 發(fā)送列表格式的json數(shù)據(jù)
# 更新多個對象（需要提供所有字段的值）
PUT http://127.0.0.1/students/
body [{"field":"value","field2":"value2"}] 發(fā)送列表格式的json數(shù)據(jù)
# 局部更新多個對象（不需要提供所有字段的值）
PATCH http://127.0.0.1/students/
body [{"field":"value"}] 發(fā)送列表格式的json數(shù)據(jù)
# 刪除多個對象
DELETE http://127.0.0.1/students/
當(dāng)然，原生的單個對象的操作也是依然支持的！
要特別注意DELETE操作，這個例子里會直接將所有的數(shù)據(jù)全部刪除。如果你想刪除指定的一批數(shù)據(jù)，可以搭配filter_backends來過濾查詢集，使用allow_bulk_destroy方法來自定義刪除策略。
可以看到bulk庫對于RESTful的url沒有任何改動，非常優(yōu)雅，比我們上面的蹩腳方法強(qiáng)太多。
路由
路由也需要修改一下。
bulk的路由可以自動映射批量操作，它對DRF原生的DefaultRouter進(jìn)行了簡單的封裝：
from rest_framework_bulk.routes import BulkRouter from .views import StudentView router = BulkRouter() router.register(r'students', StudentView) urlpatterns = router.urls
測試
現(xiàn)在可以測試一下。下面提供一部分測試數(shù)據(jù)：
[
{
"name": "s1",
"classroom": 1
},
{
"name": "s2",
"classroom": 3
},
{
"name": "s3",
"classroom": 2
}
]
- 建議在POSTMAN中進(jìn)行測試
- PUT和PATCH要攜帶id值
- PUT要攜帶所有字段的值
- PATCH可以只攜帶要更新的字段的值
- DELETE一定要小心
可以看到功能完全實現(xiàn)，批量操作成功。
DRF3相關(guān)
DRF3的API相比DRF2具有很多變化，尤其是在序列化器上。要在DRF3上使用bulk，需要注意以下幾點：
如果你的視圖需要批量更新功能，則必須指定 list_serializer_class (也就是繼承了 BulkUpdateModelMixin時)
DRF3 從 serializer.validated_data中移除了只讀字段。所以，無法關(guān)聯(lián) validated_data 和ListSerializer ，因為缺少模型主鍵這個只讀字段。為了解決這個問題，你必須在你的序列化類中使用 BulkSerializerMixin ，這個混入類會添加模型主鍵字段到 validated_data中。默認(rèn)情況，模型主鍵是 id ，你可以通過 update_lookup_field 屬性來指定主鍵名:
class FooSerializer(BulkSerializerMixin, ModelSerializer):
class Meta(object):
model = FooModel
list_serializer_class = BulkListSerializer
update_lookup_field = 'slug'
注意事項
大多數(shù)API的每種資源都有兩個級別的url：
url(r'foo/', ...)url(r'foo/(?P<pk>\d+)/', ...)
但是，第二個URL不適用于批量操作，因為該URL直接映射到單個資源。因此，所有批量通用視圖僅適用于第一個URL。
如果只需要某個單獨的批量操作功能，bulk提供了多個通用視圖類。例如，ListBulkCreateAPIView 將僅執(zhí)行批量創(chuàng)建操作。有關(guān)可用的通用視圖類的完整列表，請訪問generics.py的源代碼。
大多數(shù)批量操作都是安全的，因為數(shù)據(jù)都是和每個對象關(guān)聯(lián)的。例如，如果您需要更新3個特定資源，則必須在PUT或PATCH的請求數(shù)據(jù)中明確的標(biāo)識出那些資源的id。唯一的例外是批量刪除，例如對第一種URL的DELETE請求可能會刪除所有資源，而無需任何特殊確認(rèn)。為了解決這個問題，批量刪除混入類中提供了一個鉤子，以確定是否應(yīng)允許執(zhí)行該批量刪除請求，也就是allow_bulk_destroy方法：
class FooView(BulkDestroyAPIView):
def allow_bulk_destroy(self, qs, filtered):
# 你的自定義業(yè)務(wù)邏輯寫在這里
# qs參數(shù)是一個查詢集，它來自self.get_queryset()
# 默認(rèn)要檢查qs是否被過濾了。
# filtered參數(shù)來自self.filter_queryset(qs)
return qs is not filtered # 最終返回True，則執(zhí)行刪除操作。返回False，則不執(zhí)行。
默認(rèn)情況下，allow_bulk_destroy方法會檢查查詢集是否已過濾，如果沒有過濾，則不允許執(zhí)行該批量刪除操作。此處的邏輯是，你知道自己在刪除哪些對象，知道自己沒有進(jìn)行全部對象的刪除操作。通俗地說就是，程序員對你的代碼在作什么，心里要有數(shù)。
源碼解讀
下圖是目錄組織結(jié)構(gòu)。分drf2和drf3，基本使用drf3。test目錄我們不關(guān)心。
核心其實就是根目錄下的5個模塊和drf3目錄。其中的models.py文件是空的，沒有代碼。
__init__.py
這個模塊就是簡單地導(dǎo)入其它模塊：
__version__ = '0.2.1'
__author__ = 'Miroslav Shubernetskiy'
try:
from .generics import * # noqa
from .mixins import * # noqa
from .serializers import * # noqa
except Exception:
pass
#NOQA 注釋的作用是告訴PEP8規(guī)范檢測工具，這個地方不需要檢測。
也可以在一個文件的第一行增加 #flake8：NOQA 來告訴規(guī)范檢測工具，這個文件不用檢查。
serializers.py
源代碼：
# 這是用于Python版本兼容，print方法和Unicode字符
from __future__ import print_function, unicode_literals
import rest_framework
if str(rest_framework.__version__).startswith('2'):
from .drf2.serializers import * # noqa
else:
from .drf3.serializers import * # noqa
就是針對不同的DRF版本，導(dǎo)入不同的serializers。
mixins.py
源代碼：
from __future__ import print_function, unicode_literals
import rest_framework
if str(rest_framework.__version__).startswith('2'):
from .drf2.mixins import * # noqa
else:
from .drf3.mixins import * # noqa
和serializers.py類似，針對不同的DRF版本，導(dǎo)入不同的mixins。
routes.py
搭配bulk的BulkModelViewSet視圖類進(jìn)行工作。
源代碼：
from __future__ import unicode_literals, print_function
import copy
from rest_framework.routers import DefaultRouter, SimpleRouter
__all__ = [
'BulkRouter',
]
class BulkRouter(DefaultRouter):
"""
將http的method映射到bulk的minxins中的處理函數(shù)
"""
routes = copy.deepcopy(SimpleRouter.routes)
routes[0].mapping.update({
'put': 'bulk_update',
'patch': 'partial_bulk_update',
'delete': 'bulk_destroy',
})
對DRF原生的DefaultRouter路由模塊進(jìn)行再次封裝，主要是修改三個HTTP方法的映射關(guān)系，將它們映射到bulk庫的mixins方法。
generics.py
這個模塊的風(fēng)格和DRF的源碼非常類似，都是各種繼承搭配出來各種類視圖。
里面混用了DRF原生的mixin和bulk自己寫的mixin。
主要是將http的method映射到視圖類中對應(yīng)的處理方法。
源代碼：
from __future__ import unicode_literals, print_function
from rest_framework import mixins
from rest_framework.generics import GenericAPIView
from rest_framework.viewsets import ModelViewSet
from . import mixins as bulk_mixins
__all__ = [
'BulkCreateAPIView',
'BulkDestroyAPIView',
'BulkModelViewSet',
'BulkUpdateAPIView',
'ListBulkCreateAPIView',
'ListBulkCreateDestroyAPIView',
'ListBulkCreateUpdateAPIView',
'ListBulkCreateUpdateDestroyAPIView',
'ListCreateBulkUpdateAPIView',
'ListCreateBulkUpdateDestroyAPIView',
]
# ################################################## #
# 下面是一些具體的視圖類。通過將mixin類與基視圖組合來提供方法處理程序。
# 基本前面繼承一堆mixins，后面繼承GenericAPIView
# ################################################## #
# 批量創(chuàng)建
class BulkCreateAPIView(bulk_mixins.BulkCreateModelMixin,
GenericAPIView):
def post(self, request, *args, **kwargs):
return self.create(request, *args, **kwargs)
# 批量更新（局部和整體）
class BulkUpdateAPIView(bulk_mixins.BulkUpdateModelMixin,
GenericAPIView):
def put(self, request, *args, **kwargs):
return self.bulk_update(request, *args, **kwargs)
def patch(self, request, *args, **kwargs):
return self.partial_bulk_update(request, *args, **kwargs)
# 批量刪除
class BulkDestroyAPIView(bulk_mixins.BulkDestroyModelMixin,
GenericAPIView):
def delete(self, request, *args, **kwargs):
return self.bulk_destroy(request, *args, **kwargs)
# 批量查看和創(chuàng)建
# 注意批量查看依然使用的是DRF原生的ListModelMixin提供的功能
class ListBulkCreateAPIView(mixins.ListModelMixin,
bulk_mixins.BulkCreateModelMixin,
GenericAPIView):
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
return self.create(request, *args, **kwargs)
# 批量查看、單個創(chuàng)建、批量更新
class ListCreateBulkUpdateAPIView(mixins.ListModelMixin,
mixins.CreateModelMixin,
bulk_mixins.BulkUpdateModelMixin,
GenericAPIView):
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
return self.create(request, *args, **kwargs)
def put(self, request, *args, **kwargs):
return self.bulk_update(request, *args, **kwargs)
def patch(self, request, *args, **kwargs):
return self.partial_bulk_update(request, *args, **kwargs)
class ListCreateBulkUpdateDestroyAPIView(mixins.ListModelMixin,
mixins.CreateModelMixin,
bulk_mixins.BulkUpdateModelMixin,
bulk_mixins.BulkDestroyModelMixin,
GenericAPIView):
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
return self.create(request, *args, **kwargs)
def put(self, request, *args, **kwargs):
return self.bulk_update(request, *args, **kwargs)
def patch(self, request, *args, **kwargs):
return self.partial_bulk_update(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
return self.bulk_destroy(request, *args, **kwargs)
class ListBulkCreateUpdateAPIView(mixins.ListModelMixin,
bulk_mixins.BulkCreateModelMixin,
bulk_mixins.BulkUpdateModelMixin,
GenericAPIView):
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
return self.create(request, *args, **kwargs)
def put(self, request, *args, **kwargs):
return self.bulk_update(request, *args, **kwargs)
def patch(self, request, *args, **kwargs):
return self.partial_bulk_update(request, *args, **kwargs)
class ListBulkCreateDestroyAPIView(mixins.ListModelMixin,
bulk_mixins.BulkCreateModelMixin,
bulk_mixins.BulkDestroyModelMixin,
GenericAPIView):
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
return self.create(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
return self.bulk_destroy(request, *args, **kwargs)
# 這個功能最全面
class ListBulkCreateUpdateDestroyAPIView(mixins.ListModelMixin,
bulk_mixins.BulkCreateModelMixin,
bulk_mixins.BulkUpdateModelMixin,
bulk_mixins.BulkDestroyModelMixin,
GenericAPIView):
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
return self.create(request, *args, **kwargs)
def put(self, request, *args, **kwargs):
return self.bulk_update(request, *args, **kwargs)
def patch(self, request, *args, **kwargs):
return self.partial_bulk_update(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
return self.bulk_destroy(request, *args, **kwargs)
# ########################################################## #
# 專門提供的一個viewset，搭配了批量創(chuàng)建、更新和刪除功能
# 它需要搭配bulk的router模塊使用。
# 如果不用這個，就用ListBulkCreateUpdateDestroyAPIView
# ########################################################## #
class BulkModelViewSet(bulk_mixins.BulkCreateModelMixin,
bulk_mixins.BulkUpdateModelMixin,
bulk_mixins.BulkDestroyModelMixin,
ModelViewSet):
pass
drf3/mixins.py
這個模塊實現(xiàn)了核心的業(yè)務(wù)邏輯。請注意閱讀源代碼中的注釋。
源代碼：
from __future__ import print_function, unicode_literals
from rest_framework import status
from rest_framework.mixins import CreateModelMixin
from rest_framework.response import Response
__all__ = [
'BulkCreateModelMixin',
'BulkDestroyModelMixin',
'BulkUpdateModelMixin',
]
class BulkCreateModelMixin(CreateModelMixin):
"""
Django REST >= 2.2.5.以后的版本多了一個many=True的參數(shù)。
通過這個參數(shù)，可以實現(xiàn)單個和批量創(chuàng)建實例的統(tǒng)一操作。
其本質(zhì)是使用DRF提供的ListSerializer類
"""
# 重寫create方法
def create(self, request, *args, **kwargs):
# 通過判斷request.data變量是列表還是字典，來區(qū)分是單體操作還是批量操作。
# 這要求我們前端發(fā)送json格式的數(shù)據(jù)時，必須定義好數(shù)據(jù)格式
bulk = isinstance(request.data, list)
if not bulk: # 如果不是批量操作，則調(diào)用父類的單體創(chuàng)建方法
return super(BulkCreateModelMixin, self).create(request, *args, **kwargs)
else: # 如果是批量操作，則添加many=True參數(shù)
serializer = self.get_serializer(data=request.data, many=True)
serializer.is_valid(raise_exception=True)
# 這里少了DRF源碼中的headers = self.get_success_headers(serializer.data)
self.perform_bulk_create(serializer)
return Response(serializer.data, status=status.HTTP_201_CREATED)
# 這是個鉤子方法
def perform_bulk_create(self, serializer):
return self.perform_create(serializer)
class BulkUpdateModelMixin(object):
"""
同樣是通過many=True參數(shù)來實現(xiàn)批量更新
"""
# 重寫單個對象的獲取
def get_object(self):
lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
# 這個if執(zhí)行的是父類的操作
if lookup_url_kwarg in self.kwargs:
return super(BulkUpdateModelMixin, self).get_object()
# 如果沒有攜帶id，則直接返回，什么都不做。
# 也就是 PUT http://127.0.0.1/students/
# 和 PUT http://127.0.0.1/students/1/的區(qū)別
return
# 核心的更新方法
def bulk_update(self, request, *args, **kwargs):
# 先看看是PUT還是PATCH
partial = kwargs.pop('partial', False)
# 限制只對過濾后的查詢集進(jìn)行更新
# 下面的代碼就是基本的DRF反序列化套路
# 核心是instances是個過濾集，many指定為True，partial根據(jù)方法來變
# 這里的邏輯是將單體更新當(dāng)作只有一個元素的列表來更新（也就是批量為1）。
serializer = self.get_serializer(
self.filter_queryset(self.get_queryset()),
data=request.data,
many=True,
partial=partial,
)
serializer.is_valid(raise_exception=True)
self.perform_bulk_update(serializer)
return Response(serializer.data, status=status.HTTP_200_OK)
# 如果是PATCH方法，則手動添加partial=True參數(shù)，表示局部更新
# 實際執(zhí)行的方法和整體更新一樣，都是調(diào)用bulk_update方法
def partial_bulk_update(self, request, *args, **kwargs):
kwargs['partial'] = True
return self.bulk_update(request, *args, **kwargs)
# 鉤子方法
def perform_update(self, serializer):
serializer.save()
# 鉤子方法
def perform_bulk_update(self, serializer):
return self.perform_update(serializer)
# 刪除操作
class BulkDestroyModelMixin(object):
"""
用于刪除模型實例
"""
def allow_bulk_destroy(self, qs, filtered):
"""
這是一個鉤子，用于確保批量刪除操作是安全的。
默認(rèn)情況下，它會檢查刪除操作是否在一個過濾集上進(jìn)行，不能對原始查詢集也就是qs進(jìn)行刪除。
最終的返回值是布爾值，如果返回True，表示允許刪除，否則拒絕。
源碼這里是簡單地比較了qs和filtered是否相同，你可以自定義判斷邏輯。
刪除操作可以配合過濾后端。
"""
return qs is not filtered
# DELETE方法將被轉(zhuǎn)發(fā)到這里
def bulk_destroy(self, request, *args, **kwargs):
# 首先，獲取查詢集
qs = self.get_queryset()
# 獲取過濾集
filtered = self.filter_queryset(qs)
# 調(diào)用allow_bulk_destroy方法，判斷是否允許該刪除操作
if not self.allow_bulk_destroy(qs, filtered):
# 如果不允許，返回400響應(yīng)，錯誤的請求
return Response(status=status.HTTP_400_BAD_REQUEST)
# 否則對過濾集執(zhí)行批量刪除操作
self.perform_bulk_destroy(filtered)
return Response(status=status.HTTP_204_NO_CONTENT)
# 這個刪除方法，其實就是ORM的delete方法
# 之所以設(shè)置這個方法，其實就是個鉤子，方便我們自定義
def perform_destroy(self, instance):
instance.delete()
# 批量刪除很簡單，就是遍歷過濾集，逐個刪除
def perform_bulk_destroy(self, objects):
for obj in objects:
self.perform_destroy(obj)
drf3/serializers.py
這個模塊只有兩個類，它們提供了2個功能。
- BulkSerializerMixin：往驗證后的數(shù)據(jù)中添加主鍵字段的值
- BulkListSerializer：提供批量更新的update方法
源代碼：
from __future__ import print_function, unicode_literals
import inspect # Python內(nèi)置模塊。從活動的Python對象獲取有用的信息。
from rest_framework.exceptions import ValidationError
from rest_framework.serializers import ListSerializer
__all__ = [
'BulkListSerializer',
'BulkSerializerMixin',
]
# 由于DRF源碼在默認(rèn)情況下，會將只讀字段的值去掉，所以id主鍵值不會出現(xiàn)在validated_data中
# 因為我們現(xiàn)在需要批量更新對象，url中也沒有攜帶對象的id，所以我們需要手動將id的值添加回去。
class BulkSerializerMixin(object):
# 由外部數(shù)據(jù)轉(zhuǎn)換為Python內(nèi)部字典
def to_internal_value(self, data):
# 先調(diào)用父類的方法，獲得返回值
ret = super(BulkSerializerMixin, self).to_internal_value(data)
# 去Meta元類中看看，有沒有指定'update_lookup_field'屬性，如果沒有，默認(rèn)使用id
# 這本質(zhì)就是個鉤子，允許我們自定義主鍵字段
id_attr = getattr(self.Meta, 'update_lookup_field', 'id')
# 獲取當(dāng)前請求的類型
request_method = getattr(getattr(self.context.get('view'), 'request'), 'method', '')
# 如果下面的三個條件都滿足：
# self.root是BulkListSerializer的實例
# id_attr變量不為空
# 請求的方法是'PUT'或'PATCH'
# 那么執(zhí)行if語句中的代碼
if all((isinstance(self.root, BulkListSerializer),
id_attr,
request_method in ('PUT', 'PATCH'))):
# 拿到id字段的句柄
id_field = self.fields[id_attr]
# 拿到字段的值
id_value = id_field.get_value(data)
# 為ret追加鍵值對
ret[id_attr] = id_value
return ret
# 這個類主要是在ListSerializer基礎(chǔ)上重寫的update邏輯，實現(xiàn)批量操作
class BulkListSerializer(ListSerializer):
# 指定用于更新的查詢字段為id
update_lookup_field = 'id'
def update(self, queryset, all_validated_data):
# 先看看有沒有指定用于查詢的字段
id_attr = getattr(self.child.Meta, 'update_lookup_field', 'id')
# 通過id去獲取所有的鍵值對
# 下面是一個字典推導(dǎo)式
all_validated_data_by_id = {
i.pop(id_attr): i
for i in all_validated_data
}
# 對數(shù)據(jù)類型做判斷
if not all((bool(i) and not inspect.isclass(i)
for i in all_validated_data_by_id.keys())):
raise ValidationError('')
# 使用ORM從查詢集中過濾出那些需要更新的模型實例
# 比如id__in=[1,3,4]
objects_to_update = queryset.filter(**{
'{}__in'.format(id_attr): all_validated_data_by_id.keys(),
})
# 如果過濾出來的模型實例數(shù)量和用于更新的數(shù)據(jù)數(shù)量不一致，彈出異常
if len(all_validated_data_by_id) != objects_to_update.count():
raise ValidationError('Could not find all objects to update.')
# 準(zhǔn)備一個空列表，用于保存將要被更新的實例
updated_objects = []
# 循環(huán)每個實例
for obj in objects_to_update:
obj_id = getattr(obj, id_attr)
obj_validated_data = all_validated_data_by_id.get(obj_id)
# 使用模型序列化器的update方法進(jìn)行實際的更新動作，以防update方法在別的地方被覆蓋
updated_objects.append(self.child.update(obj, obj_validated_data))
return updated_objects
到此這篇關(guān)于深度解析Django REST Framework 批量操作的文章就介紹到這了,更多相關(guān)Django REST Framework批量操作內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
Django事務(wù)transaction的使用以及多個裝飾器問題
這篇文章主要介紹了Django事務(wù)transaction的使用以及多個裝飾器問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-08-08
這篇文章主要介紹了django反向解析URL和URL命名空間，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-06-06
python SQLAlchemy 數(shù)據(jù)庫連接池的實現(xiàn)
SSQLAlchemy提供了強(qiáng)大的連接池和連接管理功能,可以有效地管理數(shù)據(jù)庫連接,本文主要介紹了python SQLAlchemy 數(shù)據(jù)庫連接池的實現(xiàn),具有一定的參考價值,感興趣的可以了解一下2025-03-03
python使用pil進(jìn)行圖像處理(等比例壓縮、裁剪)實例代碼
這篇文章主要介紹了python使用pil進(jìn)行圖像處理(等比例壓縮、裁剪)實例代碼，首先介紹了pil的相關(guān)內(nèi)容，然后分享了實例代碼，具有一定借鑒價值，需要的朋友可以參考下。2017-12-12
Python word2vec訓(xùn)練詞向量實例分析講解
這篇文章主要介紹了Python word2vec訓(xùn)練詞向量實例分析，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)吧2022-12-12
這篇文章主要介紹了Python高級文件操作之shutil庫詳解,文中有非常詳細(xì)的代碼示例,對正在學(xué)習(xí)python的小伙伴們有很大的幫助,需要的朋友可以參考下2021-05-05
我們可以使用Template 設(shè)置我們的網(wǎng)頁，同時，一個完美的網(wǎng)頁需要css，js，image 等靜態(tài)文件的支持,這篇文章主要介紹了django中靜態(tài)文件配置static的方法,感興趣的小伙伴們可以參考一下2018-05-05
這篇文章主要介紹了Python break語句的作用、使用方法,需要的朋友可以參考下2014-03-03
本教程將詳細(xì)介紹Python中的字符串對齊方法以及字符串判斷方法,這些方法在文本處理、格式化輸出和字符串匹配中非常實用,無論你是Python初學(xué)者還是想要鞏固基礎(chǔ)知識的程序員,這篇教程都能幫助你全面理解這些操作,需要的朋友可以參考下2025-04-04
Python中matplotlib庫安裝失敗的經(jīng)驗總結(jié)(附pycharm配置anaconda)
最近根據(jù)領(lǐng)導(dǎo)布置的學(xué)習(xí)任務(wù),開始學(xué)習(xí)python中的matplotlib,朋友告訴我這個很簡單,然而剛踏入安裝的門檻,就遇到了安裝不成功的問題,下面這篇文章主要給大家介紹了關(guān)于Python中matplotlib庫安裝失敗的經(jīng)驗總結(jié),需要的朋友可以參考下2022-08-08