前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
工具
TVP
最新优惠活动
文章/答案/技术大牛
发布
首页
学习
活动
专区
工具
TVP最新优惠活动
返回腾讯云官网
社区首页 >专栏 >Python进阶40-drf框架(二)

Python进阶40-drf框架(二)

作者头像
DriverZeng
发布于 2022-09-26 13:01:02
1.9K0
发布于 2022-09-26 13:01:02
举报
文章被收录于专栏：Linux云计算及前后端开发

-曾老湿, 江湖人称曾老大。

-多年互联网运维工作经验，曾负责过大规模集群架构自动化运维管理工作。 -擅长Web集群架构与自动化运维，曾负责国内某大型金融公司运维工作。 -devops项目经理兼DBA。 -开发过一套自动化运维平台（功能如下）： 1)整合了各个公有云API，自主创建云主机。 2)ELK自动化收集日志功能。 3)Saltstack自动化运维统一配置管理工具。 4)Git、Jenkins自动化代码上线及自动化测试平台。 5)堡垒机，连接Linux、Windows平台及日志审计。 6)SQL执行及审批流程。 7)慢查询日志分析web界面。

解析模块

为啥要配置解析模块

代码语言：javascript
复制
"""
1）drf给我们通过了多种解析数据包方式的解析类
2）我们可以通过配置来控制前台提交的哪些格式的数据后台在解析，哪些数据不解析
3）全局配置就是针对每一个视图类，局部配置就是针对指定的视图来，让它们可以按照配置规则选择性解析数据
"""
代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response


class Book(APIView):
    def get(self, request, *args, **kwargs):
        return Response('get  OK')

    def post(self, request, *args, **kwargs):
    ## url拼接参数：只有一种传参方式就是拼接参数
        print(request.query_params)
    ## 数据包参数：有三种传参方式，form-data、urlencoded、json
        print(request.data)
        return Response('post  OK')

源码入口

代码语言：javascript
复制
# APIView类的dispatch方法中
request = self.initialize_request(request, *args, **kwargs)  # 点进去

# 获取解析类
parsers=self.get_parsers(),  # 点进去

# 去类属性(局部配置) 或 配置文件(全局配置) 拿 parser_classes
return [parser() for parser in self.parser_classes]

全局配置

项目settings.py文件

代码语言：javascript
复制
REST_FRAMEWORK = {
    # 全局解析类配置
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',  # json数据包
        'rest_framework.parsers.FormParser',  # urlencoding数据包
        'rest_framework.parsers.MultiPartParser'  # form-date数据包
    ],
}

局部配置

应用views.py的具体视图类

代码语言：javascript
复制
from rest_framework.parsers import JSONParser
class Book(APIView):
    # 局部解析类配置，只要json类型的数据包才能被解析
    parser_classes = [JSONParser]
    pass

异常处理模块

为啥要定义异常模块

代码语言：javascript
复制
"""
1）所有经过drf的APIView视图类产生的异常，都可以提供异常处理方案
2）drf默认提供了异常处理方案(rest_framework.views.exception_handler)，但是处理范围有限
3）drf提供的处理方案两种，处理了返回异常现象，没处理返回None(后续就是服务器抛异常给前台)
4）自定义异常的目的就是解决drf没有处理的异常，让前台得到合理的异常信息返回，后台记录异常具体信息
"""

源码分析

代码语言：javascript
复制
# 异常模块：APIView类的dispatch方法中
response = self.handle_exception(exc)  # 点进去

# 获取处理异常的句柄(方法)
# 一层层看源码，走的是配置文件，拿到的是rest_framework.views的exception_handler
# 自定义：直接写exception_handler函数，在自己的配置文件配置EXCEPTION_HANDLER指向自己的
exception_handler = self.get_exception_handler()

# 异常处理的结果
# 自定义异常就是提供exception_handler异常处理函数，处理的目的就是让response一定有值
response = exception_handler(exc, context)

如何使用

自定义exception_handler函数如何书写实现体

代码语言：javascript
复制
# 修改自己的配置文件setting.py
REST_FRAMEWORK = {
    # 全局配置异常模块
    'EXCEPTION_HANDLER': 'api.exception.exception_handler',
}
代码语言：javascript
复制
# 1）先将异常处理交给rest_framework.views的exception_handler去处理
# 2）判断处理的结果(返回值)response，有值代表drf已经处理了，None代表需要自己处理

# 自定义异常处理文件exception，在文件中书写exception_handler函数
from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework.views import Response
from rest_framework import status
def exception_handler(exc, context):
    # drf的exception_handler做基础处理
    response = drf_exception_handler(exc, context)
    # 为空，自定义二次处理
    if response is None:
        # print(exc)
        # print(context)
        print('%s - %s - %s' % (context['view'], context['request'].method, exc))
        return Response({
            'detail': '服务器错误'
        }, status=status.HTTP_500_INTERNAL_SERVER_ERROR, exception=True)
    return response

响应模块

响应类型构造器

rest_framework.response.Response

代码语言：javascript
复制
def __init__(self, data=None, status=None,
                 template_name=None, headers=None,
                 exception=False, content_type=None):
     """
        :param data: 响应数据
        :param status: http响应状态码
        :param template_name: drf也可以渲染页面，渲染的页面模板地址（不用了解）
        :param headers: 响应头
        :param exception: 是否异常了
        :param content_type: 响应的数据格式（一般不用处理，响应头中带了，且默认是json）
    """
    pass

使用

常规实例化响应对象

代码语言：javascript
复制
# status就是解释一堆 数字 网络状态码的模块
from rest_framework import status就是解释一堆 数字 网络状态码的模块
# 一般情况下只需要返回数据，status和headers都有默认值
return Response(data={数据}, status=status.HTTP_200_OK, headers={设置的响应头})

序列化组件

序列化组件介绍

1.Serializer(偏底层) 2.ModelSerializer(重点) 3.ListModelSerializer(辅助群改)

Serializer

模型层

代码语言：javascript
复制
from django.db import models


# Create your models here.

class User(models.Model):
    GENDER_CHOICES = [
        [0, '男'],
        [1, '女'],
    ]
    name = models.CharField(max_length=64)
    pwd = models.CharField(max_length=32)
    phone = models.CharField(max_length=11,null=True,default=None)
    gender = models.IntegerField(choices=GENDER_CHOICES, default=0)
    icon = models.ImageField(upload_to='icon',default='icon/default.jpg')

    class Meta:
        db_table = 'zls_user'
        verbose_name = '用户'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name

admin注册

代码语言：javascript
复制
from django.contrib import admin
from . import models
# Register your models here.
admin.site.register(models.User)

数据库迁移

代码语言：javascript
复制
MacBook-pro:rest_ful driverzeng$ python3 manage.py makemigrations
MacBook-pro:rest_ful driverzeng$ python3 manage.py migrate

settings配置

代码语言：javascript
复制
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

图片urls配置

一定要放在主路由中

代码语言：javascript
复制
from django.conf.urls import url,include
from django.contrib import admin
from django.views.static import serve
from django.conf import settings

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^api/', include('api.urls')),
    url(r'^media/(?P<path>.*)', serve,{'document_root': settings.MEDIA_ROOT}),
]

使用admin创建用户



路由

代码语言：javascript
复制
from django.conf.urls import url
from . import views
from django.views.static import serve
from django.conf import settings

urlpatterns = [
    url(r'^users/$', views.User.as_view()),
    url(r'^users/(?P<pk>.*)/$', views.User.as_view()),
]

serializer

定义序列化的字段，有点类似于Forms组件的用法。

需要先创建一个serializer.py文件，当然文件名可以自定义，与models文件在同一级即可

代码语言：javascript
复制
# 序列化组件，为每一个model类，提供一套序列化工具类

from rest_framework import serializers


class UserSerializer(serializers.Serializer):
    name = serializers.CharField()
    phone = serializers.CharField()
    gender = serializers.IntegerField()
    icon = serializers.ImageField()

视图

代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response
from . import models
from . import serializers


class User(APIView):
    def get(self,request,*args,**kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                user_obj = models.User.objects.get(pk=pk)
                ## 用户对象不能直接作为数据返回给前台
                ## 序列化
                user_ser = serializers.UserSerializer(user_obj)
                return Response({
                    'status':0,
                    'msg': 0,
                    'results':user_ser.data
                })
            except:
                return Response({
                    'status': 2,
                    'msg': '用户不存在',
                })
        else:
            user_obj_list = models.User.objects.all()
            # 序列化多个数据
            user_ser_data = serializers.UserSerializer(user_obj_list,many=True).data
            return Response({
                'status':0,
                'msg':0,
                'results':user_ser_data
            })



自定义序列化属性

gender是0和1，看起来很别扭。

代码语言：javascript
复制
# 序列化组件，为每一个model类，提供一套序列化工具类

from rest_framework import serializers


class UserSerializer(serializers.Serializer):
    name = serializers.CharField()
    phone = serializers.CharField()
    gender = serializers.IntegerField()
    icon = serializers.ImageField()

    ## 自定义序列化属性

    gender_value = serializers.SerializerMethodField()
    def get_gender_value(self,obj):
        return obj.get_gender_display()



在序列化过程中，我们可以删除不想显示的字段，就比如说是gender，这样的话，就可以把gender_value改成gender了

代码语言：javascript
复制
# 序列化组件，为每一个model类，提供一套序列化工具类

from rest_framework import serializers


class UserSerializer(serializers.Serializer):
    name = serializers.CharField()
    phone = serializers.CharField()
    # gender = serializers.IntegerField()
    icon = serializers.ImageField()

    ## 自定义序列化属性

    gender = serializers.SerializerMethodField()

    def get_gender(self, obj):
        return obj.get_gender_display()



icon传递过去的数据，在前台发现点击无法直接看到图片，所以我们可以修改属性，传递一个完整路径

代码语言：javascript
复制
# 序列化组件，为每一个model类，提供一套序列化工具类

from rest_framework import serializers
from django.conf import settings


class UserSerializer(serializers.Serializer):
    name = serializers.CharField()
    phone = serializers.CharField()
    # gender = serializers.IntegerField()
    # icon = serializers.ImageField()

    ## 自定义序列化属性

    gender = serializers.SerializerMethodField()

    def get_gender(self, obj):
        return obj.get_gender_display()

    icon = serializers.SerializerMethodField()

    def get_icon(self, obj):
        return '%s%s%s' % (r'http://127.0.0.1:8000', settings.MEDIA_URL, str(obj.icon))



反序列化

代码语言：javascript
复制
# 序列化组件，为每一个model类，提供一套序列化工具类

from rest_framework import serializers
from django.conf import settings


class UserDescSerializer(serializers.Serializer):
    ### 1.哪些字段必须反序列化？
    ### 2.字段都有哪些安全校验？
    ### 3.哪些字段需要额外提供校验？
    ### 4.哪些字段间存在联合校验？


    #### 注意：反序列化字段，都是入库字段，不会出现自定义属性
    name = serializers.CharField()
    pwd = serializers.CharField()
    phone = serializers.CharField()
    gender = serializers.IntegerField()
代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response
from . import models
from . import serializers


class User(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                user_obj = models.User.objects.get(pk=pk)
                ## 用户对象不能直接作为数据返回给前台
                ## 序列化
                user_ser = serializers.UserSerializer(user_obj)
                return Response({
                    'status': 0,
                    'msg': 0,
                    'results': user_ser.data
                })
            except:
                return Response({
                    'status': 2,
                    'msg': '用户不存在',
                })
        else:
            user_obj_list = models.User.objects.all()
            # 序列化多个数据
            user_ser_data = serializers.UserSerializer(user_obj_list, many=True).data
            return Response({
                'status': 0,
                'msg': 0,
                'results': user_ser_data
            })

    # 暂时只考虑单增
    def post(self, request, *args, **kwargs):
        request_data = request.data
        ## 数据是否合法
        if not isinstance(request_data, dict) or request_data == {}:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.UserDescSerializer(request_data)
        return Response({
            'status': 0,
            'msg': 'OK',
        })



代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response
from . import models
from . import serializers


class User(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                user_obj = models.User.objects.get(pk=pk)
                ## 用户对象不能直接作为数据返回给前台
                ## 序列化
                user_ser = serializers.UserSerializer(user_obj)
                return Response({
                    'status': 0,
                    'msg': 0,
                    'results': user_ser.data
                })
            except:
                return Response({
                    'status': 2,
                    'msg': '用户不存在',
                })
        else:
            user_obj_list = models.User.objects.all()
            # 序列化多个数据
            user_ser_data = serializers.UserSerializer(user_obj_list, many=True).data
            return Response({
                'status': 0,
                'msg': 0,
                'results': user_ser_data
            })

    # 暂时只考虑单增
    def post(self, request, *args, **kwargs):
        request_data = request.data
        ## 数据是否合法
        if not isinstance(request_data, dict) or request_data == {}:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.UserDescSerializer(data=request_data)
        if book_ser.is_valid():
            ## 校验通过,完成新增
            book_obj = book_ser.save()
            return Response({
                'status': 0,
                'msg': 'OK',
                'results': serializers.UserSerializer(book_obj).data
            })
        else:
            ## 校验失败
            return Response({
                'status': 1,
                'msg': book_ser.errors,
            })

通过，并进入校验阶段



反序列化校验与入库

serializer.py

代码语言：javascript
复制
# 序列化组件 - 为每一个model类通过一套序列化工具类
# 序列化组件的工作方式与django froms组件非常相似
from rest_framework import serializers, exceptions
from django.conf import settings

from . import models

class UserSerializer(serializers.Serializer):
    name = serializers.CharField()
    phone = serializers.CharField()
    # 序列化提供给前台的字段个数由后台决定，可以少提供，
    # 但是提供的数据库对应的字段，名字一定要与数据库字段相同
    # sex = serializers.IntegerField()
    # icon = serializers.ImageField()

    # 自定义序列化属性
    # 属性名随意，值由固定的命名规范方法提供:
    #       get_属性名(self, 参与序列化的model对象)
    #       返回值就是自定义序列化属性的值
    gender = serializers.SerializerMethodField()
    def get_gender(self, obj):
        # choice类型的解释型值 get_字段_display() 来访问
        return obj.get_gender_display()


    icon = serializers.SerializerMethodField()
    def get_icon(self, obj):
        # settings.MEDIA_URL: 自己配置的 /media/，给后面高级序列化与视图类准备的
        # obj.icon不能直接作为数据返回，因为内容虽然是字符串，但是类型是ImageFieldFile类型
        return '%s%s%s' % (r'http://127.0.0.1:8000', settings.MEDIA_URL, str(obj.icon))


class UserDeserializer(serializers.Serializer):
    # 1) 哪些自动必须反序列化
    # 2) 字段都有哪些安全校验
    # 3) 哪些字段需要额外提供校验
    # 4) 哪些字段间存在联合校验
    # 注：反序列化字段都是用来入库的，不会出现自定义方法属性，会出现可以设置校验规则的自定义属性(re_pwd)
    name = serializers.CharField(
        max_length=64,
        min_length=3,
        error_messages={
            'max_length': '太长',
            'min_length': '太短'
        }
    )
    pwd = serializers.CharField()
    phone = serializers.CharField(required=False)
    sex = serializers.IntegerField(required=False)

    # 自定义有校验规则的反序列化字段
    re_pwd = serializers.CharField(required=True)

    # 小结：
    # name，pwd，re_pwd为必填字段
    # phone，sex为选填字段
    # 五个字段都必须提供完成的校验规则


    # 局部钩子：validate_要校验的字段名(self, 当前要校验字段的值)
    # 校验规则：校验通过返回原值，校验失败，抛出异常
    def validate_name(self, value):
        if 'g' in value.lower():  # 名字中不能出现g
            raise exceptions.ValidationError('名字非法，是个鸡贼！')
        return value

    # 全局钩子：validate(self, 系统与局部钩子校验通过的所有数据)
    # 校验规则：校验通过返回原值，校验失败，抛出异常
    def validate(self, attrs):
        pwd = attrs.get('pwd')
        re_pwd = attrs.pop('re_pwd')
        if pwd != re_pwd:
            raise exceptions.ValidationError({'pwd&re_pwd': '两次密码不一致'})
        return attrs

    # 要完成新增，需要自己重写 create 方法
    def create(self, validated_data):
        # 尽量在所有校验规则完毕之后，数据可以直接入库
        return models.User.objects.create(**validated_data)

views.py

代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response
from . import models
from . import serializers


class User(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                user_obj = models.User.objects.get(pk=pk)
                ## 用户对象不能直接作为数据返回给前台
                ## 序列化
                user_ser = serializers.UserSerializer(user_obj)
                return Response({
                    'status': 0,
                    'msg': 0,
                    'results': user_ser.data
                })
            except:
                return Response({
                    'status': 2,
                    'msg': '用户不存在',
                })
        else:
            user_obj_list = models.User.objects.all()
            # 序列化多个数据
            user_ser_data = serializers.UserSerializer(user_obj_list, many=True).data
            return Response({
                'status': 0,
                'msg': 0,
                'results': user_ser_data
            })

    # 暂时只考虑单增
    def post(self, request, *args, **kwargs):
        request_data = request.data
        ## 数据是否合法
        if not isinstance(request_data, dict) or request_data == {}:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.UserDeserializer(data=request_data)
        if book_ser.is_valid():
            ## 校验通过,完成新增
            book_obj = book_ser.save()
            print(serializers.UserSerializer(book_obj).data)
            return Response({
                'status': 0,
                'msg': 'OK',
                'results': serializers.UserSerializer(book_obj).data
            })
        else:
            ## 校验失败
            return Response({
                'status': 1,
                'msg': book_ser.errors
            })





总结

代码语言：javascript
复制
# 反序列化总结
# 1）book_ser = serializers.UserDeserializer(data=request_data)  # 数据必须赋值data
# 2）book_ser.is_valid()  # 结果为 通过 | 不通过
# 3）不通过返回 book_ser.errors 给前台，通过 book_ser.save() 得到新增的对象，再正常返回



# 序列化类总结：
    # 1）设置必填与选填序列化字段，设置校验规则
    #     # 2）为需要额外校验的字段提供局部钩子函数，如果该字段不入库，且不参与全局钩子校验，可以将值取出校验
    #     # 3）为有联合关系的字段们提供全局钩子函数，如果某些字段不入库，可以将值取出校验
    #     # 4）重写create方法，完成校验通过的数据入库工作，得到新增的对象
    

"""
1、解析模块：全局局部配置
REST_FRAMEWORK = {
    # 全局解析类配置
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        'rest_framework.parsers.MultiPartParser'
    ],
}
form rest_framework.parsers import JSONParser, FormParser
class User(APIView):
    parser_classes = [JSONParser, FormParser]
    def get():
        pass

2、异常模块
REST_FRAMEWORK = {
    # 全局配置异常模块
    'EXCEPTION_HANDLER': 'api.exception.exception_handler',
}
def exception_handler(exc, context):
    response = drf views 中的 exception_handler 先处理
    if response is None:
        通过context，exc记录详细的异常信息
        自己自定义响应对象
        return Response({
            'detail': '服务器错误'
        }, status=status.HTTP_500_INTERNAL_SERVER_ERROR, exception=True)
    return response

3、响应模块
    Response(data, status, headers, content_type, exception)

4、Serializer序列化模块
    序列化
     ser：
        1）设置需要返回给前台 那些model类有对应的 字段，不需要返回的就不用设置了
        2）设置方法字段，字段名可以随意，字段值有 get_字段名 提供，来完成一些需要处理在返回的数据
     view：
        1）从数据库中将要序列化给前台的model对象，或是对个model对象查询出来
            user_obj = models.User.objects.get(pk=pk) 或者
            user_obj_list = models.User.objects.all()
        2）将对象交给序列化处理，产生序列化对象，如果序列化的是多个数据，要设置many=True
            user_ser = serializers.UserSerializer(user_obj) 或者
            user_ser = serializers.UserSerializer(user_obj_list, many=True)
        3）序列化 对象.data 就是可以返回给前台的序列化数据
            return Response({
                'status': 0,
                'msg': 0,
                'results': user_ser.data
            })
    反序列化
     ser：
        1）设置必填与选填序列化字段，设置校验规则
        2）为需要额外校验的字段提供局部钩子函数，如果该字段不入库，且不参与全局钩子校验，可以将值取出校验
        3）为有联合关系的字段们提供全局钩子函数，如果某些字段不入库，可以将值取出校验
        4）重写create方法，完成校验通过的数据入库工作，得到新增的对象
     view：
"""

ModelSerializer

该方法是重点，完全可以代替Serializer

新建一个项目，基础环境准备

设置数据库

代码语言：javascript
复制
mysql> create database drf;
代码语言：javascript
复制
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'drf',
        "HOST":'10.0.0.51',
        "USER":'zls',
        "PASSWORD":'123',
        # 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

init中设置使用pymysql

代码语言：javascript
复制
import pymysql
pymysql.install_as_MySQLdb()

drf配置

代码语言：javascript
复制
REST_FRAMEWORK = {}

media配置

代码语言：javascript
复制
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR,'media')

时区及语言设置

代码语言：javascript
复制
LANGUAGE_CODE = 'zh-hans'

TIME_ZONE = 'Asia/Shanghai'

USE_I18N = True

USE_L10N = True

USE_TZ = False

注册drf

代码语言：javascript
复制
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'api.apps.ApiConfig',
    'rest_framework'
]

路由分发

代码语言：javascript
复制
from django.conf.urls import url,include
from django.contrib import admin
from django.views.static import serve
from django.conf import settings

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^api/', include('api.urls')),
    url(r'^media/(?P<path>.*)', serve,{'document_root':settings.MEDIA_ROOT}),
]

添加异常模块

可有可无

代码语言：javascript
复制
from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework.response import Response
from rest_framework import status
def exception_handler(exc, context):
    # drf的exception_handler做基础处理
    response = drf_exception_handler(exc, context)
    # 为空，自定义二次处理
    if response is None:
        # print(exc)
        # print(context)
        print('%s - %s - %s' % (context['view'], context['request'].method, exc))
        return Response({
            'detail': '服务器错误'
        }, status=status.HTTP_500_INTERNAL_SERVER_ERROR, exception=True)
    return response

全局配置异常模块

代码语言：javascript
复制
REST_FRAMEWORK = {
    # 全局配置异常模块
    'EXCEPTION_HANDLER': 'api.exception.exception_handler',
}

创建表模型

代码语言：javascript
复制
from django.db import models

## 图书管理系统：Book、Author、AuthorDetail、Publish
"""
Book表: name、price、img、authors、publish、is_delete、create_time
Publish表: name、address、is_delete、create_time
Author表: name、age、is_delete、create_time
AuthorDetail表: mobile, author、is_delete、create_time
"""


# 1）基表：封装公有字段
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=0)
    create_time = models.DateTimeField(auto_now_add=True)

    ## 作为基表，所以这张表不需要创建，需要指定abstract = True
    class Meta:
        abstract = True


class Book(BaseModel):
    # Book表: name、price、img、authors、publish、is_delete、create_time
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    img = models.ImageField(upload_to='img', default='img/default.jpg')
    publish = models.ForeignKey(to='Publish')
    authors = models.ManyToManyField(to='Author')

    class Meta:
        db_table = 'book'
        verbose_name = '书籍'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class Publish(BaseModel):
    # Publish表: name、address、is_delete、create_time
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)

    class Meta:
        db_table = 'publish'
        verbose_name = '出版社'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class Author(BaseModel):
    # Author表: name、age、is_delete、create_time
    name = models.CharField(max_length=64)
    age = models.SmallIntegerField()

    class Meta:
        db_table = 'author'
        verbose_name = '作者'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class AuthorDetail(BaseModel):
    # AuthorDetail表: mobile, author、is_delete、create_time
    mobile = models.CharField(max_length=11)
    author = models.OneToOneField(to='Author')

    class Meta:
        db_table = 'author_detail'
        verbose_name = '作者详情'
        verbose_name_plural = verbose_name

    def __str__(self):
        return '%s的详情' % self.author.name

数据库迁移

代码语言：javascript
复制
MacBook-pro:model_ser driverzeng$ python3 manage.py makemigrations
MacBook-pro:model_ser driverzeng$ python3 manage.py migrate



注册admin

代码语言：javascript
复制
from django.contrib import admin
from . import models
# Register your models here.
admin.site.register(models.Author)
admin.site.register(models.Publish)
admin.site.register(models.AuthorDetail)
admin.site.register(models.Book)

创建超级用户

代码语言：javascript
复制
MacBook-pro:model_ser driverzeng$ python3 manage.py createsuperuser
Username (leave blank to use 'driverzeng'): admin
Email address:
Password: admin123
Password (again): admin123
Superuser created successfully.

多表断关联

代码语言：javascript
复制
from django.db import models

## 图书管理系统：Book、Author、AuthorDetail、Publish
"""
Book表: name、price、img、authors、publish、is_delete、create_time
Publish表: name、address、is_delete、create_time
Author表: name、age、is_delete、create_time
AuthorDetail表: mobile, author、is_delete、create_time
"""


# 1）基表：封装公有字段
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=0)
    create_time = models.DateTimeField(auto_now_add=True)

    ## 作为基表，所以这张表不需要创建，需要指定abstract = True
    class Meta:
        abstract = True


class Book(BaseModel):
    # Book表: name、price、img、authors、publish、is_delete、create_time
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    img = models.ImageField(upload_to='img', default='img/default.jpg')
    publish = models.ForeignKey(to='Publish', db_constraint=False, related_name='books', on_delete=models.DO_NOTHING)
    authors = models.ManyToManyField(to='Author', db_constraint=False, related_name='books')

    class Meta:
        db_table = 'book'
        verbose_name = '书籍'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class Publish(BaseModel):
    # Publish表: name、address、is_delete、create_time
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)

    class Meta:
        db_table = 'publish'
        verbose_name = '出版社'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class Author(BaseModel):
    # Author表: name、age、is_delete、create_time
    name = models.CharField(max_length=64)
    age = models.SmallIntegerField()

    class Meta:
        db_table = 'author'
        verbose_name = '作者'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class AuthorDetail(BaseModel):
    # AuthorDetail表: mobile, author、is_delete、create_time
    mobile = models.CharField(max_length=11)
    ### db_constraint=False 不关联
    ### on_delete=models.CASCADE是级联关系，删除作者同时删除详情
    ### related_name='detail'反向查询直接使用detail
    author = models.OneToOneField(to='Author', db_constraint=False, on_delete=models.CASCADE, related_name='detail')

    class Meta:
        db_table = 'author_detail'
        verbose_name = '作者详情'
        verbose_name_plural = verbose_name

    def __str__(self):
        return '%s的详情' % self.author.name

总结：

1.db_constraint=False 不关联

2.on_delete

代码语言：javascript
复制
on_delete:
    - models.CASCADE 级联，作者删除，详情殉情
    - models.SET_NULL 置空，作者删除，详情置空
    - models.SET_DEFAULT 重置，作者删除，详情重置
    - models.DO_NOTHING 不动，作者删除，详情不动

3.related_name='detail'反向查询直接使用detail

4.多对多，manytomany 不能设置on_delete

admin造数据









接口路由

子路由

代码语言：javascript
复制
from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^books/$',views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$',views.Book.as_view()),
]

接口视图

代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response
from . import models,serializers

class Book(APIView):
    def get(self,request,*args,**kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk)
                book_data = serializers.BookModelSerializer(book_obj).data

            except:
                return Response({
                    'status':1,
                    'msg':'书籍不存在'
                })
        else:
            book_query = models.Book.objects.all()
            book_data = serializers.BookModelSerializer(book_query,many=True).data
        return Response({
            'status': 0,
            'msg': '成功',
            'results': book_data
        })

接口序列化文件

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer
from . import models


class BookModelSerializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        fields = ('name', 'price')



显示所有字段

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer
from . import models


class BookModelSerializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        # fields = ('name', 'price')
        fields = '__all__'



排除字段

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer
from . import models


class BookModelSerializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        # fields = ('name', 'price')
        ## 所有字段
        # fields = '__all__'
        ## 排除字段
        exclude = ('id','is_delete','create_time')



自动深度

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer
from . import models


class BookModelSerializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        # fields = ('name', 'price')
        ## 所有字段
        # fields = '__all__'
        ## 排除字段
        exclude = ('id','is_delete','create_time')
        ## 自动深度
        depth = 1



自定义连表字段

代码语言：javascript
复制
from django.db import models

## 图书管理系统：Book、Author、AuthorDetail、Publish
"""
Book表: name、price、img、authors、publish、is_delete、create_time
Publish表: name、address、is_delete、create_time
Author表: name、age、is_delete、create_time
AuthorDetail表: mobile, author、is_delete、create_time
"""


# 1）基表：封装公有字段
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=0)
    create_time = models.DateTimeField(auto_now_add=True)

    ## 作为基表，所以这张表不需要创建，需要指定abstract = True
    class Meta:
        abstract = True


class Book(BaseModel):
    # Book表: name、price、img、authors、publish、is_delete、create_time
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    img = models.ImageField(upload_to='img', default='img/default.jpg')
    publish = models.ForeignKey(to='Publish', db_constraint=False, related_name='books', on_delete=models.DO_NOTHING)
    authors = models.ManyToManyField(to='Author', db_constraint=False, related_name='books')

    @property
    def publish_name(self):
        return self.publish.name
代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer
from . import models


class BookModelSerializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        fields = ('name', 'price','publish_name')



多表反序列化

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer
from . import models


class BookModelSerializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        fields = ('name', 'price','img', 'publish_name')
        ## 所有字段
        # fields = '__all__'
        ## 排除字段
        # exclude = ('id','is_delete','create_time')
        ## 自动深度
        # depth = 1


class BookModelDeserializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        fields = ('name', 'price','img', 'publish', 'authors')
代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response
from . import models, serializers


class Book(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk)
                book_data = serializers.BookModelSerializer(book_obj).data

            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.all()
            book_data = serializers.BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': '成功',
            'results': book_data
        })

    def post(self, request, *args, **kwargs):
        request_data = request.data
        # if isinstance(request_data,dict):
        book_ser = serializers.BookModelDeserializer(data=request_data)
        ## 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': '成功',
            'results': serializers.BookModelSerializer(book_obj).data
        })

校验规则

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer
from . import models


class BookModelSerializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        fields = ('name', 'price', 'img', 'publish_name')
        ## 所有字段
        # fields = '__all__'
        ## 排除字段
        # exclude = ('id','is_delete','create_time')
        ## 自动深度
        # depth = 1


class BookModelDeserializer(ModelSerializer):
    class Meta:
        ## 序列化类，关联的model类
        model = models.Book
        ## 参与序列化的字段
        fields = ('name', 'price', 'img', 'publish', 'authors')

        # extra_kwargs用来完成反序列化字段的系统校验规则
        extra_kwargs = {
            'img': {
                'required': True,
                'error_messages': {
                    'required': '必填项',
                }
            }
        }



写数据库，无需重写create，ModelSerializer已经实现，所以我们直接写局部钩子和全局钩子即可。

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer, SerializerMethodField
from rest_framework.exceptions import ValidationError
from . import models


class PublishModelSerializer(ModelSerializer):
    class Meta:
        model = models.Publish
        fields = ('name', 'address')

class BookModelSerializer(ModelSerializer):
    # 了解: 该方式设置的序列化字段，必须在fields中声明
    # publish_address = SerializerMethodField()
    # def get_publish_address(self, obj):
    #     return obj.publish.address

    # 自定义连表深度 - 子序列化方式
    publish = PublishModelSerializer()

    class Meta:
        # 序列化类关联的model类
        model = models.Book
        # 参与序列化的字段
        fields = ('name', 'price', 'img', 'author_list', 'publish')

        # 了解知识点
        # 所有字段
        # fields = '__all__'
        # 与fields不共存，exclude排除哪些字段
        # exclude = ('id', 'is_delete', 'create_time')
        # 自动连表深度
        # depth = 1

class BookModelDeserializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'publish', 'authors')
        # extra_kwargs 用来完成反序列化字段的 系统校验规则
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            }
        }

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

    # ModelSerializer类已经帮我们实现了 create 与 update 方法
代码语言：javascript
复制
from django.db import models

# 图书管理系统：Book、Author、AuthorDetail、Publish
"""
Book表: name、price、img、authors、publish、is_delete、create_time
Publish表: name、address、is_delete、create_time
Author表: name、age、is_delete、create_time
AuthorDetail表: mobile, author、is_delete、create_time
"""

# 1) 基表
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)
    create_time = models.DateTimeField(auto_now_add=True)

    # 作为基表的Model不能在数据库中形成对应的表，设置 abstract = True
    class Meta:
        abstract = True


class Book(BaseModel):
    """name、price、img、authors、publish、is_delete、create_time"""
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    img = models.ImageField(upload_to='img', default='img/default.jpg')
    publish = models.ForeignKey(
        to='Publish',
        db_constraint=False,
        related_name='books',
        on_delete=models.DO_NOTHING,
    )
    authors = models.ManyToManyField(
        to='Author',
        db_constraint=False,
        related_name='books'
    )


    @property
    def publish_name(self):
        return self.publish.name

    @property
    def author_list(self):
        return self.authors.values('name', 'age', 'detail__mobile').all()

    class Meta:
        db_table = 'book'
        verbose_name = '书籍'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class Publish(BaseModel):
    """name、address、is_delete、create_time"""
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)

    class Meta:
        db_table = 'publish'
        verbose_name = '出版社'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class Author(BaseModel):
    """name、age、is_delete、create_time"""
    name = models.CharField(max_length=64)
    age = models.IntegerField()

    class Meta:
        db_table = 'author'
        verbose_name = '作者'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class AuthorDetail(BaseModel):
    """mobile, author、is_delete、create_time"""
    mobile = models.CharField(max_length=11)
    author = models.OneToOneField(
        to='Author',
        db_constraint=False,
        related_name='detail',
        on_delete=models.CASCADE,
    )

    class Meta:
        db_table = 'author_detail'
        verbose_name = '作者详情'
        verbose_name_plural = verbose_name
    def __str__(self):
        return '%s的详情' % self.author.name
代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response

from . import models, serializers

class Publish(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                publish_obj = models.Publish.objects.get(pk=pk, is_delete=False)
                publish_data = serializers.PublishModelSerializer(publish_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '出版社不存在'
                })
        else:
            publish_query = models.Publish.objects.filter(is_delete=False).all()
            publish_data = serializers.PublishModelSerializer(publish_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': publish_data
        })



class Book(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    def post(self, request, *args, **kwargs):
        request_data = request.data
        book_ser = serializers.BookModelDeserializer(data=request_data)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.BookModelSerializer(book_obj).data
        })

序列化与反序列化整合

路由

代码语言：javascript
复制
from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^books/$',views.Book.as_view()),
    url(r'^books/(?P<pk>.*)/$',views.Book.as_view()),
    
    url(r'^v2/books/$', views.V2Book.as_view()),
    url(r'^v2/books/(?P<pk>.*)/$', views.V2Book.as_view()),
]

视图

代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response

from . import models, serializers


class V2Book(APIView):
    # 单查：有pk
    # 群查：无pk
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    # 单增：传的数据是与model对应的字典
    # 群增：传的数据是 装多个 model对应字典 的列表
    def post(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, dict):
            many = False
        elif isinstance(request_data, list):
            many = True
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.V2BookModelSerializer(data=request_data, many=many)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_result, many=many).data
        })

    # 单删：有pk
    # 群删：有pks   |  {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True):
            return Response({
                'status': 0,
                'msg': '删除成功',
            })
        return Response({
            'status': 1,
            'msg': '删除失败',
        })

序列化文件

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer, SerializerMethodField
from rest_framework.exceptions import ValidationError
from . import models

"""
1) fields中设置所有序列化与反序列化字段
2) extra_kwargs划分只序列化或只反序列化字段
    write_only：只反序列化
    read_only：只序列化
    自定义字段默认只序列化(read_only)
3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则
"""
class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            },
            'publish': {
                'write_only': True
            },
            'authors': {
                'write_only': True
            },
            'img': {
                'read_only': True,
            },
            'author_list': {
                'read_only': True,
            },
            'publish_name': {
                'read_only': True,
            }
        }

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

模型

代码语言：javascript
复制
from django.db import models

# 图书管理系统：Book、Author、AuthorDetail、Publish
"""
Book表: name、price、img、authors、publish、is_delete、create_time
Publish表: name、address、is_delete、create_time
Author表: name、age、is_delete、create_time
AuthorDetail表: mobile, author、is_delete、create_time
"""

# 1) 基表
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)
    create_time = models.DateTimeField(auto_now_add=True)

    # 作为基表的Model不能在数据库中形成对应的表，设置 abstract = True
    class Meta:
        abstract = True


class Book(BaseModel):
    """name、price、img、authors、publish、is_delete、create_time"""
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    img = models.ImageField(upload_to='img', default='img/default.jpg')
    publish = models.ForeignKey(
        to='Publish',
        db_constraint=False,
        related_name='books',
        on_delete=models.DO_NOTHING,
    )
    authors = models.ManyToManyField(
        to='Author',
        db_constraint=False,
        related_name='books'
    )


    @property
    def publish_name(self):
        return self.publish.name

    @property
    def author_list(self):
        return self.authors.values('name', 'age', 'detail__mobile').all()

    class Meta:
        db_table = 'book'
        verbose_name = '书籍'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class Publish(BaseModel):
    """name、address、is_delete、create_time"""
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)

    class Meta:
        db_table = 'publish'
        verbose_name = '出版社'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class Author(BaseModel):
    """name、age、is_delete、create_time"""
    name = models.CharField(max_length=64)
    age = models.IntegerField()

    class Meta:
        db_table = 'author'
        verbose_name = '作者'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class AuthorDetail(BaseModel):
    """mobile, author、is_delete、create_time"""
    mobile = models.CharField(max_length=11)
    author = models.OneToOneField(
        to='Author',
        db_constraint=False,
        related_name='detail',
        on_delete=models.CASCADE,
    )

    class Meta:
        db_table = 'author_detail'
        verbose_name = '作者详情'
        verbose_name_plural = verbose_name
    def __str__(self):
        return '%s的详情' % self.author.name

单增，群增,单删，群删接口

视图

代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response

from . import models, serializers


class V2Book(APIView):
    # 单查：有pk
    # 群查：无pk
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    # 单增：传的数据是与model对应的字典
    # 群增：传的数据是 装多个 model对应字典 的列表
    def post(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, dict):
            many = False
        elif isinstance(request_data, list):
            many = True
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.V2BookModelSerializer(data=request_data, many=many)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_result, many=many).data
        })

    # 单删：有pk
    # 群删：有pks   |  {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True):
            return Response({
                'status': 0,
                'msg': '删除成功',
            })
        return Response({
            'status': 1,
            'msg': '删除失败',
        })


class Publish(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                publish_obj = models.Publish.objects.get(pk=pk, is_delete=False)
                publish_data = serializers.PublishModelSerializer(publish_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '出版社不存在'
                })
        else:
            publish_query = models.Publish.objects.filter(is_delete=False).all()
            publish_data = serializers.PublishModelSerializer(publish_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': publish_data
        })



class Book(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    def post(self, request, *args, **kwargs):
        request_data = request.data
        book_ser = serializers.BookModelDeserializer(data=request_data)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.BookModelSerializer(book_obj).data
        })

模型

代码语言：javascript
复制
from django.db import models

# 图书管理系统：Book、Author、AuthorDetail、Publish
"""
Book表: name、price、img、authors、publish、is_delete、create_time
Publish表: name、address、is_delete、create_time
Author表: name、age、is_delete、create_time
AuthorDetail表: mobile, author、is_delete、create_time
"""

# 1) 基表
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)
    create_time = models.DateTimeField(auto_now_add=True)

    # 作为基表的Model不能在数据库中形成对应的表，设置 abstract = True
    class Meta:
        abstract = True


class Book(BaseModel):
    """name、price、img、authors、publish、is_delete、create_time"""
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    img = models.ImageField(upload_to='img', default='img/default.jpg')
    publish = models.ForeignKey(
        to='Publish',
        db_constraint=False,
        related_name='books',
        on_delete=models.DO_NOTHING,
    )
    authors = models.ManyToManyField(
        to='Author',
        db_constraint=False,
        related_name='books'
    )


    @property
    def publish_name(self):
        return self.publish.name

    @property
    def author_list(self):
        return self.authors.values('name', 'age', 'detail__mobile').all()

    class Meta:
        db_table = 'book'
        verbose_name = '书籍'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class Publish(BaseModel):
    """name、address、is_delete、create_time"""
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)

    class Meta:
        db_table = 'publish'
        verbose_name = '出版社'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class Author(BaseModel):
    """name、age、is_delete、create_time"""
    name = models.CharField(max_length=64)
    age = models.IntegerField()

    class Meta:
        db_table = 'author'
        verbose_name = '作者'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.name

class AuthorDetail(BaseModel):
    """mobile, author、is_delete、create_time"""
    mobile = models.CharField(max_length=11)
    author = models.OneToOneField(
        to='Author',
        db_constraint=False,
        related_name='detail',
        on_delete=models.CASCADE,
    )

    class Meta:
        db_table = 'author_detail'
        verbose_name = '作者详情'
        verbose_name_plural = verbose_name
    def __str__(self):
        return '%s的详情' % self.author.name

序列化

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer, SerializerMethodField
from rest_framework.exceptions import ValidationError
from . import models


class PublishModelSerializer(ModelSerializer):
    class Meta:
        model = models.Publish
        fields = ('name', 'address')

class BookModelSerializer(ModelSerializer):
    # 了解: 该方式设置的序列化字段，必须在fields中声明
    # publish_address = SerializerMethodField()
    # def get_publish_address(self, obj):
    #     return obj.publish.address

    # 自定义连表深度 - 子序列化方式
    publish = PublishModelSerializer()

    class Meta:
        # 序列化类关联的model类
        model = models.Book
        # 参与序列化的字段
        fields = ('name', 'price', 'img', 'author_list', 'publish')

        # 了解知识点
        # 所有字段
        # fields = '__all__'
        # 与fields不共存，exclude排除哪些字段
        # exclude = ('id', 'is_delete', 'create_time')
        # 自动连表深度
        # depth = 1

class BookModelDeserializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'publish', 'authors')
        # extra_kwargs 用来完成反序列化字段的 系统校验规则
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            }
        }

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

    # ModelSerializer类已经帮我们实现了 create 与 update 方法


"""
1) fields中设置所有序列化与反序列化字段
2) extra_kwargs划分只序列化或只反序列化字段
    write_only：只反序列化
    read_only：只序列化
    自定义字段默认只序列化(read_only)
3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则
"""
class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            },
            'publish': {
                'write_only': True
            },
            'authors': {
                'write_only': True
            },
            'img': {
                'read_only': True,
            },
            'author_list': {
                'read_only': True,
            },
            'publish_name': {
                'read_only': True,
            }
        }

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

单整体改

代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response

from . import models, serializers

class V2Book(APIView):
    # 单查：有pk
    # 群查：无pk
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    # 单增：传的数据是与model对应的字典
    # 群增：传的数据是 装多个 model对应字典 的列表
    def post(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, dict):
            many = False
        elif isinstance(request_data, list):
            many = True
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.V2BookModelSerializer(data=request_data, many=many)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_result, many=many).data
        })

    # 单删：有pk
    # 群删：有pks   |  {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True):
            return Response({
                'status': 0,
                'msg': '删除成功',
            })
        return Response({
            'status': 1,
            'msg': '删除失败',
        })

    # 单整体改,传的数据是与model对应的字典{name|price|publish|authors}
    def put(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')
        old_book_obj = models.Book.objects.filter(pk=pk).first()
        ## 将众多 数据的校验交给序列化类来 处理，让序列化累扮演反序列化的角色，校验成功后，序列化帮你入库
        book_ser = serializers.V2BookModelSerializer(instance=old_book_obj, data=request_data)
        book_ser.is_valid(raise_exception=True)
        # 校验通过，完成数据的更新：要知道更新的目标，用来更新的新数据
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'put OK',
            'results': serializers.V2BookModelSerializer(book_obj).data
        })





单局部改

代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response

from . import models, serializers

class V2Book(APIView):
    # 单查：有pk
    # 群查：无pk
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    # 单增：传的数据是与model对应的字典
    # 群增：传的数据是 装多个 model对应字典 的列表
    def post(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, dict):
            many = False
        elif isinstance(request_data, list):
            many = True
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.V2BookModelSerializer(data=request_data, many=many)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_result, many=many).data
        })

    # 单删：有pk
    # 群删：有pks   |  {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True):
            return Response({
                'status': 0,
                'msg': '删除成功',
            })
        return Response({
            'status': 1,
            'msg': '删除失败',
        })

    # 单整体改,传的数据是与model对应的字典{name|price|publish|authors}
    def put(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')
        old_book_obj = models.Book.objects.filter(pk=pk).first()
        ## 将众多 数据的校验交给序列化类来 处理，让序列化累扮演反序列化的角色，校验成功后，序列化帮你入库
        book_ser = serializers.V2BookModelSerializer(instance=old_book_obj, data=request_data)
        book_ser.is_valid(raise_exception=True)
        # 校验通过，完成数据的更新：要知道更新的目标，用来更新的新数据
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'put OK',
            'results': serializers.V2BookModelSerializer(book_obj).data
        })

    # 单局部改
    def patch(self,request,*args,**kwargs):
        request_data = request.data
        pk = kwargs.get('pk')
        old_book_obj = models.Book.objects.filter(pk=pk).first()
        ## 将众多 数据的校验交给序列化类来 处理，让序列化累扮演反序列化的角色，校验成功后，序列化帮你入库
        book_ser = serializers.V2BookModelSerializer(instance=old_book_obj, data=request_data,partial=True)
        book_ser.is_valid(raise_exception=True)
        # 校验通过，完成数据的更新：要知道更新的目标，用来更新的新数据
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'put OK',
            'results': serializers.V2BookModelSerializer(book_obj).data
        })



群改接口

请求数据应该是列表套字典：[{},{},{}] 或者字典套字典： {"1":{},"2":{},"3":{}}

群改需要使用ListSerializer，并且要重写update方法

代码语言：javascript
复制
from rest_framework.serializers import ModelSerializer, SerializerMethodField
from rest_framework.exceptions import ValidationError
from . import models


class PublishModelSerializer(ModelSerializer):
    class Meta:
        model = models.Publish
        fields = ('name', 'address')

class BookModelSerializer(ModelSerializer):
    # 了解: 该方式设置的序列化字段，必须在fields中声明
    # publish_address = SerializerMethodField()
    # def get_publish_address(self, obj):
    #     return obj.publish.address

    # 自定义连表深度 - 子序列化方式
    publish = PublishModelSerializer()

    class Meta:
        # 序列化类关联的model类
        model = models.Book
        # 参与序列化的字段
        fields = ('name', 'price', 'img', 'author_list', 'publish')

        # 了解知识点
        # 所有字段
        # fields = '__all__'
        # 与fields不共存，exclude排除哪些字段
        # exclude = ('id', 'is_delete', 'create_time')
        # 自动连表深度
        # depth = 1

class BookModelDeserializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'publish', 'authors')
        # extra_kwargs 用来完成反序列化字段的 系统校验规则
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            }
        }

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

    # ModelSerializer类已经帮我们实现了 create 与 update 方法


"""
1) fields中设置所有序列化与反序列化字段
2) extra_kwargs划分只序列化或只反序列化字段
    write_only：只反序列化
    read_only：只序列化
    自定义字段默认只序列化(read_only)
3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则
"""
from rest_framework.serializers import ListSerializer

# 重点：ListSerializer与ModelSerializer建立关联的是：
# ModelSerializer的Meta类的 - list_serializer_class
class V2BookListSerializer(ListSerializer):
    def update(self, instance, validated_data):
        # print(instance)  # 要更新的对象们
        # print(validated_data)  # 更新的对象对应的数据们
        # print(self.child)  # 服务的模型序列化类 - V2BookModelSerializer
        for index, obj in enumerate(instance):
            self.child.update(obj, validated_data[index])
        return instance



class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        extra_kwargs = {
            'name': {
                'required': True,
                'min_length': 1,
                'error_messages': {
                    'required': '必填项',
                    'min_length': '太短',
                }
            },
            'publish': {
                'write_only': True
            },
            'authors': {
                'write_only': True
            },
            'img': {
                'read_only': True,
            },
            'author_list': {
                'read_only': True,
            },
            'publish_name': {
                'read_only': True,
            }
        }

        # 群改，需要设置 自定义ListSerializer，重写群改的 update 方法
        list_serializer_class = V2BookListSerializer

    def validate_name(self, value):
        # 书名不能包含 g 字符
        if 'g' in value.lower():
            raise ValidationError('该g书不能出版')
        return value

    def validate(self, attrs):
        publish = attrs.get('publish')
        name = attrs.get('name')
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs
代码语言：javascript
复制
from rest_framework.views import APIView
from rest_framework.response import Response

from . import models, serializers

class Publish(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                publish_obj = models.Publish.objects.get(pk=pk, is_delete=False)
                publish_data = serializers.PublishModelSerializer(publish_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '出版社不存在'
                })
        else:
            publish_query = models.Publish.objects.filter(is_delete=False).all()
            publish_data = serializers.PublishModelSerializer(publish_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': publish_data
        })



class Book(APIView):
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    def post(self, request, *args, **kwargs):
        request_data = request.data
        book_ser = serializers.BookModelDeserializer(data=request_data)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.BookModelSerializer(book_obj).data
        })



class V2Book(APIView):
    # 单查：有pk
    # 群查：无pk
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            try:
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                book_data = serializers.V2BookModelSerializer(book_obj).data
            except:
                return Response({
                    'status': 1,
                    'msg': '书籍不存在'
                })
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_data = serializers.V2BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

    # 单增：传的数据是与model对应的字典
    # 群增：传的数据是 装多个 model对应字典 的列表
    def post(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, dict):
            many = False
        elif isinstance(request_data, list):
            many = True
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })
        book_ser = serializers.V2BookModelSerializer(data=request_data, many=many)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)
        book_result = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_result, many=many).data
        })

    # 单删：有pk
    # 群删：有pks   |  {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks = request.data.get('pks')
        if models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True):
            return Response({
                'status': 0,
                'msg': '删除成功',
            })
        return Response({
            'status': 1,
            'msg': '删除失败',
        })


    # 单整体改: 对 v2/books/(pk)/ 传的数据是与model对应的字典{name|price|publish|authors}
    def put(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')
        old_book_obj = models.Book.objects.filter(pk=pk).first()
        # 目的：将众多数据的校验交给序列化类来处理 - 让序列化类扮演反序列化角色，校验成功后，序列化类来帮你入库
        book_ser = serializers.V2BookModelSerializer(instance=old_book_obj, data=request_data, partial=False)
        book_ser.is_valid(raise_exception=True)
        # 校验通过，完成数据的更新：要更新的目标，用来更新的新数据
        book_obj = book_ser.save()

        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_obj).data
        })


    # 单局部改：对 v2/books/(pk)/ 传的数据，数据字段key都是选填
    # 群局部改：
    # 请求数据 - [{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]
    def patch(self, request, *args, **kwargs):
        request_data = request.data
        pk = kwargs.get('pk')

        # 将单改，群改的数据都格式化成 pks=[要需要的对象主键标识] | request_data=[每个要修改的对象对应的修改数据]
        if pk and isinstance(request_data, dict):  # 单改
            pks = [pk, ]
            request_data = [request_data, ]
        elif not pk and isinstance(request_data, list): # 群改
            pks = []
            for dic in request_data:  # 遍历前台数据[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，拿一个个字典
                pk = dic.pop('pk', None)
                if pk:
                    pks.append(pk)
                else:
                    return Response({
                        'status': 1,
                        'msg': '数据有误',
                    })
        else:
            return Response({
                'status': 1,
                'msg': '数据有误',
            })

        # pks与request_data数据筛选，
        # 1）将pks中的没有对应数据的pk与数据已删除的pk移除，request_data对应索引位上的数据也移除
        # 2）将合理的pks转换为 objs
        objs = []
        new_request_data = []
        for index, pk in enumerate(pks):
            try:
                # pk对应的数据合理，将合理的对象存储
                obj = models.Book.objects.get(pk=pk,is_delete=False)
                objs.append(obj)
                # 对应索引的数据就需要保存下来
                new_request_data.append(request_data[index])
            except:
                # 重点：反面教程 - pk对应的数据有误，将对应索引的data中request_data中移除
                # index = pks.index(pk)
                # request_data.pop(index)
                continue

        book_ser = serializers.V2BookModelSerializer(instance=objs, data=new_request_data, partial=True, many=True)
        book_ser.is_valid(raise_exception=True)
        book_objs = book_ser.save()

        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.V2BookModelSerializer(book_objs, many=True).data
        })



    # 总结：
    """
    1）单整体修改：
    V2BookModelSerializer(
        instance=要被更新的对象, 
        data=用来更新的数据,
        partial=默认False，必须的字段全部参与校验
    )
    2）单局部修改：
    V2BookModelSerializer(
        instance=要被更新的对象, 
        data=用来更新的数据,
        partial=设置True，必须的字段都变为选填字段
    )
    注：partial设置True的本质就是使字段 required=True 校验规则失效
    """
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2019-04-29，如有侵权请联系 cloudcommunity@tencent.com 删除
文件存储
运维
python
自动化
数据迁移

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

文件存储
运维
python
自动化
数据迁移
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
LV.
文章
0
获赞
0
目录
  • 解析模块
  • 异常处理模块
  • 响应模块
  • 序列化组件
    • Serializer
      • ModelSerializer
      相关产品与服务
      文件存储
      文件存储（Cloud File Storage，CFS）为您提供安全可靠、可扩展的共享文件存储服务。文件存储可与腾讯云服务器、容器服务、批量计算等服务搭配使用，为多个计算节点提供容量和性能可弹性扩展的高性能共享存储。腾讯云文件存储的管理界面简单、易使用，可实现对现有应用的无缝集成；按实际用量付费，为您节约成本，简化 IT 运维工作。
      产品介绍产品文档
      领券

      腾讯云开发者

      扫码关注腾讯云开发者

      扫码关注腾讯云开发者

      领取腾讯云代金券

      热门产品

      热门推荐

      更多推荐

      Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

      深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

      腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

      问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

      Copyright © 2013 - 2024 Tencent Cloud.

      All Rights Reserved. 腾讯云 版权所有

      登录 后参与评论