首页 > 其他分享> > drf框架 - 序列化组件 | ModelSerializer

drf框架 - 序列化组件 | ModelSerializer

2019-10-17 09:01:55 作者：互联网

ModelSerializer

序列化准备:

配置 settings.py

# 注册rest_framework框架
INSTALLED_APPS = [
    ...
    'rest_framework'
]
# 配置mysql数据库
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'db10',
        'USER': 'root',
        'PASSWORD':'root',
    }
}

"""
任何__init__.py文件中
import pymysql
pymysql.install_as_MySQLdb()
"""

# 国际化
LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_I18N = True
USE_L10N = True
USE_TZ = False

# 配置静态文件
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

路由

# 主路由:
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('app01.urls')),
    # 暴露media文件夹
    url(r'^media/(?P<path>.*)', serve, {'document_root': settings.MEDIA_ROOT})
]
# 子路由:
from django.conf.urls import url
from . import views

urlpatterns = [
    ...
]

模型层: models.py

# 多表设计
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

知识补充:

基表

# 上述的表中都含有 is_delete、create_time 字段,我们可以创建一个基表类含有这两个字段,其他的表来继承这个基表类即可(类似抽象类)

class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)  # 该字段默认是 0
    create_time = models.DateTimeField(auto_now_add=True)

    # 作为基表的model类不能在数据库中形成对应的表,所以一定需要设置 abstract = True
    class Meta:
        abstract = True

断关联多表关系(***)

1、外键位置：
    一对多 - 外键放多的一方
    一对一 - 从逻辑正反向考虑，如作者表与作者详情表，作者删除级联删除详情，详情删除作者依旧存在，所以建议外键在详情表中
    多对多 - 外键在关系表中
2、ORM正向方向连表查找：
    正向：通过外键字段 eg: author_detial_obj.author 
    反向：通过related_name的值 eg：author_obj.detail
    注：依赖代码见下方
3、连表操作关系：
    1）作者删除，作者详情级联 - on_delete=models.CASCADE  # 被关联表中的数据删除,主关联表中的对应数据也删除
    2）作者删除，作者详情置空 - null=True, on_delete=models.SET_NULL  # 被关联表中的数据删除,主关联表中的对应的字段为空(null)
    3）作者删除，作者详情重置 - default=0, on_delete=models.SET_DEFAULT  # 被关联表中的数据删除,主关联表中的对应数据字段可以通过事先定义好的default=0改为0
    4）作者删除，作者详情不动 - on_delete=models.DO_NOTHING  # 被关联表中的数据删除,主关联表中的数据不做任何处理
    注：拿作者与作者详情表举例
4、外键关联字段的参数 - 如何实现 断关联、目前表间操作关系、方向查询字段
    - 图书表中:
    # 关联出版社外键字段
    publish = models.ForeignKey(
        to='Publish',
        db_constraint=False,  # book表与publish表在库中段关联,但在逻辑上还是有关系
        related_name='books',  # 反向跨表时按related_name定义的名字即可
        on_delete=models.DO_NOTHING,  # 断级联,当出版社删除时,对应的图书不做任何处理
    )
    # 关联作者外键字段
    authors = models.ManyToManyField(
        to='Author',
        db_constraint=False,
        related_name='books',
    )
    - 作者详情表中
    author = models.OneToOneField(
        to='Author',
        db_constraint=False,
        related_name='detail',
        on_delete=models.CASCADE,  # 级联
    )
注意: 
    1.ManyToManyField不能设置on_delete，OneToOneField、ForeignKey必须设置on_delete（django1.x系统默认级联，但是django2.x必须手动明确）
    2.OneToOneField 本质是继承了 ForeignKey

from django.db import models

# 基表
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)  # 该字段默认是 0
    create_time = models.DateTimeField(auto_now_add=True)

    # 作为基表的model类不能在数据库中形参对应的表,所以需要设置 abstract = True
    class Meta:
        abstract = True

# 图书表
class Book(BaseModel):  # 继承基表,就会继承基表中的字段
    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,  # book表与publish表在库中段关联,但在逻辑上还是有关系
        related_name='books',  # 反向跨表时按related_name定义的名字即可
        on_delete=models.DO_NOTHING,  # 断级联,当出版社删除时,对应的图书不错任何处理
    )
    # 关联作者外键字段
    authors = models.ManyToManyField(
        to='Author',
        db_constraint=False,
        related_name='books',
    )

    # ModelSerializer序列化 自定义的字段属性
    @property
    def publish_name(self):
        return self.publish.name  # 利用跨表查询返回publish的name
    @property
    def author_list(self):
        return self.authors.values('name', 'detail__mobile')

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

    def __str__(self):
        return self.name

class Publish(BaseModel):
    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 = 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 = 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

ModelSerializer 序列化使用:

应用下创建 serializers.py

from rest_framework.serializers import ModelSerializer, SerializerMethodField
from . import models
from rest_framework.exceptions import ValidationError

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

        # 1.序列化关联的model类
        model = models.Book
        # 2.参与序列化的字段(插拔式),可选择字段展示(model类中有的字段都可以展示,也可以在model类中自定义字段来展示)
        fields = ('name', 'price','publish_name')  # 这里直接写外键字段,到前端展示的是对应model类一条记录的外键pk值

        # 了解
        # fields = '__all__'  # 展示所有model类字段,除model中自定义的方法字段
        # exclude = ('id', 'is_delete', 'create_time')  # 不展示的字段
        # depth = 1  # 自动连表深度

视图层

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:
                # 根据pk查询对应的书籍,注意要指定is_delete=False,因为被删除的数据不能给用户查看
                book_obj = models.Book.objects.get(pk=pk, is_delete=False)
                # model对象不能直接返回给前端,需要序列化,拿到serializers对象字典
                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_query是列表,序列化是要指定many=True
            book_data = serializers.BookModelSerializer(book_query, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': book_data
        })

路由层

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

ModelSerializer 反序列化使用:

serializers.py文件中:

# 创建Book模型类的反序列化类
class BookModelDeserializer(ModelSerializer):
    class Meta:
        # 序列化关联的model类
        model = models.Book
        # 1.fields内的变量名(字段)要对应关联的model类,
        # 2.fields内的字段是前端发来的,字段有默认值的可以不参与反序列化
        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):
        # 书名不能包含 K 字符
        if 'k' in value.lower():
            raise ValidationError('函非法字符')
        return value
    # 全局钩子
    def validate(self, attrs):  # attrs 是个字典
        print(attrs)
        # OrderedDict([('name', '三国'), ('price', Decimal('2.33')), ('publish', <Publish: 首都出版社>), ('authors', [<Author: hanmm>])])
        publish = attrs.get('publish')
        print(publish, type(publish))
        # 首都出版社 <class 'app01.models.Publish'>
        name = attrs.get('name')
        print(name, type(name))
        # 三国 <class 'str'>
        
        # 同一出版社的书不能重复创建
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

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

视图层

class Book(APIView):  
    def post(self, request, *args, **kwargs):
        # 拿到数据包中的数据字典
        request_data = request.data
        # 将数据包字典反序列化并校验,拿到序列化后的对象
        book_ser = serializers.BookModelDeserializer(data=request_data)
        # 当校验失败，马上终止当前视图方法，抛异常返回给前台
        book_ser.is_valid(raise_exception=True)  # 指定参数raise_exception=True, 当 book_ser.is_valid为False时自动向前端抛出错误
        book_obj = book_ser.save()
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': serializers.BookModelSerializer(book_obj).data
        })

路由层

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

ModelSerializer 序列化反序列化整合(*****)

1) fields中设置所有序列化与反序列化字段(插拔式)
2) extra_kwargs划分只序列化或只反序列化字段
    write_only：只反序列化 (要写入数据库的字段)
    read_only：只序列化 (要展示给前端的字段)
    自定义字段默认只序列化(read_only)
3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则

serializers.py文件中:

class V2BookModelSerializer(ModelSerializer):
    class Meta:
        model = models.Book
        # 设置所有字段
        fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors')
        # extra_kwargs划分只序列化或只反序列化字段
        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):
        # 书名不能包含 K 字符
        if 'k' in value.lower():
            raise ValidationError('函非法字符')
        return value

    # 全局钩子
    def validate(self, attrs):  # attrs 是个字典
        print(attrs)
        # OrderedDict([('name', '三国'), ('price', Decimal('2.33')), ('publish', <Publish: 首都出版社>), ('authors', [<Author: hanmm>])])
        publish = attrs.get('publish')
        print(publish, type(publish))
        # 首都出版社 <class 'app01.models.Publish'>
        name = attrs.get('name')
        print(name, type(name))
        # 三国 <class 'str'>
        if models.Book.objects.filter(name=name, publish=publish):
            raise ValidationError({'book': '该书已存在'})
        return attrs

视图层

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
        # 单增与群增的代码一样,区别在与反序列化时是否指定many=True
        if isinstance(request_data, dict):  # 判断request_data是否是dict的对象
            # 是单增 many=False
            many = False
        elif isinstance(request_data, list): # 判断request_data是否是dict的对象
            # 是群增 many=True
            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_obj_list = book_ser.save()
        print(book_obj_list, type(book_obj_list))  # [<Book: 东游>, <Book: 水浒>] <class 'list'>
        return Response({
            'status': 0,
            'msg': 'ok',
            'results':serializers.V2BookModelSerializer(book_obj_list, many=many).data
        })

    # 单删 有pk 指定一个pk
    # 群删 有pks 指定多个pk {"pks": [1, 2, 3]}
    def delete(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]
        else:
            pks =request.data.get('pks')
        # 返回修改几条记录的数量
        num = models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True)
        if num:
            return Response({
                'status': 0,
                'msg': '删除成功',
            })
        return Response({
            'status': 1,
            'msg': '删除失败',
        })

路由层

from django.conf.urls import url
from . import views

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

标签：ModelSerializer,name,models,publish,book,序列化,True,drf
来源： https://www.cnblogs.com/waller/p/11689919.html

drf框架 - 序列化组件 | ModelSerializer

ModelSerializer

序列化准备:

配置 settings.py

路由

知识补充:

基表

断关联多表关系(***)

ModelSerializer 序列化 使用:

应用下创建 serializers.py

视图层

路由层

ModelSerializer 反序列化 使用:

serializers.py文件中:

视图层

路由层

ModelSerializer 序列化反序列化整合(*****)

serializers.py文件中:

视图层

路由层

ModelSerializer 序列化使用:

ModelSerializer 反序列化使用: