Django rest_framework实现增删改查接口

目录

• Django rest_framework实现增删改查接口
  • 写接口前的知识准备
    • __all__的使用方法
    • 序列化类配置
    • Response二次封装
    • 连表深度查询
  • 单查群查接口
  • 单删群删接口
  • 单增，群增接口
  • 整体单改群改接口
  • 局部修改数据
  • 视图给序列化传参

Django rest_framework实现增删改查接口

本文使用Django的rest_framework框架的ModelSerializer模块和ListSerializer模块实现单查群查、单删群删、单增群增、单改群改接口。

写接口前的知识准备

__all__的使用方法

在默认情况下，如果使用“from 模块名 import *”这样的语句来导入模块，程序会导入该模块中所有不以下画线开头的成员（包括变量、函数和类）。但在一些场景中，我们并不希望每个成员都被暴露出来供外界使用，此时可借助于模块的 __all__ 变量，将变量的值设置成一个列表，只有该列表中的成员才会被暴露出来。

以下划线_开头的变量在导包时用“from 模块名 import *”是无法导入的，可以通过__all__来指定导入的_变量。

例如，下面程序定义了一个包含 __all__ 变量的模块：

'''测试__all__变量的模块'''
def hello(): 
    print("Hello, Python")
def world():
    print("Pyhton World is funny")
def test():    
    print('--test--')
# 定义__all__变量，指定默认只导入hello和world两个成员__all__ = ['hello', 'world']

上面的 __all__ 变量指定该模块默认只被导入 hello 和 world 两个成员。下面程序示范了模块中 __all__ 变量的用处：

# 导入all_module模块内所有成员from all_module import *hello()world()test() # 会提示找不到test()函数

上面第 2 行代码使用“from all_module import *”导入了 all_module 模块下所有的成员。由于该模块包含了 __all__ 变量，因此该语句只导入 __all__ 变量所列出的成员。

序列化类配置

内嵌类Meta的三个属性介绍：

fields = ['name', 'address', 'books']或者" __all__"fields可以指定字段进行序列化、反序列化，以及连表查询时可以查询到的字段。

exclude = ['name']指查询的时候不包括该字段。

depth = 1 值代表深度次数，深度查询指的是当一张表有关联的表时，在查询查自己的表时顺便将关联的表的内容也查出来，如果被深度查询的外键采用__all__，会将所关联表的所有字段都查出来。如果将深度值设置为2则将所关联表的其他关联的表也查出来，就这样一层一层深入，已经查过的表就不查了，所以不会出现死循环。

class BookModelSerializer(serializers.ModelSerializer):
    # 配置depth：自动深度查询的是关联表的所有字段，数据量太多
    class Meta:

        list_serializer_class = BookListSerializer

        model = models.Book
        fields = ['name', 'price', 'publish', 'authors', 'publish_info', 'author_list']
        extra_kwargs = {
            'publish': {
                'write_only': True
            },
            'authors': {
                'write_only': True
            }
        }

class PublishModelSerializer(serializers.ModelSerializer):

    class Meta:
        model = models.Publish
        fields = ['name', 'address', 'books']

        # 了解配置
        # fields = '__all__'
        # exclude = ['name']
        # depth = 2  # 自动深度，值代表深度次数，但是被深度的外键采用__all__，显示所以字段

Response二次封装

对rest_framework的Response类进行二次封装可以按照我们自己的要求去定义response的功能。

from rest_framework.response import Response
class APIResponse(Response):
    def __init__(self, status=0, msg='ok', results=None, http_status=None,
                 headers=None, exception=False, content_type=None, **kwargs):
        # 将status、msg、results、kwargs格式化成data
        data = {
            'status': status,
            'msg': msg,
        }
        # results只要不为空都是数据：False、0、'' 都是数据 => 条件不能写if results
        if results is not None:
            data['results'] = results
        # 将kwargs中额外的k-v数据添加到data中
        data.update(**kwargs)

        super().__init__(data=data, status=http_status, headers=headers, exception=exception, content_type=content_type)

连表深度查询

连表深度查询的方式有三种：

第一种：子序列化：必须有子序列化类配合，不能反向查询

第二种：配置depth：自动深度查询的是关联表的所有字段，数据量太多

第三种：插拔式@property：名字不能与外键名同名（最常用方式）

下面介绍插拔式：

如果书要连表查询出版社，首先在书的模板类中定义@property的方法如下：

    @property
    def publish_info(self):  # 单个数据
        return {
            'name': self.publish.name,
            'address': self.publish.address,
        }#return出我们需要查询出来的第二张表的字段和数据，前提方法名不能和外键字段名重名

然后在序列化类BookModelSerializer中的meta的fields属性中添加上面定义的方法名，这样就可以实现连表查询。

class BookModelSerializer(serializers.ModelSerializer):
    # 外键字段默认显示的是外键值(int类型)，不会自己进行深度查询
    # 深度查询方式：
    # 1）子序列化：必须有子序列化类配合，不能反序列化了
    # 2）配置depth：自动深度查询的是关联表的所有字段，数据量太多
    # 3）插拔式@property：名字不能与外键名同名
    class Meta:
        # ModelSerializer默认配置了ListSerializer辅助类，帮助完成群增群改
        # list_serializer_class = serializers.ListSerializer
        # 如果只有群增，是不需要自定义配置的，但要完成群改，必须自定义配置
        list_serializer_class = BookListSerializer

        model = models.Book
        fields = ['name', 'price', 'publish', 'authors', 'publish_info', 'author_list']

插拔式还可以在模型类中导入所链表的序列化的数据达到连查的目的如：

@property
    def publish_info(self):  # 单个数据
        from .serializers import PublishModelSerializer
        return PublishModelSerializer(self.publish).data

然后在序列化类BookModelSerializer中的meta的fields属性中添加上面定义的方法名。

单查群查接口

class BookAPIView(APIView):
    # 单查群查
    def get(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:
            book_obj = models.Book.objects.filter(is_delete=False, pk=pk).first()
            book_ser = serializers.BookModelSerializer(book_obj)
        else:
            book_query = models.Book.objects.filter(is_delete=False).all()
            book_ser = serializers.BookModelSerializer(book_query, many=True)
        return APIResponse(results=book_ser.data)
        # return Response(data=book_ser.data)

单删群删接口

    def delete(self, request, *args, **kwargs):
        """
        单删：接口：/books/(pk)/   数据：空
        群删：接口：/books/   数据：[pk1, ..., pkn]
        逻辑：修改is_delete字段，修改成功代表删除成功，修改失败代表删除失败
        """
        pk = kwargs.get('pk')
        if pk:
            pks = [pk]  # 将单删格式化成群删一条
        else:
            pks = request.data  # 群删
        try:  # 数据如果有误，数据库执行会出错
            rows = models.Book.objects.filter(is_delete=False, pk__in=pks).update(is_delete=True)
        except:
            return APIResponse(1, '数据有误')

        if rows:
            return APIResponse(0, '删除成功')
        return APIResponse(1, '删除失败')

单增，群增接口

    def post(self, request, *args, **kwargs):
        """
        单增：接口：/books/   数据：{...}
        群增：接口：/books/   数据：[{...}, ..., {...}]
        逻辑：将数据给系列化类处理，数据的类型关系到 many 属性是否为True
        """
        if isinstance(request.data, dict):
            many = False
        elif isinstance(request.data, list):
            many = True
        else:
            return Response(data={'detail': '数据有误'}, status=400)

        book_ser = serializers.BookModelSerializer(data=request.data, many=many)
        book_ser.is_valid(raise_exception=True)
        book_obj_or_list = book_ser.save()
        return APIResponse(results=serializers.BookModelSerializer(book_obj_or_list, many=many).data)

整体单改群改接口

 def put(self, request, *args, **kwargs):
        """
        单改：接口：/books/(pk)/   数据：{...}
        群增：接口：/books/   数据：[{pk, ...}, ..., {pk, ...}]
        逻辑：将数据给系列化类处理，数据的类型关系到 many 属性是否为True
        """
        pk = kwargs.get('pk')
        if pk:  # 单改
            try:
                # 与增的区别在于，需要明确被修改的对象，交给序列化类
                book_instance = models.Book.objects.get(is_delete=False, pk=pk)
            except:
                return Response({'detail': 'pk error'}, status=400)

            book_ser = serializers.BookModelSerializer(instance=book_instance, data=request.data)
            book_ser.is_valid(raise_exception=True)
            book_obj = book_ser.save()
            return APIResponse(results=serializers.BookModelSerializer(book_obj).data)
        else:  # 群改
            # 分析（重点）：
            # 1）数据是列表套字典，每个字典必须带pk，就是指定要修改的对象，如果有一条没带pk，整个数据有误
            # 2）如果pk对应的对象已被删除，或是对应的对象不存在，可以认为整个数据有误(建议)，可以认为将这些错误数据抛出即可
            request_data = request.data
            try:
                pks = []
                for dic in request_data:
                    pk = dic.pop('pk')  # 解决分析1，没有pk pop方法就会抛异常
                    pks.append(pk)

                book_query = models.Book.objects.filter(is_delete=False, pk__in=pks).all()
                if len(pks) != len(book_query):
                    raise Exception('pk对应的数据不存在')
            except Exception as e:
                return Response({'detail': '%s' % e}, status=400)

            book_ser = serializers.BookModelSerializer(instance=book_query, data=request_data, many=True)
            book_ser.is_valid(raise_exception=True)
            book_list = book_ser.save()
            return APIResponse(results=serializers.BookModelSerializer(book_list, many=True).data)

局部修改数据

    # 局部单改群改
    def patch(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:  # 单改
            try:
                book_instance = models.Book.objects.get(is_delete=False, pk=pk)
            except:
                return Response({'detail': 'pk error'}, status=400)
            # 设置partial=True的序列化类，参与反序列化的字段，都会置为选填字段
            # 1）提供了值得字段发生修改。
            # 2）没有提供的字段采用被修改对象原来的值

            # 设置context的值，目的：在序列化完成自定义校验(局部与全局钩子)时，可能需要视图类中的变量，如请求对象request
            # 可以通过context将其传入，在序列化校验方法中，self.context就能拿到传入的视图类中的变量
            book_ser = serializers.BookModelSerializer(instance=book_instance, data=request.data, partial=True, context={'request': request})
            book_ser.is_valid(raise_exception=True)
            book_obj = book_ser.save()
            return APIResponse(results=serializers.BookModelSerializer(book_obj).data)
        else:  # 群改
            request_data = request.data
            try:
                pks = []
                for dic in request_data:
                    pk = dic.pop('pk')
                    pks.append(pk)

                book_query = models.Book.objects.filter(is_delete=False, pk__in=pks).all()
                if len(pks) != len(book_query):
                    raise Exception('pk对应的数据不存在')
            except Exception as e:
                return Response({'detail': '%s' % e}, status=400)

            book_ser = serializers.BookModelSerializer(instance=book_query, data=request_data, many=True, partial=True)
            book_ser.is_valid(raise_exception=True)
            book_list = book_ser.save()
            return APIResponse(results=serializers.BookModelSerializer(book_list, many=True).data)

视图给序列化传参

 def patch(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        if pk:  # 单改
            try:
                book_instance = models.Book.objects.get(is_delete=False, pk=pk)
            except:
                return Response({'detail': 'pk error'}, status=400)
            # 设置partial=True的序列化类，参与反序列化的字段，都会置为选填字段
            # 1）提供了值得字段发生修改。
            # 2）没有提供的字段采用被修改对象原来的值

            # 设置context的值，目的：在序列化完成自定义校验(局部与全局钩子)时，可能需要视图类中的变量，如请求对象request
            # 可以通过context将其传入，在序列化校验方法中，self.context就能拿到传入的视图类中的变量
            book_ser = serializers.BookModelSerializer(instance=book_instance, 
                                                       data=request.data,
                                                       partial=True, 
                                                       context={'request': request})
            book_ser.is_valid(raise_exception=True)
            book_obj = book_ser.save()
            return APIResponse(results=serializers.BookModelSerializer(book_obj).data)