序列化器的嵌套使用

原因
一对多的查询使用方法
序列化器中

from rest_framework import serializers
from school.models import teacher, course,student


class CourseModelSerializer(serializers.ModelSerializer):
    """用于查询一对多指定模型"""

    class Meta:
        model = course
        fields = "__all__"


class TeacherModelSerializer(serializers.ModelSerializer):
    # 模型嵌套方案
    # 1.重写模型字段,指定返回的数据是什么
    course = CourseModelSerializer(many=True)  # 指定many:老师为1,课程为n,循环检测

    class Meta:
        model = teacher
        # 写入teacher模型中没有的字段,
        # 但是course只能看见对象不能看见具体值
        fields = ["id", "name", "course"]

view写查询方法

from django.views import View
from django.http.response import JsonResponse
from school.models import teacher, course, student
from school.serializer import TeacherModelSerializer, CourseModelSerializer2, \
    StudentModelSerializer2


# 一对多,展示数据
class TeacherView(View):
    def get2(self, request):
        """获取一个老师信息"""
        teach = teacher.objects.first()
        serializer = TeacherModelSerializer(instance=teach)
        return JsonResponse(serializer.data,
                            # 强制把含有中文的字典转json并返回响应
                            json_dumps_params={"ensure_ascii": False})

    def get(self, request):
        """获取多个老师信息"""
        teach_list = teacher.objects.all()
        serializer = TeacherModelSerializer(instance=teach_list, many=True)
        return JsonResponse(serializer.data,
                            safe=False,  # 允许访问非字典类型数据
                            json_dumps_params={"ensure_ascii": False})

多对一,一对一查询展示
序列化器

class TeacherModelSerializer2(serializers.ModelSerializer):
    """用于查询多对一指定模型"""

    class Meta:
        model = teacher
        fields = ["id", "name"]


class CourseModelSerializer2(serializers.ModelSerializer):
    """课程模型"""

    # teacher = TeacherModelSerializer2()#方式一:在新序列化器中指定模型需要的字段
    # teacher = serializers.CharField(source="teacher.name")  # 方式二 直接重写指定

    class Meta:
        model = course
        fields = ["id", "name", "teacher"]
        # 方式三:指定关联深度,根据外键自动查,但是会获取到该模型所有字段
        # 老师->课程 depth=1
        # 老师->课程->成绩 depth=2
        # 老师->课程->成绩->学生 depth=3
        depth = 1
class StudentModelSerializer2(serializers.ModelSerializer):
    """学生信息序列化器"""
    class Meta:
        model = student
        fields = ["id","name","achievement"]#id,名字,成绩,achievement属于成绩字段名(任意),但是在model.py中方法名与此一致

view视图编写查询逻辑

#多对一数据展示
class CourseView(View):
    def get1(self, request):
        cur = course.objects.first()
        serializer = CourseModelSerializer2(instance=cur)
        return JsonResponse(serializer.data,
                            json_dumps_params={"ensure_ascii": False})

    def get(self, request):
        cur_list = course.objects.all()
        serializer = CourseModelSerializer2(instance=cur_list, many=True)
        return JsonResponse(serializer.data,
                            safe=False,
                            json_dumps_params={"ensure_ascii": False})

嵌套查询的方案4
我们使用的序列化器多对一中的
```
StudentModelSerializer2
```
视图编写

class StudentView(View):
    def get(self, request):
        """获取去一个学生以及相关信息"""
        stu = student.objects.first()
        serializer = StudentModelSerializer2(instance=stu)
        return JsonResponse(serializer.data,
                            safe=False,
                            # 强制把含有中文的字典转json并返回响应
                            json_dumps_params={"ensure_ascii": False})

如何实现从学生到成绩关联,在model中有了改变写法,也就是property封装的函数,返回什么那么学生成绩部分就会展示出什么样的数据

class student(models.Model):
    """学生模型"""
    name = models.CharField(verbose_name="姓名", max_length=50)
    age = models.IntegerField(verbose_name="年龄")
    sex = models.BooleanField(verbose_name="性别")

    class Meta:
        db_table = "sch_school"

    def __str__(self):
        return self.name

    @property  # 表示此函数不加任何参数
    def achievement(self):
        queryset = self.s_achievement.all()
        ret = [{"score":item.score,"course":item.course} for item in queryset]
        return ret