DRF初识与序列化

2023-07-27 14:27:52

一、Django的序列化方法

1、为什么要用序列化组件

做前后端分离的项目，我们前后端数据交互一般都选择JSON，JSON是一个轻量级的数据交互格式。
那么我们给前端数据的时候都要转成json格式，那就需要对我们从数据库拿到的数据进行序列化。

2、表的构建

CHOICES = ((1, "python"), (2, "linux"), (3, "go"))

# 书籍表

class Book(models.Model):

    title = models.CharField(max_length=64)

    category = models.IntegerField(choices=CHOICES)  # 书籍分类

    pub_time = models.DateField()

    publisher = models.ForeignKey(to="Publisher")

    authors = models.ManyToManyField(to="Author")

    class Meta:

        verbose_name = '书籍'

        verbose_name_plural = verbose_name

    def __str__(self):

        return self.title

# 出版社表

class Publisher(models.Model):

    title = models.CharField(max_length=64)

    class Meta:

        verbose_name = '出版社'

        verbose_name_plural = verbose_name

    def __str__(self):

        return self.title

# 作者表

class Author(models.Model):

    name = models.CharField(max_length=32)

    class Meta:

        verbose_name = '作者'

        verbose_name_plural = verbose_name

    def __str__(self):

        return self.name

3、希望构建的字典格式

book_list = [

    {

        "id": 1,

        "title": "",

        "publisher": {  # 外键

            "id": 1

            "title": ""

        },

        "authors": [{}, {}]  # 多对多

    },

    {

        "id": 2,

        "title": "",

        "publisher": {  # 外键

            "id": 1

            "title": ""

        },

        "authors": [{}, {}]  # 多对多

    },

]

4、方法一

在Django中使用Json模块序列化

class BooksView(views.View):

    def get(self, request):

        book_queryset = Book.objects.values("id", "title", "pub_time", "publisher")

        book_list = list(book_queryset)  # 把queryset类型转换成列表

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

        ret = []

        for book in book_list:

            publisher_obj = Publisher.objects.filter(id=book["publisher"]).first()

            # 修改原字典中的publisher对应的值

            book["publisher"] = {

                "id": publisher_obj.id,

                "title": publisher_obj.title

            }

            # 把新的字典追加到一个空列表中

            ret.append(book)

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

        return HttpResponse(ret)

# json不能序列化时间字段,重写JSONEncoder里面的default方法解决

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)

5、方法二

使用JsonResponse，自动帮我们重写了JSONEncoder里面的default方法，解决时间字段的问题

class BooksView(views.View):

    def get(self, request):

        book_queryset = Book.objects.values("id", "title", "pub_time", "publisher")

        book_list = list(book_queryset)  # 把queryset类型转换成列表

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

        ret = []

        for book in book_list:

            publisher_obj = Publisher.objects.filter(id=book["publisher"]).first()

            # 修改原字典中的publisher对应的值

            book["publisher"] = {

                "id": publisher_obj.id,

                "title": publisher_obj.title

            }

            # 把新的字典追加到一个空列表中

            ret.append(book)

        return JsonResponse(ret, safe=False, json_dumps_params={'ensure_ascii': False})

6、方法三

使用Django自带的序列化模块

from django.core import serializers

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

class BooksView(views.View):

    def get(self, request):

        book_queryset = Book.objects.all()

        ret = serializers.serialize("json", book_queryset, ensure_ascii=False)

        return HttpResponse(ret)

二、DRF序列化的介绍

1、介绍

下载DRF模块：pip install djangorestframework

导入：

    from rest_framework.views import APIView

    from rest_framework.response import Response

使用DRF默认的页面，需要在settings的APP注册rest_framework

INSTALLED_APPS = [

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'rest_framework',

]

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

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

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

2、APIView跟View区别

-- APIView继承了View

-- APIView的as_view方法实现了csrf中间件的豁免(用DRF不需要再把settings的csrf中间件注释掉了)

-- 重新封装了request

    request._request可以拿到旧的request

    request.query_params  旧的request.GET即_request.GET

    request.data    除了GET请求外的所有的数据,_request.POST、_request.FILES等
-- 序列化器对象.data
　　存放序列化好的数据
　　校验通过的数据存放到validated_data里，最后也会序列化封装到序列化对象.data里面返回给前端
　　校验不通过，错误信息存到序列化对象.errors里面
-- DRF有自己的序列化模块
　　from rest_framework import serializers

-- Response

　　继承了HttpResponse

　　携带HTTP标准状态码

　　做模板的渲染

3、使用方法

-- 序列化(传数据到前端)

    -- 声明一个序列化器

        class BookSerializer(serializers.Serializer):

            id = serializers.IntegerField(required=False)

            title = serializers.CharField(max_length=32)

            pub_time = serializers.DateField()

    -- 视图里序列化我们的queryset或者某个对象

        # queryset需要声明many=True

        ser_obj = BookSerializer(queryset, many=True)

        # 具体的某个的对象则不需要声明

        ser_obj = BookSerializer(book_obj)

        return Response(ser_obj.data)

    -- 实现流程

        -- 如果指定了many=True

        -- 把queryset当成可迭代对象去循环 得到每个模型对象

        -- 把每个模型对象放入序列号器进行序列化

        -- 进行字段匹配 匹配上的字段进行序列化 匹配不上丢弃

        -- 必须满足序列化的所有字段要求

-- 反序列化(从前端获取数据)

    -- 获取前端传过来的数据

    -- 用序列化器进行校验

        # 新增一条数据

        ser_obj = BookSerializer(data=request.data)

        # 编辑某条数据

        # instance编辑哪个对象，data前端传过来要跟新的某些字段数据，partial表示允许部分跟新

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

        if ser_obj.is_valid():

            ser_obj.save()# 调用create/update方法

            return Response(ser_obj.data)

        else:

            return Response(ser_obj.errors)

    -- 写create方法

        在create方法里用ORM操作创建新对象

    -- 写update方法

        在update方法里用ORM操作创编辑对象

4、注意事项

1. 外键和多对多字段的序列化需要额外再设置序列化器

2. 序列化

    序列化器的参数是queryset和many

3. 反序列化

    序列化器的参数是data=提交上来的数据

4. 序列化器字段类型不统一的情况

    反序列化要用的一些字段通过一些参数跟序列化区分开

    -- required=False

    -- read_only=True

    -- write_only=True

5. 反序列化的验证

    is_valid()    　　 --> 校验数据

    post请求中的save()  --> 调用序列化器的create方法
　　put请求中的save()    --> 调用序列化器的update方法

三、DRF序列化示例

1、声明序列化器

# serializers.py文件

from rest_framework import serializers

from libsys.models import Book

CHOICES = ((1, "python"), (2, "linux"), (3, "go"))

# 继承serializers.Serializer

class PublisherSerializer(serializers.Serializer):

    id = serializers.IntegerField()

    title = serializers.CharField(max_length=64)

class AuthorSerializer(serializers.Serializer):

    id = serializers.IntegerField()

    name = serializers.CharField(max_length=32)

# 字段的声明和models相类似

class BookSerializer(serializers.Serializer):

    # POST校验的时候required=False声明不需要校验这个字段

    id = serializers.IntegerField(required=False)

    title = serializers.CharField(max_length=64)

    pub_time = serializers.DateField()

    # 选择字段，显示的是数字

    # category = serializers.ChoiceField(choices=CHOICES)

    # 把选择字段显示成字符类型，source参数后面跟的是ORM操作

    # read_only=True表示这个字段只在渲染前端的时候使用

    category = serializers.CharField(source='get_category_display', read_only=True)

    # write_only=True表示这个字段只在POST提交数据，做校验的时候使用

    post_category = serializers.IntegerField(write_only=True)

    # 外键需要设置额外的序列化器对它进行序列化

    publisher = PublisherSerializer(read_only=True)

    publisher_id = serializers.IntegerField(write_only=True)

    # 多对多字段需要设置额外的序列化器对它进行序列化，且声明many=True

    authors = AuthorSerializer(many=True, read_only=True)

    author_list = serializers.ListField(write_only=True)

    def create(self, validated_data):  # validated_data是通过校验的数据，最后也会封装到data里面

        #通过ORM操作给Book表增加数据

        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"])

        return book_obj

    def update(self, instance, validated_data):

        # 通过ORM操作给Book表编辑数据

        # instance就是book_obj

        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", False):

            instance.authors.set(validated_data["author_list"])

        instance.save()

        return instance

2、在视图函数中调用

from libsys.models import Book, Publisher, Author

from rest_framework.views import APIView

from rest_framework.response import Response

from .serializers import BookSerializer

# Create your views here.

# 书籍列表

class BookView(APIView):

    def get(self, request):

        book_queryset = Book.objects.all()

        # 声明一个序列化器

        # 用序列化器去序列化queryset(queryset有多个对象的时候，需要声明many=True)

        # 把数据提交到序列化器，跟序列化器的字段进行匹配，匹配成功就进行序列化

        ser_obj = BookSerializer(book_queryset, many=True)

        return Response(ser_obj.data)

    # 新增书籍

    def post(self, request):

        # 前端传过来的数据应该也是这样的

        # {"id""title",

        #       category: 1

        #       publisher: 1

        #       authors: [1, 2]

        #  }

        # 获取前端传过来的数据

        book_obj = request.data

        # 用序列化器做校验

        ser_obj = BookSerializer(data=book_obj)

        if ser_obj.is_valid():

            # 校验通过，新增书籍

            ser_obj.save()  # 这里的save方法会去调用序列化器的create方法

            print(ser_obj.validated_data)  # validated_data是通过校验的数据，也会封装到data里面

            return Response(ser_obj.data)

        # 校验不通过返回错误信息

        return Response(ser_obj.errors)

# 编辑书籍

class BookEditView(APIView):

    def get(self, request, id):

        book_obj = Book.objects.filter(pk=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)

        if ser_obj.is_valid():

            ser_obj.save()

            return Response(ser_obj.data)

        return Response(ser_obj.errors)

四、验证

1、单个字段的验证(局部钩子)

class BookSerializer(serializers.Serializer):

    id = serializers.IntegerField(required=False)

    title = serializers.CharField(max_length=64)

    其他字段...

    # 局部钩子方法：validate_字段名,value 是提交过来的这个字段的数据

    def validate_title(self, value):

        # 定义校验规则：标题必须含有python、linux、go

        course_list = ['python', 'linux', 'go']

        for course in course_list:

            if course in value.lower():

                return value

        else:

            raise serializers.ValidationError('输入的书籍名不合法')

2、多个字段的验证(全局钩子)

class BookSerializer(serializers.Serializer):

    post_category = serializers.IntegerField(write_only=True)

    publisher_id = serializers.IntegerField(write_only=True)

    其他字段...

    # 全局钩子方法：validate,attrs 是前端传过来的所有的数据组成的字典

    def validate(self, attrs):

        # 定义校验规则：书籍分类和作者id不能超过3

        if attrs['post_category'] > 3 or attrs['publisher_id'] > 3:

            raise serializers.ValidationError('输入的图书分类或作者不存在')

        return attrs

3、自定义校验规则

def my_validate(value):

    if '周星星' in value:

        raise serializers.ValidationError('输入的书籍太帅，不合法')

    return value

class BookSerializer(serializers.Serializer):

    id = serializers.IntegerField(required=False)

    # validators声明校验的规则

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

4、校验的权重

自定义校验 > 局部钩子 > 全局钩子

五、ModelSerializer

1、介绍

跟Django的Form组件类似，我们使用DRF进行前后端数据交互，有很多需要序列化和反序列化的字段都跟models模型相关，
那么，DRF也给我们提供了跟模型紧密相关的序列化器：ModelSerializer
-- 继承serializers.ModelSerializer
-- 它和Form有点类似
-- 它会根据模型自动生成一组字段
-- 它默认实现了.update()以及.create()方法

2、定义ModelSerializer序列化器

class BookSerializer(serializers.ModelSerializer):

    class Meta:

        model = Book

        fields = "__all__"

        # fields = ["id", "title", "pub_time"]

        # exclude = ["user"]

        # 分别是所有字段 包含某些字段 排除某些字段

3、外键关系的字段

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

class BookSerializer(serializers.ModelSerializer):

    class Meta:

        model = Book

        fields = "__all__"

        # fields = ["id", "title", "pub_time"]

        # exclude = ["user"]

        # 分别是所有字段 包含某些字段 排除某些字段

        # depth 代表找嵌套关系的第几层

        depth = 1

4、META中的其他参数

class BookSerializer(serializers.ModelSerializer):

    class Meta:

        model = Book

        fields = "__all__"

        # fields = ["id", "title", "pub_time"]

        # exclude = ["user"]

        # 分别是所有字段 包含某些字段 排除某些字段

        # depth 代表找嵌套关系的第几层

        depth = 1

        # 只读字段

         read_only_fields = ["id"]

         # 给某些字段设置额外参数

        extra_kwargs = {"title": {"validators": [my_validate,]}}

5、SerializerMethodField方法字段

外键关联的对象有很多字段我们是用不到的，如果都传给前端会有数据冗余，

就需要我们自己去定制序列化外键对象的哪些字段。

使用了方法字段，它会自动去找对应的钩子函数(get_字段名)，这个方法字段展示的值就是钩子函数的返回值

钩子函数的参数obj：就是序列化的每个模型对象 book_obj

class BookSerializer(serializers.ModelSerializer):

    # 方法字段

    # SerializerMethodField 会去找钩子方法 钩子方法的返回值给这个字段

    # 钩子函数：get_字段名称

    category_text = serializers.SerializerMethodField(read_only=True)

    publisher_info = serializers.SerializerMethodField(read_only=True)

    author_info = serializers.SerializerMethodField(read_only=True)

    def get_category_text(self, obj):

        # obj就是序列化的每个模型对象 book_obj

        return obj.get_category_display()

    def get_publisher_info(self, obj):

        return {"id": obj.publisher_id, "title": obj.publisher.title}

    def get_author_info(self, obj):

        return [{"id": author.id, "name": author.name} for author in obj.authors.all()]

    class Meta:

        model = Book

        fields = "__all__"

6、完整的ModelSerializer思路

因为depth会让我们外键变成只读，所以一般来说我们不用它，

因为如果是前端发数据过来(post,put等)，我们对外键、多对多等字段进行验证是验证其在数据库的中真实值，

因此，把ModelSerializer序列化器fields代表的字段应该用于反序列化，而对序列化到前端的外键、多对多等字段的数据，

我们可以使用SerializerMethodField对其进行处理后展示到前端。

class BookSerializer(serializers.ModelSerializer):

    # 方法字段

    category_text = serializers.SerializerMethodField(read_only=True)

    publisher_info = serializers.SerializerMethodField(read_only=True)

    author_info = serializers.SerializerMethodField(read_only=True)

    # 方法字段的值，取决于它对应的方法字段的钩子函数的返回值

    def get_category_text(self, obj):

        # obj就是序列化的每个模型对象 book_obj

        return obj.get_category_display()

    def get_publisher_info(self, obj):

        return {"id": obj.publisher_id, "title": obj.publisher.title}

    def get_author_info(self, obj):

        return [{"id": author.id, "name": author.name} for author in obj.authors.all()]

    class Meta:

        model = Book

        fields = "__all__"

        # fields = ["id", "title", "pub_time"]

        # exclude = ["user"]

        # 分别是所有字段 包含某些字段 排除某些字段

        # depth 代表找嵌套关系的第几层

        # depth = 1

        extra_kwargs = {

            "category": {'write_only': True},

            "publisher": {'write_only': True},

            "authors": {'write_only': True},

        }

码农公寓

一、Django的序列化方法

1、为什么要用序列化组件

2、表的构建

3、希望构建的字典格式

4、方法一

5、方法二

6、方法三

二、DRF序列化的介绍

1、介绍

2、APIView跟View区别

3、使用方法

4、注意事项

三、DRF序列化示例

1、声明序列化器

2、在视图函数中调用

四、验证

1、 单个字段的验证(局部钩子)

2、 多个字段的验证(全局钩子)

3、 自定义校验规则

4、校验的权重

五、ModelSerializer

1、介绍

2、定义ModelSerializer序列化器

3、外键关系的字段

4、META中的其他参数

5、SerializerMethodField方法字段

6、完整的ModelSerializer思路

相关文章

1、单个字段的验证(局部钩子)

2、多个字段的验证(全局钩子)

3、自定义校验规则