DRF~day04 之序列化高级用法之source、序列化高级用法之定制字段的两种方式、多表关联反序列化保存、反序列化字段校验其他、ModelSerializer使用

已于 2023-05-28 18:37:51 修改
阅读量493 收藏
点赞数
分类专栏： Django-REST-framework框架 文章标签： python django 开发语言
于 2023-05-28 16:33:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55672697/article/details/130912132
版权

DRF 之 序列化高级用法之source、 序列化高级用法之定制字段的两种方式、多表关联反序列化保存、反序列化字段校验其他、ModelSerializer使用

文章目录

一、 序列化高级用法之source

1.1、 创建表模型（models.py文件下创建）

from django.db import models

# Create your models here.


class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)
    # on_delete:
    # CASCADE:级联删除，只要删除publish，跟publish关联的book，全都被删除
    # SET_DEFAULT:只要删除publish，跟publish关联的book，的publish字段会变成默认值，一定要配合default使用
    # SET_NULL:只要删除publish，跟publish关联的book，的publish字段会变成空，一定要配合null=True使用
    # models.SET(add):括号中可以放个值，也可以放个函数内存地址，只要删除publish，跟publish关联的book，的publish字段会变成set设的值或执行函数
    # 书籍和出版社是 ： 1对多关系 ForeignKey(to='表名', )
    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    # 多对多关系
    authors = models.ManyToManyField(to='Author')

    # source的第二种用法 ： 给查询数来的书籍名添加后缀名
    def sb_name(self):
        return self.name + '_sb'

    # 定义字段类型的方式2：
    # 字典类型
    # @property 的意思是把方法变成可以调用的数据（可加可不加）
    @property
    def publish_dict(self):
        # 这个对象是
        return {'id': self.publish.pk, 'name': self.publish.name, 'addr': self.publish.addr}

    def author_list(self):
        l =[]
        for list in self.authors.all():
            l.append({'id': list.pk, 'name': list.name, 'phone': list.phone, 'age': list.author_detail.age})
        return l


class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)


class Author(models.Model):
    name = models.CharField(max_length=32)
    phone = models.CharField(max_length=11)
    # 本质就是ForeignKey，但是唯一，多的一方唯一，形成了一对一
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)


class AuthorDetail(models.Model):
    email = models.CharField(max_length=32)
    age = models.IntegerField()

1.2、路由设置

    path('book/', views.bookview.as_view()),
    path('book/<int:pk>/', views.BookDetailView.as_view()),

1.3、视图类代码

class bookview(APIView):
    def get(self, request):
        res = models.Book.objects.all()
        # 把查询的表的对象res传入到序列化类中进行数据处理，在Bookserializers（）的括号中用instance接收对象
        ser = Bookserializers(instance=res, many=True)
        print(res)
        print(ser.data)
        return Response({'code': 200, 'msg': '成功', 'results': ser.data})

    def post(self, request):
        # 创建数据
        # 接收前端传来的数据去反序列化
        print(request.data)
        res = Bookserializers(data=request.data)  # 反序列化
        # 校验反序列化后的数据
        if res.is_valid():
            print(res.validated_data)  # 打印校验之后的数据
            # 保存数据
            res.save()
            return Response({'code': 200, 'msg': '更新成功'})
        else:
            print(res.errors)  # 打印校验失败的信息
            return Response({'code': 404, 'msg': '创建失败', '失败data': res.errors})


class BookDetailView(APIView):
    # 查询单个数据
    def get(self, request, pk):
        res_obj = models.Book.objects.all().get(pk=pk)
        ser = Bookserializers(res_obj)  # 序列化
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})

    # 修改数据
    def put(self, request, pk):
        res_obj = models.Book.objects.filter(pk=pk).first()
        print(res_obj)
        ser = Bookserializers(instance=res_obj, data=request.data)
        if ser.is_valid():
            print(ser.validated_data)
            ser.save()
            return Response({'code': 100, 'msg': '修改成功', 'results': ser.validated_data})
        else:
            print(ser.validated_data)
            return Response({'code': 100, 'msg': '修改失败', 'results': ser.errors})

    def delete(self, request, pk):
        models.Book.objects.filter(pk=pk).first().delete()
        return Response({'code': 100, 'msg': '删除成功'})

1.4、序列化类代码

# 1、 source的用法
class Bookserializers(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.CharField()
    # 写的这些字段类的名字，必须是book对象中的属性，不然book_name会报错
    # 如果不想报错，使用source指定book对象中的属性
    # 第一种用法：放一个对象的属性
    # book_name = serializers.CharField(source='name')  # 给前端看到的是 book_name
    # name = serializers.CharField(source='name')  # 坑，会报错
    # name = serializers.CharField()  # 同一个字段，可以序列化多次，但一般不会写
    book_name = serializers.CharField(source='name')
    book_price = serializers.CharField(source='price')

    # # 第二种用法：放一个对象的方法  book.sb_name()--->真正的书名_sb
    # # 在模型表中写方法
    # # 这个方法的意思是： 给查询出来的数据添加一个_sb的后缀名
    # book_name = serializers.CharField(source='sb_name')
    # book_price = serializers.CharField(source='price')

    # # 第三种：关联查询，拿出出版社的名字
    # Publish_name = serializers.CharField(source='publish.name')
    #
    # name = serializers.CharField()
    # price = serializers.CharField()

1.5、source的用法的展示

1.5.1、用法一：展示数据信息

  • 普通展示
    在这里插入图片描述
  • 使用source的方法展示（自定义字段展示给前端看）
    在这里插入图片描述

1.5.2、用法二：给查询出来的数据添加一个_sb的后缀名

  • 序列化类中的代码
    # # 第二种用法：放一个对象的方法  book.sb_name()--->真正的书名_sb
    # # 在模型表中写方法
    # # 这个方法的意思是： 给查询出来的数据添加一个_sb的后缀名
    book_name = serializers.CharField(source='sb_name')
    book_price = serializers.CharField(source='price')
  • 模型层中的代码
    # source的第二种用法 ： 给查询数来的书籍名添加后缀名
    def sb_name(self):
        return self.name + '_sb'
  • 展示效果
    在这里插入图片描述

1.5.3、用法三：关联查询，拿出出版社的名字：

  • 序列化类中的代码
    # # 第三种：关联查询，拿出出版社的名字
    # 这里的source='publish.name'是跨表查询出版社表中对应的出版社名称
    Publish_name = serializers.CharField(source='publish.name')
    name = serializers.CharField()
    price = serializers.CharField()
  • 展示效果
    在这里插入图片描述

1.6 总结

# 总结：1、source的用法
	-1 修改前端看到的字段key值---》source指定的必须是对象的属性
    	book_name = serializers.CharField(source='name')
    -2 修改前端看到的value值，---》source指定的必须是对象的方法
    	表模型中写方法
          def sb_name(self):
        	return self.name + '_sb'
        序列化类中
        	book_name = serializers.CharField(source='sb_name')
            
     -3 可以关联查询（得有关联关系）
    	publish_name = serializers.CharField(source='publish.name')
    

# 2 定制序列化的字段之source，字段参数
	- 指定一个要序列化的对象中得字段
    - 指定一个要序列化的对象中得方法，方法返回什么，字段就是什么
    - 指定连表操作

二、序列化高级用法之定制字段的两种方式

2.1、方式一：在序列化类中写方法


方式一：在序列化类中写
	1 写一个字段，对应的字段类是：SerializerMethodField
    2 必须对应一个 get_字段名的方法，方法必须接受一个obj，返回什么，这个字段对应的value就是什么
  • 序列化类中的代码
# 2、 定制字段方式1
class Bookserializers(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.CharField()
    # 拿出出版社的id和名字和addr，放到一个字典中
    # 方式一：SerializerMethodField来定制，
    # 如果写了这个，必须配合一个方法get_字段名，这个方法返回什么，这个字段的值就是什么
    publish_dict = serializers.SerializerMethodField()

    # 这个字段名必须是 SerializerMethodField() 的字段
    # 返回的字段要自己定义

    def get_publish_dict(self, obj):
        # 这个obj变量是随便写的，因为这个变量是视图类传进来的对象，
        # 把instance接收对象写到get_字段名 的方法的形参中
        print(obj)
        return {'id': obj.publish.pk, 'name': obj.publish.name, 'addr': obj.publish.addr}

    # 练习：拿出所有作者的信息--》多条 [{name:,phone:},{}] 列表样式
    author_list = serializers.SerializerMethodField()

    def get_author_list(self, lili):
        print(lili)
        lk = []
        for i in lili.authors.all():
            lk.append({'id': i.pk, 'name': i.name, 'phone': i.phone, 'age': i.author_detail.age})
        return lk

效果展示
在这里插入图片描述

2.2、方式二：在模型类中写方法

  • 序列化中的代码
# 2、 定制字段方式2
class Bookserializers(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.CharField()
    # # 1 序列化类中这样写
    # # 2 到表模型中写一个方法，方法名必须叫 publish_dict，这个方法返回什么，这个字段的value就是什么
    # # DictField() 字典类型
    publish_dict = serializers.DictField()

    # ListField()列表类型
    author_list = serializers.ListField()
  • 模型层中的代码
    # 定义字段类型的方式2：
    # 字典类型
    # @property 的意思是把方法变成可以调用的数据（可加可不加）
    @property
    def publish_dict(self):
        # 这个对象是
        return {'id': self.publish.pk, 'name': self.publish.name, 'addr': self.publish.addr}

    def author_list(self):
        l =[]
        for list in self.authors.all():
            l.append({'id': list.pk, 'name': list.name, 'phone': list.phone, 'age': list.author_detail.age})
        return l

展示效果
在这里插入图片描述

2.3、总结

# 定制序列化的字段之  两种方式(为了关联查询)
	-方式一：
        -在序列化类中写  SerializerMethodField---》get_字段名(self,obj)，返回什么这个字段就是什么
        -基于对象的跨表查询
            -正向：book.publish
            -反向:publish.book_set.all()
            
    -方式二：
    	-在表模型中写方法，方法返回结果
        -在序列化类中，使用ListField，DictField...接收

三、多表关联反序列化保存和修改

# 序列化和反序列化，用的同一个序列化类
	-序列化的字段有：name，price ，   publish_detail，author_list
    -反序列化字段：name，price    ，publish，author

3.1 反序列化之保存

  • 视图类
class BookView(APIView):
    def post(self, request):
        ser = BookSerialzier(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})

*序列化类

class Bookserializers(serializers.Serializer):
    # 即用来做序列化，又用来做反序列化
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # 这俩，只用来做序列化
    # read_only参数 表明该字段仅用于序列化输出，默认False
    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)

    # 这俩，只用来做反序列化
    # write_only参数 表明该字段仅用于反序列化输入，默认False
    publish_id = serializers.IntegerField(write_only=True)
    authors = serializers.ListField(write_only=True)

    # 局部钩子：给某个字段做个校验
    # 书名中不能包含sb
    # validate_字段名
    # def validate_name(self, name):
    #     pass

    # 创建表数据
    def create(self, validated_data):
        # 这里是接收前端传来的数据，数据在validated_data 里面
        # 创建数据表的数据,传来数据是字典类型
        # 正常这样写，但是这是多表操作，所以不行
        # book = Book.objects.create(name=validated_data.get('name'),
        #                            price=validated_data.get('price'),
        #                            publish=validated_data.get('publish'),
        #                            authors=validated_data.get('authors')
        #                            )

        # 先操作书籍表
        # 但是数据里面有列表形式数据所有先删除数据拿返回值打散数据变成关键字参数进行传递
        authors = validated_data.pop('authors')
        # 数据在validated_data 里面是关键字的形式所有用**kwargs接收
        book = Book.objects.create(**validated_data)
        # 这样原先的author的数据是[1,2],后面数据是（1,2）使用*args接收
        # 书籍和作者表是多对多的关系，所以要块表操作，正向查询表名小写，添加数据
        book.authors.add(*authors)
        # 保存操作数据
        book.save()
        return book
  • 展示
    在这里插入图片描述

    在这里插入图片描述

3.2 反序列化之修改

  • 视图类
    # 修改数据
    def put(self, request, pk):
        res_obj = models.Book.objects.filter(pk=pk).first()
        print(res_obj)
        ser = Bookserializers(instance=res_obj, data=request.data)
        if ser.is_valid():
            print(ser.validated_data)
            ser.save()
            return Response({'code': 100, 'msg': '修改成功', 'results': ser.validated_data})
        else:
            print(ser.validated_data)
            return Response({'code': 100, 'msg': '修改失败', 'results': ser.errors})
  • 序列化类
#### 3 序列化类，即做序列化，又做反序列化，还做数据校验
class Bookserializers(serializers.Serializer):
    # 即用来做序列化，又用来做反序列化
    name = serializers.CharField(max_length=8)
    price = serializers.CharField()

    # 这俩，只用来做序列化
    # read_only参数 表明该字段仅用于序列化输出，默认False
    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)

    # 这俩，只用来做反序列化
    # write_only参数 表明该字段仅用于反序列化输入，默认False
    publish_id = serializers.IntegerField(write_only=True)
    authors = serializers.ListField(write_only=True)

    # 局部钩子：给某个字段做个校验
    # 书名中不能包含sb
    # validate_字段名
    # def validate_name(self, name):
    #     pass
    
	# 修改数据
    def update(self, instance, validated_data):
        # 数据里面有列表形式数据所有先删除数据拿返回值打散数据变成关键字参数进行传递
        authors = validated_data.pop('authors')
        # print(authors, type(authors))
        # authors = list(authors)
        # print(authors, type(authors))
        for intem in validated_data:  # 把字典进行循环
            # setattr反射方法： setatter（对象，属性，属性值）
            # 这个的意思是如果对象对应的属性和属性值就修改属性值，没有就新增属性和属性值
            setattr(instance, intem, validated_data[intem])
        # instance是视图函数查询出来的书籍表的对象，书籍表操作作者表相关联的表数据
        # 把第三张表数据操作
        instance.authors.set(authors)
        instance.save()
        return instance

展示
在这里插入图片描述

3.3、总结

#  反序列化的保存和修改
	-保存：book：{name:xx,price:18,publish_id:1,authors:[1]}
    -视图函数中：ser=BookSerializer(data=request.data)
    -ser.is_valid()---->校验过后的数据---》ser.validated_data
    -视图类中：ser.save()
    -序列化类中：重写 create方法--->自己写保存
    
    
    -修改：book：{name:xx,price:18,publish_id:1,authors:[1]}
    -视图函数中：ser=BookSerializer(data=request.data,instance=book)
     -ser.is_valid()---->校验过后的数据---》ser.validated_data
    -视图类中：ser.save()
    -序列化类中：重写 update方法--->自己写修改

四、反序列化字段校验其他

# 视图类中调用：ser.is_valid()---》触发数据的校验
	-4层
    	-字段自己的：max_length，required。。。
        -字段自己的：配合一个函数name = serializers.CharField(max_length=8,validators=[xxx])
        -局部钩子
        -全局钩子

五、ModelSerializer使用

# 5 ModelSerialzier的使用
'''
# 现在学的ModelSerializer，表示跟表模型一一对应，用法跟之前基本类似
1 写序列化类，继承ModelSerializer
2 在序列化类中，再写一个类，必须叫
    class Meta:
        model=表模型
         fields=[] # 要序列化的字段
3 可以重写字段，一定不要放在class Meta
    -定制字段，跟之前讲的一样
4 自定制的字段，一定要在fields中注册一下
5 class Meta: 有个extra_kwargs，为某个字段定制字段参数
6 局部钩子，全局钩子，完全一致
7 大部分请情况下，不需要重写 create和update了
'''

class Bookserializers(serializers.ModelSerializer):
    class Meta:
        model =Book   # 指定表模型 （相当于把book表中的所有东西复制一份到这里来了）
        # fields='__all__'  # 把表模型中所有字段都映射过来
        fields = ['name', 'price', 'publish_detail', 'author_list', 'publish', 'authors']  # 自定制的字段，一定要在这里注册一下
        extra_kwargs = {
            'name': {'max_length': 10, 'required': True},
            'publish': {'write_only': True},
            'authors': {'write_only': True}
        }

    # 自定制字段：publish_detail  author_list 写法有两种，跟之前一模一样
    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)
  • 展示
    查看所有书籍信息
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

总结：

# 之前写的序列化类，继承了Serializer，写字段，跟表模型没有必然联系
class XXSerialzier(Serializer)
	id=serializer.CharField()
	name=serializer.CharField()
    
 XXSerialzier既能序列化Book，又能序列化Publish


# 现在学的ModelSerializer，表示跟表模型一一对应，用法跟之前基本类似

	1 写序列化类，继承ModelSerializer
    2 在序列化类中，再写一个类，必须叫
    	class Meta:
			model=表模型
             fields=[] # 要序列化的字段
             # fields=['id','自定制字段']  # 分析明白:哪些字段是读写，哪些字段是只读，哪些字段是只写
    		 extra_kwargs={'id':{'required':True,'write_only':True}}
    3 可以重写字段，一定不要放在class Meta
    book_name=serializer.CharField(source='name',read_only=True)
    	-定制字段，跟之前讲的一样
    4 自定制的字段，一定要在fields中注册一下
    5 class Meta: 有个extra_kwargs，为某个字段定制字段参数
    6 局部钩子，全局钩子，完全一致
    7 大部分请情况下，不需要重写 create和update了

六、总代码

  • 路由层
urlpatterns = [
    path('admin/', admin.site.urls),
    # 做路由分发
    path('app01/', include('app01.urls')),
]


# app01的路由

from django.urls import path
from app01 import views

urlpatterns = [
    path('book/', views.bookview.as_view()),
    path('book/<int:pk>/', views.BookDetailView.as_view()),

    path('publish/', views.Publishview.as_view()),
    path('publish/<int:pk>/', views.Publishviewkk.as_view()),

    path('author/', views.Authorview.as_view()),
    path('author/<int:pk>/', views.Authorviews.as_view()),

]
  • 模型层
from django.db import models

# Create your models here.


class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.CharField(max_length=32)
    # on_delete:
    # CASCADE:级联删除，只要删除publish，跟publish关联的book，全都被删除
    # SET_DEFAULT:只要删除publish，跟publish关联的book，的publish字段会变成默认值，一定要配合default使用
    # SET_NULL:只要删除publish，跟publish关联的book，的publish字段会变成空，一定要配合null=True使用
    # models.SET(add):括号中可以放个值，也可以放个函数内存地址，只要删除publish，跟publish关联的book，的publish字段会变成set设的值或执行函数
    # 书籍和出版社是 ： 1对多关系 ForeignKey(to='表名', )
    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    # 多对多关系
    authors = models.ManyToManyField(to='Author')

    # source的第二种用法 ： 给查询数来的书籍名添加后缀名
    def sb_name(self):
        return self.name + '_sb'




    # 定义字段类型的方式2：
    # 字典类型
    # @property 的意思是把方法变成可以调用的数据（可加可不加）
    @property
    def publish_dict(self):
        # 这个对象是
        return {'id': self.publish.pk, 'name': self.publish.name, 'addr': self.publish.addr}

    def author_list(self):
        l =[]
        for list in self.authors.all():
            l.append({'id': list.pk, 'name': list.name, 'phone': list.phone, 'age': list.author_detail.age})
        return l


class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)


class Author(models.Model):
    name = models.CharField(max_length=32)
    phone = models.CharField(max_length=11)
    # 本质就是ForeignKey，但是唯一，多的一方唯一，形成了一对一
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)


class AuthorDetail(models.Model):
    email = models.CharField(max_length=32)
    age = models.IntegerField()
  • 序列化类
from rest_framework import serializers
from .models import Book
# 局部钩子验证模块导入
from rest_framework.exceptions import ValidationError


# 1、 source的用法
# class Bookserializers(serializers.Serializer):
# name = serializers.CharField()
# price = serializers.CharField()
# 写的这些字段类的名字，必须是book对象中的属性，不然book_name会报错
# 如果不想报错，使用source指定book对象中的属性
# 第一种用法：放一个对象的属性
# book_name = serializers.CharField(source='name')  # 给前端看到的是 book_name
# name = serializers.CharField(source='name')  # 坑，会报错
# name = serializers.CharField()  # 同一个字段，可以序列化多次，但一般不会写
# book_name = serializers.CharField(source='name')
# book_price = serializers.CharField(source='price')

# # 第二种用法：放一个对象的方法  book.sb_name()--->真正的书名_sb
# # 在模型表中写方法
# # 这个方法的意思是： 给查询出来的数据添加一个_sb的后缀名
# book_name = serializers.CharField(source='sb_name')
# book_price = serializers.CharField(source='price')

# # 第三种：关联查询，拿出出版社的名字
# Publish_name = serializers.CharField(source='publish.name')
# name = serializers.CharField()
# price = serializers.CharField()


# # 2、 定制字段方式1
# class Bookserializers(serializers.Serializer):
#     name = serializers.CharField()
#     price = serializers.CharField()
#     # 拿出出版社的id和名字和addr，放到一个字典中
#     # 方式一：SerializerMethodField来定制，
#     # 如果写了这个，必须配合一个方法get_字段名，这个方法返回什么，这个字段的值就是什么
#     publish_dict = serializers.SerializerMethodField()
#
#     # 这个字段名必须是 SerializerMethodField() 的字段
#     # 返回的字段要自己定义
#
#     def get_publish_dict(self, obj):
#         # 这个obj变量是随便写的，因为这个变量是视图类传进来的对象，
#         # 把instance接收对象写到get_字段名 的方法的形参中
#         print(obj)
#         return {'id': obj.publish.pk, 'name': obj.publish.name, 'addr': obj.publish.addr}
#
#     # 练习：拿出所有作者的信息--》多条 [{name:,phone:},{}] 列表样式
#     author_list = serializers.SerializerMethodField()
#
#     def get_author_list(self, lili):
#         print(lili)
#         lk = []
#         for i in lili.authors.all():
#             lk.append({'id': i.pk, 'name': i.name, 'phone': i.phone, 'age': i.author_detail.age})
#         return lk


# # 2、 定制字段方式2
# class Bookserializers(serializers.Serializer):
#     name = serializers.CharField()
#     price = serializers.CharField()
#     # # 1 序列化类中这样写
#     # # 2 到表模型中写一个方法，方法名必须叫 publish_dict，这个方法返回什么，这个字段的value就是什么
#     # # DictField() 字典类型
#     publish_dict = serializers.DictField()
#
#     # ListField()列表类型
#     author_list = serializers.ListField()


# #### 3 序列化类，即做序列化，又做反序列化，还做数据校验
# class Bookserializers(serializers.Serializer):
#     # 即用来做序列化，又用来做反序列化
#     name = serializers.CharField(max_length=8)
#     price = serializers.CharField()
#
#     # 这俩，只用来做序列化
#     # read_only参数 表明该字段仅用于序列化输出，默认False
#     publish_detail = serializers.DictField(read_only=True)
#     author_list = serializers.ListField(read_only=True)
#
#     # 这俩，只用来做反序列化
#     # write_only参数 表明该字段仅用于反序列化输入，默认False
#     publish_id = serializers.IntegerField(write_only=True)
#     authors = serializers.ListField(write_only=True)
#
#     # 局部钩子：给某个字段做个校验
#     # 书名中不能包含sb
#     # validate_字段名
#     # def validate_name(self, name):
#     #     pass
#
#     # 创建表数据
#     def create(self, validated_data):
#         # 这里是接收前端传来的数据，数据在validated_data 里面
#         # 创建数据表的数据,传来数据是字典类型
#         # 正常这样写，但是这是多表操作，所以不行
#         # book = Book.objects.create(name=validated_data.get('name'),
#         #                            price=validated_data.get('price'),
#         #                            publish=validated_data.get('publish'),
#         #                            authors=validated_data.get('authors')
#         #                            )
#
#         # 先操作书籍表
#         # 但是数据里面有列表形式数据所有先删除数据拿返回值打散数据变成关键字参数进行传递
#         authors = validated_data.pop('authors')
#         # 数据在validated_data 里面是关键字的形式所有用**kwargs接收
#         book = Book.objects.create(**validated_data)
#         # 这样原先的author的数据是[1,2],后面数据是（1,2）使用*args接收
#         # 书籍和作者表是多对多的关系，所以要块表操作，正向查询表名小写，添加数据
#         book.authors.add(*authors)
#         # 保存操作数据
#         book.save()
#         return book
#
#     def update(self, instance, validated_data):
#         # 数据里面有列表形式数据所有先删除数据拿返回值打散数据变成关键字参数进行传递
#         authors = validated_data.pop('authors')
#         # print(authors, type(authors))
#         # authors = list(authors)
#         # print(authors, type(authors))
#         for intem in validated_data:  # 把字典进行循环
#             # setattr反射方法： setatter（对象，属性，属性值）
#             # 这个的意思是如果对象对应的属性和属性值就修改属性值，没有就新增属性和属性值
#             setattr(instance, intem, validated_data[intem])
#         # instance是视图函数查询出来的书籍表的对象，书籍表操作作者表相关联的表数据
#         # 把第三张表数据操作
#         instance.authors.set(authors)
#         instance.save()
#         return instance


# # 5 ModelSerialzier的使用
# '''
# # 现在学的ModelSerializer，表示跟表模型一一对应，用法跟之前基本类似
# 1 写序列化类，继承ModelSerializer
# 2 在序列化类中，再写一个类，必须叫
#     class Meta:
#         model=表模型
#          fields=[] # 要序列化的字段
# 3 可以重写字段，一定不要放在class Meta
#     -定制字段，跟之前讲的一样
# 4 自定制的字段，一定要在fields中注册一下
# 5 class Meta: 有个extra_kwargs，为某个字段定制字段参数
# 6 局部钩子，全局钩子，完全一致
# 7 大部分请情况下，不需要重写 create和update了
# '''
#
# class Bookserializers(serializers.ModelSerializer):
#     class Meta:
#         model =Book   # 指定表模型 （相当于把book表中的所有东西复制一份到这里来了）
#         # fields='__all__'  # 把表模型中所有字段都映射过来
#         fields = ['name', 'price', 'publish_detail', 'author_list', 'publish', 'authors']  # 自定制的字段，一定要在这里注册一下
#         extra_kwargs = {
#             'name': {'max_length': 10, 'required': True},
#             'publish': {'write_only': True},
#             'authors': {'write_only': True}
#         }
#
#     # 自定制字段：publish_detail  author_list 写法有两种，跟之前一模一样
#     publish_detail = serializers.DictField(read_only=True)
#     author_list = serializers.ListField(read_only=True)


# 作业1
# from app01 import models
#
#
# class Bookserializers(serializers.ModelSerializer):
#     class Meta:
#         model = models.Publish
#         fields =['id', 'name', 'addr']


# 作业2
from app01 import models


class Bookserializers(serializers.ModelSerializer):
    class Meta:
        model = models.Author
        # fields = '__all__'
        fields = ['id', 'name', 'phone', 'email', 'age']

    # 不是表的字段，一定要重写
    email = serializers.CharField(source='author_detail.email')
    age = serializers.IntegerField(source='author_detail.age')

    def create(self, validated_data):
        print(validated_data)
        # {'name': '刘亦菲', 'phone': '123456', 'author_detail': {'email': '1@qq.com', 'age': 18}}
        author_detail = validated_data.pop('author_detail')
        print(author_detail)
        # {'name': '刘亦菲', 'phone': '123456', 'author_detail': {'email': '1@qq.com', 'age': 18}}

        author_detail_obj = models.AuthorDetail.objects.create(**author_detail)
        print(author_detail_obj)  # AuthorDetail object (6)

        validated_data['author_detail'] = author_detail_obj
        suthor_obj = models.Author.objects.create(**validated_data)
        return suthor_obj

    def update(self, instance, validated_data):
        instance.name = validated_data.get('name')
        instance.phone = validated_data.get('phone')
        instance.author_detail.email = validated_data.get('author_detail').get('email')
        instance.author_detail.age = validated_data.get('author_detail').get('age')
        instance.save()
        instance.author_detail.save()
        return instance
  • 视图层
from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from app01 import models
from app01.serializer import Bookserializers


# Create your views here.


class bookview(APIView):
    def get(self, request):
        print(1)
        res = models.Book.objects.all()
        print(res)
        # 把查询的表的对象res传入到序列化类中进行数据处理，在Bookserializers（）的括号中用instance接收对象
        ser = Bookserializers(instance=res, many=True)
        print(res)
        print(ser.data)
        return Response({'code': 200, 'msg': '成功', 'results': ser.data})

    def post(self, request):
        # 创建数据
        # 接收前端传来的数据去反序列化
        print(request.data)
        res = Bookserializers(data=request.data)  # 反序列化
        # 校验反序列化后的数据
        if res.is_valid():
            print(res.validated_data)  # 打印校验之后的数据
            # 保存数据
            res.save()
            return Response({'code': 200, 'msg': '更新成功'})
        else:
            print(res.errors)  # 打印校验失败的信息
            return Response({'code': 404, 'msg': '创建失败', '失败data': res.errors})


class BookDetailView(APIView):
    # 查询单个数据
    def get(self, request, pk):
        res_obj = models.Book.objects.all().get(pk=pk)
        ser = Bookserializers(res_obj)  # 序列化
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})

    # 修改数据
    def put(self, request, pk):
        res_obj = models.Book.objects.filter(pk=pk).first()
        print(res_obj)
        ser = Bookserializers(instance=res_obj, data=request.data)
        if ser.is_valid():
            print(ser.validated_data)
            ser.save()
            return Response({'code': 100, 'msg': '修改成功', 'results': ser.validated_data})
        else:
            print(ser.validated_data)
            return Response({'code': 100, 'msg': '修改失败', 'results': ser.errors})

    def delete(self, request, pk):
        models.Book.objects.filter(pk=pk).first().delete()
        return Response({'code': 100, 'msg': '删除成功'})







##############################################  第二题作业   #2  Publish的5个接口，ModelSerializer写



# class Publishview(APIView):
#     def get(self, request):
#         res_obj = models.Publish.objects.all()
#         ser = Bookserializers(instance=res_obj, many=True)
#         return Response({'code': 200, 'msg': '成功', 'results': ser.data})
#
#     def post(self, request):
#         ser = Bookserializers(data=request.data)
#         if ser.is_valid():
#             ser.save()
#             return Response({'code': 200, 'msg': '更新成功'})
#         else:
#             return Response({'code': 404, 'msg': '创建失败', '失败data': ser.errors})


# class Publishviewkk(APIView):
#     def get(self, request, pk):
#         res = models.Book.objects.all().get(pk=pk)
#         ser = Bookserializers(instance=res, many=False)
#         return Response({'code': 200, 'msg': '成功', 'results': ser.data})
#
#     # 修改数据
#     def put(self, request, pk):
#         res_obj = models.Publish.objects.filter(pk=pk).first()
#         print(res_obj)
#         ser = Bookserializers(instance=res_obj, data=request.data)
#         if ser.is_valid():
#             print(ser.validated_data)
#             ser.save()
#             return Response({'code': 100, 'msg': '修改成功', 'results': ser.validated_data})
#         else:
#             print(ser.validated_data)
#             return Response({'code': 100, 'msg': '修改失败', 'results': ser.errors})
#
#     def delete(self, request, pk):
#         models.Publish.objects.filter(pk=pk).first().delete()
#         return Response({'code': 100, 'msg': '删除成功'})






# ##############################   第三题作业  
## 3 author的5个接口（写不出来没关系）（
#-新增或修改author时，把author_detail的内容也新增进去


# class Authorview(APIView):
#     # 查询所有数据
#     def get(self, request):
#         res = models.Author.objects.all()
#         ser = Bookserializers(instance=res, many=True)
#         return Response({'code': 200, 'msg': '成功', 'results': ser.data})
#
#     # 增加
#     def post(self, request):
#         res = Bookserializers(data=request.data)
#         if res.is_valid():
#             res.save()
#             return Response({'code': 200, 'msg': '更新成功'})
#         else:
#             return Response({'code': 404, 'msg': '创建失败', '失败data': res.errors})
#
#
#
# class Authorviews(APIView):
#     # 查询一条数据
#     def get(self, request, pk):
#         res = models.Author.objects.filter(pk=pk).first()
#         # res = models.Author.objects.all().get(pk=pk)
#         print(res)
#         ser = Bookserializers(instance=res)
#         return Response({'code': 200, 'msg': '成功', 'results': ser.data})
#
#     # 修改
#     def put(self, request, pk):
#         res = models.Author.objects.filter(pk=pk).first()
#         ser = Bookserializers(data=request.data, instance=res)
#         if ser.is_valid():
#             ser.save()
#             return Response({'code': 100, 'msg': '修改成功', 'results': ser.validated_data})
#         else:
#             return Response({'code': 100, 'msg': '修改失败', 'results': ser.errors})
#
#
#     def delete(self, request, pk):
#         models.Author.objects.filter(pk=pk).first()
#         # models.AuthorDetail.objects.filter(pk=.author_detail.id).delete()
#         return Response({'code': 100, 'msg': '删除成功'})

总结

以上就是今天要讲的内容，本文仅仅简单介绍了的 序列化和反序列化的高级使用 。

er仔琪
关注
专栏目录
Django + DRF 实现列表接口定制查询参数功能和多选查询
feishicheng的博客
10-20 4850
前言 最近在使用 Django 配合 DRF (django-rest-framework) 开发 CD 系统调度器，遇到了这个需求。 之前做侧开，主要侧重于测试，也进行过这种列表接口的测试。也熟悉了标准的调用方法。现在主要侧重于开发，就轮到我开发这种接口了。 查了下 DRF 默认支持的查询机制和前端需要的有点不一样。所以在这里把具体实现记录下。 需求 手头上现有一个发布单的列表接口，可以返回目前...
DRF 之 序列化与反序列化
Hello LinWoW~ ⊙o⊙
07-03 2360
序列化组件 使用drf的序列化组件： 1 新建一个序列化类继承Serializer 2 在类中写要序列化的字段 在视图中使用序列化的类： 1 实例化序列化的类产生对象,在产生对象的时候，传入需要序列化的对象（queryset） 2 对象.data 3 return Response(对象.data) 高级用法： source：可以指定字段（name publish.name），可以指...
DRF框架之连表查询
weixin_42144277的博客
08-14 2522
DRF框架之连表查询 DRF框架的视图序列化器封装节省了我们很多的工作，同时orm也让我们对数据库的操作更加方便。但我一直认为连表查询是DRF框架的一个痛点。大家应该经常能见到这样一种需求，一个接口需要返回两个表中的数据。在原生sql中这几乎不算问题，join in一下就好了。但是DRF中就不一样了，我们虽然可以通过object_set来实现表连接的功能，但是在DRF中，如果我们想要使用序列化器，...
drf_source:B站老男孩drf原始学习
03-23
drf_source:B站老男孩drf原始学习
drf中source的用法
weixin_44128416的博客
09-02 114
source是序列化类中，字段类的属性，它有三种用法。
DRF从入门到精通二（Request源码分析、DRF之序列化、反序列化、反序列化校验、序列化器常用字段及参数、source、定制字段、保存数据）
最新发布
Mchen的博客
12-20 1254
1. 新的request跟之前的用法一模一样，如果新的request取不到，它使用__getattr__魔法方法去原生request中取。当然原生的也可以直接在新的request中拿到，request . _request 2. 新的request中多了data属性，request . data客户端提交的请求体中的数据，无论是什么编码都在request . data中 3. 其他的使用和原生的request一模一样。
Django框架中序列化和反序列化的例子
09-18
这里的每个字段都对应着`BookInfo`模型的一个字段，`read_only=True`表示该字段只能在序列化时使用，不能在反序列化时修改。 **2. 序列化器的使用** 要使用序列化器，需要创建其实例，并传入要序列化的对象。例如，...
drf之接口、高级定制字段、多表关联
菜CAI的博客
09-01 295
drf之接口，高级定制字段、source的高级用法、以及多表关联
DRF的序列化——Serializers 序列化组件
01-20
为什么要用序列化组件 当我们做前后端分离的项目~~ 我们前后端交互一般都选择JSON数据格式，JSON是一个轻量级的数据交互格式。 那么我们给前端数据的时候都要转成json格式，那就需要对我们从数据库拿到的数据进行...
Django框架序列化与反序列化操作详解
01-20
使用`serialize()`函数进行序列化，而`deserialize()`函数（在DRF中是`to_representation()`和`to_internal_value()`方法）用于反序列化。 例如，当一个POST请求包含图书数据时，`BookInfoSerializer`会将这些数据...
3-drf-序列化组件的初步使用、序列化类中的高级用法source、高级用法定制字段、高级用法定制字段、反序列化校验总结
linjun的博客
08-31 194
序列化组件的初步使用、序列化类中的高级用法source、高级用法定制字段、高级用法定制字段、反序列化校验总结
drf : source，定制序列化字段以及反序列化新增。局部钩子(validate_字段名)，全局钩子(validate)...
felix的博客
04-01 411
source,SerializerMethodField,局部钩子，全局钩子 serialzer.py : source 用处1对应字段：起别名， 用处2对应方法：在表模型中定义一个方法，source可以与其关联 用处3对应方法：可以当做字段 第三种方法的扩展用法：使用程度高。 model.py from django.db import models # Create your mo...
drf自定义返回的外键类型:source+序列化器嵌套+model自定义字段
python_web全栈
02-04 4378
一. 序列化器单独放外键字段， 如果是不经过处理，会返回id: "teacher"返回外键的id值 二. source a. 适用于查询一个字段的 "teacher_name": "dbj"， b. 查询多个需要进行，写多个(不方便，如果是一层外键的话，我们一般用序列化器嵌套) teacher_name = serializers.CharField(source='teacher.name') teacher_id = serializers.CharField(source='teacher
DRF序列化器中，给字段起别名__source__
Victory_wbx的博客
07-02 2964
DRF序列化器中，给字段起别名__source__ 在djangorestframework中，当我们在反序列化和序列化时，如果出现需求和字段名不匹配时可以通过给字段起别名的方法解决 字段中的通用属性source可以连接到数据库中的字段 from rest_framework import serializers from goods.models import SPUSpecification...
DRF中的序列化器详细应用
qq_25068917的博客
07-17 3220
  视图的功能：说白了就是接收前端请求，进行数据处理 （这里的处理包括：如果前端是GET请求，则构造查询集，将结果返回，这个过程为序列化；如果前端是POST请求，假如要对数据库进行改动，则需要拿到前端发来的数据，进行校验，将数据写入数据库，这个过程称为反序列化） 最原始的视图可以实现这样的逻辑处理，但是针对不同的请求，需要在类视图中定义多个方法实现各自的处理，这样是可以解决问题，但是存在一个...
python-DRF_修改删除接口_source用法_模型类序列化器_SerializerMethodField_drf的请求响应_many=True_局部全局钩子解析
qq_31455841的博客
11-03 1043
hhhhhh
DRF十大组件用法和作用
cc576795555的博客
08-03 752
###################################################认证实现 自定义认证的类 """ from rest_framework.authentication import BaseAuthentication from rest_framework.exceptions import Authenticati...
修改删除接口,模型化序列化器,高级用法之source,SerializerMethodField,drf的请求与响应,many=True源码分析
yikenaoguazi的博客
11-05 373
day84一.昨日回顾二.今日内容1 修改,删除接口urls.pyviews.pyserializer.py2 高级用法之source3 模型化序列化器4 高级用法之SerializerMethodField5 drf的请求与响应7many=True源码分析,局部全局钩子源码解析扩展 一.昨日回顾 1 restful规范 -只是一个规范，规范了前后端交互的接口（api接口）格式 -10条 -https部署 -请求地址中有接口标识 -https://api.baidu.com -htt
Django框架序列化与反序列化实战解析
序列化过程通常在视图层（views.py）进行，通过实例化序列化器并传入模型实例。例如，要序列化一个特定的`BookInfo`对象，可以创建一个`BookInfoSerializer`实例，将模型对象作为`instance`参数传入，然后访问序列化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值