Serializers 序列化组件

Serializers 序列化组件

 

为什么要用序列化组件

当我们做前后端分离的项目~~我们前后端交互一般都选择JSON数据格式，JSON是一个轻量级的数据交互格式。

那么我们给前端数据的时候都要转成json格式，那就需要对我们从数据库拿到的数据进行序列化。

接下来我们看下django序列化和rest_framework序列化的对比~~

Django的序列化方法

# 第一版 用values以及JsonResponse实现序列化(发现就简单的数据拿出来还这么费劲)
class BookView(View):
    def get(self, request):
        book_queryset = Book.objects.values("id", "title", "pub_time", "publisher")
        book_list = list(book_queryset)
        ret = []
        # 如果我们需要取外键关联的字段信息 需要循环获取外键 再去数据库查然后拼接成我们想要的
        for book in book_list:
            book["publisher"] = {
                "id": book["publisher"],
                "title": Publisher.objects.filter(id=book["publisher"]).first().title,
            }
            ret.append(book)
        # return HttpResponse(ret)  #
        return JsonResponse(ret, safe=False, json_dumps_params={"ensure_ascii": False})

# 第二版 django的序列化:用Django的serialize实现的序列化 不能序列化外键关系
class BookView(View):
    def get(self, request):
        book_queryset = Book.objects.all()
        data = serializers.serialize("json", book_queryset, ensure_ascii=False)
        return HttpResponse(data)

DRF序列化的方法

首先，我们要用DRF的序列化，就要遵循人家框架的一些标准，

　　-- pip install djangorestframework  # 安装

　　-- Django我们CBV继承类是View，现在DRF我们要用APIView

　　-- Django中返回的时候我们用HTTPResponse，JsonResponse，render ，DRF我们用Response

为什么这么用~我们之后会详细讲~~我们继续来看序列化~~

序列化

from rest_framework import serializers
from djangoDemo.models import Book


class PublisherSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)  # required=False 序列化去验证，反序列化不验证
    title = serializers.CharField(max_length=32)
    pub_time = serializers.DateField()
    category = serializers.CharField(source="get_category_display", read_only=True)  # source 后边参数都会当成ORM去操作
   
    publisher = PublisherSerializer(read_only=True)
    # 内部通过外键关系的id找到了publisher_obj
    # 然后实例化并传参 PublisherSerializer (publisher_obj)


    authors = AuthorSerializer(many=True, read_only=True)  # read_only = True  正序使用 反序不使用

# 查看所有的book
class BookView(APIView):

    def get(self, request):
        book_queryset = Book.objects.all()
        # 用序列化器进行序列化  能够匹配的就进行序列化 匹配不上的就抛弃
        ser_obj = BookSerializer(book_queryset, many=True)
        return Response(ser_obj.data)

反序列化

当前端给我们发post的请求的时候~前端给我们传过来的数据~我们要进行一些校验然后保存到数据库

这些校验以及保存工作，DRF的Serializer也给我们提供了一些方法

首先~我们要写反序列化用的一些字段~有些字段要跟序列化区分开

Serializer提供了.is_valid()  和.save()方法

from rest_framework import serializers
from djangoDemo.models import Book


class PublisherSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)  # required=False 序列化去验证，反序列化不验证
    title = serializers.CharField(max_length=32)
    pub_time = serializers.DateField()
    category = serializers.CharField(source="get_category_display", read_only=True)  # source 后边参数都会当成ORM去操作
    post_category = serializers.IntegerField(write_only=True)  # write_only=True正序不用，反序用

    publisher = PublisherSerializer(read_only=True)
    # 内部通过外键关系的id找到了publisher_obj
    # 然后实例化并传参 PublisherSerializer (publisher_obj)
    publisher_id = serializers.IntegerField(write_only=True)  # 只有反序使用

    authors = AuthorSerializer(many=True, read_only=True)  # read_only = True  正序使用 反序不使用
    author_list = serializers.ListField(write_only=True)

    def create(self, validated_data):
        # validated_data 校验通过通过的数据   就是book_obj
        # 通过ORM操作给 book表增加数据
        print(validated_data)
        book_obj = Book.objects.create(title=validated_data["title"],
                                       pub_time=validated_data["pub_time"],
                                       category=validated_data["post_category"],
                                       publisher_id=validated_data["publisher_id"])
        book_obj.authors.add(*validated_data["author_list"])  # 添加对应的作者
        print(book_obj)

        return book_obj  # 返回对象 不返回就报错

from rest_framework.views import APIView
from rest_framework.response import Response
from djangoDemo.models import Book
from .serializers import BookSerializer


# 查看所有的book
class BookView(APIView):

    def get(self, request):
        book_queryset = Book.objects.all()
        # 用序列化器进行序列化  能够匹配的就进行序列化 匹配不上的就抛弃
        ser_obj = BookSerializer(book_queryset, many=True)
        return Response(ser_obj.data)

    def post(self,request):
        # 确定数据类型以及数据解构
        # 对前端传过来的数据进行校验（前部数据不可信！）（序列化去做）
        book_obj = request.data  # 相当于request.POST
        # print(book_obj)
        ser_obj = BookSerializer(data=book_obj)  # 反序列化
        if ser_obj.is_valid():  # 如果检验成功
            ser_obj.save()  # 要调用create方法 需要去serializer中去写
            return Response(ser_obj.validated_data)  # 返回一个 ser_obj.validated_data 检验通过的数据

        return Response(ser_obj.errors)  # 没验证成功 就返回  ser_obj.errors 错误信息


# 查看单条book信息
class BookEditView(APIView):

    def get(self, request, id):
        book_obj = Book.objects.filter(id=id).first()
        ser_obj = BookSerializer(book_obj)
        return Response(ser_obj.data)

当前端给我们发送patch请求的时候，前端传给我们用户要更新的数据，我们要对数据进行部分验证

from rest_framework import serializers
from djangoDemo.models import Book


class PublisherSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)  # required=False 序列化去验证，反序列化不校验
    title = serializers.CharField(max_length=32)
    pub_time = serializers.DateField()
    category = serializers.CharField(source="get_category_display", read_only=True)  # source 后边参数都会当成ORM去操作
    post_category = serializers.IntegerField(write_only=True)  # write_only=True正序不用，反序用

    publisher = PublisherSerializer(read_only=True)
    # 内部通过外键关系的id找到了publisher_obj
    # 然后实例化并传参 PublisherSerializer (publisher_obj)
    publisher_id = serializers.IntegerField(write_only=True)  # 只有反序使用

    authors = AuthorSerializer(many=True, read_only=True)  # read_only = True  正序使用 反序不使用
    author_list = serializers.ListField(write_only=True)

    def create(self, validated_data):
        # validated_data 校验通过通过的数据   就是book_obj
        # 通过ORM操作给 book表增加数据
        print(validated_data)
        book_obj = Book.objects.create(title=validated_data["title"],
                                       pub_time=validated_data["pub_time"],
                                       category=validated_data["post_category"],
                                       publisher_id=validated_data["publisher_id"])
        book_obj.authors.add(*validated_data["author_list"])  # 添加对应的作者
        print(book_obj)

        return book_obj  # 返回对象 不返回就报错

    def update(self, instance, validated_data):
        # instance 更新的book_obj 对象
        # validated_data 校验通过的数据
        # ORM做更新操作
        instance.title = validated_data.get("title", instance.title)  # （ 拿到传过来的值，拿不到就用book对象自身的值）
        instance.pub_time = validated_data.get("pub_time", instance.pub_time)  # 同理
        instance.category = validated_data.get("post_category", instance.category)
        instance.publisher_id = validated_data.get("publisher_id", instance.publisher_id)
        if validated_data.get("author_list"):  # 取到作者（多对多）对应的值后
            instance.authors.set(validated_data["author_list"])  # 设置对应作者的关系表的值
        instance.save()  # 保存下所有的值
        return instance  # 返回book对象

from rest_framework.views import APIView
from rest_framework.response import Response
from djangoDemo.models import Book
from .serializers import BookSerializer


# 查看所有的book
class BookView(APIView):

    def get(self, request):
        book_queryset = Book.objects.all()
        # 用序列化器进行序列化  能够匹配的就进行序列化 匹配不上的就抛弃
        ser_obj = BookSerializer(book_queryset, many=True)
        return Response(ser_obj.data)

    def post(self, request):
        # 确定数据类型以及数据解构
        # 对前端传过来的数据进行校验（前部数据不可信！）（序列化去做）
        book_obj = request.data  # 相当于request.POST
        # print(book_obj)
        ser_obj = BookSerializer(data=book_obj)  # 反序列化
        if ser_obj.is_valid():  # 如果检验成功
            ser_obj.save()  # 要调用create方法 需要去serializer中去写
            return Response(ser_obj.validated_data)  # 返回一个 ser_obj.validated_data 检验通过的数据

        return Response(ser_obj.errors)  # 没验证成功 就返回  ser_obj.errors 错误信息


# 查看单条book信息
class BookEditView(APIView):

    def get(self, request, id):
        book_obj = Book.objects.filter(id=id).first()
        ser_obj = BookSerializer(book_obj)
        return Response(ser_obj.data)

    def put(self, request, id):
        book_obj = Book.objects.filter(id=id).first()
        ser_obj = BookSerializer(instance=book_obj, data=request.data, partial=True)
        #                       对象的本身传进去， 数据传进去，部分校验=true
        if ser_obj.is_valid():
            ser_obj.save()
            return Response(ser_obj.validated_data)  # 返回更新的内容
        return Response(ser_obj.errors)  # 返回错误信息

 验证

如果我们需要对一些字段进行自定义的验证~DRF也给我们提供了钩子方法

    # 暴露出来的钩子函数 单字段的校验
    def validate_title(self, value):
        print(1111)
        # vlaue 就是title的值，对value处理
        if "python" not in value.lower():
            raise serializers.ValidationError("title字段必须有python")
        return value

    # 多字段的钩子函数
    def validate(self, attrs):
        print(2222)
        # attrs 字典有你传过来的所有的字段
        print(attrs)
        if "python" in attrs["title"].lower() or attrs["post_category"] == 1:
            return attrs
        else:
            raise serializers.ValidationError("分类或标题不符合要求")

# 自己定义的校验方法需要配合字段使用   在字段中加入 validators=[my_validate, ]
def my_validate(value):
    print(333)
    if "敏感词汇" in value.lower():
        raise serializers.ValidationError("含有敏感词汇")
    return value

可以看出顺序是  自己定义的校验==》单子段的校验 ==》多字段校验

 ModelSerializer

现在我们已经清楚了Serializer的用法，会发现我们所有的序列化跟我们的模型都紧密相关

那么，DRF也给我们提供了跟模型紧密相关的序列化器  ModelSerializer

　　-- 它会根据模型自动生成一组字段

　　-- 它简单的默认实现了.update()以及.create()方法

定义一个ModelSerializer序列化器

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = "__all__"
        # fields = ["id", "title", "pub_time"]
        # exclude = ["user"]
        # 分别是所有字段 包含某些字段 排除某些字段

外键关系的序列化

注意：当序列化类MATE中定义了depth时，这个序列化类中引用字段（外键）则自动变为只读

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = "__all__"
        # fields = ["id", "title", "pub_time"]
        # exclude = ["user"]
        # 分别是所有字段 包含某些字段 排除某些字段
        depth = 1
# depth 代表找嵌套关系的第几层

自定义字段

我们可以声明一些字段来覆盖默认字段，来进行自定制~

比如我们的选择字段，默认显示的是选择的key，我们要给用户展示的是value。

class BookSerializer(serializers.ModelSerializer):
    chapter = serializers.CharField(source="get_chapter_display", read_only=True)
    
    class Meta:
        model = Book
        fields = "__all__"
        # fields = ["id", "title", "pub_time"]
        # exclude = ["user"]
        # depth = 1  #  外键的深度 ，外键的所有字段（比较冗余）（开发不常用，一般自己构造）

Meta中其它关键字参数

class BookSerializer(serializers.ModelSerializer):
    chapter = serializers.CharField(source="get_chapter_display", read_only=True)

    class Meta:
        model = Book
        fields = "__all__"
        # fields = ["id", "title", "pub_time"]
        # exclude = ["user"]
        # 分别是所有字段 包含某些字段 排除某些字段
        depth = 1
        read_only_fields = ["id"]
        extra_kwargs = {"title": {"validators": [my_validate,]}}

post以及patch请求

由于depth会让我们外键变成只读，所以我们再定义一个序列化的类，其实只要去掉depth就可以了~~

class BookSerializer(serializers.ModelSerializer):
        chapter = serializers.CharField(source="get_chapter_display", read_only=True)
        class Meta:
        model = Book
        fields = "__all__"
        # depth 会让所有的外键关系字段变成read_only = True
        # depth = 1  #  外键的深度 ，外键的所有字段（比较冗余）（开发不常用，一般自己构造）
        extra_kwargs = {"publisher": {"write_only": True}, "authors": {"write_only": True}}  # 反序校验的字段

SerializerMethodField

外键关联的对象有很多字段我们是用不到的~都传给前端会有数据冗余~就需要我们自己去定制序列化外键对象的哪些字段,然后现在回写成下边这样的

class BookSerializer(serializers.ModelSerializer):
    chapter = serializers.CharField(source="get_chapter_display", read_only=True)

    class Meta:
        model = Book
        fields = "__all__"
        # fields = ["id", "title", "pub_time"]
        # exclude = ["user"]
        # 分别是所有字段 包含某些字段 排除某些字段
        read_only_fields = ["id"]
        extra_kwargs = {"title": {"validators": [my_validate,]}}

用ModelSerializer改进上面Serializer的完整版

class BookSerializer(serializers.ModelSerializer):
    dis_chapter = serializers.SerializerMethodField(read_only=True)
    users = serializers.SerializerMethodField(read_only=True)
    publishers = serializers.SerializerMethodField(read_only=True)

    def get_users(self, obj):
        # obj是当前序列化的book对象
        users_query_set = obj.user.all()
        return [{"id": user_obj.pk, "name": user_obj.name} for user_obj in users_query_set]

    def get_publishers(self, obj):
        publisher_obj = obj.publisher
        return {"id": publisher_obj.pk, "title": publisher_obj.title}

    def get_dis_chapter(self, obj):
        return obj.get_chapter_display()

    class Meta:
        model = Book
        # fields = "__all__"
        # 字段是有序的
        fields = ["id", "title","dis_chapter", "pub_time", "publishers", "users","chapter", "user", "publisher"]
        # exclude = ["user"]
        # 分别是所有字段 包含某些字段 排除某些字段
        read_only_fields = ["id", "dis_chapter", "users", "publishers"]
        extra_kwargs = {"title": {"validators": [my_validate,]}, "user": {"write_only": True}, "publisher": {"write_only": True},
                        "chapter": {"write_only": True}}