Serializers序列化组件

Django的序列化方法

　　.values 序列化结果

class BooksView(View):

    def get(self, request):

        book_list = Book.objects.values('id', 'title', 'chapter', 'pub_time', 'publisher')

        book_list = list(book_list)

        # 如果我们需要取外键关联的字段信息，需要循环获取外键，再去数据库查然后拼接成我们想要的

        ret = []

        for book in book_list:

            pub_dict = {}

            pub_obj = Publish.objects.filter(pk=book['publisher']).first()

            pub_dict['id'] = pub_obj.pk

            pub_dict['title'] = pub_obj.title

            book['publisher'] = pub_dict

            ret.append(book)

        ret = json.dumps(book_list, ensure_ascii=False, cls=MyJson)

        # json不能解决时间格式的数据

        return HttpResponse(ret)

# json.JSONEncoder.default()

# 解决json不能序列化时间字段的问题

class MyJson(json.JSONEncoder):

    def default(self, field):

        if isinstance(field, datetime.datetime):

            return field.strftime('%Y-%m-%d %H:%M:%S')

        elif isinstance(field, datetime.date):

            return field.strftime('%Y-%m-%d')

        else:

            return json.JSONEncoder.default(self, field)

　　django serializers

from django.core import serializers

# 能够得到我们要的效果，结构有点复杂

class BooksView(View):

    def get(self, request):

        book_list = Book.objects.all()

        ret = serializers.serialize('json', book_list)

        return HttpResponse(ret)

DRF序列化的方法

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

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

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

序列化

　　第一步，声明序列化类

// 定义一个序列化器类

class BookSerializer(serializers.Serializer):

    id = serializers.IntegerField()

    title = serializers.CharField(max_length=32)

    CHOICES = ((1, 'Linux'),(2,'Django'),(3,'Python'))

    chapter = serializers.ChoiceField(choices=CHOICES,

        source='get_chapter_display')

    pub_time = serializers.DateField()

　　第二步，序列化对象

from rest_framework.views import APIView

from rest_framework.response import Response

class BookView(APIView):

    def get(self, request):

        book_list = Book.objects.all()

        # 序列化对象，many=True为可以序列化多个

        ret = BookSerializer(book_list, many=True)

        # 序列化的数据存放在data中

        return Response(ret.data)

外键关系的序列化

from rest_framework import serializers

from .models import Book
　　

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

class UserSerializer(serializers.Serializer):
　　id = serializers.IntegerField(read_only=True)
　　name = serializers.CharField(max_length=32)
　　age = serializers.IntegerField()

class BookSerializer(serializers.Serializer):
　　id = serializers.IntegerField(read_only=True)
　　title = serializers.CharField(max_length=32)
　　CHOICES = ((1,'Linux'),(2,'Python'),(3,'Go'))
　　category= serializers.ChoiceField(choices=CHOICES,
　　source='get_category_display',read_only=True)
　　pub_time = serializers.DateField()

　　publisher = PublisherSerializer(read_only=True)
　　user = UserSerializer(many=True,read_only=True)

反序列化

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

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

Serializer提供了.is_vaild()和.save()方法~~

　　反序列化serializer.py

class BookSerializer(serializers.Serializer):

    id = serializers.IntegerField(read_only=True)
　　title = serializers.CharField(max_length=32)
　　CHOICES = ((1,'Linux'),(2,'Python'),(3,'Go'))
　　category = serializers.ChoiceField(choices=CHOICES,
　　　　source='get_category_display',read_only=True)
　　post_category = serializers.IntegerField(write_only=True)
　　pub_time = serializers.DateField()
　　
　　publisher = PublisherSerializer(read_only=True)
　　user = UserSerializer(many=True, read_only=True)

　　users = serializers.ListField(write_only=True)
　　publisher_id = serializers.IntegerField(write_only=True)

　　def create(self, validated_date):
　　　　book = Book.objects.create(title=validated_data['title'],
　　　　category=validated_data['post_category'], pub_time=validate_data['pub_time'],
　　　　publisher_id=validated_data['publisher_id'])
　　　　book.user.add(*validated_data['users'])
　　　　return book

　　反序列化views.py

class BookView(APIView):

    def get(self, request):

        book_list = Book.objects.all()

        ret = BookSerializer(book_lilst, many=True)

        return Response(ret.data)

    def post(self, request):

        serializer = BookSerializer(data=request.data)

        if serializer.is_valid():

            serializer.save()

            return Response(serializer.validated_data)

        else:

            return Response(serializer.errors)

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

　　PATCH请求Serializers.py

class BookSerializer(serializers.Serializer):

    id = serializers.IntegerField(read_only=True)
　　title = serializers.CharField(max_length=32)
　　CHOICES = ((1,'Linux'),(2,'Python'),(3,'Go'))
　　category = serializers.ChoiceField(choices=CHOICES,
　　　　source='get_category_display',read_only=True)
　　post_category = serializers.IntegerField(write_only=True)
　　pub_time = serializers.DateField()
　　
　　publisher = PublisherSerializer(read_only=True)
　　user = UserSerializer(many=True, read_only=True)

　　users = serializers.ListField(write_only=True)
　　publisher_id = serializers.IntegerField(write_only=True)

　　def create(self, validated_date):
　　　　book = Book.objects.create(title=validated_data['title'],
　　　　category=validated_data['post_category'], pub_time=validate_data['pub_time'],
　　　　publisher_id=validated_data['publisher_id'])
　　　　book.user.add(*validated_data['users'])
　　　　return book
　　
　　def update(self, instance, validated_data):
　　　　instance.title = validated_data.get('title',instance.title)

　　　　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

　　put请求views.py

# 更新函数

class BookEditView(APIView):

    def put(self, request, id):

        book_obj = Book.objects.filter(id=id).first()

        ser_obj = BookSerializer(instance=book_obj, data=request.data, partial=True)

        if ser_obj.is_valid():

            ser_obj.save()

            return Response(ser_obj.validated_data)

        return Response(ser_obj.errors)

验证--钩子函数

　　自定义验证钩子函数

# validators验证器
def my_validate(value):

    print(1111)

    if "敏感信息" in value.lower():

        raise serializers.ValidationError("有敏感词汇")

    return value

　　单个字段的钩子函数

class BookSerializer(serializers.Serializer):

    id = serializers.IntegerField(required=False)

    # 自定义钩子函数的使用

    title = serializers.CharField(max_length=32, validators=[my_validate,])

    # 单个验证函数，title这个字段必须在要序列化的字段中

    # validate_字段名

    def validate_title(self, value):

        # value就是title的值 对value处理

        if "python" not in value.lower():

            raise serializers.ValidationError("标题必须含有python")

        return value

　　多个字段的验证

    def validate(self, attrs):

        # attrs 是你传过来的所有的字段信息组成的字典

        if "python" in attrs["title"].lower() or attrs["post_category"] == 1:

            return attrs

        else:

            raise serializers.ValidationError("分类或标题不合符要求")

　　权重关系：　

　　　　自定义验证 > 单个字段的验证 > 多个字段的验证　

ModelSerializer

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

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

定义一个ModelSerializer序列化

class BookSerializer(serializers.ModelSerializer):

        class Meta:

        model = Book

        fields = "__all__"

        # exclude=["id"]

        # 会让你这些所有的外键关系变成read_only = True
        # depth 代表找嵌套关系的第几层，

        # depth = 1  # 外键关系的序列化

        # 可以实现字段的不展现

        extra_kwargs = {"publisher": {"write_only": True}, "authors":

                 {"write_only": True}}

SerializerMethodField

外键关联的对象有很多字段我们是用不到的~都传给前端会有数据冗余~就需要我们自己去定制序列化外键对象的哪些字段~~

class BookSerializer(serializers.ModelSerializer):

    # SerializerMethodField方法调用get_authors_info这个方法并把返回值传给publisher_info

    # 并在页面上展现出来
pu  publisher_info = serializers.SerializerMethodField(read_only=True)

    authors_info = serializers.SerializerMethodField(read_only=True)

    def get_authors_info(self, obj):

        # obj 就是序列化的每个Book对象

        authors_querset = obj.authors.all()

        return [{"id": author.id, "name": author.name} for author in authors_querset]

    def get_publisher_info(self, obj):

        publisher_obj = obj.publisher

        return {"id": publisher_obj.id, "title": publisher_obj.title}

    class Meta:

        model = Book

        fields = "__all__"

        # exclude=["id"]

        # 会让你这些所有的外键关系变成read_only = True

        # depth = 1
        # 可以让一些字段不在页面上展现出来

        extra_kwargs = {"publisher": {"write_only": True}, "authors":{"write_only": True}}

POST请求：重写了create方法

PUT/PATCH请求：重写update方法

save() 方法其实是调用了create方法

巴特西