restfulframework引用多对多外键

记录一下工作中遇到的问题

最近在写restfulframework，感觉还是很便利的

首先贴一下文档地址

https://www.django-rest-framework.org/api-guide/filtering/

https://www.django-rest-framework.org/api-guide/serializers/

https://www.django-rest-framework.org/api-guide/relations/#manytomanyfields-with-a-through-model

使用GernricViewSet可以便捷的新增接口，在类中定义queryset指定模型，用serializer_class指定序列化类，用pagination_class指定分页类，再用filter_backends和filter_class做筛选，可以解决大部分curd问题，如下

class GitLabCommit(mixins.ListModelMixin, mixins.RetrieveModelMixin,viewsets.GenericViewSet):

    #加RetriveModelMixin可以查询特定模型的信息

    queryset = GitCommit.objects.all()

    serializer_class = CommitSerializer

    pagination_class = MyPageNumberPagination

    filter_backends = (DjangoFilterBackend,)

    filter_class = UserCommitFilter

其中模型类无需多言，序列化类形如下

class CommitSerializer(serializers.ModelSerializer):

    author_email = serializers.CharField(source='author.email')

    branch_name = serializers.CharField(source = "branch.branchName")

    branch_project_name = serializers.CharField(source="branch.project.projectName")

    class Meta:

        model = GitCommit

        fields = "__all__"

fields这里也可以写成元组的形式

fields = ("StaffId","name","staff_name")

分页类类似这样

class MyCursorPagination(pagination.CursorPagination):

    """

    Cursor 光标分页 性能高，安全

    """

    page_size = 9

    ordering = '-update_time'

    page_size_query_param = "pages"

    max_page_size = 20

    cursor_query_description = '页面'

    page_size_query_description = '每页条数'

class MyPageNumberPagination(pagination.PageNumberPagination):

    """

    普通分页，数据量越大性能越差

    """

    page_size = 11

    page_size_query_param = 'size'

    page_query_param = 'page'

    max_page_size = 20

这是过滤器类，可以直接定义查找字段或者通过方法进行复杂查找

class UserCommitFilter(filters.FilterSet):

    user_id = filters.NumberFilter(field_name='author__StaffId', lookup_expr='exact')

    start_date = filters.DateFilter(field_name='commitDate', lookup_expr='gte')

    end_date = filters.DateFilter(field_name='commitDate', lookup_expr='lt')

    commit_sum = filters.NumberFilter(method="get_sum")

    def get_sum(self,queryset,name,values):

        if values == 1:

            return queryset.annotate(total_addLines = Sum("addLines"),total_delLins = Sum("delLines"),total_totalLins = Sum("totalLines"))

这里有一个问题：如果序列化所涉及的模型是关联模型怎么办呢？

可以参考这个

https://zhuanlan.zhihu.com/p/27667372

这里特别说一下，对于多对多模型，可以通过嵌套来进行关联，如下

模型定义

class Staff(BaseTable):

    StaffId = models.IntegerField(primary_key=True, help_text="工号")

    email = models.CharField(max_length=50,default="",null=True,help_text="邮箱")

    name = models.CharField(max_length=50,default="",null=True,help_text="姓名")

    department = models.ForeignKey(Department,on_delete=models.CASCADE)

    def __str__(self):

        return "%s:%s"%(self.StaffId,self.name)

    class Meta:

        db_table = "gitlab_measure_staff"

class GitGroup(BaseTable):

    id = models.AutoField(primary_key=True, help_text="ID")

    name = models.CharField(max_length=100,default="",null=True,help_text="组名称")

    members = models.ManyToManyField(Staff)

    class Meta:

        db_table = "gitlab_measure_gitgroup"

序列化

class StaffSerializer(serializers.ModelSerializer):

    staff_name = serializers.CharField(source="name")

    class Meta:

        model = Staff

        fields = ("StaffId","name","staff_name")

class GitGroupSerializer(serializers.ModelSerializer):

    members = StaffSerializer(many=True,read_only=True)

    class Meta:

        model = GitGroup

        fields = ("id","name","members")

如果此时又有一个project类中的group关联到gitgroup，希望在展示的时候展示出组中所有成员该怎么办呢？

这里可以使用depth指定查询的深度

class ProjectSerializer(serializers.ModelSerializer):

    gitGroup_name = serializers.CharField(source='gitGroup.name')

    gitGroup_id = serializers.CharField(source="gitGroup.id")

    department_name = serializers.CharField(source="department.name")

    class Meta:

        model = GitProject

        fields = "__all__"

        depth = 2

这样在结果中就能看到展示的组和成员了，因为在serilizers.ModelSerializer中的get_field()方法中会根据调用self.build_field，将depth传入，build_field方法会调用self.buid_nested_field方法来，再返回一个ModelSerializer类，再在外层函数中循环调用来获取层层对象，最多不超过10层

        for field_name in field_names:

            # If the field is explicitly declared on the class then use that.

            if field_name in declared_fields:

                fields[field_name] = declared_fields[field_name]

                continue

            extra_field_kwargs = extra_kwargs.get(field_name, {})

            source = extra_field_kwargs.get('source', '*')

            if source == '*':

                source = field_name

            # Determine the serializer field class and keyword arguments.

            field_class, field_kwargs = self.build_field(

                source, info, model, depth

            )

            # Include any kwargs defined in `Meta.extra_kwargs`

            field_kwargs = self.include_extra_kwargs(

                field_kwargs, extra_field_kwargs

            )

            # Create the serializer field.

            fields[field_name] = field_class(**field_kwargs)

    def build_field(self, field_name, info, model_class, nested_depth):

        """

        Return a two tuple of (cls, kwargs) to build a serializer field with.

        """

        if field_name in info.fields_and_pk:

            model_field = info.fields_and_pk[field_name]

            return self.build_standard_field(field_name, model_field)

        elif field_name in info.relations:

            relation_info = info.relations[field_name]

            if not nested_depth:

                return self.build_relational_field(field_name, relation_info)

            else:

                return self.build_nested_field(field_name, relation_info, nested_depth)

        elif hasattr(model_class, field_name):

            return self.build_property_field(field_name, model_class)

        elif field_name == self.url_field_name:

            return self.build_url_field(field_name, model_class)

        return self.build_unknown_field(field_name, model_class)

    def build_nested_field(self, field_name, relation_info, nested_depth):

        """

        Create nested fields for forward and reverse relationships.

        """

        class NestedSerializer(ModelSerializer):

            class Meta:

                model = relation_info.related_model

                depth = nested_depth - 1

                fields = '__all__'

        field_class = NestedSerializer

        field_kwargs = get_nested_relation_kwargs(relation_info)

        return field_class, field_kwargs

巴特西

restfulframework引用多对多外键

最新文章

热门文章