序列化类ser.py

from rest_framework import serializers
from index import models
class BookListSerializer(serializers.ListSerializer):
    def update(self, instance, validated_data):
        #insatnce是数据对象，validated_data修改的数据
        #根据新增多条数据来修改。
        #self.child是我们自己写BookModelSerializer对象，内部提供了修改单个的update方法，
        #想办法利用修改单个的方法，循环将数据给该方法，就可以实现多条数据修改
        #要更新，数据肯定是清洗后的数据，
        return [
            self.child.update(instance=attrs,validated_data=validated_data[i]) for i,attrs in enumerate(instance)
        ]

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        list_serializer_class = BookListSerializer
        # 指定many=True后，先到这个类去执行，这个类我们只重写update方法，其他的方法都是由父类ListSerialiser去实现的。
        model = models.Book
        fields = ('name','price','authors','publish','publish_name','author_name')
        extra_kwargs = {
            'publish_name':{'read_only':True},
            'publish':{'write_only':True},
            'author_name': {'read_only': True},
            'authors': {'write_only': True},

        }

模型类：models.py

from django.db import models

# Create your models here.
class BaseModel(models.Model):
    # 是否删除
    is_delete = models.BooleanField(default=False)
    # 注册时间，首次登录，插入当前时间，后面基本不会变
    create_time = models.DateTimeField(auto_now_add=True)
    # 只要更新，就插入当前时间
    last_update_time = models.DateTimeField(auto_now=True)
    class Meta:
        #联合索引、联合唯一（ip和端口）
        abstract=True
        #抽象表，不然每个继承的它的类都会生成一个表



class Book(BaseModel):
    id= models.AutoField(primary_key=True)
    name = models.CharField(max_length=32,db_index=True)
    price = models.DecimalField(max_digits=6,decimal_places=2)
    #一对多，关联字段写在多的一方
    publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
    #多对多，跟作者，关联字段写在被查多的表上
    authors = models.ManyToManyField(to='Author',db_constraint=False)
    class Meta:
        verbose_name_plural='书表'
    def __str__(self):
        return self.name
    @property
    def publish_name(self):
        return self.publish.name
    def author_name(self):
        author_lis = self.authors.all()
        return [{'name':author.name,'sex':author.get_sex_display()} for author in author_lis]


class Publish(BaseModel):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=50)
    class Meta:
        verbose_name_plural='出版社表'
    def __str__(self):
        return self.name

class Author(BaseModel):
    name = models.CharField(max_length=32)
    sex = models.IntegerField(choices=((1,'男'),(2,'女')),default=1)
    #一对一关系 OneToOneField本质是外键+unique，这种设置级联删除
    authordetail = models.OneToOneField(to='AuthorDetail',on_delete=models.CASCADE)
    class Meta:
        verbose_name_plural='用户表'
    def __str__(self):
        return self.name

class AuthorDetail(BaseModel):
    mobile = models.CharField(max_length=11)
    class Meta:
        verbose_name_plural='用户详情表'

视图：views.py

from django.shortcuts import render
from rest_framework.views import APIView
# Create your views here.
from  index import models
from index.ser import  BookModelSerializer
from utils.response import Sresponse
class BookAPIView(APIView):
    #单个查询和批量查询
    def get(self,request,*args,**kwargs):
        pk = kwargs.get('pk',None)
        if pk:
            book = models.Book.objects.filter(id=pk,is_delete=False).first()
            ser = BookModelSerializer(instance=book)
            return Sresponse(msg='查询成功',data=ser.data)
        else:
            book_list = models.Book.objects.filter(is_delete=False)
            ser_lis = BookModelSerializer(instance=book_list,many=True)
            return Sresponse(msg='查询所有数据',data=ser_lis.data)
    #增：增一条、增多条。
    def post(self,request,*args,**kwargs):
       op_obj = request.data
       if isinstance(op_obj,dict):
           #如果是字典的对象，说明是增一条数据
            ser  = BookModelSerializer(data=op_obj)
            ser.is_valid(raise_exception=True)#配置了全局异常处理就可以设置这个
            ser.save()#这样才是真的保存到数据库中
            return Sresponse(msg='增数据成功',data=ser.data)
       elif isinstance(op_obj,list):
           #如果是列表的对象，说明是批量增加，for循环上面的的
           #方法二、many=True，重写ListSerializer的update方法
           ser = BookModelSerializer(data=op_obj,many=True)
           ser.is_valid(raise_exception=True)  # 配置了全局异常处理就可以设置这个
           ser.save()  # 这样才是真的保存到数据库中
           return Sresponse(msg='增多条数据成功', data=ser.data)
    #单个修改和批量修改
    def put(self,request,*args,**kwargs):
        if isinstance(request.data,dict):
            book = models.Book.objects.filter(id=request.data.get('id')).first()
            ser = BookModelSerializer(instance=book,data=request.data)
            ser.is_valid(raise_exception=True)
            ser.save()
            return Sresponse(msg='修改成功',data=ser.data)
        elif isinstance(request.data,list):
            #拿到的前端的数据[{'id':,'name':,'price':}]
            #[书对象1，书对象2...], [{'name':,'price':},]
            # ser_lis=[]
            # for data in request.data:
            #     pk = data.get('id')
            #     obj = models.Book.objects.filter(id=pk).first()
            #     ser = BookModelSerializer(instance=obj,data=data)
            #     ser.is_valid(raise_exception=True)
            #     ser.save()
            #     ser_lis.append(ser.data)
            # return Sresponse(msg='批量修改成功',data=ser_lis)
            book_list=[]
            data_list=[]
            for item in request.data:
                pk=item.pop('id')
                book = models.Book.objects.filter(id=pk).first()
                book_list.append(book)
                data_list.append(item)
            book_ser = BookModelSerializer(instance=book_list,data=data_list,many=True)
            book_ser.is_valid(raise_exception=True)
            book_ser.save()#走自己写的update方法
            return Sresponse(book_ser.data)

    def delete(self,request,*args,**kwargs):
        pk = kwargs.get('pk',None)
        pk_lis=[]
        if pk:
           pk_lis.append(pk)
           #批量删， 规定前端的数据格式 {'pks':[1,2,3]}
        elif 'pks' in request.data:
            pk_lis=request.data.get('pks')
            print(757575)
        if pk_lis:
            num = models.Book.objects.filter(id__in=pk_lis,is_delete=False).update(is_delete=True)
            if num:
                dic={'del_number':num}
                return Sresponse(msg='删除数据成功',data=dic)
            else:
                return Sresponse(msg='该数据不存在，无法进行删除',code=404)
        else:
            return Sresponse(msg='请求方式错误。',code=400)

路由：urls.py

urlpatterns = [
    path('api/book/<int:pk>/',views.BookAPIView.as_view()),
    path('api/book/', views.BookAPIView.as_view()),
]