Django用rest_framework里的serializers.ModelSerializer序列化

已于 2022-12-12 12:25:23 修改
阅读量1.2k 收藏 8
点赞数
分类专栏： # rest_framework 文章标签： 序列化
于 2019-07-25 15:53:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsx1314lovezyf/article/details/97267556
版权

序列化组件的使用及接口设计

  1. 请求接口设计get请求所有数据(restapi规范)

      GET						127.0.0.1:8000/books/			# 获取所有数据, 返回值:[{}, {}, {}]
  GET						127.0.0.1:8000/books/{id}       # 获取一条数据, 返回值:{}
  POST					    127.0.0.1:8000/books/			# 新增一条数据, 返回值:{}
  PUT						127.0.0.1:8000/books/{id}       # 修改一条数据, 返回值:{}
  DELETE                    127.0.0.1:8000/books/{id}       # 删除一条数据, 返回值: 空对象

  2. 创建model.py

    1. python manage.py makemigrations
    2. python manage.py migrate
3. urls.py

4. views.py

   1. 开始使用序列化

      1. 导入模块 from rest_framework import serializers

      2. 建立一个序列化类

         ```python
         class BookSerializer(serializers.ModelSerializer):
           	字段可以自定义
         ```

         

      3. 获取queryset

         ​	origin_data = BookInfo.objects.all()

      4. 开始序列化

            serialized_data = BookSerializer(origin_data, many=True )

      5. 序列化后的数据, 返回给客户端

         return Response(serialized_data.data)

GET所有数据案例

  1. 创建模型类

    from django.db import models

from datetime import datetime
# from django.contrib.auth.models import AbstractUser


class AuthorInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者名称")
    age = models.IntegerField(verbose_name="作者年龄")

    class Meta:
        db_table = "db_author_info"
        verbose_name = "作者信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class PublishInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="出版社名称")
    city = models.CharField(max_length=32, verbose_name="出版社所在城市")
    email = models.EmailField(verbose_name="出版社邮箱")

    class Meta:
        db_table = "db_publish_info"
        verbose_name = "出版社信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class BookInfo(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")
    publishDate = models.DateField(default=datetime.now, verbose_name="出版日期")

    # max_digits小数位加整数位多少长度 decimal_places小数位长度为2
    price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="图书价格")
    
    # on_delete
    # CASCADE:这就是默认的选项，级联删除，你无需显性指定它。
		# PROTECT: 保护模式，如果采用该选项，删除的时候，会抛出ProtectedError错误。
		# SET_NULL: 置空模式，删除的时候，外键字段被设置为空，前提就是blank=True, null=True,定义该字段的时候，允许为空。
		# SET_DEFAULT: 置默认值，删除的时候，外键字段设置为默认值，所以定义外键的时候注意加上一个默认值。
		# SET(): 自定义一个值，该值当然只能是对应的实体了
    publish = models.ForeignKey(PublishInfo, related_name="book", related_query_name="book_query", on_delete=models.CASCADE, verbose_name="出版社")
    # ManyToManyField多对多
    authors = models.ManyToManyField(AuthorInfo, verbose_name="图书作者")

    class Meta:
        db_table = "db_book_info"
        verbose_name = "图书信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.title

  2. 创建urls.py

    from django.urls import re_path
from .views import BookView

urlpatterns = [
  	# restapi风格定制路由
    re_path(r"^books/$", BookView.as_view()),
]

  3. 创建views.py

    1. 导入模块

      # 第一步: 导入模块
from rest_framework import serializers

    2. 建立序列化类

      class BookSerializer(serializers.ModelSerializer):
    class Meta:
        # 指定    要操作的模型类
        model = BookInfo

        # 指定序列化的字段
        fields = (
            "title",
            "price",
            "publishDate",
            "publish",
            "authors",
            "author_list",
            "publish_name",
            "publish_city"
        )

        # 指定那些字段是只写的
        # write_only只写的 (只写的 前端发送数据时要写它, 后端返回数据时没有它)
        extra_kwargs = {
            "publish": {"write_only": True},
            "authors": {"write_only": True}
        }

    # 自定义的字段
    # read_only只读的 (只读的 前端发送数据时不用写它, 后端返回数据时有它)
    publish_name = serializers.CharField(max_length=32, read_only=True, source="publish.name")
    publish_city = serializers.CharField(max_length=32, read_only=True, source="publish.city")

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, book_obj):
        # 拿到queryset开始循环 [ {}, {}, {}]
        authors = []
				
        # book_obj.authors.all() 获取所有author对象
        for author in book_obj.authors.all():
            authors.append(author.name)
        return authors

    3. 获取queryset/开始序列化/序列化后的数据, 返回给客户端

      from rest_framework.views import APIView
# Response返回序列化对象
from rest_framework.response import Response

from .models import BookInfo, PublishInfo, AuthorInfo
from .app_serializers import BookSerializer


class BookView(APIView):
    def get(self, request):
        # 第三步: 获取queryset
        origin_data = BookInfo.objects.all()

        # 第四步: 开始序列化
        # 当序列化多条数据时 要加上many=True
        serialized_data = BookSerializer(origin_data, many=True)
				
     # 返回序列化对象
        # 记住序列化的值在data属性里
        # 所以这里用serialized_data.data取序列化的值
        return Response(serialized_data.data)

    4. postman效果图
      在这里插入图片描述

序列化组件的使用及接口设计

  1. 请求接口设计post新增一条数据(restapi规范)

    GET						127.0.0.1:8000/books/			# 获取所有数据, 返回值:[{}, {}, {}]
GET						127.0.0.1:8000/books/{id}       # 获取一条数据, 返回值:{}
POST					127.0.0.1:8000/books/			# 新增一条数据, 返回值:{}
PUT						127.0.0.1:8000/books/{id}       # 修改一条数据, 返回值:{}
DELETE                  127.0.0.1:8000/books/{id}       # 删除一条数据, 返回值: 空对象

  2. 创建model.py

    1. python manage.py makemigrations
    2. python manage.py migrate

  3. urls.py

  4. views.py

    1. 开始使用序列化

      1. 导入模块 from rest_framework import serializers

      2. 建立一个序列化类

        class BookSerializer(serializers.ModelSerializer):
  	字段可以自定义

      3. 获取客户端请求数据
        client_data = request.data

      4. 开始序列化

        verified_data = BookSerializer(data=client_data, many=False)

      5. 写入数据库
        verified_data.save()

      6. 序列化后的数据, 返回给客户端

        return Response(serialized_data.data)

POST案例

  1. 创建模型类

    from django.db import models

from datetime import datetime
# from django.contrib.auth.models import AbstractUser


class AuthorInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者名称")
    age = models.IntegerField(verbose_name="作者年龄")

    class Meta:
        db_table = "db_author_info"
        verbose_name = "作者信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class PublishInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="出版社名称")
    city = models.CharField(max_length=32, verbose_name="出版社所在城市")
    email = models.EmailField(verbose_name="出版社邮箱")

    class Meta:
        db_table = "db_publish_info"
        verbose_name = "出版社信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class BookInfo(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")
    publishDate = models.DateField(default=datetime.now, verbose_name="出版日期")

    # max_digits小数位加整数位多少长度 decimal_places小数位长度为2
    price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="图书价格")
    
    # on_delete
    # CASCADE:这就是默认的选项，级联删除，你无需显性指定它。
		# PROTECT: 保护模式，如果采用该选项，删除的时候，会抛出ProtectedError错误。
		# SET_NULL: 置空模式，删除的时候，外键字段被设置为空，前提就是blank=True, null=True,定义该字段的时候，允许为空。
		# SET_DEFAULT: 置默认值，删除的时候，外键字段设置为默认值，所以定义外键的时候注意加上一个默认值。
		# SET(): 自定义一个值，该值当然只能是对应的实体了
    publish = models.ForeignKey(PublishInfo, related_name="book", related_query_name="book_query", on_delete=models.CASCADE, verbose_name="出版社")
    # ManyToManyField多对多
    authors = models.ManyToManyField(AuthorInfo, verbose_name="图书作者")

    class Meta:
        db_table = "db_book_info"
        verbose_name = "图书信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.title

  2. 创建urls.py

    from django.urls import re_path
from .views import BookView

urlpatterns = [
  	# restapi风格定制路由
    re_path(r"^books/$", BookView.as_view()),
]

  3. 创建views.py

    1. 导入模块

      # 第一步: 导入模块
from rest_framework import serializers

    2. 建立序列化类

      class BookSerializer(serializers.ModelSerializer):
    class Meta:
        # 指定    要操作的模型类
        model = BookInfo

        # 指定序列化的字段
        fields = (
            "title",
            "price",
            "publishDate",
            "publish",
            "authors",
            "author_list",
            "publish_name",
            "publish_city"
        )

        # 指定那些字段是只写的
        # write_only只写的 (只写的 前端发送数据时要写它, 后端返回数据时没有它)
        extra_kwargs = {
            "publish": {"write_only": True},
            "authors": {"write_only": True}
        }

    # 自定义的字段
    # read_only只读的 (只读的 前端发送数据时不用写它, 后端返回数据时有它)
    publish_name = serializers.CharField(max_length=32, read_only=True, source="publish.name")
    publish_city = serializers.CharField(max_length=32, read_only=True, source="publish.city")

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, book_obj):
    	#  book_obj是BookInfo的对象
        # 拿到queryset开始循环 [ {}, {}, {}]
        authors = []
				
        # book_obj.authors.all() 获取所有author对象
        for author in book_obj.authors.all():
            authors.append(author.name)
        return authors

    3. 获取queryset/开始序列化/序列化后的数据, 返回给客户端

      from rest_framework.views import APIView
# Response返回序列化对象
from rest_framework.response import Response

from .models import BookInfo, PublishInfo, AuthorInfo
from .app_serializers import BookSerializer


class BookView(APIView):
    def get(self, request):
        # 第三步: 获取queryset
        origin_data = BookInfo.objects.all()

        # 第四步: 开始序列化
        # 当序列化多条数据时 要加上many=True
        serialized_data = BookSerializer(origin_data, many=True)
				
     # 返回序列化对象
        # 记住序列化的值在data属性里
        # 所以这里用serialized_data.data取序列化的值
        return Response(serialized_data.data)
    def post(self, request):
     # 接受前端发送的json数据
        client_data = request.data

        # many默认是False, 可以省略不写
        # 开始序列化
        verified_data = BookSerializer(data=client_data, many=False)
        # 判断序列化数据的合法性
        if verified_data.is_valid():
            # 当执行save()直接保存到数据库
            verified_data.save()

            return Response(verified_data.data)
        else:
            return Response(verified_data.errors)

    4. postman效果图
      在这里插入图片描述

序列化组件的使用及接口设计

  1. 请求接口设计get请求单个数据(restapi规范)

      GET						127.0.0.1:8000/books/			# 获取所有数据, 返回值:[{}, {}, {}]
  GET						127.0.0.1:8000/books/{id}       # 获取一条数据, 返回值:{}
  POST					    127.0.0.1:8000/books/			# 新增一条数据, 返回值:{}
  PUT						127.0.0.1:8000/books/{id}       # 修改一条数据, 返回值:{}
  DELETE                    127.0.0.1:8000/books/{id}       # 删除一条数据, 返回值: 空对象

  2. 创建model.py

    1. python manage.py makemigrations
    2. python manage.py migrate
3. urls.py

4. views.py

   1. 开始使用序列化

      1. 导入模块 from rest_framework import serializers

      2. 建立一个序列化类

         ```python
         class BookSerializer(serializers.ModelSerializer):
           	字段可以自定义
         ```

         

      3. 获取queryset

         ​	book_obj = BookInfo.objects.get(id=1)

      4. 开始序列化

            serialized_data = BookSerializer(book_obj, many=False)

      5. 序列化后的数据, 返回给客户端

         return Response(serialized_data.data)

GET单个数据案例

  1. 创建模型类

    from django.db import models

from datetime import datetime
# from django.contrib.auth.models import AbstractUser


class AuthorInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者名称")
    age = models.IntegerField(verbose_name="作者年龄")

    class Meta:
        db_table = "db_author_info"
        verbose_name = "作者信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class PublishInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="出版社名称")
    city = models.CharField(max_length=32, verbose_name="出版社所在城市")
    email = models.EmailField(verbose_name="出版社邮箱")

    class Meta:
        db_table = "db_publish_info"
        verbose_name = "出版社信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class BookInfo(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")
    publishDate = models.DateField(default=datetime.now, verbose_name="出版日期")

    # max_digits小数位加整数位多少长度 decimal_places小数位长度为2
    price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="图书价格")
    
    # on_delete
    # CASCADE:这就是默认的选项，级联删除，你无需显性指定它。
		# PROTECT: 保护模式，如果采用该选项，删除的时候，会抛出ProtectedError错误。
		# SET_NULL: 置空模式，删除的时候，外键字段被设置为空，前提就是blank=True, null=True,定义该字段的时候，允许为空。
		# SET_DEFAULT: 置默认值，删除的时候，外键字段设置为默认值，所以定义外键的时候注意加上一个默认值。
		# SET(): 自定义一个值，该值当然只能是对应的实体了
    publish = models.ForeignKey(PublishInfo, related_name="book", related_query_name="book_query", on_delete=models.CASCADE, verbose_name="出版社")
    # ManyToManyField多对多
    authors = models.ManyToManyField(AuthorInfo, verbose_name="图书作者")

    class Meta:
        db_table = "db_book_info"
        verbose_name = "图书信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.title

  2. 创建urls.py

    from django.urls import re_path
from .views import BookView

urlpatterns = [
  	# restapi风格定制路由
    re_path(r"^books/(\d+)/$", BookFilterView.as_view())
]

  3. 创建views.py

    1. 导入模块

      # 第一步: 导入模块
from rest_framework import serializers

    2. 建立序列化类

      class BookSerializer(serializers.ModelSerializer):
    class Meta:
        # 指定    要操作的模型类
        model = BookInfo

        # 指定序列化的字段
        fields = (
            "title",
            "price",
            "publishDate",
            "publish",
            "authors",
            "author_list",
            "publish_name",
            "publish_city"
        )

        # 指定那些字段是只写的
        # write_only只写的 (只写的 前端发送数据时要写它, 后端返回数据时没有它)
        extra_kwargs = {
            "publish": {"write_only": True},
            "authors": {"write_only": True}
        }

    # 自定义的字段
    # read_only只读的 (只读的 前端发送数据时不用写它, 后端返回数据时有它)
    publish_name = serializers.CharField(max_length=32, read_only=True, source="publish.name")
    publish_city = serializers.CharField(max_length=32, read_only=True, source="publish.city")

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, book_obj):
        # 拿到queryset开始循环 [ {}, {}, {}]
        authors = []
				
        # book_obj.authors.all() 获取所有author对象
        for author in book_obj.authors.all():
            authors.append(author.name)
        return authors

    3. 获取queryset/开始序列化/序列化后的数据, 返回给客户端

       from django.shortcuts import render
 from django.http import JsonResponse
 
 from rest_framework.views import APIView
 
 from rest_framework.response import Response
 
 from .models import BookInfo, PublishInfo, AuthorInfo
 from .app_serializers import BookSerializer
 
 class BookFilterView(APIView):
     def get(self, request, book_id):
         try:
             book_obj = BookInfo.objects.get(id=book_id)
         except BookInfo.DoesNotExist:
             book_obj = None
 
         if book_obj is None:
             return JsonResponse({"error": "该书不存在"})
 
         # 开始序列化 序列化book_obj
         # many=False 指序列化一条数据
         serialized_data = BookSerializer(book_obj, many=False)
 
         return Response(serialized_data.data)

    4. postman效果图
      在这里插入图片描述

序列化组件的使用及接口设计

  1. 请求接口设计put修改单个数据(restapi规范)

      GET						127.0.0.1:8000/books/			# 获取所有数据, 返回值:[{}, {}, {}]
  GET						127.0.0.1:8000/books/{id}       # 获取一条数据, 返回值:{}
  POST					    127.0.0.1:8000/books/			# 新增一条数据, 返回值:{}
  PUT						127.0.0.1:8000/books/{id}       # 修改一条数据, 返回值:{}
  DELETE                    127.0.0.1:8000/books/{id}       # 删除一条数据, 返回值: 空对象

  2. 创建model.py

    1. python manage.py makemigrations
    2. python manage.py migrate

  3. urls.py

  4. views.py

    1. 开始使用序列化

      1. 导入模块 from rest_framework import serializers

      2. 建立一个序列化类

        class BookSerializer(serializers.ModelSerializer):
  	字段可以自定义

      3. 获取queryset
        book_obj = BookInfo.objects.get(id=1)
        ​

      4. 开始序列化

        verified_data = BookSerializer(instance=book_obj, data=request.data, many=False)

      5. 验证成功写入数据库, 验证失败范湖错误
        verified_data.save()

      6. 序列化后的数据, 返回给客户端

        return Response(serialized_data.data)

PUT修改单个数据案例

  1. 创建模型类

    from django.db import models

from datetime import datetime
# from django.contrib.auth.models import AbstractUser


class AuthorInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者名称")
    age = models.IntegerField(verbose_name="作者年龄")

    class Meta:
        db_table = "db_author_info"
        verbose_name = "作者信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class PublishInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="出版社名称")
    city = models.CharField(max_length=32, verbose_name="出版社所在城市")
    email = models.EmailField(verbose_name="出版社邮箱")

    class Meta:
        db_table = "db_publish_info"
        verbose_name = "出版社信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class BookInfo(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")
    publishDate = models.DateField(default=datetime.now, verbose_name="出版日期")

    # max_digits小数位加整数位多少长度 decimal_places小数位长度为2
    price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="图书价格")
    
    # on_delete
    # CASCADE:这就是默认的选项，级联删除，你无需显性指定它。
		# PROTECT: 保护模式，如果采用该选项，删除的时候，会抛出ProtectedError错误。
		# SET_NULL: 置空模式，删除的时候，外键字段被设置为空，前提就是blank=True, null=True,定义该字段的时候，允许为空。
		# SET_DEFAULT: 置默认值，删除的时候，外键字段设置为默认值，所以定义外键的时候注意加上一个默认值。
		# SET(): 自定义一个值，该值当然只能是对应的实体了
    publish = models.ForeignKey(PublishInfo, related_name="book", related_query_name="book_query", on_delete=models.CASCADE, verbose_name="出版社")
    # ManyToManyField多对多
    authors = models.ManyToManyField(AuthorInfo, verbose_name="图书作者")

    class Meta:
        db_table = "db_book_info"
        verbose_name = "图书信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.title

  2. 创建urls.py

    from django.urls import re_path
from .views import BookView

urlpatterns = [
  	# restapi风格定制路由
    re_path(r"^books/(\d+)/$", BookFilterView.as_view())
]

  3. 创建views.py

    1. 导入模块

      # 第一步: 导入模块
from rest_framework import serializers

    2. 建立序列化类

      class BookSerializer(serializers.ModelSerializer):
    class Meta:
        # 指定    要操作的模型类
        model = BookInfo

        # 指定序列化的字段
        fields = (
            "title",
            "price",
            "publishDate",
            "publish",
            "authors",
            "author_list",
            "publish_name",
            "publish_city"
        )

        # 指定那些字段是只写的
        # write_only只写的 (只写的 前端发送数据时要写它, 后端返回数据时没有它)
        extra_kwargs = {
            "publish": {"write_only": True},
            "authors": {"write_only": True}
        }

    # 自定义的字段
    # read_only只读的 (只读的 前端发送数据时不用写它, 后端返回数据时有它)
    publish_name = serializers.CharField(max_length=32, read_only=True, source="publish.name")
    publish_city = serializers.CharField(max_length=32, read_only=True, source="publish.city")

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, book_obj):
        # 拿到queryset开始循环 [ {}, {}, {}]
        authors = []
				
        # book_obj.authors.all() 获取所有author对象
        for author in book_obj.authors.all():
            authors.append(author.name)
        return authors

    3. 获取queryset/开始序列化/序列化后的数据, 返回给客户端

      from django.shortcuts import render
from django.http import JsonResponse

from rest_framework.views import APIView

from rest_framework.response import Response

from .models import BookInfo, PublishInfo, AuthorInfo
from .app_serializers import BookSerializer

class BookFilterView(APIView):
    def put(self, request, book_id):
        try:
            book_obj = BookInfo.objects.get(id=book_id)
        except BookInfo.DoesNotExist:
            book_obj = None
        if book_obj is None:
            return JsonResponse({"error": "该书不存在"})

        # instance指定修改的对象  (data把你从前端接收到的数据赋值给这个data, 前端传递的字段名必须跟model里字段名相同)
        # 数据修改成功
        verified_data = BookSerializer(instance=book_obj, data=request.data, many=False)

        if verified_data.is_valid():
            # 保存到数据库
            verified_data.save()
            return Response(verified_data.data)
        else:
            return Response(verified_data.errors)

    4. postman效果图
      在这里插入图片描述

序列化组件的使用及接口设计

  1. 请求接口设计delete删除单个数据(restapi规范)

      GET						127.0.0.1:8000/books/			# 获取所有数据, 返回值:[{}, {}, {}]
  GET						127.0.0.1:8000/books/{id}       # 获取一条数据, 返回值:{}
  POST					    127.0.0.1:8000/books/			# 新增一条数据, 返回值:{}
  PUT						127.0.0.1:8000/books/{id}       # 修改一条数据, 返回值:{}
  DELETE                    127.0.0.1:8000/books/{id}       # 删除一条数据, 返回值: 空对象

  2. 创建model.py

    1. python manage.py makemigrations
    2. python manage.py migrate

  3. urls.py

  4. views.py

    1. 开始使用序列化

      1. 导入模块 from rest_framework import serializers

      2. 建立一个序列化类

        class BookSerializer(serializers.ModelSerializer):
  	字段可以自定义

      3. 获取queryset
        book_obj = BookInfo.objects.get(id=1)

      4. 删除数据
        book_obj.delete()

      5. 序列化后的数据, 返回给客户端

        return Response(“”)

DELETE删除单个数据案例

  1. 创建模型类

    from django.db import models

from datetime import datetime
# from django.contrib.auth.models import AbstractUser


class AuthorInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者名称")
    age = models.IntegerField(verbose_name="作者年龄")

    class Meta:
        db_table = "db_author_info"
        verbose_name = "作者信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class PublishInfo(models.Model):
    name = models.CharField(max_length=32, verbose_name="出版社名称")
    city = models.CharField(max_length=32, verbose_name="出版社所在城市")
    email = models.EmailField(verbose_name="出版社邮箱")

    class Meta:
        db_table = "db_publish_info"
        verbose_name = "出版社信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name


class BookInfo(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")
    publishDate = models.DateField(default=datetime.now, verbose_name="出版日期")

    # max_digits小数位加整数位多少长度 decimal_places小数位长度为2
    price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="图书价格")
    
    # on_delete
    # CASCADE:这就是默认的选项，级联删除，你无需显性指定它。
		# PROTECT: 保护模式，如果采用该选项，删除的时候，会抛出ProtectedError错误。
		# SET_NULL: 置空模式，删除的时候，外键字段被设置为空，前提就是blank=True, null=True,定义该字段的时候，允许为空。
		# SET_DEFAULT: 置默认值，删除的时候，外键字段设置为默认值，所以定义外键的时候注意加上一个默认值。
		# SET(): 自定义一个值，该值当然只能是对应的实体了
    publish = models.ForeignKey(PublishInfo, related_name="book", related_query_name="book_query", on_delete=models.CASCADE, verbose_name="出版社")
    # ManyToManyField多对多
    authors = models.ManyToManyField(AuthorInfo, verbose_name="图书作者")

    class Meta:
        db_table = "db_book_info"
        verbose_name = "图书信息"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.title

  2. 创建urls.py

    from django.urls import re_path
from .views import BookView

urlpatterns = [
  	# restapi风格定制路由
    re_path(r"^books/(\d+)/$", BookFilterView.as_view())
]

  3. 创建views.py

    1. 导入模块

      # 第一步: 导入模块
from rest_framework import serializers

    2. 建立序列化类

      class BookSerializer(serializers.ModelSerializer):
    class Meta:
        # 指定    要操作的模型类
        model = BookInfo

        # 指定序列化的字段
        fields = (
            "title",
            "price",
            "publishDate",
            "publish",
            "authors",
            "author_list",
            "publish_name",
            "publish_city"
        )

        # 指定那些字段是只写的
        # write_only只写的 (只写的 前端发送数据时要写它, 后端返回数据时没有它)
        extra_kwargs = {
            "publish": {"write_only": True},
            "authors": {"write_only": True}
        }

    # 自定义的字段
    # read_only只读的 (只读的 前端发送数据时不用写它, 后端返回数据时有它)
    publish_name = serializers.CharField(max_length=32, read_only=True, source="publish.name")
    publish_city = serializers.CharField(max_length=32, read_only=True, source="publish.city")

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, book_obj):
        # 拿到queryset开始循环 [ {}, {}, {}]
        authors = []
				
        # book_obj.authors.all() 获取所有author对象
        for author in book_obj.authors.all():
            authors.append(author.name)
        return authors

    3. 获取queryset删除数据, 返回给客户端

      from django.shortcuts import render
from django.http import JsonResponse

from rest_framework.views import APIView

from rest_framework.response import Response

from .models import BookInfo, PublishInfo, AuthorInfo
from .app_serializers import BookSerializer

class BookFilterView(APIView):
    ```python
from django.shortcuts import render
from django.http import JsonResponse

from rest_framework.views import APIView

from rest_framework.response import Response

from .models import BookInfo, PublishInfo, AuthorInfo
from .app_serializers import BookSerializer

class BookFilterView(APIView):
    def delete(self, request, book_id):
        try:
            book_id = BookInfo.objects.get(id=book_id)
        except BookInfo.DoesNotExist:
            book_id = None

        if book_id is None:
            return JsonResponse({"error": "该书不存在"})

        # 删除这个对象,  它的删除代表数据库也删除了
        book_id.delete()
        return Response("")

    4. postman效果图

      在这里插入图片描述

只因为你温柔
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Django的rest_framework的序列化组件之serializers.ModelSerializer介绍
weixin_34221773的博客
02-28 1345
这里的介绍的serializers.ModelSerializer就和我们之前学习的modelform一样 serializers.ModelSerializer如下几个功能 1、序列化queryset数据 2、反序列化json数据，将反序列化后的数据转换成model对象 3、反序列化的时候还是可以对数据做校验 4、如果合法，可以调用sava方法进行post或者put请求操作 5、如果...
Django之serializer-ModelSerializer
weixin_47454485的博客
07-15 1755
一. 模型序列化器和普通序列化器对比 没有使用ModelSerializer序列化器时，我们自定义的序列化器类需要添加对应模型类中的很多字段，但是如果添加的字段有成百个，是否也需要一个一个手动添加呢？所以有一种更为简洁的模型序列化器类来帮我们优化框架代码，简化序列化器类中字段的创建 普通序列化器类示例： 在这里插入代码片 ...
Serializers 序列化组件——ModelSerializer详解
hqs2212586的专栏
09-05 4009
　　前面学习Serializers用法时，发现所有的序列化都与我们的模型紧密相关。 　　django_restframework也给我提供了跟模型紧密相关的序列化器——ModelSerializer。 　　它会根据模型自动生成一组字段；它简单的默认实现了.update()以及.create()方法。 一、ModelSerializer序列化 1、定义ModelSerializer...
【Django】REST_Framework框架——序列化器serializers源码解析
python全栈
10-26 2482
1、在客户端请求时，使用序列化器可以完成对数据的反序列化（将字典格式的数据转化为模型对象）。 2、在服务器响应时，使用序列化器可以完成对数据的序列化（将模型对象转化为字典格式的数据）。Serializer的构造方法为：使用序列化器进行反序列化输入时，需要进行验证，通过后，才能获取验证成功后的数据案例1： 案例2 4.3、validate_字段名：对字段进行校验 单个字段进行校验：项目名称不能多于10个字 4.4、validate：多字段校验 5、反序列化-保存数据 前面的验证数据成功后,我们可以使用序列化
Django drf 的 serializers.ModelSerializer 序列化 重写 Model的返回数据和字段 (两种方式)
热门推荐
weixin_62077901的博客
07-15 1万+
instance : 是当前 model 所指定的对象。（当前为 Student）# 改变该字段返回的数据：函数定义为 ： get_ + 字段名（有下划线）# source='sex' 指定model中要修改的字段，# 注意：函数名不能和 字段名重复 否则会覆盖，# 在指定的 model 下定义指定的返回数据。# self 指的是当前 model。
关于django—模型序列化器类详细内容（补充）
python全栈
08-06 1500
一、定义模型序列化器类 1、继承serializers.ModelSerializer类或其子类 2、需要在Meta内部类中指定model、fields类属性参数 3、model指定模型类（需要生成序列化器的模型类） 4、fields指定模型类中哪些字段需要自动生成序列化器字段 1）、如果指定为__all__，那么模型类中所有的字段需要自动转化为序列化器字段 2）、如果将特定的字段转化为序列化器字段,用元组表示 fields=(‘id’,‘name’,‘leader’,‘interfaces_set’,‘
django自带serializers序列化返回指定字段的方法
09-18
以下将详细介绍如何在Django中使用`serializers`序列化返回指定字段： 1. **基本使用**： Django的`serializers.serialize()`函数接受四个参数： - `format`：指定序列化格式，例如'json'、'xml'等。 - `...
django rest framework serializers序列化实例
09-16
在Django REST Framework (DRF)中，`serializers` 是关键组件，它负责数据的序列化和反序列化过程，使得数据可以在Python对象和JSON/XML等格式之间转换。这在构建API接口时尤其重要，因为我们需要将数据库中的模型...
django_rest_framework_-_vue
03-04
【标题】"django_rest_framework_-_vue" 涉及到的是使用 Django REST Framework 和 Vue.js 进行Web开发的知识点。Django REST Framework 是一个强大的、灵活的用于构建 Web API 的 Python 框架，而 Vue.js 是一个轻...
django_rest_framework_CRUD_API
04-17
Django REST framework 提供了专门的视图和序列化器类，使得这些操作更加简便。让我们深入探讨一下这些关键概念： 1. **序列化（Serialization）**：序列化是将 Python 对象转换为 JSON 或其他数据格式的过程，以...
DRF-serializers.ModelSerializer模型类序列化器
张鑫宇
03-12 866
如果想为Django存在的模型类快速创建序列化器,可以使用DRF框架封装好的ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类 基于模型类的字段条件创建约束 自动生成序列化器(serializer) 内部已经封装了create与update方法,序列化器对象在调用save()方法时,会自动对数据库进行操作 1. 基础定义 # 继承自serializer...
Django REST framework(四)-模型类序列化器ModelSerializer的使用
adminwg的博客
08-30 963
Django REST framework(四)-模型类序列化器ModelSerializer的使用
Serializer及ModelSerializer的使用
Kevincy_ximo的博客
10-06 546
1、 使用Serializer类 serializer的基础使用 DRF中的serializer就类似于Djano中的Form，只不过Form是针对模板的，而serializer是针对json,而且非常强大 以以下代码为例 class GoodsSerializer(serializers.ModelSerializer): # name = serializers.CharField(required=True,max_length=100) # click_num = serial
REST framework 序列化组件之ModelSerializer
Waller_的博客
02-16 618
ModelSerializer 如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。 ModelSerializer与常规的Serializer相同，但提供了： 基于模型类自动生成一系列字段 包含默认的create()和update()的实现 定义序列化器 比如我们创建一个Boo...
五、DRF 模型序列化器ModelSerializer
喵酱
05-25 1504
DRF 模型序列化器ModelSerializer
Serializer和ModelSerializer
weixin_45954124的博客
11-01 1195
1.序列化和反序列化 序列化，是指将复杂的QuerySet和Model类型转换成Python基本数据类型，从而将这些基本数据类型以JSON的形式响应给客户端。 反序列化则和序列化相反，是指将Http请求中传入的JSON数据转换成复杂的数据类型，从而保存在数据库中。 在REST Framework中，提供了多个用于序列化操作的类，但常用的也就如下两个： Serializer:进行序列化基本的类； ModelSerializer:继承于Serializer，内部实现了通用的序列化逻辑，其中包含了与Model字
DRF框架serializer之ModelSerializer
graceljh的博客
12-10 392
一、基本语法 在没有使用ModelSerializer序列化器类之前，我们定义的序列化器类都需要添加对应模型类字段的很多字段，如果添加的字段特别多，那么势必会影响开发效率和代码的可读性，因此会选择一种更为简洁的序列化器类来帮我们优化框架代码，简化序列化器类中字段的创建 常规序列化器类示例： 复制代码 from rest_framework import serializers from rest_framework import validators from .models import Projects
python Django Rest_Framework框架 模型类序列化器(ModelSerializer)详解（图文并茂版）
但行好事，莫问前程
04-09 2024
模型类序列化器（ModelSerializer）详解介绍区别与优点定义模型类序列化器查看生成的模型序列化器使用模型类序列化器模型序列化器字段 介绍 上篇文章我们介绍了最基础的序列化器(serializers)，python Django Rest_Framework框架 APIView介绍与序列化器详解（图文并茂版）使用它对数据对象进行序列化、反序列化时操作是比较麻烦的 如果我们需要进行序列化的对象是Django的模型类，DRF也为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一
rest_framework学习之序列化（Serializer）
zhubaoJay的博客
07-01 1315
什么是序列化？ 在我看来，序列化就是将复杂的对象数据转化为简单的通用数据格式（如json），这么一个过程就是序列化。反序列化同理。 我们看下DRF对序列化解释，序列化器允许将复杂数据(如查询集和模型实例)转换为原生Python数据类型，然后可以轻松地将其呈现为JSON、XML或其他内容类型。序列化器还提供反序列化，允许在首先验证传入的数据之后将解析后的数据转换回复杂类型。 PS：还是官方专业...
django遍历rest_framework.serializers.ListSerializer类型的数据
最新发布
06-10
在 Django Rest Framework 中，`ListSerializer` 类型的数据表示一个序列化后的列表对象。如果需要遍历该类型的数据，可以按照以下方式进行： 1. 创建一个 `ListSerializer` 的实例对象 ```python from rest_framework import serializers class MySerializer(serializers.ListSerializer): ... data = [...] serializer = MySerializer(data=data, many=True) ``` 2. 遍历 `ListSerializer` 中的每一个元素 ```python for item in serializer.data: ... ``` 在上述代码中，`MySerializer` 是一个自定义的 `ListSerializer` 类型的序列化器，`data` 是需要序列化的数据列表。在创建 `serializer` 实例对象后，可以通过 `serializer.data` 属性来获取序列化后的数据列表，然后遍历其中的每一个元素进行处理。 需要注意的是，`ListSerializer` 类型的数据不同于 Django 的 QuerySet 类型，因此无法使用 ORM 查询方法进行过滤、排序等操作。如果需要对数据进行处理，可以通过序列化前对数据进行预处理，或者在遍历数据时进行处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

只因为你温柔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值